Skip to content

Modern Docker Management, Designed for Everyone

68.0 KB
Raw Blame
package container

import (
	"bytes"
	"cmp"
	"context"
	"encoding/binary"
	"encoding/json"
	"fmt"
	"io"
	"maps"
	"net/http"
	"net/http/httptest"
	"net/netip"
	"net/url"
	"regexp"
	"slices"
	"strings"
	"sync"
	"sync/atomic"
	"testing"
	"time"

	"github.com/containerd/errdefs"
	"github.com/getarcaneapp/arcane/types/v2/base"
	containertypes "github.com/getarcaneapp/arcane/types/v2/container"
	"github.com/getarcaneapp/arcane/types/v2/image"
	podmantypes "github.com/getarcaneapp/arcane/types/v2/podman"
	"github.com/getarcaneapp/arcane/types/v2/user"
	"github.com/libtnb/sqlite"
	"github.com/moby/moby/api/types/container"
	"github.com/moby/moby/api/types/mount"
	"github.com/moby/moby/api/types/network"
	"github.com/moby/moby/client"
	"github.com/stretchr/testify/require"
	"go.getarcane.app/docker/compat"
	"go.getarcane.app/kit/pkg"
	"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/container/children/stats"
	"github.com/getarcaneapp/arcane/backend/v2/internal/database"
	"github.com/getarcaneapp/arcane/backend/v2/internal/docker"
	"github.com/getarcaneapp/arcane/backend/v2/internal/event"
	imagedomain "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/podman"
	"github.com/getarcaneapp/arcane/backend/v2/internal/project"
	"github.com/getarcaneapp/arcane/backend/v2/internal/settings"
	libpodman "github.com/getarcaneapp/arcane/backend/v2/pkg/libarcane/podman"
	"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"
)

type resourceStatsServer struct {
	mu          sync.Mutex
	containers  []container.Summary
	stats       map[string]container.StatsResponse
	statsStatus map[string]int
	statsCalls  map[string]int
	delay       time.Duration
	slowIDs     map[string]bool

	current atomic.Int32
	maxSeen atomic.Int32
}

func TestPaginateContainerProjectGroupsKeepsProjectWhole(t *testing.T) {
	items := []containertypes.Summary{
		newGroupedContainerSummary("other-1", "other-1"),
		newGroupedContainerSummary("other-2", "other-2"),
		newGroupedContainerSummary("other-3", "other-3"),
		newGroupedContainerSummary("other-4", "other-4"),
		newGroupedContainerSummary("other-5", "other-5"),
		newGroupedContainerSummary("other-6", "other-6"),
		newGroupedContainerSummary("other-7", "other-7"),
		newGroupedContainerSummary("other-8", "other-8"),
		newGroupedContainerSummary("other-9", "other-9"),
		newGroupedContainerSummary("other-10", "other-10"),
		newGroupedContainerSummary("other-11", "other-11"),
		newGroupedContainerSummary("other-12", "other-12"),
		newGroupedContainerSummary("other-13", "other-13"),
		newGroupedContainerSummary("other-14", "other-14"),
		newGroupedContainerSummary("other-15", "other-15"),
		newGroupedContainerSummary("other-16", "other-16"),
		newGroupedContainerSummary("other-17", "other-17"),
		newGroupedContainerSummary("other-18", "other-18"),
		newGroupedContainerSummary("immich-server", "immich"),
		newGroupedContainerSummary("immich-ml", "immich"),
		newGroupedContainerSummary("immich-redis", "immich"),
		newGroupedContainerSummary("immich-postgres", "immich"),
	}

	groupedItems, resp := paginateContainerProjectGroups(
		pagination.FilterResult[containertypes.Summary]{Items: items, TotalCount: int64(len(items)), TotalAvailable: int64(len(items))},
		pagination.QueryParams{Start: 0, Limit: 20},
	)

	require.Len(t, groupedItems, 19)
	require.Equal(t, int64(1), resp.TotalPages)
	require.Equal(t, 1, resp.CurrentPage)
	require.Equal(t, 20, resp.ItemsPerPage)
	require.Equal(t, int64(22), resp.TotalItems)

	projectCounts := make(map[string]int)
	for _, group := range groupedItems {
		projectCounts[group.GroupName] += len(group.Items)
	}

	require.Equal(t, 4, projectCounts["immich"])
	require.Equal(t, 1, projectCounts["other-1"])
	require.Equal(t, 1, projectCounts["other-18"])
}

func TestPaginateContainerProjectGroupsSelectsRequestedPage(t *testing.T) {
	// With Limit=4 the groups partition into three pages:
	// page 1: proj-a (4), page 2: proj-b (3) + solo-1 (1), page 3: proj-c (2) + solo-2 (1).
	items := []containertypes.Summary{
		newGroupedContainerSummary("a-1", "proj-a"),
		newGroupedContainerSummary("a-2", "proj-a"),
		newGroupedContainerSummary("a-3", "proj-a"),
		newGroupedContainerSummary("a-4", "proj-a"),
		newGroupedContainerSummary("b-1", "proj-b"),
		newGroupedContainerSummary("b-2", "proj-b"),
		newGroupedContainerSummary("b-3", "proj-b"),
		newGroupedContainerSummary("solo-1", "solo-1"),
		newGroupedContainerSummary("c-1", "proj-c"),
		newGroupedContainerSummary("c-2", "proj-c"),
		newGroupedContainerSummary("solo-2", "solo-2"),
	}
	result := pagination.FilterResult[containertypes.Summary]{Items: items, TotalCount: int64(len(items)), TotalAvailable: int64(len(items))}

	pageGroups, resp := paginateContainerProjectGroups(result, pagination.QueryParams{Start: 4, Limit: 4})

	require.Equal(t, []string{"proj-b", "solo-1"}, groupNamesOf(pageGroups))
	require.Equal(t, 2, resp.CurrentPage)
	require.Equal(t, int64(3), resp.TotalPages)
	require.Equal(t, int64(11), resp.TotalItems)

	pageGroups, resp = paginateContainerProjectGroups(result, pagination.QueryParams{Start: 400, Limit: 4})

	require.Equal(t, []string{"proj-c", "solo-2"}, groupNamesOf(pageGroups))
	require.Equal(t, 3, resp.CurrentPage)
	require.Equal(t, int64(3), resp.TotalPages)
}

func TestContainerSummaryIconsAppliedAfterGrouping(t *testing.T) {
	db := setupProjectTestDB(t)
	settingsService, err := settings.NewSettingsService(t.Context(), db, &config.Config{})
	require.NoError(t, err)
	service := NewContainerService(nil, nil, nil, settingsService, project.NewProjectService(db, settingsService, nil, nil, nil, nil, nil, nil, nil, nil, nil), nil, nil)
	dockerContainers := []container.Summary{
		{ID: "app", Names: []string{"/app"}, Labels: map[string]string{
			"com.docker.compose.project": "media",
			projects.ArcaneIconLabel:     "immich",
		}},
		{ID: "db", Names: []string{"/db"}, Labels: map[string]string{
			"com.docker.compose.project":      "media",
			"com.getarcaneapp.arcane.updater": "false",
		}},
	}

	items := service.BuildSummaries(t.Context(), dockerContainers, nil, "", nil)
	for _, item := range items {
		require.Empty(t, item.IconLightURL, "icons must be deferred until after pagination")
	}

	groups, _ := paginateContainerProjectGroups(
		pagination.FilterResult[containertypes.Summary]{Items: items, TotalCount: int64(len(items)), TotalAvailable: int64(len(items))},
		pagination.QueryParams{Start: 0, Limit: 20},
	)
	for gi := range groups {
		service.ApplySummaryIcons(t.Context(), groups[gi].Items, map[string]projects.ArcaneComposeMetadata{})
	}
	flattened := flattenContainerProjectGroups(groups)

	require.Len(t, groups, 1)
	require.NotEmpty(t, groups[0].Items[0].IconLightURL)
	require.NotEmpty(t, flattened[0].IconLightURL, "flattened items must carry icons applied to the groups")
	for _, item := range flattened {
		require.Equal(t, item.ID != "db", item.AutoUpdateEnabled, "grouped items carry the label-derived auto-update status for %s", item.ID)
	}
}

func groupNamesOf(groups []containertypes.SummaryGroup) []string {
	names := make([]string, 0, len(groups))
	for _, group := range groups {
		names = append(names, group.GroupName)
	}
	return names
}

func TestGroupContainersByProjectUsesNoProjectBucket(t *testing.T) {
	groups := groupContainersByProject([]containertypes.Summary{
		{ID: "1", Labels: map[string]string{"com.docker.compose.project": "alpha"}},
		{ID: "2", Labels: map[string]string{}},
		{ID: "3", Labels: nil},
	})

	require.Len(t, groups, 2)
	require.Equal(t, "alpha", groups[0].GroupName)
	require.Len(t, groups[0].Items, 1)
	require.Equal(t, containerNoProjectGroup, groups[1].GroupName)
	require.Len(t, groups[1].Items, 2)
}

func TestBuildContainerFilterAccessors_FiltersStandaloneContainers(t *testing.T) {
	service := &ContainerService{}
	updateInfo := &image.UpdateInfo{HasUpdate: true}
	items := []containertypes.Summary{
		{ID: "standalone", Labels: map[string]string{}, UpdateInfo: updateInfo},
		{ID: "compose", Labels: map[string]string{"com.docker.compose.project": "alpha"}, UpdateInfo: updateInfo},
		{ID: "swarm-task", Labels: map[string]string{"com.docker.swarm.service.name": "web"}, UpdateInfo: updateInfo},
	}

	result := pagination.Config[containertypes.Summary]{FilterAccessors: service.buildContainerPaginationConfig().FilterAccessors}.SearchOrderAndPaginate(
		items,
		pagination.QueryParams{Filters: map[string]string{"standalone": "true", "updates": "has_update"}},
	)

	require.Len(t, result.Items, 1)
	require.Equal(t, "standalone", result.Items[0].ID)
	require.Equal(t, int64(1), result.TotalCount)
}

func TestBuildContainerFilterAccessors_FiltersByLabel(t *testing.T) {
	service := &ContainerService{}
	items := []containertypes.Summary{
		{ID: "tagged", Labels: map[string]string{"heal": "true", "tags": "a,b"}},
		{ID: "other", Labels: map[string]string{"heal": "false"}},
		{ID: "bare", Labels: map[string]string{}},
	}
	paginationConfig := pagination.Config[containertypes.Summary]{FilterAccessors: service.buildContainerPaginationConfig().FilterAccessors}

	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", "bare"}},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := paginationConfig.SearchOrderAndPaginate(items, pagination.QueryParams{Filters: map[string]string{"label": tt.filter}})
			var got []string
			for _, item := range result.Items {
				got = append(got, item.ID)
			}
			require.Equal(t, tt.want, got)
		})
	}
}

func TestBuildCleanNetworkingConfigPreservesEndpointSettings(t *testing.T) {
	containerInspect := container.InspectResponse{
		NetworkSettings: &container.NetworkSettings{
			Networks: map[string]*network.EndpointSettings{
				"bridge": {
					Aliases:    []string{"svc"},
					IPAddress:  netip.MustParseAddr("172.17.0.2"),
					IPAMConfig: &network.EndpointIPAMConfig{IPv4Address: netip.MustParseAddr("172.17.0.5")},
				},
			},
		},
	}

	out := buildCleanNetworkingConfig(containerInspect, "1.44")
	require.NotNil(t, out)
	require.Contains(t, out.EndpointsConfig, "bridge")
	require.Equal(t, []string{"svc"}, out.EndpointsConfig["bridge"].Aliases)
	require.Equal(t, netip.MustParseAddr("172.17.0.2"), out.EndpointsConfig["bridge"].IPAddress)
	require.Nil(t, out.EndpointsConfig["bridge"].IPAMConfig)
}

func TestCompareContainerPortsForSortDesc_KeepsContainersWithoutPortsLast(t *testing.T) {
	withPublished := containertypes.Summary{
		ID:    "published",
		Names: []string{"/published"},
		Ports: []containertypes.Port{{PublicPort: 8080, PrivatePort: 80, Type: "tcp"}},
	}
	withPrivateOnly := containertypes.Summary{
		ID:    "private",
		Names: []string{"/private"},
		Ports: []containertypes.Port{{PrivatePort: 3000, Type: "tcp"}},
	}
	withoutPorts := containertypes.Summary{
		ID:    "none",
		Names: []string{"/none"},
	}

	sortBindings := (&ContainerService{}).buildContainerPaginationConfig().SortBindings
	comparePortsDesc := sortBindings[slices.IndexFunc(sortBindings, func(binding pagination.SortBinding[containertypes.Summary]) bool {
		return binding.Key == "ports"
	})].DescFn

	require.Equal(t, -1, comparePortsDesc(withPublished, withPrivateOnly))
	require.Equal(t, -1, comparePortsDesc(withPrivateOnly, withoutPorts))
	require.Equal(t, 1, comparePortsDesc(withoutPorts, withPublished))
}

func TestContainerServiceCommitContainerCallsDockerAPI(t *testing.T) {
	db := setupProjectTestDB(t)
	var gotRequest map[string]any
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodPost || dockerTestPath(r.URL.Path) != "/commit" {
			http.NotFound(w, r)
			return
		}
		gotRequest = map[string]any{
			"container": r.URL.Query().Get("container"),
			"repo":      r.URL.Query().Get("repo"),
			"tag":       r.URL.Query().Get("tag"),
			"comment":   r.URL.Query().Get("comment"),
			"author":    r.URL.Query().Get("author"),
		}
		_ = json.NewEncoder(w).Encode(map[string]string{"ID": "sha256:new-image"})
	}))
	t.Cleanup(server.Close)

	svc := NewContainerService(
		event.NewEventService(db, nil, nil),
		docker.NewDockerClientService(t.Context(), nil, nil, nil).WithClient(newTestDockerClient(t, server)),
		nil,
		nil,
		nil,
		nil,
		nil,
	)

	out, err := svc.CommitContainer(t.Context(), "container-1", containertypes.CommitRequest{
		Repository: "registry.example.com/team/app",
		Tag:        "snapshot",
		Comment:    "manual snapshot",
		Author:     "arcane",
	}, user.SystemUser)
	require.NoError(t, err)
	require.NotNil(t, out)
	require.Equal(t, "sha256:new-image", out.ID)
	require.Equal(t, map[string]any{
		"container": "container-1",
		"repo":      "registry.example.com/team/app",
		"tag":       "snapshot",
		"comment":   "manual snapshot",
		"author":    "arcane",
	}, gotRequest)

	var evt event.Event
	require.NoError(t, db.WithContext(t.Context()).Where("type = ?", event.EventTypeImageCommit).First(&evt).Error)
	require.Equal(t, "container-1", *evt.ResourceID)
}

func TestContainerServiceCommitContainerOmitsReferenceWhenRepositoryEmpty(t *testing.T) {
	db := setupProjectTestDB(t)
	var gotRequest map[string]any
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		if r.Method != http.MethodPost || dockerTestPath(r.URL.Path) != "/commit" {
			http.NotFound(w, r)
			return
		}
		gotRequest = map[string]any{
			"container": r.URL.Query().Get("container"),
			"repo":      r.URL.Query().Get("repo"),
			"tag":       r.URL.Query().Get("tag"),
		}
		_ = json.NewEncoder(w).Encode(map[string]string{"ID": "sha256:new-image"})
	}))
	t.Cleanup(server.Close)

	svc := NewContainerService(
		event.NewEventService(db, nil, nil),
		docker.NewDockerClientService(t.Context(), nil, nil, nil).WithClient(newTestDockerClient(t, server)),
		nil,
		nil,
		nil,
		nil,
		nil,
	)

	out, err := svc.CommitContainer(t.Context(), "container-1", containertypes.CommitRequest{
		Tag: "latest",
	}, user.SystemUser)
	require.NoError(t, err)
	require.NotNil(t, out)
	require.Equal(t, "sha256:new-image", out.ID)
	require.Equal(t, map[string]any{
		"container": "container-1",
		"repo":      "",
		"tag":       "",
	}, gotRequest)
}

func newGroupedContainerSummary(name, localProject string) containertypes.Summary {
	labels := map[string]string{}
	labels["com.docker.compose.project"] = cmp.Or(localProject, labels["com.docker.compose.project"])

	return containertypes.Summary{
		ID:     name,
		Names:  []string{name},
		Labels: labels,
		State:  "running",
	}
}

// dockerTestPath strips the /v1.NN version prefix Docker clients prepend, so
// fake Docker servers can match on the bare path.
func dockerTestPath(path string) string {
	return dockerAPIVersionPrefix.ReplaceAllString(path, "")
}

// newTestDockerClient builds a Docker client pointed at a fake Docker HTTP server.
func newTestDockerClient(t *testing.T, server *httptest.Server) *client.Client {
	t.Helper()

	httpClient := server.Client()
	cli, err := client.New(
		client.WithHost(server.URL),
		client.WithAPIVersion("1.41"),
		client.WithHTTPClient(httpClient),
	)
	require.NoError(t, err)

	t.Cleanup(func() {
		_ = cli.Close()
	})

	return cli
}

// setupProjectTestDB builds an in-memory DB migrated for project-related tests.
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.Project{}, &settings.SettingVariable{}, &imageupdate.ImageUpdateRecord{}, &event.Event{}, &kv.KVEntry{}))
	return &database.DB{DB: db}
}

var dockerAPIVersionPrefix = regexp.MustCompile(`^/v\d+\.\d+`)

func TestApplyEditPreservesUnmanagedSettings(t *testing.T) {
	cfg := container.Config{
		Image:        "nginx:1.25",
		Env:          []string{"OLD=1"},
		StopSignal:   "SIGQUIT",
		ExposedPorts: network.PortSet{network.MustParsePort("80/tcp"): {}, network.MustParsePort("9000/tcp"): {}},
	}
	hc := container.HostConfig{
		Binds:        []string{"/data:/data"},
		PortBindings: network.PortMap{network.MustParsePort("80/tcp"): {{HostPort: "8080"}}},
		Sysctls:      map[string]string{"net.core.somaxconn": "1024"},
		LogConfig:    container.LogConfig{Type: "json-file", Config: map[string]string{"max-size": "5m"}},

		Ulimits: []*container.Ulimit{{Name: "nofile", Soft: 1024, Hard: 2048}},
	}

	env := []string{"NEW=1"}
	req := containertypes.Edit{Environment: &env}

	cfg, err := applyEditToContainerConfig(cfg, hc.PortBindings, req)
	require.NoError(t, err)
	require.NoError(t, applyEditToHostConfig(&hc, req))

	require.Equal(t, []string{"NEW=1"}, cfg.Env)
	require.Equal(t, "SIGQUIT", cfg.StopSignal)
	require.Equal(t, map[string]string{"net.core.somaxconn": "1024"}, hc.Sysctls)
	require.Equal(t, "json-file", hc.LogConfig.Type)
	require.Len(t, hc.Ulimits, 1)
	require.Equal(t, []string{"/data:/data"}, hc.Binds)
	require.Contains(t, cfg.ExposedPorts, network.MustParsePort("80/tcp"))
}

func TestMergeEditMountsPreservesMountOptions(t *testing.T) {
	existing := []mount.Mount{
		{
			Type:          mount.TypeVolume,
			Source:        "data",
			Target:        "/data",
			VolumeOptions: &mount.VolumeOptions{NoCopy: true, Labels: map[string]string{"keep": "me"}},
		},
		{Type: mount.TypeTmpfs, Target: "/tmp/scratch", TmpfsOptions: &mount.TmpfsOptions{SizeBytes: 1024}},
	}

	// Round-trip the volume mount (toggling read-only) and drop the tmpfs one.
	requested := []containertypes.MountCreate{{Type: "volume", Source: "data", Target: "/data", ReadOnly: true}}

	out := mergeEditMounts(existing, requested)
	require.Len(t, out, 1)
	require.True(t, out[0].ReadOnly)
	require.NotNil(t, out[0].VolumeOptions)
	require.Equal(t, map[string]string{"keep": "me"}, out[0].VolumeOptions.Labels)
}

func TestMergeEditMountsAppliesSourceChange(t *testing.T) {
	existing := []mount.Mount{
		{
			Type:          mount.TypeVolume,
			Source:        "old-volume",
			Target:        "/data",
			VolumeOptions: &mount.VolumeOptions{NoCopy: true, Labels: map[string]string{"keep": "me"}},
		},
		{
			Type:        mount.TypeBind,
			Source:      "/old/path",
			Target:      "/config",
			BindOptions: &mount.BindOptions{Propagation: mount.PropagationRPrivate},
		},
	}

	// Same type and target but a different source must honor the new source
	// while retaining the original driver options.
	requested := []containertypes.MountCreate{
		{Type: "volume", Source: "new-volume", Target: "/data"},
		{Type: "bind", Source: "/new/path", Target: "/config", ReadOnly: true},
	}

	out := mergeEditMounts(existing, requested)
	require.Len(t, out, 2)
	require.Equal(t, "new-volume", out[0].Source)
	require.NotNil(t, out[0].VolumeOptions)
	require.Equal(t, map[string]string{"keep": "me"}, out[0].VolumeOptions.Labels)
	require.Equal(t, "/new/path", out[1].Source)
	require.True(t, out[1].ReadOnly)
	require.NotNil(t, out[1].BindOptions)
	require.Equal(t, mount.PropagationRPrivate, out[1].BindOptions.Propagation)
}

func TestApplyEditRecomputesExposedPorts(t *testing.T) {
	cfg := container.Config{
		ExposedPorts: network.PortSet{
			network.MustParsePort("80/tcp"):   {},
			network.MustParsePort("9000/tcp"): {},
		},
	}
	hc := container.HostConfig{
		PortBindings: network.PortMap{network.MustParsePort("80/tcp"): {{HostPort: "8080"}}},
	}

	newBindings := map[string][]containertypes.PortBindingCreate{"443/tcp": {{HostPort: "8443"}}}
	req := containertypes.Edit{HostConfig: &containertypes.HostConfigEdit{PortBindings: &newBindings}}

	cfg, err := applyEditToContainerConfig(cfg, hc.PortBindings, req)
	require.NoError(t, err)
	require.NoError(t, applyEditToHostConfig(&hc, req))

	// new binding key + previously-exposed-but-unbound port survive; the old bound port is gone
	require.Contains(t, cfg.ExposedPorts, network.MustParsePort("443/tcp"))
	require.Contains(t, cfg.ExposedPorts, network.MustParsePort("9000/tcp"))
	require.NotContains(t, cfg.ExposedPorts, network.MustParsePort("80/tcp"))
	require.Contains(t, hc.PortBindings, network.MustParsePort("443/tcp"))
}

func TestApplyEditHostname(t *testing.T) {
	// nil preserves the existing hostname
	cfg, err := applyEditToContainerConfig(container.Config{Hostname: "old-host"}, nil, containertypes.Edit{})
	require.NoError(t, err)
	require.Equal(t, "old-host", cfg.Hostname)

	cfg, err = applyEditToContainerConfig(cfg, nil, containertypes.Edit{Hostname: new(" new-host ")})
	require.NoError(t, err)
	require.Equal(t, "new-host", cfg.Hostname)

	// empty clears it so Docker assigns its default on recreate
	cfg, err = applyEditToContainerConfig(cfg, nil, containertypes.Edit{Hostname: new("")})
	require.NoError(t, err)
	require.Empty(t, cfg.Hostname)
}

func TestBuildEditNetworkingConfig(t *testing.T) {
	containerInspect := container.InspectResponse{
		HostConfig: &container.HostConfig{NetworkMode: "my-net"},
		NetworkSettings: &container.NetworkSettings{
			Networks: map[string]*network.EndpointSettings{
				"my-net": {Aliases: []string{"svc"}, DNSNames: []string{"svc"}},
			},
		},
	}

	// nil request preserves existing attachments
	out, err := buildEditNetworkingConfig(containerInspect, nil, "1.44")
	require.NoError(t, err)
	require.NotNil(t, out)
	require.Contains(t, out.EndpointsConfig, "my-net")

	// explicit desired set: keep my-net with new alias + static IP, add other-net
	req := &containertypes.NetworkingConfigCreate{
		EndpointsConfig: map[string]containertypes.EndpointSettingsCreate{
			"my-net":    {Aliases: []string{"renamed"}, IPv4Address: "10.5.0.9"},
			"other-net": {},
		},
	}
	out, err = buildEditNetworkingConfig(containerInspect, req, "1.44")
	require.NoError(t, err)
	require.Len(t, out.EndpointsConfig, 2)
	require.Equal(t, []string{"renamed"}, out.EndpointsConfig["my-net"].Aliases)
	require.Equal(t, netip.MustParseAddr("10.5.0.9"), out.EndpointsConfig["my-net"].IPAMConfig.IPv4Address)
	require.Equal(t, []string{"svc"}, out.EndpointsConfig["my-net"].DNSNames)

	// host network mode: endpoint edits are skipped entirely
	hostModeInspect := container.InspectResponse{HostConfig: &container.HostConfig{NetworkMode: "host"}}
	out, err = buildEditNetworkingConfig(hostModeInspect, req, "1.44")
	require.NoError(t, err)
	require.Nil(t, out)
}

func TestRetainedVolumeMountPoints(t *testing.T) {
	original := container.HostConfig{
		Binds: []string{"/cache", "removed:/removed", "kept:/kept"},
		Mounts: []mount.Mount{
			{Type: mount.TypeVolume, Target: "/anon-mount"},
		},
	}
	updated := container.HostConfig{
		Binds: []string{"/cache", "kept:/kept", "renamed:/image-volume"},
		Mounts: []mount.Mount{
			{Type: mount.TypeVolume, Target: "/anon-mount"},
		},
	}
	mountPoints := []container.MountPoint{
		{Type: mount.TypeVolume, Name: "anon-cache", Destination: "/cache"},
		{Type: mount.TypeVolume, Name: "removed", Destination: "/removed"},
		{Type: mount.TypeVolume, Name: "kept", Destination: "/kept"},
		{Type: mount.TypeVolume, Name: "anon-mount", Destination: "/anon-mount"},
		{Type: mount.TypeVolume, Name: "image-data", Destination: "/data"},
		{Type: mount.TypeVolume, Name: "image-other", Destination: "/image-volume"},
	}

	retained := retainedVolumeMountPoints(original, updated, mountPoints)

	require.Len(t, retained, 3)
	require.Equal(t, []string{"anon-cache", "anon-mount", "image-data"}, []string{retained[0].Name, retained[1].Name, retained[2].Name})
}

func TestContainerServiceResizeExec(t *testing.T) {
	db := setupProjectTestDB(t)
	var gotPath, gotHeight, gotWidth string
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		gotPath = r.Method + " " + dockerTestPath(r.URL.Path)
		gotHeight = r.URL.Query().Get("h")
		gotWidth = r.URL.Query().Get("w")
		w.WriteHeader(http.StatusOK)
	}))
	t.Cleanup(server.Close)

	svc := NewContainerService(
		event.NewEventService(db, nil, nil),
		docker.NewDockerClientService(t.Context(), nil, nil, nil).WithClient(newTestDockerClient(t, server)),
		nil,
		nil,
		nil,
		nil,
		nil,
	)

	require.NoError(t, svc.ResizeExec(t.Context(), "exec-1", 120, 40))
	require.Equal(t, "POST /exec/exec-1/resize", gotPath)
	require.Equal(t, "40", gotHeight)
	require.Equal(t, "120", gotWidth)
}

func TestRecreateContainerDaemonCorrelation(t *testing.T) {
	db := setupProjectTestDB(t)
	events := event.NewEventService(db, nil, nil)
	observed := make(chan string, 8)
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		path := dockerTestPath(r.URL.Path)
		if path == "/version" || path == "/info" {
			w.Header().Set("Content-Type", "application/json")
			_, _ = w.Write([]byte("{}"))
			return
		}
		id, name := "old-id", "web"
		if path == "/containers/create" {
			id = ""
		}
		if path == "/containers/new-id/start" {
			id = "new-id"
		}
		if !events.ShouldSuppressDaemonEvent("container", id, name, "") {
			t.Errorf("missing correlation before Docker mutation %s", path)
		}
		if events.ShouldSuppressDaemonEvent("container", "unrelated", "other", "") {
			t.Errorf("unrelated container suppressed during %s", path)
		}
		observed <- path
		if path == "/containers/create" {
			w.Header().Set("Content-Type", "application/json")
			w.WriteHeader(http.StatusCreated)
			if err := json.NewEncoder(w).Encode(map[string]any{"Id": "new-id", "Warnings": []string{}}); err != nil {
				t.Errorf("encode container creation response: %v", err)
			}
			return
		}
		w.WriteHeader(http.StatusNoContent)
	}))
	t.Cleanup(server.Close)
	kvService := kv.NewKVService(db)
	svc := NewContainerService(events, docker.NewDockerClientService(t.Context(), nil, nil, nil).WithClient(newTestDockerClient(t, server)), nil, nil, nil, kvService, nil)
	info := container.InspectResponse{
		ID:         "old-id",
		Name:       "/web",
		State:      &container.State{Running: true},
		Config:     &container.Config{Image: "app:latest"},
		HostConfig: &container.HostConfig{},
	}
	id, err := svc.recreateContainer(
		t.Context(),
		info,
		"redeploy",
		"web",
		info.Config,
		info.HostConfig,
		nil,
		"1.41",
		event.EventTypeContainerDeploy,
		user.SystemUser,
	)
	require.NoError(t, err)
	require.Equal(t, "new-id", id)
	require.Len(t, observed, 5)
	require.Equal(
		t,
		[]string{
			"/containers/old-id/rename",
			"/containers/old-id/stop",
			"/containers/create",
			"/containers/new-id/start",
			"/containers/old-id",
		},
		[]string{
			<-observed,
			<-observed,
			<-observed,
			<-observed,
			<-observed,
		},
	)
	require.True(t, events.ShouldSuppressDaemonEvent("container", "old-id", "", ""))
	require.True(t, events.ShouldSuppressDaemonEvent("container", "new-id", "", ""))
	journals, err := kvService.ListByPrefix(t.Context(), redeployJournalKeyPrefix)
	require.NoError(t, err)
	require.Empty(t, journals)
}

func TestRecreateContainerRollsBackAfterRequestCancellation(t *testing.T) {
	db := setupProjectTestDB(t)
	ctx, cancel := context.WithCancel(t.Context())
	defer cancel()
	var mu sync.Mutex
	var observed []string
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		path := dockerTestPath(r.URL.Path)
		if path == "/version" || path == "/info" {
			w.Header().Set("Content-Type", "application/json")
			_, _ = w.Write([]byte("{}"))
			return
		}
		mu.Lock()
		observed = append(observed, r.Method+" "+path)
		mu.Unlock()
		switch path {
		case "/containers/create":
			w.Header().Set("Content-Type", "application/json")
			w.WriteHeader(http.StatusCreated)
			if err := json.NewEncoder(w).Encode(map[string]any{"Id": "new-id", "Warnings": []string{}}); err != nil {
				t.Errorf("encode container creation response: %v", err)
			}
		case "/containers/new-id/start":
			cancel()
			w.WriteHeader(http.StatusInternalServerError)
		default:
			w.WriteHeader(http.StatusNoContent)
		}
	}))
	t.Cleanup(server.Close)
	kvService := kv.NewKVService(db)
	svc := NewContainerService(event.NewEventService(db, nil, nil), docker.NewDockerClientService(t.Context(), nil, nil, nil).WithClient(newTestDockerClient(t, server)), nil, nil, nil, kvService, nil)
	info := container.InspectResponse{
		ID:         "old-id",
		Name:       "/web",
		State:      &container.State{Running: true},
		Config:     &container.Config{Image: "app:latest"},
		HostConfig: &container.HostConfig{},
	}

	_, err := svc.recreateContainer(ctx, info, "redeploy", "web", info.Config, info.HostConfig, nil, "1.41", event.EventTypeContainerDeploy, user.SystemUser)
	require.Error(t, err)
	require.ErrorIs(t, ctx.Err(), context.Canceled)

	mu.Lock()
	defer mu.Unlock()
	require.Equal(
		t,
		[]string{
			"POST /containers/old-id/rename",
			"POST /containers/old-id/stop",
			"POST /containers/create",
			"POST /containers/new-id/start",
			"DELETE /containers/new-id",
			"POST /containers/old-id/start",
			"POST /containers/old-id/rename",
		},
		observed,
	)
	journals, err := kvService.ListByPrefix(t.Context(), redeployJournalKeyPrefix)
	require.NoError(t, err)
	require.Empty(t, journals)
}

func TestRecoverInterruptedRedeploys(t *testing.T) {
	backupName := "web" + redeployBackupInfix + "1700000000"
	backup := container.Summary{
		ID:    "backup-id",
		Names: []string{"/" + backupName},
		State: container.StateExited,
	}
	journal := RedeployJournal{
		OriginalID:   "backup-id",
		OriginalName: "web",
		BackupName:   backupName,
		NewName:      "web",
	}
	tests := []struct {
		name         string
		journals     []RedeployJournal
		containers   []container.Summary
		want         []string
		wantJournals int
	}{
		{
			name:     "replacement running removes backup",
			journals: []RedeployJournal{journal},
			containers: []container.Summary{
				backup,
				{ID: "new-id", Names: []string{"/web"}, State: container.StateRunning},
			},
			want: []string{"DELETE /containers/backup-id?force=1"},
		},
		{
			name:       "missing replacement restores original name",
			journals:   []RedeployJournal{journal},
			containers: []container.Summary{backup},
			want:       []string{"POST /containers/backup-id/rename?name=web"},
		},
		{
			name:     "stopped replacement leaves both",
			journals: []RedeployJournal{journal},
			containers: []container.Summary{
				backup,
				{ID: "new-id", Names: []string{"/web"}, State: container.StateExited},
			},
			wantJournals: 1,
		},
		{
			name:     "backup with a different ID is skipped",
			journals: []RedeployJournal{journal},
			containers: []container.Summary{
				{ID: "other-id", Names: []string{"/" + backupName}, State: container.StateExited},
			},
		},
		{
			name:       "name-matching container without a journal is left alone",
			containers: []container.Summary{backup},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			kvService := kv.NewKVService(setupProjectTestDB(t))
			for _, j := range tt.journals {
				payload, err := json.Marshal(j)
				require.NoError(t, err)
				require.NoError(t, kvService.Set(t.Context(), redeployJournalKeyPrefix+j.OriginalID, string(payload)))
			}
			var mu sync.Mutex
			var mutations []string
			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				path := dockerTestPath(r.URL.Path)
				if path == "/containers/json" {
					w.Header().Set("Content-Type", "application/json")
					if err := json.NewEncoder(w).Encode(tt.containers); err != nil {
						t.Errorf("encode container list: %v", err)
					}
					return
				}
				mu.Lock()
				mutations = append(mutations, r.Method+" "+path+kit.Ternary(r.URL.RawQuery != "", "?"+r.URL.RawQuery, ""))
				mu.Unlock()
				w.WriteHeader(http.StatusNoContent)
			}))
			t.Cleanup(server.Close)
			svc := NewContainerService(nil, docker.NewDockerClientService(t.Context(), nil, nil, nil).WithClient(newTestDockerClient(t, server)), nil, nil, nil, kvService, nil)

			require.NoError(t, svc.RecoverInterruptedRedeploys(t.Context()))

			mu.Lock()
			defer mu.Unlock()
			require.Equal(t, tt.want, mutations)
			journals, err := kvService.ListByPrefix(t.Context(), redeployJournalKeyPrefix)
			require.NoError(t, err)
			require.Len(t, journals, tt.wantJournals)
		})
	}
}

func TestBuildSummariesUsesContainerTagPolicyUpdates(t *testing.T) {
	settingsService, err := settings.NewSettingsService(t.Context(), setupProjectTestDB(t), &config.Config{})
	require.NoError(t, err)
	service := NewContainerService(nil, nil, nil, settingsService, nil, nil, nil)
	strategyLabel := "com.getarcaneapp.arcane.updater.strategy"
	containers := []container.Summary{
		{ID: "first", Image: "app:3.1.0", ImageID: "shared-image"},
		{ID: "second", Image: "app:3.1.0", ImageID: "shared-image", Labels: map[string]string{strategyLabel: "auto"}},
		{ID: "unchecked", Image: "app:3.1.0", ImageID: "shared-image", Labels: map[string]string{strategyLabel: "tag"}},
		{ID: "digest", Image: "app:3.1.0", ImageID: "shared-image", Labels: map[string]string{strategyLabel: "digest"}},
		{ID: "opted-out", Names: []string{"/opted-out"}, Image: "app:3.1.0", ImageID: "shared-image", Labels: map[string]string{"com.getarcaneapp.arcane.updater": "false"}},
		{ID: "unmonitored", Image: "app:3.1.0", ImageID: "shared-image", Labels: map[string]string{"com.getarcaneapp.arcane.update-check": "false"}},
	}
	// The lookup keys results by container ID; containers opted out of checks have no entry.
	updates := map[string]*image.UpdateInfo{
		"first":     {HasUpdate: true, UpdateType: "digest"},
		"second":    {HasUpdate: true, UpdateType: "tag", LatestVersion: "4.0.0"},
		"digest":    {HasUpdate: true, UpdateType: "digest"},
		"opted-out": {HasUpdate: true, UpdateType: "digest"},
	}
	items := service.BuildSummaries(t.Context(), containers, updates, "", nil)
	require.Equal(t, "digest", items[0].UpdateStrategy, "an unlabeled container follows the digest")
	require.Equal(t, "tag", items[1].UpdateStrategy)
	require.Equal(t, "digest", items[3].UpdateStrategy)
	require.Equal(t, "digest", items[0].UpdateInfo.UpdateType)
	require.Equal(t, "4.0.0", items[1].UpdateInfo.LatestVersion)
	require.Nil(t, items[2].UpdateInfo)
	require.Equal(t, "digest", items[3].UpdateInfo.UpdateType)

	require.True(t, items[0].AutoUpdateEnabled, "containers without opt-out are eligible")
	require.False(t, items[4].AutoUpdateEnabled, "the updater label disables auto-update")
	require.Equal(t, "digest", items[4].UpdateInfo.UpdateType, "disabling automatic updates keeps check results visible")
	require.Nil(t, items[5].UpdateInfo, "a container without a lookup result reports no status")
	require.True(t, items[5].AutoUpdateEnabled, "the update-check label does not affect installation eligibility")
	encoded, err := json.Marshal(items[4])
	require.NoError(t, err)
	require.Contains(t, string(encoded), `"autoUpdateEnabled":false`, "false status must stay serialized")
}

func TestContainerServiceGetContainerProcesses(t *testing.T) {
	tests := []struct {
		name     string
		status   int
		body     string
		fallback *struct {
			status int
			body   string
		}
		wantTitles []string
		wantRows   [][]string
		wantErr    func(error) bool
	}{
		{
			name:   "docker snapshot",
			status: http.StatusOK,
			body: "{\"Titles\":[\"PID\",\"USER\",\"%CPU\",\"%MEM\",\"ELAPSED\",\"CMD\"],\"Processes\":[[\"1\",\"root\",\"0.0\",\"0.1\",\"01:02:0" +
				"3\",\"nginx: master process nginx -g daemon off;\"],[\"29\",\"nginx\",\"0.0\",\"0.1\",\"01:02:03\",\"nginx: worker" +
				" process\"]]}",
			wantTitles: []string{"PID", "USER", "%CPU", "%MEM", "ELAPSED", "CMD"},
			wantRows: [][]string{
				{
					"1",
					"root",
					"0.0",
					"0.1",
					"01:02:03",
					"nginx: master process nginx -g daemon off;",
				},
				{
					"29",
					"nginx",
					"0.0",
					"0.1",
					"01:02:03",
					"nginx: worker process",
				},
			},
		},
		{name: "empty", status: http.StatusOK, body: `{}`, wantTitles: []string{}, wantRows: [][]string{}},
		{name: "not found", status: http.StatusNotFound, body: `{"message":"No such container: container-1"}`, wantErr: errdefs.IsNotFound},
		{name: "not running", status: http.StatusConflict, body: `{"message":"container container-1 is not running"}`, wantErr: errdefs.IsConflict},
		{
			name:   "busybox ps falls back",
			status: http.StatusInternalServerError,
			body:   `{"message":"ps: bad -o argument '%cpu', supported arguments: user,group,comm,args,pid,ppid,pgid,etime,nice,rgroup,ruser,time,tty,vsz,stat,rss"}`,
			fallback: &struct {
				status int
				body   string
			}{http.StatusOK, `{"Titles":["PID","USER","ELAPSED","COMMAND"],"Processes":[["1","root","01:02:03","nginx: master process nginx -g daemon off;"]]}`},
			wantTitles: []string{"PID", "USER", "ELAPSED", "COMMAND"},
			wantRows:   [][]string{{"1", "root", "01:02:03", "nginx: master process nginx -g daemon off;"}},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			var gotArgs []string
			server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
				if r.Method != http.MethodGet || dockerTestPath(r.URL.Path) != "/containers/container-1/top" {
					http.NotFound(w, r)
					return
				}
				gotArgs = append(gotArgs, r.URL.Query().Get("ps_args"))
				status, body := tt.status, tt.body
				if tt.fallback != nil && len(gotArgs) > 1 {
					status, body = tt.fallback.status, tt.fallback.body
				}
				w.Header().Set("Content-Type", "application/json")
				w.WriteHeader(status)
				if _, err := io.WriteString(w, body); err != nil {
					t.Error(err)
				}
			}))
			t.Cleanup(server.Close)
			settingsService, err := settings.NewSettingsService(t.Context(), setupProjectTestDB(t), &config.Config{})
			require.NoError(t, err)
			svc := NewContainerService(nil, docker.NewDockerClientService(t.Context(), nil, nil, nil).WithClient(newTestDockerClient(t, server)), nil, settingsService, nil, nil, nil)

			processes, err := svc.GetContainerProcesses(t.Context(), "container-1")
			wantArgs := []string{strings.Join(containerProcessesPsArgs[0], " ")}
			if tt.fallback != nil {
				wantArgs = append(wantArgs, strings.Join(containerProcessesPsArgs[1], " "))
			}
			require.Equal(t, wantArgs, gotArgs)
			if tt.wantErr != nil {
				require.True(t, tt.wantErr(err), "unexpected error: %v", err)
				return
			}
			require.NoError(t, err)
			require.Equal(t, tt.wantTitles, processes.Titles)
			require.Equal(t, tt.wantRows, processes.Processes)
		})
	}
}

func TestContainerServiceGetContainerProcessesPropagatesContext(t *testing.T) {
	requestDone := make(chan struct{})
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		<-r.Context().Done()
		close(requestDone)
	}))
	t.Cleanup(server.Close)
	settingsService, err := settings.NewSettingsService(t.Context(), setupProjectTestDB(t), &config.Config{})
	require.NoError(t, err)
	svc := NewContainerService(nil, docker.NewDockerClientService(t.Context(), nil, nil, nil).WithClient(newTestDockerClient(t, server)), nil, settingsService, nil, nil, nil)

	ctx, cancel := context.WithTimeout(t.Context(), 50*time.Millisecond)
	defer cancel()
	_, err = svc.GetContainerProcesses(ctx, "container-1")
	require.ErrorIs(t, err, context.DeadlineExceeded)
	select {
	case <-requestDone:
	case <-time.After(5 * time.Second):
		t.Fatal("Docker request was not cancelled")
	}
}

func newResourceStatsServer() *resourceStatsServer {
	return &resourceStatsServer{
		stats:       map[string]container.StatsResponse{},
		statsStatus: map[string]int{},
		statsCalls:  map[string]int{},
		slowIDs:     map[string]bool{},
	}
}

func (f *resourceStatsServer) addContainer(id, name, state string, labels ...map[string]string) {
	f.mu.Lock()
	defer f.mu.Unlock()
	var l map[string]string
	if len(labels) > 0 {
		l = labels[0]
	}
	f.containers = append(f.containers, container.Summary{ID: id, Names: []string{"/" + name}, State: container.ContainerState(state), Image: "img:latest", Labels: l})
}

func (f *resourceStatsServer) setStats(id string, cpuPercent float64, memoryUsage, memoryLimit uint64) {
	f.mu.Lock()
	defer f.mu.Unlock()
	// cpuPercent maps to cpuDelta/systemDelta*100 with a fixed systemDelta of 1000.
	f.stats[id] = container.StatsResponse{
		CPUStats: container.CPUStats{
			CPUUsage:    container.CPUUsage{TotalUsage: uint64(1000 + cpuPercent*10)},
			SystemUsage: 2000,
		},
		PreCPUStats: container.CPUStats{
			CPUUsage:    container.CPUUsage{TotalUsage: 1000},
			SystemUsage: 1000,
		},
		MemoryStats: container.MemoryStats{
			Usage: memoryUsage,
			Limit: memoryLimit,
		},
		Read: time.Now(),
	}
}

func (f *resourceStatsServer) callsFor(id string) int {
	f.mu.Lock()
	defer f.mu.Unlock()
	return f.statsCalls[id]
}

func (f *resourceStatsServer) handler() http.Handler {
	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		path := dockerTestPath(r.URL.Path)
		switch {
		case path == "/containers/json":
			f.mu.Lock()
			list := append([]container.Summary{}, f.containers...)
			f.mu.Unlock()
			_ = json.NewEncoder(w).Encode(list)
		case strings.HasPrefix(path, "/containers/") && strings.HasSuffix(path, "/json"):
			id := strings.TrimSuffix(strings.TrimPrefix(path, "/containers/"), "/json")
			f.mu.Lock()
			defer f.mu.Unlock()
			for _, summary := range f.containers {
				if summary.ID == id {
					inspect := container.InspectResponse{
						ID:    summary.ID,
						Name:  summary.Names[0],
						Image: summary.ImageID,
						Config: &container.Config{
							Image:  summary.Image,
							Labels: summary.Labels,
						},
						State: &container.State{Status: summary.State},
					}
					if err := json.NewEncoder(w).Encode(inspect); err != nil {
						http.Error(w, err.Error(), http.StatusInternalServerError)
					}
					return
				}
			}
			w.WriteHeader(http.StatusNotFound)
		case strings.HasPrefix(path, "/containers/") && strings.HasSuffix(path, "/stats"):
			id := strings.TrimSuffix(strings.TrimPrefix(path, "/containers/"), "/stats")
			cur := f.current.Add(1)
			for {
				seen := f.maxSeen.Load()
				if cur <= seen || f.maxSeen.CompareAndSwap(seen, cur) {
					break
				}
			}
			defer f.current.Add(-1)

			f.mu.Lock()
			f.statsCalls[id]++
			statsData, hasStats := f.stats[id]
			status, hasStatus := f.statsStatus[id]
			delay := f.delay
			slow := f.slowIDs[id]
			f.mu.Unlock()

			wait := kit.Ternary(slow, time.Second, delay)
			if wait > 0 {
				select {
				case <-time.After(wait):
				case <-r.Context().Done():
					return
				}
			}
			if hasStatus {
				w.WriteHeader(status)
				return
			}
			if !hasStats {
				w.WriteHeader(http.StatusNotFound)
				return
			}
			_ = json.NewEncoder(w).Encode(statsData)
		default:
			http.NotFound(w, r)
		}
	})
}

func newResourceSortService(t *testing.T, fixture *resourceStatsServer) *ContainerService {
	t.Helper()
	server := httptest.NewServer(fixture.handler())
	t.Cleanup(server.Close)

	db := setupProjectTestDB(t)
	settingsService, err := settings.NewSettingsService(t.Context(), db, &config.Config{})
	require.NoError(t, err)
	dockerService := docker.NewDockerClientService(t.Context(), nil, nil, nil).WithClient(newTestDockerClient(t, server))
	return NewContainerService(
		nil,
		dockerService,
		imagedomain.NewImageService(db, dockerService, nil, nil, nil, nil, settingsService, nil),
		settingsService,
		nil,
		nil,
		nil,
	)
}

func resourceSortParams(sort, order string, start, limit int) pagination.QueryParams {
	return pagination.QueryParams{
		Sort:    sort,
		Order:   pagination.SortOrder(order),
		Start:   start,
		Limit:   limit,
		Filters: map[string]string{},
	}
}

func summaryIDs(items []containertypes.Summary) []string {
	ids := make([]string, 0, len(items))
	for _, item := range items {
		ids = append(ids, item.ID)
	}
	return ids
}

func listResourceSorted(t *testing.T, svc *ContainerService, params pagination.QueryParams) ContainerListResult {
	t.Helper()
	result, err := svc.ListContainersPaginated(t.Context(), params, true, true, true, "")
	require.NoError(t, err)
	return result
}

func TestResourceSortRanksMemoryByBytesNotPercent(t *testing.T) {
	fixture := newResourceStatsServer()
	// high-percent: 800 of 1000 bytes (80%); high-bytes: 900 of 10000 (9%).
	fixture.addContainer("high-percent", "high-percent", "running")
	fixture.setStats("high-percent", 10, 800, 1000)
	fixture.addContainer("high-bytes", "high-bytes", "running")
	fixture.setStats("high-bytes", 10, 900, 10000)
	fixture.addContainer("opted-out", "opted-out", "running", map[string]string{"com.getarcaneapp.arcane.updater": "false"})
	fixture.setStats("opted-out", 10, 100, 10000)
	svc := newResourceSortService(t, fixture)

	result := listResourceSorted(t, svc, resourceSortParams(containertypes.SortMemoryUsage, "desc", 0, 20))
	require.Equal(t, []string{"high-bytes", "high-percent", "opted-out"}, summaryIDs(result.Items))
	require.True(t, result.Items[0].AutoUpdateEnabled)
	require.False(t, result.Items[2].AutoUpdateEnabled)

	result = listResourceSorted(t, svc, resourceSortParams(containertypes.SortMemoryUsage, "asc", 0, 20))
	require.Equal(t, []string{"opted-out", "high-percent", "high-bytes"}, summaryIDs(result.Items))

	flat, err := svc.ListContainersPaginated(t.Context(), resourceSortParams("name", "asc", 0, 20), true, true, true, "")
	require.NoError(t, err)
	require.Equal(t, []string{"high-bytes", "high-percent", "opted-out"}, summaryIDs(flat.Items))
	require.True(t, flat.Items[0].AutoUpdateEnabled)
	require.False(t, flat.Items[2].AutoUpdateEnabled)

	details, err := svc.GetContainerDetails(t.Context(), "opted-out")
	require.NoError(t, err)
	require.False(t, details.AutoUpdateEnabled, "detail status must match the list status")
	details, err = svc.GetContainerDetails(t.Context(), "high-bytes")
	require.NoError(t, err)
	require.True(t, details.AutoUpdateEnabled)
}

func TestResourceSortOrdersAcrossPages(t *testing.T) {
	fixture := newResourceStatsServer()
	memoryByID := map[string]uint64{"c1": 100, "c2": 200, "c3": 300, "c4": 400, "c5": 500}
	for id, memory := range memoryByID {
		fixture.addContainer(id, id, "running")
		fixture.setStats(id, 0, memory, 10000)
	}
	svc := newResourceSortService(t, fixture)

	tests := []struct {
		name  string
		order string
		start int
		want  []string
	}{
		{name: "desc page 1", order: "desc", start: 0, want: []string{"c5", "c4"}},
		{name: "desc page 2", order: "desc", start: 2, want: []string{"c3", "c2"}},
		{name: "desc page 3", order: "desc", start: 4, want: []string{"c1"}},
		{name: "asc page 1", order: "asc", start: 0, want: []string{"c1", "c2"}},
		{name: "asc page 2", order: "asc", start: 2, want: []string{"c3", "c4"}},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			result := listResourceSorted(t, svc, resourceSortParams(containertypes.SortMemoryUsage, tt.order, tt.start, 2))
			require.Equal(t, tt.want, summaryIDs(result.Items))
			require.Equal(t, int64(5), result.Pagination.TotalItems)
		})
	}
}

func TestResourceSortOrdersByCPUPercent(t *testing.T) {
	fixture := newResourceStatsServer()
	fixture.addContainer("busy", "busy", "running")
	fixture.setStats("busy", 90, 100, 1000)
	fixture.addContainer("idle", "idle", "running")
	fixture.setStats("idle", 5, 100, 1000)
	svc := newResourceSortService(t, fixture)

	result := listResourceSorted(t, svc, resourceSortParams(containertypes.SortCPUUsage, "desc", 0, 20))
	require.Equal(t, []string{"busy", "idle"}, summaryIDs(result.Items))
	require.InDelta(t, 90, result.Items[0].ResourceSample.CPUPercent, 0.2)
	require.InDelta(t, 5, result.Items[1].ResourceSample.CPUPercent, 0.2)
}

func TestResourceSortAppliesSearchAndFiltersBeforeCollectingStats(t *testing.T) {
	fixture := newResourceStatsServer()
	fixture.addContainer("web", "web", "running", map[string]string{"team": "backend"})
	fixture.setStats("web", 10, 100, 1000)
	fixture.addContainer("db", "db", "running")
	fixture.setStats("db", 20, 200, 1000)
	svc := newResourceSortService(t, fixture)

	params := resourceSortParams(containertypes.SortMemoryUsage, "desc", 0, 20)
	params.Search = "web"
	result := listResourceSorted(t, svc, params)
	require.Equal(t, []string{"web"}, summaryIDs(result.Items))
	require.Equal(t, 1, fixture.callsFor("web"))
	require.Equal(t, 0, fixture.callsFor("db"), "filtered-out containers must not trigger stats collection")

	params = resourceSortParams(containertypes.SortMemoryUsage, "desc", 0, 20)
	params.Filters["label"] = "team=backend"
	result = listResourceSorted(t, svc, params)
	require.Equal(t, []string{"web"}, summaryIDs(result.Items))
	require.Equal(t, 0, fixture.callsFor("db"))
}

func TestResourceSortHandlesZeroUnavailableStoppedAndTies(t *testing.T) {
	fixture := newResourceStatsServer()
	fixture.addContainer("zero", "zero", "running")
	fixture.setStats("zero", 0, 0, 1000)
	fixture.addContainer("tie-b", "alpha", "running")
	fixture.setStats("tie-b", 0, 100, 1000)
	fixture.addContainer("tie-a", "alpha", "running")
	fixture.setStats("tie-a", 0, 100, 1000)
	fixture.addContainer("broken", "broken", "running")
	fixture.statsStatus["broken"] = http.StatusInternalServerError
	fixture.addContainer("stopped", "stopped", "exited")
	svc := newResourceSortService(t, fixture)

	asc := listResourceSorted(t, svc, resourceSortParams(containertypes.SortMemoryUsage, "asc", 0, 20))
	require.Equal(t, []string{"zero", "tie-a", "tie-b", "broken", "stopped"}, summaryIDs(asc.Items),
		"zeros first, unavailable and stopped last, ties by name then ID")
	require.NotNil(t, asc.Items[0].ResourceSample, "zero usage is a valid sample, not unavailable")
	require.Nil(t, asc.Items[3].ResourceSample)
	require.Nil(t, asc.Items[4].ResourceSample)

	desc := listResourceSorted(t, svc, resourceSortParams(containertypes.SortMemoryUsage, "desc", 0, 20))
	require.Equal(t, []string{"tie-a", "tie-b", "zero", "broken", "stopped"}, summaryIDs(desc.Items),
		"unavailable stays last in descending order too")

	require.Equal(t, 0, fixture.callsFor("stopped"), "stopped containers must not trigger stats collection")
}

func TestResourceSortCachesSamples(t *testing.T) {
	fixture := newResourceStatsServer()
	fixture.addContainer("web", "web", "running")
	fixture.setStats("web", 10, 100, 1000)
	svc := newResourceSortService(t, fixture)

	for range 2 {
		listResourceSorted(t, svc, resourceSortParams(containertypes.SortMemoryUsage, "desc", 0, 20))
	}
	require.Equal(t, 1, fixture.callsFor("web"), "second list within the TTL must reuse the cached sample")
}

func TestResourceSortCacheExpires(t *testing.T) {
	fixture := newResourceStatsServer()
	fixture.addContainer("web", "web", "running")
	fixture.setStats("web", 10, 100, 1000)
	svc := newResourceSortService(t, fixture)
	svc.stats = stats.New(svc.dockerService.GetClient, svc.dockerService.DockerHost, 50*time.Millisecond, 0, 0)

	listResourceSorted(t, svc, resourceSortParams(containertypes.SortMemoryUsage, "desc", 0, 20))
	time.Sleep(100 * time.Millisecond)
	listResourceSorted(t, svc, resourceSortParams(containertypes.SortMemoryUsage, "desc", 0, 20))
	require.Equal(t, 2, fixture.callsFor("web"), "expired entries must be refetched")
}

func TestResourceSortCoalescesConcurrentFetches(t *testing.T) {
	fixture := newResourceStatsServer()
	fixture.addContainer("web", "web", "running")
	fixture.setStats("web", 10, 100, 1000)
	fixture.delay = 100 * time.Millisecond
	svc := newResourceSortService(t, fixture)

	const callers = 8
	var wg sync.WaitGroup
	errs := make([]error, callers)
	for i := range callers {
		wg.Go(func() {
			_, err := svc.stats.Collect(t.Context(), []containertypes.Summary{{ID: "web", State: "running"}}, stats.ContainerResourceSampleTTL)
			errs[i] = err
		})
	}
	wg.Wait()
	for _, err := range errs {
		require.NoError(t, err)
	}
	require.Equal(t, 1, fixture.callsFor("web"), "concurrent fetches for the same container must coalesce")
}

func TestResourceSortBoundsCollectionConcurrency(t *testing.T) {
	fixture := newResourceStatsServer()
	fixture.delay = 50 * time.Millisecond
	for i := range 32 {
		id := fmt.Sprintf("c%02d", i)
		fixture.addContainer(id, id, "running")
		fixture.setStats(id, 0, uint64(i), 10000)
	}
	svc := newResourceSortService(t, fixture)

	result := listResourceSorted(t, svc, resourceSortParams(containertypes.SortMemoryUsage, "desc", 0, 40))
	require.Len(t, result.Items, 32)
	require.LessOrEqual(t, fixture.maxSeen.Load(), int32(stats.ContainerResourceCollectConcurrency))
}

func TestResourceSortBatchTimeoutFailsRequest(t *testing.T) {
	fixture := newResourceStatsServer()
	fixture.addContainer("slow", "slow", "running")
	fixture.setStats("slow", 10, 100, 1000)
	fixture.delay = time.Second
	svc := newResourceSortService(t, fixture)
	svc.stats = stats.New(svc.dockerService.GetClient, svc.dockerService.DockerHost, stats.ContainerResourceSampleTTL, 0, 50*time.Millisecond)

	_, err := svc.ListContainersPaginated(t.Context(), resourceSortParams(containertypes.SortMemoryUsage, "desc", 0, 20), true, true, true, "")
	require.Error(t, err, "batch timeout must fail the refresh instead of presenting a partial sort")
}

func TestResourceSortPerContainerTimeoutMarksUnavailable(t *testing.T) {
	fixture := newResourceStatsServer()
	fixture.addContainer("fast", "fast", "running")
	fixture.setStats("fast", 10, 100, 1000)
	fixture.addContainer("slow", "slow", "running")
	fixture.setStats("slow", 10, 200, 1000)
	fixture.slowIDs["slow"] = true
	svc := newResourceSortService(t, fixture)
	svc.stats = stats.New(svc.dockerService.GetClient, svc.dockerService.DockerHost, stats.ContainerResourceSampleTTL, 50*time.Millisecond, 0)

	result := listResourceSorted(t, svc, resourceSortParams(containertypes.SortMemoryUsage, "desc", 0, 20))
	require.Equal(t, []string{"fast", "slow"}, summaryIDs(result.Items))
	require.NotNil(t, result.Items[0].ResourceSample)
	require.Nil(t, result.Items[1].ResourceSample, "per-container timeout leaves the sample unavailable")
}

func TestResourceSortCancelledContextFailsRequest(t *testing.T) {
	fixture := newResourceStatsServer()
	fixture.addContainer("web", "web", "running")
	fixture.setStats("web", 10, 100, 1000)
	fixture.delay = time.Second
	svc := newResourceSortService(t, fixture)

	ctx, cancel := context.WithCancel(t.Context())
	go func() {
		time.Sleep(50 * time.Millisecond)
		cancel()
	}()

	_, err := svc.ListContainersPaginated(ctx, resourceSortParams(containertypes.SortMemoryUsage, "desc", 0, 20), true, true, true, "")
	require.Error(t, err)
}

func TestSampleResourcesFiltersRequestedIDs(t *testing.T) {
	capped := make([]string, ResourceSampleLimit+1)
	for i := range capped {
		capped[i] = fmt.Sprintf("c%03d", i)
	}
	tests := []struct {
		name    string
		running []string
		stopped []string
		request []string
		want    []string
	}{
		{
			name:    "stopped, unknown and blank ids are omitted",
			running: []string{"web"},
			stopped: []string{"db"},
			request: []string{"web", "db", "ghost", "", " "},
			want:    []string{"web"},
		},
		{
			name:    "only exact requested ids are sampled",
			running: []string{"web", "web2"},
			request: []string{"web"},
			want:    []string{"web"},
		},
		{
			name:    "ids past the limit are ignored",
			running: capped,
			request: capped,
			want:    capped[:ResourceSampleLimit],
		},
		{
			name:    "no ids samples nothing",
			running: []string{"web"},
		},
	}
	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			fixture := newResourceStatsServer()
			for _, id := range tt.running {
				fixture.addContainer(id, id, "running")
				fixture.setStats(id, 10, 100, 1000)
			}
			for _, id := range tt.stopped {
				fixture.addContainer(id, id, "exited")
				fixture.setStats(id, 10, 100, 1000)
			}
			svc := newResourceSortService(t, fixture)

			samples, err := svc.SampleResources(t.Context(), tt.request, stats.ContainerResourceSampleTTL)
			require.NoError(t, err)
			require.ElementsMatch(t, tt.want, slices.Collect(maps.Keys(samples)))
			for _, id := range tt.stopped {
				require.Zero(t, fixture.callsFor(id), "stopped containers must not trigger stats collection")
			}
		})
	}
}

func newLogsTestService(t *testing.T, tty bool, logsBody []byte, gotQuery *url.Values) *ContainerService {
	t.Helper()
	server := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		switch dockerTestPath(r.URL.Path) {
		case "/containers/container-1/json":
			ttyJSON := kit.Ternary(tty, "true", "false")
			_, _ = io.WriteString(w, `{"Id":"0123456789abcdef0123456789abcdef","Config":{"Tty":`+ttyJSON+`}}`)
		case "/containers/container-1/logs":
			*gotQuery = r.URL.Query()
			_, _ = w.Write(logsBody)
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(server.Close)

	return NewContainerService(
		event.NewEventService(setupProjectTestDB(t), nil, nil),
		docker.NewDockerClientService(t.Context(), nil, nil, nil).WithClient(newTestDockerClient(t, server)),
		nil,
		nil,
		nil,
		nil,
		nil,
	)
}

func TestContainerServiceDownloadLogsDemultiplexesNonTTY(t *testing.T) {
	var frames bytes.Buffer
	longLine := strings.Repeat("x", 70*1024) + "\n"
	for _, frame := range []struct {
		stream  byte
		payload string
	}{
		{1, "out one\n"},
		{2, "err one\n"},
		{1, "\n"},
		{1, longLine},
		{2, "err two\n"},
	} {
		header := make([]byte, 8)
		header[0] = frame.stream
		binary.BigEndian.PutUint32(header[4:], uint32(len(frame.payload)))
		frames.Write(header)
		frames.WriteString(frame.payload)
	}

	var gotQuery url.Values
	svc := newLogsTestService(t, false, frames.Bytes(), &gotQuery)

	reader, filename, err := svc.DownloadLogs(t.Context(), "container-1")
	require.NoError(t, err)
	t.Cleanup(func() { _ = reader.Close() })

	content, err := io.ReadAll(reader)
	require.NoError(t, err)
	require.NoError(t, reader.Close())

	require.Equal(t, "container-0123456789ab-logs.log", filename)
	require.Equal(t, "out one\nerr one\n\n"+longLine+"err two\n", string(content))
	require.Equal(t, "1", gotQuery.Get("stdout"))
	require.Equal(t, "1", gotQuery.Get("stderr"))
	require.Contains(t, []string{"", "all"}, gotQuery.Get("tail"))
	require.Equal(t, "1", gotQuery.Get("timestamps"))
	require.NotEqual(t, "1", gotQuery.Get("follow"))
	require.Empty(t, gotQuery.Get("since"))
}

func TestContainerServiceDownloadLogsPassesTTYOutputThrough(t *testing.T) {
	var gotQuery url.Values
	svc := newLogsTestService(t, true, []byte("raw tty line\r\nno trailing newline"), &gotQuery)

	reader, filename, err := svc.DownloadLogs(t.Context(), "container-1")
	require.NoError(t, err)

	content, err := io.ReadAll(reader)
	require.NoError(t, err)
	require.NoError(t, reader.Close())

	require.Equal(t, "container-0123456789ab-logs.log", filename)
	require.Equal(t, "raw tty line\r\nno trailing newline", string(content))
}

func containerScopeContext(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 TestAggregateContainersMergesEnvironments(t *testing.T) {
	bodies := map[string]any{
		"a": ContainerPaginatedResponse{
			Success:               true,
			Data:                  []containertypes.Summary{newGroupedContainerSummary("alpha", "shop"), newGroupedContainerSummary("charlie", "web")},
			Counts:                containertypes.StatusCounts{RunningContainers: 1, StoppedContainers: 1, TotalContainers: 2},
			Pagination:            base.PaginationResponse{TotalItems: 2, GrandTotalItems: 3},
			ResourceSortSupported: true,
		},
		"b": ContainerPaginatedResponse{
			Success:    true,
			Data:       []containertypes.Summary{newGroupedContainerSummary("bravo", "shop"), newGroupedContainerSummary("delta", "")},
			Counts:     containertypes.StatusCounts{RunningContainers: 2, TotalContainers: 2},
			Pagination: base.PaginationResponse{TotalItems: 2},
		},
	}
	rowLabels := func(items []containertypes.Summary) []string {
		out := make([]string, 0, len(items))
		for _, item := range items {
			out = append(out, item.EnvironmentID+"/"+item.Names[0])
		}
		return out
	}
	svc := &ContainerService{}

	t.Run("sorts by name across environments and pages", func(t *testing.T) {
		ctx, queries := containerScopeContext(t, "/api/environments/a,b,c/containers?start=2&limit=2&sort=name&order=asc&groupBy=project", bodies)
		body, err := svc.AggregateContainers(ctx, pagination.QueryParams{SortParams: pagination.SortParams{Sort: "name", Order: pagination.SortAsc}, Params: pagination.Params{Start: 2, Limit: 2}}, "")
		require.NoError(t, err)

		require.True(t, body.Success)
		require.Equal(t, []string{"a/charlie", "b/delta"}, rowLabels(body.Data))
		require.Equal(t, "Env a", body.Data[0].EnvironmentName)
		require.Empty(t, body.Groups)
		require.Equal(t, int64(4), body.Pagination.TotalItems)
		require.Equal(t, int64(5), body.Pagination.GrandTotalItems)
		require.Equal(t, int64(2), body.Pagination.TotalPages)
		require.Equal(t, 2, body.Pagination.CurrentPage)
		require.Equal(t, containertypes.StatusCounts{RunningContainers: 3, StoppedContainers: 1, TotalContainers: 4}, body.Counts)
		require.False(t, body.ResourceSortSupported)
		require.Equal(t, []base.EnvironmentFailure{{Environment: base.EnvironmentRef{ID: "c", Name: "c"}, Message: "environment offline"}}, body.FailedEnvironments)
		for _, id := range []string{"a", "b", "c"} {
			stored, ok := queries.Load(id)
			require.True(t, ok)
			query := stored.(url.Values)
			require.Equal(t, "0", query.Get("start"))
			require.Equal(t, "-1", query.Get("limit"))
			require.Equal(t, "name", query.Get("sort"))
			require.False(t, query.Has("groupBy"))
		}
	})

	t.Run("sorts by environment", func(t *testing.T) {
		ctx, _ := containerScopeContext(t, "/api/environments/a,b,c/containers?sort=environment&order=asc", bodies)
		body, err := svc.AggregateContainers(ctx, pagination.QueryParams{SortParams: pagination.SortParams{Sort: "environment", Order: pagination.SortAsc}, Params: pagination.Params{Limit: 20}}, "")
		require.NoError(t, err)
		require.Equal(t, []string{"a/alpha", "a/charlie", "b/bravo", "b/delta"}, rowLabels(body.Data))
	})

	t.Run("project groups merge across environments and stay whole", func(t *testing.T) {
		ctx, queries := containerScopeContext(t, "/api/environments/a,b,c/containers?start=0&limit=1&sort=name&order=asc&groupBy=project", bodies)
		body, err := svc.AggregateContainers(ctx, pagination.QueryParams{SortParams: pagination.SortParams{Sort: "name", Order: pagination.SortAsc}, Params: pagination.Params{Limit: 1}}, "project")
		require.NoError(t, err)

		require.Equal(t, []string{"shop"}, groupNamesOf(body.Groups))
		require.Equal(t, []string{"a/alpha", "b/bravo"}, rowLabels(body.Groups[0].Items))
		require.Equal(t, []string{"a/alpha", "b/bravo"}, rowLabels(body.Data))
		require.Equal(t, int64(3), body.Pagination.TotalPages)
		require.Equal(t, int64(4), body.Pagination.TotalItems)
		stored, _ := queries.Load("a")
		require.False(t, stored.(url.Values).Has("groupBy"))
	})

	t.Run("resource sort is supported only when every environment supports it", func(t *testing.T) {
		ctx, _ := containerScopeContext(t, "/api/environments/a,b,c/containers", map[string]any{"a": bodies["a"]})
		body, err := svc.AggregateContainers(ctx, pagination.QueryParams{Params: pagination.Params{Limit: 20}}, "")
		require.NoError(t, err)
		require.True(t, body.ResourceSortSupported)
		require.Len(t, body.FailedEnvironments, 2)
	})

	t.Run("all environments failing returns empty data", func(t *testing.T) {
		ctx, _ := containerScopeContext(t, "/api/environments/a,b,c/containers", map[string]any{})
		body, err := svc.AggregateContainers(ctx, pagination.QueryParams{Params: pagination.Params{Limit: 20}}, "")
		require.NoError(t, err)
		require.True(t, body.Success)
		require.Empty(t, body.Data)
		require.Len(t, body.FailedEnvironments, 3)
	})
}

type quadletTestSystemd struct {
	mu    sync.Mutex
	calls []string
}

func (f *quadletTestSystemd) Availability(context.Context) podmantypes.SystemdAvailability {
	return podmantypes.SystemdAvailability{Available: true}
}

func (f *quadletTestSystemd) Start(_ context.Context, unit string) error {
	return f.record("start " + unit)
}

func (f *quadletTestSystemd) Stop(_ context.Context, unit string) error {
	return f.record("stop " + unit)
}

func (f *quadletTestSystemd) Restart(_ context.Context, unit string) error {
	return f.record("restart " + unit)
}

func (f *quadletTestSystemd) UnitStatus(_ context.Context, unit string) (podmantypes.UnitStatus, error) {
	return podmantypes.UnitStatus{Name: unit, ActiveState: "active"}, nil
}

func (f *quadletTestSystemd) record(call string) error {
	f.mu.Lock()
	defer f.mu.Unlock()
	f.calls = append(f.calls, call)
	return nil
}

func newQuadletTestContainerService(t *testing.T) (*ContainerService, *quadletTestSystemd, func() []string) {
	t.Helper()

	var mu sync.Mutex
	var dockerCalls []string
	dockerServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		path := dockerTestPath(r.URL.Path)
		mu.Lock()
		dockerCalls = append(dockerCalls, r.Method+" "+path)
		mu.Unlock()
		if r.Method == http.MethodGet && path == "/containers/quadlet-id/json" {
			w.Header().Set("Content-Type", "application/json")
			if err := json.NewEncoder(w).Encode(container.InspectResponse{
				ID:         "quadlet-id",
				Name:       "/web",
				State:      &container.State{Running: true},
				Config:     &container.Config{Image: "nginx:latest", Labels: map[string]string{podmantypes.SystemdUnitLabel: "web.service"}},
				HostConfig: &container.HostConfig{},
			}); err != nil {
				t.Errorf("encode inspect response: %v", err)
			}
			return
		}
		w.WriteHeader(http.StatusNoContent)
	}))
	t.Cleanup(dockerServer.Close)

	libpodServer := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json")
		switch r.URL.Path {
		case "/v4.0.0/libpod/version":
			_, _ = w.Write([]byte(`{"Version":"6.1.0","ApiVersion":"6.1.0"}`))
		case "/v4.0.0/libpod/info":
			_, _ = w.Write([]byte(`{"host":{"security":{"rootless":false}}}`))
		case "/v4.0.0/libpod/containers/json":
			_, _ = w.Write([]byte(`[{"Id":"quadlet-id","Names":["web"],"Labels":{"PODMAN_SYSTEMD_UNIT":"web.service"}}]`))
		case "/v4.0.0/libpod/quadlets/json":
			_, _ = w.Write([]byte(`[{"Name":"web.container","UnitName":"web.service"}]`))
		default:
			http.NotFound(w, r)
		}
	}))
	t.Cleanup(libpodServer.Close)

	systemd := &quadletTestSystemd{}
	svc := NewContainerService(
		event.NewEventService(setupProjectTestDB(t), nil, nil),
		docker.NewDockerClientService(t.Context(), nil, nil, nil).WithClient(newTestDockerClient(t, dockerServer)),
		nil,
		nil,
		nil,
		nil,
		podman.NewService(podman.Config{
			Engine: func(context.Context) (compat.EngineCompatibilityInfo, error) {
				return compat.EngineCompatibilityInfo{Name: "podman"}, nil
			},
			Host: libpodServer.URL,
			NewSystemd: func(bool) libpodman.Systemd {
				return systemd
			},
		}),
	)
	return svc, systemd, func() []string {
		mu.Lock()
		defer mu.Unlock()
		return slices.Clone(dockerCalls)
	}
}

func TestContainerLifecycleRoutesQuadletContainersThroughSystemd(t *testing.T) {
	svc, systemd, dockerCalls := newQuadletTestContainerService(t)
	actor := user.Actor{ID: "user-1", Username: "tester"}

	require.NoError(t, svc.StartContainer(t.Context(), "quadlet-id", actor))
	require.NoError(t, svc.StopContainer(t.Context(), "quadlet-id", actor))
	require.NoError(t, svc.RestartContainer(t.Context(), "quadlet-id", actor))
	require.Equal(t, []string{"start web.service", "stop web.service", "restart web.service"}, systemd.calls)
	require.Empty(t, dockerCalls())

	require.NoError(t, svc.StartContainer(t.Context(), "plain-id", actor))
	require.Equal(t, []string{"POST /containers/plain-id/start"}, dockerCalls())
	require.Len(t, systemd.calls, 3)
}

func TestContainerMutationsRefuseQuadletContainers(t *testing.T) {
	svc, systemd, dockerCalls := newQuadletTestContainerService(t)
	actor := user.Actor{ID: "user-1", Username: "tester"}

	_, err := svc.EditContainer(t.Context(), "quadlet-id", containertypes.Edit{}, actor)
	require.ErrorIs(t, err, common.ErrContainerQuadletManaged)
	_, err = svc.RedeployContainer(t.Context(), "quadlet-id", actor)
	require.ErrorIs(t, err, common.ErrContainerQuadletManaged)
	require.ErrorIs(t, svc.DeleteContainer(t.Context(), "quadlet-id", true, true, actor), common.ErrContainerQuadletManaged)

	require.Equal(t, []string{
		"GET /containers/quadlet-id/json",
		"GET /containers/quadlet-id/json",
		"GET /containers/quadlet-id/json",
	}, dockerCalls())
	require.Empty(t, systemd.calls)
}