Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
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(¤tRecord).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(¤tRecord).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(¤tRecord).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(®istry.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)
}