@automattic/vip 4.1.4 → 4.1.6

package/internal/releasepromotion/buildkite_test.go

@@ -1,284 +0,0 @@
-package releasepromotion
-
-import (
-	"context"
-	"encoding/json/v2"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"strings"
-	"sync/atomic"
-	"testing"
-	"time"
-)
-
-func TestWaitForTaggedBuildSelectsExactTagAndCommit(t *testing.T) {
-	t.Parallel()
-	const tag = "5.0.0-beta.1"
-	const commit = "0123456789abcdef0123456789abcdef01234567"
-	server := newBuildkiteServer(t, func(w http.ResponseWriter, r *http.Request) {
-		assertBuildkiteRequest(t, r)
-		if got := r.URL.Query().Get("branch"); got != tag {
-			t.Errorf("branch query = %q, want %q", got, tag)
-		}
-		if got := r.URL.Query().Get("commit"); got != commit {
-			t.Errorf("commit query = %q, want %q", got, commit)
-		}
-		if got := r.URL.Query().Get("exclude_jobs"); got != "true" {
-			t.Errorf("exclude_jobs query = %q, want true", got)
-		}
-		writeJSON(t, w, []Build{
-			{Number: 1, Branch: "trunk", Commit: commit, State: "passed", CreatedAt: time.Unix(1, 0)},
-			{Number: 2, Branch: tag, Commit: strings.Repeat("a", 40), State: "passed", CreatedAt: time.Unix(2, 0)},
-			{Number: 3, Branch: tag, Commit: commit, State: "passed", CreatedAt: time.Unix(3, 0)},
-		})
-	})
-	defer server.Close()
-
-	client := testBuildkiteClient(server.URL)
-	build, err := client.WaitForTaggedBuild(context.Background(), tag, commit)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if build.Number != 3 {
-		t.Fatalf("build number = %d, want 3", build.Number)
-	}
-}
-
-func TestWaitForTaggedBuildIgnoresStaleCommitBuild(t *testing.T) {
-	t.Parallel()
-	const tag = "5.0.0-beta.1"
-	const commit = "0123456789abcdef0123456789abcdef01234567"
-	var requests atomic.Int32
-	server := newBuildkiteServer(t, func(w http.ResponseWriter, _ *http.Request) {
-		if requests.Add(1) == 1 {
-			writeJSON(t, w, []Build{{Number: 1, Branch: tag, Commit: strings.Repeat("a", 40), State: "passed"}})
-			return
-		}
-		writeJSON(t, w, []Build{{Number: 2, Branch: tag, Commit: commit, State: "passed"}})
-	})
-	defer server.Close()
-	client := testBuildkiteClient(server.URL)
-	client.Sleep = func(context.Context, time.Duration) error { return nil }
-
-	build, err := client.WaitForTaggedBuild(context.Background(), tag, commit)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if build.Number != 2 || requests.Load() != 2 {
-		t.Fatalf("build = %#v, requests = %d", build, requests.Load())
-	}
-}
-
-func TestWaitForTaggedBuildWaitsThroughScheduledAndRunning(t *testing.T) {
-	t.Parallel()
-	states := []string{"creating", "scheduled", "waiting", "running", "failing", "canceling", "blocked", "passed"}
-	var requests atomic.Int32
-	server := newBuildkiteServer(t, func(w http.ResponseWriter, _ *http.Request) {
-		index := int(requests.Add(1)) - 1
-		writeJSON(t, w, []Build{{Number: 7, Branch: "5.0.0-rc.1", Commit: strings.Repeat("b", 40), State: states[index]}})
-	})
-	defer server.Close()
-	client := testBuildkiteClient(server.URL)
-	client.Sleep = func(context.Context, time.Duration) error { return nil }
-
-	build, err := client.WaitForTaggedBuild(context.Background(), "5.0.0-rc.1", strings.Repeat("b", 40))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if build.State != "passed" || requests.Load() != int32(len(states)) {
-		t.Fatalf("build state = %q, requests = %d", build.State, requests.Load())
-	}
-}
-
-func TestWaitForTaggedBuildReturnsFailedAndCanceledStates(t *testing.T) {
-	t.Parallel()
-	for _, state := range []string{"failed", "canceled"} {
-		state := state
-		t.Run(state, func(t *testing.T) {
-			t.Parallel()
-			server := newBuildkiteServer(t, func(w http.ResponseWriter, _ *http.Request) {
-				writeJSON(t, w, []Build{{Number: 9, Branch: "5.0.0-beta.2", Commit: strings.Repeat("c", 40), State: state, WebURL: "https://buildkite.example/build/9"}})
-			})
-			defer server.Close()
-			client := testBuildkiteClient(server.URL)
-			_, err := client.WaitForTaggedBuild(context.Background(), "5.0.0-beta.2", strings.Repeat("c", 40))
-			if err == nil || !strings.Contains(err.Error(), state) || !strings.Contains(err.Error(), "https://buildkite.example/build/9") {
-				t.Fatalf("error = %v", err)
-			}
-		})
-	}
-}
-
-func TestGetBuild(t *testing.T) {
-	t.Parallel()
-	server := newBuildkiteServer(t, func(w http.ResponseWriter, r *http.Request) {
-		if !strings.HasSuffix(r.URL.Path, "/builds/28") {
-			t.Fatalf("path = %q", r.URL.Path)
-		}
-		writeJSON(t, w, Build{Number: 28, Branch: "trunk", Commit: strings.Repeat("d", 40), State: "passed"})
-	})
-	defer server.Close()
-	build, err := testBuildkiteClient(server.URL).GetBuild(context.Background(), 28)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if build.Number != 28 {
-		t.Fatalf("build number = %d", build.Number)
-	}
-}
-
-func TestDownloadArtifactsRequiresExactManifest(t *testing.T) {
-	t.Parallel()
-	artifacts := completeArtifactManifest("http://unused.invalid")
-	artifacts = artifacts[1:]
-	server := newBuildkiteServer(t, func(w http.ResponseWriter, r *http.Request) {
-		if strings.HasSuffix(r.URL.Path, "/artifacts") {
-			writeJSON(t, w, artifacts)
-			return
-		}
-		http.NotFound(w, r)
-	})
-	defer server.Close()
-	err := testBuildkiteClient(server.URL).DownloadArtifacts(context.Background(), Build{Number: 28}, t.TempDir())
-	if err == nil || !strings.Contains(err.Error(), "missing artifacts") {
-		t.Fatalf("error = %v", err)
-	}
-}
-
-func TestDownloadArtifacts(t *testing.T) {
-	t.Parallel()
-	var serverURL string
-	server := newBuildkiteServer(t, func(w http.ResponseWriter, r *http.Request) {
-		assertBuildkiteRequest(t, r)
-		if strings.HasSuffix(r.URL.Path, "/artifacts") {
-			writeJSON(t, w, completeArtifactManifest(serverURL))
-			return
-		}
-		if strings.HasPrefix(r.URL.Path, "/download/") {
-			_, _ = w.Write([]byte(filepath.Base(r.URL.Path)))
-			return
-		}
-		http.NotFound(w, r)
-	})
-	serverURL = server.URL
-	defer server.Close()
-
-	root := t.TempDir()
-	err := testBuildkiteClient(server.URL).DownloadArtifacts(context.Background(), Build{Number: 28}, root)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, artifactPath := range ExpectedArtifactPaths() {
-		name := filepath.Base(artifactPath)
-		contents, err := os.ReadFile(filepath.Join(root, name))
-		if err != nil {
-			t.Fatal(err)
-		}
-		if string(contents) != name {
-			t.Errorf("%s contents = %q", name, contents)
-		}
-	}
-}
-
-func TestDownloadArtifactsRejectsNonSuccessHTTPStatus(t *testing.T) {
-	t.Parallel()
-	var serverURL string
-	server := newBuildkiteServer(t, func(w http.ResponseWriter, r *http.Request) {
-		if strings.HasSuffix(r.URL.Path, "/artifacts") {
-			writeJSON(t, w, completeArtifactManifest(serverURL))
-			return
-		}
-		http.Error(w, "nope", http.StatusBadGateway)
-	})
-	serverURL = server.URL
-	defer server.Close()
-	root := t.TempDir()
-	err := testBuildkiteClient(server.URL).DownloadArtifacts(context.Background(), Build{Number: 28}, root)
-	if err == nil || !strings.Contains(err.Error(), "502") {
-		t.Fatalf("error = %v", err)
-	}
-	matches, err := filepath.Glob(filepath.Join(root, "*.partial"))
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(matches) != 0 {
-		t.Fatalf("partial files left behind: %v", matches)
-	}
-}
-
-func newBuildkiteServer(t *testing.T, handler http.HandlerFunc) *httptest.Server {
-	t.Helper()
-	return httptest.NewServer(handler)
-}
-
-func testBuildkiteClient(baseURL string) *BuildkiteClient {
-	return &BuildkiteClient{BaseURL: baseURL, Token: "test-token", HTTPClient: http.DefaultClient, PollInterval: time.Millisecond}
-}
-
-func assertBuildkiteRequest(t *testing.T, r *http.Request) {
-	t.Helper()
-	if got := r.Header.Get("Authorization"); got != "Bearer test-token" {
-		t.Errorf("Authorization = %q", got)
-	}
-}
-
-func completeArtifactManifest(baseURL string) []Artifact {
-	paths := ExpectedArtifactPaths()
-	artifacts := make([]Artifact, 0, len(paths))
-	for i, artifactPath := range paths {
-		artifacts = append(artifacts, Artifact{
-			ID:          fmt.Sprintf("artifact-%d", i),
-			Path:        artifactPath,
-			Filename:    filepath.Base(artifactPath),
-			State:       "finished",
-			DownloadURL: baseURL + "/download/" + filepath.Base(artifactPath),
-		})
-	}
-	return artifacts
-}
-
-func writeJSON(t *testing.T, w http.ResponseWriter, value any) {
-	t.Helper()
-	w.Header().Set("Content-Type", "application/json")
-	data, err := json.Marshal(value)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if _, err := w.Write(data); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestDownloadArtifactsRejectsStaleOptionalInstallers(t *testing.T) {
-	server := newBuildkiteServer(t, func(w http.ResponseWriter, r *http.Request) {
-		if !strings.HasSuffix(r.URL.Path, "/artifacts") {
-			t.Errorf("unexpected download into nonempty directory: %s", r.URL)
-			w.WriteHeader(500)
-			return
-		}
-		var artifacts []Artifact
-		for _, p := range ExpectedArtifactPaths() {
-			if strings.Contains(p, ".tar.gz") {
-				artifacts = append(artifacts, Artifact{Path: p, State: "finished", DownloadURL: "https://example.invalid/download"})
-			}
-		}
-		writeJSON(t, w, artifacts)
-	})
-	defer server.Close()
-	root := t.TempDir()
-	stale := filepath.Join(root, "vip-next-darwin-amd64.pkg")
-	if err := os.WriteFile(stale, []byte("previous build"), 0600); err != nil {
-		t.Fatal(err)
-	}
-	err := testBuildkiteClient(server.URL).DownloadArtifacts(context.Background(), Build{Number: 28}, root)
-	if err == nil || !strings.Contains(err.Error(), "must be empty") {
-		t.Fatalf("accepted stale artifact: %v", err)
-	}
-	got, err := os.ReadFile(stale)
-	if err != nil || string(got) != "previous build" {
-		t.Fatalf("changed existing artifact: %q %v", got, err)
-	}
-}

package/internal/releasepromotion/contract.go

@@ -1,165 +0,0 @@
-package releasepromotion
-
-import (
-	"fmt"
-	"os"
-	"path"
-	"path/filepath"
-	"regexp"
-	"sort"
-	"strings"
-)
-
-const (
-	GitHubRepository      = "Automattic/vip-cli"
-	BuildkiteOrganization = "automattic"
-	BuildkitePipeline     = "vip-cli"
-	TrunkRef              = "refs/heads/trunk"
-)
-
-var prereleaseVersionPattern = regexp.MustCompile(`^5\.(0|[1-9][0-9]*)\.(0|[1-9][0-9]*)-(alpha|beta|rc)\.(0|[1-9][0-9]*)$`)
-
-var expectedArtifactPaths = []string{
-	"dist/vip-next-darwin-amd64.pkg",
-	"dist/vip-next-darwin-amd64.pkg.sha256",
-	"dist/vip-next-darwin-arm64.pkg",
-	"dist/vip-next-darwin-arm64.pkg.sha256",
-	"dist/vip-next-windows-amd64.msi",
-	"dist/vip-next-windows-amd64.msi.sha256",
-	"dist/vip-next-darwin-amd64.tar.gz",
-	"dist/vip-next-darwin-amd64.tar.gz.sha256",
-	"dist/vip-next-darwin-arm64.tar.gz",
-	"dist/vip-next-darwin-arm64.tar.gz.sha256",
-	"dist/vip-next-linux-amd64.tar.gz",
-	"dist/vip-next-linux-amd64.tar.gz.sha256",
-	"dist/vip-next-linux-arm64.tar.gz",
-	"dist/vip-next-linux-arm64.tar.gz.sha256",
-	"dist/vip-next-windows-amd64.tar.gz",
-	"dist/vip-next-windows-amd64.tar.gz.sha256",
-}
-
-type Artifact struct {
-	ID          string `json:"id"`
-	JobID       string `json:"job_id"`
-	Path        string `json:"path"`
-	Filename    string `json:"filename"`
-	State       string `json:"state"`
-	DownloadURL string `json:"download_url"`
-}
-
-func ValidateRequest(version, ref string) error {
-	if !prereleaseVersionPattern.MatchString(version) {
-		return fmt.Errorf("invalid prerelease version %q; expected an unprefixed 5.x prerelease such as 5.0.0-beta.1", version)
-	}
-	if ref != TrunkRef {
-		return fmt.Errorf("invalid workflow ref %q; prereleases must run from %s", ref, TrunkRef)
-	}
-	return nil
-}
-
-func ExpectedArtifactPaths() []string {
-	return append([]string(nil), expectedArtifactPaths...)
-}
-
-func ValidateArtifactManifest(artifacts []Artifact) (map[string]Artifact, error) {
-	expected := make(map[string]struct{}, len(expectedArtifactPaths))
-	for _, artifactPath := range expectedArtifactPaths {
-		expected[artifactPath] = struct{}{}
-	}
-
-	manifest := make(map[string]Artifact, len(artifacts))
-	var unexpected []string
-	var unfinished []string
-	var duplicates []string
-	for _, artifact := range artifacts {
-		normalizedPath := strings.ReplaceAll(artifact.Path, `\`, "/")
-		artifactPath := path.Clean(normalizedPath)
-		if artifactPath != normalizedPath {
-			unexpected = append(unexpected, artifact.Path)
-			continue
-		}
-		if _, ok := expected[artifactPath]; !ok {
-			unexpected = append(unexpected, artifactPath)
-			continue
-		}
-		if _, ok := manifest[artifactPath]; ok {
-			duplicates = append(duplicates, artifactPath)
-			continue
-		}
-		artifact.Path = artifactPath
-		manifest[artifactPath] = artifact
-		if artifact.State != "finished" {
-			unfinished = append(unfinished, artifactPath)
-		}
-	}
-
-	var missing []string
-	for _, artifactPath := range expectedArtifactPaths {
-		if _, ok := manifest[artifactPath]; !ok {
-			// Portable binaries are mandatory. Installers are optional, but a
-			// package and its checksum must always be present together.
-			companion := strings.TrimSuffix(artifactPath, ".sha256")
-			if companion == artifactPath {
-				companion += ".sha256"
-			}
-			_, paired := manifest[companion]
-			if strings.Contains(artifactPath, ".tar.gz") || paired {
-				missing = append(missing, artifactPath)
-			}
-		}
-	}
-
-	if len(missing)+len(unexpected)+len(unfinished)+len(duplicates) > 0 {
-		sort.Strings(missing)
-		sort.Strings(unexpected)
-		sort.Strings(unfinished)
-		sort.Strings(duplicates)
-		var problems []string
-		if len(missing) > 0 {
-			problems = append(problems, "missing artifacts: "+strings.Join(missing, ", "))
-		}
-		if len(unexpected) > 0 {
-			problems = append(problems, "unexpected artifacts: "+strings.Join(unexpected, ", "))
-		}
-		if len(duplicates) > 0 {
-			problems = append(problems, "duplicate artifacts: "+strings.Join(duplicates, ", "))
-		}
-		if len(unfinished) > 0 {
-			problems = append(problems, "artifacts not finished: "+strings.Join(unfinished, ", "))
-		}
-		return nil, fmt.Errorf("invalid Buildkite artifact manifest: %s", strings.Join(problems, "; "))
-	}
-
-	return manifest, nil
-}
-
-// localArtifactPaths applies the same contract to downloads before upload. It
-// also rejects unknown files and non-regular entries instead of publishing them.
-func localArtifactPaths(root string) ([]string, error) {
-	entries, err := os.ReadDir(root)
-	if err != nil {
-		return nil, err
-	}
-	var artifacts []Artifact
-	for _, entry := range entries {
-		info, err := entry.Info()
-		if err != nil {
-			return nil, err
-		}
-		if !info.Mode().IsRegular() {
-			return nil, fmt.Errorf("replacement asset %q is not a regular file", entry.Name())
-		}
-		artifacts = append(artifacts, Artifact{Path: "dist/" + entry.Name(), State: "finished"})
-	}
-	manifest, err := ValidateArtifactManifest(artifacts)
-	if err != nil {
-		return nil, err
-	}
-	paths := make([]string, 0, len(manifest))
-	for _, p := range expectedArtifactPaths {
-		if _, ok := manifest[p]; ok {
-			paths = append(paths, filepath.Base(p))
-		}
-	}
-	return paths, nil
-}

package/internal/releasepromotion/contract_test.go

@@ -1,211 +0,0 @@
-package releasepromotion
-
-import (
-	"reflect"
-	"strings"
-	"testing"
-)
-
-func TestValidateRequest(t *testing.T) {
-	t.Parallel()
-	tests := []struct {
-		version string
-		ref     string
-		ok      bool
-	}{
-		{"5.0.0-beta.1", "refs/heads/trunk", true},
-		{"5.12.3-alpha.10", "refs/heads/trunk", true},
-		{"5.1.0-rc.2", "refs/heads/trunk", true},
-		{"5.0.0-beta.200", "refs/heads/trunk", true},
-		{"5.0.65-alpha.1", "refs/heads/trunk", true},
-		{"5.0.0", "refs/heads/trunk", false},
-		{"v5.0.0-beta.1", "refs/heads/trunk", false},
-		{"4.9.0-beta.1", "refs/heads/trunk", false},
-		{"5.0.0-beta1", "refs/heads/trunk", false},
-		{"5.0.0-beta.1", "refs/heads/feature", false},
-	}
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.version+"/"+tt.ref, func(t *testing.T) {
-			t.Parallel()
-			err := ValidateRequest(tt.version, tt.ref)
-			if (err == nil) != tt.ok {
-				t.Errorf("ValidateRequest(%q, %q) error = %v, want ok=%v", tt.version, tt.ref, err, tt.ok)
-			}
-		})
-	}
-}
-
-func TestManifestAllowsMissingInstallerPairs(t *testing.T) {
-	var artifacts []Artifact
-	for _, p := range ExpectedArtifactPaths() {
-		if strings.Contains(p, ".tar.gz") {
-			artifacts = append(artifacts, Artifact{Path: p, State: "finished"})
-		}
-	}
-	if _, err := ValidateArtifactManifest(artifacts); err != nil {
-		t.Fatal(err)
-	}
-	artifacts = append(artifacts, Artifact{Path: "dist/vip-next-windows-amd64.msi", State: "finished"}, Artifact{Path: "dist/vip-next-windows-amd64.msi.sha256", State: "finished"})
-	if _, err := ValidateArtifactManifest(artifacts); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestManifestRejectsPartialInstallerPairs(t *testing.T) {
-	for _, missing := range []string{
-		"dist/vip-next-darwin-amd64.pkg", "dist/vip-next-darwin-amd64.pkg.sha256",
-		"dist/vip-next-darwin-arm64.pkg", "dist/vip-next-darwin-arm64.pkg.sha256",
-		"dist/vip-next-windows-amd64.msi", "dist/vip-next-windows-amd64.msi.sha256",
-	} {
-		t.Run(missing, func(t *testing.T) {
-			var artifacts []Artifact
-			for _, p := range ExpectedArtifactPaths() {
-				if p != missing {
-					artifacts = append(artifacts, Artifact{Path: p, State: "finished"})
-				}
-			}
-			if _, err := ValidateArtifactManifest(artifacts); err == nil || !strings.Contains(err.Error(), missing) {
-				t.Fatalf("missing installer artifact accepted: %v", err)
-			}
-		})
-	}
-}
-
-func TestValidateArtifactManifest(t *testing.T) {
-	t.Parallel()
-	expected := ExpectedArtifactPaths()
-	artifacts := make([]Artifact, 0, len(expected))
-	for i, artifactPath := range expected {
-		artifacts = append(artifacts, Artifact{
-			ID:          string(rune('a' + i)),
-			Path:        artifactPath,
-			Filename:    artifactPath,
-			State:       "finished",
-			DownloadURL: "https://example.invalid/artifact",
-		})
-	}
-
-	manifest, err := ValidateArtifactManifest(artifacts)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if len(manifest) != len(expected) {
-		t.Fatalf("manifest length = %d, want %d", len(manifest), len(expected))
-	}
-	for _, artifactPath := range expected {
-		if _, ok := manifest[artifactPath]; !ok {
-			t.Errorf("manifest missing %q", artifactPath)
-		}
-	}
-}
-
-func TestValidateArtifactManifestNormalizesWindowsSeparators(t *testing.T) {
-	t.Parallel()
-	expected := ExpectedArtifactPaths()
-	artifacts := make([]Artifact, 0, len(expected))
-	for _, artifactPath := range expected {
-		buildkitePath := artifactPath
-		if strings.Contains(artifactPath, "-windows-") {
-			buildkitePath = strings.ReplaceAll(artifactPath, "/", `\`)
-		}
-		artifacts = append(artifacts, Artifact{Path: buildkitePath, State: "finished"})
-	}
-
-	manifest, err := ValidateArtifactManifest(artifacts)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for _, artifactPath := range expected {
-		artifact, ok := manifest[artifactPath]
-		if !ok {
-			t.Errorf("manifest missing normalized path %q", artifactPath)
-			continue
-		}
-		if artifact.Path != artifactPath {
-			t.Errorf("artifact path = %q, want normalized %q", artifact.Path, artifactPath)
-		}
-	}
-}
-
-func TestValidateArtifactManifestRejectsInvalidSets(t *testing.T) {
-	t.Parallel()
-	valid := func() []Artifact {
-		paths := ExpectedArtifactPaths()
-		artifacts := make([]Artifact, 0, len(paths))
-		for _, artifactPath := range paths {
-			artifacts = append(artifacts, Artifact{Path: artifactPath, State: "finished"})
-		}
-		return artifacts
-	}
-
-	tests := []struct {
-		name   string
-		mutate func([]Artifact) []Artifact
-		want   []string
-	}{
-		{
-			name: "missing",
-			mutate: func(artifacts []Artifact) []Artifact {
-				return artifacts[1:]
-			},
-			want: []string{"missing", ExpectedArtifactPaths()[0]},
-		},
-		{
-			name: "duplicate",
-			mutate: func(artifacts []Artifact) []Artifact {
-				return append(artifacts, artifacts[0])
-			},
-			want: []string{"duplicate", ExpectedArtifactPaths()[0]},
-		},
-		{
-			name: "unexpected",
-			mutate: func(artifacts []Artifact) []Artifact {
-				return append(artifacts, Artifact{Path: "dist/notes.txt", State: "finished"})
-			},
-			want: []string{"unexpected", "dist/notes.txt"},
-		},
-		{
-			name: "unfinished",
-			mutate: func(artifacts []Artifact) []Artifact {
-				artifacts[0].State = "uploading"
-				return artifacts
-			},
-			want: []string{"not finished", ExpectedArtifactPaths()[0]},
-		},
-		{
-			name: "windows traversal",
-			mutate: func(artifacts []Artifact) []Artifact {
-				artifacts[0].Path = `dist\..\vip-next-darwin-amd64.tar.gz`
-				return artifacts
-			},
-			want: []string{"unexpected", `dist\..\vip-next-darwin-amd64.tar.gz`},
-		},
-	}
-
-	for _, tt := range tests {
-		tt := tt
-		t.Run(tt.name, func(t *testing.T) {
-			t.Parallel()
-			_, err := ValidateArtifactManifest(tt.mutate(valid()))
-			if err == nil {
-				t.Fatal("ValidateArtifactManifest() error = nil")
-			}
-			for _, want := range tt.want {
-				if !strings.Contains(err.Error(), want) {
-					t.Errorf("error %q does not contain %q", err, want)
-				}
-			}
-		})
-	}
-}
-
-func TestExpectedArtifactPathsReturnsCopy(t *testing.T) {
-	t.Parallel()
-	want := ExpectedArtifactPaths()
-	got := ExpectedArtifactPaths()
-	got[0] = "changed"
-	if reflect.DeepEqual(got, want) {
-		t.Fatal("ExpectedArtifactPaths returned shared storage")
-	}
-}