upaas/internal/docker/dockerignore_test.go

package docker //nolint:testpackage // tests the unexported performBuild

import (
	"archive/tar"
	"errors"
	"io"
	"log/slog"
	"net/http"
	"net/http/httptest"
	"os"
	"path/filepath"
	"slices"
	"strings"
	"testing"

	"github.com/docker/docker/client"
)

// TestPerformBuildFollowsDockerignore runs builds against a fake Docker API
// and checks which files the build context sent to it holds.
func TestPerformBuildFollowsDockerignore(t *testing.T) {
	t.Parallel()

	tests := []struct {
		name       string
		dockerfile string
		files      map[string]string // path in the context: contents
		want       []string          // files sent in the build context
	}{
		{
			name:       "no ignore file",
			dockerfile: "Dockerfile",
			files:      map[string]string{"Dockerfile": "", "main.go": ""},
			want:       []string{"Dockerfile", "main.go"},
		},
		{
			name:       "excludes and re-includes",
			dockerfile: "Dockerfile",
			files: map[string]string{
				".dockerignore": "secret.txt\n*.md\n!README.md\n",
				"Dockerfile":    "",
				"NOTES.md":      "",
				"README.md":     "",
				"main.go":       "",
				"secret.txt":    "",
			},
			want: []string{".dockerignore", "Dockerfile", "README.md", "main.go"},
		},
		{
			name:       "keeps the Dockerfile and .dockerignore",
			dockerfile: "Dockerfile",
			files: map[string]string{
				".dockerignore": "Dockerfile\n.dockerignore\nsecret.txt\n",
				"Dockerfile":    "",
				"main.go":       "",
				"secret.txt":    "",
			},
			want: []string{".dockerignore", "Dockerfile", "main.go"},
		},
		{
			name:       "an ignore file next to the Dockerfile wins over .dockerignore",
			dockerfile: "deploy/Dockerfile",
			files: map[string]string{
				".dockerignore":                  "main.go\n",
				"deploy/Dockerfile":              "",
				"deploy/Dockerfile.dockerignore": "secret.txt\n",
				"main.go":                        "",
				"secret.txt":                     "",
			},
			want: []string{
				".dockerignore",
				"deploy/Dockerfile",
				"deploy/Dockerfile.dockerignore",
				"main.go",
			},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			t.Parallel()

			contextDir := t.TempDir()

			for name, contents := range tt.files {
				path := filepath.Join(contextDir, name)

				err := os.MkdirAll(filepath.Dir(path), 0o750)
				if err != nil {
					t.Fatal(err)
				}

				err = os.WriteFile(path, []byte(contents), 0o600)
				if err != nil {
					t.Fatal(err)
				}
			}

			got, err := buildContextFiles(t, contextDir, tt.dockerfile)
			if err != nil {
				t.Fatal(err)
			}

			if !slices.Equal(got, tt.want) {
				t.Errorf("build context holds %q, want %q", got, tt.want)
			}
		})
	}
}

// TestPerformBuildFailsOnMalformedDockerignore checks that a pattern the
// docker command line would reject fails the build.
func TestPerformBuildFailsOnMalformedDockerignore(t *testing.T) {
	t.Parallel()

	contextDir := t.TempDir()

	err := os.WriteFile(filepath.Join(contextDir, ".dockerignore"), []byte("[\n"), 0o600)
	if err != nil {
		t.Fatal(err)
	}

	_, err = buildContextFiles(t, contextDir, "Dockerfile")

	want := "failed to create build context: " +
		"invalid pattern in .dockerignore: syntax error in pattern"
	if err == nil || err.Error() != want {
		t.Errorf("got error %v, want %q", err, want)
	}
}

// TestPerformBuildFailsOnUnreadableDockerignore checks that an ignore file
// that cannot be read, here because it is a directory, fails the build.
func TestPerformBuildFailsOnUnreadableDockerignore(t *testing.T) {
	t.Parallel()

	contextDir := t.TempDir()

	err := os.Mkdir(filepath.Join(contextDir, ".dockerignore"), 0o750)
	if err != nil {
		t.Fatal(err)
	}

	_, err = buildContextFiles(t, contextDir, "Dockerfile")

	want := "failed to create build context: failed to read .dockerignore: "
	if err == nil || !strings.HasPrefix(err.Error(), want) {
		t.Errorf("got error %v, want one starting %q", err, want)
	}
}

// buildContextFiles runs a build of contextDir against a fake Docker API and
// returns the names of the files in the build context sent to it, sorted.
func buildContextFiles(t *testing.T, contextDir, dockerfile string) ([]string, error) {
	t.Helper()

	sent := make(chan []string, 1)

	srv := httptest.NewServer(http.HandlerFunc(
		func(w http.ResponseWriter, r *http.Request) {
			switch {
			case strings.HasSuffix(r.URL.Path, "/version"):
				_, _ = w.Write([]byte(`{"Version":"27.3.1","ApiVersion":"1.47"}`))
			case strings.HasSuffix(r.URL.Path, "/session"):
				serveSession(t, w, r, make(chan string, 1))
			case strings.HasSuffix(r.URL.Path, "/build"):
				sent <- tarFileNames(t, r.Body)
			default:
				t.Errorf("unexpected request to %s", r.URL.Path)
			}
		},
	))
	t.Cleanup(srv.Close)

	dockerAPI, err := client.NewClientWithOpts(
		client.WithHost("tcp://" + srv.Listener.Addr().String()),
	)
	if err != nil {
		t.Fatal(err)
	}

	c := &Client{docker: dockerAPI, log: slog.Default()}

	_, err = c.performBuild(t.Context(), BuildImageOptions{
		ContextDir:     contextDir,
		DockerfilePath: dockerfile,
	})
	if err != nil {
		return nil, err
	}

	return <-sent, nil
}

// tarFileNames returns the names of the regular files in the tar read from r,
// sorted.
func tarFileNames(t *testing.T, r io.Reader) []string {
	t.Helper()

	var names []string

	reader := tar.NewReader(r)

	for {
		header, err := reader.Next()
		if errors.Is(err, io.EOF) {
			break
		}

		if err != nil {
			t.Errorf("reading the build context: %v", err)

			return nil
		}

		if header.Typeflag == tar.TypeReg {
			names = append(names, header.Name)
		}
	}

	slices.Sort(names)

	return names
}