compose/pkg/compose/executor_test.go
Nicolas De Loof e1131ad655
Some checks are pending
ci / validate (lint) (push) Waiting to run
ci / validate (validate-docs) (push) Waiting to run
ci / validate (validate-go-mod) (push) Waiting to run
ci / validate (validate-headers) (push) Waiting to run
ci / binary (push) Waiting to run
ci / binary-finalize (push) Blocked by required conditions
ci / bin-image-test (push) Waiting to run
ci / test (push) Waiting to run
ci / e2e (plugin, oldstable) (push) Waiting to run
ci / e2e (standalone, oldstable) (push) Waiting to run
ci / e2e (plugin, stable) (push) Waiting to run
ci / e2e (standalone, stable) (push) Waiting to run
ci / coverage (push) Blocked by required conditions
ci / release (push) Blocked by required conditions
merge / bin-image-prepare (push) Waiting to run
merge / bin-image (push) Blocked by required conditions
merge / module-image (push) Waiting to run
Scorecards supply-chain security / Scorecards analysis (push) Waiting to run
zizmor / zizmor (push) Waiting to run
refactor(reconcile): aggregate observed resources, resolve conflicts in reconcile
collectObservedState indexed networks/volumes by compose label into a
single-valued map, so two live resources sharing a label (e.g. a leftover
after a rename) collided and the "winner" depended on the daemon's list
order — a nondeterministic `up` (spurious create/recreate events, possible
churn) on subsequent runs.

Make collection lossless and move the selection into the reconciler:

- ObservedState.Networks/Volumes become map[string][]Observed*: collection
  records every label-sharing resource and makes no premature choice.
- selectNetwork/selectVolume deterministically pick the resource matching
  the desired name (else the lexicographically smallest), returning the
  others as orphans.
- reconcile resolves the observed state once (resolveObserved) into
  single-valued resolvedNetworks/resolvedVolumes used everywhere, and warns
  about orphans instead of acting on them — they are left untouched because
  removing them could drop data or break unrelated workloads.

Adds selection unit tests, a collector aggregation test and a reconcile
conflict test (deterministic no-op + orphan warning across list orders).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>
Signed-off-by: Nicolas De Loof <nicolas.deloof@gmail.com>
2026-07-27 14:56:25 +02:00

452 lines
16 KiB
Go

/*
Copyright 2020 Docker Compose CLI authors
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
package compose
import (
"context"
"errors"
"fmt"
"testing"
"github.com/compose-spec/compose-go/v2/types"
"github.com/moby/moby/api/types/container"
"github.com/moby/moby/client"
"go.uber.org/mock/gomock"
"gotest.tools/v3/assert"
"github.com/docker/compose/v5/pkg/api"
"github.com/docker/compose/v5/pkg/mocks"
)
// noopEventProcessor discards all events.
type noopEventProcessor struct{}
func (noopEventProcessor) Start(_ context.Context, _ string) {}
func (noopEventProcessor) On(_ ...api.Resource) {}
func (noopEventProcessor) Done(_ string, _ bool) {}
func newTestService(t *testing.T) (*composeService, *mocks.MockAPIClient) {
t.Helper()
mockCtrl := gomock.NewController(t)
cli := mocks.NewMockCli(mockCtrl)
apiClient := mocks.NewMockAPIClient(mockCtrl)
cli.EXPECT().Client().Return(apiClient).AnyTimes()
svc, err := NewComposeService(cli, WithEventProcessor(noopEventProcessor{}))
assert.NilError(t, err)
return svc.(*composeService), apiClient
}
func TestExecutePlanEmpty(t *testing.T) {
svc, _ := newTestService(t)
err := svc.executePlan(t.Context(), &types.Project{Name: "test"}, emptyObservedState("test"), &Plan{})
assert.NilError(t, err)
}
func TestExecutePlanCreateNetwork(t *testing.T) {
svc, apiClient := newTestService(t)
nw := types.NetworkConfig{Name: "test_default"}
project := &types.Project{
Name: "test",
Networks: types.Networks{"default": nw},
}
// createNetwork issues a plain NetworkCreate (divergence/reuse decisions are
// made by the reconciler from the observed state, not here).
apiClient.EXPECT().NetworkCreate(gomock.Any(), "test_default", gomock.Any()).
Return(client.NetworkCreateResult{ID: "net1"}, nil)
plan := &Plan{}
plan.addNode(Operation{
Type: OpCreateNetwork,
ResourceID: "network:default",
Cause: "not found",
Name: nw.Name,
Network: &nw,
}, "")
err := svc.executePlan(t.Context(), project, emptyObservedState("test"), plan)
assert.NilError(t, err)
}
func TestExecutePlanStopRemoveContainer(t *testing.T) {
svc, apiClient := newTestService(t)
ctr := container.Summary{
ID: "c1",
Names: []string{"/test-web-1"},
Labels: map[string]string{
api.ServiceLabel: "web",
api.ContainerNumberLabel: "1",
},
}
apiClient.EXPECT().ContainerStop(gomock.Any(), "c1", gomock.Any()).
Return(client.ContainerStopResult{}, nil)
apiClient.EXPECT().ContainerRemove(gomock.Any(), "c1", gomock.Any()).
Return(client.ContainerRemoveResult{}, nil)
plan := &Plan{}
stopNode := plan.addNode(Operation{
Type: OpStopContainer,
ResourceID: "service:web:1",
Cause: "scale down",
Container: &ctr,
}, "")
plan.addNode(Operation{
Type: OpRemoveContainer,
ResourceID: "service:web:1",
Cause: "scale down",
Container: &ctr,
}, "", stopNode)
err := svc.executePlan(t.Context(), &types.Project{Name: "test"}, emptyObservedState("test"), plan)
assert.NilError(t, err)
}
// emptyObservedState returns an ObservedState with no containers/networks/volumes,
// suitable for executor tests that don't exercise service-reference resolution.
func emptyObservedState(project string) *ObservedState {
return &ObservedState{
ProjectName: project,
Containers: map[string][]ObservedContainer{},
Networks: map[string][]ObservedNetwork{},
Volumes: map[string][]ObservedVolume{},
}
}
// TestExecutePlanRemoveContainerDropsFromCache verifies that after a container
// is removed, subsequent service-reference resolution does not see its stale ID.
// Without this guarantee, a recreate followed by a dependent's create can pick
// up the just-removed container, depending on the canonical-name sort order.
//
// Goes through newPlanExecutor + run (i.e. the same code path executePlan
// uses in production) so the test exercises the errgroup, done-channel
// wiring and group tracker — not a hand-rolled loop over executeNode.
func TestExecutePlanRemoveContainerDropsFromCache(t *testing.T) {
svc, apiClient := newTestService(t)
oldCtr := container.Summary{
ID: "old-id",
Names: []string{"/test-web-1"},
Labels: map[string]string{
api.ServiceLabel: "web",
api.ContainerNumberLabel: "1",
},
}
apiClient.EXPECT().ContainerStop(gomock.Any(), "old-id", gomock.Any()).
Return(client.ContainerStopResult{}, nil)
apiClient.EXPECT().ContainerRemove(gomock.Any(), "old-id", gomock.Any()).
Return(client.ContainerRemoveResult{}, nil)
observed := &ObservedState{
ProjectName: "test",
Containers: map[string][]ObservedContainer{
"web": {{ID: "old-id", Summary: oldCtr}},
},
Networks: map[string][]ObservedNetwork{},
Volumes: map[string][]ObservedVolume{},
}
plan := &Plan{}
stopNode := plan.addNode(Operation{
Type: OpStopContainer,
ResourceID: "service:web:1",
Cause: "scale down",
Container: &oldCtr,
}, "")
plan.addNode(Operation{
Type: OpRemoveContainer,
ResourceID: "service:web:1",
Cause: "scale down",
Container: &oldCtr,
}, "", stopNode)
exec := svc.newPlanExecutor(&types.Project{Name: "test"}, observed)
assert.NilError(t, exec.run(t.Context(), plan))
assert.Equal(t, len(exec.containersByService["web"]), 0,
"removed container should be dropped from the live view")
}
// TestExecutePlanConcurrentRemovesCacheCoherence stresses the cache mutex by
// scheduling N independent Stop+Remove pairs that the DAG lets the errgroup
// run concurrently. After the plan completes the cache must be empty, with no
// duplicates and no surviving entries — failure under -race would indicate a
// missing or incorrect lock around containersByService.
func TestExecutePlanConcurrentRemovesCacheCoherence(t *testing.T) {
svc, apiClient := newTestService(t)
const replicas = 5
ctrs := make([]container.Summary, replicas)
for i := range ctrs {
ctrs[i] = container.Summary{
ID: fmt.Sprintf("c%d", i),
Names: []string{fmt.Sprintf("/test-web-%d", i+1)},
Labels: map[string]string{
api.ServiceLabel: "web",
api.ContainerNumberLabel: fmt.Sprintf("%d", i+1),
},
}
}
// Each container gets exactly one Stop and one Remove. gomock matches by
// any order across calls, so concurrent execution is fine.
for i := range ctrs {
apiClient.EXPECT().ContainerStop(gomock.Any(), ctrs[i].ID, gomock.Any()).
Return(client.ContainerStopResult{}, nil)
apiClient.EXPECT().ContainerRemove(gomock.Any(), ctrs[i].ID, gomock.Any()).
Return(client.ContainerRemoveResult{}, nil)
}
webContainers := make([]ObservedContainer, replicas)
for i := range ctrs {
webContainers[i] = ObservedContainer{ID: ctrs[i].ID, Summary: ctrs[i]}
}
observed := &ObservedState{
ProjectName: "test",
Containers: map[string][]ObservedContainer{"web": webContainers},
Networks: map[string][]ObservedNetwork{},
Volumes: map[string][]ObservedVolume{},
}
// Build N independent Stop→Remove chains. The errgroup will fan them out
// across goroutines that all hammer containersByService under the mutex.
plan := &Plan{}
for i := range ctrs {
stop := plan.addNode(Operation{
Type: OpStopContainer,
ResourceID: fmt.Sprintf("service:web:%d", i+1),
Cause: "scale down",
Container: &ctrs[i],
}, "")
plan.addNode(Operation{
Type: OpRemoveContainer,
ResourceID: fmt.Sprintf("service:web:%d", i+1),
Cause: "scale down",
Container: &ctrs[i],
}, "", stop)
}
exec := svc.newPlanExecutor(&types.Project{Name: "test"}, observed)
assert.NilError(t, exec.run(t.Context(), plan))
assert.Equal(t, len(exec.containersByService["web"]), 0,
"all removed containers should be dropped from the live view")
}
// TestExecutePlanRecreateVolume drives the destructive core of a volume
// recreation — stop container → remove container → remove volume → create
// volume — end to end through the executor, asserting each Docker API call
// fires. The dependency edges force the destructive order: the volume can only
// be removed once the container referencing it is gone.
func TestExecutePlanRecreateVolume(t *testing.T) {
svc, apiClient := newTestService(t)
ctr := container.Summary{
ID: "c1",
Names: []string{"/test-db-1"},
Labels: map[string]string{
api.ServiceLabel: "db",
api.ContainerNumberLabel: "1",
},
}
apiClient.EXPECT().ContainerStop(gomock.Any(), "c1", gomock.Any()).
Return(client.ContainerStopResult{}, nil)
apiClient.EXPECT().ContainerRemove(gomock.Any(), "c1", gomock.Any()).
Return(client.ContainerRemoveResult{}, nil)
apiClient.EXPECT().VolumeRemove(gomock.Any(), "recreate_data", gomock.Any()).
Return(client.VolumeRemoveResult{}, nil)
apiClient.EXPECT().VolumeCreate(gomock.Any(), gomock.Any()).
Return(client.VolumeCreateResult{}, nil)
vol := types.VolumeConfig{Name: "recreate_data", Driver: "local"}
project := &types.Project{
Name: "recreate",
Volumes: types.Volumes{"data": vol},
}
plan := &Plan{}
stopNode := plan.addNode(Operation{
Type: OpStopContainer,
ResourceID: "service:db:1",
Cause: "mounted volume config changed",
Container: &ctr,
}, "")
removeNode := plan.addNode(Operation{
Type: OpRemoveContainer,
ResourceID: "service:db:1",
Cause: "mounted volume config changed",
Container: &ctr,
}, "", stopNode)
removeVolNode := plan.addNode(Operation{
Type: OpRemoveVolume,
ResourceID: "volume:data",
Cause: "config hash diverged",
Name: vol.Name,
}, "", removeNode)
plan.addNode(Operation{
Type: OpCreateVolume,
ResourceID: "volume:data",
Cause: "recreate after config change",
Name: vol.Name,
Volume: &vol,
}, "", removeVolNode)
err := svc.executePlan(t.Context(), project, emptyObservedState("recreate"), plan)
assert.NilError(t, err)
}
// TestExecutePlanRecreateNetwork drives a network recreation — stop container →
// disconnect → remove network → create network → connect — end to end through
// the executor, asserting each Docker API call fires. The container keeps its
// identity (it is reconnected, not recreated).
func TestExecutePlanRecreateNetwork(t *testing.T) {
svc, apiClient := newTestService(t)
ctr := container.Summary{
ID: "c1",
Names: []string{"/recreate-web-1"},
Labels: map[string]string{
api.ServiceLabel: "web",
api.ContainerNumberLabel: "1",
},
}
apiClient.EXPECT().ContainerStop(gomock.Any(), "c1", gomock.Any()).
Return(client.ContainerStopResult{}, nil)
apiClient.EXPECT().NetworkDisconnect(gomock.Any(), "recreate_frontend", gomock.Any()).
Return(client.NetworkDisconnectResult{}, nil)
apiClient.EXPECT().NetworkRemove(gomock.Any(), "recreate_frontend", gomock.Any()).
Return(client.NetworkRemoveResult{}, nil)
apiClient.EXPECT().NetworkCreate(gomock.Any(), "recreate_frontend", gomock.Any()).
Return(client.NetworkCreateResult{ID: "net2"}, nil)
apiClient.EXPECT().NetworkConnect(gomock.Any(), "recreate_frontend", gomock.Any()).
Return(client.NetworkConnectResult{}, nil)
nw := types.NetworkConfig{Name: "recreate_frontend", Driver: "overlay"}
project := &types.Project{
Name: "recreate",
Networks: types.Networks{"frontend": nw},
}
plan := &Plan{}
stopNode := plan.addNode(Operation{
Type: OpStopContainer,
ResourceID: "service:web:1",
Cause: "network frontend config changed",
Container: &ctr,
}, "")
disconnectNode := plan.addNode(Operation{
Type: OpDisconnectNetwork,
ResourceID: "service:web:1",
Cause: "network frontend recreate",
Container: &ctr,
Name: nw.Name,
}, "", stopNode)
removeNode := plan.addNode(Operation{
Type: OpRemoveNetwork,
ResourceID: "network:frontend",
Cause: "config hash diverged",
Name: nw.Name,
}, "", disconnectNode)
createNode := plan.addNode(Operation{
Type: OpCreateNetwork,
ResourceID: "network:frontend",
Cause: "recreate after config change",
Name: nw.Name,
Network: &nw,
}, "", removeNode)
plan.addNode(Operation{
Type: OpConnectNetwork,
ResourceID: "service:web:1",
Cause: "network frontend recreate",
Container: &ctr,
Name: nw.Name,
}, "", createNode)
err := svc.executePlan(t.Context(), project, emptyObservedState("recreate"), plan)
assert.NilError(t, err)
}
// TestExecutePlanCreateNetworkConflictIsSuccess verifies that a NetworkCreate
// conflict (a concurrent up/run created the same network) is treated as success
// rather than surfacing as a hard failure.
func TestExecutePlanCreateNetworkConflictIsSuccess(t *testing.T) {
svc, apiClient := newTestService(t)
nw := types.NetworkConfig{Name: "test_default"}
project := &types.Project{Name: "test", Networks: types.Networks{"default": nw}}
apiClient.EXPECT().NetworkCreate(gomock.Any(), "test_default", gomock.Any()).
Return(client.NetworkCreateResult{}, conflictError{})
plan := &Plan{}
plan.addNode(Operation{
Type: OpCreateNetwork,
ResourceID: "network:default",
Cause: "not found",
Name: nw.Name,
Network: &nw,
}, "")
assert.NilError(t, svc.executePlan(t.Context(), project, emptyObservedState("test"), plan))
}
// TestExecRemoveNetworkBestEffort verifies that a best-effort network removal
// (old network on a rename) tolerates a conflict (still in use) but propagates
// any other error, while a mandatory removal propagates conflicts too.
func TestExecRemoveNetworkBestEffort(t *testing.T) {
newExec := func(t *testing.T) (*planExecutor, *mocks.MockAPIClient) {
svc, apiClient := newTestService(t)
return svc.newPlanExecutor(&types.Project{Name: "test"}, emptyObservedState("test")), apiClient
}
t.Run("best-effort ignores conflict", func(t *testing.T) {
exec, apiClient := newExec(t)
apiClient.EXPECT().NetworkRemove(gomock.Any(), "old", gomock.Any()).Return(client.NetworkRemoveResult{}, conflictError{})
err := exec.execRemoveNetwork(t.Context(), Operation{Type: OpRemoveNetwork, Name: "old", BestEffort: true})
assert.NilError(t, err)
})
t.Run("best-effort propagates non-conflict", func(t *testing.T) {
exec, apiClient := newExec(t)
apiClient.EXPECT().NetworkRemove(gomock.Any(), "old", gomock.Any()).Return(client.NetworkRemoveResult{}, errors.New("transport failure"))
err := exec.execRemoveNetwork(t.Context(), Operation{Type: OpRemoveNetwork, Name: "old", BestEffort: true})
assert.ErrorContains(t, err, "transport failure")
})
t.Run("mandatory removal propagates conflict", func(t *testing.T) {
exec, apiClient := newExec(t)
apiClient.EXPECT().NetworkRemove(gomock.Any(), "old", gomock.Any()).Return(client.NetworkRemoveResult{}, conflictError{})
err := exec.execRemoveNetwork(t.Context(), Operation{Type: OpRemoveNetwork, Name: "old", BestEffort: false})
assert.Assert(t, err != nil, "mandatory removal must propagate conflict")
})
}
// notFoundError implements the errdefs.ErrNotFound interface for test mocks.
type notFoundError struct{}
func (notFoundError) Error() string { return "not found" }
func (notFoundError) NotFound() {}
// conflictError implements the errdefs.ErrConflict interface for test mocks.
type conflictError struct{}
func (conflictError) Error() string { return "conflict" }
func (conflictError) Conflict() {}