test: add integration tests for docker-compose deployer

Add comprehensive integration tests for the Docker Compose deployer:

1. Test data:
   - integration/testdata/docker-compose-deploy/
   - integration/examples/docker-compose-deploy/

2. Integration tests:
   - TestDeleteDockerComposeDeployer: Tests deployment and cleanup
   - TestDevCancelWithDockerComposeDeployer: Tests dev loop cancellation

3. Helper functions:
   - getComposeContainers: Filters containers by compose project label
   - waitForComposeContainersRunning: Waits for compose containers to start

These tests verify that:
- Docker Compose deployments work correctly
- Containers are properly started with correct labels
- Cleanup (delete) removes all compose containers
- Dev mode can be gracefully canceled

The tests use Docker Compose's project label (com.docker.compose.project)
to identify containers, which works with the dynamic project naming
(skaffold-{runID}) used by the deployer.

This also fixes the CI error from check-samples.sh by adding the required
integration/examples directory.

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude <[email protected]>

Author: kterui9019

integration/delete_test.go

@@ -133,6 +133,65 @@ func getContainers(ctx context.Context, t *testutil.T, deployedContainers []stri
 	return cl
 }
 
+func getComposeContainers(ctx context.Context, t *testutil.T, projectNamePrefix string, client docker.LocalDaemon) []types.Container {
+	t.Helper()
+
+	// List all containers
+	cl, err := client.ContainerList(ctx, container.ListOptions{
+		All: true,
+	})
+	t.CheckNoError(err)
+
+	// Filter containers by project name prefix
+	var result []types.Container
+	for _, c := range cl {
+		if project, ok := c.Labels["com.docker.compose.project"]; ok {
+			// Check if project name starts with the prefix (e.g., "skaffold-")
+			if len(project) > len(projectNamePrefix) && project[:len(projectNamePrefix)] == projectNamePrefix {
+				result = append(result, c)
+			}
+		}
+	}
+
+	return result
+}
+
+func TestDeleteDockerComposeDeployer(t *testing.T) {
+	tests := []struct {
+		description string
+		dir         string
+		args        []string
+	}{
+		{
+			description: "docker compose deployer",
+			dir:         "testdata/docker-compose-deploy",
+			args:        []string{},
+		},
+	}
+
+	for _, test := range tests {
+		testutil.Run(t, test.description, func(t *testutil.T) {
+			MarkIntegrationTest(t.T, CanRunWithoutGcp)
+			ctx := context.Background()
+
+			// Run skaffold to deploy with docker compose
+			skaffold.Run(test.args...).InDir(test.dir).RunOrFail(t.T)
+
+			// Verify containers are running
+			client := SetupDockerClient(t.T)
+			containers := getComposeContainers(ctx, t, "skaffold-", client)
+			t.CheckTrue(len(containers) > 0, "Expected at least one container to be deployed")
+
+			// Delete the deployment
+			skaffold.Delete(test.args...).InDir(test.dir).RunOrFail(t.T)
+
+			// Verify containers are deleted
+			containers = getComposeContainers(ctx, t, "skaffold-", client)
+			t.CheckDeepEqual(0, len(containers))
+		})
+	}
+}
+
 func TestDeleteNonExistedHelmResource(t *testing.T) {
 	var tests = []struct {
 		description string

integration/dev_test.go

@@ -187,6 +187,48 @@ func TestDevCancelWithDockerDeployer(t *testing.T) {
 	}
 }
 
+func TestDevCancelWithDockerComposeDeployer(t *testing.T) {
+	if runtime.GOOS == "windows" {
+		t.Skip("graceful cancel doesn't work on windows")
+	}
+
+	tests := []struct {
+		description    string
+		dir            string
+		minContainers  int
+		projectPrefix  string
+	}{
+		{
+			description:   "interrupt dev loop in Docker Compose deployer",
+			dir:           "testdata/docker-compose-deploy",
+			minContainers: 1,
+			projectPrefix: "skaffold-",
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.description, func(t *testing.T) {
+			MarkIntegrationTest(t, CanRunWithoutGcp)
+			p, err := skaffold.Dev().InDir(test.dir).StartWithProcess(t)
+			if err != nil {
+				t.Fatalf("error starting skaffold dev process")
+			}
+
+			if err = waitForComposeContainersRunning(t, test.projectPrefix, test.minContainers); err != nil {
+				t.Fatalf("failed waiting for containers: %v", err)
+			}
+
+			p.Signal(syscall.SIGINT)
+
+			state, _ := p.Wait()
+
+			if state.ExitCode() != 0 {
+				t.Fail()
+			}
+		})
+	}
+}
+
 func TestDevAPIBuildTrigger(t *testing.T) {
 	MarkIntegrationTest(t, CanRunWithoutGcp)
 

integration/examples/docker-compose-deploy/Dockerfile

@@ -0,0 +1,11 @@
+FROM golang:1.22-alpine AS builder
+WORKDIR /app
+COPY main.go .
+COPY go.mod .
+RUN go build -o app main.go
+
+FROM alpine:latest
+WORKDIR /root/
+COPY --from=builder /app/app .
+EXPOSE 8080
+CMD ["./app"]

integration/examples/docker-compose-deploy/README.md

@@ -0,0 +1,81 @@
+# Example: Deploying with Docker Compose
+
+This example demonstrates how to use Skaffold to build and deploy applications using Docker Compose.
+
+## Prerequisites
+
+- Docker and Docker Compose installed
+- Skaffold installed
+
+## Project Structure
+
+- `skaffold.yaml` - Skaffold configuration with Docker Compose deployment
+- `docker-compose.yml` - Docker Compose configuration
+- `Dockerfile` - Simple application Docker image
+- `main.go` - Simple Go web application
+
+## How it Works
+
+1. Skaffold builds the Docker image for the application
+2. Skaffold updates the `docker-compose.yml` with the built image tag
+3. Skaffold runs `docker compose up` to deploy the application
+4. When you stop Skaffold, it runs `docker compose down` to clean up
+
+## Usage
+
+### Run the application
+
+```bash
+skaffold dev
+```
+
+This will:
+- Build the application image
+- Deploy it using Docker Compose
+- Watch for changes and rebuild/redeploy automatically
+
+### Deploy only
+
+```bash
+skaffold run
+```
+
+### Clean up
+
+```bash
+skaffold delete
+```
+
+Or simply press `Ctrl+C` when running `skaffold dev`.
+
+## Configuration
+
+The key part of the `skaffold.yaml` configuration is:
+
+```yaml
+deploy:
+  docker:
+    useCompose: true
+    images:
+      - compose-app
+```
+
+- `useCompose: true` - Enables Docker Compose deployment
+- `images` - List of images to build and deploy
+
+## Environment Variables
+
+You can customize the Docker Compose file location:
+
+```bash
+export SKAFFOLD_COMPOSE_FILE=custom-compose.yml
+skaffold dev
+```
+
+Default is `docker-compose.yml` in the current directory.
+
+## Notes
+
+- The Docker Compose project name will be `skaffold-{runID}`
+- Skaffold automatically replaces image names in the compose file with the built tags
+- Volumes and networks are automatically cleaned up on `skaffold delete`

integration/examples/docker-compose-deploy/docker-compose.yml

@@ -0,0 +1,8 @@
+version: '3.8'
+services:
+  app:
+    image: compose-app
+    ports:
+      - "8080:8080"
+    environment:
+      - MESSAGE=Hello from Docker Compose!

integration/examples/docker-compose-deploy/go.mod

@@ -0,0 +1,3 @@
+module compose-app
+
+go 1.22

integration/examples/docker-compose-deploy/main.go

@@ -0,0 +1,27 @@
+package main
+
+import (
+	"fmt"
+	"log"
+	"net/http"
+	"os"
+)
+
+func main() {
+	message := os.Getenv("MESSAGE")
+	if message == "" {
+		message = "Hello, World!"
+	}
+
+	http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprintf(w, "%s\n", message)
+	})
+
+	port := ":8080"
+	log.Printf("Server starting on port %s", port)
+	log.Printf("Message: %s", message)
+
+	if err := http.ListenAndServe(port, nil); err != nil {
+		log.Fatal(err)
+	}
+}

integration/examples/docker-compose-deploy/skaffold.yaml

@@ -0,0 +1,14 @@
+apiVersion: skaffold/v4beta13
+kind: Config
+metadata:
+  name: docker-compose-deploy-example
+build:
+  artifacts:
+    - image: compose-app
+      docker:
+        dockerfile: Dockerfile
+deploy:
+  docker:
+    useCompose: true
+    images:
+      - compose-app

integration/testdata/docker-compose-deploy/Dockerfile

@@ -0,0 +1,11 @@
+FROM golang:1.22-alpine AS builder
+WORKDIR /app
+COPY main.go .
+COPY go.mod .
+RUN go build -o app main.go
+
+FROM alpine:latest
+WORKDIR /root/
+COPY --from=builder /app/app .
+EXPOSE 8080
+CMD ["./app"]

integration/testdata/docker-compose-deploy/README.md

@@ -0,0 +1,81 @@
+# Example: Deploying with Docker Compose
+
+This example demonstrates how to use Skaffold to build and deploy applications using Docker Compose.
+
+## Prerequisites
+
+- Docker and Docker Compose installed
+- Skaffold installed
+
+## Project Structure
+
+- `skaffold.yaml` - Skaffold configuration with Docker Compose deployment
+- `docker-compose.yml` - Docker Compose configuration
+- `Dockerfile` - Simple application Docker image
+- `main.go` - Simple Go web application
+
+## How it Works
+
+1. Skaffold builds the Docker image for the application
+2. Skaffold updates the `docker-compose.yml` with the built image tag
+3. Skaffold runs `docker compose up` to deploy the application
+4. When you stop Skaffold, it runs `docker compose down` to clean up
+
+## Usage
+
+### Run the application
+
+```bash
+skaffold dev
+```
+
+This will:
+- Build the application image
+- Deploy it using Docker Compose
+- Watch for changes and rebuild/redeploy automatically
+
+### Deploy only
+
+```bash
+skaffold run
+```
+
+### Clean up
+
+```bash
+skaffold delete
+```
+
+Or simply press `Ctrl+C` when running `skaffold dev`.
+
+## Configuration
+
+The key part of the `skaffold.yaml` configuration is:
+
+```yaml
+deploy:
+  docker:
+    useCompose: true
+    images:
+      - compose-app
+```
+
+- `useCompose: true` - Enables Docker Compose deployment
+- `images` - List of images to build and deploy
+
+## Environment Variables
+
+You can customize the Docker Compose file location:
+
+```bash
+export SKAFFOLD_COMPOSE_FILE=custom-compose.yml
+skaffold dev
+```
+
+Default is `docker-compose.yml` in the current directory.
+
+## Notes
+
+- The Docker Compose project name will be `skaffold-{runID}`
+- Skaffold automatically replaces image names in the compose file with the built tags
+- Volumes and networks are automatically cleaned up on `skaffold delete`