Port envd from e2b with internalized shared packages and Connect RPC
- Copy envd source from e2b-dev/infra, internalize shared dependencies
into envd/internal/shared/ (keys, filesystem, id, smap, utils)
- Switch from gRPC to Connect RPC for all envd services
- Update module paths to git.omukk.dev/wrenn/{sandbox,sandbox/envd}
- Add proto specs (process, filesystem) with buf-based code generation
- Implement full envd: process exec, filesystem ops, port forwarding,
cgroup management, MMDS integration, and HTTP API
- Update main module dependencies (firecracker SDK, pgx, goose, etc.)
- Remove placeholder .gitkeep files replaced by real implementations
This commit is contained in:
405
envd/internal/services/filesystem/dir_test.go
Normal file
405
envd/internal/services/filesystem/dir_test.go
Normal file
@ -0,0 +1,405 @@
|
||||
package filesystem
|
||||
|
||||
import (
|
||||
"context"
|
||||
"errors"
|
||||
"fmt"
|
||||
"os"
|
||||
"os/user"
|
||||
"path/filepath"
|
||||
"testing"
|
||||
|
||||
"connectrpc.com/authn"
|
||||
"connectrpc.com/connect"
|
||||
"github.com/google/uuid"
|
||||
"github.com/stretchr/testify/assert"
|
||||
"github.com/stretchr/testify/require"
|
||||
|
||||
"git.omukk.dev/wrenn/sandbox/envd/internal/services/spec/filesystem"
|
||||
)
|
||||
|
||||
func TestListDir(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
// Setup temp root and user
|
||||
root := t.TempDir()
|
||||
u, err := user.Current()
|
||||
require.NoError(t, err)
|
||||
|
||||
// Setup directory structure
|
||||
testFolder := filepath.Join(root, "test")
|
||||
require.NoError(t, os.MkdirAll(filepath.Join(testFolder, "test-dir", "sub-dir-1"), 0o755))
|
||||
require.NoError(t, os.MkdirAll(filepath.Join(testFolder, "test-dir", "sub-dir-2"), 0o755))
|
||||
filePath := filepath.Join(testFolder, "test-dir", "sub-dir-1", "file.txt")
|
||||
require.NoError(t, os.WriteFile(filePath, []byte("Hello, World!"), 0o644))
|
||||
|
||||
// Service instance
|
||||
svc := mockService()
|
||||
|
||||
// Helper to inject user into context
|
||||
injectUser := func(ctx context.Context, u *user.User) context.Context {
|
||||
return authn.SetInfo(ctx, u)
|
||||
}
|
||||
|
||||
tests := []struct {
|
||||
name string
|
||||
depth uint32
|
||||
expectedPaths []string
|
||||
}{
|
||||
{
|
||||
name: "depth 0 lists only root directory",
|
||||
depth: 0,
|
||||
expectedPaths: []string{
|
||||
filepath.Join(testFolder, "test-dir"),
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "depth 1 lists root directory",
|
||||
depth: 1,
|
||||
expectedPaths: []string{
|
||||
filepath.Join(testFolder, "test-dir"),
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "depth 2 lists first level of subdirectories (in this case the root directory)",
|
||||
depth: 2,
|
||||
expectedPaths: []string{
|
||||
filepath.Join(testFolder, "test-dir"),
|
||||
filepath.Join(testFolder, "test-dir", "sub-dir-1"),
|
||||
filepath.Join(testFolder, "test-dir", "sub-dir-2"),
|
||||
},
|
||||
},
|
||||
{
|
||||
name: "depth 3 lists all directories and files",
|
||||
depth: 3,
|
||||
expectedPaths: []string{
|
||||
filepath.Join(testFolder, "test-dir"),
|
||||
filepath.Join(testFolder, "test-dir", "sub-dir-1"),
|
||||
filepath.Join(testFolder, "test-dir", "sub-dir-2"),
|
||||
filepath.Join(testFolder, "test-dir", "sub-dir-1", "file.txt"),
|
||||
},
|
||||
},
|
||||
}
|
||||
|
||||
for _, tt := range tests {
|
||||
t.Run(tt.name, func(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
ctx := injectUser(t.Context(), u)
|
||||
req := connect.NewRequest(&filesystem.ListDirRequest{
|
||||
Path: testFolder,
|
||||
Depth: tt.depth,
|
||||
})
|
||||
resp, err := svc.ListDir(ctx, req)
|
||||
require.NoError(t, err)
|
||||
assert.NotEmpty(t, resp.Msg)
|
||||
assert.Len(t, resp.Msg.GetEntries(), len(tt.expectedPaths))
|
||||
actualPaths := make([]string, len(resp.Msg.GetEntries()))
|
||||
for i, entry := range resp.Msg.GetEntries() {
|
||||
actualPaths[i] = entry.GetPath()
|
||||
}
|
||||
assert.ElementsMatch(t, tt.expectedPaths, actualPaths)
|
||||
})
|
||||
}
|
||||
}
|
||||
|
||||
func TestListDirNonExistingPath(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
svc := mockService()
|
||||
u, err := user.Current()
|
||||
require.NoError(t, err)
|
||||
ctx := authn.SetInfo(t.Context(), u)
|
||||
|
||||
req := connect.NewRequest(&filesystem.ListDirRequest{
|
||||
Path: "/non-existing-path",
|
||||
Depth: 1,
|
||||
})
|
||||
_, err = svc.ListDir(ctx, req)
|
||||
require.Error(t, err)
|
||||
var connectErr *connect.Error
|
||||
ok := errors.As(err, &connectErr)
|
||||
assert.True(t, ok, "expected error to be of type *connect.Error")
|
||||
assert.Equal(t, connect.CodeNotFound, connectErr.Code())
|
||||
}
|
||||
|
||||
func TestListDirRelativePath(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
// Setup temp root and user
|
||||
u, err := user.Current()
|
||||
require.NoError(t, err)
|
||||
|
||||
// Setup directory structure
|
||||
testRelativePath := fmt.Sprintf("test-%s", uuid.New())
|
||||
testFolderPath := filepath.Join(u.HomeDir, testRelativePath)
|
||||
filePath := filepath.Join(testFolderPath, "file.txt")
|
||||
require.NoError(t, os.MkdirAll(testFolderPath, 0o755))
|
||||
require.NoError(t, os.WriteFile(filePath, []byte("Hello, World!"), 0o644))
|
||||
|
||||
// Service instance
|
||||
svc := mockService()
|
||||
ctx := authn.SetInfo(t.Context(), u)
|
||||
|
||||
req := connect.NewRequest(&filesystem.ListDirRequest{
|
||||
Path: testRelativePath,
|
||||
Depth: 1,
|
||||
})
|
||||
resp, err := svc.ListDir(ctx, req)
|
||||
require.NoError(t, err)
|
||||
assert.NotEmpty(t, resp.Msg)
|
||||
|
||||
expectedPaths := []string{
|
||||
filepath.Join(testFolderPath, "file.txt"),
|
||||
}
|
||||
assert.Len(t, resp.Msg.GetEntries(), len(expectedPaths))
|
||||
|
||||
actualPaths := make([]string, len(resp.Msg.GetEntries()))
|
||||
for i, entry := range resp.Msg.GetEntries() {
|
||||
actualPaths[i] = entry.GetPath()
|
||||
}
|
||||
assert.ElementsMatch(t, expectedPaths, actualPaths)
|
||||
}
|
||||
|
||||
func TestListDir_Symlinks(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
root := t.TempDir()
|
||||
u, err := user.Current()
|
||||
require.NoError(t, err)
|
||||
ctx := authn.SetInfo(t.Context(), u)
|
||||
|
||||
symlinkRoot := filepath.Join(root, "test-symlinks")
|
||||
require.NoError(t, os.MkdirAll(symlinkRoot, 0o755))
|
||||
|
||||
// 1. Prepare a real directory + file that a symlink will point to
|
||||
realDir := filepath.Join(symlinkRoot, "real-dir")
|
||||
require.NoError(t, os.MkdirAll(realDir, 0o755))
|
||||
filePath := filepath.Join(realDir, "file.txt")
|
||||
require.NoError(t, os.WriteFile(filePath, []byte("hello via symlink"), 0o644))
|
||||
|
||||
// 2. Prepare a standalone real file (points-to-file scenario)
|
||||
realFile := filepath.Join(symlinkRoot, "real-file.txt")
|
||||
require.NoError(t, os.WriteFile(realFile, []byte("i am a plain file"), 0o644))
|
||||
|
||||
// 3. Create the three symlinks
|
||||
linkToDir := filepath.Join(symlinkRoot, "link-dir") // → directory
|
||||
linkToFile := filepath.Join(symlinkRoot, "link-file") // → file
|
||||
cyclicLink := filepath.Join(symlinkRoot, "cyclic") // → itself
|
||||
require.NoError(t, os.Symlink(realDir, linkToDir))
|
||||
require.NoError(t, os.Symlink(realFile, linkToFile))
|
||||
require.NoError(t, os.Symlink(cyclicLink, cyclicLink))
|
||||
|
||||
svc := mockService()
|
||||
|
||||
t.Run("symlink to directory behaves like directory and the content looks like inside the directory", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
req := connect.NewRequest(&filesystem.ListDirRequest{
|
||||
Path: linkToDir,
|
||||
Depth: 1,
|
||||
})
|
||||
resp, err := svc.ListDir(ctx, req)
|
||||
require.NoError(t, err)
|
||||
expected := []string{
|
||||
filepath.Join(linkToDir, "file.txt"),
|
||||
}
|
||||
actual := make([]string, len(resp.Msg.GetEntries()))
|
||||
for i, e := range resp.Msg.GetEntries() {
|
||||
actual[i] = e.GetPath()
|
||||
}
|
||||
assert.ElementsMatch(t, expected, actual)
|
||||
})
|
||||
|
||||
t.Run("link to file", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
req := connect.NewRequest(&filesystem.ListDirRequest{
|
||||
Path: linkToFile,
|
||||
Depth: 1,
|
||||
})
|
||||
_, err := svc.ListDir(ctx, req)
|
||||
require.Error(t, err)
|
||||
assert.Contains(t, err.Error(), "not a directory")
|
||||
})
|
||||
|
||||
t.Run("cyclic symlink surfaces 'too many links' → invalid-argument", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
req := connect.NewRequest(&filesystem.ListDirRequest{
|
||||
Path: cyclicLink,
|
||||
})
|
||||
_, err := svc.ListDir(ctx, req)
|
||||
require.Error(t, err)
|
||||
var connectErr *connect.Error
|
||||
ok := errors.As(err, &connectErr)
|
||||
assert.True(t, ok, "expected error to be of type *connect.Error")
|
||||
assert.Equal(t, connect.CodeFailedPrecondition, connectErr.Code())
|
||||
assert.Contains(t, connectErr.Error(), "cyclic symlink")
|
||||
})
|
||||
|
||||
t.Run("symlink not resolved if not root", func(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
req := connect.NewRequest(&filesystem.ListDirRequest{
|
||||
Path: symlinkRoot,
|
||||
Depth: 3,
|
||||
})
|
||||
res, err := svc.ListDir(ctx, req)
|
||||
require.NoError(t, err)
|
||||
expected := []string{
|
||||
filepath.Join(symlinkRoot, "cyclic"),
|
||||
filepath.Join(symlinkRoot, "link-dir"),
|
||||
filepath.Join(symlinkRoot, "link-file"),
|
||||
filepath.Join(symlinkRoot, "real-dir"),
|
||||
filepath.Join(symlinkRoot, "real-dir", "file.txt"),
|
||||
filepath.Join(symlinkRoot, "real-file.txt"),
|
||||
}
|
||||
actual := make([]string, len(res.Msg.GetEntries()))
|
||||
for i, e := range res.Msg.GetEntries() {
|
||||
actual[i] = e.GetPath()
|
||||
}
|
||||
assert.ElementsMatch(t, expected, actual, "symlinks should not be resolved when listing the symlink root directory")
|
||||
})
|
||||
}
|
||||
|
||||
// TestFollowSymlink_Success makes sure that followSymlink resolves symlinks,
|
||||
// while also being robust to the /var → /private/var indirection that exists on macOS.
|
||||
func TestFollowSymlink_Success(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
// Base temporary directory. On macOS this lives under /var/folders/…
|
||||
// which itself is a symlink to /private/var/folders/….
|
||||
base := t.TempDir()
|
||||
|
||||
// Create a real directory that we ultimately want to resolve to.
|
||||
target := filepath.Join(base, "target")
|
||||
require.NoError(t, os.MkdirAll(target, 0o755))
|
||||
|
||||
// Create a symlink pointing at the real directory so we can verify that
|
||||
// followSymlink follows it.
|
||||
link := filepath.Join(base, "link")
|
||||
require.NoError(t, os.Symlink(target, link))
|
||||
|
||||
got, err := followSymlink(link)
|
||||
require.NoError(t, err)
|
||||
|
||||
// Canonicalise the expected path too, so that /var → /private/var (macOS)
|
||||
// or any other benign symlink indirections don’t cause flaky tests.
|
||||
want, err := filepath.EvalSymlinks(link)
|
||||
require.NoError(t, err)
|
||||
|
||||
require.Equal(t, want, got, "followSymlink should resolve and canonicalise symlinks")
|
||||
}
|
||||
|
||||
// TestFollowSymlink_MultiSymlinkChain verifies that followSymlink follows a chain
|
||||
// of several symlinks (non‑cyclic) correctly.
|
||||
func TestFollowSymlink_MultiSymlinkChain(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
base := t.TempDir()
|
||||
|
||||
// Final destination directory.
|
||||
target := filepath.Join(base, "target")
|
||||
require.NoError(t, os.MkdirAll(target, 0o755))
|
||||
|
||||
// Build a 3‑link chain: link1 → link2 → link3 → target.
|
||||
link3 := filepath.Join(base, "link3")
|
||||
require.NoError(t, os.Symlink(target, link3))
|
||||
|
||||
link2 := filepath.Join(base, "link2")
|
||||
require.NoError(t, os.Symlink(link3, link2))
|
||||
|
||||
link1 := filepath.Join(base, "link1")
|
||||
require.NoError(t, os.Symlink(link2, link1))
|
||||
|
||||
got, err := followSymlink(link1)
|
||||
require.NoError(t, err)
|
||||
|
||||
want, err := filepath.EvalSymlinks(link1)
|
||||
require.NoError(t, err)
|
||||
|
||||
require.Equal(t, want, got, "followSymlink should resolve an arbitrary symlink chain")
|
||||
}
|
||||
|
||||
func TestFollowSymlink_NotFound(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
_, err := followSymlink("/definitely/does/not/exist")
|
||||
require.Error(t, err)
|
||||
|
||||
var cerr *connect.Error
|
||||
require.ErrorAs(t, err, &cerr)
|
||||
require.Equal(t, connect.CodeNotFound, cerr.Code())
|
||||
}
|
||||
|
||||
func TestFollowSymlink_CyclicSymlink(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
dir := t.TempDir()
|
||||
a := filepath.Join(dir, "a")
|
||||
b := filepath.Join(dir, "b")
|
||||
require.NoError(t, os.MkdirAll(a, 0o755))
|
||||
require.NoError(t, os.MkdirAll(b, 0o755))
|
||||
|
||||
// Create a two‑node loop: a/loop → b/loop, b/loop → a/loop.
|
||||
require.NoError(t, os.Symlink(filepath.Join(b, "loop"), filepath.Join(a, "loop")))
|
||||
require.NoError(t, os.Symlink(filepath.Join(a, "loop"), filepath.Join(b, "loop")))
|
||||
|
||||
_, err := followSymlink(filepath.Join(a, "loop"))
|
||||
require.Error(t, err)
|
||||
|
||||
var cerr *connect.Error
|
||||
require.ErrorAs(t, err, &cerr)
|
||||
require.Equal(t, connect.CodeFailedPrecondition, cerr.Code())
|
||||
require.Contains(t, cerr.Message(), "cyclic")
|
||||
}
|
||||
|
||||
func TestCheckIfDirectory(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
dir := t.TempDir()
|
||||
require.NoError(t, checkIfDirectory(dir))
|
||||
|
||||
file := filepath.Join(dir, "file.txt")
|
||||
require.NoError(t, os.WriteFile(file, []byte("hello"), 0o644))
|
||||
|
||||
err := checkIfDirectory(file)
|
||||
require.Error(t, err)
|
||||
|
||||
var cerr *connect.Error
|
||||
require.ErrorAs(t, err, &cerr)
|
||||
require.Equal(t, connect.CodeInvalidArgument, cerr.Code())
|
||||
}
|
||||
|
||||
func TestWalkDir_Depth(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
root := t.TempDir()
|
||||
sub := filepath.Join(root, "sub")
|
||||
subsub := filepath.Join(sub, "subsub")
|
||||
require.NoError(t, os.MkdirAll(subsub, 0o755))
|
||||
|
||||
entries, err := walkDir(root, root, 1)
|
||||
require.NoError(t, err)
|
||||
|
||||
// Collect the names for easier assertions.
|
||||
names := make([]string, 0, len(entries))
|
||||
for _, e := range entries {
|
||||
names = append(names, e.GetName())
|
||||
}
|
||||
|
||||
require.Contains(t, names, "sub")
|
||||
require.NotContains(t, names, "subsub", "entries beyond depth should be excluded")
|
||||
}
|
||||
|
||||
func TestWalkDir_Error(t *testing.T) {
|
||||
t.Parallel()
|
||||
|
||||
_, err := walkDir("/does/not/exist", "/does/not/exist", 1)
|
||||
require.Error(t, err)
|
||||
|
||||
var cerr *connect.Error
|
||||
require.ErrorAs(t, err, &cerr)
|
||||
require.Equal(t, connect.CodeInternal, cerr.Code())
|
||||
}
|
||||
Reference in New Issue
Block a user