Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
package startup
import (
"math"
"os"
"path/filepath"
"strconv"
"testing"
"github.com/samber/mo"
"github.com/stretchr/testify/require"
kit "go.getarcane.app/kit/pkg"
)
func TestLoadRuntimeIdentityRequest(t *testing.T) {
t.Run("disabled when unset outside a container", func(t *testing.T) {
req, warning, err := loadRuntimeIdentityRequest(&RuntimeIdentityConfig{
DockerHost: "unix:///tmp/docker.sock",
}, false)
require.NoError(t, err)
require.Empty(t, warning)
require.False(t, req.Enabled)
require.Equal(t, "unix:///tmp/docker.sock", req.DockerHost)
})
t.Run("enabled with default non-root runtime when unset in container", func(t *testing.T) {
req, warning, err := loadRuntimeIdentityRequest(&RuntimeIdentityConfig{
DockerHost: "unix:///tmp/docker.sock",
}, true)
require.NoError(t, err)
require.Empty(t, warning)
require.True(t, req.Enabled)
require.Equal(t, defaultRuntimeUID, req.UID)
require.Equal(t, defaultRuntimeGID, req.GID)
require.Equal(t, uint32(defaultRuntimeUID), req.CredentialUID)
require.Equal(t, uint32(defaultRuntimeGID), req.CredentialGID)
require.Equal(t, "unix:///tmp/docker.sock", req.DockerHost)
})
t.Run("warning when partial config", func(t *testing.T) {
req, warning, err := loadRuntimeIdentityRequest(&RuntimeIdentityConfig{PUID: "1001"}, true)
require.NoError(t, err)
require.Contains(t, warning, "PUID and PGID must both be set")
require.True(t, req.Enabled)
require.Equal(t, defaultRuntimeUID, req.UID)
require.Equal(t, defaultRuntimeGID, req.GID)
require.Equal(t, uint32(defaultRuntimeUID), req.CredentialUID)
require.Equal(t, uint32(defaultRuntimeGID), req.CredentialGID)
})
t.Run("warning when partial config outside container", func(t *testing.T) {
req, warning, err := loadRuntimeIdentityRequest(&RuntimeIdentityConfig{PUID: "1001"}, false)
require.NoError(t, err)
require.Contains(t, warning, "PUID and PGID must both be set to enable runtime identity outside containers")
require.False(t, req.Enabled)
require.Zero(t, req.UID)
require.Zero(t, req.GID)
require.Equal(t, uint32(0), req.CredentialUID)
require.Equal(t, uint32(0), req.CredentialGID)
})
t.Run("error when invalid numeric value", func(t *testing.T) {
_, _, err := loadRuntimeIdentityRequest(&RuntimeIdentityConfig{PUID: "abc", PGID: "1001"}, false)
require.Error(t, err)
require.Contains(t, err.Error(), "invalid PUID")
})
t.Run("error when value exceeds uint32", func(t *testing.T) {
tooLarge := strconv.FormatUint(uint64(math.MaxUint32)+1, 10)
_, _, err := loadRuntimeIdentityRequest(&RuntimeIdentityConfig{PUID: tooLarge, PGID: "1001"}, false)
require.Error(t, err)
require.Contains(t, err.Error(), "invalid PUID")
})
t.Run("enabled when both set", func(t *testing.T) {
req, warning, err := loadRuntimeIdentityRequest(&RuntimeIdentityConfig{
PUID: "1001",
PGID: "2001",
DockerHost: "unix:///tmp/docker.sock",
}, false)
require.NoError(t, err)
require.Empty(t, warning)
require.True(t, req.Enabled)
require.Equal(t, 1001, req.UID)
require.Equal(t, 2001, req.GID)
require.Equal(t, uint32(1001), req.CredentialUID)
require.Equal(t, uint32(2001), req.CredentialGID)
require.Equal(t, "unix:///tmp/docker.sock", req.DockerHost)
})
t.Run("error when value is negative", func(t *testing.T) {
_, _, err := loadRuntimeIdentityRequest(&RuntimeIdentityConfig{PUID: "-1", PGID: "1001"}, false)
require.Error(t, err)
require.Contains(t, err.Error(), "invalid PUID")
})
}
func TestRunningInContainer(t *testing.T) {
t.Run("explicit arcane env enables container mode", func(t *testing.T) {
inContainer := runningInContainer(
func(key string) string {
return kit.Ternary(key == "ARCANE_IN_CONTAINER", "true", "")
},
func(string) (os.FileInfo, error) {
return nil, os.ErrNotExist
},
)
require.True(t, inContainer)
})
t.Run("container env enables container mode", func(t *testing.T) {
inContainer := runningInContainer(
func(key string) string {
return kit.Ternary(key == "container", "podman", "")
},
func(string) (os.FileInfo, error) {
return nil, os.ErrNotExist
},
)
require.True(t, inContainer)
})
t.Run("container marker file enables container mode", func(t *testing.T) {
inContainer := runningInContainer(
func(string) string { return "" },
func(path string) (os.FileInfo, error) {
return nil, kit.Ternary(path == "/run/.containerenv", nil, os.ErrNotExist)
},
)
require.True(t, inContainer)
})
t.Run("no signal disables container mode", func(t *testing.T) {
inContainer := runningInContainer(
func(string) string { return "" },
func(string) (os.FileInfo, error) {
return nil, os.ErrNotExist
},
)
require.False(t, inContainer)
})
}
func TestConfigureRuntimeDockerConfigEnv(t *testing.T) {
t.Run("sets default for non root runtime when unset in container", func(t *testing.T) {
cfg := &RuntimeIdentityConfig{}
env := map[string]string{}
configDir, err := configureRuntimeDockerConfigEnv(
cfg,
func(key, value string) error {
env[key] = value
return nil
},
1001,
1001,
true,
)
require.NoError(t, err)
require.Equal(t, defaultDockerConfigDir, configDir)
require.Equal(t, defaultDockerConfigDir, env["DOCKER_CONFIG"])
require.Equal(t, defaultDockerConfigDir, cfg.DockerConfig)
})
t.Run("skips default for non root runtime when unset outside container", func(t *testing.T) {
cfg := &RuntimeIdentityConfig{}
env := map[string]string{}
setCalled := false
configDir, err := configureRuntimeDockerConfigEnv(
cfg,
func(key, value string) error {
setCalled = true
env[key] = value
return nil
},
1001,
1001,
false,
)
require.NoError(t, err)
require.Empty(t, configDir)
require.Empty(t, env["DOCKER_CONFIG"])
require.Empty(t, cfg.DockerConfig)
require.False(t, setCalled)
})
t.Run("preserves explicit docker config for non root runtime", func(t *testing.T) {
cfg := &RuntimeIdentityConfig{DockerConfig: "/custom/docker-config"}
env := map[string]string{}
setCalled := false
configDir, err := configureRuntimeDockerConfigEnv(
cfg,
func(key, value string) error {
setCalled = true
env[key] = value
return nil
},
1001,
1001,
false,
)
require.NoError(t, err)
require.Equal(t, "/custom/docker-config", configDir)
require.Empty(t, env["DOCKER_CONFIG"])
require.Equal(t, "/custom/docker-config", cfg.DockerConfig)
require.False(t, setCalled)
})
t.Run("skips explicit root runtime", func(t *testing.T) {
cfg := &RuntimeIdentityConfig{}
env := map[string]string{}
setCalled := false
configDir, err := configureRuntimeDockerConfigEnv(
cfg,
func(key, value string) error {
setCalled = true
env[key] = value
return nil
},
0,
0,
true,
)
require.NoError(t, err)
require.Empty(t, configDir)
require.Empty(t, env["DOCKER_CONFIG"])
require.Empty(t, cfg.DockerConfig)
require.False(t, setCalled)
})
t.Run("sets default for mixed root uid non root gid runtime", func(t *testing.T) {
cfg := &RuntimeIdentityConfig{}
env := map[string]string{}
configDir, err := configureRuntimeDockerConfigEnv(
cfg,
func(key, value string) error {
env[key] = value
return nil
},
0,
1001,
true,
)
require.NoError(t, err)
require.Equal(t, defaultDockerConfigDir, configDir)
require.Equal(t, defaultDockerConfigDir, env["DOCKER_CONFIG"])
require.Equal(t, defaultDockerConfigDir, cfg.DockerConfig)
})
}
func TestEnsureRuntimeDockerConfigCreatesCustomDirectory(t *testing.T) {
customDir := filepath.Join(t.TempDir(), "custom-docker-config")
cfg := &RuntimeIdentityConfig{DockerConfig: customDir}
require.NoError(t, ensureRuntimeDockerConfig(
cfg,
func(string, string) error {
require.FailNow(t, "setenv should not be called for explicit DOCKER_CONFIG")
return nil
},
1001,
1001,
false,
))
info, err := os.Stat(customDir)
require.NoError(t, err)
require.True(t, info.IsDir())
require.Equal(t, customDir, cfg.DockerConfig)
}
func TestRuntimeIdentitySupplementaryGroups(t *testing.T) {
t.Run("maps default docker socket group when docker host unset", func(t *testing.T) {
groups := runtimeIdentitySupplementaryGroups(
"",
func(socketPath string) mo.Option[uint32] {
require.Equal(t, defaultDockerSocketPath, socketPath)
return mo.Some(uint32(997))
},
)
require.Equal(t, []uint32{997}, groups)
})
t.Run("maps custom unix docker host socket group", func(t *testing.T) {
groups := runtimeIdentitySupplementaryGroups(
"unix:///tmp/docker.sock",
func(socketPath string) mo.Option[uint32] {
require.Equal(t, "/tmp/docker.sock", socketPath)
return mo.Some(uint32(998))
},
)
require.Equal(t, []uint32{998}, groups)
})
t.Run("skips non unix docker host", func(t *testing.T) {
called := false
groups := runtimeIdentitySupplementaryGroups(
"tcp://docker:2375",
func(string) mo.Option[uint32] {
called = true
return mo.None[uint32]()
},
)
require.Nil(t, groups)
require.False(t, called)
})
t.Run("skips socket group when socket lookup fails", func(t *testing.T) {
groups := runtimeIdentitySupplementaryGroups(
"unix:///tmp/missing.sock",
func(string) mo.Option[uint32] { return mo.None[uint32]() },
)
require.Nil(t, groups)
})
}
func TestParseMountpoints(t *testing.T) {
data := `36 25 0:32 / /proc rw,nosuid,nodev,noexec,relatime - proc proc rw
97 92 0:44 / /app/data rw,relatime - ext4 /dev/sda1 rw
98 92 0:45 / /app/data/projects rw,relatime - ext4 /dev/sdb1 rw
99 92 0:46 / /builds rw,relatime - ext4 /dev/sdc1 rw
`
parsed := parseMountpoints(data)
require.Contains(t, parsed, "/app/data")
require.Contains(t, parsed, "/app/data/projects")
require.Contains(t, parsed, "/builds")
}
func TestSQLiteDatabasePath(t *testing.T) {
t.Run("uses default sqlite path when unset", func(t *testing.T) {
path, ok, err := sqliteDatabasePath("")
require.NoError(t, err)
require.True(t, ok)
require.Equal(t, "data/arcane.db", path)
})
t.Run("preserves absolute sqlite path", func(t *testing.T) {
path, ok, err := sqliteDatabasePath("file:/app/custom/arcane.db?_pragma=journal_mode(WAL)")
require.NoError(t, err)
require.True(t, ok)
require.Equal(t, "/app/custom/arcane.db", path)
})
t.Run("returns relative sqlite path", func(t *testing.T) {
path, ok, err := sqliteDatabasePath("file:data/arcane.db?_pragma=journal_mode(WAL)")
require.NoError(t, err)
require.True(t, ok)
require.Equal(t, "data/arcane.db", path)
})
t.Run("skips non sqlite database urls", func(t *testing.T) {
path, ok, err := sqliteDatabasePath("postgres://arcane:secret@db/arcane")
require.NoError(t, err)
require.False(t, ok)
require.Empty(t, path)
})
}
func TestEnsureSQLiteFilesExist(t *testing.T) {
tempDir := t.TempDir()
dbPath := filepath.Join(tempDir, "arcane.db")
require.NoError(t, ensureSQLiteFilesExist("file:"+dbPath))
require.FileExists(t, dbPath)
require.NoFileExists(t, dbPath+"-wal")
require.NoFileExists(t, dbPath+"-shm")
}
func TestEnsureSQLiteFilesExistInternalCreatesParentDir(t *testing.T) {
tempDir := t.TempDir()
dbPath := filepath.Join(tempDir, "subdir", "arcane.db")
require.NoError(t, ensureSQLiteFilesExist("file:"+dbPath))
require.FileExists(t, dbPath)
}
func TestUnescapeMountInfoPath(t *testing.T) {
tests := []struct {
name string
input string
expect string
}{
{"space", `/mnt/my\040dir`, "/mnt/my dir"},
{"tab", `/mnt/my\011dir`, "/mnt/my\tdir"},
{"newline", `/mnt/my\012dir`, "/mnt/my\ndir"},
{"backslash", `/mnt/my\134dir`, `/mnt/my\dir`},
{"no escapes", `/mnt/simple`, "/mnt/simple"},
}
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
require.Equal(t, tt.expect, unescapeMountInfoPath(tt.input))
})
}
}
func TestChownRecursiveInternalSkipsProjects(t *testing.T) {
tempDir := t.TempDir()
// Setup directory structure:
// tempDir/
// database/
// projects/ (this is the protected projects directory)
// demo/
// keep.txt (should not be touched)
projectsDir := filepath.Join(tempDir, "projects")
demoDir := filepath.Join(projectsDir, "demo")
keepFile := filepath.Join(demoDir, "keep.txt")
databaseDir := filepath.Join(tempDir, "database")
require.NoError(t, os.MkdirAll(demoDir, 0o755))
require.NoError(t, os.WriteFile(keepFile, []byte("keep"), 0o644))
require.NoError(t, os.MkdirAll(databaseDir, 0o755))
// Track visited paths using mocked lchownFn
visited := make(map[string]bool)
oldLchownFn := lchownFn
lchownFn = func(path string, uid, gid int) error {
visited[filepath.Clean(path)] = true
return nil
}
t.Cleanup(func() {
lchownFn = oldLchownFn
})
mountpoints := make(map[string]struct{})
err := chownRecursive(tempDir, 1000, 1000, mountpoints, filepath.Clean(projectsDir))
require.NoError(t, err)
cleanedTempDir := filepath.Clean(tempDir)
cleanedDatabaseDir := filepath.Clean(databaseDir)
cleanedProjectsDir := filepath.Clean(projectsDir)
cleanedDemoDir := filepath.Clean(demoDir)
cleanedKeepFile := filepath.Clean(keepFile)
// Assert base directories / other directories under the path were visited
require.True(t, visited[cleanedTempDir], "temp root dir must be visited")
require.True(t, visited[cleanedDatabaseDir], "non-protected database dir must be visited")
// Assert projects directory itself was visited (top level chown)
require.True(t, visited[cleanedProjectsDir], "protected projects dir must be visited at top-level")
// Assert contents inside elements of projects directory were NOT visited
require.False(t, visited[cleanedDemoDir], "subdir inside projects dir must NOT be visited")
require.False(t, visited[cleanedKeepFile], "file inside projects dir must NOT be visited")
}
func TestPrepareWritablePathsInternalChownsTopLevelProjectsShallowly(t *testing.T) {
tempDir := t.TempDir()
dataDir := filepath.Join(tempDir, "data")
buildsDir := filepath.Join(tempDir, "builds")
projectsDir := filepath.Join(dataDir, "projects")
demoDir := filepath.Join(projectsDir, "demo")
keepFile := filepath.Join(demoDir, "keep.txt")
databaseDir := filepath.Join(dataDir, "database")
require.NoError(t, os.MkdirAll(demoDir, 0o755))
require.NoError(t, os.WriteFile(keepFile, []byte("keep"), 0o644))
require.NoError(t, os.MkdirAll(databaseDir, 0o755))
visited := make(map[string]bool)
oldLchownFn := lchownFn
lchownFn = func(path string, uid, gid int) error {
visited[filepath.Clean(path)] = true
return nil
}
t.Cleanup(func() {
lchownFn = oldLchownFn
})
err := prepareWritablePathsWithRoots(os.Getuid(), os.Getgid(), map[string]struct{}{}, filepath.Clean(projectsDir), dataDir, buildsDir)
require.NoError(t, err)
require.True(t, visited[filepath.Clean(projectsDir)], "top-level projects dir must be chowned")
require.True(t, visited[filepath.Clean(databaseDir)], "non-protected data child must be chowned")
require.False(t, visited[filepath.Clean(demoDir)], "subdir inside projects dir must NOT be chowned")
require.False(t, visited[filepath.Clean(keepFile)], "file inside projects dir must NOT be chowned")
}