Skip to content

Modern Docker Management, Designed for Everyone

22.3 KB
Raw Blame
package projects

import (
	"context"
	"errors"
	"os"
	"path/filepath"
	"strings"
	"testing"

	composetypes "github.com/compose-spec/compose-go/v2/types"
	"github.com/docker/compose/v5/pkg/api"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
)

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

	composeContent := "services:\n  app:\n    image: nginx:alpine\n"

	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()

			dir := t.TempDir()
			expectedPath := filepath.Join(dir, tc.fileName)
			require.NoError(t, os.WriteFile(expectedPath, []byte(composeContent), 0o600))

			composePath, err := DetectComposeFile(t.Context(), "", dir)
			require.NoError(t, err)
			assert.Equal(t, expectedPath, composePath)
		})
	}
}

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

	dir := t.TempDir()
	expectedPath := filepath.Join(dir, "radarr.yaml")
	require.NoError(t, os.WriteFile(expectedPath, []byte("services:\n  app:\n    image: nginx:alpine\n"), 0o600))

	composePath, err := DetectComposeFile(t.Context(), "", dir)
	require.NoError(t, err)
	assert.Equal(t, expectedPath, composePath)
}

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

	root := t.TempDir()
	dir := filepath.Join(root, "Radarr-3")
	require.NoError(t, os.MkdirAll(dir, 0o755))
	expectedPath := filepath.Join(dir, "radarr.yaml")
	require.NoError(t, os.WriteFile(expectedPath, []byte("services:\n  app:\n    image: nginx:alpine\n"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "config.yaml"), []byte("x-extra: true\n"), 0o600))

	composePath, err := DetectComposeFile(t.Context(), "", dir)
	require.NoError(t, err)
	assert.Equal(t, expectedPath, composePath)
}

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

	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "alpha.yaml"), []byte("services:\n  a:\n    image: nginx:alpine\n"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "beta.yml"), []byte("services:\n  b:\n    image: busybox:latest\n"), 0o600))

	_, err := DetectComposeFile(t.Context(), "", dir)
	require.Error(t, err)
	assert.Contains(t, err.Error(), "multiple custom compose files")
}

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

	dir := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(dir, "values.yaml"), []byte("replicaCount: 2\nimage:\n  tag: latest\n"), 0o600))

	_, err := DetectComposeFile(t.Context(), "", dir)
	require.Error(t, err)
	assert.Contains(t, err.Error(), "no compose file found")
}

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

	t.Run("returns empty when no override present", func(t *testing.T) {
		t.Parallel()
		dir := t.TempDir()
		require.NoError(t, os.WriteFile(filepath.Join(dir, "compose.yaml"), []byte("services:\n  app:\n    image: nginx:alpine\n"), 0o600))
		assert.Empty(t, DetectComposeOverrideFile(dir))
	})

	t.Run("detects override file", func(t *testing.T) {
		t.Parallel()
		dir := t.TempDir()
		overridePath := filepath.Join(dir, "compose.override.yaml")
		require.NoError(t, os.WriteFile(overridePath, []byte("services:\n  app:\n    image: busybox:latest\n"), 0o600))
		assert.Equal(t, overridePath, DetectComposeOverrideFile(dir))
	})

	t.Run("prefers highest-preference override when multiple present", func(t *testing.T) {
		t.Parallel()
		dir := t.TempDir()
		preferred := filepath.Join(dir, "compose.override.yml")
		require.NoError(t, os.WriteFile(preferred, []byte("services:\n  app:\n    image: busybox:latest\n"), 0o600))
		require.NoError(t, os.WriteFile(filepath.Join(dir, "docker-compose.override.yaml"), []byte("services:\n  app:\n    image: alpine:3\n"), 0o600))
		assert.Equal(t, preferred, DetectComposeOverrideFile(dir))
	})
}

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

	dir := t.TempDir()
	basePath := filepath.Join(dir, "compose.yaml")
	require.NoError(t, os.WriteFile(basePath, []byte("services:\n  app:\n    image: nginx:alpine\n"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(dir, "compose.override.yaml"), []byte("services:\n  app:\n    image: busybox:latest\n"), 0o600))

	detected, err := DetectComposeFile(t.Context(), "", dir)
	require.NoError(t, err)
	assert.Equal(t, basePath, detected)
}

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

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

	_, err := DetectComposeFile(t.Context(), "", dir)
	require.Error(t, err)
}

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

	dir := t.TempDir()
	basePath := filepath.Join(dir, "compose.yaml")
	overridePath := filepath.Join(dir, "compose.override.yaml")
	require.NoError(t, os.WriteFile(basePath, []byte("services:\n  app:\n    image: nginx:alpine\n    environment:\n      FROM_BASE: \"1\"\n"), 0o600))
	require.NoError(t, os.WriteFile(overridePath, []byte("services:\n  app:\n    image: busybox:latest\n    environment:\n      FROM_OVERRIDE: \"1\"\n"), 0o600))

	cache := NewParsedComposeCache()
	project, err := LoadCachedComposeProject(t.Context(), cache, "demo-id", dir, basePath, "demo", dir, false, nil)
	require.NoError(t, err)
	require.NotNil(t, project)

	app := project.Services["app"]
	assert.Equal(t, "busybox:latest", app.Image)
	assert.Contains(t, app.Environment, "FROM_BASE")
	assert.Contains(t, app.Environment, "FROM_OVERRIDE")
	assert.Equal(t, []string{basePath, overridePath}, project.ComposeFiles)

	delete(project.Services, "app")
	cached, err := LoadCachedComposeProject(t.Context(), cache, "demo-id", dir, basePath, "demo", dir, false, nil)
	require.NoError(t, err)
	assert.Equal(t, "busybox:latest", cached.Services["app"].Image)
}

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

	dir := t.TempDir()
	basePath := filepath.Join(dir, "base.yml")
	require.NoError(t, os.MkdirAll(filepath.Join(dir, "sub"), 0o755))
	extraPath := filepath.Join(dir, "sub", "extra.yml")
	require.NoError(t, os.WriteFile(basePath, []byte("services:\n  app:\n    image: nginx:alpine\n"), 0o600))
	require.NoError(t, os.WriteFile(extraPath, []byte("services:\n  worker:\n    image: busybox:latest\n"), 0o600))
	// A standard override on disk must NOT be auto-merged when COMPOSE_FILE is set.
	require.NoError(t, os.WriteFile(filepath.Join(dir, "compose.override.yaml"), []byte("services:\n  app:\n    image: alpine:3\n"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(dir, ".env"), []byte("COMPOSE_FILE=base.yml:sub/extra.yml\n"), 0o600))

	project, err := LoadComposeProject(t.Context(), basePath, "demo", dir, false, nil, nil, nil, false, nil, nil, nil)
	require.NoError(t, err)
	require.NotNil(t, project)

	assert.Contains(t, project.Services, "app")
	assert.Contains(t, project.Services, "worker")
	assert.Equal(t, "nginx:alpine", project.Services["app"].Image, "override must not be merged when COMPOSE_FILE is set")
	assert.Equal(t, []string{basePath, extraPath}, project.ComposeFiles)
}

func TestLoadComposeProject_ArcaneProcessEnvInterpolation(t *testing.T) {
	// Arcane's own env (e.g. PORT) must not leak into compose interpolation of
	// managed projects: ${PORT:-8191} falls back to its default (issue #3499).
	// Allowlisted vars like TZ still flow through.
	t.Setenv("PORT", "3552")
	t.Setenv("TZ", "America/Chicago")

	testCases := []struct {
		name    string
		compose string
		check   func(t *testing.T, app composetypes.ServiceConfig)
	}{
		{
			name:    "blocked var falls back to compose default",
			compose: "services:\n  app:\n    image: nginx:alpine\n    ports:\n      - \"${PORT:-8191}:8191\"\n",
			check: func(t *testing.T, app composetypes.ServiceConfig) {
				t.Helper()
				require.Len(t, app.Ports, 1)
				assert.Equal(t, "8191", app.Ports[0].Published)
			},
		},
		{
			name:    "allowlisted var flows through",
			compose: "services:\n  app:\n    image: nginx:alpine\n    environment:\n      TZ: ${TZ:-UTC}\n",
			check: func(t *testing.T, app composetypes.ServiceConfig) {
				t.Helper()
				require.NotNil(t, app.Environment["TZ"])
				assert.Equal(t, "America/Chicago", *app.Environment["TZ"])
			},
		},
	}

	for _, tc := range testCases {
		t.Run(tc.name, func(t *testing.T) {
			dir := t.TempDir()
			basePath := filepath.Join(dir, "compose.yaml")
			require.NoError(t, os.WriteFile(basePath, []byte(tc.compose), 0o600))

			project, err := LoadComposeProject(t.Context(), basePath, "demo", dir, false, nil, nil, nil, false, nil, nil, nil)
			require.NoError(t, err)
			require.NotNil(t, project)

			tc.check(t, project.Services["app"])
		})
	}
}

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

	dir := t.TempDir()
	// A custom base filename (not a standard compose candidate) is the explicit
	// `-f` case: `docker compose` does not auto-load an override for it, so neither
	// do we, even though compose.override.yaml sits right beside it.
	basePath := filepath.Join(dir, "mystack.yaml")
	overridePath := filepath.Join(dir, "compose.override.yaml")
	require.NoError(t, os.WriteFile(basePath, []byte("services:\n  app:\n    image: nginx:alpine\n    environment:\n      FROM_BASE: \"1\"\n"), 0o600))
	require.NoError(t, os.WriteFile(overridePath, []byte("services:\n  app:\n    image: busybox:latest\n    environment:\n      FROM_OVERRIDE: \"1\"\n"), 0o600))

	project, err := LoadComposeProject(t.Context(), basePath, "demo", dir, false, nil, nil, nil, false, nil, nil, nil)
	require.NoError(t, err)
	require.NotNil(t, project)

	app := project.Services["app"]
	assert.Equal(t, "nginx:alpine", app.Image)
	assert.Contains(t, app.Environment, "FROM_BASE")
	assert.NotContains(t, app.Environment, "FROM_OVERRIDE")
	assert.Equal(t, []string{basePath}, project.ComposeFiles)
}

func TestLoadComposeProjectFromDir_SupportsPodmanComposeNames(t *testing.T) {
	composeContent := "services:\n  app:\n    image: nginx:alpine\n"

	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()

			dir := t.TempDir()
			expectedPath := filepath.Join(dir, tc.fileName)
			require.NoError(t, os.WriteFile(expectedPath, []byte(composeContent), 0o600))

			project, composePath, err := LoadComposeProjectFromDir(
				t.Context(),
				dir,
				"podman-project",
				filepath.Dir(dir),
				false,
				nil,
			)
			require.NoError(t, err)
			require.NotNil(t, project)

			assert.Equal(t, expectedPath, composePath)
			assert.Equal(t, []string{expectedPath}, project.ComposeFiles)
			assert.NotEmpty(t, project.Services)
		})
	}
}

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

	dir := t.TempDir()
	expectedPath := filepath.Join(dir, "radarr.yaml")
	require.NoError(t, os.WriteFile(expectedPath, []byte("services:\n  app:\n    image: nginx:alpine\n"), 0o600))

	project, composePath, err := LoadComposeProjectFromDir(
		t.Context(),
		dir,
		"radarr",
		filepath.Dir(dir),
		false,
		nil,
	)
	require.NoError(t, err)
	require.NotNil(t, project)
	assert.Equal(t, expectedPath, composePath)
	assert.Equal(t, []string{expectedPath}, project.ComposeFiles)
}

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

	projectsRoot := t.TempDir()
	projectDir := filepath.Join(projectsRoot, "nested", "services")
	require.NoError(t, os.MkdirAll(projectDir, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(projectDir, "compose.yaml"), []byte("services:\n  app:\n    image: nginx:alpine\n"), 0o600))

	project, composePath, err := LoadComposeProjectFromDir(t.Context(), projectDir, "nested-services", "", false, nil)
	require.NoError(t, err)
	require.NotNil(t, project)

	assert.Equal(t, filepath.Join(projectDir, "compose.yaml"), composePath)

	_, statErr := os.Stat(filepath.Join(projectsRoot, "nested", GlobalEnvFileName))
	assert.ErrorIs(t, statErr, os.ErrNotExist)
}

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

	// Reproduces the GitSync chicken-and-egg problem: a compose file references
	// ${CONFIG_FILE} in a bind-mount source, but no .env exists yet.  The strict
	// loader would resolve ${CONFIG_FILE} to "" and produce ":/etc/app/app.conf"
	// (empty section between colons).  The lenient loader must succeed instead.
	dir := t.TempDir()
	composePath := filepath.Join(dir, "compose.yaml")
	require.NoError(t, os.WriteFile(composePath, []byte(`services:
  app:
    image: nginx:alpine
    volumes:
      - ${CONFIG_FILE}:/etc/app/app.conf
`), 0o600))

	project, err := LoadComposeProject(t.Context(), composePath, "demo", dir, false, nil, nil, nil, true, nil, nil, nil)
	require.NoError(t, err)
	require.NotNil(t, project)
	assert.Len(t, project.Services, 1)
}

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

	// Same chicken-and-egg problem for typed fields: deploy.resources.limits.cpus
	// is parsed as a float and memory as a size. With no .env the strict loader
	// fails with `strconv.ParseFloat: parsing "": invalid syntax` and
	// `invalid size: ''`. Lenient mode must succeed so the GitOps sync can
	// create the project and let the user supply real values afterward.
	dir := t.TempDir()
	composePath := filepath.Join(dir, "compose.yaml")
	require.NoError(t, os.WriteFile(composePath, []byte(`services:
  chrony:
    image: ${DOCKER_IMAGE}
    deploy:
      resources:
        limits:
          cpus: ${CPU}
          memory: ${MEMORY}
`), 0o600))

	project, err := LoadComposeProject(t.Context(), composePath, "demo", dir, false, nil, nil, nil, true, nil, nil, nil)
	require.NoError(t, err)
	require.NotNil(t, project)
	assert.Len(t, project.Services, 1)
}

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

	// The lenient loader used to report the placeholder as every undefined
	// variable's value, which suppressed
	// ${VAR:-default} resolution and fed "/placeholder-undefined" into the
	// ports host entry ("invalid hostPort"). Defaults must resolve normally;
	// only variables with no default fall back to the placeholder.
	dir := t.TempDir()
	composePath := filepath.Join(dir, "compose.yaml")
	require.NoError(t, os.WriteFile(composePath, []byte(`services:
  app:
    image: nginx:alpine
    ports:
      - "${ARCANE_TEST_UNSET_PORT:-3169}:3000"
    environment:
      - MAX_FILE_SIZE=${ARCANE_TEST_UNSET_SIZE:-104857600}
`), 0o600))

	project, err := LoadComposeProject(t.Context(), composePath, "demo", dir, false, nil, nil, nil, true, nil, nil, nil)
	require.NoError(t, err)
	require.NotNil(t, project)
	require.Len(t, project.Services, 1)
	svc := project.Services["app"]
	require.Len(t, svc.Ports, 1)
	assert.Equal(t, "3169", svc.Ports[0].Published)
	require.NotNil(t, svc.Environment["MAX_FILE_SIZE"])
	assert.Equal(t, "104857600", *svc.Environment["MAX_FILE_SIZE"])
}

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

	projectDir := t.TempDir()
	includePath := filepath.Join(projectDir, "included.compose.yaml")
	composePath := filepath.Join(projectDir, "compose.yaml")

	require.NoError(t, os.WriteFile(includePath, []byte(`services:
  included:
    image: nginx:alpine
    profiles: [manual]
    volumes:
      - included-data:/data
volumes:
  included-data:
`), 0o600))
	require.NoError(t, os.WriteFile(composePath, []byte(`include:
  - included.compose.yaml
services:
  root:
    image: busybox:latest
`), 0o600))

	project, err := LoadComposeProject(t.Context(), composePath, "demo", projectDir, false, nil, nil, nil, false, nil, []string{"root", "included"}, nil)
	require.NoError(t, err)
	require.NotNil(t, project)

	rootService := project.Services["root"]
	includedService := project.Services["included"]
	require.Contains(t, project.Services, "included")
	require.Contains(t, project.Volumes, "included-data")
	require.Equal(t, "demo_included-data", project.Volumes["included-data"].Name)
	expectedConfigFiles := strings.Join(project.ComposeFiles, ",")

	require.Equal(t, []string{composePath}, project.ComposeFiles)
	require.Equal(t, project.WorkingDir, rootService.CustomLabels[api.WorkingDirLabel])
	require.Equal(t, expectedConfigFiles, rootService.CustomLabels[api.ConfigFilesLabel])
	require.Equal(t, project.WorkingDir, includedService.CustomLabels[api.WorkingDirLabel])
	require.Equal(t, expectedConfigFiles, includedService.CustomLabels[api.ConfigFilesLabel])
}

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

	tests := []struct {
		name        string
		composeBody string
		wantName    string
	}{
		{
			name: "yaml name",
			composeBody: `name: ai_tools
services:
  app:
    image: nginx:alpine
`,
			wantName: "ai_tools",
		},
		{
			name: "default name",
			composeBody: `services:
  app:
    image: nginx:alpine
`,
			wantName: "aitools",
		},
	}

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

			projectDir := t.TempDir()
			composePath := filepath.Join(projectDir, "compose.yaml")
			require.NoError(t, os.WriteFile(composePath, []byte(tt.composeBody), 0o600))

			project, err := LoadComposeProject(t.Context(), composePath, "aitools", projectDir, false, nil, nil, nil, false, nil, nil, nil)
			require.NoError(t, err)
			require.NotNil(t, project)
			require.Equal(t, tt.wantName, project.Name)

			service := project.Services["app"]
			require.Equal(t, tt.wantName, service.CustomLabels[api.ProjectLabel])
		})
	}
}

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

	dir := t.TempDir()
	composePath := filepath.Join(dir, "compose.yaml")
	require.NoError(t, os.WriteFile(composePath, []byte(`services:
  app:
    image: nginx:alpine
    volumes:
      - ./config.conf:/etc/app/config.conf
`), 0o600))

	project, err := LoadComposeProject(t.Context(), composePath, "demo", dir, false, nil, nil, nil, false, nil, nil, nil)
	require.NoError(t, err)

	ResolveRelativeProjectPaths(project, dir)

	service := project.Services["app"]
	require.Len(t, service.Volumes, 1)
	assert.Equal(t, filepath.Join(dir, "config.conf"), service.Volumes[0].Source)
}

// Reproduces the reported case where a relative bind path escaping the projects
// mount resolved against Arcane's container path instead of the host path
// `docker compose up` would use, while checking that in-mount relative paths and
// intentionally absolute paths keep their current behavior.
func TestLoadComposeProject_RemapsRelativeBindEscapingProjectsMount(t *testing.T) {
	t.Parallel()

	projectsRoot := t.TempDir()
	projectDir := filepath.Join(projectsRoot, "goclaw")
	require.NoError(t, os.MkdirAll(projectDir, 0o755))

	composePath := filepath.Join(projectDir, "compose.yaml")
	require.NoError(t, os.WriteFile(composePath, []byte(`services:
  goclaw:
    image: nginx:alpine
    volumes:
      - ../../../../goclaw/data:/app/data
      - ./data:/app/cache
      - /mnt/nas/media:/media
`), 0o600))

	pathMapper := NewPathMapper(projectsRoot, "/docker/112/arcane/arcane-data/projects")
	require.True(t, pathMapper.IsNonMatchingMount())

	project, err := LoadComposeProject(t.Context(), composePath, "goclaw", projectsRoot, false, pathMapper, nil, nil, false, nil, nil, nil)
	require.NoError(t, err)

	sources := make(map[string]string)
	for _, volume := range project.Services["goclaw"].Volumes {
		sources[volume.Target] = volume.Source
	}

	// Escapes the mount: must land where `docker compose up` in the host project
	// directory would put it, not at the container-resolved "/goclaw/data".
	assert.Equal(t, "/docker/112/goclaw/data", sources["/app/data"])
	// Stays inside the mount: already correct today, must not change.
	assert.Equal(t, "/docker/112/arcane/arcane-data/projects/goclaw/data", sources["/app/cache"])
	// Absolute host path: must be passed through untouched.
	assert.Equal(t, "/mnt/nas/media", sources["/media"])
}

// The prepare callback must observe local, resolved bind sources: after
// relative paths are anchored to the project directory, but before host path
// translation rewrites them for the Docker daemon. Read-only loads pass nil
// and must not touch the filesystem.
func TestLoadComposeProject_PrepareRunsBeforeHostPathTranslation(t *testing.T) {
	t.Parallel()

	projectsRoot := t.TempDir()
	projectDir := filepath.Join(projectsRoot, "caddy")
	require.NoError(t, os.MkdirAll(projectDir, 0o755))

	composePath := filepath.Join(projectDir, "compose.yaml")
	require.NoError(t, os.WriteFile(composePath, []byte(`services:
  caddy:
    image: caddy:2
    volumes:
      - ./conf:/etc/caddy
  disabled:
    image: busybox
    profiles: [extra]
    volumes:
      - ./never:/never
`), 0o600))

	pathMapper := NewPathMapper(projectsRoot, "/host/projects")
	require.True(t, pathMapper.IsNonMatchingMount())

	var seen []string
	prepare := func(_ context.Context, project *composetypes.Project) error {
		for _, service := range project.Services {
			for _, volume := range service.Volumes {
				seen = append(seen, volume.Source)
			}
		}
		return os.MkdirAll(filepath.Join(projectDir, "conf"), 0o755)
	}

	project, err := LoadComposeProject(t.Context(), composePath, "caddy", projectsRoot, false, pathMapper, nil, nil, false, nil, nil, prepare)
	require.NoError(t, err)

	assert.Equal(t, []string{filepath.Join(projectDir, "conf")}, seen, "prepare sees only active services with local resolved sources")
	assert.Equal(t, "/host/projects/caddy/conf", project.Services["caddy"].Volumes[0].Source, "host translation still applies after prepare")
	assert.DirExists(t, filepath.Join(projectDir, "conf"))

	prepareErr := errors.New("boom")
	_, err = LoadComposeProject(t.Context(), composePath, "caddy", projectsRoot, false, pathMapper, nil, nil, false, nil, nil, func(context.Context, *composetypes.Project) error {
		return prepareErr
	})
	require.ErrorIs(t, err, prepareErr)

	require.NoError(t, os.RemoveAll(filepath.Join(projectDir, "conf")))
	_, err = LoadComposeProject(t.Context(), composePath, "caddy", projectsRoot, false, pathMapper, nil, nil, false, nil, nil, nil)
	require.NoError(t, err)
	assert.NoDirExists(t, filepath.Join(projectDir, "conf"), "nil prepare must not create bind directories")
}