Add e2e tests for reconciliation behavior

Test coverage for behaviors identified during the reconciliation
engine refactoring:

- TestReconcileReplaceLabel: verify com.docker.compose.replace label
  is set on recreated containers
- TestReconcileNetworkConfigChange: verify network config change
  triggers network recreation and container reconnection
- TestReconcileVolumeConfigChange: verify volume config change with
  -y triggers volume recreation and container recreation
- TestReconcileDependentRestart: verify dependent services with
  restart:true are stopped and restarted when dependency is recreated
- TestReconcileIdempotent: verify running up twice with no changes
  produces no recreations

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>
Signed-off-by: Nicolas De Loof <nicolas.deloof@gmail.com>

Author: ndeloof

pkg/e2e/fixtures/reconciliation-test/compose.yaml

@@ -0,0 +1,31 @@
+services:
+  web:
+    image: nginx:alpine
+    environment:
+      - LABEL=${LABEL:-default}
+    networks:
+      - frontend
+    volumes:
+      - data:/data
+    depends_on:
+      db:
+        condition: service_started
+        restart: true
+
+  db:
+    image: alpine
+    command: sleep infinity
+    networks:
+      - frontend
+    volumes:
+      - data:/data
+
+networks:
+  frontend:
+    labels:
+      - config=${NET_LABEL:-v1}
+
+volumes:
+  data:
+    labels:
+      config: ${VOL_LABEL:-v1}

pkg/e2e/reconciliation_test.go

@@ -0,0 +1,217 @@
+/*
+   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 e2e
+
+import (
+	"fmt"
+	"strings"
+	"testing"
+
+	"gotest.tools/v3/assert"
+	"gotest.tools/v3/icmd"
+)
+
+// TestReconcileReplaceLabel verifies that when a container is recreated (due to
+// config change), the new container gets the com.docker.compose.replace label
+// pointing to the replaced container's service name and number.
+func TestReconcileReplaceLabel(t *testing.T) {
+	c := NewCLI(t)
+	const projectName = "reconcile-replace-label"
+	t.Cleanup(func() {
+		c.cleanupWithDown(t, projectName)
+	})
+
+	// First up: create containers
+	c.RunDockerComposeCmd(t, "-f", "./fixtures/reconciliation-test/compose.yaml",
+		"--project-name", projectName, "up", "-d")
+
+	// Verify no replace label on fresh containers
+	res := c.RunDockerCmd(t, "inspect", fmt.Sprintf("%s-db-1", projectName),
+		"-f", `{{ index .Config.Labels "com.docker.compose.replace" }}`)
+	res.Assert(t, icmd.Expected{Out: ""})
+
+	// Second up with changed env to trigger recreate
+	cli := NewCLI(t, WithEnv("LABEL=changed"))
+	res = cli.RunDockerComposeCmd(t, "-f", "./fixtures/reconciliation-test/compose.yaml",
+		"--project-name", projectName, "up", "-d")
+	assert.Assert(t, strings.Contains(res.Stderr(), "Recreated"), "expected Recreated in output: %s", res.Stderr())
+
+	// Verify replace label is set on the recreated container
+	res = c.RunDockerCmd(t, "inspect", fmt.Sprintf("%s-db-1", projectName),
+		"-f", `{{ index .Config.Labels "com.docker.compose.replace" }}`)
+	assert.Assert(t, strings.Contains(res.Stdout(), "db-1"),
+		"expected replace label to contain 'db-1', got: %s", res.Stdout())
+}
+
+// TestReconcileNetworkConfigChange verifies that when a network's configuration
+// changes (e.g. labels), the network is recreated and containers are reconnected
+// to the new network.
+func TestReconcileNetworkConfigChange(t *testing.T) {
+	c := NewCLI(t)
+	const projectName = "reconcile-net-change"
+	t.Cleanup(func() {
+		c.cleanupWithDown(t, projectName)
+	})
+
+	// First up: create with default network labels
+	c.RunDockerComposeCmd(t, "-f", "./fixtures/reconciliation-test/compose.yaml",
+		"--project-name", projectName, "up", "-d")
+
+	// Check network has v1 label
+	netName := fmt.Sprintf("%s_frontend", projectName)
+	res := c.RunDockerCmd(t, "network", "inspect", netName, "-f", `{{ index .Labels "config" }}`)
+	res.Assert(t, icmd.Expected{Out: "v1"})
+
+	// Get the initial network ID
+	res = c.RunDockerCmd(t, "network", "inspect", netName, "-f", "{{ .Id }}")
+	initialNetID := strings.TrimSpace(res.Stdout())
+
+	// Second up with changed network label -> network should be recreated
+	cli := NewCLI(t, WithEnv("NET_LABEL=v2"))
+	res = cli.RunDockerComposeCmd(t, "-f", "./fixtures/reconciliation-test/compose.yaml",
+		"--project-name", projectName, "up", "-d")
+	assert.Assert(t, strings.Contains(res.Stderr(), "Recreat"), "expected recreate events: %s", res.Stderr())
+
+	// Network should have v2 label
+	res = c.RunDockerCmd(t, "network", "inspect", netName, "-f", `{{ index .Labels "config" }}`)
+	res.Assert(t, icmd.Expected{Out: "v2"})
+
+	// Network ID should have changed (recreated, not just updated)
+	res = c.RunDockerCmd(t, "network", "inspect", netName, "-f", "{{ .Id }}")
+	newNetID := strings.TrimSpace(res.Stdout())
+	assert.Assert(t, newNetID != initialNetID, "expected network ID to change after recreate")
+
+	// Containers should be connected to the new network (running with connectivity)
+	res = c.RunDockerCmd(t, "inspect", fmt.Sprintf("%s-db-1", projectName),
+		"-f", `{{ range .NetworkSettings.Networks }}{{ .NetworkID }}{{ end }}`)
+	assert.Assert(t, strings.Contains(res.Stdout(), newNetID),
+		"expected container connected to new network %s, got: %s", newNetID, res.Stdout())
+}
+
+// TestReconcileVolumeConfigChange verifies that when a volume's configuration
+// changes, the user is prompted, and if confirmed, the volume is recreated and
+// containers are also recreated to use the new volume.
+func TestReconcileVolumeConfigChange(t *testing.T) {
+	c := NewCLI(t)
+	const projectName = "reconcile-vol-change"
+	t.Cleanup(func() {
+		c.cleanupWithDown(t, projectName)
+	})
+
+	// First up: create with default volume labels
+	c.RunDockerComposeCmd(t, "-f", "./fixtures/reconciliation-test/compose.yaml",
+		"--project-name", projectName, "up", "-d")
+
+	// Check volume has v1 label
+	volName := fmt.Sprintf("%s_data", projectName)
+	res := c.RunDockerCmd(t, "volume", "inspect", volName, "-f", `{{ index .Labels "config" }}`)
+	res.Assert(t, icmd.Expected{Out: "v1"})
+
+	// Second up with changed volume label + -y to auto-confirm
+	cli := NewCLI(t, WithEnv("VOL_LABEL=v2"))
+	res = cli.RunDockerComposeCmd(t, "-f", "./fixtures/reconciliation-test/compose.yaml",
+		"--project-name", projectName, "up", "-d", "-y")
+
+	// Volume should have v2 label (recreated)
+	res = c.RunDockerCmd(t, "volume", "inspect", volName, "-f", `{{ index .Labels "config" }}`)
+	res.Assert(t, icmd.Expected{Out: "v2"})
+
+	// Containers should be running (recreated to mount the new volume)
+	res = c.RunDockerComposeCmd(t, "--project-name", projectName, "ps", "--format", "json")
+	assert.Assert(t, strings.Contains(res.Stdout(), `"State":"running"`),
+		"expected running containers after volume recreate")
+}
+
+// TestReconcileDependentRestart verifies that when a service is recreated,
+// dependent services with restart:true are stopped and restarted.
+func TestReconcileDependentRestart(t *testing.T) {
+	c := NewCLI(t)
+	const projectName = "reconcile-dep-restart"
+	t.Cleanup(func() {
+		c.cleanupWithDown(t, projectName)
+	})
+
+	// First up: create all services
+	c.RunDockerComposeCmd(t, "-f", "./fixtures/reconciliation-test/compose.yaml",
+		"--project-name", projectName, "up", "-d")
+
+	// Get initial web container ID
+	res := c.RunDockerCmd(t, "inspect", fmt.Sprintf("%s-web-1", projectName), "-f", "{{ .Id }}")
+	initialWebID := strings.TrimSpace(res.Stdout())
+
+	// Recreate db (by changing env) — web depends on db with restart:true
+	// so web should be stopped and restarted
+	cli := NewCLI(t, WithEnv("LABEL=trigger-recreate"))
+	res = cli.RunDockerComposeCmd(t, "-f", "./fixtures/reconciliation-test/compose.yaml",
+		"--project-name", projectName, "up", "-d")
+
+	out := res.Stderr()
+	// db should be recreated
+	assert.Assert(t, strings.Contains(out, "Recreated") || strings.Contains(out, "Recreate"),
+		"expected db recreate: %s", out)
+
+	// web should have been stopped (due to restart:true dependency)
+	// It may be Stopped+Started or Recreated depending on whether its config also changed
+	assert.Assert(t, strings.Contains(out, fmt.Sprintf("%s-web-1", projectName)),
+		"expected web container in output: %s", out)
+
+	// Both containers should be running
+	res = c.RunDockerComposeCmd(t, "--project-name", projectName, "ps", "-q")
+	lines := strings.Split(strings.TrimSpace(res.Stdout()), "\n")
+	assert.Equal(t, len(lines), 2, "expected 2 running containers")
+
+	// web container should have been replaced (new ID)
+	res = c.RunDockerCmd(t, "inspect", fmt.Sprintf("%s-web-1", projectName), "-f", "{{ .Id }}")
+	newWebID := strings.TrimSpace(res.Stdout())
+	assert.Assert(t, newWebID != initialWebID, "expected web container to be replaced")
+}
+
+// TestReconcileIdempotent verifies that running "up -d" twice with no changes
+// produces no recreations — containers should show as "Running".
+func TestReconcileIdempotent(t *testing.T) {
+	c := NewCLI(t)
+	const projectName = "reconcile-idempotent"
+	t.Cleanup(func() {
+		c.cleanupWithDown(t, projectName)
+	})
+
+	// First up
+	c.RunDockerComposeCmd(t, "-f", "./fixtures/reconciliation-test/compose.yaml",
+		"--project-name", projectName, "up", "-d")
+
+	// Get container IDs
+	res := c.RunDockerCmd(t, "inspect", fmt.Sprintf("%s-db-1", projectName), "-f", "{{ .Id }}")
+	dbID := strings.TrimSpace(res.Stdout())
+	res = c.RunDockerCmd(t, "inspect", fmt.Sprintf("%s-web-1", projectName), "-f", "{{ .Id }}")
+	webID := strings.TrimSpace(res.Stdout())
+
+	// Second up with no changes
+	res = c.RunDockerComposeCmd(t, "-f", "./fixtures/reconciliation-test/compose.yaml",
+		"--project-name", projectName, "up", "-d")
+	out := res.Stderr()
+
+	// Should show "Running" not "Recreated" or "Created"
+	assert.Assert(t, strings.Contains(out, "Running"), "expected Running in output: %s", out)
+	assert.Assert(t, !strings.Contains(out, "Recreated"), "unexpected Recreated in output: %s", out)
+	assert.Assert(t, !strings.Contains(out, "Created"), "unexpected Created in output: %s", out)
+
+	// Container IDs should be unchanged
+	res = c.RunDockerCmd(t, "inspect", fmt.Sprintf("%s-db-1", projectName), "-f", "{{ .Id }}")
+	assert.Equal(t, strings.TrimSpace(res.Stdout()), dbID)
+	res = c.RunDockerCmd(t, "inspect", fmt.Sprintf("%s-web-1", projectName), "-f", "{{ .Id }}")
+	assert.Equal(t, strings.TrimSpace(res.Stdout()), webID)
+}