Skip to content

Modern Docker Management, Designed for Everyone

17.6 KB
Raw Blame
package projects

import (
	"errors"
	"os"
	"path/filepath"
	"runtime"
	"testing"
	"time"

	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"go.getarcane.app/acfs"
	kit "go.getarcane.app/kit/pkg"

	"github.com/getarcaneapp/arcane/backend/v2/pkg/utils"
)

func TestWriteFilesPermissions(t *testing.T) {
	// Save original perms
	origFilePerm := utils.FilePerm
	origDirPerm := utils.DirPerm
	defer func() {
		utils.FilePerm = origFilePerm
		utils.DirPerm = origDirPerm
	}()

	tmpDir := t.TempDir()
	projectsRoot := tmpDir
	projectDir := filepath.Join(tmpDir, "test-project")

	t.Run("WriteComposeFile uses custom permissions", func(t *testing.T) {
		utils.FilePerm = 0o600
		utils.DirPerm = 0o700

		err := WriteComposeFile(t.Context(), projectsRoot, projectDir, "services: {}")
		require.NoError(t, err)

		composePath := filepath.Join(projectDir, "compose.yaml")
		info, err := os.Stat(composePath)
		require.NoError(t, err)

		if runtime.GOOS != "windows" {
			assert.Equal(t, os.FileMode(0o600), info.Mode().Perm())

			dirInfo, statErr := os.Stat(projectDir)
			require.NoError(t, statErr)
			assert.Equal(t, os.FileMode(0o700), dirInfo.Mode().Perm())
		}
	})

	t.Run("WriteEnvFile uses custom permissions", func(t *testing.T) {
		utils.FilePerm = 0o600
		utils.DirPerm = 0o700

		err := WriteProjectFile(t.Context(), projectsRoot, projectDir, ".env", "VAR=VAL")
		require.NoError(t, err)

		envPath := filepath.Join(projectDir, ".env")
		info, err := os.Stat(envPath)
		require.NoError(t, err)

		if runtime.GOOS != "windows" {
			assert.Equal(t, os.FileMode(0o600), info.Mode().Perm())
		}
	})
}

func TestWriteProjectFile_DoesNotReplaceIdenticalContent(t *testing.T) {
	projectsRoot := t.TempDir()
	projectDir := filepath.Join(projectsRoot, "test-project")
	require.NoError(t, os.MkdirAll(projectDir, 0o755))

	filePath := filepath.Join(projectDir, EffectiveEnvFileName)
	content := "VALUE=unchanged\n"
	require.NoError(t, os.WriteFile(filePath, []byte(content), 0o600))

	fixedTime := time.Unix(1_700_000_000, 0)
	require.NoError(t, os.Chtimes(filePath, fixedTime, fixedTime))
	original, err := os.Stat(filePath)
	require.NoError(t, err)

	require.NoError(t, WriteProjectFile(t.Context(), projectsRoot, projectDir, EffectiveEnvFileName, content))

	info, err := os.Stat(filePath)
	require.NoError(t, err)
	assert.True(t, info.ModTime().Equal(fixedTime), "identical content should not replace the file")
	assert.True(t, os.SameFile(original, info))
	assert.Equal(t, original.Mode().Perm(), info.Mode().Perm())

	require.NoError(t, WriteProjectFile(t.Context(), projectsRoot, projectDir, EffectiveEnvFileName, "VALUE=new\n"))
	updated, err := os.Stat(filePath)
	require.NoError(t, err)
	assert.True(t, os.SameFile(original, updated), "changed content should preserve the inode")
	if runtime.GOOS != "windows" {
		assert.Equal(t, os.FileMode(0o600), updated.Mode().Perm(), "changed content should preserve the file mode")
	}
	actual, err := os.ReadFile(filePath)
	require.NoError(t, err)
	assert.Equal(t, "VALUE=new\n", string(actual))
}

func TestWriteEnvFile_WritesThroughExternalSymlink(t *testing.T) {
	projectsRoot := t.TempDir()
	projectDir := filepath.Join(projectsRoot, "test-project")
	require.NoError(t, os.MkdirAll(projectDir, 0o755))

	externalDir := t.TempDir()
	targetPath := filepath.Join(externalDir, "project.env")
	targetPerm := os.FileMode(0o640)
	require.NoError(t, os.WriteFile(targetPath, []byte("VALUE=old\n"), targetPerm))
	require.NoError(t, os.Chmod(targetPath, targetPerm))

	envPath := filepath.Join(projectDir, EffectiveEnvFileName)
	if err := os.Symlink(targetPath, envPath); err != nil {
		t.Skipf("symlink creation is unavailable: %v", err)
	}
	originalLinkTarget, err := os.Readlink(envPath)
	require.NoError(t, err)

	require.NoError(t, WriteProjectFile(t.Context(), projectsRoot, projectDir, ".env", "VALUE=new\n"))

	linkInfo, err := os.Lstat(envPath)
	require.NoError(t, err)
	require.NotZero(t, linkInfo.Mode()&os.ModeSymlink)
	currentLinkTarget, err := os.Readlink(envPath)
	require.NoError(t, err)
	assert.Equal(t, originalLinkTarget, currentLinkTarget)

	targetContent, err := os.ReadFile(targetPath)
	require.NoError(t, err)
	assert.Equal(t, "VALUE=new\n", string(targetContent))
	if runtime.GOOS != "windows" {
		targetInfo, statErr := os.Stat(targetPath)
		require.NoError(t, statErr)
		assert.Equal(t, targetPerm, targetInfo.Mode().Perm())
	}
}

func TestWriteEnvFile_DanglingSymlinkRemainsUntouched(t *testing.T) {
	projectsRoot := t.TempDir()
	projectDir := filepath.Join(projectsRoot, "test-project")
	require.NoError(t, os.MkdirAll(projectDir, 0o755))

	missingTarget := filepath.Join(t.TempDir(), "missing.env")
	envPath := filepath.Join(projectDir, EffectiveEnvFileName)
	if err := os.Symlink(missingTarget, envPath); err != nil {
		t.Skipf("symlink creation is unavailable: %v", err)
	}

	for range 2 {
		err := WriteProjectFile(t.Context(), projectsRoot, projectDir, ".env", "VALUE=new\n")
		require.Error(t, err)
		assert.Contains(t, err.Error(), "resolve env file symlink")

		linkInfo, statErr := os.Lstat(envPath)
		require.NoError(t, statErr)
		require.NotZero(t, linkInfo.Mode()&os.ModeSymlink)
		linkTarget, readlinkErr := os.Readlink(envPath)
		require.NoError(t, readlinkErr)
		assert.Equal(t, missingTarget, linkTarget)
		require.NoFileExists(t, missingTarget)
	}
}

func TestWriteEnvFile_RejectsNonRegularSymlinkTarget(t *testing.T) {
	projectsRoot := t.TempDir()
	projectDir := filepath.Join(projectsRoot, "test-project")
	require.NoError(t, os.MkdirAll(projectDir, 0o755))

	targetDir := t.TempDir()
	envPath := filepath.Join(projectDir, EffectiveEnvFileName)
	if err := os.Symlink(targetDir, envPath); err != nil {
		t.Skipf("symlink creation is unavailable: %v", err)
	}

	err := WriteProjectFile(t.Context(), projectsRoot, projectDir, ".env", "VALUE=new\n")
	require.Error(t, err)
	assert.Contains(t, err.Error(), "not a regular file")
	linkInfo, statErr := os.Lstat(envPath)
	require.NoError(t, statErr)
	require.NotZero(t, linkInfo.Mode()&os.ModeSymlink)
}

func TestWriteProjectFile_StillRejectsNonEnvSymlink(t *testing.T) {
	for _, writer := range []string{"project", "compose", "sync"} {
		t.Run(writer, func(t *testing.T) {
			projectsRoot := t.TempDir()
			projectDir := filepath.Join(projectsRoot, "test-project")
			require.NoError(t, os.MkdirAll(projectDir, 0o755))

			targetPath := filepath.Join(t.TempDir(), "compose.yaml")
			require.NoError(t, os.WriteFile(targetPath, []byte("services: {}\n"), 0o600))
			fileName := kit.Ternary(writer == "project", OverrideEnvFileName, DefaultComposeFileName)
			linkPath := filepath.Join(projectDir, fileName)
			if err := os.Symlink(targetPath, linkPath); err != nil {
				t.Skipf("symlink creation is unavailable: %v", err)
			}

			var err error
			switch writer {
			case "project":
				err = WriteProjectFile(t.Context(), projectsRoot, projectDir, fileName, "services: { updated: true }")
			case "compose":
				err = WriteComposeFile(t.Context(), projectsRoot, projectDir, "services: { updated: true }")
			case "sync":
				_, err = WriteSyncedDirectory(t.Context(), projectsRoot, projectDir, []SyncFile{
					{RelativePath: DefaultComposeFileName, Content: []byte("services: { updated: true }")},
				})
			}
			require.Error(t, err)
			if writer == "project" {
				assert.Contains(t, err.Error(), "destination is a symlink")
			} else {
				require.ErrorIs(t, err, acfs.ErrSymlink)
			}

			targetContent, readErr := os.ReadFile(targetPath)
			require.NoError(t, readErr)
			assert.Equal(t, "services: {}\n", string(targetContent))
			linkInfo, statErr := os.Lstat(linkPath)
			require.NoError(t, statErr)
			require.NotZero(t, linkInfo.Mode()&os.ModeSymlink)
		})
	}
}

func TestWriteProjectFiles(t *testing.T) {
	tmpDir := t.TempDir()
	projectsRoot := tmpDir
	projectDir := filepath.Join(tmpDir, "test-project")

	t.Run("creates new project with empty env when envContent is nil", func(t *testing.T) {
		err := WriteProjectFiles(t.Context(), projectsRoot, projectDir, "services: {}", nil)
		require.NoError(t, err)

		envPath := filepath.Join(projectDir, ".env")
		content, err := os.ReadFile(envPath)
		require.NoError(t, err)
		assert.Empty(t, string(content))
	})

	t.Run("preserves existing env when envContent is nil", func(t *testing.T) {
		envPath := filepath.Join(projectDir, ".env")
		expected := "EXISTING=true"
		err := os.WriteFile(envPath, []byte(expected), 0o600)
		require.NoError(t, err)

		err = WriteProjectFiles(t.Context(), projectsRoot, projectDir, "services: { updated: true }", nil)
		require.NoError(t, err)

		content, err := os.ReadFile(envPath)
		require.NoError(t, err)
		assert.Equal(t, expected, string(content))
	})

	t.Run("overwrites env when envContent is provided", func(t *testing.T) {
		envPath := filepath.Join(projectDir, ".env")
		newContent := "NEW=true"
		err := WriteProjectFiles(t.Context(), projectsRoot, projectDir, "services: {}", &newContent)
		require.NoError(t, err)

		content, err := os.ReadFile(envPath)
		require.NoError(t, err)
		assert.Equal(t, newContent, string(content))
	})
}

func TestWriteComposeFile_PreservesExistingPodmanComposeNames(t *testing.T) {
	testCases := []struct {
		name     string
		fileName string
	}{
		{name: "podman-compose.yaml", fileName: "podman-compose.yaml"},
		{name: "podman-compose.yml", fileName: "podman-compose.yml"},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			t.Parallel()

			tmpDir := t.TempDir()
			projectsRoot := tmpDir
			projectDir := filepath.Join(tmpDir, "test-project")
			require.NoError(t, os.MkdirAll(projectDir, 0o755))

			existingComposePath := filepath.Join(projectDir, tc.fileName)
			require.NoError(t, os.WriteFile(existingComposePath, []byte("services: {}"), 0o600))
			original, err := os.Stat(existingComposePath)
			require.NoError(t, err)

			expectedContent := "services:\n  app:\n    image: nginx:alpine\n"
			err = WriteComposeFile(t.Context(), projectsRoot, projectDir, expectedContent)
			require.NoError(t, err)

			actualContent, err := os.ReadFile(existingComposePath)
			require.NoError(t, err)
			assert.Equal(t, expectedContent, string(actualContent))
			updated, err := os.Stat(existingComposePath)
			require.NoError(t, err)
			assert.True(t, os.SameFile(original, updated), "compose updates should preserve the inode")
			if runtime.GOOS != "windows" {
				assert.Equal(t, os.FileMode(0o600), updated.Mode().Perm(), "compose updates should preserve the file mode")
			}

			_, err = os.Stat(filepath.Join(projectDir, "compose.yaml"))
			assert.True(t, os.IsNotExist(err), "compose.yaml should not be created when existing podman-compose file is present")
		})
	}
}

func TestWriteSyncedDirectory_HonorsExecutableBit(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skip("file mode bits are not represented on Windows FS")
	}

	root := t.TempDir()
	project := filepath.Join(root, "myproject")
	files := []SyncFile{
		{RelativePath: "compose.yml", Content: []byte("services:\n  app:\n    image: alpine\n"), Executable: false},
		{RelativePath: "scripts/pre-deploy.sh", Content: []byte("#!/bin/sh\necho hi\n"), Executable: true},
		{RelativePath: "README.md", Content: []byte("readme"), Executable: false},
	}

	_, err := WriteSyncedDirectory(t.Context(), root, project, files)
	require.NoError(t, err)

	composeInfo, err := os.Stat(filepath.Join(project, "compose.yml"))
	require.NoError(t, err)
	assert.Equal(t, os.FileMode(0), composeInfo.Mode().Perm()&0o111, "compose.yml should not be executable")

	scriptInfo, err := os.Stat(filepath.Join(project, "scripts", "pre-deploy.sh"))
	require.NoError(t, err)
	assert.NotEqual(t, os.FileMode(0), scriptInfo.Mode().Perm()&0o111, "scripts/pre-deploy.sh should be executable")
}

func TestWriteSyncedDirectory_DowngradesExecutableBit(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skip("file mode bits are not represented on Windows FS")
	}

	root := t.TempDir()
	project := filepath.Join(root, "myproject")
	// First write: script committed as +x.
	_, err := WriteSyncedDirectory(t.Context(), root, project, []SyncFile{
		{RelativePath: "scripts/hook.sh", Content: []byte("#!/bin/sh\n"), Executable: true},
	})
	require.NoError(t, err)
	first, err := os.Stat(filepath.Join(project, "scripts", "hook.sh"))
	require.NoError(t, err)
	require.NotEqual(t, os.FileMode(0), first.Mode().Perm()&0o111)

	// Second write: same file, now without +x (e.g. the repo dropped the bit).
	// The write path must re-chmod so the on-disk mode tracks the repo, not
	// the previous write.
	_, err = WriteSyncedDirectory(t.Context(), root, project, []SyncFile{
		{RelativePath: "scripts/hook.sh", Content: []byte("#!/bin/sh\necho updated\n"), Executable: false},
	})
	require.NoError(t, err)
	second, err := os.Stat(filepath.Join(project, "scripts", "hook.sh"))
	require.NoError(t, err)
	assert.True(t, os.SameFile(first, second), "sync updates should preserve the inode")
	assert.Equal(t, os.FileMode(0), second.Mode().Perm()&0o111, "executable bit should clear on update when repo no longer marks +x")
}

func TestWriteSyncedDirectory_UpgradesExecutableBitOnUpdate(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skip("file mode bits are not represented on Windows FS")
	}

	root := t.TempDir()
	project := filepath.Join(root, "myproject")

	// First write: file committed without +x.
	_, err := WriteSyncedDirectory(t.Context(), root, project, []SyncFile{
		{RelativePath: "scripts/hook.sh", Content: []byte("#!/bin/sh\n"), Executable: false},
	})
	require.NoError(t, err)
	first, err := os.Stat(filepath.Join(project, "scripts", "hook.sh"))
	require.NoError(t, err)
	require.Equal(t, os.FileMode(0), first.Mode().Perm()&0o111)

	// Second write: same file, now with +x (e.g. the repo added the bit).
	// The write path must apply the new mode on an update, not just on create.
	_, err = WriteSyncedDirectory(t.Context(), root, project, []SyncFile{
		{RelativePath: "scripts/hook.sh", Content: []byte("#!/bin/sh\n"), Executable: true},
	})
	require.NoError(t, err)
	second, err := os.Stat(filepath.Join(project, "scripts", "hook.sh"))
	require.NoError(t, err)
	assert.True(t, os.SameFile(first, second), "permission updates should preserve the inode")
	assert.NotEqual(t, os.FileMode(0), second.Mode().Perm()&0o111, "executable bit should set on update when repo marks +x")
}

func TestWriteComposeFile_PreservesExistingCustomComposeNames(t *testing.T) {
	t.Parallel()

	tmpDir := t.TempDir()
	projectsRoot := tmpDir
	projectDir := filepath.Join(tmpDir, "Radarr-3")
	require.NoError(t, os.MkdirAll(projectDir, 0o755))

	existingComposePath := filepath.Join(projectDir, "radarr.yaml")
	require.NoError(t, os.WriteFile(existingComposePath, []byte("services: {}"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectDir, "config.yaml"), []byte("x-config: true\n"), 0o600))

	expectedContent := "services:\n  app:\n    image: nginx:alpine\n"
	err := WriteComposeFile(t.Context(), projectsRoot, projectDir, expectedContent)
	require.NoError(t, err)

	actualContent, err := os.ReadFile(existingComposePath)
	require.NoError(t, err)
	assert.Equal(t, expectedContent, string(actualContent))

	_, err = os.Stat(filepath.Join(projectDir, "compose.yaml"))
	assert.True(t, os.IsNotExist(err), "compose.yaml should not be created when an existing custom compose file is present")
}

func TestReadComposeOverrideContent(t *testing.T) {
	t.Parallel()

	dir := t.TempDir()
	assert.Empty(t, ReadComposeOverrideContent(dir))

	content := "services:\n  app:\n    image: busybox:latest\n"
	require.NoError(t, os.WriteFile(filepath.Join(dir, "compose.override.yaml"), []byte(content), 0o600))
	assert.Equal(t, content, ReadComposeOverrideContent(dir))
}

func TestResolveComposeOverride(t *testing.T) {
	t.Parallel()

	t.Run("returns highest-preference match", func(t *testing.T) {
		t.Parallel()
		available := map[string]string{
			"compose.override.yml":         "first\n",
			"docker-compose.override.yaml": "second\n",
		}
		name, content, found, err := ResolveComposeOverride(
			func(n string) bool { _, ok := available[n]; return ok },
			func(n string) (string, error) { return available[n], nil },
		)
		require.NoError(t, err)
		require.True(t, found)
		// compose.override.yml precedes docker-compose.override.yaml in compose-go order.
		assert.Equal(t, "compose.override.yml", name)
		assert.Equal(t, "first\n", content)
	})

	t.Run("returns not found when nothing exists", func(t *testing.T) {
		t.Parallel()
		name, content, found, err := ResolveComposeOverride(
			func(string) bool { return false },
			func(string) (string, error) { return "", nil },
		)
		require.NoError(t, err)
		assert.False(t, found)
		assert.Empty(t, name)
		assert.Empty(t, content)
	})

	t.Run("propagates read error", func(t *testing.T) {
		t.Parallel()
		_, _, found, err := ResolveComposeOverride(
			func(string) bool { return true },
			func(string) (string, error) { return "", errors.New("boom") },
		)
		require.Error(t, err)
		assert.False(t, found)
	})
}

func TestWriteComposeOverrideFile(t *testing.T) {
	t.Parallel()

	root := t.TempDir()
	dir := filepath.Join(root, "proj")
	require.NoError(t, os.MkdirAll(dir, 0o755))

	// A stale override under a different candidate name should be cleaned up.
	require.NoError(t, os.WriteFile(filepath.Join(dir, "docker-compose.override.yml"), []byte("stale\n"), 0o600))

	content := "services:\n  app:\n    image: busybox:latest\n"
	require.NoError(t, WriteComposeOverrideFile(t.Context(), root, dir, &content, "compose.override.yaml"))

	written, err := os.ReadFile(filepath.Join(dir, "compose.override.yaml"))
	require.NoError(t, err)
	assert.Equal(t, content, string(written))

	_, statErr := os.Stat(filepath.Join(dir, "docker-compose.override.yml"))
	assert.True(t, os.IsNotExist(statErr))

	// Nil content removes all override files.
	require.NoError(t, WriteComposeOverrideFile(t.Context(), root, dir, nil, ""))
	_, statErr = os.Stat(filepath.Join(dir, "compose.override.yaml"))
	assert.True(t, os.IsNotExist(statErr))
}