@automattic/vip 4.1.4 → 4.1.6

package/internal/parity/diff.go

@@ -1,128 +0,0 @@
-//go:build parity
-
-package parity
-
-import (
-	"crypto/sha256"
-	"encoding/hex"
-	"fmt"
-	"io"
-	"regexp"
-)
-
-type DiffResult struct {
-	Equal         bool
-	ExitCodeDelta string
-	StdoutDelta   string
-	StderrDelta   string
-}
-
-// ambientStderrRules strip environment-dependent noise from stderr before any
-// comparison. This is not the same thing as a scenario's own normalize rules:
-// those describe output a scenario chose to ignore, whereas these describe
-// output that depends only on where the harness happens to be running.
-//
-// Keep this list tiny and each pattern anchored to a whole line. Every entry
-// here is output the harness has been made blind to, so a pattern that is one
-// character too broad silently stops catching real divergences.
-var ambientStderrRules = []NormalizeRule{
-	// On a headless Linux runner there is no D-Bus secret service, so vip-next
-	// reports that it fell back to a 0600 credentials file. The Node CLI uses
-	// configstore and has no equivalent concept, so it says nothing. Left in,
-	// this one line failed 32 differential scenarios on Linux that all passed
-	// on macOS, where a keychain is always available.
-	//
-	// The difference is real and user-visible on headless Linux; it is recorded
-	// in docs/CUTOVER-BREAKING-CHANGES.md rather than here, because a divergence
-	// that appears in every single scenario is a property of the environment,
-	// not of any one command.
-	{Pattern: `(?m)^warning: OS keyring unavailable; storing credentials in .*\n?`, Replacement: ""},
-}
-
-// normalizeStderr applies the ambient rules before the scenario's own, so that
-// no scenario has to restate environment noise it never asked about.
-func normalizeStderr(s string, rules []NormalizeRule) (string, error) {
-	s, err := ApplyNormalizers(s, ambientStderrRules)
-	if err != nil {
-		return "", err
-	}
-	return ApplyNormalizers(s, rules)
-}
-
-func ApplyNormalizers(s string, rules []NormalizeRule) (string, error) {
-	for _, r := range rules {
-		re, err := regexp.Compile(r.Pattern)
-		if err != nil {
-			return "", fmt.Errorf("compile normalizer %q: %w", r.Pattern, err)
-		}
-		s = re.ReplaceAllString(s, r.Replacement)
-	}
-	return s, nil
-}
-
-func Diff(s *Scenario, a, b *RunResult) (*DiffResult, error) {
-	aOut, err := ApplyNormalizers(a.Stdout, s.Normalize.Stdout)
-	if err != nil {
-		return nil, err
-	}
-	bOut, err := ApplyNormalizers(b.Stdout, s.Normalize.Stdout)
-	if err != nil {
-		return nil, err
-	}
-	aErr, err := normalizeStderr(a.Stderr, s.Normalize.Stderr)
-	if err != nil {
-		return nil, err
-	}
-	bErr, err := normalizeStderr(b.Stderr, s.Normalize.Stderr)
-	if err != nil {
-		return nil, err
-	}
-
-	res := &DiffResult{Equal: true}
-	if a.ExitCode != b.ExitCode {
-		res.Equal = false
-		res.ExitCodeDelta = fmt.Sprintf("exit code: a=%d b=%d", a.ExitCode, b.ExitCode)
-	}
-	if aOut != bOut {
-		res.Equal = false
-		res.StdoutDelta = fmt.Sprintf("stdout diverges:\n--- a\n%s\n--- b\n%s", aOut, bOut)
-	}
-	if aErr != bErr {
-		res.Equal = false
-		res.StderrDelta = fmt.Sprintf("stderr diverges:\n--- a\n%s\n--- b\n%s", aErr, bErr)
-	}
-	if !res.Equal && s.ExpectedDrift != nil {
-		got := driftSignature(a.ExitCode, aOut, aErr, b.ExitCode, bOut, bErr)
-		if got != s.ExpectedDrift.Signature {
-			// Print what actually diverged, not just the hashes. A bare pair of
-			// signatures tells you a blessed drift moved but not how, which turns
-			// every mismatch into a bisect. This is the normalized output the
-			// signature was taken over, so what you read here is exactly what was
-			// hashed.
-			return nil, fmt.Errorf(
-				"expected_drift signature mismatch: recorded=%s actual=%s\n"+
-					"normalized a (Node): exit=%d\n--- stdout\n%s\n--- stderr\n%q\n"+
-					"normalized b (Go):   exit=%d\n--- stdout\n%s\n--- stderr\n%q",
-				s.ExpectedDrift.Signature, got,
-				a.ExitCode, aOut, aErr,
-				b.ExitCode, bOut, bErr,
-			)
-		}
-	}
-	return res, nil
-}
-
-func driftSignature(nodeExit int, nodeStdout, nodeStderr string, goExit int, goStdout, goStderr string) string {
-	h := sha256.New()
-	write := func(label string, value string) {
-		_, _ = fmt.Fprintf(h, "%s:%d:", label, len(value))
-		_, _ = io.WriteString(h, value)
-	}
-	write("node-exit", fmt.Sprintf("%d", nodeExit))
-	write("node-stdout", nodeStdout)
-	write("node-stderr", nodeStderr)
-	write("go-exit", fmt.Sprintf("%d", goExit))
-	write("go-stdout", goStdout)
-	write("go-stderr", goStderr)
-	return hex.EncodeToString(h.Sum(nil))
-}

package/internal/parity/diff_test.go

@@ -1,155 +0,0 @@
-//go:build parity
-
-package parity
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestApplyNormalizersStdout(t *testing.T) {
-	rules := []NormalizeRule{
-		{Pattern: `vip-next \S+ \(commit \S+\)`, Replacement: `vip-next <VERSION> (commit <COMMIT>)`},
-	}
-	in := "vip-next 1.2.3 (commit abcdef1)\n"
-	got, err := ApplyNormalizers(in, rules)
-	if err != nil {
-		t.Fatalf("ApplyNormalizers: %v", err)
-	}
-	want := "vip-next <VERSION> (commit <COMMIT>)\n"
-	if got != want {
-		t.Errorf("got %q, want %q", got, want)
-	}
-}
-
-func TestDiffResultEqualWhenNormalized(t *testing.T) {
-	scenario := &Scenario{
-		Argv: []string{"--version"},
-	}
-	scenario.Normalize.Stdout = []NormalizeRule{
-		{Pattern: `vip-next \S+ \(commit \S+\)`, Replacement: `vip-next <X> (commit <Y>)`},
-	}
-	a := &RunResult{ExitCode: 0, Stdout: "vip-next 1.0.0 (commit abcd1234)\n"}
-	b := &RunResult{ExitCode: 0, Stdout: "vip-next 1.0.0 (commit deadbeef)\n"}
-
-	d, err := Diff(scenario, a, b)
-	if err != nil {
-		t.Fatalf("Diff: %v", err)
-	}
-	if !d.Equal {
-		t.Errorf("expected Equal after normalization; got %+v", d)
-	}
-}
-
-func TestDiffResultUnequalOnExitCode(t *testing.T) {
-	scenario := &Scenario{Argv: []string{"--version"}}
-	a := &RunResult{ExitCode: 0}
-	b := &RunResult{ExitCode: 1}
-
-	d, err := Diff(scenario, a, b)
-	if err != nil {
-		t.Fatalf("Diff: %v", err)
-	}
-	if d.Equal {
-		t.Errorf("expected !Equal on differing exit codes; got Equal")
-	}
-	if d.ExitCodeDelta == "" {
-		t.Errorf("expected ExitCodeDelta to describe the divergence")
-	}
-}
-
-func TestDiffRejectsAnAcceptedDriftWhoseOutputFingerprintChanged(t *testing.T) {
-	scenario := &Scenario{Argv: []string{"example"}}
-	scenario.ExpectedDrift = &ExpectedDrift{
-		Reason:    "intentional example",
-		Signature: strings.Repeat("0", 64),
-	}
-	node := &RunResult{ExitCode: 0, Stdout: "node output\n"}
-	goResult := &RunResult{ExitCode: 0, Stdout: "go output\n"}
-
-	_, err := Diff(scenario, node, goResult)
-	if err == nil || !strings.Contains(err.Error(), "expected_drift signature mismatch") {
-		t.Fatalf("Diff error = %v, want expected_drift signature mismatch", err)
-	}
-}
-
-// The keychain fallback notice is environment noise, not a behavioural
-// divergence: on a headless Linux runner there is no D-Bus secret service, so
-// vip-next reports that it fell back to a 0600 file and the Node CLI — which
-// has no equivalent concept — says nothing. Before this was normalized away,
-// it failed 32 of the differential scenarios on Linux while every one of them
-// passed on a developer's macOS machine.
-func TestDiffIgnoresTheAmbientKeychainFallbackNotice(t *testing.T) {
-	scenario := &Scenario{Argv: []string{"app", "list"}}
-	node := &RunResult{ExitCode: 0, Stdout: "same\n"}
-	goResult := &RunResult{
-		ExitCode: 0,
-		Stdout:   "same\n",
-		Stderr:   "warning: OS keyring unavailable; storing credentials in /home/runner/.config/vip/credentials.json (0600)\n",
-	}
-
-	d, err := Diff(scenario, node, goResult)
-	if err != nil {
-		t.Fatalf("Diff: %v", err)
-	}
-	if !d.Equal {
-		t.Errorf("keychain fallback notice must not count as a divergence; got %+v", d)
-	}
-}
-
-// The ambient rule is deliberately narrow. A real message on stderr — including
-// one that merely mentions the keyring — must still diverge, or the normalizer
-// would be hiding the very thing the harness exists to catch.
-func TestDiffStillReportsRealStderrDivergence(t *testing.T) {
-	scenario := &Scenario{Argv: []string{"app", "list"}}
-	node := &RunResult{ExitCode: 0, Stdout: "same\n"}
-	goResult := &RunResult{
-		ExitCode: 0,
-		Stdout:   "same\n",
-		Stderr:   "Error: could not read credentials from the OS keyring\n",
-	}
-
-	d, err := Diff(scenario, node, goResult)
-	if err != nil {
-		t.Fatalf("Diff: %v", err)
-	}
-	if d.Equal {
-		t.Error("a real stderr message must still diverge")
-	}
-	if d.StderrDelta == "" {
-		t.Error("expected StderrDelta to describe the divergence")
-	}
-}
-
-// The notice must be stripped before the drift signature is computed, or an
-// accepted divergence would fingerprint differently on Linux than on macOS and
-// every expected_drift scenario would fail on exactly one of the two.
-func TestAmbientNoticeIsStrippedBeforeTheDriftSignature(t *testing.T) {
-	mk := func(stderr string) (*Scenario, *RunResult, *RunResult) {
-		s := &Scenario{Argv: []string{"app", "list"}}
-		return s,
-			&RunResult{ExitCode: 0, Stdout: "node\n"},
-			&RunResult{ExitCode: 1, Stdout: "go\n", Stderr: stderr}
-	}
-
-	clean, a1, b1 := mk("")
-	noisy, a2, b2 := mk("warning: OS keyring unavailable; storing credentials in /home/runner/.config/vip/credentials.json (0600)\n")
-
-	// Capture the signature each case produces by asserting against a wrong one.
-	sig := func(s *Scenario, a, b *RunResult) string {
-		s.ExpectedDrift = &ExpectedDrift{Reason: "x", Signature: strings.Repeat("0", 64)}
-		_, err := Diff(s, a, b)
-		if err == nil {
-			t.Fatal("expected a signature mismatch to read the actual signature from")
-		}
-		_, actual, found := strings.Cut(err.Error(), "actual=")
-		if !found {
-			t.Fatalf("unexpected error shape: %v", err)
-		}
-		return actual
-	}
-
-	if got, want := sig(noisy, a2, b2), sig(clean, a1, b1); got != want {
-		t.Errorf("signature differs with the ambient notice present:\n with = %s\nwithout = %s", got, want)
-	}
-}

package/internal/parity/differential_test.go

@@ -1,166 +0,0 @@
-//go:build parity
-
-package parity
-
-import (
-	"errors"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"sync"
-	"sync/atomic"
-	"testing"
-)
-
-// The shared Node-vs-Go rig.
-//
-// WHY A SINGLETON
-//
-// Every differential scenario needs the Node CLI authenticated, and since
-// trunk 4.1.0 the ONLY way to authenticate it is a real credential-store write
-// (Token.get reads getKeychain() and nothing else; there has never been an env
-// escape hatch — see keychain.go). Node derives the service name from
-// API_HOST, so a per-scenario httptest server means a per-scenario service
-// name: 30-odd credentials created and destroyed per run, 30-odd chances to
-// leak one, and 30-odd chances for a SIGKILL to strand one. A previous
-// incarnation of that pattern left 727 orphaned entries to be purged by hand.
-//
-// So the whole test binary shares ONE httptest server, therefore ONE API_HOST,
-// therefore ONE seeded credential — written once before the first differential
-// runs and deleted once after the last one finishes. The count of credentials
-// a full run creates is a constant, not a function of how many scenarios
-// exist, which is the property that keeps "before == after" true as scenarios
-// are added.
-//
-// The cost is that the server's handler has to change per scenario. It is held
-// in an atomic and swapped by each subtest; differential subtests therefore
-// MUST NOT call t.Parallel(). TestDifferentialScenariosAreSequential documents
-// and does not enforce that — the swap itself is race-free, but two scenarios
-// interleaving would serve each other's recordings.
-type differentialRig struct {
-	nodeBin string
-	goBin   string
-	srv     *httptest.Server
-	handler atomic.Pointer[http.Handler]
-	token   string
-
-	// binDir is removed at teardown; the built binary has to outlive whichever
-	// test happened to construct the rig.
-	binDir string
-}
-
-var (
-	rigOnce  sync.Once
-	rig      *differentialRig
-	rigSkip  string
-	rigFatal error
-)
-
-// differentialAvailable returns the shared rig, or a reason to skip.
-//
-// Callers must treat a non-empty skip reason as a LOUD skip (LoudSkip), never
-// as a pass: on a host where the Node CLI cannot be run or its credential
-// store cannot be driven, the differential compares nothing, and a silent
-// green there is precisely the failure this whole area exists to remove.
-func differentialAvailable(t *testing.T) (*differentialRig, string) {
-	t.Helper()
-	rigOnce.Do(setupDifferentialRig)
-	if rigFatal != nil {
-		// A harness bug (a bad build, a service-name derivation that has
-		// drifted from Node's) is not a hostile environment. Fail.
-		t.Fatalf("differential rig: %v", rigFatal)
-	}
-	return rig, rigSkip
-}
-
-func setupDifferentialRig() {
-	node := ResolveNodeVipBin(os.Getenv("NODE_VIP_BIN"), DefaultNodeVipBinProbe())
-	if !node.Ready {
-		rigSkip = node.Reason
-		return
-	}
-
-	binDir, err := os.MkdirTemp("", "vip-next-differential")
-	if err != nil {
-		rigFatal = fmt.Errorf("temp dir for the Go binary: %w", err)
-		return
-	}
-	goBin, err := buildVipNextInto(binDir, "test", "test")
-	if err != nil {
-		_ = os.RemoveAll(binDir)
-		rigFatal = err
-		return
-	}
-
-	r := &differentialRig{nodeBin: node.Path, goBin: goBin, binDir: binDir, token: FixtureToken()}
-	r.srv = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
-		h := r.handler.Load()
-		if h == nil {
-			// A request outside any scenario is a harness bug, not data.
-			// Answer with something that cannot be mistaken for a payload.
-			w.Header().Set("Content-Type", "application/json")
-			w.WriteHeader(http.StatusInternalServerError)
-			_, _ = w.Write([]byte(`{"errors":[{"message":"parity: no scenario handler installed"}]}`))
-			return
-		}
-		(*h).ServeHTTP(w, req)
-	}))
-
-	// Publish the rig BEFORE seeding, so teardown collects a partial write.
-	rig = r
-
-	switch err := SeedNodeKeychainToken(r.nodeBin, r.srv.URL, r.token); {
-	case errors.Is(err, ErrKeychainSeedMismatch):
-		rigFatal = fmt.Errorf("seeding the Node credential: %w", err)
-	case err != nil:
-		rigSkip = "the credential store could not be driven, and the Node CLI has no other " +
-			"way to authenticate (it has never had an environment escape hatch). Details: " +
-			err.Error()
-	}
-}
-
-// teardownDifferentialRig is called from TestMain AFTER m.Run(). It is the
-// only place the shared credential is removed, and it runs whether the suite
-// passed, failed, or panicked out of an individual test.
-func teardownDifferentialRig() {
-	if rig == nil {
-		return
-	}
-	if rig.srv != nil {
-		rig.srv.Close()
-	}
-	if err := CleanupParityCredentials(rig.nodeBin, rig.srv.URL); err != nil {
-		fmt.Fprintf(os.Stderr, "parity differential: credential cleanup failed: %v\n", err)
-	}
-	if rig.binDir != "" {
-		_ = os.RemoveAll(rig.binDir)
-	}
-}
-
-// serve installs h as the handler for the rest of the current subtest and
-// restores the previous one afterwards.
-func (r *differentialRig) serve(t *testing.T, h http.Handler) {
-	t.Helper()
-	previous := r.handler.Load()
-	r.handler.Store(&h)
-	t.Cleanup(func() { r.handler.Store(previous) })
-}
-
-// scenarioEnv is the environment both binaries get: the scenario's own
-// overrides, plus the shared API_HOST, plus the Go-side token.
-//
-// The two CLIs receive the SAME credential by two different routes — Node from
-// the seeded store, Go from VIP_TOKEN_OVERRIDE under GO_ENV=test. Minting it
-// once and handing the same string to both is what keeps these scenarios a
-// test of command output rather than of credential plumbing, and it is what
-// lets the ~50 mock-only scenarios stay off the credential store entirely.
-func (r *differentialRig) scenarioEnv(s *Scenario) map[string]string {
-	env := map[string]string{}
-	for k, v := range s.Env {
-		env[k] = v
-	}
-	env["API_HOST"] = r.srv.URL
-	env["VIP_TOKEN_OVERRIDE"] = r.token
-	return env
-}

package/internal/parity/edge_workers_build_smoke_test.go

@@ -1,69 +0,0 @@
-//go:build parity && edgeworkers_build_smoke
-
-package parity
-
-import (
-	"bytes"
-	"os"
-	"path/filepath"
-	"reflect"
-	"testing"
-)
-
-// Opt-in only: downloads the pinned SDK/compiler into owned temporary projects.
-func TestEdgeWorkersRealCompilerSmoke(t *testing.T) {
-	rig, skip := differentialAvailable(t)
-	if skip != "" {
-		t.Skip(LoudSkip("Edge Workers real compiler smoke", skip))
-	}
-	api := newEdgeFixtureAPI("empty")
-	rig.serve(t, api)
-	env := FixtureEnv(rig.scenarioEnv(&Scenario{Env: map[string]string{"NO_COLOR": "1", "VIP_NON_INTERACTIVE": "1"}}))
-	roots := []string{edgeFixtureProject(t, "empty"), edgeFixtureProject(t, "empty")}
-	trees := make([]map[string]string, 2)
-	artifacts := make([][]byte, 2)
-	run := func(bin, dir string, args ...string) {
-		t.Helper()
-		result, err := Run(RunSpec{Binary: bin, Dir: dir, Argv: args, Env: env})
-		if err != nil {
-			t.Fatal(err)
-		}
-		if result.ExitCode != 0 {
-			t.Fatalf("%s %v: %s\n%s", bin, args, result.Stdout, result.Stderr)
-		}
-	}
-	for i, bin := range []string{rig.nodeBin, rig.goBin} {
-		run(bin, roots[i], "edge-workers", "init", ".")
-		run(bin, roots[i], "edge-workers", "new", "headers")
-		trees[i] = edgeTree(t, roots[i])
-		if i == 0 {
-			run("npm", roots[i], "install", "--no-audit", "--no-fund")
-		} else {
-			lock, err := os.ReadFile(filepath.Join(roots[0], "package-lock.json"))
-			if err != nil {
-				t.Fatal(err)
-			}
-			edgeWrite(t, roots[i], "package-lock.json", lock, 0644)
-			run("npm", roots[i], "ci", "--no-audit", "--no-fund")
-		}
-		run(bin, roots[i], "edge-workers", "build", "headers")
-		file := filepath.Join(roots[i], "build/headers.wasm")
-		artifact, err := os.ReadFile(file)
-		if err != nil || len(artifact) == 0 {
-			t.Fatalf("artifact %v", err)
-		}
-		artifacts[i] = artifact
-		run("node", roots[i], "-e", `const fs=require('node:fs');const m=new WebAssembly.Module(fs.readFileSync(process.argv[1]));const names=WebAssembly.Module.exports(m).filter(x=>x.kind==='function').map(x=>x.name).sort();if(JSON.stringify(names)!==JSON.stringify(['alloc','on_client_response']))throw Error('Unexpected exports: '+JSON.stringify(names));`, file)
-		t.Logf("runtime %d compiled %d bytes with only alloc/on_client_response exports", i, len(artifact))
-	}
-	if !reflect.DeepEqual(trees[0], trees[1]) {
-		t.Fatal("real scaffold files differ")
-	}
-	if !bytes.Equal(artifacts[0], artifacts[1]) {
-		t.Fatal("real compiler artifacts differ")
-	}
-	ops, requests := api.snapshot()
-	if len(ops) != 0 || len(requests) != 0 {
-		t.Fatalf("local build issued API requests: %v", ops)
-	}
-}

package/internal/parity/edge_workers_cases_test.go

@@ -1,77 +0,0 @@
-//go:build parity
-
-package parity
-
-// Each case runs both real roots; expected writes are asserted independently.
-var edgeWorkerScenarios = map[string]edgeWorkerCase{
-	"edge-workers-init":                           {Fixture: "empty", State: "empty", WantPersistentOps: []string{}, WantExit: 0},
-	"edge-workers-init-nonempty":                  {Fixture: "basic", State: "empty", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-init-invalid-type":              {Fixture: "empty", State: "empty", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-new":                            {Fixture: "basic", State: "empty", WantPersistentOps: []string{}, WantExit: 0},
-	"edge-workers-new-location":                   {Fixture: "basic", State: "empty", WantPersistentOps: []string{}, WantExit: 0},
-	"edge-workers-new-invalid-location":           {Fixture: "basic", State: "empty", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-new-invalid-name":               {Fixture: "basic", State: "empty", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-build-missing-compiler":         {Fixture: "basic", State: "empty", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-build-empty":                    {Fixture: "no-workers", State: "empty", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-build-name-all":                 {Fixture: "basic", State: "empty", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-build-one":                      {Fixture: "compiler", State: "empty", WantPersistentOps: []string{}, WantExit: 0},
-	"edge-workers-build-all":                      {Fixture: "two-compiler", State: "empty", WantPersistentOps: []string{}, WantExit: 0},
-	"edge-workers-build-compiler-error":           {Fixture: "compiler-error", State: "empty", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-list-table":                     {Fixture: "basic", State: "inactive", WantPersistentOps: []string{}, WantExit: 0},
-	"edge-workers-list-csv":                       {Fixture: "basic", State: "inactive", WantPersistentOps: []string{}, WantExit: 0},
-	"edge-workers-list-json":                      {Fixture: "basic", State: "inactive", WantPersistentOps: []string{}, WantExit: 0},
-	"edge-workers-list-empty":                     {Fixture: "basic", State: "empty", WantPersistentOps: []string{}, WantExit: 0},
-	"edge-workers-list-empty-json":                {Fixture: "basic", State: "empty", WantPersistentOps: []string{}, WantExit: 0},
-	"edge-workers-get":                            {Fixture: "basic", State: "inactive", WantPersistentOps: []string{}, WantExit: 0},
-	"edge-workers-get-source":                     {Fixture: "basic", State: "formatted-source", WantPersistentOps: []string{}, WantExit: 0},
-	"edge-workers-get-empty-source":               {Fixture: "basic", State: "empty-source", WantPersistentOps: []string{}, WantExit: 0},
-	"edge-workers-get-missing":                    {Fixture: "basic", State: "inactive", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-read-null":                      {Fixture: "basic", State: "null-read", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-validate":                       {Fixture: "basic", State: "empty", WantPersistentOps: []string{}, WantExit: 0},
-	"edge-workers-validate-invalid":               {Fixture: "basic", State: "invalid-validation", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-validate-all":                   {Fixture: "two-workers", State: "empty", WantPersistentOps: []string{}, WantExit: 0},
-	"edge-workers-validate-name-all":              {Fixture: "basic", State: "empty", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-validate-no-name":               {Fixture: "basic", State: "empty", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-validate-no-artifact":           {Fixture: "no-artifact", State: "empty", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-validate-null":                  {Fixture: "basic", State: "null-validation", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-deploy-create":                  {Fixture: "basic", State: "empty", WantPersistentOps: []string{"create:headers"}, WantExit: 0},
-	"edge-workers-deploy-create-enable":           {Fixture: "basic", State: "empty", WantPersistentOps: []string{"create:headers", "enable:headers"}, WantExit: 0},
-	"edge-workers-deploy-inactive-update":         {Fixture: "basic", State: "inactive", WantPersistentOps: []string{"update:headers"}, WantExit: 0},
-	"edge-workers-deploy-inactive-update-enable":  {Fixture: "basic", State: "inactive", WantPersistentOps: []string{"update:headers", "enable:headers"}, WantExit: 0},
-	"edge-workers-deploy-active-update":           {Fixture: "basic", State: "active", WantPersistentOps: []string{"update:headers"}, WantExit: 0},
-	"edge-workers-deploy-active-update-enable":    {Fixture: "basic", State: "active", WantPersistentOps: []string{"update:headers"}, WantExit: 0},
-	"edge-workers-deploy-location-preserve":       {Fixture: "location-preserve", State: "inactive", WantPersistentOps: []string{"update:headers"}, WantExit: 0},
-	"edge-workers-deploy-location-clear":          {Fixture: "location-clear", State: "inactive", WantPersistentOps: []string{"update:headers"}, WantExit: 0},
-	"edge-workers-deploy-location-replace":        {Fixture: "location-replace", State: "inactive", WantPersistentOps: []string{"update:headers"}, WantExit: 0},
-	"edge-workers-deploy-source-empty":            {Fixture: "source-empty", State: "empty", WantPersistentOps: []string{"create:headers"}, WantExit: 0},
-	"edge-workers-deploy-skip-source":             {Fixture: "basic", State: "inactive", WantPersistentOps: []string{"update:headers"}, WantExit: 0},
-	"edge-workers-deploy-all-preparation-failure": {Fixture: "two-workers", State: "invalid-second", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-deploy-upload-failure":          {Fixture: "two-workers", State: "upload-second-fails", WantPersistentOps: []string{"create:a", "create:b"}, WantExit: 1},
-	"edge-workers-deploy-enable-failure":          {Fixture: "two-workers", State: "enable-fails", WantPersistentOps: []string{"create:a", "enable:a"}, WantExit: 1},
-	"edge-workers-deploy-production-refused":      {Fixture: "basic", State: "empty", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-deploy-name-all":                {Fixture: "basic", State: "empty", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-enable":                         {Fixture: "basic", State: "inactive", WantPersistentOps: []string{"enable:headers"}, WantExit: 0},
-	"edge-workers-enable-production-refused":      {Fixture: "basic", State: "inactive", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-disable":                        {Fixture: "basic", State: "active", WantPersistentOps: []string{"disable:headers"}, WantExit: 0},
-	"edge-workers-delete-force":                   {Fixture: "basic", State: "inactive", WantPersistentOps: []string{"delete:headers"}, WantExit: 0},
-	"edge-workers-delete-rejected":                {Fixture: "basic", State: "false-delete", WantPersistentOps: []string{"delete:headers"}, WantExit: 1},
-	"edge-workers-mutation-null":                  {Fixture: "basic", State: "null-mutation", WantPersistentOps: []string{"enable:headers"}, WantExit: 1},
-	"edge-workers-mutation-graphql-error":         {Fixture: "basic", State: "graphql-error", WantPersistentOps: []string{"enable:headers"}, WantExit: 1},
-	"edge-workers-bare-path":                      {Fixture: "basic", State: "empty", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-bare-location":                  {Fixture: "basic", State: "empty", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-short-equals":                   {Fixture: "basic", State: "empty", WantPersistentOps: []string{}, WantExit: 0},
-	"edge-workers-double-dash":                    {Fixture: "basic", State: "empty", WantPersistentOps: []string{}, WantExit: 0},
-	"edge-workers-duplicate-names":                {Fixture: "duplicates", State: "empty", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-entry-escape":                   {Fixture: "entry-escape", State: "empty", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-artifact-symlink":               {Fixture: "artifact-symlink", State: "empty", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-repeated-path":                  {Fixture: "basic", State: "empty", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-repeated-type":                  {Fixture: "basic", State: "empty", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-bare-type":                      {Fixture: "basic", State: "empty", WantPersistentOps: []string{}, WantExit: 1},
-	"edge-workers-unicode-order":                  {Fixture: "unicode-compiler", State: "empty", WantPersistentOps: []string{}, WantExit: 0},
-	"edge-workers-json-control-name":              {Fixture: "basic", State: "control-name", WantPersistentOps: []string{}, WantExit: 0},
-	"edge-workers-table-control-name":             {Fixture: "basic", State: "control-name", WantPersistentOps: []string{}, WantExit: 0},
-	"edge-workers-get-no-source":                  {Fixture: "basic", State: "no-source", WantPersistentOps: []string{}, WantExit: 0},
-	"edge-workers-deploy-production-skip":         {Fixture: "basic", State: "empty", WantPersistentOps: []string{"create:headers"}, WantExit: 0},
-	"edge-workers-deploy-skip-validate":           {Fixture: "basic", State: "empty", WantPersistentOps: []string{"create:headers"}, WantExit: 0},
-	"edge-workers-deploy-skip-source-create":      {Fixture: "basic", State: "empty", WantPersistentOps: []string{"create:headers"}, WantExit: 0},
-}