Skip to content

Modern Docker Management, Designed for Everyone

352 KB
Raw Blame
package project

import (
	"cmp"
	"context"
	"encoding/binary"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"io/fs"
	"maps"
	"net/http"
	"net/http/httptest"
	"net/netip"
	"net/url"
	"os"
	"path/filepath"
	"runtime"
	"strings"
	"sync"
	"sync/atomic"
	"testing"
	"time"

	"github.com/compose-spec/compose-go/v2/types"
	"github.com/docker/compose/v5/pkg/api"
	"github.com/getarcaneapp/arcane/types/v2/base"
	"github.com/getarcaneapp/arcane/types/v2/containerregistry"
	imagetypes "github.com/getarcaneapp/arcane/types/v2/image"
	projecttypes "github.com/getarcaneapp/arcane/types/v2/project"
	usertypes "github.com/getarcaneapp/arcane/types/v2/user"
	volumetypes "github.com/getarcaneapp/arcane/types/v2/volume"
	"github.com/libtnb/sqlite"
	"github.com/moby/moby/api/pkg/authconfig"
	"github.com/moby/moby/api/pkg/stdcopy"
	"github.com/moby/moby/api/types/container"
	dockertypesimage "github.com/moby/moby/api/types/image"
	dockerregistry "github.com/moby/moby/api/types/registry"
	"github.com/moby/moby/api/types/volume"
	"github.com/moby/moby/client"
	"github.com/opencontainers/go-digest"
	"github.com/samber/mo"
	"github.com/stretchr/testify/assert"
	"github.com/stretchr/testify/require"
	"go.getarcane.app/acfs"
	buildtypes "go.getarcane.app/builds/types"
	kit "go.getarcane.app/kit/pkg"
	"go.getarcane.app/updater/labels"
	updatertypes "go.getarcane.app/updater/types"
	"gorm.io/gorm"

	"github.com/getarcaneapp/arcane/backend/v2/internal/common"
	"github.com/getarcaneapp/arcane/backend/v2/internal/config"
	"github.com/getarcaneapp/arcane/backend/v2/internal/database"
	"github.com/getarcaneapp/arcane/backend/v2/internal/docker"
	"github.com/getarcaneapp/arcane/backend/v2/internal/event"
	"github.com/getarcaneapp/arcane/backend/v2/internal/image"
	"github.com/getarcaneapp/arcane/backend/v2/internal/imageupdate"
	"github.com/getarcaneapp/arcane/backend/v2/internal/kv"
	"github.com/getarcaneapp/arcane/backend/v2/internal/project/children/deployment"
	projectdetails "github.com/getarcaneapp/arcane/backend/v2/internal/project/children/details"
	"github.com/getarcaneapp/arcane/backend/v2/internal/project/children/listing"
	projectsync "github.com/getarcaneapp/arcane/backend/v2/internal/project/children/sync"
	"github.com/getarcaneapp/arcane/backend/v2/internal/project/children/tags"
	"github.com/getarcaneapp/arcane/backend/v2/internal/project/children/update"
	"github.com/getarcaneapp/arcane/backend/v2/internal/project/children/workspace"
	"github.com/getarcaneapp/arcane/backend/v2/internal/registry"
	"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/volumes"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/pagination"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/projects"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/httpx"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/iconcatalog"
	"github.com/getarcaneapp/arcane/backend/v2/pkg/utils/imageref"
)

var testRegistryCredentials = func(context.Context) ([]containerregistry.Credential, error) { return nil, nil }

var testDockerService = &docker.DockerClientService{Client: func() *client.Client {
	cli, _ := client.New(client.WithHost("tcp://127.0.0.1:1"), client.WithAPIVersion("1.41"))
	return cli
}()}

type testBuildBuilder struct {
	err error
}

func (b testBuildBuilder) BuildImage(_ context.Context, _ string, _ buildtypes.BuildRequest, _ io.Writer, _ string, _ *usertypes.Actor) (*buildtypes.BuildResult, error) {
	if b.err != nil {
		return nil, b.err
	}
	return &buildtypes.BuildResult{Provider: "local"}, nil
}

func (testBuildBuilder) BuildSettings() buildtypes.BuildSettings {
	return buildtypes.BuildSettings{}
}

var _ builder = testBuildBuilder{}

func setupProjectTestDB(t *testing.T) *database.DB {
	t.Helper()
	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
	require.NoError(t, err)
	require.NoError(t, db.AutoMigrate(&Project{}, &ProjectTag{}, &GitOpsSync{}, &settings.SettingVariable{}, &imageupdate.ImageUpdateRecord{}, &event.Event{}, &kv.KVEntry{}))
	return &database.DB{DB: db}
}

func TestUpdateProjectWorkspaceRejectsInvalidManifestBeforeProjectLookup(t *testing.T) {
	service := NewProjectService(nil, nil, nil, nil, testDockerService, testBuildBuilder{}, nil, nil, nil, nil, testRegistryCredentials)

	_, err := service.UpdateProjectWorkspace(t.Context(), "missing", projecttypes.WorkspaceUpdateManifest{}, nil, usertypes.Actor{})
	require.ErrorIs(t, err, common.ErrProjectWorkspaceBadRequest)
	require.ErrorContains(t, err, "revision")
}

func TestValidateWorkspaceChangesAgainstGitOps(t *testing.T) {
	owned := map[string]struct{}{"compose.yaml": {}, "conf/app.conf": {}}

	err := workspace.ValidateWorkspaceChangesAgainstGitOps([]projecttypes.WorkspaceFileChange{
		{Operation: projecttypes.FileOpUpdateFile, RelativePath: "conf/app.conf"},
	}, owned)
	require.ErrorIs(t, err, common.ErrProjectWorkspaceForbidden)
	require.ErrorContains(t, err, "conf/app.conf")

	// Recursively deleting a folder that still holds a sync-owned file must
	// also be rejected.
	err = workspace.ValidateWorkspaceChangesAgainstGitOps([]projecttypes.WorkspaceFileChange{
		{Operation: projecttypes.FileOpDelete, RelativePath: "conf", Recursive: true},
	}, owned)
	require.ErrorIs(t, err, common.ErrProjectWorkspaceForbidden)

	// The operator overlay (e.g. a secret env file the repo cannot carry)
	// stays editable.
	err = workspace.ValidateWorkspaceChangesAgainstGitOps([]projecttypes.WorkspaceFileChange{
		{Operation: projecttypes.FileOpCreateFile, RelativePath: "app.env"},
	}, owned)
	require.NoError(t, err)
}

func newSettingsServiceForTest(t *testing.T, ctx context.Context, db *database.DB) (*settings.SettingsService, error) {
	t.Helper()
	svc, err := settings.NewSettingsService(ctx, db, &config.Config{})
	if err == nil {
		t.Cleanup(func() { require.NoError(t, svc.Stop(context.WithoutCancel(t.Context()))) })
	}
	return svc, err
}

func newTestDockerClient(t *testing.T, server *httptest.Server) *client.Client {
	t.Helper()

	cli, err := client.New(
		client.WithHost(server.URL),
		client.WithAPIVersion("1.41"),
		client.WithHTTPClient(server.Client()),
	)
	require.NoError(t, err)
	t.Cleanup(func() { _ = cli.Close() })
	return cli
}

func decodeRegistryAuth(t *testing.T, encoded string) dockerregistry.AuthConfig {
	t.Helper()
	cfg, err := authconfig.Decode(encoded)
	require.NoError(t, err)
	return *cfg
}

func newImagePullServerWithObserver(t *testing.T, inspectByRef map[string]dockertypesimage.InspectResponse, onPull func(fullRef, authHeader string)) *httptest.Server {
	t.Helper()

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case strings.HasSuffix(r.URL.Path, "/images/create"):
			fullRef := strings.TrimSpace(r.URL.Query().Get("fromImage"))
			tag := strings.TrimSpace(r.URL.Query().Get("tag"))
			if fullRef != "" && tag != "" {
				lastSlash := strings.LastIndex(fullRef, "/")
				lastColon := strings.LastIndex(fullRef, ":")
				if lastColon <= lastSlash {
					fullRef += ":" + tag
				}
			}
			if onPull != nil {
				onPull(fullRef, strings.TrimSpace(r.Header.Get("X-Registry-Auth")))
			}
			w.Header().Set("Content-Type", "application/json")
			_ = json.NewEncoder(w).Encode(map[string]string{"status": "Pulled", "id": fullRef})
		case strings.Contains(r.URL.Path, "/images/") && strings.HasSuffix(r.URL.Path, "/json"):
			path := r.URL.Path
			imagePathIndex := strings.Index(path, "/images/")
			if !assert.NotEqual(t, -1, imagePathIndex) {
				return
			}
			encodedRef := strings.TrimSuffix(path[imagePathIndex+len("/images/"):], "/json")
			imageRef, err := url.PathUnescape(encodedRef)
			if !assert.NoError(t, err) {
				return
			}
			inspect, ok := inspectByRef[imageRef]
			if !ok {
				http.Error(w, "not found", http.StatusNotFound)
				return
			}
			w.Header().Set("Content-Type", "application/json")
			_ = json.NewEncoder(w).Encode(inspect)
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(server.Close)
	return server
}

func TestProjectService_RefreshProjectImageRefs_PersistsBuildMetadata(t *testing.T) {
	ctx := t.Context()
	db := setupProjectTestDB(t)
	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectPath := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(`services:
  explicit:
    build: .
    image: test2:latest
  worker:
    build:
      context: .
      dockerfile: Dockerfile
  regular:
    image: postgres:17
`), 0o644))

	proj := &Project{
		ID:   "project-build-image-refs",
		Name: "demo",
		Path: projectPath,
	}
	require.NoError(t, db.Create(proj).Error)

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	svc.refreshProjectImageRefs(ctx, proj)

	var saved Project
	require.NoError(t, db.First(&saved, "id = ?", proj.ID).Error)
	assert.ElementsMatch(t, []string{"test2:latest", "postgres:17"}, projects.ParseImageRefsJSON(saved.ImageRefsJSON))
	require.NotNil(t, saved.BuildImageRefsJSON)
	assert.ElementsMatch(t, []string{"test2:latest", "demo-worker"}, projects.ParseImageRefsJSON(*saved.BuildImageRefsJSON))
}

func TestProjectService_BackfillProjectImageRefs_RetriesOnlyMissingMetadata(t *testing.T) {
	ctx := t.Context()
	db := setupProjectTestDB(t)
	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	validPath := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(validPath, "compose.yaml"), []byte(`services:
  app:
    build: .
    image: local-app:latest
`), 0o644))
	invalidPath := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(invalidPath, "compose.yaml"), []byte("services: [\n"), 0o644))
	regularPath := t.TempDir()
	require.NoError(t, os.WriteFile(filepath.Join(regularPath, "compose.yaml"), []byte(`services:
  app:
    image: nginx:latest
`), 0o644))

	valid := &Project{ID: "backfill-valid", Name: "valid", Path: validPath}
	invalid := &Project{ID: "backfill-invalid", Name: "invalid", Path: invalidPath}
	regular := &Project{ID: "backfill-regular", Name: "regular", Path: regularPath}
	require.NoError(t, db.Create(valid).Error)
	require.NoError(t, db.Create(invalid).Error)
	require.NoError(t, db.Create(regular).Error)

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	count, err := svc.BackfillProjectImageRefs(ctx)
	require.NoError(t, err)
	require.Equal(t, 3, count)

	var savedValid Project
	require.NoError(t, db.First(&savedValid, "id = ?", valid.ID).Error)
	require.NotNil(t, savedValid.BuildImageRefsJSON)
	assert.Equal(t, []string{"local-app:latest"}, projects.ParseImageRefsJSON(*savedValid.BuildImageRefsJSON))

	var savedInvalid Project
	require.NoError(t, db.First(&savedInvalid, "id = ?", invalid.ID).Error)
	assert.Nil(t, savedInvalid.BuildImageRefsJSON)

	var savedRegular Project
	require.NoError(t, db.First(&savedRegular, "id = ?", regular.ID).Error)
	require.NotNil(t, savedRegular.BuildImageRefsJSON)
	assert.Equal(t, "[]", *savedRegular.BuildImageRefsJSON)

	require.NoError(t, os.Remove(filepath.Join(validPath, "compose.yaml")))
	require.NoError(t, os.Remove(filepath.Join(regularPath, "compose.yaml")))
	count, err = svc.BackfillProjectImageRefs(ctx)
	require.NoError(t, err)
	require.Equal(t, 1, count)
	require.NoError(t, db.First(&savedValid, "id = ?", valid.ID).Error)
	require.NotNil(t, savedValid.BuildImageRefsJSON)
	assert.Equal(t, []string{"local-app:latest"}, projects.ParseImageRefsJSON(*savedValid.BuildImageRefsJSON))
	require.NoError(t, db.First(&savedRegular, "id = ?", regular.ID).Error)
	require.NotNil(t, savedRegular.BuildImageRefsJSON)
	assert.Equal(t, "[]", *savedRegular.BuildImageRefsJSON)
}

func setupProjectDestroyTestService(t *testing.T) (*ProjectService, *database.DB, string) {
	t.Helper()

	ctx := t.Context()
	db := setupProjectTestDB(t)
	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsDir := t.TempDir()
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))

	eventService := event.NewEventService(db, config.Load(), nil)
	return NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	), db, projectsDir
}

func TestProjectService_DestroyProject_RemovesFilesWhenRequested(t *testing.T) {
	ctx := t.Context()
	svc, db, projectsDir := setupProjectDestroyTestService(t)

	projectPath := filepath.Join(projectsDir, "demo-remove")
	require.NoError(t, os.MkdirAll(projectPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project-data.txt"), []byte("keep until destroy\n"), 0o644))

	dirName := "demo-remove"
	project := &Project{
		ID:      "project-destroy-remove-files",
		Name:    "demo-remove",
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	require.NoError(t, svc.DestroyProject(ctx, project.ID, true, false, usertypes.Actor{}))

	_, statErr := os.Stat(projectPath)
	assert.ErrorIs(t, statErr, os.ErrNotExist)
}

func TestProjectService_DestroyProject_PreservesFilesWhenRequested(t *testing.T) {
	ctx := t.Context()
	svc, db, projectsDir := setupProjectDestroyTestService(t)

	projectPath := filepath.Join(projectsDir, "demo-preserve")
	require.NoError(t, os.MkdirAll(projectPath, 0o755))
	projectDataPath := filepath.Join(projectPath, "project-data.txt")
	require.NoError(t, os.WriteFile(projectDataPath, []byte("preserve on destroy\n"), 0o644))

	dirName := "demo-preserve"
	project := &Project{
		ID:      "project-destroy-preserve-files",
		Name:    "demo-preserve",
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	require.NoError(t, svc.DestroyProject(ctx, project.ID, false, false, usertypes.Actor{}))

	assert.NoDirExists(t, projectPath)
	assert.NoFileExists(t, projectDataPath)

	entries, err := os.ReadDir(projectsDir)
	require.NoError(t, err)
	require.Len(t, entries, 1)
	trashName := entries[0].Name()
	require.True(t, strings.HasPrefix(trashName, ".arcane-trash-demo-preserve-"), "trash dir name: %s", trashName)
	assert.FileExists(t, filepath.Join(projectsDir, trashName, "project-data.txt"))
}

func TestProjectService_LockProject_SerializesSameProject(t *testing.T) {
	svc, _, _ := setupProjectDestroyTestService(t)

	unlock, err := svc.lockProject(t.Context(), "test", "project-a")
	require.NoError(t, err)

	done := make(chan error, 1)
	go func() { done <- svc.DownProject(t.Context(), "project-a", usertypes.Actor{}) }()

	select {
	case downErr := <-done:
		t.Fatalf("DownProject ran while another operation held the project lease: %v", downErr)
	case <-time.After(100 * time.Millisecond):
	}

	otherCtx, cancel := context.WithTimeout(t.Context(), time.Second)
	defer cancel()
	otherErr := svc.DownProject(otherCtx, "project-b", usertypes.Actor{})
	require.Error(t, otherErr)
	require.NotErrorIs(t, otherErr, context.DeadlineExceeded, "a different project must not wait on the held lease")

	unlock()
	select {
	case downErr := <-done:
		require.Error(t, downErr)
		require.NotErrorIs(t, downErr, context.DeadlineExceeded)
	case <-time.After(2 * time.Second):
		t.Fatal("DownProject did not run after the project lease was released")
	}
}

func TestProjectService_LockProject_ReturnsWaitErrorOnDeadline(t *testing.T) {
	svc, _, _ := setupProjectDestroyTestService(t)

	unlock, err := svc.lockProject(t.Context(), "test", "project-a")
	require.NoError(t, err)
	defer unlock()

	ctx, cancel := context.WithTimeout(t.Context(), 50*time.Millisecond)
	defer cancel()
	downErr := svc.DownProject(ctx, "project-a", usertypes.Actor{})
	require.ErrorIs(t, downErr, context.DeadlineExceeded)
	assert.Contains(t, downErr.Error(), "down project project-a: waiting for in-progress operation")
}

func TestProjectService_DownProject_RestoresPreviousStatusOnFailure(t *testing.T) {
	ctx := t.Context()
	svc, db, projectsDir := setupProjectDestroyTestService(t)
	t.Setenv("DOCKER_HOST", "tcp://127.0.0.1:1")

	require.NoError(t, db.Create(&Project{
		ID:      "project-down-fails",
		Name:    "down-fails",
		DirName: new("down-fails"),
		Path:    createComposeProjectDir(t, projectsDir, "down-fails"),
		Status:  ProjectStatusStopped,
	}).Error)

	require.Error(t, svc.DownProject(ctx, "project-down-fails", usertypes.Actor{}))

	var stored Project
	require.NoError(t, db.First(&stored, "id = ?", "project-down-fails").Error)
	assert.Equal(t, ProjectStatusStopped, stored.Status)
}

func TestProjectService_DestroyProject_KeepsRowWhenDownFails(t *testing.T) {
	ctx := t.Context()
	svc, db, projectsDir := setupProjectDestroyTestService(t)
	t.Setenv("DOCKER_HOST", "tcp://127.0.0.1:1")

	projectPath := createComposeProjectDir(t, projectsDir, "destroy-down-fails")
	require.NoError(t, db.Create(&Project{
		ID:      "project-destroy-down-fails",
		Name:    "destroy-down-fails",
		DirName: new("destroy-down-fails"),
		Path:    projectPath,
		Status:  ProjectStatusRunning,
	}).Error)

	require.Error(t, svc.DestroyProject(ctx, "project-destroy-down-fails", true, true, usertypes.Actor{}))

	var stored Project
	require.NoError(t, db.First(&stored, "id = ?", "project-destroy-down-fails").Error)
	assert.Equal(t, ProjectStatusRunning, stored.Status)
	assert.DirExists(t, projectPath)
}

func TestProjectService_GetProjectFromDatabaseByID(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	// Setup dependencies
	settingsService, _ := newSettingsServiceForTest(t, ctx, db)
	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	// Create test project
	proj := &Project{
		ID:   "p1",
		Name: "test-project",
		Path: "/tmp/test-project",
	}
	require.NoError(t, db.Create(proj).Error)

	// Test success
	found, err := svc.GetProjectFromDatabaseByID(ctx, "p1")
	require.NoError(t, err)
	assert.Equal(t, "test-project", found.Name)

	// Test not found
	_, err = svc.GetProjectFromDatabaseByID(ctx, "non-existent")
	require.Error(t, err)
	assert.Contains(t, err.Error(), "project not found")
}

func TestProjectService_UpdateProjectStatus(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	proj := &Project{
		ID:     "p1",
		Status: ProjectStatusUnknown,
	}
	require.NoError(t, db.Create(proj).Error)

	err := svc.updateProjectStatus(ctx, "p1", ProjectStatusRunning)
	require.NoError(t, err)

	var updated Project
	require.NoError(t, db.First(&updated, "id = ?", "p1").Error)
	assert.Equal(t, ProjectStatusRunning, updated.Status)
	if updated.UpdatedAt != nil {
		assert.WithinDuration(t, time.Now(), *updated.UpdatedAt, time.Second)
	} else {
		assert.Fail(t, "UpdatedAt should not be nil")
	}
}

func TestProjectService_GetProjectByComposeName(t *testing.T) {
	ctx := t.Context()

	t.Run("exact match", func(t *testing.T) {
		db := setupProjectTestDB(t)
		svc := NewProjectService(
			db,
			nil,
			event.NewEventService(db, nil, nil),
			image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
			testDockerService,
			testBuildBuilder{},
			nil,
			nil,
			config.Load(),
			kv.NewKVService(db),
			testRegistryCredentials,
		)

		proj := &Project{
			ID:   "p1",
			Name: "myproject",
			Path: "/tmp/myproject",
		}
		require.NoError(t, db.Create(proj).Error)

		found, err := svc.GetProjectByComposeName(ctx, "myproject")
		require.NoError(t, err)
		assert.Equal(t, proj.ID, found.ID)
	})

	t.Run("normalized fallback", func(t *testing.T) {
		db := setupProjectTestDB(t)
		svc := NewProjectService(
			db,
			nil,
			event.NewEventService(db, nil, nil),
			image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
			testDockerService,
			testBuildBuilder{},
			nil,
			nil,
			config.Load(),
			kv.NewKVService(db),
			testRegistryCredentials,
		)

		proj := &Project{
			ID:   "p1",
			Name: "myproject",
			Path: "/tmp/myproject",
		}
		require.NoError(t, db.Create(proj).Error)

		found, err := svc.GetProjectByComposeName(ctx, "My Project!")
		require.NoError(t, err)
		assert.Equal(t, proj.ID, found.ID)
	})

	t.Run("display name in db, normalized compose label input", func(t *testing.T) {
		db := setupProjectTestDB(t)
		svc := NewProjectService(
			db,
			nil,
			event.NewEventService(db, nil, nil),
			image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
			testDockerService,
			testBuildBuilder{},
			nil,
			nil,
			config.Load(),
			kv.NewKVService(db),
			testRegistryCredentials,
		)

		display := &Project{
			ID:   "p2",
			Name: "My Project!",
			Path: "/tmp/my-project",
		}
		require.NoError(t, db.Create(display).Error)

		found, err := svc.GetProjectByComposeName(ctx, "myproject")
		require.NoError(t, err)
		assert.Equal(t, display.ID, found.ID)
	})

	t.Run("invalidates stale normalized cache entries after deletion", func(t *testing.T) {
		db := setupProjectTestDB(t)
		svc := NewProjectService(
			db,
			nil,
			event.NewEventService(db, nil, nil),
			image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
			testDockerService,
			testBuildBuilder{},
			nil,
			nil,
			config.Load(),
			kv.NewKVService(db),
			testRegistryCredentials,
		)

		original := &Project{
			ID:   "p3",
			Name: "My Project!",
			Path: "/tmp/my-project",
		}
		require.NoError(t, db.Create(original).Error)

		found, err := svc.GetProjectByComposeName(ctx, "myproject")
		require.NoError(t, err)
		assert.Equal(t, original.ID, found.ID)

		cachedProjectID, cached := svc.composeNames.projectID("myproject").Get()
		require.True(t, cached)
		assert.Equal(t, original.ID, cachedProjectID)

		require.NoError(t, db.Delete(&Project{}, "id = ?", original.ID).Error)

		replacement := &Project{
			ID:   "p4",
			Name: "My Project!",
			Path: "/tmp/my-project-recreated",
		}
		require.NoError(t, db.Create(replacement).Error)

		found, err = svc.GetProjectByComposeName(ctx, "myproject")
		require.NoError(t, err)
		assert.Equal(t, replacement.ID, found.ID)

		cachedProjectID, cached = svc.composeNames.projectID("myproject").Get()
		require.True(t, cached)
		assert.Equal(t, replacement.ID, cachedProjectID)
	})

	t.Run("invalidates stale normalized cache entries after rename", func(t *testing.T) {
		db := setupProjectTestDB(t)
		svc := NewProjectService(
			db,
			nil,
			event.NewEventService(db, nil, nil),
			image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
			testDockerService,
			testBuildBuilder{},
			nil,
			nil,
			config.Load(),
			kv.NewKVService(db),
			testRegistryCredentials,
		)

		original := &Project{
			ID:   "p5",
			Name: "My App!",
			Path: "/tmp/my-app",
		}
		require.NoError(t, db.Create(original).Error)

		found, err := svc.GetProjectByComposeName(ctx, "myapp")
		require.NoError(t, err)
		assert.Equal(t, original.ID, found.ID)

		cachedProjectID, cached := svc.composeNames.projectID("myapp").Get()
		require.True(t, cached)
		assert.Equal(t, original.ID, cachedProjectID)

		require.NoError(t, db.Model(&Project{}).Where("id = ?", original.ID).Updates(map[string]any{
			"name": "New Service",
			"path": "/tmp/new-service",
		}).Error)

		_, err = svc.GetProjectByComposeName(ctx, "myapp")
		require.Error(t, err)
		assert.Contains(t, err.Error(), "project not found")

		_, cached = svc.composeNames.projectID("myapp").Get()
		assert.False(t, cached)
	})
}

func TestProjectService_PullProjectImages_UpdatesCurrentImageRecordAfterPull(t *testing.T) {
	ctx := t.Context()
	db := setupProjectTestDB(t)

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))

	imageRef := "registry.example.com/team/app:1.2.3"
	repository := "registry.example.com/team/app"
	imageID := "sha256:team-app"
	imageDigest := digest.FromString("team-app-digest").String()
	buildRepository := "arcane.local/demo-builder/service"

	server := newImagePullServerWithObserver(t, map[string]dockertypesimage.InspectResponse{
		imageRef: {
			ID:          imageID,
			RepoTags:    []string{imageRef},
			RepoDigests: []string{repository + "@" + imageDigest},
		},
	}, nil)

	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
	eventService := event.NewEventService(db, nil, nil)
	imageUpdateService := imageupdate.NewImageUpdateService(db, nil, nil, dockerService, nil, nil, nil)
	imageService := image.NewImageService(db, dockerService, nil, imageUpdateService, nil, eventService, settingsService, nil)
	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		imageService,
		dockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	projectPath := createComposeProjectDir(t, projectsDir, "compose-pull")
	composeContent := fmt.Sprintf("services:\n  app:\n    image: %s\n  builder:\n    build: .\n", imageRef)
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(composeContent), 0o644))

	dirName := "compose-pull"
	projectRecord := &Project{
		ID:      "project-pull",
		Name:    "compose-pull",
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(projectRecord).Error)

	now := time.Now().UTC().Add(-time.Hour)
	require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{
		ID:             "sha256:old-full",
		Repository:     repository,
		Tag:            "1.2.3",
		HasUpdate:      true,
		UpdateType:     imageupdate.UpdateTypeDigest,
		CurrentVersion: "1.2.3",
		CheckTime:      now,
	}).Error)
	require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{
		ID:             "sha256:old-short",
		Repository:     "team/app",
		Tag:            "1.2.3",
		HasUpdate:      true,
		UpdateType:     imageupdate.UpdateTypeDigest,
		CurrentVersion: "1.2.3",
		CheckTime:      now.Add(time.Minute),
	}).Error)
	require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{
		ID:             "sha256:build-only",
		Repository:     buildRepository,
		Tag:            "latest",
		HasUpdate:      true,
		UpdateType:     imageupdate.UpdateTypeDigest,
		CurrentVersion: "latest",
		CheckTime:      now.Add(2 * time.Minute),
	}).Error)

	require.NoError(t, svc.PullProjectImages(ctx, projectRecord.ID, io.Discard, usertypes.SystemUser, nil))

	// sha256:old-* records represent update records for OTHER containers still running
	// the old image. Pulling the image for one container must not mark them as up-to-date
	// (#2453: updating one container was incorrectly removing others from the update list).
	var fullRecord imageupdate.ImageUpdateRecord
	require.NoError(t, db.WithContext(ctx).Where("id = ?", "sha256:old-full").First(&fullRecord).Error)
	assert.True(t, fullRecord.HasUpdate)

	var shortRecord imageupdate.ImageUpdateRecord
	require.NoError(t, db.WithContext(ctx).Where("id = ?", "sha256:old-short").First(&shortRecord).Error)
	assert.True(t, shortRecord.HasUpdate)

	var buildRecord imageupdate.ImageUpdateRecord
	require.NoError(t, db.WithContext(ctx).Where("id = ?", "sha256:build-only").First(&buildRecord).Error)
	assert.True(t, buildRecord.HasUpdate)

	// The newly pulled image itself is correctly marked as up-to-date.
	var currentRecord imageupdate.ImageUpdateRecord
	require.NoError(t, db.WithContext(ctx).Where("id = ?", imageID).First(&currentRecord).Error)
	assert.False(t, currentRecord.HasUpdate)
	assert.Equal(t, repository, currentRecord.Repository)
	assert.Equal(t, "1.2.3", currentRecord.Tag)
	assert.Equal(t, imageDigest, mo.PointerToOption(currentRecord.CurrentDigest).OrEmpty())
	assert.Equal(t, imageDigest, mo.PointerToOption(currentRecord.LatestDigest).OrEmpty())
}

func TestProjectService_EnsureImagesPresent_UpdatesCurrentImageRecordAfterPull(t *testing.T) {
	ctx := t.Context()
	db := setupProjectTestDB(t)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	imageRef := "registry.example.com/team/api:2.0.0"
	repository := "registry.example.com/team/api"
	imageID := "sha256:team-api"
	imageDigest := digest.FromString("team-api-digest").String()

	server := newImagePullServerWithObserver(t, map[string]dockertypesimage.InspectResponse{
		imageRef: {
			ID:          imageID,
			RepoTags:    []string{imageRef},
			RepoDigests: []string{repository + "@" + imageDigest},
		},
	}, nil)

	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
	eventService := event.NewEventService(db, nil, nil)
	imageUpdateService := imageupdate.NewImageUpdateService(db, nil, nil, dockerService, nil, nil, nil)
	imageService := image.NewImageService(db, dockerService, nil, imageUpdateService, nil, eventService, settingsService, nil)
	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		imageService,
		dockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{
		ID:             "sha256:old-api",
		Repository:     repository,
		Tag:            "2.0.0",
		HasUpdate:      true,
		UpdateType:     imageupdate.UpdateTypeDigest,
		CurrentVersion: "2.0.0",
		CheckTime:      time.Now().UTC().Add(-time.Hour),
	}).Error)

	require.NoError(
		t,
		svc.composeCoordinator.EnsureImagesPresent(
			ctx,
			&types.Project{
				Services: types.Services{
					"api": {
						Image:      imageRef,
						PullPolicy: types.PullPolicyAlways,
					},
				},
			},
			io.Discard,
			svc.deployment.ImageOperations(
				nil,
				nil,
			),
		),
	)

	// sha256:old-api may still be in use by another container — pulling for one container
	// must not clear it (fixes #2453).
	var oldRecord imageupdate.ImageUpdateRecord
	require.NoError(t, db.WithContext(ctx).Where("id = ?", "sha256:old-api").First(&oldRecord).Error)
	assert.True(t, oldRecord.HasUpdate)

	var currentRecord imageupdate.ImageUpdateRecord
	require.NoError(t, db.WithContext(ctx).Where("id = ?", imageID).First(&currentRecord).Error)
	assert.False(t, currentRecord.HasUpdate)
	assert.Equal(t, imageDigest, mo.PointerToOption(currentRecord.LatestDigest).OrEmpty())
}

func TestProjectService_PullImageForService_UpdatesCurrentImageRecordAfterPull(t *testing.T) {
	ctx := t.Context()
	db := setupProjectTestDB(t)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	imageRef := "registry.example.com/team/worker:3.1.4"
	repository := "registry.example.com/team/worker"
	imageID := "sha256:team-worker"
	imageDigest := digest.FromString("team-worker-digest").String()

	server := newImagePullServerWithObserver(t, map[string]dockertypesimage.InspectResponse{
		imageRef: {
			ID:          imageID,
			RepoTags:    []string{imageRef},
			RepoDigests: []string{repository + "@" + imageDigest},
		},
	}, nil)

	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
	eventService := event.NewEventService(db, nil, nil)
	imageUpdateService := imageupdate.NewImageUpdateService(db, nil, nil, dockerService, nil, nil, nil)
	imageService := image.NewImageService(db, dockerService, nil, imageUpdateService, nil, eventService, settingsService, nil)
	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		imageService,
		dockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{
		ID:             "sha256:old-worker",
		Repository:     repository,
		Tag:            "3.1.4",
		HasUpdate:      true,
		UpdateType:     imageupdate.UpdateTypeDigest,
		CurrentVersion: "3.1.4",
		CheckTime:      time.Now().UTC().Add(-time.Hour),
	}).Error)

	require.NoError(t, svc.deployment.ImageOperations(nil, nil).Pull(ctx, imageRef, io.Discard))

	// sha256:old-worker may still be in use by another container — must not be cleared (fixes #2453).
	var oldRecord imageupdate.ImageUpdateRecord
	require.NoError(t, db.WithContext(ctx).Where("id = ?", "sha256:old-worker").First(&oldRecord).Error)
	assert.True(t, oldRecord.HasUpdate)

	var currentRecord imageupdate.ImageUpdateRecord
	require.NoError(t, db.WithContext(ctx).Where("id = ?", imageID).First(&currentRecord).Error)
	assert.False(t, currentRecord.HasUpdate)
	assert.Equal(t, imageDigest, mo.PointerToOption(currentRecord.LatestDigest).OrEmpty())
}

func TestProjectService_ComposePullSelectedServices_ReconcilesOnlyOnSuccess(t *testing.T) {
	ctx := t.Context()
	db := setupProjectTestDB(t)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	privateImageRef := "registry.example.com/team/app:9.9.9"
	privateRepository := "registry.example.com/team/app"
	privateImageID := "sha256:team-app-compose"
	privateImageDigest := digest.FromString("team-app-compose-digest").String()
	publicImageRef := "docker.io/library/nginx:1.27"
	publicRepository := "docker.io/library/nginx"
	publicImageID := "sha256:nginx-compose"
	publicImageDigest := digest.FromString("nginx-compose-digest").String()

	pullsByRef := map[string]int{}
	authHeadersByRef := map[string]string{}
	server := newImagePullServerWithObserver(t, map[string]dockertypesimage.InspectResponse{
		privateImageRef: {
			ID:          privateImageID,
			RepoTags:    []string{privateImageRef},
			RepoDigests: []string{privateRepository + "@" + privateImageDigest},
		},
		publicImageRef: {
			ID:          publicImageID,
			RepoTags:    []string{publicImageRef},
			RepoDigests: []string{publicRepository + "@" + publicImageDigest},
		},
	}, func(fullRef, authHeader string) {
		pullsByRef[fullRef]++
		authHeadersByRef[fullRef] = authHeader
	})

	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
	eventService := event.NewEventService(db, nil, nil)
	imageUpdateService := imageupdate.NewImageUpdateService(db, nil, nil, dockerService, nil, nil, nil)
	imageService := image.NewImageService(db, dockerService, nil, imageUpdateService, nil, eventService, settingsService, nil)
	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		imageService,
		dockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	projectDef := &types.Project{
		Name: "compose-selected",
		Services: types.Services{
			"app": {
				Name:  "app",
				Image: privateImageRef,
			},
			"app-copy": {
				Name:  "app-copy",
				Image: privateImageRef,
			},
			"sidecar": {
				Name:  "sidecar",
				Image: publicImageRef,
			},
			"builder": {
				Name:  "builder",
				Build: &types.BuildConfig{Context: "."},
			},
		},
	}

	now := time.Now().UTC().Add(-time.Hour)
	require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{
		ID:             "sha256:selected-old",
		Repository:     privateRepository,
		Tag:            "9.9.9",
		HasUpdate:      true,
		UpdateType:     imageupdate.UpdateTypeDigest,
		CurrentVersion: "9.9.9",
		CheckTime:      now,
	}).Error)
	require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{
		ID:             "sha256:sidecar-old",
		Repository:     publicRepository,
		Tag:            "1.27",
		HasUpdate:      true,
		UpdateType:     imageupdate.UpdateTypeDigest,
		CurrentVersion: "1.27",
		CheckTime:      now,
	}).Error)

	credentials := []containerregistry.Credential{{
		URL:      "https://registry.example.com",
		Username: "arcane-user",
		Token:    "arcane-token",
		Enabled:  true,
	}}

	require.NoError(t, svc.composeCoordinator.PullServices(ctx, projectDef, []string{"app", "app-copy", "sidecar", "builder"}, svc.deployment.ImageOperations(nil, credentials), nil))
	assert.Equal(t, 1, pullsByRef[privateImageRef], "duplicate service refs should only be pulled once")
	assert.Equal(t, 1, pullsByRef[publicImageRef], "selected public image should still be pulled")
	assert.Len(t, pullsByRef, 2, "build-backed services should not trigger image pulls")

	privateAuth := decodeRegistryAuth(t, authHeadersByRef[privateImageRef])
	assert.Equal(t, "arcane-user", privateAuth.Username)
	assert.Equal(t, "arcane-token", privateAuth.Password)
	assert.Equal(t, "registry.example.com", privateAuth.ServerAddress)
	assert.Empty(t, authHeadersByRef[publicImageRef], "public image pull should not receive unrelated registry auth")

	// sha256:selected-old may still be used by another container — must not be cleared (fixes #2453).
	var selectedRecord imageupdate.ImageUpdateRecord
	require.NoError(t, db.WithContext(ctx).Where("id = ?", "sha256:selected-old").First(&selectedRecord).Error)
	assert.True(t, selectedRecord.HasUpdate)

	var sidecarRecord imageupdate.ImageUpdateRecord
	require.NoError(t, db.WithContext(ctx).Where("id = ?", "sha256:sidecar-old").First(&sidecarRecord).Error)
	assert.True(t, sidecarRecord.HasUpdate)

	var privateCurrentRecord imageupdate.ImageUpdateRecord
	require.NoError(t, db.WithContext(ctx).Where("id = ?", privateImageID).First(&privateCurrentRecord).Error)
	assert.False(t, privateCurrentRecord.HasUpdate)
	assert.Equal(t, privateImageDigest, mo.PointerToOption(privateCurrentRecord.LatestDigest).OrEmpty())

	var publicCurrentRecord imageupdate.ImageUpdateRecord
	require.NoError(t, db.WithContext(ctx).Where("id = ?", publicImageID).First(&publicCurrentRecord).Error)
	assert.False(t, publicCurrentRecord.HasUpdate)
	assert.Equal(t, publicImageDigest, mo.PointerToOption(publicCurrentRecord.LatestDigest).OrEmpty())
}

func TestProjectService_ComposePullSelectedServices_LeavesRecordsWhenPullFails(t *testing.T) {
	ctx := t.Context()
	db := setupProjectTestDB(t)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	imageRef := "registry.example.com/team/app:9.9.9"
	repository := "registry.example.com/team/app"

	failingServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if strings.HasSuffix(r.URL.Path, "/images/create") {
			http.Error(w, "pull failed", http.StatusUnauthorized)
			return
		}
		http.NotFound(w, r)
	}))
	t.Cleanup(failingServer.Close)

	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, failingServer)}
	imageUpdateService := imageupdate.NewImageUpdateService(db, nil, nil, dockerService, nil, nil, nil)
	imageService := image.NewImageService(db, dockerService, nil, imageUpdateService, nil, event.NewEventService(db, nil, nil), settingsService, nil)
	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		imageService,
		dockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	projectDef := &types.Project{
		Name: "compose-selected",
		Services: types.Services{
			"app": {
				Name:  "app",
				Image: imageRef,
			},
		},
	}

	require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{
		ID:             "sha256:selected-old",
		Repository:     repository,
		Tag:            "9.9.9",
		HasUpdate:      true,
		UpdateType:     imageupdate.UpdateTypeDigest,
		CurrentVersion: "9.9.9",
		CheckTime:      time.Now().UTC().Add(-time.Hour),
	}).Error)

	err = svc.composeCoordinator.PullServices(ctx, projectDef, []string{"app"}, svc.deployment.ImageOperations(nil, nil), nil)
	require.Error(t, err)
	require.ErrorContains(t, err, "failed to pull image")

	var selectedRecord imageupdate.ImageUpdateRecord
	require.NoError(t, db.WithContext(ctx).Where("id = ?", "sha256:selected-old").First(&selectedRecord).Error)
	assert.True(t, selectedRecord.HasUpdate)

	var count int64
	require.NoError(t, db.WithContext(ctx).Model(&imageupdate.ImageUpdateRecord{}).Where("id = ?", "sha256:team-app-compose").Count(&count).Error)
	assert.Zero(t, count)
}

func TestProjectService_UpdateProjectServicesHardFailsWhenPullFails(t *testing.T) {
	ctx := t.Context()
	db := setupProjectTestDB(t)
	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))

	imageRef := "registry.example.com/team/app:9.9.9"
	failingServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if strings.HasSuffix(r.URL.Path, "/images/create") {
			http.Error(w, "compose pull failed", http.StatusUnauthorized)
			return
		}
		http.NotFound(w, r)
	}))
	t.Cleanup(failingServer.Close)

	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, failingServer)}
	imageUpdateService := imageupdate.NewImageUpdateService(db, nil, nil, dockerService, nil, nil, nil)
	imageService := image.NewImageService(db, dockerService, nil, imageUpdateService, nil, event.NewEventService(db, nil, nil), settingsService, nil)

	projectPath := createComposeProjectDir(t, projectsDir, "compose-update-pull-fail")
	require.NoError(
		t,
		os.WriteFile(
			filepath.Join(
				projectPath,
				"compose.yaml",
			),
			[]byte(
				"services:\n  app:\n    image: "+imageRef+"\n    labels:\n      com.getarcaneapp.arcane.updater.strategy: digest\n",
			),
			0o644,
		),
	)

	projectRecord := &Project{
		ID:      "project-update-pull-fail",
		Name:    "compose-update-pull-fail",
		DirName: new("compose-update-pull-fail"),
		Path:    projectPath,
		Status:  ProjectStatusRunning,
	}
	require.NoError(t, db.Create(projectRecord).Error)
	require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{
		ID:             "sha256:selected-old",
		Repository:     "registry.example.com/team/app",
		Tag:            "9.9.9",
		HasUpdate:      true,
		UpdateType:     imageupdate.UpdateTypeDigest,
		CurrentVersion: "9.9.9",
		CheckTime:      time.Now().UTC().Add(-time.Hour),
	}).Error)

	originalComposeUp := composeUpProjectServices
	t.Cleanup(func() {
		composeUpProjectServices = originalComposeUp
	})
	upCalled := false
	composeUpProjectServices = func(context.Context, *types.Project, []string, bool, bool, bool, map[string]dockerregistry.AuthConfig, time.Duration) error {
		upCalled = true
		return errors.New("compose up should not run")
	}

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		imageService,
		dockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	err = svc.UpdateProjectServices(ctx, projectRecord.ID, []string{"app"}, usertypes.SystemUser, true)
	require.Error(t, err)
	require.ErrorContains(t, err, "pull updated service images")
	assert.False(t, upCalled, "compose up must not run after a pull failure")

	var persistedProject Project
	require.NoError(t, db.WithContext(ctx).Where("id = ?", projectRecord.ID).First(&persistedProject).Error)
	assert.Equal(t, ProjectStatusRunning, persistedProject.Status)

	var persistedRecord imageupdate.ImageUpdateRecord
	require.NoError(t, db.WithContext(ctx).Where("id = ?", "sha256:selected-old").First(&persistedRecord).Error)
	assert.True(t, persistedRecord.HasUpdate)
}

func TestProjectService_UpdateProjectServicesForcesRecreate(t *testing.T) {
	ctx := t.Context()
	db := setupProjectTestDB(t)
	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))

	imageRef := "registry.example.com/team/app:9.9.9"
	repository := "registry.example.com/team/app"
	imageID := "sha256:project-update-force"
	imageDigest := digest.FromString("project-update-force-digest").String()

	server := newImagePullServerWithObserver(t, map[string]dockertypesimage.InspectResponse{
		imageRef: {
			ID:          imageID,
			RepoTags:    []string{imageRef},
			RepoDigests: []string{repository + "@" + imageDigest},
		},
	}, func(fullRef, _ string) {
		assert.Equal(t, imageRef, fullRef, "namespace dependents must not be pulled")
	})

	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
	imageUpdateService := imageupdate.NewImageUpdateService(db, nil, nil, dockerService, nil, nil, nil)
	eventService := event.NewEventService(db, nil, nil)
	imageService := image.NewImageService(db, dockerService, nil, imageUpdateService, nil, eventService, settingsService, nil)

	projectPath := createComposeProjectDir(t, projectsDir, "compose-update-force")
	require.NoError(
		t,
		os.WriteFile(
			filepath.Join(
				projectPath,
				"compose.yaml",
			),
			[]byte(
				"services:\n  app:\n    image: "+imageRef+"\n    labels:\n      com.getarcaneapp.arcane.updater.strategy: digest\n  sidecar:\n    image: "+
					"busybox:latest\n    network_mode: service:app\n  dormant:\n    image: busybox:latest\n    network_mode: "+
					"service:app\n  never:\n    image: busybox:latest\n    pid: service:app\n  gated:\n    image: "+
					"busybox:latest\n    network_mode: service:app\n    profiles: [extra]\n  unrelated:\n    image: "+
					"busybox:latest\n",
			),
			0o644,
		),
	)

	composeContainer := func(service string, state container.ContainerState) container.Summary {
		return container.Summary{
			ID:     service + "-container",
			Names:  []string{"/compose-update-force-" + service + "-1"},
			State:  state,
			Labels: map[string]string{api.ProjectLabel: "compose-update-force", api.ServiceLabel: service, api.ConfigHashLabel: service + "-hash"},
		}
	}
	runtimeServer := newProjectRuntimeDockerServer(t, []container.Summary{
		composeContainer("app", container.StateRunning),
		composeContainer("sidecar", container.StateRunning),
		composeContainer("dormant", container.StateExited),
	})
	t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURL(t, runtimeServer.URL))

	projectRecord := &Project{
		ID:      "project-update-force",
		Name:    "compose-update-force",
		DirName: new("compose-update-force"),
		Path:    projectPath,
		Status:  ProjectStatusRunning,
	}
	require.NoError(t, db.Create(projectRecord).Error)

	originalComposeStop := composeStopProjectServices
	originalComposeUp := composeUpProjectServices
	t.Cleanup(func() {
		composeStopProjectServices = originalComposeStop
		composeUpProjectServices = originalComposeUp
	})
	var stopped []string
	composeStopProjectServices = func(_ context.Context, _ *types.Project, services []string) error {
		stopped = services
		return nil
	}
	upCalled := false
	forceRecreate := false
	composeUpProjectServices = func(
		_ context.Context,
		selected *types.Project,
		services []string,
		removeOrphans, force, _ bool,
		_ map[string]dockerregistry.AuthConfig,
		_ time.Duration,
	) error {
		assert.True(t, eventService.ShouldSuppressDaemonEvent("container", "replacement", "app", selected.Name))
		assert.False(t, eventService.ShouldSuppressDaemonEvent("image", "pulled-image", "", ""))
		upCalled = true
		assert.Equal(t, []string{"app", "dormant", "sidecar"}, selected.ServiceNames(), "stopped dependents stay in the model for recreation")
		forceRecreate = force
		assert.Equal(t, []string{"app", "sidecar"}, services, "stopped dependents are not started")
		assert.False(t, removeOrphans)
		return errors.New("compose up failed after assertion")
	}

	svc := NewProjectService(db, settingsService, eventService, imageService, dockerService, testBuildBuilder{}, nil, nil, config.Load(), kv.NewKVService(db), testRegistryCredentials)
	err = svc.UpdateProjectServices(ctx, projectRecord.ID, []string{"app"}, usertypes.SystemUser, true)
	require.Error(t, err)
	assert.True(t, eventService.ShouldSuppressDaemonEvent("container", "replacement", "app", "compose-update-force"), "failed updates retain correlation through rollback grace")
	assert.False(t, eventService.ShouldSuppressDaemonEvent("container", "unrelated", "unrelated", "other-project"))
	assert.True(t, upCalled)
	assert.Equal(t, []string{"app", "sidecar"}, stopped)
	assert.True(t, forceRecreate, "service updates must force recreate after pulling the updated image")
}

type fakeProjectVolumeRenameMigration struct {
	applyCalled    bool
	commitCalled   bool
	rollbackCalled bool
	applyErr       error
	commitErr      error
	rollbackErr    error
}

func (m *fakeProjectVolumeRenameMigration) Apply(context.Context) error {
	m.applyCalled = true
	return m.applyErr
}

func (m *fakeProjectVolumeRenameMigration) Rollback(context.Context) error {
	m.rollbackCalled = true
	return m.rollbackErr
}

func (m *fakeProjectVolumeRenameMigration) Commit(context.Context) error {
	m.commitCalled = true
	return m.commitErr
}

func TestProjectService_UpdateProject_RenameFailsWhenVolumeMigrationPreparationFails(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))

	eventService := event.NewEventService(db, nil, nil)
	dockerServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case strings.HasSuffix(r.URL.Path, "/_ping"):
			_, _ = io.WriteString(w, "OK")
		case strings.HasSuffix(r.URL.Path, "/version"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode(map[string]string{
				"ApiVersion":    "1.41",
				"MinAPIVersion": "1.24",
				"Version":       "24.0.0",
			})) {
				return
			}
		case strings.HasSuffix(r.URL.Path, "/containers/json"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode([]container.Summary{})) {
				return
			}
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/bar_data"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode(map[string]any{
				"Name": "bar_data",
			})) {
				return
			}
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(dockerServer.Close)
	t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURL(t, dockerServer.URL))

	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, dockerServer)}
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		dockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	originalDirName := "Foo"
	originalPath := createComposeProjectDir(t, projectsDir, originalDirName)
	require.NoError(
		t,
		os.WriteFile(
			filepath.Join(
				originalPath,
				"compose.yaml",
			),
			[]byte(
				"services:\n  app:\n    image: nginx:alpine\n    volumes:\n      - data:/data\nvolumes:\n  data:\n    driver: local\n",
			),
			0o644,
		),
	)

	project := &Project{
		ID:      "proj-volume-conflict",
		Name:    "Foo",
		DirName: &originalDirName,
		Path:    originalPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	_, err = svc.UpdateProject(ctx, project.ID, new("bar"), nil, nil, nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})

	require.Error(t, err)
	assert.Contains(t, err.Error(), "target volume already exists")
	assert.DirExists(t, originalPath)
	assert.NoDirExists(t, filepath.Join(projectsDir, "bar"))

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	assert.Equal(t, "Foo", fromDB.Name)
	assert.Equal(t, originalPath, fromDB.Path)
}

func TestProjectService_ApplyProjectUpdateWithRenameJournal_AppliesVolumeMigrationWhenNameChanges(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	migration := &fakeProjectVolumeRenameMigration{}

	originalDirName := "Foo"
	originalPath := createComposeProjectDir(t, projectsDir, originalDirName)

	project := &Project{
		ID:      "proj-volume-success",
		Name:    "Foo",
		DirName: &originalDirName,
		Path:    originalPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	projectForUpdate := *project
	err = svc.applyProjectUpdate(ctx, &projectForUpdate, "bar", projectsDir, nil, nil, nil, migration, nil)
	require.NoError(t, err)

	assert.True(t, migration.applyCalled)
	assert.True(t, migration.commitCalled)
	assert.False(t, migration.rollbackCalled)
	assert.Equal(t, "bar", projectForUpdate.Name)
	assert.DirExists(t, filepath.Join(projectsDir, "bar"))
	assert.NoDirExists(t, originalPath)

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	assert.Equal(t, "bar", fromDB.Name)
	assert.Equal(t, filepath.Join(projectsDir, "bar"), fromDB.Path)
}

func TestProjectService_PrepareProjectRenameVolumeMigrationForUpdate_UsesComposePreview(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))

	dockerServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
			http.NotFound(w, r)
		case strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode(map[string]any{
				"Name":   "nginx_data",
				"Driver": "local",
				"Labels": map[string]string{
					api.ProjectLabel: "nginx",
					api.VolumeLabel:  "data",
				},
			})) {
				return
			}
		case strings.HasSuffix(r.URL.Path, "/containers/json"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode([]container.Summary{})) {
				return
			}
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(dockerServer.Close)

	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, dockerServer)}
	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		dockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	projectPath := filepath.Join(projectsDir, "nginx")
	require.NoError(t, os.MkdirAll(projectPath, 0o755))
	oldCompose := "services:\n  app:\n    image: nginx:alpine\n    volumes:\n      - data:/data\nvolumes:\n  data:\n    driver: local\n"
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(oldCompose), 0o644))

	project := &Project{
		ID:      "proj-preview-volume-rename",
		Name:    "nginx",
		DirName: new("nginx"),
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}

	t.Run("skips volume made explicit in pending compose", func(t *testing.T) {
		newCompose := "services:\n  app:\n    image: nginx:alpine\n    volumes:\n      - data:/data\nvolumes:\n  data:\n    name: fixed-data\n"

		migration, prepareErr := svc.prepareProjectRenameVolumeMigration(ctx, project, "web", projectsDir, &newCompose, nil, nil)

		require.NoError(t, prepareErr)
		require.Nil(t, migration)
		bytes, readErr := os.ReadFile(filepath.Join(projectPath, "compose.yaml"))
		require.NoError(t, readErr)
		require.Equal(t, oldCompose, string(bytes))
		require.Empty(t, projectUpdatePreviewDirs(t, projectsDir))
	})

	t.Run("plans unchanged auto-managed volume from pending compose", func(t *testing.T) {
		newCompose := "services:\n  app:\n    image: nginx:alpine\n    volumes:\n      - data:/data\nvolumes:\n  data:\n    driver: local\n"

		migration, prepareErr := svc.prepareProjectRenameVolumeMigration(ctx, project, "web", projectsDir, &newCompose, nil, nil)

		require.NoError(t, prepareErr)
		require.NotNil(t, migration)
		journalSource, ok := migration.(volumetypes.JournalSource)
		require.True(t, ok)
		journalVolumes := journalSource.JournalVolumes()
		require.Len(t, journalVolumes, 1)
		require.Equal(t, "data", journalVolumes[0].Key)
		require.Equal(t, "nginx_data", journalVolumes[0].OldName)
		require.Equal(t, "web_data", journalVolumes[0].NewName)
		require.Empty(t, projectUpdatePreviewDirs(t, projectsDir))
	})

	t.Run("plans auto-managed volume when pending compose name renames project", func(t *testing.T) {
		newCompose := "name: web\nservices:\n  app:\n    image: nginx:alpine\n    volumes:\n      - data:/data\nvolumes:\n  data:\n    driver: local\n"

		migration, prepareErr := svc.prepareProjectRenameVolumeMigration(ctx, project, "web", projectsDir, &newCompose, nil, nil)

		require.NoError(t, prepareErr)
		require.NotNil(t, migration)
		journalSource, ok := migration.(volumetypes.JournalSource)
		require.True(t, ok)
		journalVolumes := journalSource.JournalVolumes()
		require.Len(t, journalVolumes, 1)
		require.Equal(t, "data", journalVolumes[0].Key)
		require.Equal(t, "nginx_data", journalVolumes[0].OldName)
		require.Equal(t, "web_data", journalVolumes[0].NewName)
		require.Empty(t, projectUpdatePreviewDirs(t, projectsDir))
	})

	t.Run("plans interpolated explicit name from pending compose", func(t *testing.T) {
		newCompose := "services:\n  app:\n    image: nginx:alpine\n    volumes:\n      - data:/data\nvolumes:\n  data:\n    name: ${DATA_VOLUME:-nginx_data}\n"

		migration, prepareErr := svc.prepareProjectRenameVolumeMigration(ctx, project, "web", projectsDir, &newCompose, nil, nil)

		require.NoError(t, prepareErr)
		require.NotNil(t, migration)
		journalSource, ok := migration.(volumetypes.JournalSource)
		require.True(t, ok)
		journalVolumes := journalSource.JournalVolumes()
		require.Len(t, journalVolumes, 1)
		require.Equal(t, "data", journalVolumes[0].Key)
		require.Equal(t, "nginx_data", journalVolumes[0].OldName)
		require.Equal(t, "web_data", journalVolumes[0].NewName)
		require.Empty(t, projectUpdatePreviewDirs(t, projectsDir))
	})
}

func TestProjectService_ApplyProjectUpdateWithRenameJournal_RollsBackVolumeMigrationWhenProjectSaveFails(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	migration := &fakeProjectVolumeRenameMigration{}

	require.NoError(t, db.Callback().Update().Before("gorm:update").Register("arcane_test_project_save_failure", func(tx *gorm.DB) {
		if tx.Statement.Schema != nil && tx.Statement.Schema.Name == "Project" {
			_ = tx.AddError(errors.New("forced project save failure"))
		}
	}))

	originalDirName := "Foo"
	originalPath := createComposeProjectDir(t, projectsDir, originalDirName)

	project := &Project{
		ID:      "proj-volume-save-fail",
		Name:    "Foo",
		DirName: &originalDirName,
		Path:    originalPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	projectForUpdate := *project
	err = svc.applyProjectUpdate(ctx, &projectForUpdate, "bar", projectsDir, nil, nil, nil, migration, nil)
	require.Error(t, err)
	assert.Contains(t, err.Error(), "forced project save failure")
	assert.True(t, migration.applyCalled)
	assert.False(t, migration.commitCalled)
	assert.True(t, migration.rollbackCalled)
}

func TestProjectService_ApplyProjectUpdateWithRenameJournal_SucceedsCommittedRenameWhenSourceCleanupFails(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	migration := &fakeProjectVolumeRenameMigration{
		commitErr: errors.New("source cleanup failed"),
	}

	originalDirName := "Foo"
	originalPath := createComposeProjectDir(t, projectsDir, originalDirName)

	project := &Project{
		ID:      "proj-volume-cleanup-fail",
		Name:    "Foo",
		DirName: &originalDirName,
		Path:    originalPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	projectForUpdate := *project
	err = svc.applyProjectUpdate(ctx, &projectForUpdate, "bar", projectsDir, nil, nil, nil, migration, nil)
	require.NoError(t, err)
	require.True(t, migration.applyCalled)
	require.True(t, migration.commitCalled)
	require.False(t, migration.rollbackCalled)
	require.NoDirExists(t, originalPath)
	require.DirExists(t, filepath.Join(projectsDir, "bar"))

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	require.Equal(t, "bar", fromDB.Name)
	require.Equal(t, filepath.Join(projectsDir, "bar"), fromDB.Path)
}

func TestProjectService_UpdateProject_ClearsJournalForNonRenameWhenRecoveryDockerUnavailable(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))

	eventService := event.NewEventService(db, nil, nil)
	kvService := kv.NewKVService(db)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)

	oldDir := "nginx"
	projectPath := createComposeProjectDir(t, projectsDir, oldDir)
	project := &Project{
		ID:      "proj-non-rename-recovery-docker-unavailable",
		Name:    "nginx",
		DirName: &oldDir,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    projectPath,
		NewPath:    filepath.Join(projectsDir, "web"),
		OldDirName: &oldDir,
		NewDirName: "web",
		Phase:      projecttypes.RenameJournalPhaseTargetsCopied,
		Volumes: []volumetypes.JournalVolume{
			{
				Key:     "data",
				OldName: "nginx_data",
				NewName: "web_data",
			},
		},
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	envContent := "FOO=bar\n"
	updated, err := svc.UpdateProject(ctx, project.ID, nil, nil, &envContent, nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})

	require.NoError(t, err)
	require.Equal(t, "nginx", updated.Name)

	envBytes, err := os.ReadFile(filepath.Join(projectPath, ".env"))
	require.NoError(t, err)
	require.Equal(t, envContent, string(envBytes))

	_, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok)
}

func TestProjectService_UpdateProject_AllowsRenameAfterJournalRecoveryWithoutDockerService(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))

	eventService := event.NewEventService(db, nil, nil)
	kvService := kv.NewKVService(db)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		&docker.DockerClientService{Client: newTestDockerClient(t, configureProjectRuntimeDocker(t, nil))},
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)

	oldDir := "nginx"
	projectPath := createComposeProjectDir(t, projectsDir, oldDir)
	project := &Project{
		ID:      "proj-rename-recovery-docker-unavailable",
		Name:    "nginx",
		DirName: &oldDir,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    projectPath,
		NewPath:    filepath.Join(projectsDir, "web"),
		OldDirName: &oldDir,
		NewDirName: "web",
		Phase:      projecttypes.RenameJournalPhaseTargetsCopied,
		Volumes: []volumetypes.JournalVolume{
			{
				Key:     "data",
				OldName: "nginx_data",
				NewName: "web_data",
			},
		},
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	updated, err := svc.UpdateProject(ctx, project.ID, new("web"), nil, nil, nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})

	require.NoError(t, err)
	require.NotNil(t, updated)
	require.Equal(t, "web", updated.Name)
	require.NoDirExists(t, projectPath)
	require.DirExists(t, filepath.Join(projectsDir, "web"))

	_, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok)
}

func TestProjectService_UpdateProject_RenamesDirectoryWhenNameChanges(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		&docker.DockerClientService{Client: newTestDockerClient(t, configureProjectRuntimeDocker(t, nil))},
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	originalDirName := "Foo"
	originalPath := createComposeProjectDir(t, projectsDir, originalDirName)

	project := &Project{
		ID:      "proj-1",
		Name:    "Foo",
		DirName: &originalDirName,
		Path:    originalPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	updated, err := svc.UpdateProject(ctx, project.ID, new("bar"), nil, nil, nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})

	require.NoError(t, err)

	expectedPath := filepath.Join(projectsDir, "bar")
	assert.Equal(t, "bar", updated.Name)
	assert.Equal(t, expectedPath, updated.Path)
	require.NotNil(t, updated.DirName)
	assert.Equal(t, "bar", *updated.DirName)
	assert.NoDirExists(t, originalPath)
	assert.DirExists(t, expectedPath)

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	assert.Equal(t, "bar", fromDB.Name)
	assert.Equal(t, expectedPath, fromDB.Path)
	require.NotNil(t, fromDB.DirName)
	assert.Equal(t, "bar", *fromDB.DirName)
}

func TestProjectService_UpdateProject_RenameFailsWhenTargetDirectoryExists(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		&docker.DockerClientService{Client: newTestDockerClient(t, configureProjectRuntimeDocker(t, nil))},
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	originalDirName := "Foo"
	originalPath := createComposeProjectDir(t, projectsDir, originalDirName)

	targetPath := filepath.Join(projectsDir, "bar")
	require.NoError(t, os.MkdirAll(targetPath, 0o755))

	project := &Project{
		ID:      "proj-2",
		Name:    "Foo",
		DirName: &originalDirName,
		Path:    originalPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	_, err = svc.UpdateProject(ctx, project.ID, new("bar"), nil, nil, nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})

	require.Error(t, err)
	assert.Contains(t, err.Error(), "project directory already exists")
	assert.DirExists(t, originalPath)
	assert.DirExists(t, targetPath)

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	assert.Equal(t, "Foo", fromDB.Name)
	assert.Equal(t, originalPath, fromDB.Path)
	require.NotNil(t, fromDB.DirName)
	assert.Equal(t, "Foo", *fromDB.DirName)
}

func TestProjectService_UpdateProject_RenameFailsWhenProjectRunning(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	originalDirName := "Foo"
	originalPath := filepath.Join(projectsDir, originalDirName)
	require.NoError(t, os.MkdirAll(originalPath, 0o755))

	project := &Project{
		ID:      "proj-3",
		Name:    "Foo",
		DirName: &originalDirName,
		Path:    originalPath,
		Status:  ProjectStatusRunning,
	}
	require.NoError(t, db.Create(project).Error)

	_, err = svc.UpdateProject(ctx, project.ID, new("bar"), nil, nil, nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})

	require.Error(t, err)
	assert.Contains(t, err.Error(), "project must be stopped before renaming (current status: running)")
	assert.DirExists(t, originalPath)
	assert.NoDirExists(t, filepath.Join(projectsDir, "bar"))

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	assert.Equal(t, "Foo", fromDB.Name)
	assert.Equal(t, originalPath, fromDB.Path)
	require.NotNil(t, fromDB.DirName)
	assert.Equal(t, "Foo", *fromDB.DirName)
}

func TestProjectService_UpdateProject_RenameRejectsStaleStoppedWhenRuntimeIsRunning(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))

	eventService := event.NewEventService(db, nil, nil)
	server := configureProjectRuntimeDocker(t, []container.Summary{
		{
			ID:     "app-container",
			Names:  []string{"/foo-app-1"},
			Image:  "nginx:alpine",
			State:  container.StateRunning,
			Status: "Up 30 seconds",
			Labels: map[string]string{
				api.ProjectLabel:    "foo",
				api.ServiceLabel:    "app",
				api.ConfigHashLabel: "app-hash",
				api.WorkingDirLabel: filepath.Join(projectsDir, "Foo"),
			},
		},
	})
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		&docker.DockerClientService{Client: newTestDockerClient(t, server)},
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	originalDirName := "Foo"
	originalPath := createComposeProjectDir(t, projectsDir, originalDirName)

	project := &Project{
		ID:      "proj-stale-stopped-running-rename",
		Name:    "Foo",
		DirName: &originalDirName,
		Path:    originalPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	_, err = svc.UpdateProject(ctx, project.ID, new("bar"), nil, nil, nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})

	require.Error(t, err)
	assert.Contains(t, err.Error(), "project must be stopped before renaming (current status: running)")
	assert.DirExists(t, originalPath)
	assert.NoDirExists(t, filepath.Join(projectsDir, "bar"))

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	assert.Equal(t, "Foo", fromDB.Name)
	assert.Equal(t, originalPath, fromDB.Path)
	assert.Equal(t, ProjectStatusStopped, fromDB.Status)
}

func TestProjectService_RecoverStuckProjectStatuses(t *testing.T) {
	tests := []struct {
		name       string
		saved      ProjectStatus
		containers []container.Summary
		want       ProjectStatus
	}{
		{
			name:  "deploying with running containers becomes running",
			saved: ProjectStatusDeploying,
			containers: []container.Summary{
				{
					ID:     "app-container",
					Names:  []string{"/foo-app-1"},
					Image:  "nginx:alpine",
					State:  container.StateRunning,
					Status: "Up 30 seconds",
					Labels: map[string]string{
						api.ProjectLabel: "foo",
						api.ServiceLabel: "app",
					},
				},
			},
			want: ProjectStatusRunning,
		},
		{
			// Compose services without a container are reported as stopped.
			name:  "restarting without containers becomes stopped",
			saved: ProjectStatusRestarting,
			want:  ProjectStatusStopped,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			db := setupProjectTestDB(t)
			ctx := t.Context()

			projectsDir := t.TempDir()
			t.Setenv("PROJECTS_DIRECTORY", projectsDir)

			settingsService, err := newSettingsServiceForTest(t, ctx, db)
			require.NoError(t, err)
			require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))

			server := configureProjectRuntimeDocker(t, tt.containers)
			svc := NewProjectService(
				db,
				settingsService,
				event.NewEventService(db, nil, nil),
				image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
				&docker.DockerClientService{Client: newTestDockerClient(t, server)},
				testBuildBuilder{},
				nil,
				nil,
				config.Load(),
				kv.NewKVService(db),
				testRegistryCredentials,
			)

			dirName := "foo"
			project := &Project{
				ID:      "proj-stuck",
				Name:    "foo",
				DirName: &dirName,
				Path:    createComposeProjectDir(t, projectsDir, dirName),
				Status:  tt.saved,
			}
			require.NoError(t, db.Create(project).Error)

			require.NoError(t, svc.RecoverStuckProjectStatuses(ctx))

			var fromDB Project
			require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
			assert.Equal(t, tt.want, fromDB.Status)
		})
	}
}

func TestProjectService_UpdateProject_RenameResolvesUnknownStoppedStatusBeforeVolumeMigration(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))

	eventService := event.NewEventService(db, nil, nil)
	server := newProjectRuntimeDockerServer(t, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		&docker.DockerClientService{Client: newTestDockerClient(t, server)},
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURL(t, server.URL))

	originalDirName := "Foo"
	originalPath := createComposeProjectDir(t, projectsDir, originalDirName)
	statusReason := "stale runtime status"

	project := &Project{
		ID:           "proj-unknown-stopped-rename",
		Name:         "Foo",
		DirName:      &originalDirName,
		Path:         originalPath,
		Status:       ProjectStatusUnknown,
		StatusReason: &statusReason,
	}
	require.NoError(t, db.Create(project).Error)

	updated, err := svc.UpdateProject(ctx, project.ID, new("bar"), nil, nil, nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})

	require.NoError(t, err)

	expectedPath := filepath.Join(projectsDir, "bar")
	assert.Equal(t, "bar", updated.Name)
	assert.Equal(t, expectedPath, updated.Path)
	assert.Equal(t, ProjectStatusStopped, updated.Status)
	assert.Nil(t, updated.StatusReason)
	assert.Equal(t, 1, updated.ServiceCount)
	assert.Equal(t, 0, updated.RunningCount)
	assert.NoDirExists(t, originalPath)
	assert.DirExists(t, expectedPath)

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	assert.Equal(t, "bar", fromDB.Name)
	assert.Equal(t, expectedPath, fromDB.Path)
	assert.Equal(t, ProjectStatusStopped, fromDB.Status)
	assert.Nil(t, fromDB.StatusReason)
	assert.Equal(t, 1, fromDB.ServiceCount)
	assert.Equal(t, 0, fromDB.RunningCount)
}

func TestProjectService_UpdateProject_RenameRejectsUnknownWhenRuntimeIsRunning(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))

	eventService := event.NewEventService(db, nil, nil)
	server := newProjectRuntimeDockerServer(t, []container.Summary{
		{
			ID:     "app-container",
			Names:  []string{"/foo-app-1"},
			Image:  "nginx:alpine",
			State:  container.StateRunning,
			Status: "Up 30 seconds",
			Labels: map[string]string{
				api.ProjectLabel:    "foo",
				api.ServiceLabel:    "app",
				api.ConfigHashLabel: "app-hash",
				api.WorkingDirLabel: "/host/path/projects/Foo",
			},
		},
	})
	t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURL(t, server.URL))
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		&docker.DockerClientService{Client: newTestDockerClient(t, server)},
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	originalDirName := "Foo"
	originalPath := createComposeProjectDir(t, projectsDir, originalDirName)
	statusReason := "stale runtime status"

	project := &Project{
		ID:           "proj-unknown-running-rename",
		Name:         "Foo",
		DirName:      &originalDirName,
		Path:         originalPath,
		Status:       ProjectStatusUnknown,
		StatusReason: &statusReason,
	}
	require.NoError(t, db.Create(project).Error)

	_, err = svc.UpdateProject(ctx, project.ID, new("bar"), nil, nil, nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})

	require.Error(t, err)
	assert.Contains(t, err.Error(), "project must be stopped before renaming (current status: running)")
	assert.DirExists(t, originalPath)
	assert.NoDirExists(t, filepath.Join(projectsDir, "bar"))

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	assert.Equal(t, "Foo", fromDB.Name)
	assert.Equal(t, originalPath, fromDB.Path)
	assert.Equal(t, ProjectStatusUnknown, fromDB.Status)
	require.NotNil(t, fromDB.StatusReason)
	assert.Equal(t, statusReason, *fromDB.StatusReason)
}

func TestProjectService_UpdateProject_ValidatesComposeUsingExistingProjectName(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "demo"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))

	project := &Project{
		ID:      "proj-compose-name",
		Name:    "demo",
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	compose := `name: ${COMPOSE_PROJECT_NAME}
services:
  app:
    image: nginx:alpine
`
	env := "COMPOSE_PROJECT_NAME=\n"

	updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), new(env), nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})

	require.NoError(t, err)
	require.NotNil(t, updated)
	assert.Equal(t, "demo", updated.Name)
}

func TestProjectService_UpdateProject_AllowsMissingEnvFileDuringComposeValidation(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "env-required"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))

	project := &Project{
		ID:      "proj-env-file",
		Name:    "env-required",
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	compose := `services:
  app:
    image: nginx:alpine
    env_file:
      - .env
`

	updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), nil, nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})

	require.NoError(t, err)
	require.NotNil(t, updated)

	_, statErr := os.Stat(filepath.Join(projectPath, ".env"))
	require.NoError(t, statErr)
}

func TestProjectService_UpdateProject_EnvRetargetWritesExplicitIdenticalComposeToSelectedBase(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "retarget-explicit"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))

	baseContent := "services:\n  base:\n    image: nginx:alpine\n"
	altContent := "services:\n  alt:\n    image: busybox:latest\n"
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(baseContent), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "alt.yaml"), []byte(altContent), 0o644))

	project := &Project{
		ID:      "proj-retarget-explicit",
		Name:    dirName,
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	// An explicit composeContent is authoritative even when it is
	// byte-identical to the previous base: the caller intends the retargeted
	// base to carry this content.
	explicitCompose := baseContent
	_, err = svc.UpdateProject(ctx, project.ID, nil, &explicitCompose, new("COMPOSE_FILE=alt.yaml\n"), nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})
	require.NoError(t, err)

	altOnDisk, readErr := os.ReadFile(filepath.Join(projectPath, "alt.yaml"))
	require.NoError(t, readErr)
	assert.Equal(t, baseContent, string(altOnDisk), "an explicit submission must be written to the newly selected base")

	baseOnDisk, readErr := os.ReadFile(filepath.Join(projectPath, "compose.yaml"))
	require.NoError(t, readErr)
	assert.Equal(t, baseContent, string(baseOnDisk))

	envOnDisk, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
	require.NoError(t, readErr)
	assert.Contains(t, string(envOnDisk), "COMPOSE_FILE=alt.yaml")
}

func TestProjectService_UpdateProject_EnvRetargetWithoutComposePayloadPreservesNewBase(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "retarget-omit"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))

	baseContent := "services:\n  base:\n    image: nginx:alpine\n"
	altContent := "services:\n  alt:\n    image: busybox:latest\n"
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(baseContent), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "alt.yaml"), []byte(altContent), 0o644))

	project := &Project{
		ID:      "proj-retarget-omit",
		Name:    dirName,
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	// Clients omit composeContent when the compose editor is unchanged: an
	// env-only retarget must switch the selection without touching either file.
	_, err = svc.UpdateProject(ctx, project.ID, nil, nil, new("COMPOSE_FILE=alt.yaml\n"), nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})
	require.NoError(t, err)

	altOnDisk, readErr := os.ReadFile(filepath.Join(projectPath, "alt.yaml"))
	require.NoError(t, readErr)
	assert.Equal(t, altContent, string(altOnDisk), "the newly selected base must keep its own content")

	baseOnDisk, readErr := os.ReadFile(filepath.Join(projectPath, "compose.yaml"))
	require.NoError(t, readErr)
	assert.Equal(t, baseContent, string(baseOnDisk))

	envOnDisk, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
	require.NoError(t, readErr)
	assert.Contains(t, string(envOnDisk), "COMPOSE_FILE=alt.yaml")
}

func TestProjectService_UpdateProject_EnvRetargetWritesEditedComposeToSelectedBase(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "retarget-edit"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))

	baseContent := "services:\n  base:\n    image: nginx:alpine\n"
	altContent := "services:\n  alt:\n    image: busybox:latest\n"
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(baseContent), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "alt.yaml"), []byte(altContent), 0o644))

	project := &Project{
		ID:      "proj-retarget-edit",
		Name:    dirName,
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	editedCompose := "services:\n  alt:\n    image: redis:alpine\n"
	_, err = svc.UpdateProject(ctx, project.ID, nil, &editedCompose, new("COMPOSE_FILE=alt.yaml\n"), nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})
	require.NoError(t, err)

	altOnDisk, readErr := os.ReadFile(filepath.Join(projectPath, "alt.yaml"))
	require.NoError(t, readErr)
	assert.Equal(t, editedCompose, string(altOnDisk), "an edited compose must be written to the newly selected base")

	baseOnDisk, readErr := os.ReadFile(filepath.Join(projectPath, "compose.yaml"))
	require.NoError(t, readErr)
	assert.Equal(t, baseContent, string(baseOnDisk))
}

func TestProjectService_UpdateProject_AllowsMissingLocalIncludeDuringComposeValidation(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "include-new"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))

	project := &Project{
		ID:      "proj-missing-include",
		Name:    "include-new",
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	compose := `include:
  - metadata.yaml
services:
  app:
    image: nginx:alpine
`

	updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), nil, nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})

	require.NoError(t, err)
	require.NotNil(t, updated)

	includePath := filepath.Join(projectPath, "metadata.yaml")
	assert.NoFileExists(t, includePath)

	details, err := svc.GetProjectDetails(ctx, project.ID, projecttypes.AllDetails())
	require.NoError(t, err)
	require.Len(t, details.IncludeFiles, 1)
	assert.Equal(t, "metadata.yaml", details.IncludeFiles[0].RelativePath)
}

func TestProjectService_CreateProject_AllowsExternalInclude(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	require.NoError(t, os.WriteFile(filepath.Join(projectsDir, "shared.yaml"), []byte("services: {}\n"), 0o644))

	compose := `include:
  - ../shared.yaml
services:
  app:
    image: nginx:alpine
`

	project, err := svc.CreateProject(ctx, "with-external-include", compose, nil, projecttypes.CreateProjectWorkspaceManifest{}, nil, nil, nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})
	require.NoError(t, err)
	require.NotNil(t, project)
	assert.DirExists(t, filepath.Join(projectsDir, "with-external-include"))
	assert.FileExists(t, filepath.Join(projectsDir, "shared.yaml"))
}

func TestProjectService_UpdateProject_AllowsExternalInclude(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "external-include"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(projectsDir, "shared.yaml"), []byte("services: {}\n"), 0o644))

	project := &Project{
		ID:      "proj-external-include",
		Name:    "external-include",
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	user := usertypes.Actor{ID: "u1", Username: "tester"}

	compose := `include:
  - ../shared.yaml
services:
  app:
    image: nginx:alpine
`
	updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), nil, nil, user)
	require.NoError(t, err)
	require.NotNil(t, updated)

	override := `include:
  - ../shared.yaml
`
	_, err = svc.UpdateProject(ctx, project.ID, nil, nil, nil, new(override), user)
	require.NoError(t, err)
}

func TestProjectService_CreateProject_CommitsWorkspaceAndConfigurationTogether(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()
	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	uploadIndex := 0
	manifest := projecttypes.CreateProjectWorkspaceManifest{FileChanges: []projecttypes.WorkspaceFileChange{{
		Operation: projecttypes.FileOpCreateFile, RelativePath: "config/app.txt", UploadIndex: &uploadIndex,
	}}}

	created, err := svc.CreateProject(
		ctx,
		"atomic-workspace",
		"services:\n  app:\n    image: nginx:alpine\n",
		new("VALUE=one\n"),
		manifest,
		map[int][]byte{0: []byte("workspace content\n")},
		nil,
		nil,
		usertypes.Actor{ID: "u1", Username: "tester"},
	)
	require.NoError(t, err)
	require.NotNil(t, created)
	require.FileExists(t, filepath.Join(created.Path, projects.DefaultComposeFileName))
	require.FileExists(t, filepath.Join(created.Path, ".env"))
	require.FileExists(t, filepath.Join(created.Path, "config", "app.txt"))
	content, err := os.ReadFile(filepath.Join(created.Path, "config", "app.txt"))
	require.NoError(t, err)
	require.Equal(t, "workspace content\n", string(content))

	compose := "services:\n  app:\n    image: nginx:alpine\n"
	user := usertypes.Actor{ID: "u1", Username: "tester"}
	_, err = svc.CreateProject(ctx, "Atomic-Workspace", compose, nil, projecttypes.CreateProjectWorkspaceManifest{}, nil, nil, nil, user)
	require.ErrorIs(t, err, common.ErrConflict)
	_, err = svc.CreateProject(ctx, "atomic-workspace", compose, nil, projecttypes.CreateProjectWorkspaceManifest{}, nil, nil, nil, user, false)
	require.ErrorIs(t, err, common.ErrConflict)
	var count int64
	require.NoError(t, db.WithContext(ctx).Model(&Project{}).Count(&count).Error)
	require.Equal(t, int64(1), count)
	require.NoDirExists(t, filepath.Join(projectsDir, "Atomic-Workspace"))
}

func TestProjectService_CreateProject_RollsBackInvalidWorkspaceManifest(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()
	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	manifest := projecttypes.CreateProjectWorkspaceManifest{FileChanges: []projecttypes.WorkspaceFileChange{{
		Operation: projecttypes.FileOpDelete, RelativePath: "missing.txt",
	}}}

	created, err := svc.CreateProject(
		ctx,
		"invalid-workspace",
		"services:\n  app:\n    image: nginx:alpine\n",
		nil,
		manifest,
		nil,
		nil,
		nil,
		usertypes.Actor{ID: "u1", Username: "tester"},
	)
	require.Error(t, err)
	require.Nil(t, created)
	require.NoDirExists(t, filepath.Join(projectsDir, "invalid-workspace"))

	var count int64
	require.NoError(t, db.Model(&Project{}).Where("name = ?", "invalid-workspace").Count(&count).Error)
	require.Zero(t, count)
}

func TestProjectService_UpdateProject_UsesExistingEnvFileDuringComposeValidation(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "env-existing"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("FOO=bar\n"), 0o600))

	project := &Project{
		ID:      "proj-existing-env-file",
		Name:    "env-existing",
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	compose := `services:
  app:
    image: nginx:alpine
    env_file:
      - .env
`

	updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), nil, nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})

	require.NoError(t, err)
	require.NotNil(t, updated)

	envBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
	require.NoError(t, readErr)
	assert.Equal(t, "FOO=bar\n", string(envBytes))
}

// newProjectServiceForOverrideTest builds a project with a base compose
// file on disk and returns the service, the project record, and the project path.
func newProjectServiceForOverrideTest(t *testing.T, dirName string) (*ProjectService, *Project, string) {
	t.Helper()
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

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

	project := &Project{
		ID:      "proj-" + dirName,
		Name:    dirName,
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	return svc, project, projectPath
}

func TestProjectService_UpdateProject_CreatesOverrideWithDefaultName(t *testing.T) {
	ctx := t.Context()
	svc, project, projectPath := newProjectServiceForOverrideTest(t, "override-create")

	override := "services:\n  app:\n    image: busybox:latest\n"
	_, err := svc.UpdateProject(ctx, project.ID, nil, nil, nil, new(override), usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})
	require.NoError(t, err)

	// A project with no override on disk gets the .yaml default, matching Arcane's
	// compose.yaml base default (not compose.override.yml, candidates[0]).
	overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "compose.override.yaml"))
	require.NoError(t, readErr)
	assert.Equal(t, override, string(overrideBytes))

	details, err := svc.GetProjectDetails(ctx, project.ID, projecttypes.DetailsOptions{IncludeComposeContent: true})
	require.NoError(t, err)
	assert.Equal(t, "compose.override.yaml", details.OverrideFileName)
	assert.Equal(t, override, details.OverrideContent)
}

func TestProjectService_UpdateProject_PreservesExistingOverrideName(t *testing.T) {
	ctx := t.Context()
	svc, project, projectPath := newProjectServiceForOverrideTest(t, "override-preserve")

	// An existing docker-compose.override.yml must keep its name on edit rather
	// than being rewritten to the default compose.override.yaml.
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "docker-compose.override.yml"), []byte("services:\n  app:\n    image: alpine:3\n"), 0o600))

	override := "services:\n  app:\n    image: busybox:latest\n"
	_, err := svc.UpdateProject(ctx, project.ID, nil, nil, nil, new(override), usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})
	require.NoError(t, err)

	overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "docker-compose.override.yml"))
	require.NoError(t, readErr)
	assert.Equal(t, override, string(overrideBytes))
	assert.NoFileExists(t, filepath.Join(projectPath, "compose.override.yaml"))
}

func TestProjectService_UpdateProject_DeletesOverrideOnBlank(t *testing.T) {
	ctx := t.Context()
	svc, project, projectPath := newProjectServiceForOverrideTest(t, "override-delete")

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

	// A non-nil blank override deletes the file so the deploy stops merging it.
	_, err := svc.UpdateProject(ctx, project.ID, nil, nil, nil, new(""), usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})
	require.NoError(t, err)

	assert.NoFileExists(t, overridePath)
}

func TestProjectService_UpdateProject_MergedValidationFailureLeavesDiskUnchanged(t *testing.T) {
	ctx := t.Context()
	baseCompose := "services:\n  app:\n    image: nginx:alpine\n"
	svc, project, projectPath := newProjectServiceForOverrideTest(t, "override-invalid")

	// A new base compose plus a malformed override must fail validation, and the
	// backup/restore must leave both the base and the override untouched on disk.
	newCompose := "services:\n  app:\n    image: nginx:1.27\n"
	badOverride := "services:\n  app:\n    image: \"unterminated\n"
	_, err := svc.UpdateProject(ctx, project.ID, nil, new(newCompose), nil, new(badOverride), usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})
	require.Error(t, err)

	baseBytes, readErr := os.ReadFile(filepath.Join(projectPath, "compose.yaml"))
	require.NoError(t, readErr)
	assert.Equal(t, baseCompose, string(baseBytes))
	assert.NoFileExists(t, filepath.Join(projectPath, "compose.override.yaml"))
}

func TestProjectService_UpdateProject_UsesProvidedEnvContentDuringComposeValidation(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "env-updated"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))

	project := &Project{
		ID:      "proj-new-env-file",
		Name:    "env-updated",
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	compose := `services:
  app:
    image: nginx:alpine
    env_file:
      - .env
`
	env := "FOO=updated\n"

	updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), new(env), nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})

	require.NoError(t, err)
	require.NotNil(t, updated)

	envBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
	require.NoError(t, readErr)
	assert.Equal(t, env, string(envBytes))
}

func TestProjectService_UpdateProject_ReturnsEnvParseErrorDuringComposeValidation(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "env-invalid"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))

	project := &Project{
		ID:      "proj-invalid-env-file",
		Name:    "env-invalid",
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	compose := `services:
  app:
    image: nginx:alpine
    environment:
      - REQUIRED=${REQUIRED}
`
	env := "BROKEN=${UNTERMINATED\n"

	updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), new(env), nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})

	require.Error(t, err)
	assert.Nil(t, updated)
	assert.Contains(t, err.Error(), "invalid compose file: parse provided env content")
	assert.Contains(t, err.Error(), "parse env")
}

func TestProjectService_UpdateProject_UsesGlobalEnvDuringComposeValidation(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "global-env-update"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(projectsDir, projects.GlobalEnvFileName), []byte("DATA_NAS_FOLDER=/srv/media\nMYPATH=/containers/\n"), 0o600))

	project := &Project{
		ID:      "proj-global-env-update",
		Name:    dirName,
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	compose := `services:
  cats:
    image: mikesir87/cats:1.0
    volumes:
      - ${DATA_NAS_FOLDER}:/data
      - ${MYPATH}cats/templates:/app/templates
`

	updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), nil, nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})

	require.NoError(t, err)
	require.NotNil(t, updated)

	composeBytes, readErr := os.ReadFile(filepath.Join(projectPath, "compose.yaml"))
	require.NoError(t, readErr)
	assert.Equal(t, compose, string(composeBytes))
}

func TestProjectService_UpdateProject_DoesNotResolveHostEnvThroughGlobalEnvDuringComposeValidation(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)
	t.Setenv("HOST_ONLY_PATH", "/host/secret")

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "host-env-guard"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(projectsDir, projects.GlobalEnvFileName), []byte("DATA_NAS_FOLDER=${HOST_ONLY_PATH}\n"), 0o600))

	project := &Project{
		ID:      "proj-host-env-guard",
		Name:    dirName,
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	compose := `services:
  app:
    image: nginx:alpine
    volumes:
      - ${DATA_NAS_FOLDER}:/data
`

	updated, err := svc.UpdateProject(ctx, project.ID, nil, new(compose), nil, nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})

	require.Error(t, err)
	assert.Nil(t, updated)
	assert.Contains(t, err.Error(), "invalid compose file")
}

func TestProjectService_UpdateProject_DerivesProjectOverrideEnvWhenGitSourceExists(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "override-edit"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n  app:\n    image: nginx:alpine\n"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\n"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\n"), 0o600))

	project := &Project{
		ID:      "proj-override-edit",
		Name:    "override-edit",
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	updated, err := svc.UpdateProject(ctx, project.ID, nil, nil, new("BASE=git\nLOCAL_ONLY=example\n"), nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})

	require.NoError(t, err)
	require.NotNil(t, updated)

	overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
	require.NoError(t, readErr)
	assert.Equal(t, "LOCAL_ONLY=example\n", string(overrideBytes))

	effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
	require.NoError(t, readErr)
	assert.Contains(t, string(effectiveBytes), "BASE=git\n")
	assert.Contains(t, string(effectiveBytes), "LOCAL_ONLY=example\n")
}

func TestProjectService_UpdateProject_UnchangedGitEnvLeavesFilesUntouched(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "unchanged-git-env"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n  app:\n    image: nginx:alpine\n"), 0o600))

	gitContent := "# git formatting\nBASE=git\n"
	overrideContent := "# local formatting\nTOKEN='$pbkdf2-sha512$310000$XXX'\n"
	effectiveContent := gitContent + overrideContent
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte(effectiveContent), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte(gitContent), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte(overrideContent), 0o600))

	project := &Project{
		ID:      "proj-unchanged-git-env",
		Name:    dirName,
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	updated, err := svc.UpdateProject(ctx, project.ID, nil, nil, &effectiveContent, nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})
	require.NoError(t, err)
	require.NotNil(t, updated)

	effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
	require.NoError(t, readErr)
	assert.Equal(t, effectiveContent, string(effectiveBytes))

	gitBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env.git"))
	require.NoError(t, readErr)
	assert.Equal(t, gitContent, string(gitBytes))

	overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
	require.NoError(t, readErr)
	assert.Equal(t, overrideContent, string(overrideBytes))
}

func TestProjectService_PersistEffectiveEnvContent_RemovesStaleOverrideWithoutGitSource(t *testing.T) {
	projectsDir := t.TempDir()
	projectPath := filepath.Join(projectsDir, "direct-env")
	require.NoError(t, os.MkdirAll(projectPath, 0o755))

	effectiveContent := "TOKEN=current\n"
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte(effectiveContent), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("TOKEN=stale\n"), 0o600))

	require.NoError(t, projectsync.PersistEffectiveEnvContent(t.Context(), projectPath, projectsDir, effectiveContent))

	effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
	require.NoError(t, readErr)
	assert.Equal(t, effectiveContent, string(effectiveBytes))

	_, statErr := os.Stat(filepath.Join(projectPath, "project.env"))
	assert.ErrorIs(t, statErr, os.ErrNotExist)
}

func TestProjectService_PersistEffectiveEnvContent_RemovesStaleGitOverride(t *testing.T) {
	projectsDir := t.TempDir()
	projectPath := filepath.Join(projectsDir, "git-env")
	require.NoError(t, os.MkdirAll(projectPath, 0o755))

	effectiveContent := "BASE=git\nTOKEN=git\n"
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte(effectiveContent), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte(effectiveContent), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("TOKEN=stale\n"), 0o600))

	require.NoError(t, projectsync.PersistEffectiveEnvContent(t.Context(), projectPath, projectsDir, effectiveContent))

	effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
	require.NoError(t, readErr)
	assert.Equal(t, effectiveContent, string(effectiveBytes))

	gitBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env.git"))
	require.NoError(t, readErr)
	assert.Equal(t, effectiveContent, string(gitBytes))

	_, statErr := os.Stat(filepath.Join(projectPath, "project.env"))
	assert.ErrorIs(t, statErr, os.ErrNotExist)
}

func TestProjectService_UpdateProject_DeletingGitBackedKeyFallsBackToGit(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "override-delete"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n  app:\n    image: nginx:alpine\n"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\nTOKEN=local\nLOCAL_ONLY=1\n"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\nTOKEN=git\n"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("TOKEN=local\nLOCAL_ONLY=1\n"), 0o600))

	project := &Project{
		ID:      "proj-override-delete",
		Name:    "override-delete",
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	updated, err := svc.UpdateProject(ctx, project.ID, nil, nil, new("BASE=git\nLOCAL_ONLY=1\n"), nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})

	require.NoError(t, err)
	require.NotNil(t, updated)

	overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
	require.NoError(t, readErr)
	assert.Equal(t, "LOCAL_ONLY=1\n", string(overrideBytes))

	effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
	require.NoError(t, readErr)
	assert.Contains(t, string(effectiveBytes), "BASE=git\n")
	assert.Contains(t, string(effectiveBytes), "TOKEN=git\n")
	assert.Contains(t, string(effectiveBytes), "LOCAL_ONLY=1\n")
	assert.NotContains(t, string(overrideBytes), "TOKEN=")
}

func TestProjectService_ApplyGitSyncProjectFiles_MigratesDirectEnvIntoProjectOverride(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "git-sync-migrate"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n  app:\n    image: nginx:alpine\n"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("TOKEN=stale-local\nLOCAL_ONLY=1\n"), 0o600))

	project := &Project{
		ID:      "proj-git-sync-migrate",
		Name:    "git-sync-migrate",
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	gitEnv := "TOKEN=git\nREMOTE_ONLY=1\n"
	updated, _, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, "services:\n  app:\n    image: nginx:alpine\n", &gitEnv, nil, "", usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})
	require.NoError(t, err)
	require.NotNil(t, updated)

	gitSourceBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env.git"))
	require.NoError(t, readErr)
	assert.Equal(t, gitEnv, string(gitSourceBytes))

	overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
	require.NoError(t, readErr)
	assert.Equal(t, "LOCAL_ONLY=1\n", string(overrideBytes))

	effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
	require.NoError(t, readErr)
	assert.Contains(t, string(effectiveBytes), "TOKEN=git\n")
	assert.Contains(t, string(effectiveBytes), "LOCAL_ONLY=1\n")
	assert.Contains(t, string(effectiveBytes), "REMOTE_ONLY=1\n")
}

func TestProjectService_ApplyGitSyncProjectFiles_PreservesGitEnvSyntax(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "git-sync-env-syntax"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n  app:\n    image: nginx:alpine\n"), 0o600))

	project := &Project{
		ID:      "proj-git-sync-env-syntax",
		Name:    dirName,
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	compose := `services:
  app:
    image: nginx:alpine
    environment:
      CLOUDFLARE_CLIENT_SECRET: ${CLOUDFLARE_CLIENT_SECRET:?set in env}
`
	gitEnv := "# keep git formatting\nZ_LAST=last\nCLOUDFLARE_CLIENT_SECRET=$$pbkdf2-sha512$$310000$$XXX\nQUOTED_SECRET='$pbkdf2-sha512$310000$XXX'\nA_FIRST=first"

	for i := range 2 {
		updated, changed, applyGitSyncProjectFilesErr := svc.ApplyGitSyncProjectFiles(ctx, project.ID, compose, &gitEnv, nil, "", usertypes.Actor{
			ID:       "u1",
			Username: "tester",
		})
		require.NoError(t, applyGitSyncProjectFilesErr)
		require.NotNil(t, updated)
		assert.Equal(t, i == 0, changed)

		effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
		require.NoError(t, readErr)
		assert.Equal(t, gitEnv, string(effectiveBytes))

		gitBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env.git"))
		require.NoError(t, readErr)
		assert.Equal(t, gitEnv, string(gitBytes))

		_, statErr := os.Stat(filepath.Join(projectPath, "project.env"))
		require.ErrorIs(t, statErr, os.ErrNotExist)
	}

	effectiveEnv, err := projects.ParseProjectEnvFile(filepath.Join(projectPath, ".env"), nil)
	require.NoError(t, err)
	assert.Equal(t, "$pbkdf2-sha512$310000$XXX", effectiveEnv["CLOUDFLARE_CLIENT_SECRET"])
	assert.Equal(t, "$pbkdf2-sha512$310000$XXX", effectiveEnv["QUOTED_SECRET"])
}

func TestProjectService_ApplyGitSyncProjectFiles_NormalizesStaleCopiedGitOverrides(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "git-sync-normalize"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n  app:\n    image: nginx:alpine\n"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\nSHARED=1\n"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("BASE=git\nSHARED=1\nTOKEN=local\n"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\nSHARED=1\nTOKEN=local\n"), 0o600))

	project := &Project{
		ID:      "proj-git-sync-normalize",
		Name:    "git-sync-normalize",
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	updated, _, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, "services:\n  app:\n    image: nginx:alpine\n", new("BASE=git-updated\nSHARED=1\nREMOTE_ONLY=1\n"), nil, "", usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})
	require.NoError(t, err)
	require.NotNil(t, updated)

	overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
	require.NoError(t, readErr)
	assert.Equal(t, "TOKEN=local\n", string(overrideBytes))

	effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
	require.NoError(t, readErr)
	assert.Contains(t, string(effectiveBytes), "BASE=git-updated\n")
	assert.Contains(t, string(effectiveBytes), "REMOTE_ONLY=1\n")
	assert.Contains(t, string(effectiveBytes), "TOKEN=local\n")
}

func TestProjectService_ApplyGitSyncProjectFiles_RemovesLegacyDeletedGitMasks(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "git-sync-delete-mask"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n  app:\n    image: nginx:alpine\n"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("TOKEN=git\nSHARED=1\n"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("TOKEN=\nLOCAL_ONLY=1\n"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("LOCAL_ONLY=1\nSHARED=1\n"), 0o600))

	project := &Project{
		ID:      "proj-git-sync-delete-mask",
		Name:    "git-sync-delete-mask",
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	updated, _, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, "services:\n  app:\n    image: nginx:alpine\n", new("TOKEN=git-updated\nSHARED=1\nREMOTE_ONLY=1\n"), nil, "", usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})
	require.NoError(t, err)
	require.NotNil(t, updated)

	overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "project.env"))
	require.NoError(t, readErr)
	assert.Equal(t, "LOCAL_ONLY=1\n", string(overrideBytes))

	effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
	require.NoError(t, readErr)
	assert.Contains(t, string(effectiveBytes), "TOKEN=git-updated\n")
	assert.Contains(t, string(effectiveBytes), "LOCAL_ONLY=1\n")
	assert.Contains(t, string(effectiveBytes), "REMOTE_ONLY=1\n")
	assert.NotContains(t, string(overrideBytes), "TOKEN=")
}

func TestProjectService_ApplyGitSyncProjectFiles_RemovesGitEnvSource(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "git-sync-remove"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n  app:\n    image: nginx:alpine\n"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\n"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\n"), 0o600))

	project := &Project{
		ID:      "proj-git-sync-remove",
		Name:    "git-sync-remove",
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	updated, _, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, "services:\n  app:\n    image: nginx:alpine\n", nil, nil, "", usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})
	require.NoError(t, err)
	require.NotNil(t, updated)

	_, statErr := os.Stat(filepath.Join(projectPath, ".env.git"))
	assert.True(t, os.IsNotExist(statErr))

	effectiveBytes, readErr := os.ReadFile(filepath.Join(projectPath, ".env"))
	require.NoError(t, readErr)
	assert.Equal(t, "BASE=git\n", string(effectiveBytes))
}

func TestProjectService_ApplyGitSyncProjectFiles_WritesAndRemovesComposeOverride(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "git-sync-override"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n  app:\n    image: nginx:alpine\n"), 0o600))

	project := &Project{
		ID:      "proj-git-sync-override",
		Name:    dirName,
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	overrideContent := "services:\n  app:\n    image: busybox:latest\n"
	updated, _, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, "services:\n  app:\n    image: nginx:alpine\n", nil, new(overrideContent), "compose.override.yaml", usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})
	require.NoError(t, err)
	require.NotNil(t, updated)

	overrideBytes, readErr := os.ReadFile(filepath.Join(projectPath, "compose.override.yaml"))
	require.NoError(t, readErr)
	assert.Equal(t, overrideContent, string(overrideBytes))

	// A subsequent sync without an override removes the previously synced file.
	updated, _, err = svc.ApplyGitSyncProjectFiles(ctx, project.ID, "services:\n  app:\n    image: nginx:alpine\n", nil, nil, "", usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})
	require.NoError(t, err)
	require.NotNil(t, updated)

	_, statErr := os.Stat(filepath.Join(projectPath, "compose.override.yaml"))
	assert.True(t, os.IsNotExist(statErr))
}

func TestProjectService_ApplyGitSyncProjectFiles_UsesGlobalEnvDuringComposeValidation(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "git-sync-global-env"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(projectsDir, projects.GlobalEnvFileName), []byte("DATA_NAS_FOLDER=/srv/media\nMYPATH=/containers/\n"), 0o600))

	project := &Project{
		ID:      "proj-git-sync-global-env",
		Name:    dirName,
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	compose := `services:
  cats:
    image: mikesir87/cats:1.0
    volumes:
      - ${DATA_NAS_FOLDER}:/data
      - ${MYPATH}cats/templates:/app/templates
`

	updated, _, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, compose, nil, nil, "", usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})
	require.NoError(t, err)
	require.NotNil(t, updated)

	composeBytes, readErr := os.ReadFile(filepath.Join(projectPath, "compose.yaml"))
	require.NoError(t, readErr)
	assert.Equal(t, compose, string(composeBytes))
}

// TestProjectService_ApplyGitSyncProjectFiles_TolerantOfUndefinedComposeVar verifies
// a git sync updating a compose file that references an undefined ${VAR} (with no
// .env supplying it yet) succeeds instead of failing compose validation with a
// typed-decode error like `strconv.ParseFloat: parsing "": invalid syntax`.
func TestProjectService_ApplyGitSyncProjectFiles_TolerantOfUndefinedComposeVar(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "git-sync-undefined-var"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n  app:\n    image: nginx:alpine\n"), 0o600))

	compose := `services:
  app:
    image: nginx:alpine
    deploy:
      resources:
        limits:
          cpus: "${CPU}"
`

	project := &Project{
		ID:      "proj-git-sync-undefined-var",
		Name:    dirName,
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	updated, _, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, compose, nil, nil, "", usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})
	require.NoError(t, err)
	require.NotNil(t, updated)

	composeBytes, readErr := os.ReadFile(filepath.Join(projectPath, "compose.yaml"))
	require.NoError(t, readErr)
	assert.Equal(t, compose, string(composeBytes))
}

func TestProjectService_GetProjectDetails_ReturnsEffectiveEnvContent(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "details-override"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n  app:\n    image: nginx:alpine\n"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("BASE=git\nTOKEN=secret\n"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env.git"), []byte("BASE=git\n"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "project.env"), []byte("TOKEN=secret\n"), 0o600))

	project := &Project{
		ID:      "proj-details-override",
		Name:    "details-override",
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	details, err := svc.GetProjectDetails(ctx, project.ID, projecttypes.AllDetails())
	require.NoError(t, err)
	assert.Equal(t, "BASE=git\nTOKEN=secret\n", details.EnvContent)
}

func TestBuildProjectUpdateInfoSummary(t *testing.T) {
	now := time.Now().UTC()

	tests := []struct {
		name        string
		imageRefs   []string
		updates     map[string]*imagetypes.UpdateInfo
		wantStatus  string
		wantCount   int
		wantChecked int
		wantErrors  int
		wantUpdates int
		wantError   string
	}{
		{
			name:        "unknown when no checks exist",
			imageRefs:   []string{"nginx:latest"},
			updates:     nil,
			wantStatus:  "unknown",
			wantCount:   1,
			wantChecked: 0,
			wantErrors:  0,
			wantUpdates: 0,
		},
		{
			name:      "has update when any image has update",
			imageRefs: []string{"nginx:latest", "redis:7"},
			updates: map[string]*imagetypes.UpdateInfo{
				"nginx:latest": {HasUpdate: true, CheckTime: now},
				"redis:7":      {HasUpdate: false, CheckTime: now.Add(-time.Minute)},
			},
			wantStatus:  "has_update",
			wantCount:   2,
			wantChecked: 2,
			wantErrors:  0,
			wantUpdates: 1,
		},
		{
			name:      "error when no updates but a check failed",
			imageRefs: []string{"nginx:latest"},
			updates: map[string]*imagetypes.UpdateInfo{
				"nginx:latest": {HasUpdate: false, CheckTime: now, Error: "rate limited"},
			},
			wantStatus:  "error",
			wantCount:   1,
			wantChecked: 1,
			wantErrors:  1,
			wantUpdates: 0,
			wantError:   "rate limited",
		},
		{
			name:      "up to date when all images checked without updates",
			imageRefs: []string{"nginx:latest", "redis:7"},
			updates: map[string]*imagetypes.UpdateInfo{
				"nginx:latest": {HasUpdate: false, CheckTime: now},
				"redis:7":      {HasUpdate: false, CheckTime: now.Add(-time.Minute)},
			},
			wantStatus:  "up_to_date",
			wantCount:   2,
			wantChecked: 2,
			wantErrors:  0,
			wantUpdates: 0,
		},
		{
			name:      "not pulled when an image is missing locally and nothing else needs attention",
			imageRefs: []string{"nginx:latest", "redis:7"},
			updates: map[string]*imagetypes.UpdateInfo{
				"nginx:latest": {HasUpdate: false, UpdateType: imageupdate.UpdateTypeNotPulled, CheckTime: now},
				"redis:7":      {HasUpdate: false, CheckTime: now.Add(-time.Minute)},
			},
			wantStatus:  "not_pulled",
			wantCount:   2,
			wantChecked: 2,
			wantErrors:  0,
			wantUpdates: 0,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			summary := buildUpdateInfoSummary(tt.imageRefs, tt.updates, nil)
			require.NotNil(t, summary)
			assert.Equal(t, tt.wantStatus, summary.Status)
			assert.Equal(t, tt.wantCount, summary.ImageCount)
			assert.Equal(t, tt.wantChecked, summary.CheckedImageCount)
			assert.Equal(t, tt.wantErrors, summary.ErrorCount)
			assert.Equal(t, tt.wantUpdates, summary.ImagesWithUpdates)
			assert.Equal(t, tt.wantUpdates > 0, summary.HasUpdate)
			assert.Equal(t, tt.imageRefs, summary.ImageRefs)
			if tt.wantError != "" {
				require.NotNil(t, summary.ErrorMessage)
				assert.Equal(t, tt.wantError, *summary.ErrorMessage)
			} else {
				assert.Nil(t, summary.ErrorMessage)
			}
			if tt.wantUpdates > 0 {
				assert.Equal(t, []string{tt.imageRefs[0]}, summary.UpdatedImageRefs)
			} else {
				assert.Empty(t, summary.UpdatedImageRefs)
			}
		})
	}
}

func TestProjectService_GetProjectDetails_IncludesUpdateInfo(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))

	imageService := image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		imageService,
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	projectPath := createComposeProjectDir(t, projectsDir, "updates-demo")
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n  app:\n    image: nginx:latest\n"), 0o644))

	projectRecord := &Project{
		ID:      "proj-update-info",
		Name:    "updates-demo",
		DirName: new("updates-demo"),
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(projectRecord).Error)

	require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{
		ID:             "sha256:update-demo",
		Repository:     "docker.io/library/nginx",
		Tag:            "latest",
		HasUpdate:      true,
		UpdateType:     "digest",
		CurrentVersion: "latest",
		CheckTime:      time.Now().UTC(),
	}).Error)

	details, err := svc.GetProjectDetails(ctx, projectRecord.ID, projecttypes.AllDetails())
	require.NoError(t, err)
	require.NotNil(t, details.UpdateInfo)
	assert.Equal(t, "has_update", details.UpdateInfo.Status)
	assert.True(t, details.UpdateInfo.HasUpdate)
	assert.Equal(t, 1, details.UpdateInfo.ImageCount)
	assert.Equal(t, 1, details.UpdateInfo.CheckedImageCount)
	assert.Equal(t, 1, details.UpdateInfo.ImagesWithUpdates)
	assert.Equal(t, []string{"nginx:latest"}, details.UpdateInfo.ImageRefs)
	assert.Equal(t, []string{"nginx:latest"}, details.UpdateInfo.UpdatedImageRefs)
}

func TestProjectService_GetProjectDetails_RefreshesRuntimeStatusWithoutRuntimeServices(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))

	projectPath := createComposeProjectDir(t, projectsDir, "projectA")
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n  server:\n    image: nginx:alpine\n  worker:\n    image: busybox:latest\n"), 0o644))

	server := newProjectRuntimeDockerServer(t, []container.Summary{
		{
			ID:     "server-container",
			Names:  []string{"/projecta-server-1"},
			Image:  "nginx:alpine",
			State:  container.StateRunning,
			Status: "Up 30 seconds (healthy)",
			Ports: []container.PortSummary{
				{
					IP:          netip.MustParseAddr("0.0.0.0"),
					PrivatePort: 80,
					PublicPort:  8080,
					Type:        "tcp",
				},
			},
			Labels: map[string]string{
				api.ProjectLabel:    "projecta",
				api.ServiceLabel:    "server",
				api.ConfigHashLabel: "server-hash",
				api.WorkingDirLabel: "/host/path/projects/projectA",
			},
		},
		{
			ID:     "worker-container",
			Names:  []string{"/projecta-worker-1"},
			Image:  "busybox:latest",
			State:  container.StateRunning,
			Status: "Up 30 seconds",
			Labels: map[string]string{
				api.ProjectLabel:    "projecta",
				api.ServiceLabel:    "worker",
				api.ConfigHashLabel: "worker-hash",
				api.WorkingDirLabel: "/host/path/projects/projectA",
			},
		},
	})

	projectRecord := &Project{
		ID:           "proj-runtime-refresh",
		Name:         "projectA",
		DirName:      new("projectA"),
		Path:         projectPath,
		Status:       ProjectStatusStopped,
		ServiceCount: 2,
		RunningCount: 0,
	}
	require.NoError(t, db.Create(projectRecord).Error)

	t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURL(t, server.URL))
	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		&docker.DockerClientService{Client: newTestDockerClient(t, server)},
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	details, err := svc.GetProjectDetails(ctx, projectRecord.ID, projecttypes.DetailsOptions{})
	require.NoError(t, err)
	assert.Equal(t, string(ProjectStatusRunning), details.Status)
	assert.Equal(t, 2, details.ServiceCount)
	assert.Equal(t, 2, details.RunningCount)
	assert.Empty(t, details.RuntimeServices)
}

func TestProjectService_GetProjectDetails_PopulatesRuntimeServicesFromComposePs(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))

	projectPath := createComposeProjectDir(t, projectsDir, "projectA")
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n  server:\n    image: nginx:alpine\n"), 0o644))

	server := newProjectRuntimeDockerServer(t, []container.Summary{
		{
			ID:     "server-container",
			Names:  []string{"/projecta-server-1"},
			Image:  "nginx:alpine",
			State:  container.StateRunning,
			Status: "Up 30 seconds",
			Labels: map[string]string{
				api.ProjectLabel:    "projecta",
				api.ServiceLabel:    "server",
				api.ConfigHashLabel: "server-hash",
				api.WorkingDirLabel: "/host/path/projects/projectA",
			},
		},
	})

	projectRecord := &Project{
		ID:           "proj-runtime-services",
		Name:         "projectA",
		DirName:      new("projectA"),
		Path:         projectPath,
		Status:       ProjectStatusStopped,
		ServiceCount: 1,
		RunningCount: 0,
	}
	require.NoError(t, db.Create(projectRecord).Error)

	t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURL(t, server.URL))
	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		&docker.DockerClientService{Client: newTestDockerClient(t, server)},
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	details, err := svc.GetProjectDetails(ctx, projectRecord.ID, projecttypes.DetailsOptions{IncludeRuntimeServices: true})
	require.NoError(t, err)
	require.Len(t, details.RuntimeServices, 1)
	assert.Equal(t, string(ProjectStatusRunning), details.Status)
	assert.Equal(t, "server", details.RuntimeServices[0].Name)
	assert.Equal(t, "running", details.RuntimeServices[0].Status)
	assert.Equal(t, "server-container", details.RuntimeServices[0].ContainerID)
	assert.Equal(t, "projecta-server-1", details.RuntimeServices[0].ContainerName)
}

func TestListingPage_FiltersByLabel(t *testing.T) {
	items := []projecttypes.Details{
		{ID: "tagged", RuntimeServices: []projecttypes.RuntimeService{
			{Name: "web", ContainerLabels: map[string]string{"heal": "true"}},
			{Name: "db", ContainerLabels: map[string]string{"tags": "a,b"}},
		}},
		{ID: "other", RuntimeServices: []projecttypes.RuntimeService{{Name: "web", ContainerLabels: map[string]string{"heal": "false"}}}},
		{ID: "down"},
	}
	tests := []struct {
		name   string
		filter string
		want   []string
	}{
		{name: "key only", filter: "heal", want: []string{"tagged", "other"}},
		{name: "key and value", filter: "heal=true", want: []string{"tagged"}},
		{name: "missing key", filter: "missing", want: nil},
		{name: "value containing comma", filter: "tags=a,b", want: []string{"tagged"}},
		{name: "blank is a no-op", filter: " ", want: []string{"tagged", "other", "down"}},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result, _ := listing.Page(items, pagination.QueryParams{Filters: map[string]string{"label": tt.filter}, Limit: -1}, func(string) bool { return true })
			var got []string
			for _, item := range result.Items {
				got = append(got, item.ID)
			}
			require.Equal(t, tt.want, got)
		})
	}
}

func TestProjectService_ListProjects_FiltersByUpdateStatus(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))

	imageService := image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		imageService,
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	updatedPath := createComposeProjectDir(t, projectsDir, "updated-demo")
	require.NoError(t, os.WriteFile(filepath.Join(updatedPath, "compose.yaml"), []byte("services:\n  app:\n    image: nginx:latest\n"), 0o644))
	upToDatePath := createComposeProjectDir(t, projectsDir, "current-demo")
	require.NoError(t, os.WriteFile(filepath.Join(upToDatePath, "compose.yaml"), []byte("services:\n  app:\n    image: redis:7\n"), 0o644))
	errorPath := createComposeProjectDir(t, projectsDir, "error-demo")
	require.NoError(t, os.WriteFile(filepath.Join(errorPath, "compose.yaml"), []byte("services:\n  app:\n    image: busybox:latest\n"), 0o644))
	unknownPath := createComposeProjectDir(t, projectsDir, "unknown-demo")
	require.NoError(t, os.WriteFile(filepath.Join(unknownPath, "compose.yaml"), []byte("services:\n  app:\n    image: alpine:latest\n"), 0o644))

	require.NoError(t, db.Create(&Project{
		ID:      "project-updated",
		Name:    "updated-demo",
		DirName: new("updated-demo"),
		Path:    updatedPath,
		Status:  ProjectStatusStopped,
	}).Error)
	require.NoError(t, db.Create(&Project{
		ID:      "project-current",
		Name:    "current-demo",
		DirName: new("current-demo"),
		Path:    upToDatePath,
		Status:  ProjectStatusStopped,
	}).Error)
	require.NoError(t, db.Create(&Project{
		ID:      "project-error",
		Name:    "error-demo",
		DirName: new("error-demo"),
		Path:    errorPath,
		Status:  ProjectStatusStopped,
	}).Error)
	require.NoError(t, db.Create(&Project{
		ID:      "project-unknown",
		Name:    "unknown-demo",
		DirName: new("unknown-demo"),
		Path:    unknownPath,
		Status:  ProjectStatusStopped,
	}).Error)

	now := time.Now().UTC()
	require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{
		ID:             "sha256:updated-image",
		Repository:     "docker.io/library/nginx",
		Tag:            "latest",
		HasUpdate:      true,
		UpdateType:     "digest",
		CurrentVersion: "latest",
		CheckTime:      now,
	}).Error)
	require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{
		ID:             "sha256:current-image",
		Repository:     "docker.io/library/redis",
		Tag:            "7",
		HasUpdate:      false,
		UpdateType:     "tag",
		CurrentVersion: "7",
		CheckTime:      now.Add(-time.Minute),
	}).Error)
	require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{
		ID:             "sha256:error-image",
		Repository:     "docker.io/library/busybox",
		Tag:            "latest",
		HasUpdate:      false,
		UpdateType:     "error",
		CurrentVersion: "latest",
		CheckTime:      now.Add(-2 * time.Minute),
		LastError:      new("registry timeout"),
	}).Error)

	tests := []struct {
		name     string
		filter   string
		expected []string
	}{
		{name: "has update", filter: "has_update", expected: []string{"updated-demo"}},
		{name: "up to date", filter: "up_to_date", expected: []string{"current-demo"}},
		{name: "error", filter: "error", expected: []string{"error-demo"}},
		{name: "unknown", filter: "unknown", expected: []string{"unknown-demo"}},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			items, page, listProjectsErr := svc.ListProjects(ctx, pagination.QueryParams{
				Filters: map[string]string{
					"updates": tt.filter,
				},
				Limit: -1,
				Sort:  "name", Order: pagination.SortAsc,
			})
			require.NoError(t, listProjectsErr)
			require.EqualValues(t, len(tt.expected), page.TotalItems)

			names := make([]string, 0, len(items))
			for _, item := range items {
				names = append(names, item.Name)
			}
			assert.Equal(t, tt.expected, names)
		})
	}
}

func TestBuildDiscoveredComposeProjectUpdateRows(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()
	imageService := image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil)
	now := time.Now().UTC()

	require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{
		ID:             "sha256:media-image",
		Repository:     "docker.io/library/nginx",
		Tag:            "latest",
		HasUpdate:      true,
		UpdateType:     imageupdate.UpdateTypeDigest,
		CurrentVersion: "latest",
		CheckTime:      now,
	}).Error)
	require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{
		ID:             "sha256:known-image",
		Repository:     "docker.io/library/redis",
		Tag:            "7",
		HasUpdate:      true,
		UpdateType:     imageupdate.UpdateTypeDigest,
		CurrentVersion: "7",
		CheckTime:      now,
	}).Error)
	rows := discoveryListingForTest(imageService).DiscoveredUpdateRows(ctx, []container.Summary{
		{
			ID:      "media-web",
			Names:   []string{"/media-web-1"},
			Image:   "nginx:latest",
			ImageID: "sha256:media-image",
			State:   "running",
			Labels: map[string]string{
				"com.docker.compose.project": "media",
				"com.docker.compose.service": "web",
			},
		},
		{
			ID:      "known-cache",
			Image:   "redis:7",
			ImageID: "sha256:known-image",
			State:   "running",
			Labels: map[string]string{
				"com.docker.compose.project": "known",
				"com.docker.compose.service": "cache",
			},
		},
		{
			ID:      "plain-container",
			Image:   "busybox:latest",
			ImageID: "sha256:plain-image",
			State:   "running",
			Labels:  map[string]string{},
		},
	}, map[string]struct{}{"known": {}}, iconcatalog.DefaultCatalog)

	require.Len(t, rows, 1)
	row := rows[0]
	assert.Equal(t, "compose:media", row.ID)
	assert.Equal(t, "media", row.Name)
	assert.True(t, row.IsDiscovered)
	assert.Equal(t, string(ProjectStatusRunning), row.Status)
	require.NotNil(t, row.UpdateInfo)
	assert.True(t, row.UpdateInfo.HasUpdate)
	assert.Equal(t, []string{"nginx:latest"}, row.UpdateInfo.UpdatedImageRefs)
	require.Len(t, row.RuntimeServices, 1)
	assert.Equal(t, "web", row.RuntimeServices[0].Name)
}

func TestBuildDiscoveredComposeProjectUpdateRows_FallsBackToImageID(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()
	imageService := image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil)

	require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{
		ID:             "sha256:media-image",
		Repository:     "registry.example.test/custom/media",
		Tag:            "latest",
		HasUpdate:      true,
		UpdateType:     imageupdate.UpdateTypeDigest,
		CurrentVersion: "latest",
		CheckTime:      time.Now().UTC(),
	}).Error)

	containers := []container.Summary{
		{
			ID:      "media-web",
			Image:   "nginx:latest",
			ImageID: "sha256:media-image",
			State:   "running",
			Labels: map[string]string{
				"com.docker.compose.project": "media",
				"com.docker.compose.service": "web",
			},
		},
		{
			ID:      "media-web-replica",
			Image:   "nginx:latest",
			ImageID: "sha256:media-image",
			State:   "running",
			Labels: map[string]string{
				"com.docker.compose.project": "media",
				"com.docker.compose.service": "web",
				labels.LabelUpdater:          "false",
			},
		},
		{
			ID:      "pinned-web",
			Image:   "nginx:1.25.0",
			ImageID: "sha256:media-image",
			State:   "running",
			Labels: map[string]string{
				"com.docker.compose.project": "pinned",
				"com.docker.compose.service": "web",
				labels.LabelUpdateStrategy:   "tag",
			},
		},
	}
	rows := discoveryListingForTest(imageService).DiscoveredUpdateRows(ctx, containers, map[string]struct{}{}, iconcatalog.DefaultCatalog)

	require.Len(t, rows, 1, "replicas count once and a tag policy never inherits the digest check")
	assert.Equal(t, "compose:media", rows[0].ID)
	assert.Equal(t, []string{"nginx:latest"}, rows[0].UpdateInfo.UpdatedImageRefs)

	// The tracked-project path resolves the same record through the runtime image ID.
	settingsService, settingsErr := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, settingsErr)
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", t.TempDir()))
	service := NewProjectService(db, settingsService, nil, imageService, testDockerService, testBuildBuilder{}, nil, nil, nil, nil, testRegistryCredentials)
	detail := projecttypes.Details{
		ID: "tracked",
		RuntimeServices: []projecttypes.RuntimeService{
			{
				Name:            "web",
				ContainerID:     "media-web",
				Image:           "nginx:latest",
				ImageID:         "sha256:media-image",
				ContainerLabels: containers[0].Labels,
			},
		},
	}
	info := service.enrichProjectsWithUpdateInfo(ctx, []Project{{ID: "tracked"}}, []projecttypes.Details{detail}, true, nil)[0].UpdateInfo
	require.True(t, info.HasUpdate)
	assert.Equal(t, []string{"nginx:latest"}, info.UpdatedImageRefs)
	detail.RuntimeServices[0].ImageID = ""
	info = service.enrichProjectsWithUpdateInfo(ctx, []Project{{ID: "tracked"}}, []projecttypes.Details{detail}, true, nil)[0].UpdateInfo
	require.False(t, info.HasUpdate, "a missing runtime image ID inherits nothing")
}

func TestProjectService_ListProjects_FiltersArchivedProjects(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	projectsRoot := t.TempDir()
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))

	activePath := createComposeProjectDir(t, projectsRoot, "active-demo")
	archivedPath := createComposeProjectDir(t, projectsRoot, "archived-demo")
	require.NoError(t, db.Create(&Project{
		ID:      "project-active",
		Name:    "active-demo",
		DirName: new("active-demo"),
		Path:    activePath,
		Status:  ProjectStatusStopped,
	}).Error)
	require.NoError(t, db.Create(&Project{
		ID:         "project-archived",
		Name:       "archived-demo",
		DirName:    new("archived-demo"),
		Path:       archivedPath,
		Status:     ProjectStatusStopped,
		IsArchived: true,
		ArchivedAt: new(time.Now().UTC()),
	}).Error)

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	items, page, err := svc.ListProjects(ctx, pagination.QueryParams{
		Limit: -1,
		Sort:  "name", Order: pagination.SortAsc,
	})
	require.NoError(t, err)
	require.EqualValues(t, 1, page.TotalItems)
	require.Len(t, items, 1)
	assert.Equal(t, "active-demo", items[0].Name)

	items, page, err = svc.ListProjects(ctx, pagination.QueryParams{
		Filters: map[string]string{"archived": "true"},
		Limit:   -1,
		Sort:    "name", Order: pagination.SortAsc,
	})
	require.NoError(t, err)
	require.EqualValues(t, 1, page.TotalItems)
	require.Len(t, items, 1)
	assert.Equal(t, "archived-demo", items[0].Name)
	assert.True(t, items[0].IsArchived)

	items, page, err = svc.ListProjects(ctx, pagination.QueryParams{
		Filters: map[string]string{"archived": "all"},
		Limit:   -1,
		Sort:    "name", Order: pagination.SortAsc,
	})
	require.NoError(t, err)
	require.EqualValues(t, 2, page.TotalItems)
	require.Len(t, items, 2)
	assert.Equal(t, []string{"active-demo", "archived-demo"}, []string{items[0].Name, items[1].Name})
}

func TestProjectService_ListProjects_FiltersByExactName(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	projectsRoot := t.TempDir()
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))

	for _, name := range []string{"demo", "demo-extra"} {
		require.NoError(t, db.Create(&Project{
			ID:      "project-" + name,
			Name:    name,
			DirName: new(name),
			Path:    createComposeProjectDir(t, projectsRoot, name),
			Status:  ProjectStatusStopped,
		}).Error)
	}

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	// Sorting by status pages in memory, so both pagination paths are covered.
	for _, sort := range []string{"name", "status"} {
		items, page, listErr := svc.ListProjects(ctx, pagination.QueryParams{
			Filters: map[string]string{"name": "demo"},
			Limit:   1,
			Sort:    sort,
			Order:   pagination.SortAsc,
		})
		require.NoError(t, listErr, sort)
		require.EqualValues(t, 1, page.TotalItems, sort)
		require.Len(t, items, 1, sort)
		assert.Equal(t, "project-demo", items[0].ID, sort)
	}
}

func TestProjectService_ArchiveProject_RequiresStoppedProject(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsRoot := t.TempDir()
	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))

	projectPath := createComposeProjectDir(t, projectsRoot, "running-demo")
	// DB row says stopped; the live Docker state below is what must block the archive.
	require.NoError(t, db.Create(&Project{
		ID:      "project-running",
		Name:    "running-demo",
		DirName: new("running-demo"),
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}).Error)

	server := configureProjectRuntimeDocker(t, []container.Summary{
		{
			ID:     "app-container",
			Names:  []string{"/running-demo-app-1"},
			Image:  "nginx:alpine",
			State:  container.StateRunning,
			Status: "Up 30 seconds",
			Labels: map[string]string{
				api.ProjectLabel:    "running-demo",
				api.ServiceLabel:    "app",
				api.ConfigHashLabel: "app-hash",
				api.WorkingDirLabel: "/host/path/projects/running-demo",
			},
		},
	})
	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		&docker.DockerClientService{Client: newTestDockerClient(t, server)},
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	err = svc.ArchiveProject(ctx, "project-running", usertypes.Actor{ID: "user-1", Username: "tester"})
	require.Error(t, err)
	require.ErrorIs(t, err, common.ErrProjectMustBeStopped)

	var stored Project
	require.NoError(t, db.First(&stored, "id = ?", "project-running").Error)
	assert.False(t, stored.IsArchived)
	assert.Nil(t, stored.ArchivedAt)
}

func TestProjectService_ArchiveProject_TogglesArchiveFlag(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsRoot := t.TempDir()
	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))

	projectPath := createComposeProjectDir(t, projectsRoot, "stopped-demo")
	require.NoError(t, db.Create(&Project{
		ID:      "project-stopped",
		Name:    "stopped-demo",
		DirName: new("stopped-demo"),
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}).Error)

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		&docker.DockerClientService{Client: newTestDockerClient(t, configureProjectRuntimeDocker(t, nil))},
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	user := usertypes.Actor{ID: "user-1", Username: "tester"}

	require.NoError(t, svc.ArchiveProject(ctx, "project-stopped", user))
	var stored Project
	require.NoError(t, db.First(&stored, "id = ?", "project-stopped").Error)
	assert.True(t, stored.IsArchived)
	assert.NotNil(t, stored.ArchivedAt)

	require.NoError(t, svc.UnarchiveProject(ctx, "project-stopped", user))
	var unarchived Project
	require.NoError(t, db.First(&unarchived, "id = ?", "project-stopped").Error)
	assert.False(t, unarchived.IsArchived)
	assert.Nil(t, unarchived.ArchivedAt)
}

func TestProjectService_ArchiveProject_LiveVerificationErrorPolicy(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsRoot := t.TempDir()
	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))

	unreachablePath := createComposeProjectDir(t, projectsRoot, "unreachable-demo")
	require.NoError(t, db.Create(&Project{
		ID:      "project-unreachable",
		Name:    "unreachable-demo",
		DirName: new("unreachable-demo"),
		Path:    unreachablePath,
		Status:  ProjectStatusStopped,
	}).Error)

	noComposePath := filepath.Join(projectsRoot, "no-compose-demo")
	require.NoError(t, os.MkdirAll(noComposePath, 0o755))
	require.NoError(t, db.Create(&Project{
		ID:      "project-no-compose",
		Name:    "no-compose-demo",
		DirName: new("no-compose-demo"),
		Path:    noComposePath,
		Status:  ProjectStatusStopped,
	}).Error)

	t.Setenv("DOCKER_HOST", "tcp://127.0.0.1:1")

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	user := usertypes.Actor{ID: "user-1", Username: "tester"}

	err = svc.ArchiveProject(ctx, "project-unreachable", user)
	require.Error(t, err)
	var stored Project
	require.NoError(t, db.First(&stored, "id = ?", "project-unreachable").Error)
	assert.False(t, stored.IsArchived)

	require.NoError(t, svc.ArchiveProject(ctx, "project-no-compose", user))
	var archived Project
	require.NoError(t, db.First(&archived, "id = ?", "project-no-compose").Error)
	assert.True(t, archived.IsArchived)
}

func TestProjectService_ListProjects_PersistsInferredServiceCount(t *testing.T) {
	db := setupProjectTestDB(t)
	settingsService, err := newSettingsServiceForTest(t, t.Context(), db)
	require.NoError(t, err)
	projectsDir := t.TempDir()
	require.NoError(t, settingsService.SetStringSetting(t.Context(), "projectsDirectory", projectsDir))
	projectPath := filepath.Join(projectsDir, "inferred")
	require.NoError(t, os.MkdirAll(projectPath, 0o755))
	inferred := Project{ID: "inferred", Name: "inferred", Path: projectPath, ServiceCount: 0}
	known := Project{ID: "known", Name: "known", Path: filepath.Join(projectsDir, "known"), ServiceCount: 4}
	require.NoError(t, db.Create(&inferred).Error)
	require.NoError(t, db.Create(&known).Error)
	containers := []container.Summary{
		{ID: "c1", State: "running", Names: []string{"/inferred-web"}, Labels: map[string]string{
			api.ProjectLabel: "inferred", api.ServiceLabel: "web", api.WorkingDirLabel: projectPath,
		}},
		{ID: "c2", State: "exited", Names: []string{"/inferred-db"}, Labels: map[string]string{
			api.ProjectLabel: "inferred", api.ServiceLabel: "db", api.WorkingDirLabel: projectPath,
		}},
		{ID: "c3", State: "running", Names: []string{"/known-web"}, Labels: map[string]string{
			api.ProjectLabel: "known", api.ServiceLabel: "web", api.WorkingDirLabel: known.Path,
		}},
	}
	service := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		&docker.DockerClientService{Client: newTestDockerClient(t, configureProjectRuntimeDocker(t, containers))},
		testBuildBuilder{},
		nil,
		nil,
		nil,
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	rows, _, err := service.ListProjects(t.Context(), pagination.QueryParams{Limit: -1, Sort: "name", Order: pagination.SortAsc})
	require.NoError(t, err)
	require.Len(t, rows, 2)
	require.Equal(t, 2, rows[0].ServiceCount)
	require.Equal(t, 4, rows[1].ServiceCount)

	// The inferred count is persisted because the plain list path sorts and
	// paginates on this column in SQL.
	var stored Project
	require.NoError(t, db.First(&stored, "id = ?", "inferred").Error)
	require.Equal(t, 2, stored.ServiceCount)

	var storedKnown Project
	require.NoError(t, db.First(&storedKnown, "id = ?", "known").Error)
	require.Equal(t, 4, storedKnown.ServiceCount, "a persisted non-zero count must not be overwritten by the live container count")
}

func TestProjectService_ListProjects_WithDerivedStatusFilter_AllowsAllPageSizeSentinel(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))

	for i := range 25 {
		projectPath := createComposeProjectDir(t, projectsRoot, fmt.Sprintf("stopped-%02d", i))
		require.NoError(t, db.Create(&Project{
			ID:      fmt.Sprintf("project-%02d", i),
			Name:    fmt.Sprintf("stopped-%02d", i),
			DirName: new(fmt.Sprintf("stopped-%02d", i)),
			Path:    projectPath,
			Status:  ProjectStatusStopped,
		}).Error)
	}

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		&docker.DockerClientService{Client: newTestDockerClient(t, configureProjectRuntimeDocker(t, nil))},
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	items, page, err := svc.ListProjects(ctx, pagination.QueryParams{
		Filters: map[string]string{
			"status": string(ProjectStatusStopped),
		},
		Limit: -1,
		Sort:  "name", Order: pagination.SortAsc,
	})
	require.NoError(t, err)
	assert.EqualValues(t, 25, page.TotalItems)
	require.Len(t, items, 25)
	assert.Equal(t, "stopped-00", items[0].Name)
	assert.Equal(t, "stopped-24", items[len(items)-1].Name)
}

func TestProjectService_DeployProject_StopsOnBuildPreparationError(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()
	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	projectDir := filepath.Join(projectsRoot, "demo")
	require.NoError(t, os.MkdirAll(projectDir, 0o755))
	composeContent := "services:\n  web:\n    pull_policy: build\n    build:\n      context: .\n"

	require.NoError(t, os.WriteFile(filepath.Join(projectDir, "compose.yaml"), []byte(composeContent), 0o644))
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot+":"+projectsRoot))

	proj := &Project{
		ID:     "p1",
		Name:   "demo",
		Path:   projectDir,
		Status: ProjectStatusStopped,
	}
	require.NoError(t, db.Create(proj).Error)

	buildSvc := testBuildBuilder{err: errors.New("boom build")}
	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		buildSvc,
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	err = svc.DeployProject(ctx, "p1", usertypes.Actor{ID: "u1", Username: "tester"}, nil)
	require.Error(t, err)
	assert.Contains(t, err.Error(), "failed to prepare project images for deploy")
	assert.Contains(t, err.Error(), "boom build")

	var updated Project
	require.NoError(t, db.First(&updated, "id = ?", "p1").Error)
	assert.Equal(t, ProjectStatusStopped, updated.Status)
}

func TestProjectService_DeployProject_BuildsGeneratedImageWithoutPull(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()
	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	projectDir := filepath.Join(projectsRoot, "demo")
	require.NoError(t, os.MkdirAll(projectDir, 0o755))
	composeContent := "services:\n  caddy:\n    build:\n      dockerfile_inline: |\n        FROM caddy:builder AS builder\n     " +
		"   RUN xcaddy build --with github.com/caddyserver/replace-response\n\n        FROM caddy:latest\n      " +
		"  COPY --from=builder /usr/bin/caddy /usr/bin/caddy\n"

	require.NoError(t, os.WriteFile(filepath.Join(projectDir, "compose.yaml"), []byte(composeContent), 0o644))
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot+":"+projectsRoot))

	proj := &Project{
		ID:     "p-generated",
		Name:   "build-test",
		Path:   projectDir,
		Status: ProjectStatusStopped,
	}
	require.NoError(t, db.Create(proj).Error)

	buildSvc := testBuildBuilder{err: errors.New("boom build")}
	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, testDockerService, nil, nil, nil, nil, nil, nil),
		testDockerService,
		buildSvc,
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	err = svc.DeployProject(ctx, proj.ID, usertypes.Actor{ID: "u1", Username: "tester"}, nil)
	require.Error(t, err)
	assert.Contains(t, err.Error(), "failed to prepare project images for deploy")
	assert.Contains(t, err.Error(), "boom build")
	assert.NotContains(t, err.Error(), "failed to pull image arcane.local/")
	assert.NotContains(t, err.Error(), "failed to resolve reference \"arcane.local/")
}

func TestProjectService_SyncProjectsFromFileSystem_IgnoresSymlinkedProjectDirsWhenDisabled(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	targetRoot := t.TempDir()
	createComposeProjectDir(t, projectsRoot, "regular")
	linkTarget := createComposeProjectDir(t, targetRoot, "linked-target")
	require.NoError(t, os.Symlink(linkTarget, filepath.Join(projectsRoot, "linked")))

	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
	require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "false"))

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))

	items, err := svc.ListAllProjects(ctx)
	require.NoError(t, err)
	require.Len(t, items, 1)
	assert.Equal(t, "regular", items[0].Name)
	assert.Equal(t, filepath.Join(projectsRoot, "regular"), items[0].Path)
}

func TestProjectService_SyncProjectsFromFileSystem_DetectsSymlinkedProjectDirsWhenEnabled(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	targetRoot := t.TempDir()
	linkTarget := createComposeProjectDir(t, targetRoot, "linked-target")
	linkPath := filepath.Join(projectsRoot, "linked")
	require.NoError(t, os.Symlink(linkTarget, linkPath))

	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
	require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "true"))

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))

	items, err := svc.ListAllProjects(ctx)
	require.NoError(t, err)
	require.Len(t, items, 1)
	assert.Equal(t, "linked", items[0].Name)
	assert.Equal(t, linkPath, items[0].Path)
}

func TestProjectService_SyncProjectsFromFileSystem_DiscoversNestedProjectsAndRelativePaths(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	nestedPath := createComposeProjectDir(t, projectsRoot, filepath.Join("main-project", "sub-project1"))
	topLevelPath := createComposeProjectDir(t, projectsRoot, "project2")

	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))

	items, page, err := svc.ListProjects(ctx, pagination.QueryParams{
		Sort: "path", Order: pagination.SortAsc,
		Limit: -1,
	})
	require.NoError(t, err)
	require.EqualValues(t, 2, page.TotalItems)
	require.Len(t, items, 2)

	assert.Equal(t, "main-project/sub-project1", items[0].RelativePath)
	assert.Equal(t, nestedPath, items[0].Path)
	assert.Equal(t, "sub-project1", items[0].DirName)

	assert.Equal(t, "project2", items[1].RelativePath)
	assert.Equal(t, topLevelPath, items[1].Path)
	assert.Equal(t, "project2", items[1].DirName)
}

func TestProjectService_SyncProjectsFromFileSystem_RespectsConfiguredScanMaxDepth(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	topLevelPath := createComposeProjectDir(t, projectsRoot, "project1")
	createComposeProjectDir(t, projectsRoot, filepath.Join("group", "project2"))

	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
	t.Setenv("PROJECT_SCAN_MAX_DEPTH", "1")

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))

	items, err := svc.ListAllProjects(ctx)
	require.NoError(t, err)
	require.Len(t, items, 1)
	assert.Equal(t, "project1", items[0].Name)
	assert.Equal(t, topLevelPath, items[0].Path)
}

func TestProjectService_ListProjects_LoadsProjectIconFromGlobalEnvInIncludedMetadata(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

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

	require.NoError(t, os.WriteFile(
		filepath.Join(projectsRoot, projects.GlobalEnvFileName),
		[]byte("ICON_CDN_URL=https://cdn.jsdelivr.net/gh/selfhst/icons@main\n"),
		0o600,
	))

	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(`include:
  - metadata.yaml
services:
  watchtower:
    image: nickfedor/watchtower:latest
`), 0o600))

	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "metadata.yaml"), []byte(`x-watchtower-icon-light: &watchtower-icon "${ICON_CDN_URL:+${ICON_CDN_URL}/svg/watchtower.svg}"
x-arcane:
  icon-light: *watchtower-icon
  icon-dark: *watchtower-icon
services:
  watchtower:
    labels:
      com.getarcaneapp.arcane.icon-light: *watchtower-icon
      com.getarcaneapp.arcane.icon-dark: *watchtower-icon
`), 0o600))

	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))

	items, page, err := svc.ListProjects(ctx, pagination.QueryParams{
		Sort: "path", Order: pagination.SortAsc,
		Limit: -1,
	})
	require.NoError(t, err)
	require.EqualValues(t, 1, page.TotalItems)
	require.Len(t, items, 1)
	assert.Equal(t, "https://cdn.jsdelivr.net/gh/selfhst/icons@main/svg/watchtower.svg", items[0].IconLightURL)
	assert.Equal(t, "https://cdn.jsdelivr.net/gh/selfhst/icons@main/svg/watchtower.svg", items[0].IconDarkURL)
}

func TestProjectService_SyncProjectsFromFileSystem_RemovesDeletedNestedProject(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	projectPath := createComposeProjectDir(t, projectsRoot, filepath.Join("main-project", "sub-project1"))

	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))

	items, err := svc.ListAllProjects(ctx)
	require.NoError(t, err)
	require.Len(t, items, 1)

	require.NoError(t, os.Remove(filepath.Join(projectPath, "compose.yaml")))
	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))

	items, err = svc.ListAllProjects(ctx)
	require.NoError(t, err)
	assert.Empty(t, items)
}

// TestProjectService_SyncProjectsFromFileSystem_PrunesLeakedScratchRow verifies a
// phantom project row imported from a leaked gitops scratch dir is pruned and not
// re-imported, while a real project is kept. This closes the "deleted projects
// resurrected on restart" loop for gitops scratch leftovers.
func TestProjectService_SyncProjectsFromFileSystem_PrunesLeakedScratchRow(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))

	createComposeProjectDir(t, projectsRoot, "app")

	scratchName := ".gitops-backup-9"
	scratchPath := createComposeProjectDir(t, projectsRoot, scratchName)
	require.NoError(t, db.Create(&Project{
		ID:      "phantom-scratch",
		Name:    scratchName,
		DirName: &scratchName,
		Path:    scratchPath,
	}).Error)

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))

	items, err := svc.ListAllProjects(ctx)
	require.NoError(t, err)
	require.Len(t, items, 1)
	assert.Equal(t, "app", items[0].Name)
}

func TestProjectService_SyncProjectsFromFileSystem_PreservesProjectsWhenDirectoryEmptyOrUnmounted(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	// An existing-but-empty projects directory simulates a mis-mapped or unmounted
	// projects volume: GetProjectsDirectory resolves (and MkdirAll's) it, discovery
	// finds nothing, and every stored project path is now missing on disk.
	projectsRoot := t.TempDir()
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))

	// Seed a small deployment's worth of filesystem-managed projects whose
	// directories do not exist. Each would individually be pruned as "directory no
	// longer exists"; together they would wipe the table — exactly what the
	// mass-wipe guard must prevent, even for deployments with only a handful of
	// projects (the guard must not give small installs a free pass).
	const seeded = 3
	for i := range seeded {
		require.NoError(t, db.WithContext(ctx).Create(&Project{
			Name:   fmt.Sprintf("project-%d", i),
			Path:   filepath.Join(projectsRoot, fmt.Sprintf("project-%d", i)),
			Status: ProjectStatusStopped,
		}).Error)
	}

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))

	items, err := svc.ListAllProjects(ctx)
	require.NoError(t, err)
	assert.Len(t, items, seeded, "an empty/mis-mapped projects directory must not wipe existing project records")
}

func TestProjectService_SyncProjectsFromFileSystem_PreservesProjectWithAmbiguousCustomCompose(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	projectPath := createComposeProjectDir(t, projectsRoot, "ambiguous-project")

	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))

	items, err := svc.ListAllProjects(ctx)
	require.NoError(t, err)
	require.Len(t, items, 1)

	// Replace the standard compose.yaml with two custom-named compose files. The
	// directory still holds compose content, but DetectComposeFile can't pick one
	// and returns common.ErrComposeFileNotFound. The reconcile must NOT delete the
	// record: the project's files are intact on disk and it may be deployable.
	require.NoError(t, os.Remove(filepath.Join(projectPath, "compose.yaml")))
	composeBody := []byte("services:\n  app:\n    image: nginx:alpine\n")
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "app.yaml"), composeBody, 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "extra.yaml"), composeBody, 0o644))

	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))

	items, err = svc.ListAllProjects(ctx)
	require.NoError(t, err)
	assert.Len(t, items, 1, "project with ambiguous compose files must not be deleted")
	assert.Equal(t, projectPath, items[0].Path)
}

func TestProjectService_SyncProjectsFromFileSystem_RemovesProjectsBeyondReducedScanMaxDepth(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	topLevelPath := createComposeProjectDir(t, projectsRoot, "project1")
	nestedPath := createComposeProjectDir(t, projectsRoot, filepath.Join("group", "project2"))

	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))

	// Initial sync at the default scan depth discovers both the top-level and
	// the nested project, persisting them to the database.
	defaultSvc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	require.NoError(t, defaultSvc.SyncProjectsFromFileSystem(ctx))

	items, err := defaultSvc.ListAllProjects(ctx)
	require.NoError(t, err)
	require.Len(t, items, 2)

	// Lowering the scan depth must prune the nested project from the database on
	// the next sync, even though its compose file still exists on disk.
	t.Setenv("PROJECT_SCAN_MAX_DEPTH", "1")
	depthLimitedSvc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	require.NoError(t, depthLimitedSvc.SyncProjectsFromFileSystem(ctx))

	items, err = depthLimitedSvc.ListAllProjects(ctx)
	require.NoError(t, err)
	require.Len(t, items, 1)
	assert.Equal(t, "project1", items[0].Name)
	assert.Equal(t, topLevelPath, items[0].Path)

	// The pruned project's files must remain untouched on disk so raising the
	// depth again re-discovers it.
	assert.FileExists(t, filepath.Join(nestedPath, "compose.yaml"))
}

func TestProjectService_SyncProjectsFromFileSystem_PreservesDBRecordsWhenDirectoryUnreadable(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skip("POSIX permission-denied behavior is not portable to Windows")
	}
	if os.Geteuid() == 0 {
		t.Skip("test requires a non-root UID to trigger permission-denied on ReadDir")
	}

	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	createComposeProjectDir(t, projectsRoot, "project1")

	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))

	before, err := svc.ListAllProjects(ctx)
	require.NoError(t, err)
	require.Len(t, before, 1)

	unreadable := t.TempDir()
	require.NoError(t, os.Chmod(unreadable, 0))
	t.Cleanup(func() { _ = os.Chmod(unreadable, 0o700) })

	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", unreadable))

	syncErr := svc.SyncProjectsFromFileSystem(ctx)
	require.Error(t, syncErr, "sync should propagate the permission-denied error")

	after, err := svc.ListAllProjects(ctx)
	require.NoError(t, err)
	assert.Len(t, after, 1, "DB records must not be wiped when discovery fails")
	assert.Equal(t, before[0].Path, after[0].Path)
}

// TestProjectService_SyncProjectsFromFileSystem_DiscoversReadableProjectsDespiteUnreadableNestedSibling
// covers the regression from GitHub issue #3080: a permission-denied error on a
// non-root nested subdirectory used to abort discovery of ALL projects. Unlike
// TestProjectService_SyncProjectsFromFileSystem_PreservesDBRecordsWhenDirectoryUnreadable
// above (which makes the projects ROOT itself unreadable and expects sync to still
// error), this test makes only a NESTED subdirectory unreadable and expects sync to
// succeed, discover the readable sibling project, and leave alone any existing DB
// record whose path happens to live under the now-skipped unreadable subtree.
func TestProjectService_SyncProjectsFromFileSystem_DiscoversReadableProjectsDespiteUnreadableNestedSibling(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skip("POSIX permission-denied behavior is not portable to Windows")
	}
	if os.Geteuid() == 0 {
		t.Skip("test requires a non-root UID to trigger permission-denied on ReadDir")
	}

	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	project1Path := createComposeProjectDir(t, projectsRoot, "project1")

	unreadableDir := filepath.Join(projectsRoot, "adguard-cheetah", "workingdir")
	require.NoError(t, os.MkdirAll(unreadableDir, 0o755))
	t.Cleanup(func() { _ = os.Chmod(unreadableDir, 0o700) })
	require.NoError(t, os.Chmod(unreadableDir, 0))

	// Seed a DB row (bypassing the filesystem) whose Path sits under the
	// now-unreadable subtree, simulating a project Arcane previously knew about.
	strandedDirName := "stranded-project"
	require.NoError(t, db.Create(&Project{
		ID:      "stranded-under-unreadable",
		Name:    "stranded-project",
		DirName: &strandedDirName,
		Path:    filepath.Join(unreadableDir, "stranded-project"),
		Status:  ProjectStatusStopped,
	}).Error)

	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx), "sync must succeed despite the unreadable nested directory")

	after, err := svc.ListAllProjects(ctx)
	require.NoError(t, err)

	var foundReadableSibling bool
	var foundStrandedRecord bool
	for _, p := range after {
		if p.Path == project1Path {
			foundReadableSibling = true
		}
		if p.ID == "stranded-under-unreadable" {
			foundStrandedRecord = true
		}
	}

	assert.True(t, foundReadableSibling, "readable sibling project must still be discovered")
	// evaluateProjectCleanup only prunes on os.IsNotExist; a permission-denied
	// stat falls into the "keep the record" branch, so the stranded record must survive.
	assert.True(t, foundStrandedRecord, "DB record under the unreadable subtree must not be pruned by a permission-denied stat")
}

func TestProjectService_SyncProjectsFromFileSystem_AllowsDuplicateLeafDirectoriesInDifferentParents(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	firstPath := createComposeProjectDir(t, projectsRoot, filepath.Join("main-project1", "app"))
	secondPath := createComposeProjectDir(t, projectsRoot, filepath.Join("main-project2", "app"))

	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))

	var items []Project
	require.NoError(t, db.WithContext(ctx).Order("path asc").Find(&items).Error)
	require.Len(t, items, 2)

	require.NotNil(t, items[0].DirName)
	require.NotNil(t, items[1].DirName)
	assert.Equal(t, "app", *items[0].DirName)
	assert.Equal(t, "app", *items[1].DirName)
	assert.Equal(t, firstPath, items[0].Path)
	assert.Equal(t, secondPath, items[1].Path)
}

func TestProjectService_SyncProjectsFromFileSystem_DetectsNestedSymlinkedProjectDirsWhenEnabled(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	targetRoot := t.TempDir()
	targetPath := createComposeProjectDir(t, targetRoot, filepath.Join("main-project", "sub-project1"))
	linkPath := filepath.Join(projectsRoot, "linked-root")
	require.NoError(t, os.Symlink(filepath.Join(targetRoot, "main-project"), linkPath))

	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
	require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "true"))

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))

	items, page, err := svc.ListProjects(ctx, pagination.QueryParams{
		Sort: "path", Order: pagination.SortAsc,
		Limit: -1,
	})
	require.NoError(t, err)
	require.EqualValues(t, 1, page.TotalItems)
	require.Len(t, items, 1)
	assert.Equal(t, filepath.Join(linkPath, "sub-project1"), items[0].Path)
	assert.Equal(t, "linked-root/sub-project1", items[0].RelativePath)
	assert.Equal(t, targetPath, filepath.Join(targetRoot, "main-project", "sub-project1"))
}

func TestProjectService_SyncProjectsFromFileSystem_RemovesSymlinkedProjectsWhenDisabled(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	targetRoot := t.TempDir()
	linkTarget := createComposeProjectDir(t, targetRoot, "linked-target")
	linkPath := filepath.Join(projectsRoot, "linked")
	require.NoError(t, os.Symlink(linkTarget, linkPath))

	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
	require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "true"))

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))

	items, err := svc.ListAllProjects(ctx)
	require.NoError(t, err)
	require.Len(t, items, 1)

	require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "false"))
	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))

	items, err = svc.ListAllProjects(ctx)
	require.NoError(t, err)
	assert.Empty(t, items)

	_, statErr := os.Lstat(linkPath)
	require.NoError(t, statErr)
}

func TestProjectService_SyncProjectsFromFileSystem_RefreshesServiceCountOnComposeChange(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	projectPath := createComposeProjectDir(t, projectsRoot, "demo")

	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))

	var project Project
	require.NoError(t, db.WithContext(ctx).Where("path = ?", projectPath).First(&project).Error)
	assert.Equal(t, 1, project.ServiceCount)

	updatedCompose := "services:\n  app:\n    image: nginx:alpine\n  worker:\n    image: busybox:latest\n"
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(updatedCompose), 0o644))

	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
	require.NoError(t, db.WithContext(ctx).Where("id = ?", project.ID).First(&project).Error)
	assert.Equal(t, 2, project.ServiceCount)
}

func TestProjectService_SyncProjectsFromFileSystem_AlignsNameToEffectiveComposeName(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))

	projectPath := createComposeProjectDir(t, projectsRoot, "aitools")
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(`name: ai_tools
services:
  app:
    image: nginx:alpine
`), 0o644))

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))

	var project Project
	require.NoError(t, db.WithContext(ctx).Where("path = ?", projectPath).First(&project).Error)
	assert.Equal(t, "ai_tools", project.Name)
	require.NotNil(t, project.DirName)
	assert.Equal(t, "aitools", *project.DirName)
	require.NotNil(t, project.ComposeProjectName)
	assert.Equal(t, "ai_tools", *project.ComposeProjectName)
}

func TestProjectService_SyncProjectsFromFileSystem_PreservesValidCustomNameWithoutExplicitComposeName(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))

	projectPath := createComposeProjectDir(t, projectsRoot, "folder-name")
	dirName := "folder-name"
	project := &Project{
		ID:      "proj-custom-name",
		Name:    "custom-name",
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))

	var fromDB Project
	require.NoError(t, db.WithContext(ctx).Where("id = ?", project.ID).First(&fromDB).Error)
	assert.Equal(t, "custom-name", fromDB.Name)
	require.NotNil(t, fromDB.DirName)
	assert.Equal(t, "folder-name", *fromDB.DirName)
	require.Nil(t, fromDB.ComposeProjectName)
}

func TestProjectService_SyncProjectsFromFileSystem_PreservesGitOpsProjectWithCustomComposeFilename(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()
	require.NoError(t, db.AutoMigrate(&GitOpsSync{}))

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	projectDir := filepath.Join(projectsRoot, "Radarr-3")
	require.NoError(t, os.MkdirAll(projectDir, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(projectDir, "radarr.yaml"), []byte("services:\n  app:\n    image: lscr.io/linuxserver/radarr:latest\n"), 0o644))

	syncProjectID := "proj-custom-compose"
	syncID := "sync-custom-compose"
	gitOpsSync := &GitOpsSync{
		ID:            syncID,
		Name:          "Radarr Sync",
		EnvironmentID: "0",
		RepositoryID:  "repo-1",
		ComposePath:   "apps/media/radarr.yaml",
		ProjectName:   "Radarr",
		ProjectID:     &syncProjectID,
		SyncDirectory: true,
	}
	require.NoError(t, db.Create(gitOpsSync).Error)

	project := &Project{
		ID:              syncProjectID,
		Name:            "Radarr",
		DirName:         new("Radarr-3"),
		Path:            projectDir,
		Status:          ProjectStatusStopped,
		GitOpsManagedBy: &syncID,
	}
	require.NoError(t, db.Create(project).Error)

	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))

	items, err := svc.ListAllProjects(ctx)
	require.NoError(t, err)
	require.Len(t, items, 1)
	assert.Equal(t, syncProjectID, items[0].ID)
	assert.Equal(t, projectDir, items[0].Path)
	assert.Equal(t, syncID, *items[0].GitOpsManagedBy)
}

func TestProjectService_GetProjectDetails_UsesGitOpsCustomComposeFilename(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()
	require.NoError(t, db.AutoMigrate(&GitOpsSync{}))

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	projectDir := filepath.Join(projectsRoot, "Radarr-3")
	composeContent := "services:\n  app:\n    image: lscr.io/linuxserver/radarr:latest\n"
	require.NoError(t, os.MkdirAll(projectDir, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(projectDir, "radarr.yaml"), []byte(composeContent), 0o644))
	require.NoError(t, os.WriteFile(filepath.Join(projectDir, ".env"), []byte("TZ=UTC\n"), 0o644))

	syncProjectID := "proj-custom-compose-details"
	syncID := "sync-custom-compose-details"
	require.NoError(t, db.Create(&GitOpsSync{
		ID:            syncID,
		Name:          "Radarr Sync",
		EnvironmentID: "0",
		RepositoryID:  "repo-1",
		ComposePath:   "apps/media/radarr.yaml",
		ProjectName:   "Radarr",
		ProjectID:     &syncProjectID,
		SyncDirectory: true,
	}).Error)

	require.NoError(t, db.Create(&Project{
		ID:              syncProjectID,
		Name:            "Radarr",
		DirName:         new("Radarr-3"),
		Path:            projectDir,
		Status:          ProjectStatusStopped,
		GitOpsManagedBy: &syncID,
	}).Error)

	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	composeFromContent, envFromContent, _, err := svc.projectContent(ctx, syncProjectID)
	require.NoError(t, err)
	assert.Equal(t, composeContent, composeFromContent)
	assert.Equal(t, "TZ=UTC\n", envFromContent)

	details, err := svc.GetProjectDetails(ctx, syncProjectID, projecttypes.AllDetails())
	require.NoError(t, err)
	assert.Equal(t, "radarr.yaml", details.ComposeFileName)
	assert.Equal(t, composeContent, details.ComposeContent)
	assert.Equal(t, "TZ=UTC\n", details.EnvContent)
	assert.Len(t, details.Services, 1)
}

func TestProjectService_UpdateProject_WritesThroughSymlinkedProjectPath(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	targetRoot := t.TempDir()
	targetPath := createComposeProjectDir(t, targetRoot, "demo-target")
	linkPath := filepath.Join(projectsRoot, "demo")
	require.NoError(t, os.Symlink(targetPath, linkPath))

	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
	require.NoError(t, settingsService.SetStringSetting(ctx, "followProjectSymlinks", "true"))

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	project := &Project{
		ID:      "proj-symlink-update",
		Name:    "demo",
		DirName: new("demo"),
		Path:    linkPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	updatedCompose := "services:\n  app:\n    image: nginx:1.27-alpine\n"
	updatedEnv := "FOO=updated\n"

	updated, err := svc.UpdateProject(ctx, project.ID, nil, new(updatedCompose), new(updatedEnv), nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})

	require.NoError(t, err)
	require.NotNil(t, updated)
	assert.Equal(t, linkPath, updated.Path)

	composeBytes, readErr := os.ReadFile(filepath.Join(targetPath, "compose.yaml"))
	require.NoError(t, readErr)
	assert.Equal(t, updatedCompose, string(composeBytes))

	envBytes, readErr := os.ReadFile(filepath.Join(targetPath, ".env"))
	require.NoError(t, readErr)
	assert.Equal(t, updatedEnv, string(envBytes))
}

func TestProjectService_UpdateProject_WritesThroughExternalEnvSymlink(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
	projectPath := createComposeProjectDir(t, projectsRoot, "demo")
	targetPath := filepath.Join(t.TempDir(), "project.env")
	targetPerm := os.FileMode(0o640)
	require.NoError(t, os.WriteFile(targetPath, []byte("FOO=original\n"), targetPerm))
	require.NoError(t, os.Chmod(targetPath, targetPerm))

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

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	dirName := "demo"
	project := &Project{
		ID:      "proj-external-env-symlink-update",
		Name:    dirName,
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	updatedEnv := "FOO=updated\n"
	updated, err := svc.UpdateProject(ctx, project.ID, nil, nil, &updatedEnv, nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})

	require.NoError(t, err)
	require.NotNil(t, updated)
	targetContent, err := os.ReadFile(targetPath)
	require.NoError(t, err)
	assert.Equal(t, updatedEnv, string(targetContent))
	currentLinkTarget, err := os.Readlink(envPath)
	require.NoError(t, err)
	assert.Equal(t, originalLinkTarget, currentLinkTarget)
	linkInfo, err := os.Lstat(envPath)
	require.NoError(t, err)
	require.NotZero(t, linkInfo.Mode()&os.ModeSymlink)
	if runtime.GOOS != "windows" {
		targetInfo, statErr := os.Stat(targetPath)
		require.NoError(t, statErr)
		assert.Equal(t, targetPerm, targetInfo.Mode().Perm())
	}
}

func TestProjectService_UpdateProject_RestoresExternalEnvSymlinkTargetWhenProjectSaveFails(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	projectsRoot := t.TempDir()
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsRoot))
	projectPath := createComposeProjectDir(t, projectsRoot, "demo")
	targetPath := filepath.Join(t.TempDir(), "project.env")
	originalContent := "FOO=original\n"
	targetPerm := os.FileMode(0o640)
	require.NoError(t, os.WriteFile(targetPath, []byte(originalContent), targetPerm))
	require.NoError(t, os.Chmod(targetPath, targetPerm))

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

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	dirName := "demo"
	project := &Project{
		ID:      "proj-external-env-symlink-rollback",
		Name:    dirName,
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	require.NoError(t, db.Callback().Update().Before("gorm:update").Register("arcane_test_external_env_project_save_failure", func(tx *gorm.DB) {
		if tx.Statement.Schema != nil && tx.Statement.Schema.Name == "Project" {
			_ = tx.AddError(errors.New("forced project save failure"))
		}
	}))

	updatedEnv := "FOO=updated\n"
	_, err = svc.UpdateProject(ctx, project.ID, nil, nil, &updatedEnv, nil, usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "forced project save failure")

	targetContent, err := os.ReadFile(targetPath)
	require.NoError(t, err)
	assert.Equal(t, originalContent, string(targetContent))
	currentLinkTarget, err := os.Readlink(envPath)
	require.NoError(t, err)
	assert.Equal(t, originalLinkTarget, currentLinkTarget)
	linkInfo, err := os.Lstat(envPath)
	require.NoError(t, err)
	require.NotZero(t, linkInfo.Mode()&os.ModeSymlink)
	if runtime.GOOS != "windows" {
		targetInfo, statErr := os.Stat(targetPath)
		require.NoError(t, statErr)
		assert.Equal(t, targetPerm, targetInfo.Mode().Perm())
	}
}

func createComposeProjectDir(t *testing.T, root, name string) string {
	t.Helper()

	projectPath := filepath.Join(root, name)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n  app:\n    image: nginx:alpine\n"), 0o644))

	return projectPath
}

func configureProjectRuntimeDocker(t *testing.T, containers []container.Summary) *httptest.Server {
	t.Helper()

	server := newProjectRuntimeDockerServer(t, containers)
	t.Setenv("DOCKER_HOST", dockerHostFromProjectRuntimeServerURL(t, server.URL))
	return server
}

func projectUpdatePreviewDirs(t *testing.T, projectsDir string) []string {
	t.Helper()

	matches, err := filepath.Glob(filepath.Join(projectsDir, ".project-update-preview-*"))
	require.NoError(t, err)
	return matches
}

func newProjectRuntimeDockerServer(t *testing.T, containers []container.Summary) *httptest.Server {
	t.Helper()

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case strings.HasSuffix(r.URL.Path, "/_ping"):
			_, _ = io.WriteString(w, "OK")
		case strings.HasSuffix(r.URL.Path, "/version"):
			w.Header().Set("Content-Type", "application/json")
			_ = json.NewEncoder(w).Encode(map[string]string{
				"ApiVersion":    "1.41",
				"MinAPIVersion": "1.24",
				"Version":       "24.0.0",
			})
		case strings.HasSuffix(r.URL.Path, "/containers/json"):
			w.Header().Set("Content-Type", "application/json")
			_ = json.NewEncoder(w).Encode(containers)
		case strings.Contains(r.URL.Path, "/containers/") && strings.HasSuffix(r.URL.Path, "/json"):
			containerID := strings.TrimSuffix(strings.TrimPrefix(r.URL.Path[strings.LastIndex(r.URL.Path, "/containers/"):], "/containers/"), "/json")
			for _, c := range containers {
				if c.ID != containerID {
					continue
				}
				w.Header().Set("Content-Type", "application/json")
				_ = json.NewEncoder(w).Encode(container.InspectResponse{
					ID: c.ID,
					State: &container.State{
						Status:  c.State,
						Running: c.State == container.StateRunning,
					},
				})
				return
			}
			http.NotFound(w, r)
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(server.Close)
	return server
}

func dockerHostFromProjectRuntimeServerURL(t *testing.T, serverURL string) string {
	t.Helper()

	parsed, err := url.Parse(serverURL)
	require.NoError(t, err)
	return "tcp://" + parsed.Host
}

func TestResolveRemoveOrphans(t *testing.T) {
	tests := []struct {
		name          string
		gitOpsManaged bool
		options       *projecttypes.DeployOptions
		want          bool
	}{
		{name: "non-gitops, nil options", gitOpsManaged: false, options: nil, want: false},
		{name: "non-gitops, flag false", gitOpsManaged: false, options: &projecttypes.DeployOptions{RemoveOrphans: false}, want: false},
		{name: "non-gitops, flag true opts in", gitOpsManaged: false, options: &projecttypes.DeployOptions{RemoveOrphans: true}, want: true},
		{name: "gitops, nil options stays true", gitOpsManaged: true, options: nil, want: true},
		{name: "gitops, flag false stays true", gitOpsManaged: true, options: &projecttypes.DeployOptions{RemoveOrphans: false}, want: true},
		{name: "gitops, flag true stays true", gitOpsManaged: true, options: &projecttypes.DeployOptions{RemoveOrphans: true}, want: true},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			require.Equal(t, tt.want, projects.ResolveRemoveOrphans(tt.gitOpsManaged, tt.options))
		})
	}
}

func TestProjectService_RecoverProjectRenameJournals_RollsBackUncommittedDirectoryRename(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	projectsDir := t.TempDir()
	oldDir := "nginx"
	newDir := "web"
	oldPath := filepath.Join(projectsDir, oldDir)
	newPath := filepath.Join(projectsDir, newDir)
	require.NoError(t, os.MkdirAll(newPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(newPath, "compose.yaml"), []byte("services: {}\n"), 0o600))

	project := &Project{
		ID:      "proj-rename-recovery",
		Name:    "nginx",
		DirName: &oldDir,
		Path:    oldPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    oldPath,
		NewPath:    newPath,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseTargetsCopied,
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	require.NoError(t, svc.RecoverProjectRenameJournals(ctx))

	require.FileExists(t, filepath.Join(oldPath, "compose.yaml"))
	require.NoDirExists(t, newPath)
	_, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok)

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	require.Equal(t, "nginx", fromDB.Name)
	require.Equal(t, oldPath, fromDB.Path)
	require.NotNil(t, fromDB.DirName)
	require.Equal(t, oldDir, *fromDB.DirName)
}

func TestProjectService_RecoverProjectRenameJournals_StartedPhaseSkipsVolumeRollback(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	projectsDir := t.TempDir()
	oldDir := "nginx"
	newDir := "web"
	oldPath := filepath.Join(projectsDir, oldDir)
	newPath := filepath.Join(projectsDir, newDir)
	require.NoError(t, os.MkdirAll(oldPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(oldPath, "compose.yaml"), []byte("services: {}\n"), 0o600))

	project := &Project{
		ID:      "proj-rename-started-volume-recovery",
		Name:    "nginx",
		DirName: &oldDir,
		Path:    oldPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    oldPath,
		NewPath:    newPath,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseStarted,
		Volumes: []volumetypes.JournalVolume{
			{
				Key:     "data",
				OldName: "nginx_data",
				NewName: "web_data",
			},
		},
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	require.NoError(t, svc.RecoverProjectRenameJournals(ctx))

	require.FileExists(t, filepath.Join(oldPath, "compose.yaml"))
	require.NoDirExists(t, newPath)
	_, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok)

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	require.Equal(t, "nginx", fromDB.Name)
	require.Equal(t, oldPath, fromDB.Path)
	require.NotNil(t, fromDB.DirName)
	require.Equal(t, oldDir, *fromDB.DirName)
}

func TestProjectService_RecoverProjectRenameJournals_RelocatesTargetWhenBothPathsExist(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	projectsDir := t.TempDir()
	oldDir := "nginx"
	newDir := "web"
	oldPath := filepath.Join(projectsDir, oldDir)
	newPath := filepath.Join(projectsDir, newDir)
	require.NoError(t, os.MkdirAll(oldPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(oldPath, "compose.yaml"), []byte("services: {}\n"), 0o600))
	require.NoError(t, os.MkdirAll(newPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(newPath, "compose.yaml"), []byte("services: {}\n"), 0o600))

	project := &Project{
		ID:      "proj-rename-both-paths",
		Name:    "nginx",
		DirName: &oldDir,
		Path:    oldPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    oldPath,
		NewPath:    newPath,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseStarted,
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	require.NoError(t, svc.RecoverProjectRenameJournals(ctx))

	_, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok)
	require.FileExists(t, filepath.Join(oldPath, "compose.yaml"))
	require.NoDirExists(t, newPath)

	conflictPaths, err := filepath.Glob(filepath.Join(projectsDir, ".web.rename-conflict-*"))
	require.NoError(t, err)
	require.Len(t, conflictPaths, 1)
	require.FileExists(t, filepath.Join(conflictPaths[0], "compose.yaml"))

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	require.Equal(t, "nginx", fromDB.Name)
	require.Equal(t, oldPath, fromDB.Path)
	require.NotNil(t, fromDB.DirName)
	require.Equal(t, oldDir, *fromDB.DirName)

	newName := "web"
	require.NoError(t, svc.applyProjectUpdate(t.Context(), &fromDB, newName, projectsDir, nil, nil, nil, nil, nil))
	require.Equal(t, "web", fromDB.Name)
	require.Equal(t, newPath, fromDB.Path)
	require.DirExists(t, newPath)
}

func TestProjectService_RecoverProjectRenameJournals_ClearsStartedJournalWhenDirectoryPathsMissing(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	projectsDir := t.TempDir()
	oldDir := "nginx"
	newDir := "web"
	oldPath := filepath.Join(projectsDir, oldDir)
	newPath := filepath.Join(projectsDir, newDir)

	project := &Project{
		ID:      "proj-rename-missing-paths",
		Name:    "nginx",
		DirName: &oldDir,
		Path:    oldPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    oldPath,
		NewPath:    newPath,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseStarted,
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	require.NoError(t, svc.RecoverProjectRenameJournals(ctx))

	_, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok)
	require.NoDirExists(t, oldPath)
	require.NoDirExists(t, newPath)
}

func TestProjectService_RecoverProjectRenameJournals_ClearsPreservedTargetJournalWhenPathExists(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	projectsDir := t.TempDir()
	oldDir := "nginx"
	newDir := "web"
	oldPath := filepath.Join(projectsDir, oldDir)
	newPath := filepath.Join(projectsDir, newDir)
	require.NoError(t, os.MkdirAll(oldPath, 0o755))

	project := &Project{
		ID:      "proj-rename-preserved-target",
		Name:    "nginx",
		DirName: &oldDir,
		Path:    oldPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	var targetRemoved bool
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
			http.NotFound(w, r)
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode(map[string]any{"Name": "web_data"})) {
				return
			}
		case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
			targetRemoved = true
			w.WriteHeader(http.StatusNoContent)
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(server.Close)

	kvService := kv.NewKVService(db)
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		&docker.DockerClientService{Client: newTestDockerClient(t, server)},
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    oldPath,
		NewPath:    newPath,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseTargetsCopied,
		Volumes: []volumetypes.JournalVolume{
			{
				Key:     "data",
				OldName: "nginx_data",
				NewName: "web_data",
			},
		},
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	require.NoError(t, svc.RecoverProjectRenameJournals(ctx))

	_, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok)
	require.False(t, targetRemoved, "preserved target volume should remain for manual inspection")
	require.DirExists(t, oldPath)
}

func TestProjectService_RecoverProjectRenameJournals_ClearsCommittedJournal(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	projectsDir := t.TempDir()
	oldDir := "nginx"
	newDir := "web"
	oldPath := filepath.Join(projectsDir, oldDir)
	newPath := filepath.Join(projectsDir, newDir)
	require.NoError(t, os.MkdirAll(newPath, 0o755))

	project := &Project{
		ID:      "proj-rename-committed",
		Name:    "web",
		DirName: &newDir,
		Path:    newPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    oldPath,
		NewPath:    newPath,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseOldVolumesRemoved,
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	require.NoError(t, svc.RecoverProjectRenameJournals(ctx))

	_, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok)
	require.DirExists(t, newPath)
}

func TestProjectService_FinalizeProjectRenameAfterCommit_ClearsJournalAfterSourceCleanup(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	oldDir := "nginx"
	newDir := "web"
	project := &Project{
		ID:      "proj-rename-old-volumes-removed",
		Name:    "web",
		DirName: &newDir,
		Path:    filepath.Join(t.TempDir(), newDir),
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := &projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    filepath.Join(t.TempDir(), oldDir),
		NewPath:    project.Path,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseTargetsCopied,
	}
	require.NoError(t, svc.updates.WriteJournal(ctx, journal, projecttypes.RenameJournalPhaseTargetsCopied))

	migration := &fakeProjectVolumeRenameMigration{}
	journalActive := true
	projects.FinalizeRenameAfterCommit(ctx, svc.updates.Operations(), project.ID, migration, journal, &journalActive)
	require.True(t, migration.commitCalled)
	require.False(t, journalActive)

	_, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok)
}

func TestProjectService_FinalizeProjectRenameAfterCommit_KeepsJournalWhenSourceCleanupFails(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	oldDir := "nginx"
	newDir := "web"
	project := &Project{
		ID:      "proj-rename-cleanup-failure",
		Name:    "web",
		DirName: &newDir,
		Path:    filepath.Join(t.TempDir(), newDir),
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := &projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    filepath.Join(t.TempDir(), oldDir),
		NewPath:    project.Path,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseTargetsCopied,
	}
	require.NoError(t, svc.updates.WriteJournal(ctx, journal, projecttypes.RenameJournalPhaseTargetsCopied))

	migration := &fakeProjectVolumeRenameMigration{
		commitErr: volumes.NewSourceCleanupError("nginx_data", errors.New("source cleanup failed")),
	}
	journalActive := true
	projects.FinalizeRenameAfterCommit(ctx, svc.updates.Operations(), project.ID, migration, journal, &journalActive)
	require.True(t, migration.commitCalled)
	require.True(t, journalActive)

	raw, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.True(t, ok)

	var updatedJournal projecttypes.RenameJournal
	require.NoError(t, json.Unmarshal([]byte(raw), &updatedJournal))
	require.Equal(t, projecttypes.RenameJournalPhaseSourceCleanupPending, updatedJournal.Phase)
}

func TestProjectService_RecoverProjectRenameJournals_KeepsJournalWhenDirectoryRollbackFails(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	var targetRemoved atomic.Bool
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "nginx_data"})) {
				return
			}
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
			if targetRemoved.Load() {
				http.NotFound(w, r)
				return
			}
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "web_data"})) {
				return
			}
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/containers/json"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode([]container.Summary{})) {
				return
			}
		case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
			targetRemoved.Store(true)
			w.WriteHeader(http.StatusNoContent)
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(server.Close)

	projectsDir := t.TempDir()
	oldDir := "nginx"
	newDir := "web"
	oldPath := filepath.Join(projectsDir, "missing-parent", oldDir)
	newPath := filepath.Join(projectsDir, newDir)
	require.NoError(t, os.MkdirAll(newPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(newPath, "compose.yaml"), []byte("services: {}\n"), 0o600))

	project := &Project{
		ID:      "proj-rename-directory-rollback-fails",
		Name:    "nginx",
		DirName: &oldDir,
		Path:    oldPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		dockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    oldPath,
		NewPath:    newPath,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseTargetsCopied,
		Volumes: []volumetypes.JournalVolume{
			{
				Key:     "data",
				OldName: "nginx_data",
				NewName: "web_data",
			},
		},
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	err = svc.RecoverProjectRenameJournals(ctx)
	require.Error(t, err)
	require.Contains(t, err.Error(), "rollback project directory rename")

	_, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.True(t, ok)
	require.True(t, targetRemoved.Load(), "target volume rollback should still run after directory rollback fails")
	require.FileExists(t, filepath.Join(newPath, "compose.yaml"), "failed directory rollback leaves the target path for retry")
	require.NoDirExists(t, oldPath)

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	require.Equal(t, "nginx", fromDB.Name)
	require.Equal(t, oldPath, fromDB.Path)
	require.NotNil(t, fromDB.DirName)
	require.Equal(t, oldDir, *fromDB.DirName)

	require.NoError(t, os.MkdirAll(filepath.Dir(oldPath), 0o755))
	require.NoError(t, svc.RecoverProjectRenameJournals(ctx))

	_, ok, err = kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok)
	require.FileExists(t, filepath.Join(oldPath, "compose.yaml"))
	require.NoDirExists(t, newPath)
}

func TestProjectService_RecoverProjectRenameJournals_CompletesCommittedVolumeJournalWithoutHelperImage(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	var imageInspectCalled atomic.Bool
	var oldVolumeRemoved atomic.Bool
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "web_data"})) {
				return
			}
		case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
			oldVolumeRemoved.Store(true)
			w.WriteHeader(http.StatusNoContent)
		case strings.Contains(r.URL.Path, "/images/"):
			imageInspectCalled.Store(true)
			http.NotFound(w, r)
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(server.Close)

	projectsDir := t.TempDir()
	oldDir := "nginx"
	newDir := "web"
	oldPath := filepath.Join(projectsDir, oldDir)
	newPath := filepath.Join(projectsDir, newDir)
	require.NoError(t, os.MkdirAll(newPath, 0o755))

	project := &Project{
		ID:      "proj-rename-committed-with-volumes",
		Name:    "web",
		DirName: &newDir,
		Path:    newPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		dockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    oldPath,
		NewPath:    newPath,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseOldVolumesRemoved,
		Volumes: []volumetypes.JournalVolume{
			{
				Key:     "data",
				OldName: "nginx_data",
				NewName: "web_data",
			},
		},
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	require.NoError(t, svc.RecoverProjectRenameJournals(ctx))

	_, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok)
	require.True(t, oldVolumeRemoved.Load(), "expected committed recovery to remove source volume")
	require.False(t, imageInspectCalled.Load(), "completion recovery should not inspect or pull the copy helper image")
}

func TestProjectService_RecoverProjectRenameJournals_RollsBackCommittedJournalWhenTargetMissingAndSourceExists(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	var oldVolumeRemoved atomic.Bool
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
			http.NotFound(w, r)
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "nginx_data"})) {
				return
			}
		case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
			oldVolumeRemoved.Store(true)
			w.WriteHeader(http.StatusNoContent)
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(server.Close)

	projectsDir := t.TempDir()
	oldDir := "nginx"
	newDir := "web"
	oldPath := filepath.Join(projectsDir, oldDir)
	newPath := filepath.Join(projectsDir, newDir)
	require.NoError(t, os.MkdirAll(newPath, 0o755))

	project := &Project{
		ID:      "proj-rename-missing-target-preserve-source",
		Name:    "web",
		DirName: &newDir,
		Path:    newPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		dockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    oldPath,
		NewPath:    newPath,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseOldVolumesRemoved,
		Volumes: []volumetypes.JournalVolume{
			{
				Key:     "data",
				OldName: "nginx_data",
				NewName: "web_data",
			},
		},
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	err = svc.RecoverProjectRenameJournals(ctx)
	require.NoError(t, err)
	require.False(t, oldVolumeRemoved.Load(), "source volume is the only remaining copy and must not be deleted")

	_, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok)
	require.DirExists(t, oldPath)
	require.NoDirExists(t, newPath)

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	require.Equal(t, "nginx", fromDB.Name)
	require.Equal(t, oldPath, fromDB.Path)
	require.NotNil(t, fromDB.DirName)
	require.Equal(t, oldDir, *fromDB.DirName)
}

func TestProjectService_RecoverProjectRenameJournals_ClearsJournalAfterDBRestoreWhenVolumeRollbackFails(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	var targetRemoveAttempts atomic.Int32
	var targetExists atomic.Bool
	var allowTargetRemove atomic.Bool
	targetExists.Store(true)
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
			http.NotFound(w, r)
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "nginx_data"})) {
				return
			}
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_cache"):
			if !targetExists.Load() {
				http.NotFound(w, r)
				return
			}
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "web_cache"})) {
				return
			}
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_cache"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "nginx_cache"})) {
				return
			}
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/containers/json"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode([]container.Summary{})) {
				return
			}
		case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_cache"):
			targetRemoveAttempts.Add(1)
			if allowTargetRemove.Load() {
				targetExists.Store(false)
				w.WriteHeader(http.StatusNoContent)
				return
			}
			http.Error(w, "volume busy", http.StatusInternalServerError)
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(server.Close)

	projectsDir := t.TempDir()
	oldDir := "nginx"
	newDir := "web"
	oldPath := filepath.Join(projectsDir, oldDir)
	newPath := filepath.Join(projectsDir, newDir)
	require.NoError(t, os.MkdirAll(newPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(newPath, "compose.yaml"), []byte("services: {}\n"), 0o600))

	project := &Project{
		ID:      "proj-rename-rollback-volume-fail",
		Name:    "web",
		DirName: &newDir,
		Path:    newPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		dockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    oldPath,
		NewPath:    newPath,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseProjectStateCommitted,
		Volumes: []volumetypes.JournalVolume{
			{
				Key:     "data",
				OldName: "nginx_data",
				NewName: "web_data",
			},
			{
				Key:     "cache",
				OldName: "nginx_cache",
				NewName: "web_cache",
			},
		},
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	err = svc.RecoverProjectRenameJournals(ctx)
	require.Error(t, err)
	require.ErrorContains(t, err, "remove rollback target volume web_cache")

	require.Positive(t, targetRemoveAttempts.Load())
	_, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok, "project-state journal should clear after database rollback succeeds")
	_, ok, err = kvService.Get(ctx, projecttypes.RenameRollbackCleanupKeyPrefix+project.ID)
	require.NoError(t, err)
	require.True(t, ok, "target cleanup should keep retry state when removal fails")
	require.FileExists(t, filepath.Join(oldPath, "compose.yaml"))
	require.NoDirExists(t, newPath)

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	require.Equal(t, "nginx", fromDB.Name)
	require.Equal(t, oldPath, fromDB.Path)
	require.NotNil(t, fromDB.DirName)
	require.Equal(t, oldDir, *fromDB.DirName)

	allowTargetRemove.Store(true)
	require.NoError(t, svc.RecoverProjectRenameJournals(ctx))

	_, ok, err = kvService.Get(ctx, projecttypes.RenameRollbackCleanupKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok)
	require.False(t, targetExists.Load())
}

func TestProjectService_RecoverProjectRenameJournals_KeepsRollbackCleanupWhenDockerUnavailable(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	projectsDir := t.TempDir()
	oldDir := "nginx"
	oldPath := filepath.Join(projectsDir, oldDir)
	require.NoError(t, os.MkdirAll(oldPath, 0o755))

	project := &Project{
		ID:      "proj-rename-rollback-cleanup-docker-unavailable",
		Name:    "nginx",
		DirName: &oldDir,
		Path:    oldPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	cleanup := projecttypes.RenameRollbackCleanup{
		ProjectID: project.ID,
		OldName:   "nginx",
		OldPath:   oldPath,
		NewName:   "web",
		NewPath:   filepath.Join(projectsDir, "web"),
		Volumes: []volumetypes.JournalVolume{
			{
				Key:     "data",
				OldName: "nginx_data",
				NewName: "web_data",
			},
		},
	}
	payload, err := json.Marshal(cleanup)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameRollbackCleanupKeyPrefix+project.ID, string(payload)))

	err = svc.RecoverProjectRenameJournals(ctx)
	require.Error(t, err)
	require.ErrorContains(t, err, "inspect source cleanup volume nginx_data")

	_, ok, err := kvService.Get(ctx, projecttypes.RenameRollbackCleanupKeyPrefix+project.ID)
	require.NoError(t, err)
	require.True(t, ok)
}

func TestProjectService_RecoverProjectRenameJournals_ClearsCommittedJournalWhenSourceAndTargetMissing(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
			http.NotFound(w, r)
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
			http.NotFound(w, r)
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(server.Close)

	projectsDir := t.TempDir()
	oldDir := "nginx"
	newDir := "web"
	oldPath := filepath.Join(projectsDir, oldDir)
	newPath := filepath.Join(projectsDir, newDir)
	require.NoError(t, os.MkdirAll(newPath, 0o755))

	project := &Project{
		ID:      "proj-rename-missing-both-volumes",
		Name:    "web",
		DirName: &newDir,
		Path:    newPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		dockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    oldPath,
		NewPath:    newPath,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseProjectStateCommitted,
		Volumes: []volumetypes.JournalVolume{
			{
				Key:     "data",
				OldName: "nginx_data",
				NewName: "web_data",
			},
		},
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	err = svc.RecoverProjectRenameJournals(ctx)
	require.NoError(t, err)

	_, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok)
	require.DirExists(t, newPath)
	require.NoDirExists(t, oldPath)

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	require.Equal(t, "web", fromDB.Name)
	require.Equal(t, newPath, fromDB.Path)
}

func TestProjectService_RecoverProjectRenameJournals_ClearsCommittedJournalAndCleansRemainingSourcesWhenSomeVolumesExternallyRemoved(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	var cacheSourceRemoved atomic.Bool
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
			http.NotFound(w, r)
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
			http.NotFound(w, r)
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_cache"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "web_cache"})) {
				return
			}
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_cache"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "nginx_cache"})) {
				return
			}
		case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/nginx_cache"):
			cacheSourceRemoved.Store(true)
			w.WriteHeader(http.StatusNoContent)
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(server.Close)

	projectsDir := t.TempDir()
	oldDir := "nginx"
	newDir := "web"
	oldPath := filepath.Join(projectsDir, oldDir)
	newPath := filepath.Join(projectsDir, newDir)
	require.NoError(t, os.MkdirAll(newPath, 0o755))

	project := &Project{
		ID:      "proj-rename-mixed-missing-volumes",
		Name:    "web",
		DirName: &newDir,
		Path:    newPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		dockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    oldPath,
		NewPath:    newPath,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseProjectStateCommitted,
		Volumes: []volumetypes.JournalVolume{
			{
				Key:     "data",
				OldName: "nginx_data",
				NewName: "web_data",
			},
			{
				Key:     "cache",
				OldName: "nginx_cache",
				NewName: "web_cache",
			},
		},
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	err = svc.RecoverProjectRenameJournals(ctx)
	require.NoError(t, err)

	_, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok)
	require.True(t, cacheSourceRemoved.Load(), "source volume should still be cleaned up when the target exists")
	require.DirExists(t, newPath)
	require.NoDirExists(t, oldPath)

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	require.Equal(t, "web", fromDB.Name)
	require.Equal(t, newPath, fromDB.Path)
}

func TestProjectService_RecoverProjectRenameJournals_MarksSourceCleanupPendingWhenCommittedCleanupFails(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	var sourceRemoveAttempts atomic.Int32
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "web_data"})) {
				return
			}
		case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
			sourceRemoveAttempts.Add(1)
			http.Error(w, "volume busy", http.StatusInternalServerError)
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(server.Close)

	projectsDir := t.TempDir()
	oldDir := "nginx"
	newDir := "web"
	oldPath := filepath.Join(projectsDir, oldDir)
	newPath := filepath.Join(projectsDir, newDir)
	require.NoError(t, os.MkdirAll(newPath, 0o755))

	project := &Project{
		ID:      "proj-rename-source-cleanup-fail",
		Name:    "web",
		DirName: &newDir,
		Path:    newPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		dockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    oldPath,
		NewPath:    newPath,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseProjectStateCommitted,
		Volumes: []volumetypes.JournalVolume{
			{
				Key:     "data",
				OldName: "nginx_data",
				NewName: "web_data",
			},
		},
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	err = svc.RecoverProjectRenameJournals(ctx)
	require.Error(t, err)
	var cleanupErr *volumetypes.SourceCleanupError
	require.ErrorAs(t, err, &cleanupErr)
	require.Equal(t, "nginx_data", cleanupErr.SourceVolume)
	require.Positive(t, sourceRemoveAttempts.Load())

	raw, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.True(t, ok)

	var updatedJournal projecttypes.RenameJournal
	require.NoError(t, json.Unmarshal([]byte(raw), &updatedJournal))
	require.Equal(t, projecttypes.RenameJournalPhaseSourceCleanupPending, updatedJournal.Phase)
	require.DirExists(t, newPath)
	require.NoDirExists(t, oldPath)

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	require.Equal(t, "web", fromDB.Name)
	require.Equal(t, newPath, fromDB.Path)
}

func TestProjectService_RecoverProjectRenameJournals_ClearsSourceCleanupPendingJournalAfterCleanup(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	var sourceRemoved atomic.Bool
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "web_data"})) {
				return
			}
		case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
			sourceRemoved.Store(true)
			w.WriteHeader(http.StatusNoContent)
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(server.Close)

	projectsDir := t.TempDir()
	oldDir := "nginx"
	newDir := "web"
	oldPath := filepath.Join(projectsDir, oldDir)
	newPath := filepath.Join(projectsDir, newDir)
	require.NoError(t, os.MkdirAll(newPath, 0o755))

	project := &Project{
		ID:      "proj-rename-source-cleanup-pending-clear",
		Name:    "web",
		DirName: &newDir,
		Path:    newPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		dockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    oldPath,
		NewPath:    newPath,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseSourceCleanupPending,
		Volumes: []volumetypes.JournalVolume{
			{
				Key:     "data",
				OldName: "nginx_data",
				NewName: "web_data",
			},
		},
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	err = svc.RecoverProjectRenameJournals(ctx)
	require.NoError(t, err)

	_, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok)
	require.True(t, sourceRemoved.Load())
	require.DirExists(t, newPath)
	require.NoDirExists(t, oldPath)
}

func TestProjectService_RecoverProjectRenameJournals_RollsBackSourceCleanupPendingWhenTargetMissing(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	var dataSourceRemoved atomic.Bool
	var dataTargetRemoved atomic.Bool
	var cacheTargetRemoved atomic.Bool
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
			http.NotFound(w, r)
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "nginx_data"})) {
				return
			}
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_cache"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "web_cache"})) {
				return
			}
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_cache"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "nginx_cache"})) {
				return
			}
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/containers/json"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode([]container.Summary{})) {
				return
			}
		case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
			dataSourceRemoved.Store(true)
			w.WriteHeader(http.StatusNoContent)
		case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
			dataTargetRemoved.Store(true)
			w.WriteHeader(http.StatusNoContent)
		case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_cache"):
			cacheTargetRemoved.Store(true)
			w.WriteHeader(http.StatusNoContent)
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(server.Close)

	projectsDir := t.TempDir()
	oldDir := "nginx"
	newDir := "web"
	oldPath := filepath.Join(projectsDir, oldDir)
	newPath := filepath.Join(projectsDir, newDir)
	require.NoError(t, os.MkdirAll(newPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(newPath, "compose.yaml"), []byte("services: {}\n"), 0o600))

	project := &Project{
		ID:      "proj-rename-source-cleanup-target-missing",
		Name:    "web",
		DirName: &newDir,
		Path:    newPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		dockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    oldPath,
		NewPath:    newPath,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseSourceCleanupPending,
		Volumes: []volumetypes.JournalVolume{
			{
				Key:     "data",
				OldName: "nginx_data",
				NewName: "web_data",
			},
			{
				Key:     "cache",
				OldName: "nginx_cache",
				NewName: "web_cache",
			},
		},
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	err = svc.RecoverProjectRenameJournals(ctx)
	require.NoError(t, err)

	_, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok)
	_, ok, err = kvService.Get(ctx, projecttypes.RenameRollbackCleanupKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok)
	require.False(t, dataSourceRemoved.Load(), "source volume is the remaining data copy and must not be removed")
	require.False(t, dataTargetRemoved.Load(), "missing target should not be removed")
	require.True(t, cacheTargetRemoved.Load(), "safe target volume should still be cleaned during rollback")
	require.FileExists(t, filepath.Join(oldPath, "compose.yaml"))
	require.NoDirExists(t, newPath)

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	require.Equal(t, "nginx", fromDB.Name)
	require.Equal(t, oldPath, fromDB.Path)
	require.NotNil(t, fromDB.DirName)
	require.Equal(t, oldDir, *fromDB.DirName)
}

func TestProjectService_RecoverProjectRenameJournals_KeepsSourceCleanupPendingJournalWhenCleanupFails(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	var sourceRemoveAttempts atomic.Int32
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "web_data"})) {
				return
			}
		case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
			sourceRemoveAttempts.Add(1)
			http.Error(w, "volume busy", http.StatusInternalServerError)
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(server.Close)

	projectsDir := t.TempDir()
	oldDir := "nginx"
	newDir := "web"
	oldPath := filepath.Join(projectsDir, oldDir)
	newPath := filepath.Join(projectsDir, newDir)
	require.NoError(t, os.MkdirAll(newPath, 0o755))

	project := &Project{
		ID:      "proj-rename-source-cleanup-pending-fail",
		Name:    "web",
		DirName: &newDir,
		Path:    newPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		dockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    oldPath,
		NewPath:    newPath,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseSourceCleanupPending,
		Volumes: []volumetypes.JournalVolume{
			{
				Key:     "data",
				OldName: "nginx_data",
				NewName: "web_data",
			},
		},
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	err = svc.RecoverProjectRenameJournals(ctx)
	require.Error(t, err)
	var cleanupErr *volumetypes.SourceCleanupError
	require.ErrorAs(t, err, &cleanupErr)
	require.Equal(t, "nginx_data", cleanupErr.SourceVolume)
	require.Positive(t, sourceRemoveAttempts.Load())

	raw, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.True(t, ok)

	var updatedJournal projecttypes.RenameJournal
	require.NoError(t, json.Unmarshal([]byte(raw), &updatedJournal))
	require.Equal(t, projecttypes.RenameJournalPhaseSourceCleanupPending, updatedJournal.Phase)
	require.DirExists(t, newPath)
	require.NoDirExists(t, oldPath)

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	require.Equal(t, "web", fromDB.Name)
	require.Equal(t, newPath, fromDB.Path)
}

func TestProjectService_RecoverProjectRenameJournals_ClearsStartedJournalWhenDirectoriesAreMissing(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	projectsDir := t.TempDir()
	oldDir := "nginx"
	newDir := "web"
	oldPath := filepath.Join(projectsDir, oldDir)
	newPath := filepath.Join(projectsDir, newDir)

	project := &Project{
		ID:      "proj-rename-missing-directories",
		Name:    "nginx",
		DirName: &oldDir,
		Path:    oldPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    oldPath,
		NewPath:    newPath,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseStarted,
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	require.NoError(t, svc.RecoverProjectRenameJournals(ctx))

	require.NoDirExists(t, oldPath)
	require.NoDirExists(t, newPath)
	_, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok)
}

func TestProjectService_RecoverProjectRenameJournals_ClearsMissingPathJournalWhenTargetPreserved(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	var targetRemoved atomic.Bool
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "web_data"})) {
				return
			}
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
			http.NotFound(w, r)
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/containers/json"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode([]container.Summary{})) {
				return
			}
		case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
			targetRemoved.Store(true)
			w.WriteHeader(http.StatusNoContent)
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(server.Close)

	projectsDir := t.TempDir()
	oldDir := "nginx"
	newDir := "web"
	oldPath := filepath.Join(projectsDir, oldDir)
	newPath := filepath.Join(projectsDir, newDir)

	project := &Project{
		ID:      "proj-rename-missing-path-preserved-target",
		Name:    "nginx",
		DirName: &oldDir,
		Path:    oldPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		dockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    oldPath,
		NewPath:    newPath,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseTargetsCopied,
		Volumes: []volumetypes.JournalVolume{
			{
				Key:     "data",
				OldName: "nginx_data",
				NewName: "web_data",
			},
		},
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	require.NoError(t, svc.RecoverProjectRenameJournals(ctx))

	_, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok)
	require.False(t, targetRemoved.Load(), "target volume may be the only complete copy and must stay when source restore fails")
	require.NoDirExists(t, oldPath)
	require.NoDirExists(t, newPath)

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	require.Equal(t, "nginx", fromDB.Name)
	require.Equal(t, oldPath, fromDB.Path)
}

func TestProjectService_RecoverProjectRenameJournals_ClearsJournalWhenRollbackSourceInspectFails(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	var targetRemoved atomic.Bool
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
			http.Error(w, "temporary docker error", http.StatusInternalServerError)
		case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
			targetRemoved.Store(true)
			w.WriteHeader(http.StatusNoContent)
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(server.Close)

	projectsDir := t.TempDir()
	oldDir := "nginx"
	newDir := "web"
	oldPath := filepath.Join(projectsDir, oldDir)
	newPath := filepath.Join(projectsDir, newDir)
	require.NoError(t, os.MkdirAll(oldPath, 0o755))

	project := &Project{
		ID:      "proj-rename-source-inspect-preserve",
		Name:    "nginx",
		DirName: &oldDir,
		Path:    oldPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		dockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    oldPath,
		NewPath:    newPath,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseTargetsCopied,
		Volumes: []volumetypes.JournalVolume{
			{
				Key:     "data",
				OldName: "nginx_data",
				NewName: "web_data",
			},
		},
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	require.NoError(t, svc.RecoverProjectRenameJournals(ctx))

	_, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok, "inspect uncertainty should not permanently block future renames")
	require.False(t, targetRemoved.Load(), "target volume must not be deleted when source inspection is uncertain")
	require.DirExists(t, oldPath)
	require.NoDirExists(t, newPath)

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	require.Equal(t, "nginx", fromDB.Name)
	require.Equal(t, oldPath, fromDB.Path)
}

func TestProjectService_RecoverProjectRenameJournals_ClearsJournalWhenRollbackTargetInspectFails(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	var targetRemoved atomic.Bool
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "nginx_data"})) {
				return
			}
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
			http.Error(w, "temporary docker error", http.StatusInternalServerError)
		case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
			targetRemoved.Store(true)
			w.WriteHeader(http.StatusNoContent)
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(server.Close)

	projectsDir := t.TempDir()
	oldDir := "nginx"
	newDir := "web"
	oldPath := filepath.Join(projectsDir, oldDir)
	newPath := filepath.Join(projectsDir, newDir)
	require.NoError(t, os.MkdirAll(oldPath, 0o755))

	project := &Project{
		ID:      "proj-rename-target-inspect-preserve",
		Name:    "nginx",
		DirName: &oldDir,
		Path:    oldPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		dockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    oldPath,
		NewPath:    newPath,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseTargetsCopied,
		Volumes: []volumetypes.JournalVolume{
			{
				Key:     "data",
				OldName: "nginx_data",
				NewName: "web_data",
			},
		},
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	require.NoError(t, svc.RecoverProjectRenameJournals(ctx))

	_, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok, "inspect uncertainty should not permanently block future renames")
	require.False(t, targetRemoved.Load(), "target volume must not be deleted when target inspection is uncertain")
	require.DirExists(t, oldPath)
	require.NoDirExists(t, newPath)

	var fromDB Project
	require.NoError(t, db.First(&fromDB, "id = ?", project.ID).Error)
	require.Equal(t, "nginx", fromDB.Name)
	require.Equal(t, oldPath, fromDB.Path)
}

func TestProjectService_RecoverProjectRenameJournals_ClearsJournalWhenTargetPreservedAndDirectoryRolledBack(t *testing.T) {
	db := setupProjectTestDB(t)
	require.NoError(t, db.AutoMigrate(&kv.KVEntry{}))
	ctx := t.Context()

	var targetRemoved atomic.Bool
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode(volume.Volume{Name: "web_data"})) {
				return
			}
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/volumes/nginx_data"):
			http.NotFound(w, r)
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/containers/json"):
			w.Header().Set("Content-Type", "application/json")
			if !assert.NoError(t, json.NewEncoder(w).Encode([]container.Summary{})) {
				return
			}
		case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/volumes/web_data"):
			targetRemoved.Store(true)
			w.WriteHeader(http.StatusNoContent)
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(server.Close)

	projectsDir := t.TempDir()
	oldDir := "nginx"
	newDir := "web"
	oldPath := filepath.Join(projectsDir, oldDir)
	newPath := filepath.Join(projectsDir, newDir)
	require.NoError(t, os.MkdirAll(newPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(newPath, "compose.yaml"), []byte("services: {}\n"), 0o600))

	project := &Project{
		ID:      "proj-rename-preserved-target-retry",
		Name:    "nginx",
		DirName: &oldDir,
		Path:    oldPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	kvService := kv.NewKVService(db)
	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, server)}
	svc := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		dockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kvService,
		testRegistryCredentials,
	)
	journal := projecttypes.RenameJournal{
		ProjectID:  project.ID,
		OldName:    "nginx",
		NewName:    "web",
		OldPath:    oldPath,
		NewPath:    newPath,
		OldDirName: &oldDir,
		NewDirName: newDir,
		Phase:      projecttypes.RenameJournalPhaseTargetsCopied,
		Volumes: []volumetypes.JournalVolume{
			{
				Key:     "data",
				OldName: "nginx_data",
				NewName: "web_data",
			},
		},
	}
	payload, err := json.Marshal(journal)
	require.NoError(t, err)
	require.NoError(t, kvService.Set(ctx, projecttypes.RenameJournalKeyPrefix+project.ID, string(payload)))

	err = svc.RecoverProjectRenameJournals(ctx)
	require.NoError(t, err)

	_, ok, err := kvService.Get(ctx, projecttypes.RenameJournalKeyPrefix+project.ID)
	require.NoError(t, err)
	require.False(t, ok, "preserved target data should not leave the project permanently blocked")
	require.False(t, targetRemoved.Load(), "target volume may be the only complete copy and must stay when source restore fails")
	require.FileExists(t, filepath.Join(oldPath, "compose.yaml"))
	require.NoDirExists(t, newPath)
}

func TestProjectPathMapperUsesCurrentSettings(t *testing.T) {
	db := setupProjectTestDB(t)
	settingsService, err := newSettingsServiceForTest(t, t.Context(), db)
	require.NoError(t, err)
	service := NewProjectService(nil, settingsService, nil, nil, testDockerService, testBuildBuilder{}, nil, nil, nil, nil, testRegistryCredentials)
	containerDir := t.TempDir()
	for _, hostDir := range []string{t.TempDir(), t.TempDir()} {
		require.NoError(t, settingsService.SetStringSetting(t.Context(), "projectsDirectory", containerDir+":"+hostDir))
		mapper := service.projectPathMapper(t.Context())
		require.NotNil(t, mapper)
		mapped, _, containerToHostErr := mapper.ContainerToHost(filepath.Join(containerDir, "data"))
		require.NoError(t, containerToHostErr)
		require.Equal(t, filepath.Join(hostDir, "data"), mapped)
	}
}

func TestPrepareProjectServiceImages(t *testing.T) {
	source := []byte(
		"\ufeff# operator configuration\r\n\r\nservices:\r\n  web:\r\n    image: \"app:${VERSION}\"   # keep this comment\r\n " +
			"   environment:\r\n      VERSION: ${VERSION}\r\n\r\n  worker:\r\n    image: 'app:1.2.0'  \r\n  tagged:\r\n    " +
			"image: !!str app:1.2.0\r\n  escaped:\r\n    image: \"app\\u003a1.2.0\"\r\n  untouched:\r\n    image: app:1.2.0 " +
			"# stays\r\n\r\r  plain:\r\n    image: app:1.2.0\r\n  qualified:\r\n    image: docker.io/library/app:1.2.0\r\n  " +
			"omitted:\r\n    image: registry.example.com:5000/team/app",
	)
	expected := "\ufeff# operator configuration\r\n\r\nservices:\r\n  web:\r\n    image: \"app:1.3.0\"   # keep this comment\r\n    " +
		"environment:\r\n      VERSION: ${VERSION}\r\n\r\n  worker:\r\n    image: 'app:1.3.0'  \r\n  " +
		"tagged:\r\n    image: !!str app:1.3.0\r\n  escaped:\r\n    image: \"app:1.3.0\"\r\n  untouched:\r\n    image: " +
		"app:1.2.0 # stays\r\n\r\r  plain:\r\n    image: app:1.3.0\r\n  qualified:\r\n    image: docker.io/library/app:1.3.0\r\n  " +
		"omitted:\r\n    image: registry.example.com:5000/team/app:1.3.0"
	effective := &types.Project{
		Services: types.Services{
			"web": {
				Image: "app:1.2.0",
			},
			"worker": {
				Image: "app:1.2.0",
			},
			"tagged": {
				Image: "app:1.2.0",
			},
			"escaped": {
				Image: "app:1.2.0",
			},
			"untouched": {
				Image: "app:1.2.0",
			},
			"plain": {
				Image: "app:1.2.0",
			},
			"qualified": {
				Image: "docker.io/library/app:1.2.0",
			},
			"omitted": {
				Image: "registry.example.com:5000/team/app",
			},
		},
	}
	updated, names, err := update.PrepareProjectServiceImages(source, effective, map[string]updatertypes.ServiceImageChange{
		"web":       {ExpectedRef: "docker.io/library/app:1.2.0", TargetRef: "app:1.3.0"},
		"worker":    {ExpectedRef: "app:1.2.0", TargetRef: "docker.io/library/app:1.3.0"},
		"tagged":    {ExpectedRef: "app:1.2.0", TargetRef: "app:1.3.0"},
		"escaped":   {ExpectedRef: "app:1.2.0", TargetRef: "app:1.3.0"},
		"plain":     {ExpectedRef: "app:1.2.0", TargetRef: "app:1.3.0"},
		"qualified": {ExpectedRef: "app:1.2.0", TargetRef: "app:1.3.0"},
		"omitted":   {ExpectedRef: "registry.example.com:5000/team/app", TargetRef: "registry.example.com:5000/team/app:1.3.0"},
	})
	require.NoError(t, err)
	require.Equal(t, []string{"escaped", "omitted", "plain", "qualified", "tagged", "web", "worker"}, names)
	require.Equal(t, expected, string(updated))
	require.Equal(t, "app:1.2.0", effective.Services["web"].Image)
}

func TestPrepareProjectServiceImagesRejectsUnsupportedSource(t *testing.T) {
	for _, tt := range []struct{ name, source, expected string }{
		{name: "stale effective image", source: "services:\n  web:\n    image: app:1.2.0\n", expected: "app:1.1.0"},
		{name: "stale source image", source: "services:\n  web:\n    image: app:1.1.0\n", expected: "app:1.2.0"},
		{name: "included source", source: "include: other.yaml\nservices:\n  web:\n    image: app:1.2.0\n", expected: "app:1.2.0"},
		{name: "extended service", source: "services:\n  web:\n    image: app:1.2.0\n    extends: base\n", expected: "app:1.2.0"},
		{name: "image alias", source: "x-image: &image app:1.2.0\nservices:\n  web:\n    image: *image\n", expected: "app:1.2.0"},
		{name: "missing image", source: "services:\n  web:\n    build: .\n", expected: "app:1.2.0"},
		{name: "multiple documents", source: "services:\n  web:\n    image: app:1.2.0\n---\nservices: {}\n", expected: "app:1.2.0"},
		{name: "literal block image", source: "services:\n  web:\n    image: |\n      app:1.2.0\n", expected: "app:1.2.0"},
		{name: "multi-line plain image", source: "services:\n  web:\n    image: app:${VERSION}\n      tail\n", expected: "app:1.2.0"},
	} {
		t.Run(tt.name, func(t *testing.T) {
			effective := &types.Project{Services: types.Services{"web": {Image: "app:1.2.0"}}}
			updated, _, err := update.PrepareProjectServiceImages([]byte(tt.source), effective, map[string]updatertypes.ServiceImageChange{"web": {ExpectedRef: tt.expected, TargetRef: "app:1.3.0"}})
			require.Error(t, err)
			require.Nil(t, updated)
		})
	}
}

func TestPersistProjectServiceImages(t *testing.T) {
	for _, name := range []string{"success", "concurrent edit", "symlink", "cancellation"} {
		t.Run(name, func(t *testing.T) {
			directory := t.TempDir()
			path := filepath.Join(directory, "compose.yaml")
			original := []byte("services: {}\n")
			updated := []byte("services: {web: {image: app:1.3.0}}\n")
			require.NoError(t, os.WriteFile(path, original, 0o600))
			ctx := t.Context()
			switch name {
			case "concurrent edit":
				require.NoError(t, os.WriteFile(path, []byte("# operator edit\n"), 0o600))
			case "symlink":
				require.NoError(t, os.Rename(path, filepath.Join(directory, "actual.yaml")))
				require.NoError(t, os.Symlink("actual.yaml", path))
			case "cancellation":
				var cancel context.CancelFunc
				ctx, cancel = context.WithCancel(ctx)
				cancel()
			}
			err := update.PersistProjectServiceImages(ctx, directory, "/compose.yaml", original, updated)
			content, readErr := os.ReadFile(path)
			require.NoError(t, readErr)
			if name == "success" {
				require.NoError(t, err)
				require.Equal(t, updated, content)
				return
			}
			require.Error(t, err)
			require.NotEqual(t, updated, content)
		})
	}
}

func TestUpdateProjectServiceImagesRejectsManagedOrArchived(t *testing.T) {
	for _, name := range []string{"archived", "gitops"} {
		t.Run(name, func(t *testing.T) {
			db := setupProjectTestDB(t)
			proj := Project{
				ID:              "image-update",
				Name:            "image-update",
				Path:            t.TempDir(),
				GitOpsManagedBy: kit.Ternary(name == "archived", nil, new("sync")),
				IsArchived:      name == "archived",
			}
			require.NoError(t, db.Create(&proj).Error)
			service := NewProjectService(
				db,
				nil,
				event.NewEventService(db, nil, nil),
				image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
				testDockerService,
				testBuildBuilder{},
				nil,
				nil,
				nil,
				kv.NewKVService(db),
				testRegistryCredentials,
			)
			err := service.UpdateProjectServiceImages(t.Context(), proj.ID, map[string]updatertypes.ServiceImageChange{"web": {ExpectedRef: "app:1.0.0", TargetRef: "app:1.1.0"}}, usertypes.Actor{})
			require.Error(t, err)
			if name == "archived" {
				require.ErrorIs(t, err, common.ErrProjectArchived)
			} else {
				require.ErrorContains(t, err, "source repository")
			}
		})
	}
}

func TestUpdateProjectServiceImagesPersistsBeforeDeploymentAndRetries(t *testing.T) {
	ctx := t.Context()
	db := setupProjectTestDB(t)
	directory := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", directory)
	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", directory))
	projectPath := createComposeProjectDir(t, directory, "image-tags")
	source := "# keep\n\nservices:\n  app:\n    image: app:${VERSION}\n\n  worker:\n    image: app:${VERSION}\n"
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte(source), 0o600))
	require.NoError(t, os.Chmod(filepath.Join(projectPath, "compose.yaml"), 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, ".env"), []byte("VERSION=1.2.0\n"), 0o600))
	proj := &Project{ID: "image-tags", Name: "image-tags", Path: projectPath, Status: ProjectStatusRunning}
	require.NoError(t, db.Create(proj).Error)
	deploymentError := errors.New("deployment failed after source persistence")
	originalComposeStop := composeStopProjectServices
	originalComposeUp := composeUpProjectServices
	t.Cleanup(func() {
		composeStopProjectServices = originalComposeStop
		composeUpProjectServices = originalComposeUp
	})
	var deployed []*types.Project
	var scopes [][]string
	composeStopProjectServices = func(context.Context, *types.Project, []string) error { return nil }
	composeUpProjectServices = func(_ context.Context, selected *types.Project, services []string, _, _, _ bool, _ map[string]dockerregistry.AuthConfig, _ time.Duration) error {
		deployed = append(deployed, selected)
		scopes = append(scopes, services)
		return deploymentError
	}
	pullDocker := &docker.DockerClientService{Client: newTestDockerClient(t, newImagePullServerWithObserver(t, nil, nil))}
	service := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, pullDocker, nil, imageupdate.NewImageUpdateService(db, nil, nil, pullDocker, nil, nil, nil), nil, event.NewEventService(db, nil, nil), settingsService, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		nil,
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	changes := map[string]updatertypes.ServiceImageChange{"app": {ExpectedRef: "app:1.2.0", TargetRef: "app:1.3.0"}}
	for range 2 {
		updateProjectServiceImagesErr := service.UpdateProjectServiceImages(ctx, proj.ID, changes, usertypes.SystemUser)
		require.ErrorIs(t, updateProjectServiceImagesErr, deploymentError)
		content, readComposeErr := os.ReadFile(filepath.Join(projectPath, "compose.yaml"))
		require.NoError(t, readComposeErr)
		require.Equal(t, "# keep\n\nservices:\n  app:\n    image: app:1.3.0\n\n  worker:\n    image: app:${VERSION}\n", string(content))
		mode, statComposeErr := os.Stat(filepath.Join(projectPath, "compose.yaml"))
		require.NoError(t, statComposeErr)
		require.Equal(t, os.FileMode(0o600), mode.Mode().Perm())
	}
	require.Equal(t, [][]string{{"app"}, {"app"}}, scopes)
	for _, selected := range deployed {
		require.Equal(t, "app:1.3.0", selected.Services["app"].Image)
	}
	env, err := os.ReadFile(filepath.Join(projectPath, ".env"))
	require.NoError(t, err)
	require.Equal(t, "VERSION=1.2.0\n", string(env))
}

func TestUpdateProjectServiceImagesRejectsOverrideBeforeWriting(t *testing.T) {
	ctx := t.Context()
	db := setupProjectTestDB(t)
	directory := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", directory)
	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", directory))
	projectPath := createComposeProjectDir(t, directory, "image-overrides")
	original := []byte("services:\n  app:\n    image: app:1.0.0\n")
	override := []byte("services:\n  app:\n    image: app:1.2.0\n")
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), original, 0o600))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.override.yaml"), override, 0o600))
	proj := &Project{ID: "image-overrides", Name: "image-overrides", Path: projectPath}
	require.NoError(t, db.Create(proj).Error)
	service := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		nil,
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	err = service.UpdateProjectServiceImages(ctx, proj.ID, map[string]updatertypes.ServiceImageChange{"app": {ExpectedRef: "app:1.2.0", TargetRef: "app:1.3.0"}}, usertypes.SystemUser)
	require.ErrorContains(t, err, "overrides")
	content, err := os.ReadFile(filepath.Join(projectPath, "compose.yaml"))
	require.NoError(t, err)
	require.Equal(t, original, content)
	content, err = os.ReadFile(filepath.Join(projectPath, "compose.override.yaml"))
	require.NoError(t, err)
	require.Equal(t, override, content)
}

func TestDiscoveredProjectTagUpdatesRemainScoped(t *testing.T) {
	db := setupProjectTestDB(t)
	target := "3.2.0"
	tagLabels := map[string]string{labels.LabelUpdateStrategy: "tag"}
	require.NoError(
		t,
		db.Create(
			&imageupdate.ImageUpdateRecord{
				ID: "container::first",
				PolicyKey: imageref.UpdatePolicyKey(
					"example:3.1.0",
					tagLabels,
				),
				ContainerID:   "first",
				ImageID:       "shared",
				Repository:    "docker.io/library/example",
				Tag:           "3.1.0",
				HasUpdate:     true,
				UpdateType:    "tag",
				LatestVersion: &target,
				CheckTime:     time.Now(),
			},
		).Error,
	)
	containers := []container.Summary{
		{
			ID:      "first-replica",
			Image:   "example:3.1.0",
			ImageID: "shared",
			Labels: map[string]string{
				labels.LabelUpdateStrategy:   "tag",
				"com.docker.compose.project": "first-project",
				"com.docker.compose.service": "web",
			},
		},
		{
			ID:      "first",
			Image:   "example:3.1.0",
			ImageID: "shared",
			Labels: map[string]string{
				labels.LabelUpdateStrategy:   "tag",
				"com.docker.compose.project": "first-project",
				"com.docker.compose.service": "web",
			},
		},
		{ID: "second", Image: "example:3.1.0", ImageID: "shared", Labels: map[string]string{"com.docker.compose.project": "second-project", "com.docker.compose.service": "web"}},
	}
	imageSvc := image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil)
	rows := discoveryListingForTest(imageSvc).DiscoveredUpdateRows(t.Context(), containers, nil, "")
	require.Len(t, rows, 1)
	require.Equal(t, "first-project", rows[0].Name)
	require.True(t, rows[0].UpdateInfo.HasUpdate)
	require.Equal(t, target, rows[0].UpdateInfo.UpdateInfoByRef["example:3.1.0"].LatestVersion)
	settingsService, err := newSettingsServiceForTest(t, t.Context(), db)
	require.NoError(t, err)
	require.NoError(t, settingsService.SetStringSetting(t.Context(), "projectsDirectory", t.TempDir()))
	service := NewProjectService(
		db,
		settingsService,
		nil,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		nil,
		nil,
		testRegistryCredentials,
	)
	detail := projecttypes.Details{ID: "tracked", RuntimeServices: []projecttypes.RuntimeService{{ContainerID: "first", Image: "example:3.1.0", ContainerLabels: tagLabels}}}
	info := service.enrichProjectsWithUpdateInfo(t.Context(), []Project{{ID: "tracked"}}, []projecttypes.Details{detail}, true, nil)[0].UpdateInfo
	require.True(t, info.HasUpdate)
	require.Equal(t, target, info.UpdateInfoByRef["example:3.1.0"].LatestVersion)
	delete(containers[1].Labels, labels.LabelUpdateStrategy)
	rows = discoveryListingForTest(imageSvc).DiscoveredUpdateRows(t.Context(), containers, nil, "")
	require.Empty(t, rows, "removing the strategy label falls back to digest checks")
	detail.RuntimeServices[0].ContainerLabels = containers[1].Labels
	info = service.enrichProjectsWithUpdateInfo(t.Context(), []Project{{ID: "tracked"}}, []projecttypes.Details{detail}, true, nil)[0].UpdateInfo
	require.False(t, info.HasUpdate, "an undeclared strategy no longer inherits a tag record")
	// Turning off automatic installation keeps the check current (#3532).
	containers[1].Labels = map[string]string{labels.LabelUpdateStrategy: "tag", labels.LabelUpdater: "off", "com.docker.compose.project": "first-project", "com.docker.compose.service": "web"}
	rows = discoveryListingForTest(imageSvc).DiscoveredUpdateRows(t.Context(), containers, nil, "")
	require.Len(t, rows, 1, "updater=false containers keep their check results")
	for _, policy := range []map[string]string{
		{
			labels.LabelUpdateStrategy: "digest",
		},
		{
			labels.LabelUpdateStrategy:   "tag",
			labels.LabelUpdateConstraint: "3.1.x",
		},
		{
			labels.LabelUpdateStrategy:   "tag",
			labels.LabelUpdateTagPattern: ".*",
		},
		{
			labels.LabelUpdateStrategy: "tag",
			imageref.UpdateCheckLabel:  "off",
		},
	} {
		current := map[string]string{"com.docker.compose.project": "first-project", "com.docker.compose.service": "web"}
		maps.Copy(current, policy)
		containers[1].Labels = current
		rows = discoveryListingForTest(imageSvc).DiscoveredUpdateRows(t.Context(), containers, nil, "")
		require.Empty(t, rows, "stale records must not mark discovered projects updated")
		detail.RuntimeServices[0].ContainerLabels = current
		info = service.enrichProjectsWithUpdateInfo(t.Context(), []Project{{ID: "tracked"}}, []projecttypes.Details{detail}, true, nil)[0].UpdateInfo
		require.False(t, info.HasUpdate, "runtime fallback must not apply a stale policy")
	}
}

func TestProjectTagSummaryDoesNotMutateSharedReferenceResults(t *testing.T) {
	known := map[string]*imagetypes.UpdateInfo{"example:3.1.0": {HasUpdate: false, UpdateType: "digest"}}
	scoped := map[string]*imagetypes.UpdateInfo{
		"first":  {HasUpdate: true, UpdateType: "tag", LatestVersion: "3.2.0"},
		"second": {HasUpdate: true, UpdateType: "tag", LatestVersion: "4.0.0"},
	}
	merged := projectdetails.MergeProjectContainerUpdateInfo(known, []projecttypes.RuntimeService{{ContainerID: "first", Image: "example:3.1.0"}, {ContainerID: "second", Image: "example:3.1.0"}}, scoped)
	require.True(t, merged["example:3.1.0"].HasUpdate)
	require.Empty(t, merged["example:3.1.0"].LatestVersion)
	require.False(t, known["example:3.1.0"].HasUpdate)
	require.Equal(t, "3.2.0", scoped["first"].LatestVersion)

	// A shared image result is dropped when every service using the reference
	// opted out of update checks, and kept while one still monitors it.
	known = map[string]*imagetypes.UpdateInfo{"example:3.1.0": {HasUpdate: true, UpdateType: "digest"}, "other:1.0": {HasUpdate: true, UpdateType: "digest"}}
	unmonitored := map[string]string{imageref.UpdateCheckLabel: "false"}
	merged = projectdetails.MergeProjectContainerUpdateInfo(
		known,
		[]projecttypes.RuntimeService{
			{
				ContainerID:     "a",
				Image:           "example:3.1.0",
				ContainerLabels: unmonitored,
			},
			{
				ContainerID: "b",
				Image:       "example:3.1.0",
				ContainerLabels: map[string]string{
					labels.LabelUpdater: "false",
				},
			},
		},
		nil,
	)
	require.True(t, merged["example:3.1.0"].HasUpdate, "updater=false keeps the shared result")
	require.True(t, merged["other:1.0"].HasUpdate, "references without runtime services are untouched")
	merged = projectdetails.MergeProjectContainerUpdateInfo(known, []projecttypes.RuntimeService{{ContainerID: "a", Image: "example:3.1.0", ContainerLabels: unmonitored}}, nil)
	require.NotContains(t, merged, "example:3.1.0")
	require.True(t, known["example:3.1.0"].HasUpdate)
}

func TestCountProjectsWithPendingTagUpdatesUsesRuntimeContainers(t *testing.T) {
	db := setupProjectTestDB(t)
	settingsService, err := newSettingsServiceForTest(t, t.Context(), db)
	require.NoError(t, err)
	projectRecords := []Project{
		{Name: "first", Path: "first", ImageRefsJSON: `["example:3.1.0"]`},
		{Name: "second", Path: "second", ImageRefsJSON: `["example:3.1.0"]`},
	}
	require.NoError(t, db.Create(&projectRecords).Error)
	require.NoError(
		t,
		db.Create(
			&imageupdate.ImageUpdateRecord{
				ID: "container::first-container",
				PolicyKey: imageref.UpdatePolicyKey(
					"example:3.1.0",
					map[string]string{
						labels.LabelUpdateStrategy: "tag",
					},
				),
				ContainerID: "first-container",
				ImageID:     "shared",
				HasUpdate:   true,
				UpdateType:  "tag",
			},
		).Error,
	)
	service := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		nil,
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	containers := []container.Summary{
		{
			ID:      "first-container",
			Image:   "example:3.1.0",
			ImageID: "shared",
			Labels: map[string]string{
				labels.LabelUpdateStrategy:   "tag",
				"com.docker.compose.project": "first",
				"com.docker.compose.service": "web",
			},
		},
		{ID: "second-container", Image: "example:3.1.0", ImageID: "shared", Labels: map[string]string{"com.docker.compose.project": "second", "com.docker.compose.service": "web"}},
	}
	count, err := service.CountProjectsWithPendingUpdates(t.Context(), containers)
	require.NoError(t, err)
	require.Equal(t, 1, count)
	containers[0].Labels[libarcane.HiddenResourceLabel] = "true"
	count, err = service.CountProjectsWithPendingUpdates(t.Context(), containers)
	require.NoError(t, err)
	require.Zero(t, count)

	// A digest check stored under another local tag of the running image marks
	// the project once, however many replicas share the image.
	require.NoError(t, db.Create(&Project{Name: "third", Path: "third", ImageRefsJSON: `["app:latest"]`}).Error)
	require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{ID: "moving-image", Repository: "docker.io/library/app", Tag: "stable", HasUpdate: true, UpdateType: "digest"}).Error)
	containers = append(containers,
		container.Summary{ID: "third-one", Image: "app:latest", ImageID: "moving-image", Labels: map[string]string{"com.docker.compose.project": "third", "com.docker.compose.service": "web"}},
		container.Summary{
			ID:      "third-two",
			Image:   "app:latest",
			ImageID: "moving-image",
			Labels: map[string]string{
				"com.docker.compose.project": "third",
				"com.docker.compose.service": "web",
				labels.LabelUpdater:          "false",
			},
		},
	)
	count, err = service.CountProjectsWithPendingUpdates(t.Context(), containers)
	require.NoError(t, err)
	require.Equal(t, 1, count)
	containers[2].Labels[imageref.UpdateCheckLabel] = "false"
	containers[3].Labels[imageref.UpdateCheckLabel] = "false"
	count, err = service.CountProjectsWithPendingUpdates(t.Context(), containers)
	require.NoError(t, err)
	require.Zero(t, count, "disabling update checks on every replica suppresses the project")
}

type serviceTagTransport struct {
	tags  []string
	calls int
}

func (s *serviceTagTransport) RoundTrip(request *http.Request) (*http.Response, error) {
	// The /v2/ version check precedes every listing and is not a tag call.
	if request.URL.Path == "/v2/" {
		return &http.Response{StatusCode: http.StatusOK, Header: http.Header{}, Body: http.NoBody, Request: request}, nil
	}
	s.calls++
	payload, err := json.Marshal(map[string]any{"name": "library/app", "tags": s.tags})
	if err != nil {
		return nil, err
	}
	return &http.Response{StatusCode: http.StatusOK, Header: http.Header{}, Body: io.NopCloser(strings.NewReader(string(payload))), Request: request}, nil
}

func TestProjectServiceManualUpdateDiscoversTags(t *testing.T) {
	for _, tt := range []struct {
		name          string
		tags          []string
		wantRef       string
		wantChanged   bool
		skipDiscovery bool
		wantCalls     int
		strategy      string
		omitLabels    bool
	}{
		{name: "new tag", tags: []string{"1.2.0", "1.3.0", "2.0.0"}, wantRef: "app:1.3.0", wantChanged: true, wantCalls: 1},
		{name: "same tag digest fallback", tags: []string{"1.2.0", "2.0.0"}, wantRef: "app:1.2.0", wantCalls: 1},
		{name: "planned dependency does not discover tags", tags: []string{"1.2.0", "1.3.0"}, wantRef: "app:1.2.0", skipDiscovery: true},
		{name: "unlabeled digest default", tags: []string{"1.2.0", "1.3.0", "2.0.0"}, wantRef: "app:1.2.0", omitLabels: true},
		{name: "explicit automatic tag", tags: []string{"1.2.0", "1.3.0", "2.0.0"}, wantRef: "app:1.3.0", wantChanged: true, wantCalls: 1, strategy: "auto"},
		{name: "explicit digest optout", tags: []string{"1.2.0", "1.3.0"}, wantRef: "app:1.2.0", strategy: "digest"},
	} {
		t.Run(tt.name, func(t *testing.T) {
			ctx := t.Context()
			db := setupProjectTestDB(t)
			directory := t.TempDir()
			require.NoError(t, db.AutoMigrate(&registry.ContainerRegistry{}))
			t.Setenv("PROJECTS_DIRECTORY", directory)
			settingsService, err := newSettingsServiceForTest(t, ctx, db)
			require.NoError(t, err)
			require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", directory))
			path := createComposeProjectDir(t, directory, "manual-tag")
			source := "services:\n  app:\n    image: app:1.2.0\n    labels:\n      com.getarcaneapp.arcane.updater.strategy: " +
				"tag\n      com.getarcaneapp.arcane.updater.constraint: 1.x\n  selected-digest:\n    image: " +
				"busybox:latest\n  unselected:\n    image: busybox:latest\n"
			if tt.omitLabels {
				source = strings.Replace(source, "    labels:\n      com.getarcaneapp.arcane.updater.strategy: tag\n      com.getarcaneapp.arcane.updater.constraint: 1.x\n", "", 1)
			} else if tt.strategy != "" {
				source = strings.Replace(source, "strategy: tag", "strategy: "+tt.strategy, 1)
				source = strings.Replace(source, "      com.getarcaneapp.arcane.updater.constraint: 1.x\n", "", 1)
			}

			require.NoError(t, os.WriteFile(filepath.Join(path, "compose.yaml"), []byte(source), 0o600))
			proj := &Project{ID: "manual-tag", Name: "manual-tag", Path: path, Status: ProjectStatusRunning}
			require.NoError(t, db.Create(proj).Error)
			deploymentError := errors.New("deployment reached")
			originalComposeStop := composeStopProjectServices
			originalComposeUp := composeUpProjectServices
			t.Cleanup(func() {
				composeStopProjectServices = originalComposeStop
				composeUpProjectServices = originalComposeUp
			})
			var deployed []*types.Project
			var scopes [][]string
			composeStopProjectServices = func(context.Context, *types.Project, []string) error { return nil }
			composeUpProjectServices = func(_ context.Context, selected *types.Project, services []string, _, _, _ bool, _ map[string]dockerregistry.AuthConfig, _ time.Duration) error {
				deployed = append(deployed, selected)
				scopes = append(scopes, services)
				return deploymentError
			}
			pullDocker := &docker.DockerClientService{Client: newTestDockerClient(t, newImagePullServerWithObserver(t, nil, nil))}
			transport := &serviceTagTransport{tags: tt.tags}
			registryService := registry.NewContainerRegistryService(db, nil, nil, nil, &http.Client{Transport: transport})
			service := NewProjectService(
				db,
				settingsService,
				event.NewEventService(db, nil, nil),
				image.NewImageService(db, pullDocker, nil, imageupdate.NewImageUpdateService(db, nil, nil, pullDocker, nil, nil, nil), nil, event.NewEventService(db, nil, nil), settingsService, nil),
				testDockerService,
				testBuildBuilder{},
				nil,
				registryService,
				nil,
				kv.NewKVService(db),
				testRegistryCredentials,
			)
			err = service.UpdateProjectServices(ctx, proj.ID, []string{"app", "selected-digest"}, usertypes.SystemUser, !tt.skipDiscovery)
			require.ErrorIs(t, err, deploymentError)
			require.Equal(t, tt.wantCalls, transport.calls)
			require.Len(t, deployed, 1)
			require.ElementsMatch(t, []string{"app", "selected-digest"}, deployed[0].ServiceNames())
			require.Equal(t, tt.wantRef, deployed[0].Services["app"].Image)
			require.Equal(t, "busybox:latest", deployed[0].Services["selected-digest"].Image)
			content, err := os.ReadFile(filepath.Join(path, "compose.yaml"))
			require.NoError(t, err)
			if tt.wantChanged {
				require.Equal(t, strings.Replace(source, "image: app:1.2.0", "image: "+tt.wantRef, 1), string(content))
			} else {
				require.Equal(t, source, string(content))
			}
		})
	}
}

func TestProjectServiceManualUpdateRejectsUnsafeTagPolicies(t *testing.T) {
	for _, tt := range []struct {
		name   string
		change func(*types.ServiceConfig)
	}{
		{name: "invalid constraint", change: func(s *types.ServiceConfig) { s.Labels[labels.LabelUpdateConstraint] = "not semver" }},
		{name: "local build", change: func(s *types.ServiceConfig) { s.Build = &types.BuildConfig{Context: "."} }},
		{name: "digest pin", change: func(s *types.ServiceConfig) { s.Image = "app@sha256:" + strings.Repeat("a", 64) }},
	} {
		t.Run(tt.name, func(t *testing.T) {
			serviceConfig := types.ServiceConfig{Image: "app:1.2.0", Labels: types.Labels{labels.LabelUpdateStrategy: "tag"}}
			tt.change(&serviceConfig)
			service := NewProjectService(nil, nil, nil, nil, testDockerService, testBuildBuilder{}, nil, nil, nil, nil, testRegistryCredentials)
			changes, err := service.updates.ImageChanges(t.Context(), &types.Project{Services: types.Services{"app": serviceConfig}}, nil, false)
			require.Error(t, err)
			require.NotContains(t, err.Error(), "registry service unavailable")
			require.Nil(t, changes)
		})
	}
	local := types.ServiceConfig{Name: "app", Image: "app:1.2.0", Build: &types.BuildConfig{Context: "."}}
	emptyService := NewProjectService(nil, nil, nil, nil, testDockerService, testBuildBuilder{}, nil, nil, nil, nil, testRegistryCredentials)
	changes, err := emptyService.updates.ImageChanges(t.Context(), &types.Project{Services: types.Services{"app": local}}, nil, false)
	require.NoError(t, err)
	require.Empty(t, changes, "automatic inference must preserve local-build handling")
}

func TestConfiguredProjectTagChecksMatchCurrentServicePolicy(t *testing.T) {
	services := []types.ServiceConfig{
		{Name: "stable", Image: "example:3.1.0", Labels: types.Labels{labels.LabelUpdateStrategy: "tag", labels.LabelUpdateConstraint: "3.x"}},
		{Name: "next", Image: "example:3.1.0", Labels: types.Labels{labels.LabelUpdateStrategy: "tag", labels.LabelUpdateConstraint: "4.x"}},
	}
	byRef := map[string]*imagetypes.UpdateInfo{"example:3.1.0": {HasUpdate: false, UpdateType: "digest", CheckTime: time.Now()}}
	unknown := BuildConfiguredUpdateInfo("project", services, byRef, nil)
	require.Equal(t, "unknown", unknown.Status)
	require.Zero(t, unknown.CheckedImageCount)
	require.Nil(t, unknown.ServiceUpdates["stable"].UpdateInfo)
	require.Nil(t, unknown.ServiceUpdates["next"].UpdateInfo)
	firstTarget, secondTarget := "3.2.0", "4.0.0"
	records := []imageupdate.ImageUpdateRecord{
		{ProjectID: "project", ServiceName: "stable", PolicyKey: imageref.UpdatePolicyKey(services[0].Image, services[0].Labels), HasUpdate: true, UpdateType: "tag", LatestVersion: &firstTarget},
		{ProjectID: "project", ServiceName: "next", PolicyKey: imageref.UpdatePolicyKey(services[1].Image, services[1].Labels), HasUpdate: true, UpdateType: "tag", LatestVersion: &secondTarget},
	}
	checked := BuildConfiguredUpdateInfo("project", services, byRef, records)
	require.Equal(t, "has_update", checked.Status)
	require.Equal(t, firstTarget, checked.ServiceUpdates["stable"].UpdateInfo.LatestVersion)
	require.Equal(t, secondTarget, checked.ServiceUpdates["next"].UpdateInfo.LatestVersion)
	require.Empty(t, checked.UpdateInfoByRef["example:3.1.0"].LatestVersion)
	services[0].Labels[labels.LabelUpdateConstraint] = "3.1.x"
	services[1].Image = "example:4.0.0"
	stale := BuildConfiguredUpdateInfo("project", services, byRef, records)
	require.Equal(t, "unknown", stale.Status)
	require.Nil(t, stale.ServiceUpdates["stable"].UpdateInfo)
	require.Nil(t, stale.ServiceUpdates["next"].UpdateInfo)
}

func TestStoppedProjectTagPolicyNeverInheritsSharedDigestCheck(t *testing.T) {
	db := setupProjectTestDB(t)
	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)
	settingsService, err := newSettingsServiceForTest(t, t.Context(), db)
	require.NoError(t, err)
	require.NoError(t, settingsService.SetStringSetting(t.Context(), "projectsDirectory", projectsDir))
	projectPath := createComposeProjectDir(t, projectsDir, "tag-stopped")
	require.NoError(
		t,
		os.WriteFile(
			filepath.Join(
				projectPath,
				"compose.yaml",
			),
			[]byte(
				"x-arcane:\n  hidden: true\nservices:\n  app:\n    image: nginx:3.1.0\n    labels:\n      "+
					"com.getarcaneapp.arcane.updater.strategy: tag\n      com.getarcaneapp.arcane.updater.constraint: 3.x\n",
			),
			0o644,
		),
	)
	projectRecord := &Project{ID: "tag-stopped", Name: "tag-stopped", DirName: new("tag-stopped"), Path: projectPath, Status: ProjectStatusStopped, ImageRefsJSON: `["nginx:3.1.0"]`}
	require.NoError(t, db.Create(projectRecord).Error)
	require.NoError(t, db.Create(&imageupdate.ImageUpdateRecord{ID: "shared-digest", Repository: "docker.io/library/nginx", Tag: "3.1.0", UpdateType: "digest", CheckTime: time.Now()}).Error)
	imageService := image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil)
	service := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		imageService,
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	detail, err := service.GetProjectDetails(t.Context(), projectRecord.ID, projecttypes.AllDetails())
	require.NoError(t, err)
	require.Equal(t, "unknown", detail.UpdateInfo.Status)
	require.Nil(t, detail.UpdateInfo.ServiceUpdates["app"].UpdateInfo)
	list := []projecttypes.Details{{ID: projectRecord.ID}}
	list = service.enrichProjectsWithUpdateInfo(t.Context(), []Project{*projectRecord}, list, true, nil)
	require.Equal(t, "unknown", list[0].UpdateInfo.Status)
	require.Nil(t, list[0].UpdateInfo.ServiceUpdates["app"].UpdateInfo)
	target := "3.2.0"
	policy := map[string]string{labels.LabelUpdateStrategy: "tag", labels.LabelUpdateConstraint: "3.x"}
	require.NoError(
		t,
		db.Create(
			&imageupdate.ImageUpdateRecord{
				ID:          "project::tag-stopped::app",
				ProjectID:   projectRecord.ID,
				ServiceName: "app",
				PolicyKey: imageref.UpdatePolicyKey(
					"nginx:3.1.0",
					policy,
				),
				HasUpdate:     true,
				UpdateType:    "tag",
				LatestVersion: &target,
				CheckTime:     time.Now(),
			},
		).Error,
	)
	detail, err = service.GetProjectDetails(t.Context(), projectRecord.ID, projecttypes.AllDetails())
	require.NoError(t, err)
	require.Equal(t, "has_update", detail.UpdateInfo.Status)
	require.Equal(t, target, detail.UpdateInfo.ServiceUpdates["app"].UpdateInfo.LatestVersion)
	list = service.enrichProjectsWithUpdateInfo(t.Context(), []Project{*projectRecord}, list, true, nil)
	require.Equal(t, "has_update", list[0].UpdateInfo.Status)
	count, err := service.CountProjectsWithPendingUpdates(t.Context(), []container.Summary{})
	require.NoError(t, err)
	require.Zero(t, count, "hidden configured services must not contribute to the dashboard badge")
}

func TestConfiguredProjectUsesScheduledRuntimeChecks(t *testing.T) {
	for _, tt := range []struct {
		name                                           string
		sourceRef, sourceConstraint, runtimeConstraint string
		wantUpdate                                     bool
	}{
		{name: "scheduled automatic check", sourceRef: "example:3.1.0", wantUpdate: true},
		{name: "source image changed", sourceRef: "example:3.0.0"},
		{name: "source policy changed", sourceRef: "example:3.1.0", sourceConstraint: "3.1.x"},
		{name: "runtime policy changed", sourceRef: "example:3.1.0", runtimeConstraint: "3.1.x"},
	} {
		t.Run(tt.name, func(t *testing.T) {
			ctx := t.Context()
			db := setupProjectTestDB(t)
			directory := t.TempDir()
			t.Setenv("PROJECTS_DIRECTORY", directory)
			settingsService, err := newSettingsServiceForTest(t, ctx, db)
			require.NoError(t, err)
			require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", directory))
			path := createComposeProjectDir(t, directory, "scheduled-project")
			source := "services:\n  web:\n    image: " + tt.sourceRef + "\n    labels:\n      com.getarcaneapp.arcane.updater.strategy: auto\n"
			if tt.sourceConstraint != "" {
				source += "      com.getarcaneapp.arcane.updater.constraint: " + tt.sourceConstraint + "\n"
			}
			require.NoError(t, os.WriteFile(filepath.Join(path, "compose.yaml"), []byte(source), 0o600))
			proj := Project{ID: "scheduled-project", Name: "scheduled-project", Path: path}
			require.NoError(t, db.Create(&proj).Error)
			target := "3.2.0"
			require.NoError(
				t,
				db.Create(
					&imageupdate.ImageUpdateRecord{
						ID:          "container::scheduled",
						ContainerID: "scheduled-container",
						ImageID:     "shared",
						PolicyKey: imageref.UpdatePolicyKey(
							"example:3.1.0",
							map[string]string{
								labels.LabelUpdateStrategy: "auto",
							},
						),
						Repository:    "docker.io/library/example",
						Tag:           "3.1.0",
						LatestVersion: &target,
						HasUpdate:     true,
						UpdateType:    "tag",
						CheckTime:     time.Now(),
					},
				).Error,
			)
			runtimeLabels := map[string]string{
				"com.docker.compose.project": "scheduled-project",
				"com.docker.compose.service": "web",
				api.WorkingDirLabel:          path,
				labels.LabelUpdateStrategy:   "auto",
			}
			runtimeLabels[labels.LabelUpdateConstraint] = cmp.Or(tt.runtimeConstraint, runtimeLabels[labels.LabelUpdateConstraint])
			runtimeServices := []projecttypes.RuntimeService{{Name: "web", ContainerID: "scheduled-container", Image: "example:3.1.0", ContainerLabels: runtimeLabels}}
			service := NewProjectService(
				db,
				settingsService,
				event.NewEventService(db, nil, nil),
				image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
				&docker.DockerClientService{Client: newTestDockerClient(t, configureProjectRuntimeDocker(t, []container.Summary{
					{ID: "scheduled-container", Names: []string{"/scheduled-project-web-1"}, Image: "example:3.1.0", State: container.StateRunning, Labels: runtimeLabels},
				}))},
				testBuildBuilder{},
				nil,
				nil,
				nil,
				kv.NewKVService(db),
				testRegistryCredentials,
			)
			detail, err := service.GetProjectDetails(ctx, proj.ID, projecttypes.AllDetails())
			require.NoError(t, err)
			info := detail.UpdateInfo
			require.Equal(t, tt.wantUpdate, info.HasUpdate)
			list := []projecttypes.Details{{ID: proj.ID, RuntimeServices: runtimeServices}}
			list = service.enrichProjectsWithUpdateInfo(ctx, []Project{proj}, list, true, nil)
			require.Equal(t, tt.wantUpdate, list[0].UpdateInfo.HasUpdate)
			for _, summary := range []*projecttypes.UpdateInfo{info, list[0].UpdateInfo} {
				if tt.wantUpdate {
					require.Equal(t, target, summary.ServiceUpdates["web"].UpdateInfo.LatestVersion)
				} else {
					require.Nil(t, summary.ServiceUpdates["web"].UpdateInfo)
					require.Equal(t, "unknown", summary.Status)
				}
			}
		})
	}
}

func TestConfiguredProjectAggregatesReplicaAndPreviewChecks(t *testing.T) {
	configs := []types.ServiceConfig{{Name: "web", Image: "example:3.1.0"}}
	runtimeServices := []projecttypes.RuntimeService{
		{Name: "web", ContainerID: "one", Image: "example:3.1.0"},
		{Name: "web", ContainerID: "two", Image: "docker.io/library/example:3.1.0"},
		{Name: "other", ContainerID: "unrelated", Image: "example:3.1.0"},
	}
	scoped := map[string]*imagetypes.UpdateInfo{
		"one":       {HasUpdate: false, LatestVersion: "3.1.0", UpdateType: "tag"},
		"two":       {HasUpdate: true, LatestVersion: "3.2.0", UpdateType: "tag"},
		"unrelated": {HasUpdate: true, LatestVersion: "4.0.0", UpdateType: "tag"},
	}
	runtimeUpdates := projectdetails.ConfiguredRuntimeServiceUpdateInfo(configs, runtimeServices, scoped)
	require.Len(t, runtimeUpdates, 1)
	require.True(t, runtimeUpdates["web"].HasUpdate)
	require.Empty(t, runtimeUpdates["web"].LatestVersion, "conflicting replica targets must not choose an arbitrary version")
	previewTarget := "3.3.0"
	records := []imageupdate.ImageUpdateRecord{
		{
			ProjectID:   "project",
			ServiceName: "web",
			PolicyKey: imageref.UpdatePolicyKey(
				"example:3.1.0",
				nil,
			),
			HasUpdate:     true,
			LatestVersion: &previewTarget,
			UpdateType:    "tag",
		},
	}
	summary := BuildConfiguredUpdateInfo("project", configs, nil, records, runtimeUpdates)
	require.True(t, summary.HasUpdate)
	require.Empty(t, summary.ServiceUpdates["web"].UpdateInfo.LatestVersion)
	require.Empty(t, summary.UpdateInfoByRef["example:3.1.0"].LatestVersion)
	require.Equal(t, "3.2.0", scoped["two"].LatestVersion, "aggregation must not modify shared checks")

	// A configured check reporting no update does not hide a pending replica.
	records[0].HasUpdate = false
	records[0].LatestVersion = nil
	summary = BuildConfiguredUpdateInfo("project", configs, nil, records, runtimeUpdates)
	require.True(t, summary.HasUpdate)
	require.True(t, summary.ServiceUpdates["web"].UpdateInfo.HasUpdate)
	require.Equal(t, "3.2.0", scoped["two"].LatestVersion)

	// A stale preview still advertising an update is superseded by a runtime
	// check at least as recent that found nothing; a newer preview still wins.
	previewTime := time.Now().Add(-time.Hour)
	records[0].HasUpdate = true
	records[0].LatestVersion = &previewTarget
	records[0].CheckTime = previewTime
	current := map[string]*imagetypes.UpdateInfo{"web": {HasUpdate: false, UpdateType: "digest", CheckTime: previewTime.Add(time.Minute)}}
	byRef := map[string]*imagetypes.UpdateInfo{"example:3.1.0": current["web"]}
	summary = BuildConfiguredUpdateInfo("project", configs, byRef, records, current)
	require.False(t, summary.HasUpdate)
	require.False(t, summary.ServiceUpdates["web"].UpdateInfo.HasUpdate)
	require.Equal(t, "up_to_date", summary.Status)

	current["web"].CheckTime = previewTime.Add(-time.Minute)
	summary = BuildConfiguredUpdateInfo("project", configs, byRef, records, current)
	require.True(t, summary.HasUpdate)
	require.True(t, summary.ServiceUpdates["web"].UpdateInfo.HasUpdate)
}

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

	newProject := func(volumes ...types.ServiceVolumeConfig) *types.Project {
		return &types.Project{Services: types.Services{
			"app": {Name: "app", Volumes: volumes},
		}}
	}
	bind := func(source string) types.ServiceVolumeConfig {
		return types.ServiceVolumeConfig{Type: types.VolumeTypeBind, Source: source, Target: "/t", Bind: &types.ServiceVolumeBind{CreateHostPath: true}}
	}

	t.Run("creates missing nested directories only", func(t *testing.T) {
		t.Parallel()
		projectPath := t.TempDir()
		outside := t.TempDir()
		existingFile := filepath.Join(projectPath, "Caddyfile")
		require.NoError(t, os.WriteFile(existingFile, []byte("x"), 0o600))
		existingDir := filepath.Join(projectPath, "data")
		require.NoError(t, os.Mkdir(existingDir, 0o700))

		noCreate := types.ServiceVolumeConfig{Type: types.VolumeTypeBind, Source: filepath.Join(projectPath, "manual"), Target: "/t", Bind: &types.ServiceVolumeBind{CreateHostPath: false}}
		project := newProject(
			bind(filepath.Join(projectPath, "caddy", "conf")),
			types.ServiceVolumeConfig{Type: types.VolumeTypeBind, Source: filepath.Join(projectPath, "plain"), Target: "/p"},
			bind(existingFile),
			bind(existingDir),
			bind(projectPath),
			bind(filepath.Join(outside, "elsewhere")),
			noCreate,
			types.ServiceVolumeConfig{Type: types.VolumeTypeVolume, Source: "named", Target: "/v"},
		)

		require.NoError(t, deployment.PrepareProjectBindDirectories(projectPath)(t.Context(), project))

		assert.DirExists(t, filepath.Join(projectPath, "caddy", "conf"))
		assert.DirExists(t, filepath.Join(projectPath, "plain"), "long syntax without bind block is auto-created like the daemon would")
		assert.FileExists(t, existingFile)
		info, err := os.Stat(existingDir)
		require.NoError(t, err)
		assert.Equal(t, os.FileMode(0o700), info.Mode().Perm(), "existing directory permissions preserved")
		assert.NoDirExists(t, filepath.Join(outside, "elsewhere"))
		assert.NoDirExists(t, filepath.Join(projectPath, "manual"), "create_host_path: false is respected")
		assert.NoDirExists(t, filepath.Join(projectPath, "named"))
	})

	t.Run("skips sources reached through symlinks escaping the project", func(t *testing.T) {
		t.Parallel()
		parent := t.TempDir()
		projectPath := filepath.Join(parent, "project")
		require.NoError(t, os.Mkdir(projectPath, 0o755))
		outside := filepath.Join(parent, "appdata")
		existingExternal := filepath.Join(outside, "jellyfin", "data")
		require.NoError(t, os.MkdirAll(existingExternal, 0o700))
		require.NoError(t, os.Symlink(outside, filepath.Join(projectPath, "abs")))
		require.NoError(t, os.Symlink(filepath.Join("..", "appdata"), filepath.Join(projectPath, "rel")))

		project := newProject(
			bind(filepath.Join(projectPath, "abs", "jellyfin", "data")),
			bind(filepath.Join(projectPath, "abs", "missing")),
			bind(filepath.Join(projectPath, "rel", "jellyfin", "data")),
			bind(filepath.Join(projectPath, "rel", "other")),
			bind(filepath.Join(projectPath, "local", "conf")),
		)

		require.NoError(t, deployment.PrepareProjectBindDirectories(projectPath)(t.Context(), project))

		info, err := os.Stat(existingExternal)
		require.NoError(t, err)
		assert.Equal(t, os.FileMode(0o700), info.Mode().Perm(), "external directory permissions preserved")
		assert.NoDirExists(t, filepath.Join(outside, "missing"))
		assert.NoDirExists(t, filepath.Join(outside, "other"))
		assert.DirExists(t, filepath.Join(projectPath, "local", "conf"))
	})

	t.Run("reports symlink loops and canceled contexts", func(t *testing.T) {
		t.Parallel()
		projectPath := t.TempDir()
		require.NoError(t, os.Symlink("loop", filepath.Join(projectPath, "loop")))

		err := deployment.PrepareProjectBindDirectories(projectPath)(t.Context(), newProject(bind(filepath.Join(projectPath, "loop", "conf"))))
		require.ErrorIs(t, err, acfs.ErrSymlinkLoop)
		assert.Contains(t, err.Error(), "service app")

		ctx, cancel := context.WithCancel(t.Context())
		cancel()
		err = deployment.PrepareProjectBindDirectories(projectPath)(ctx, newProject(bind(filepath.Join(projectPath, "conf"))))
		require.ErrorIs(t, err, context.Canceled)
		assert.NoDirExists(t, filepath.Join(projectPath, "conf"))
	})
}

// TestProjectService_ApplyGitSyncProjectFiles_TolerantOfPermissionLockedEnv verifies
// a permission-locked (e.g. chmod 000, foreign-owned) .env does not brick a git sync:
// the compose file still updates, the sync succeeds, and the locked file is left
// untouched instead of aborting the whole update.
func TestProjectService_ApplyGitSyncProjectFiles_TolerantOfPermissionLockedEnv(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skip("requires Unix permission semantics")
	}
	if os.Geteuid() == 0 {
		t.Skip("permission bits are ignored when running as root")
	}

	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)

	eventService := event.NewEventService(db, nil, nil)
	svc := NewProjectService(
		db,
		settingsService,
		eventService,
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	dirName := "git-sync-locked-env"
	projectPath := filepath.Join(projectsDir, dirName)
	require.NoError(t, os.MkdirAll(projectPath, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(projectPath, "compose.yaml"), []byte("services:\n  app:\n    image: nginx:alpine\n"), 0o600))

	envPath := filepath.Join(projectPath, ".env")
	require.NoError(t, os.WriteFile(envPath, []byte("FOO=locked\n"), 0o600))
	require.NoError(t, os.Chmod(envPath, 0o000))
	t.Cleanup(func() { _ = os.Chmod(envPath, 0o644) })

	project := &Project{
		ID:      "proj-git-sync-locked-env",
		Name:    "git-sync-locked-env",
		DirName: &dirName,
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	updated, _, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, "services:\n  app:\n    image: nginx:1.27-alpine\n", new("FOO=fromgit\n"), nil, "", usertypes.Actor{
		ID:       "u1",
		Username: "tester",
	})
	require.NoError(t, err)
	require.NotNil(t, updated)

	composeBytes, err := os.ReadFile(filepath.Join(projectPath, "compose.yaml"))
	require.NoError(t, err)
	assert.Contains(t, string(composeBytes), "nginx:1.27-alpine")

	// The locked .env survived untouched — sync did not attempt to overwrite it.
	require.NoError(t, os.Chmod(envPath, 0o644))
	envBytes, err := os.ReadFile(envPath)
	require.NoError(t, err)
	assert.Equal(t, "FOO=locked\n", string(envBytes))
}

func TestPrepareProjectBindDirectories_PermissionFailure(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skip("requires Unix permission semantics")
	}
	if os.Geteuid() == 0 {
		t.Skip("permission bits are ignored when running as root")
	}

	for _, tc := range []struct {
		name       string
		dirMode    os.FileMode
		fileMode   os.FileMode
		createFile bool
		wantError  bool
	}{
		{name: "missing directory in unwritable parent", dirMode: 0o500, wantError: true},
		{name: "missing directory in non-searchable parent", dirMode: 0o600},
		{name: "existing file in non-searchable parent", dirMode: 0o600, fileMode: 0o640, createFile: true},
		{name: "unreadable file in searchable parent", dirMode: 0o700, fileMode: 0o000, createFile: true},
	} {
		t.Run(tc.name, func(t *testing.T) {
			projectPath := t.TempDir()
			locked := filepath.Join(projectPath, "locked")
			require.NoError(t, os.Mkdir(locked, 0o700))
			t.Cleanup(func() { assert.NoError(t, os.Chmod(locked, 0o700)) })
			source := filepath.Join(locked, "conf")
			var originalInfo os.FileInfo
			if tc.createFile {
				require.NoError(t, os.WriteFile(source, []byte("config"), tc.fileMode))
				var err error
				originalInfo, err = os.Stat(source)
				require.NoError(t, err)
			}
			require.NoError(t, os.Chmod(locked, tc.dirMode))
			if tc.createFile {
				_, err := os.ReadFile(source)
				require.ErrorIs(t, err, fs.ErrPermission)
			}
			_, statErr := os.Lstat(source)
			switch {
			case tc.dirMode&0o100 == 0:
				require.ErrorIs(t, statErr, fs.ErrPermission)
			case tc.createFile:
				require.NoError(t, statErr)
			default:
				require.ErrorIs(t, statErr, fs.ErrNotExist)
			}

			project := &types.Project{Services: types.Services{
				"app": {Name: "app", Volumes: []types.ServiceVolumeConfig{{
					Type: types.VolumeTypeBind, Source: source, Target: "/etc/caddy",
				}}},
			}}

			err := deployment.PrepareProjectBindDirectories(projectPath)(t.Context(), project)
			if tc.wantError {
				require.ErrorIs(t, err, fs.ErrPermission)
				assert.Contains(t, err.Error(), source)
				assert.Contains(t, err.Error(), "service app")
			} else {
				require.NoError(t, err)
			}
			dirInfo, err := os.Stat(locked)
			require.NoError(t, err)
			assert.Equal(t, tc.dirMode, dirInfo.Mode().Perm())
			require.NoError(t, os.Chmod(locked, 0o700))
			if !tc.createFile {
				_, lstatErr := os.Lstat(source)
				require.ErrorIs(t, lstatErr, fs.ErrNotExist)
				return
			}
			info, err := os.Stat(source)
			require.NoError(t, err)
			assert.True(t, os.SameFile(originalInfo, info))
			assert.Equal(t, originalInfo.Mode(), info.Mode())
			assert.Equal(t, originalInfo.ModTime(), info.ModTime())
			require.NoError(t, os.Chmod(source, 0o600))
			content, err := os.ReadFile(source)
			require.NoError(t, err)
			assert.Equal(t, "config", string(content))
		})
	}
}

func newEnvDirectoryProject(t *testing.T, id string) (*ProjectService, *Project, string, context.Context) {
	t.Helper()

	db := setupProjectTestDB(t)
	ctx := t.Context()

	projectsDir := t.TempDir()
	t.Setenv("PROJECTS_DIRECTORY", projectsDir)

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	require.NoError(t, settingsService.SetStringSetting(ctx, "projectsDirectory", projectsDir))

	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)

	projectPath := createComposeProjectDir(t, projectsDir, id)
	envDir := filepath.Join(projectPath, ".env")
	require.NoError(t, os.Mkdir(envDir, 0o755))
	require.NoError(t, os.WriteFile(filepath.Join(envDir, "keep"), []byte("x"), 0o644))

	project := &Project{
		ID:      "proj-" + id,
		Name:    id,
		DirName: new(id),
		Path:    projectPath,
		Status:  ProjectStatusStopped,
	}
	require.NoError(t, db.Create(project).Error)

	return svc, project, envDir, ctx
}

func assertEnvDirectoryIntact(t *testing.T, envDir string) {
	t.Helper()
	info, err := os.Stat(envDir)
	require.NoError(t, err)
	assert.True(t, info.IsDir())
	assert.FileExists(t, filepath.Join(envDir, "keep"))
}

func TestProjectService_EnvDirectory_SyncAndDetails(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skip("requires Unix permission semantics")
	}
	svc, project, envDir, ctx := newEnvDirectoryProject(t, "env-dir-scan")

	require.NoError(t, svc.SyncProjectsFromFileSystem(ctx))
	all, err := svc.ListAllProjects(ctx)
	require.NoError(t, err)
	require.Len(t, all, 1)
	assert.Equal(t, project.Path, all[0].Path)

	details, err := svc.GetProjectDetails(ctx, project.ID, projecttypes.AllDetails())
	require.NoError(t, err)
	assert.Empty(t, details.EnvContent)
	assert.Contains(t, details.ComposeContent, "nginx:alpine")

	assertEnvDirectoryIntact(t, envDir)
}

func TestProjectService_EnvDirectory_UpdateCompose(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skip("requires Unix permission semantics")
	}
	svc, project, envDir, ctx := newEnvDirectoryProject(t, "env-dir-update")

	_, err := svc.UpdateProject(ctx, project.ID, nil, new("services:\n  app:\n    image: nginx:1.27-alpine\n"), nil, nil, usertypes.Actor{ID: "u1", Username: "tester"})
	require.NoError(t, err)

	composeBytes, err := os.ReadFile(filepath.Join(project.Path, "compose.yaml"))
	require.NoError(t, err)
	assert.Contains(t, string(composeBytes), "nginx:1.27-alpine")
	assertEnvDirectoryIntact(t, envDir)
}

func TestProjectService_EnvDirectory_GitSync(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skip("requires Unix permission semantics")
	}
	svc, project, envDir, ctx := newEnvDirectoryProject(t, "env-dir-git")

	_, _, err := svc.ApplyGitSyncProjectFiles(ctx, project.ID, "services:\n  app:\n    image: nginx:1.27-alpine\n", new("FOO=fromgit\n"), nil, "", usertypes.Actor{ID: "u1", Username: "tester"})
	require.NoError(t, err)

	composeBytes, err := os.ReadFile(filepath.Join(project.Path, "compose.yaml"))
	require.NoError(t, err)
	assert.Contains(t, string(composeBytes), "nginx:1.27-alpine")
	assertEnvDirectoryIntact(t, envDir)
}

func TestProjectService_EnvDirectory_EnvSaveFails(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skip("requires Unix permission semantics")
	}
	svc, project, envDir, ctx := newEnvDirectoryProject(t, "env-dir-save")

	_, err := svc.UpdateProject(ctx, project.ID, nil, nil, new("FOO=bar\n"), nil, usertypes.Actor{ID: "u1", Username: "tester"})
	require.ErrorContains(t, err, ".env is a directory")
	assertEnvDirectoryIntact(t, envDir)
}

func TestProjectService_OverrideEnvDirectory_EnvSaveFails(t *testing.T) {
	if runtime.GOOS == "windows" {
		t.Skip("requires Unix permission semantics")
	}
	svc, project, envDir, ctx := newEnvDirectoryProject(t, "override-dir-save")
	require.NoError(t, os.RemoveAll(envDir))
	require.NoError(t, os.WriteFile(filepath.Join(project.Path, ".env.git"), []byte("FOO=git\n"), 0o644))
	overrideDir := filepath.Join(project.Path, "project.env")
	require.NoError(t, os.Mkdir(overrideDir, 0o755))

	_, err := svc.UpdateProject(ctx, project.ID, nil, nil, new("FOO=local\n"), nil, usertypes.Actor{ID: "u1", Username: "tester"})
	require.ErrorContains(t, err, "project.env is a directory")
	info, err := os.Stat(overrideDir)
	require.NoError(t, err)
	assert.True(t, info.IsDir())
}

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

	const resolved = "/projects/app/compose.yaml"
	transient := errors.New("transient")

	type call struct {
		wantPath  string
		wantErr   error
		wantCalls int
	}

	tests := []struct {
		name      string
		env       *projectMetadataEnv
		projectID string
		// results is returned by resolve in order; the last entry repeats.
		results []error
		calls   []call
	}{
		{
			name:      "caches success",
			env:       &projectMetadataEnv{composeFiles: map[string]string{}},
			projectID: "p1",
			results:   []error{nil},
			calls: []call{
				{wantPath: resolved, wantCalls: 1},
				{wantPath: resolved, wantCalls: 1},
			},
		},
		{
			name:      "retries after failure then caches success",
			env:       &projectMetadataEnv{composeFiles: map[string]string{}},
			projectID: "p1",
			results:   []error{transient, nil},
			calls: []call{
				{wantErr: transient, wantCalls: 1},
				{wantPath: resolved, wantCalls: 2},
				{wantPath: resolved, wantCalls: 2},
			},
		},
		{
			name:      "repeated failures are never memoized",
			env:       &projectMetadataEnv{composeFiles: map[string]string{}},
			projectID: "p1",
			results:   []error{transient},
			calls: []call{
				{wantErr: transient, wantCalls: 1},
				{wantErr: transient, wantCalls: 2},
			},
		},
		{
			name:      "nil env resolves every call",
			env:       nil,
			projectID: "p1",
			results:   []error{nil},
			calls: []call{
				{wantPath: resolved, wantCalls: 1},
				{wantPath: resolved, wantCalls: 2},
			},
		},
		{
			name:      "empty project ID resolves every call",
			env:       &projectMetadataEnv{composeFiles: map[string]string{}},
			projectID: "",
			results:   []error{nil},
			calls: []call{
				{wantPath: resolved, wantCalls: 1},
				{wantPath: resolved, wantCalls: 2},
			},
		},
	}

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

			calls := 0
			resolve := func() (string, error) {
				calls++
				err := tt.results[min(calls, len(tt.results))-1]
				if err != nil {
					return "", err
				}
				return resolved, nil
			}

			for i, want := range tt.calls {
				path, err := tt.env.composeFile(tt.projectID, resolve)
				if !errors.Is(err, want.wantErr) {
					t.Fatalf("call %d: err = %v, want %v", i+1, err, want.wantErr)
				}
				if path != want.wantPath {
					t.Fatalf("call %d: path = %q, want %q", i+1, path, want.wantPath)
				}
				if calls != want.wantCalls {
					t.Fatalf("call %d: resolve invoked %d times, want %d", i+1, calls, want.wantCalls)
				}
			}
		})
	}
}

func TestProjectTags_ReconcilePreservesUIAndComposeOwnershipIsReadOnly(t *testing.T) {
	db := setupProjectTestDB(t)
	service := NewProjectService(
		db,
		nil,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		nil,
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	ctx := t.Context()
	projectModel := Project{
		ID:              "project-tags",
		Name:            "tagged",
		Path:            "/tmp/tagged",
		Status:          ProjectStatusStopped,
		IsArchived:      true,
		GitOpsManagedBy: new("gitops-1"),
	}
	require.NoError(t, db.Create(&projectModel).Error)

	projectTags, err := service.UpdateProjectTag(ctx, projectModel.ID, " Database ", projecttypes.TagColorPurple, true, usertypes.Actor{})
	require.NoError(t, err)
	require.Equal(t, []projecttypes.Tag{{Name: "database", Color: projecttypes.TagColorPurple, Sources: []projecttypes.TagSource{projecttypes.TagSourceUI}}}, projectTags)

	require.NoError(t, service.reconcileComposeProjectTags(ctx, projectModel.ID, []projecttypes.TagOption{
		{Name: "DATABASE", Color: projecttypes.TagColorBlue},
		{Name: "maintenance-window", Color: projecttypes.TagColorOrange},
	}))
	projectTags, err = service.GetProjectTags(ctx, projectModel.ID)
	require.NoError(t, err)
	require.Equal(t, []projecttypes.Tag{
		{Name: "database", Color: projecttypes.TagColorBlue, Sources: []projecttypes.TagSource{projecttypes.TagSourceUI, projecttypes.TagSourceCompose}},
		{Name: "maintenance-window", Color: projecttypes.TagColorOrange, Sources: []projecttypes.TagSource{projecttypes.TagSourceCompose}},
	}, projectTags)

	_, err = service.UpdateProjectTag(ctx, projectModel.ID, "database", "", false, usertypes.Actor{})
	require.ErrorIs(t, err, tags.ErrComposeTagReadOnly)
	_, err = service.UpdateProjectTag(ctx, projectModel.ID, "maintenance-window", projecttypes.TagColorBlue, true, usertypes.Actor{})
	require.ErrorIs(t, err, tags.ErrComposeTagReadOnly)

	require.NoError(t, service.reconcileComposeProjectTags(ctx, projectModel.ID, nil))
	projectTags, err = service.UpdateProjectTag(ctx, projectModel.ID, "database", "", false, usertypes.Actor{})
	require.NoError(t, err)
	require.Empty(t, projectTags)
}

func TestProjectTags_FilterUsesExactORNames(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx := t.Context()
	seededProjects := []Project{
		{ID: "one", Name: "one", Path: "/tmp/one", Status: ProjectStatusStopped},
		{ID: "two", Name: "two", Path: "/tmp/two", Status: ProjectStatusStopped},
		{ID: "three", Name: "three", Path: "/tmp/three", Status: ProjectStatusStopped},
	}
	require.NoError(t, db.Create(&seededProjects).Error)
	require.NoError(t, db.Create(&[]ProjectTag{
		{ProjectID: "one", Name: "database", Source: string(projecttypes.TagSourceUI)},
		{ProjectID: "two", Name: "maintenance", Source: string(projecttypes.TagSourceCompose)},
		{ProjectID: "three", Name: "database-prod", Source: string(projecttypes.TagSourceUI)},
	}).Error)

	var result []Project
	err := listing.ApplyProjectTagsDBFilter(db.WithContext(ctx).Model(&Project{}), " DATABASE,maintenance ").Order("id").Find(&result).Error
	require.NoError(t, err)
	require.Len(t, result, 2)
	require.ElementsMatch(t, []string{"one", "two"}, []string{result[0].ID, result[1].ID})
	require.NotContains(t, []string{result[0].ID, result[1].ID}, "three")

	settingsService, err := newSettingsServiceForTest(t, ctx, db)
	require.NoError(t, err)
	svc := NewProjectService(
		db,
		settingsService,
		event.NewEventService(db, nil, nil),
		image.NewImageService(db, nil, nil, nil, nil, nil, nil, nil),
		testDockerService,
		testBuildBuilder{},
		nil,
		nil,
		config.Load(),
		kv.NewKVService(db),
		testRegistryCredentials,
	)
	items, _, err := svc.ListProjects(ctx, pagination.QueryParams{Search: "MAINT", Limit: -1})
	require.NoError(t, err)
	require.Len(t, items, 1)
	require.Equal(t, "two", items[0].ID)
}

func setupLifecycleTestDB(t *testing.T) *database.DB {
	t.Helper()
	db, err := gorm.Open(sqlite.Open(":memory:"), &gorm.Config{})
	require.NoError(t, err)
	require.NoError(t, db.AutoMigrate(
		&settings.SettingVariable{},
		&Project{},
		&GitOpsSync{},
		&event.Event{},
	))
	return &database.DB{DB: db}
}

func newLifecycleTestService(t *testing.T, db *database.DB) (*LifecycleService, *settings.SettingsService) {
	t.Helper()
	settingsService, err := settings.NewSettingsService(t.Context(), db, &config.Config{})
	require.NoError(t, err)
	t.Cleanup(func() { require.NoError(t, settingsService.Stop(context.WithoutCancel(t.Context()))) })
	events := event.NewEventService(db, nil, nil)
	return NewLifecycleService(db, settingsService, events, nil, nil), settingsService
}

func writeLifecycleProjectDirWithScript(t *testing.T, scriptRel, scriptBody string) string {
	t.Helper()
	dir := t.TempDir()
	if scriptRel != "" {
		full := filepath.Join(dir, scriptRel)
		require.NoError(t, os.MkdirAll(filepath.Dir(full), 0o755))
		require.NoError(t, os.WriteFile(full, []byte(scriptBody), 0o644))
	}
	return dir
}

func TestParseLifecycleEnvText_Empty(t *testing.T) {
	got, err := ParseEnvText(nil)
	require.NoError(t, err)
	assert.Empty(t, got)

	empty := "   "
	got, err = ParseEnvText(&empty)
	require.NoError(t, err)
	assert.Empty(t, got)
}

func TestParseLifecycleEnvText_Valid(t *testing.T) {
	raw := "FOO=bar\nBAZ_2=qux"
	got, err := ParseEnvText(&raw)
	require.NoError(t, err)
	assert.Equal(t, map[string]string{"FOO": "bar", "BAZ_2": "qux"}, got)
}

func TestParseLifecycleEnvText_RejectsInvalidKeys(t *testing.T) {
	cases := map[string]string{
		"leading digit": "1FOO=bar",
		"dash":          "FOO-BAR=baz",
		"dot":           "foo.bar=baz",
		"no equals":     "FOO bar",
	}
	for name, raw := range cases {
		t.Run(name, func(t *testing.T) {
			_, err := ParseEnvText(&raw)
			require.Error(t, err)
		})
	}
}

func TestParseLifecycleExtraMountsText_Empty(t *testing.T) {
	got, err := ParseExtraMountsText(nil)
	require.NoError(t, err)
	assert.Nil(t, got)
}

func TestParseLifecycleExtraMountsText_Valid(t *testing.T) {
	raw := "/host/age.key:/age.key:ro\n/host/data:/data"
	got, err := ParseExtraMountsText(&raw)
	require.NoError(t, err)
	require.Len(t, got, 2)
	assert.Equal(t, "/host/age.key", got[0].Source)
	assert.Equal(t, "/age.key", got[0].Target)
	assert.True(t, got[0].Readonly)
	assert.Equal(t, "/host/data", got[1].Source)
	assert.Equal(t, "/data", got[1].Target)
	assert.False(t, got[1].Readonly)
}

func TestParseLifecycleExtraMountsText_RejectsRelativePaths(t *testing.T) {
	cases := []string{
		"relative/path:/in/container",
		"/host/path:relative/target",
	}
	for _, raw := range cases {
		t.Run(raw, func(t *testing.T) {
			_, err := ParseExtraMountsText(&raw)
			require.Error(t, err)
		})
	}
}

func TestParseLifecycleExtraMountsText_RejectsInvalidMode(t *testing.T) {
	raw := "/host/data:/data:wat"
	_, err := ParseExtraMountsText(&raw)
	require.Error(t, err)
}

func TestRunPreDeploy_ProjectNotGitOpsManaged(t *testing.T) {
	db := setupLifecycleTestDB(t)
	svc, settingsService := newLifecycleTestService(t, db)
	require.NoError(t, settingsService.SetStringSetting(t.Context(), "lifecycleEnabled", "true"))

	project := &Project{
		Name:            "demo",
		Path:            t.TempDir(),
		GitOpsManagedBy: nil,
	}
	require.NoError(t, svc.runPreDeploy(t.Context(), project, usertypes.Actor{}))

	// A stale marker without a sync row is treated as unmanaged.
	require.NoError(t, svc.runPreDeploy(t.Context(), &Project{
		ID:              "nonexistent",
		Name:            "demo",
		Path:            project.Path,
		GitOpsManagedBy: new("missing-sync"),
	}, usertypes.Actor{}))
}

func TestRunPreDeploy_KillSwitchAndLastRunState(t *testing.T) {
	db := setupLifecycleTestDB(t)
	settingsService, err := newSettingsServiceForTest(t, t.Context(), db)
	require.NoError(t, err)

	var exitCode atomic.Int64
	// Handlers run on server goroutines, so failures use assert rather than require.
	writeFrame := func(w io.Writer, stream stdcopy.StdType, payload string) error {
		header := []byte{byte(stream), 0, 0, 0}
		if _, writeErr := w.Write(binary.BigEndian.AppendUint32(header, uint32(len(payload)))); writeErr != nil {
			return fmt.Errorf("write stream %d frame header: %w", stream, writeErr)
		}
		if _, writeErr := io.WriteString(w, payload); writeErr != nil {
			return fmt.Errorf("write stream %d frame payload: %w", stream, writeErr)
		}
		return nil
	}
	dockerServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch {
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/images/alpine:latest/json"):
			w.Header().Set("Content-Type", "application/json")
			_, writeErr := io.WriteString(w, `{"Id":"sha256:runner"}`)
			assert.NoError(t, writeErr, "write image inspect response")
		case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/containers/create"):
			w.Header().Set("Content-Type", "application/json")
			w.WriteHeader(http.StatusCreated)
			_, writeErr := io.WriteString(w, `{"Id":"hook-1"}`)
			assert.NoError(t, writeErr, "write container create response")
		case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/containers/hook-1/start"):
			w.WriteHeader(http.StatusNoContent)
		case r.Method == http.MethodGet && strings.HasSuffix(r.URL.Path, "/containers/hook-1/logs"):
			w.Header().Set("Content-Type", "application/vnd.docker.multiplexed-stream")
			if !assert.NoError(t, writeFrame(w, stdcopy.Stdout, "hello\n"), "write stdout log frame") {
				return
			}
			assert.NoError(t, writeFrame(w, stdcopy.Stderr, "boom\n"), "write stderr log frame")
		case r.Method == http.MethodPost && strings.HasSuffix(r.URL.Path, "/containers/hook-1/wait"):
			w.Header().Set("Content-Type", "application/json")
			_, writeErr := fmt.Fprintf(w, `{"StatusCode":%d}`, exitCode.Load())
			assert.NoError(t, writeErr, "write container wait response")
		case r.Method == http.MethodDelete && strings.HasSuffix(r.URL.Path, "/containers/hook-1"):
			w.WriteHeader(http.StatusNoContent)
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(dockerServer.Close)
	dockerService := &docker.DockerClientService{Client: newTestDockerClient(t, dockerServer)}
	svc := NewLifecycleService(db, settingsService, event.NewEventService(db, nil, nil), dockerService, nil)

	syncID := "sync-1"
	project := &Project{
		ID:              "proj-1",
		Name:            "demo",
		Path:            writeLifecycleProjectDirWithScript(t, "pre-deploy.sh", "echo hi\n"),
		GitOpsManagedBy: &syncID,
	}
	require.NoError(t, db.Create(project).Error)

	scriptPath := "pre-deploy.sh"
	runnerImage := "alpine:latest"
	gitOpsSync := &GitOpsSync{
		ID:                   syncID,
		Name:                 "demo-sync",
		EnvironmentID:        "0",
		RepositoryID:         "repo-1",
		Branch:               "main",
		ComposePath:          "docker-compose.yaml",
		TargetType:           "project",
		ProjectName:          "demo",
		ProjectID:            &project.ID,
		PreDeployScriptPath:  &scriptPath,
		PreDeployRunnerImage: &runnerImage,
	}
	require.NoError(t, db.Create(gitOpsSync).Error)

	loadSync := func() GitOpsSync {
		var stored GitOpsSync
		require.NoError(t, db.First(&stored, "id = ?", syncID).Error)
		return stored
	}

	// The kill switch skips the hook and leaves no last-run state.
	require.NoError(t, svc.runPreDeploy(t.Context(), project, usertypes.Actor{}))
	assert.Nil(t, loadSync().PreDeployLastRunAt)

	require.NoError(t, settingsService.SetStringSetting(t.Context(), "lifecycleEnabled", "true"))
	before := time.Now()
	require.NoError(t, svc.runPreDeploy(t.Context(), project, usertypes.Actor{}))
	stored := loadSync()
	require.NotNil(t, stored.PreDeployLastRunAt)
	assert.WithinRange(t, *stored.PreDeployLastRunAt, before, time.Now())
	assert.Equal(t, "success", mo.PointerToOption(stored.PreDeployLastRunStatus).OrEmpty())
	assert.Equal(t, "hello\n--- stderr ---\nboom", mo.PointerToOption(stored.PreDeployLastRunOutput).OrEmpty())

	exitCode.Store(3)
	before = time.Now()
	err = svc.runPreDeploy(t.Context(), project, usertypes.Actor{})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "exited with status 3")
	stored = loadSync()
	require.NotNil(t, stored.PreDeployLastRunAt)
	assert.WithinRange(t, *stored.PreDeployLastRunAt, before, time.Now())
	assert.Equal(t, "failed", mo.PointerToOption(stored.PreDeployLastRunStatus).OrEmpty())
	assert.Equal(t, "hello\n--- stderr ---\nboom", mo.PointerToOption(stored.PreDeployLastRunOutput).OrEmpty())
}

func TestRunPreDeploy_NoScriptConfigured(t *testing.T) {
	db := setupLifecycleTestDB(t)
	svc, settingsService := newLifecycleTestService(t, db)
	require.NoError(t, settingsService.SetStringSetting(t.Context(), "lifecycleEnabled", "true"))

	syncID := "sync-1"
	project := &Project{
		ID:              "proj-1",
		Name:            "demo",
		Path:            t.TempDir(),
		GitOpsManagedBy: &syncID,
	}
	require.NoError(t, db.Create(project).Error)

	gitOpsSync := &GitOpsSync{
		ID:            syncID,
		Name:          "demo-sync",
		EnvironmentID: "0",
		RepositoryID:  "repo-1",
		Branch:        "main",
		ComposePath:   "docker-compose.yaml",
		TargetType:    "project",
		ProjectName:   "demo",
		ProjectID:     &project.ID,
	}
	require.NoError(t, db.Create(gitOpsSync).Error)

	require.NoError(t, svc.runPreDeploy(t.Context(), project, usertypes.Actor{}))
}

func TestRunPreDeploy_MissingRunnerImage(t *testing.T) {
	db := setupLifecycleTestDB(t)
	svc, settingsService := newLifecycleTestService(t, db)
	require.NoError(t, settingsService.SetStringSetting(t.Context(), "lifecycleEnabled", "true"))
	require.NoError(t, settingsService.SetStringSetting(t.Context(), "lifecycleDefaultRunnerImage", " "))

	syncID := "sync-1"
	projectDir := writeLifecycleProjectDirWithScript(t, "pre-deploy.sh", "echo hi\n")
	project := &Project{
		ID:              "proj-1",
		Name:            "demo",
		Path:            projectDir,
		GitOpsManagedBy: &syncID,
	}
	require.NoError(t, db.Create(project).Error)

	scriptPath := "pre-deploy.sh"
	gitOpsSync := &GitOpsSync{
		ID:                  syncID,
		Name:                "demo-sync",
		EnvironmentID:       "0",
		RepositoryID:        "repo-1",
		Branch:              "main",
		ComposePath:         "docker-compose.yaml",
		TargetType:          "project",
		ProjectName:         "demo",
		ProjectID:           &project.ID,
		PreDeployScriptPath: &scriptPath,
	}
	require.NoError(t, db.Create(gitOpsSync).Error)

	err := svc.runPreDeploy(t.Context(), project, usertypes.Actor{})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "runner image")
}

func TestRunPreDeploy_PathTraversalRejected(t *testing.T) {
	db := setupLifecycleTestDB(t)
	svc, settingsService := newLifecycleTestService(t, db)
	require.NoError(t, settingsService.SetStringSetting(t.Context(), "lifecycleEnabled", "true"))

	syncID := "sync-1"
	project := &Project{
		ID:              "proj-1",
		Name:            "demo",
		Path:            t.TempDir(),
		GitOpsManagedBy: &syncID,
	}
	require.NoError(t, db.Create(project).Error)

	scriptPath := "../etc/passwd"
	runnerImage := "alpine:latest"
	gitOpsSync := &GitOpsSync{
		ID:                   syncID,
		Name:                 "demo-sync",
		EnvironmentID:        "0",
		RepositoryID:         "repo-1",
		Branch:               "main",
		ComposePath:          "docker-compose.yaml",
		TargetType:           "project",
		ProjectName:          "demo",
		ProjectID:            &project.ID,
		PreDeployScriptPath:  &scriptPath,
		PreDeployRunnerImage: &runnerImage,
	}
	require.NoError(t, db.Create(gitOpsSync).Error)

	err := svc.runPreDeploy(t.Context(), project, usertypes.Actor{})
	require.Error(t, err)
	assert.Contains(t, err.Error(), "script path")
}

func discoveryListingForTest(imageService *image.ImageService) *listing.Service {
	service := NewProjectService(nil, nil, nil, imageService, testDockerService, testBuildBuilder{}, nil, nil, nil, nil, testRegistryCredentials)
	return service.listing
}

func TestListProjectReferencesIncludesArchivedProjects(t *testing.T) {
	db := setupProjectTestDB(t)
	service := &ProjectService{db: db}
	require.NoError(t, db.Create(&Project{ID: "project-active", Name: "active", Path: "/projects/active", Status: ProjectStatusStopped}).Error)
	require.NoError(t, db.Create(&Project{ID: "project-archived", Name: "archived", Path: "/projects/archived", Status: ProjectStatusStopped, IsArchived: true}).Error)

	references, err := service.ListProjectReferences(t.Context())
	require.NoError(t, err)
	require.Equal(t, []projecttypes.Reference{
		{ID: "project-active", Name: "active"},
		{ID: "project-archived", Name: "archived"},
	}, references)
}

func projectScopeContext(t *testing.T, target string, bodies map[string]any) (context.Context, *sync.Map) {
	t.Helper()
	var queries sync.Map
	return httpx.WithEnvironmentScope(t.Context(), &httpx.EnvironmentScope{
		IDs:     []string{"a", "b", "c"},
		Request: httptest.NewRequest(http.MethodGet, target, http.NoBody),
		Handler: http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
			id := strings.Split(strings.TrimPrefix(r.URL.Path, "/api/environments/"), "/")[0]
			queries.Store(id, r.URL.Query())
			body, ok := bodies[id]
			if !ok {
				w.WriteHeader(http.StatusBadGateway)
				_, _ = w.Write([]byte(`{"detail":"environment offline"}`))
				return
			}
			_ = json.NewEncoder(w).Encode(body)
		}),
		Resolve: func(_ context.Context, id string) (base.EnvironmentRef, error) {
			return base.EnvironmentRef{ID: id, Name: "Env " + id}, nil
		},
	}), &queries
}

func TestAggregateProjectsMergesEnvironments(t *testing.T) {
	bodies := map[string]any{
		"a": base.Paginated[projecttypes.Details]{Success: true, Data: []projecttypes.Details{
			{ID: "a1", Name: "web", ServiceCount: 2},
			{ID: "a2", Name: "db", ServiceCount: 1},
		}, Pagination: base.PaginationResponse{TotalItems: 2, GrandTotalItems: 3}},
		"b": base.Paginated[projecttypes.Details]{Success: true, Data: []projecttypes.Details{
			{ID: "b1", Name: "cache", ServiceCount: 3},
		}, Pagination: base.PaginationResponse{TotalItems: 1}},
	}
	rowLabels := func(items []projecttypes.Details) []string {
		out := make([]string, 0, len(items))
		for _, item := range items {
			out = append(out, item.EnvironmentID+"/"+item.Name)
		}
		return out
	}
	svc := &ProjectService{}

	t.Run("sorts by name across environments and pages", func(t *testing.T) {
		ctx, queries := projectScopeContext(t, "/api/environments/a,b,c/projects?start=0&limit=2&sort=name&order=asc", bodies)
		body, err := svc.AggregateProjects(ctx, pagination.QueryParams{SortParams: pagination.SortParams{Sort: "name", Order: pagination.SortAsc}, Params: pagination.Params{Limit: 2}})
		require.NoError(t, err)

		assert.True(t, body.Success)
		assert.Equal(t, []string{"b/cache", "a/db"}, rowLabels(body.Data))
		assert.Equal(t, "Env b", body.Data[0].EnvironmentName)
		assert.Equal(t, int64(3), body.Pagination.TotalItems)
		assert.Equal(t, int64(4), body.Pagination.GrandTotalItems)
		assert.Equal(t, int64(2), body.Pagination.TotalPages)
		require.Len(t, body.FailedEnvironments, 1)
		assert.Equal(t, "c", body.FailedEnvironments[0].Environment.ID)
		assert.Equal(t, "environment offline", body.FailedEnvironments[0].Message)
		for _, id := range []string{"a", "b"} {
			query, ok := queries.Load(id)
			require.True(t, ok)
			assert.Equal(t, "0", query.(url.Values).Get("start"))
			assert.Equal(t, "-1", query.(url.Values).Get("limit"))
		}
	})

	t.Run("sorts by service count descending", func(t *testing.T) {
		ctx, _ := projectScopeContext(t, "/api/environments/a,b,c/projects", bodies)
		body, err := svc.AggregateProjects(ctx, pagination.QueryParams{SortParams: pagination.SortParams{Sort: "serviceCount", Order: pagination.SortDesc}, Params: pagination.Params{Limit: -1}})
		require.NoError(t, err)
		assert.Equal(t, []string{"b/cache", "a/web", "a/db"}, rowLabels(body.Data))
	})

	t.Run("sorts by environment", func(t *testing.T) {
		ctx, queries := projectScopeContext(t, "/api/environments/a,b,c/projects?sort=environment&order=desc", bodies)
		body, err := svc.AggregateProjects(ctx, pagination.QueryParams{SortParams: pagination.SortParams{Sort: "environment", Order: pagination.SortDesc}, Params: pagination.Params{Limit: -1}})
		require.NoError(t, err)
		assert.Equal(t, []string{"b/cache", "a/web", "a/db"}, rowLabels(body.Data))
		query, _ := queries.Load("a")
		assert.Empty(t, query.(url.Values).Get("sort"))
	})

	t.Run("all environments failing returns empty data", func(t *testing.T) {
		ctx, _ := projectScopeContext(t, "/api/environments/a,b,c/projects", map[string]any{})
		body, err := svc.AggregateProjects(ctx, pagination.QueryParams{Params: pagination.Params{Limit: 20}})
		require.NoError(t, err)
		assert.Empty(t, body.Data)
		assert.Len(t, body.FailedEnvironments, 3)
	})
}

func TestAggregateProjectCountsSumsEnvironments(t *testing.T) {
	ctx, _ := projectScopeContext(t, "/api/environments/a,b,c/projects/counts", map[string]any{
		"a": base.ApiResponse[projecttypes.StatusCounts]{Success: true, Data: projecttypes.StatusCounts{RunningProjects: 2, StoppedProjects: 1, TotalProjects: 4, ArchivedProjects: 1}},
		"b": base.ApiResponse[projecttypes.StatusCounts]{Success: true, Data: projecttypes.StatusCounts{RunningProjects: 1, StoppedProjects: 3, TotalProjects: 4}},
	})

	body, err := (&ProjectService{}).AggregateProjectCounts(ctx)
	require.NoError(t, err)

	assert.True(t, body.Success)
	assert.Equal(t, projecttypes.StatusCounts{RunningProjects: 3, StoppedProjects: 4, TotalProjects: 8, ArchivedProjects: 1}, body.Data)
	require.Len(t, body.FailedEnvironments, 1)
	assert.Equal(t, "c", body.FailedEnvironments[0].Environment.ID)
}

func TestAggregateProjectTagsUnionsByName(t *testing.T) {
	ctx, _ := projectScopeContext(t, "/api/environments/a,b,c/projects/tags", map[string]any{
		"a": base.ApiResponse[[]projecttypes.TagOption]{Success: true, Data: []projecttypes.TagOption{{Name: "prod", Color: "red"}, {Name: "web", Color: "blue"}}},
		"b": base.ApiResponse[[]projecttypes.TagOption]{Success: true, Data: []projecttypes.TagOption{{Name: "api", Color: "green"}, {Name: "prod", Color: "gray"}}},
	})

	body, err := (&ProjectService{}).AggregateProjectTags(ctx)
	require.NoError(t, err)

	assert.Equal(t, []projecttypes.TagOption{{Name: "api", Color: "green"}, {Name: "prod", Color: "red"}, {Name: "web", Color: "blue"}}, body.Data)
	require.Len(t, body.FailedEnvironments, 1)
}