@automattic/vip 4.1.5 → 4.1.6

package/internal/devenv/postimport_test.go

@@ -1,389 +0,0 @@
-package devenv
-
-import (
-	"bytes"
-	"context"
-	"errors"
-	"io"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/Automattic/vip/internal/devenv/dockercli"
-	"github.com/Automattic/vip/internal/devenv/instancedata"
-)
-
-// fakeExecer records every compose invocation and can fail a chosen wp
-// subcommand, so the post-import sequence is testable with no Docker.
-type fakeExecer struct {
-	calls [][]string
-	// failOn fails any call whose joined argv contains this substring.
-	failOn string
-}
-
-func (f *fakeExecer) Compose(_ context.Context, _ string, args ...string) error {
-	f.calls = append(f.calls, args)
-	if f.failOn != "" && strings.Contains(strings.Join(args, " "), f.failOn) {
-		return errors.New("boom")
-	}
-	return nil
-}
-
-func (f *fakeExecer) joined() []string {
-	out := make([]string, len(f.calls))
-	for i, c := range f.calls {
-		out[i] = strings.Join(c, " ")
-	}
-	return out
-}
-
-// Register 2.20. Node's DevEnvImportSQLCommand.run() does NOT stop at the
-// `wp db import`: it flushes the object cache, reindexes Elasticsearch,
-// (re)creates the `vipgo` admin user and runs the VIP data cleanup
-// (src/commands/dev-env-import-sql.ts:128-142). vip-next skipped all of it,
-// which is why a user is locked out of their own local wp-admin after an
-// import. This pins the steps, their order and their exact argv.
-func TestPostImportStepsRunsNodeSequence(t *testing.T) {
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-	if err := instancedata.Write("e", &instancedata.InstanceData{
-		SiteSlug: "e", Multisite: []byte("false"), AdminPassword: "seededpass1",
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	f := &fakeExecer{}
-	if err := postImportSteps(context.Background(), f, "e", postImportOptions{}, &bytes.Buffer{}); err != nil {
-		t.Fatalf("postImportSteps: %v", err)
-	}
-
-	want := []string{
-		"exec -T php wp --allow-root cache flush --skip-plugins --skip-themes",
-		"exec -T php wp --allow-root cli has-command vip-search",
-		"exec -T php wp --allow-root vip-search index --setup --network-wide --skip-confirm",
-		"exec -T php wp --allow-root dev-env-add-admin --username=vipgo --password=seededpass1 --skip-plugins --skip-themes",
-		"exec -T php wp --allow-root vip data-cleanup sql-import",
-	}
-	got := f.joined()
-	if len(got) != len(want) {
-		t.Fatalf("post-import ran %d steps, want %d:\n got %v\nwant %v", len(got), len(want), got, want)
-	}
-	for i := range want {
-		if got[i] != want[i] {
-			t.Errorf("step %d =\n %q\nwant %q", i, got[i], want[i])
-		}
-	}
-}
-
-// Node appends --quiet to flushCache, addAdminUser and dataCleanup from the
-// `quiet` argument — except that import-sql calls addAdminUser WITHOUT it
-// (dev-env-import-sql.ts:141 passes only lando+slug), so the admin step is
-// never quiet. Node's own inconsistency; matched deliberately.
-func TestPostImportStepsQuietMatchesNodeArgumentPassing(t *testing.T) {
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-	if err := instancedata.Write("e", &instancedata.InstanceData{
-		SiteSlug: "e", Multisite: []byte("false"), AdminPassword: "seededpass1",
-	}); err != nil {
-		t.Fatal(err)
-	}
-
-	f := &fakeExecer{}
-	if err := postImportSteps(context.Background(), f, "e", postImportOptions{Quiet: true}, &bytes.Buffer{}); err != nil {
-		t.Fatalf("postImportSteps: %v", err)
-	}
-	got := f.joined()
-	want := []string{
-		"exec -T php wp --allow-root cache flush --skip-plugins --skip-themes --quiet",
-		"exec -T php wp --allow-root cli has-command vip-search",
-		"exec -T php wp --allow-root vip-search index --setup --network-wide --skip-confirm",
-		"exec -T php wp --allow-root dev-env-add-admin --username=vipgo --password=seededpass1 --skip-plugins --skip-themes",
-		"exec -T php wp --allow-root vip data-cleanup sql-import --quiet",
-	}
-	for i := range want {
-		if i >= len(got) || got[i] != want[i] {
-			t.Errorf("quiet step %d = %q, want %q", i, safeIdx(got, i), want[i])
-		}
-	}
-}
-
-func safeIdx(s []string, i int) string {
-	if i < len(s) {
-		return s[i]
-	}
-	return "<missing>"
-}
-
-// fakeImportRunner is a full stand-in for dockercli.Runner covering everything
-// the import path touches, so the whole ImportSQL sequence runs with no Docker.
-type fakeImportRunner struct {
-	fakeExecer
-	docker  [][]string
-	stdin   [][]string
-	failOnD string
-	// psStates is what ComposePS returns once psSet is true (psSet exists so a
-	// test can assert on an EMPTY service list — a never-started environment).
-	// Unset means php + database running, the normal case.
-	psStates []dockercli.ServiceState
-	psSet    bool
-	psErr    error
-}
-
-func (f *fakeImportRunner) ComposePS(_ context.Context, _ string) ([]dockercli.ServiceState, error) {
-	if f.psErr != nil {
-		return nil, f.psErr
-	}
-	if f.psSet {
-		return f.psStates, nil
-	}
-	return []dockercli.ServiceState{
-		{Service: "php", State: "running"},
-		{Service: "database", State: "running"},
-	}, nil
-}
-
-func (f *fakeImportRunner) Docker(_ context.Context, args ...string) error {
-	f.docker = append(f.docker, args)
-	if f.failOnD != "" && strings.Contains(strings.Join(args, " "), f.failOnD) {
-		return errors.New("boom")
-	}
-	return nil
-}
-
-func (f *fakeImportRunner) ComposeStdin(_ context.Context, _ string, _ io.Reader, args ...string) error {
-	f.stdin = append(f.stdin, args)
-	return nil
-}
-
-func (f *fakeImportRunner) ComposeOut(_ context.Context, _ string, args ...string) ([]byte, error) {
-	if len(args) > 0 && args[0] == "ps" {
-		return []byte("containerid123\n"), nil
-	}
-	return nil, nil
-}
-
-func seedImportEnv(t *testing.T) {
-	t.Helper()
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-	if err := instancedata.Write("e", &instancedata.InstanceData{
-		SiteSlug: "e", Multisite: []byte("false"), AdminPassword: "seededpass1",
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-// writeDump produces a dump that passes the dev-env SQL validation (which now
-// runs on this path): DROP TABLE + CREATE TABLE + AUTO_INCREMENT present, a
-// wp_ prefix, InnoDB, and no siteurl pointing away from the environment.
-func writeDump(t *testing.T) string {
-	t.Helper()
-	p := filepath.Join(t.TempDir(), "dump.sql")
-	body := strings.Join([]string{
-		"-- MySQL dump 10.13",
-		"DROP TABLE IF EXISTS `wp_options`;",
-		"CREATE TABLE `wp_options` (",
-		"  `option_id` bigint(20) unsigned NOT NULL AUTO_INCREMENT,",
-		"  PRIMARY KEY (`option_id`)",
-		") ENGINE=InnoDB DEFAULT CHARSET=utf8mb4;",
-	}, "\n") + "\n"
-	if err := os.WriteFile(p, []byte(body), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	return p
-}
-
-// Register 2.20 (wiring): the post-import steps must actually run at the end of
-// `dev-env import sql`, not merely exist. Before this fix the import stopped at
-// `wp db import` and the user was locked out of their local wp-admin.
-func TestImportSQLRunsPostImportSteps(t *testing.T) {
-	seedImportEnv(t)
-	f := &fakeImportRunner{}
-	if err := importSQL(context.Background(), f, "e", writeDump(t), ImportOptions{}); err != nil {
-		t.Fatalf("importSQL: %v", err)
-	}
-	all := strings.Join(f.joined(), "\n")
-	for _, want := range []string{
-		"wp --allow-root db import",
-		"cache flush",
-		"dev-env-add-admin --username=vipgo",
-		"vip data-cleanup sql-import",
-	} {
-		if !strings.Contains(all, want) {
-			t.Errorf("import sql did not run %q; ran:\n%s", want, all)
-		}
-	}
-	// Order: the import itself must come first.
-	if i, j := strings.Index(all, "db import"), strings.Index(all, "cache flush"); i < 0 || j < 0 || i > j {
-		t.Errorf("post-import steps must follow the import, got:\n%s", all)
-	}
-}
-
-// The MyDumper path shares Node's run(), so it gets the same post-import steps.
-// vip-next's importMyDumperDump returned early, skipping all of them.
-func TestImportSQLMyDumperRunsPostImportSteps(t *testing.T) {
-	seedImportEnv(t)
-	p := filepath.Join(t.TempDir(), "dump.sql")
-	// A MyDumper stream skips dropTable/dropDB but still has to satisfy the
-	// createTable / autoIncrement required checks.
-	body := "-- metadata.header 1\n-- mydb-schema-create.sql 0\n" +
-		"CREATE TABLE `wp_options` (`option_id` bigint(20) NOT NULL AUTO_INCREMENT, PRIMARY KEY (`option_id`)) ENGINE=InnoDB;\n"
-	if err := os.WriteFile(p, []byte(body), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	f := &fakeImportRunner{}
-	if err := importSQL(context.Background(), f, "e", p, ImportOptions{}); err != nil {
-		t.Fatalf("importSQL: %v", err)
-	}
-	if len(f.stdin) == 0 {
-		t.Fatal("expected the myloader stream path to be taken")
-	}
-	if !strings.Contains(strings.Join(f.joined(), "\n"), "dev-env-add-admin --username=vipgo") {
-		t.Errorf("MyDumper import skipped the vipgo admin user; ran:\n%v", f.joined())
-	}
-}
-
-// Node prints "Success: Database imported." after the import unless --quiet
-// (dev-env-import-sql.ts:117). vip-next printed nothing at all.
-func TestImportSQLPrintsSuccessUnlessQuiet(t *testing.T) {
-	seedImportEnv(t)
-	var out bytes.Buffer
-	f := &fakeImportRunner{}
-	if err := importSQL(context.Background(), f, "e", writeDump(t), ImportOptions{Out: &out}); err != nil {
-		t.Fatal(err)
-	}
-	if !strings.Contains(out.String(), "Database imported.") {
-		t.Errorf("missing Node's success line, got %q", out.String())
-	}
-
-	seedImportEnv(t)
-	out.Reset()
-	if err := importSQL(context.Background(), &fakeImportRunner{}, "e", writeDump(t), ImportOptions{Quiet: true, Out: &out}); err != nil {
-		t.Fatal(err)
-	}
-	if strings.Contains(out.String(), "Database imported.") {
-		t.Errorf("--quiet must suppress the success line, got %q", out.String())
-	}
-}
-
-// --skip-reindex must actually skip the Elasticsearch reindex (Node:
-// dev-env-import-sql.ts:130). It was a documented no-op in vip-next.
-func TestPostImportStepsSkipReindex(t *testing.T) {
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-	if err := instancedata.Write("e", &instancedata.InstanceData{
-		SiteSlug: "e", Multisite: []byte("false"), AdminPassword: "seededpass1",
-	}); err != nil {
-		t.Fatal(err)
-	}
-	f := &fakeExecer{}
-	if err := postImportSteps(context.Background(), f, "e", postImportOptions{SkipReindex: true}, &bytes.Buffer{}); err != nil {
-		t.Fatalf("postImportSteps: %v", err)
-	}
-	for _, c := range f.joined() {
-		if strings.Contains(c, "vip-search") {
-			t.Errorf("--skip-reindex still ran the reindex: %q", c)
-		}
-	}
-	// The admin user must still be created.
-	if !strings.Contains(strings.Join(f.joined(), "\n"), "dev-env-add-admin") {
-		t.Error("--skip-reindex must not skip the vipgo admin user")
-	}
-}
-
-// Node wraps reIndexSearch in try/catch with the comment "Exception means they
-// don't have vip-search enabled" — a missing vip-search must NOT fail the
-// import, and must not stop the admin user from being created.
-func TestPostImportStepsReindexFailureIsNotFatal(t *testing.T) {
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-	if err := instancedata.Write("e", &instancedata.InstanceData{
-		SiteSlug: "e", Multisite: []byte("false"), AdminPassword: "seededpass1",
-	}); err != nil {
-		t.Fatal(err)
-	}
-	f := &fakeExecer{failOn: "vip-search"}
-	if err := postImportSteps(context.Background(), f, "e", postImportOptions{}, &bytes.Buffer{}); err != nil {
-		t.Fatalf("a missing vip-search must not fail the import, got %v", err)
-	}
-	if !strings.Contains(strings.Join(f.joined(), "\n"), "dev-env-add-admin") {
-		t.Error("the admin user must still be created after a reindex failure")
-	}
-}
-
-// Node's dataCleanup catches its own error and prints "WARNING: data cleanup
-// failed." (dev-environment-database.ts:53-57) — it must not fail the import.
-func TestPostImportStepsDataCleanupFailureWarnsAndContinues(t *testing.T) {
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-	if err := instancedata.Write("e", &instancedata.InstanceData{
-		SiteSlug: "e", Multisite: []byte("false"), AdminPassword: "seededpass1",
-	}); err != nil {
-		t.Fatal(err)
-	}
-	var out bytes.Buffer
-	f := &fakeExecer{failOn: "data-cleanup"}
-	if err := postImportSteps(context.Background(), f, "e", postImportOptions{}, &out); err != nil {
-		t.Fatalf("data cleanup failure must not be fatal, got %v", err)
-	}
-	if !strings.Contains(out.String(), "WARNING: data cleanup failed.") {
-		t.Errorf("missing Node's warning, got %q", out.String())
-	}
-}
-
-// addAdminUser is NOT wrapped in Node — a failure there aborts run() and the
-// command exits 1. Being locked out must be loud, not silent.
-func TestPostImportStepsAdminUserFailureIsFatal(t *testing.T) {
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-	if err := instancedata.Write("e", &instancedata.InstanceData{
-		SiteSlug: "e", Multisite: []byte("false"), AdminPassword: "seededpass1",
-	}); err != nil {
-		t.Fatal(err)
-	}
-	f := &fakeExecer{failOn: "dev-env-add-admin"}
-	if err := postImportSteps(context.Background(), f, "e", postImportOptions{}, &bytes.Buffer{}); err == nil {
-		t.Error("a failed vipgo admin user must fail the command (Node does not catch it)")
-	}
-}
-
-// Node's flushCache is also uncaught (dev-env-import-sql.ts:128).
-func TestPostImportStepsFlushCacheFailureIsFatal(t *testing.T) {
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-	if err := instancedata.Write("e", &instancedata.InstanceData{
-		SiteSlug: "e", Multisite: []byte("false"), AdminPassword: "seededpass1",
-	}); err != nil {
-		t.Fatal(err)
-	}
-	f := &fakeExecer{failOn: "cache flush"}
-	if err := postImportSteps(context.Background(), f, "e", postImportOptions{}, &bytes.Buffer{}); err == nil {
-		t.Error("a failed cache flush must fail the command (Node does not catch it)")
-	}
-	if len(f.calls) != 1 {
-		t.Errorf("flush failure must abort before the later steps, ran %v", f.joined())
-	}
-}
-
-// Node's addAdminUser regenerates the password when instance data has none (or
-// the placeholder "password") and PERSISTS it, so `dev-env info` shows the
-// credentials that actually work (dev-environment-database.ts:23-43).
-func TestPostImportStepsGeneratesAndPersistsMissingAdminPassword(t *testing.T) {
-	for _, seeded := range []string{"", "password"} {
-		t.Run("seed="+seeded, func(t *testing.T) {
-			t.Setenv("XDG_DATA_HOME", t.TempDir())
-			if err := instancedata.Write("e", &instancedata.InstanceData{
-				SiteSlug: "e", Multisite: []byte("false"), AdminPassword: seeded,
-			}); err != nil {
-				t.Fatal(err)
-			}
-			f := &fakeExecer{}
-			if err := postImportSteps(context.Background(), f, "e", postImportOptions{}, &bytes.Buffer{}); err != nil {
-				t.Fatal(err)
-			}
-			d, err := instancedata.Read("e")
-			if err != nil {
-				t.Fatal(err)
-			}
-			if len(d.AdminPassword) != passwordLength || d.AdminPassword == seeded {
-				t.Fatalf("adminPassword not regenerated/persisted: %q", d.AdminPassword)
-			}
-			if !strings.Contains(strings.Join(f.joined(), "\n"), "--password="+d.AdminPassword) {
-				t.Errorf("wp was given a different password than the one persisted: %v", f.joined())
-			}
-		})
-	}
-}

package/internal/devenv/proxy/ca.go

@@ -1,110 +0,0 @@
-package proxy
-
-import (
-	"context"
-	_ "embed"
-	"errors"
-	"fmt"
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/Automattic/vip/internal/devenv/paths"
-)
-
-//go:embed scripts/gen-certs.sh
-var genCertsScript string
-
-// ProxyCertsVolume is the shared named volume that holds the CA and per-env
-// leaf certs (mounted at /certs on both the cert-gen one-shot and the proxy).
-const ProxyCertsVolume = "vip-dev-env-certs"
-
-// caContainerPath is where the CA PEM lives inside the proxy container.
-const caContainerPath = "/certs/lndo.site.pem"
-
-// CertRequest describes a per-environment leaf cert to generate.
-type CertRequest struct {
-	Basename   string   // base name for cert files (e.g. "example")
-	CommonName string   // cert subject CN; defaults to Basename if empty
-	SANs       []string // Subject Alternative Names
-}
-
-// validCertField rejects characters that would corrupt the openssl subject or
-// the space-split SAN list inside gen-certs.sh.
-func validCertField(s string) bool {
-	return s != "" && !strings.ContainsAny(s, " \t\r\n/")
-}
-
-// CAHostPath returns the host-side path where the CA PEM is extracted to.
-func CAHostPath() string {
-	return filepath.Join(paths.XDGData(), "vip", "dev-env", "proxy", "ca.pem")
-}
-
-// EnsureCA runs a one-shot container that idempotently generates the CA
-// (lndo.site.pem / lndo.site.key) in the shared certs volume.
-//
-// Both one-shot runs here override the image entrypoint with sh: the stock
-// Traefik entrypoint.sh probes whether $1 is a Traefik subcommand and, when it
-// is not, prints "= 'sh' is not a Traefik command: assuming shell execution."
-// to stderr before exec'ing anyway. Bypassing it drops that noise.
-func EnsureCA(ctx context.Context, r DockerRunner) error {
-	// Intentionally omits proxy_config: no CERT_BASENAME/CERT_SANS are passed,
-	// so the script's leaf-cert and Traefik YAML section is skipped entirely.
-	return r.Docker(ctx,
-		"run", "--rm",
-		"--entrypoint", "sh",
-		"-v", ProxyCertsVolume+":/certs",
-		ProxyImage,
-		"-c", genCertsScript,
-	)
-}
-
-// EnsureCert runs a one-shot container that generates a per-environment leaf
-// cert (signed by the CA) and writes a Traefik file-provider YAML into the
-// proxy_config volume. Returns an error if Basename or SANs are empty.
-func EnsureCert(ctx context.Context, r DockerRunner, req CertRequest) error {
-	if req.Basename == "" || len(req.SANs) == 0 {
-		return errors.New("proxy: EnsureCert requires Basename and SANs")
-	}
-	if !validCertField(req.Basename) {
-		return fmt.Errorf("proxy: invalid cert field %q", req.Basename)
-	}
-	if req.CommonName != "" && !validCertField(req.CommonName) {
-		return fmt.Errorf("proxy: invalid cert field %q", req.CommonName)
-	}
-	for _, san := range req.SANs {
-		if !validCertField(san) {
-			return fmt.Errorf("proxy: invalid cert field %q", san)
-		}
-	}
-
-	args := []string{
-		"run", "--rm",
-		"--entrypoint", "sh",
-		"-v", ProxyCertsVolume + ":/certs",
-		"-v", ProxyConfigVolume + ":/proxy_config",
-		"-e", "CERT_BASENAME=" + req.Basename,
-	}
-	if req.CommonName != "" {
-		args = append(args, "-e", "CERT_CN="+req.CommonName)
-	}
-	args = append(args,
-		"-e", "CERT_SANS="+strings.Join(req.SANs, " "),
-		ProxyImage,
-		"-c", genCertsScript,
-	)
-
-	return r.Docker(ctx, args...)
-}
-
-// ExtractCA docker-cp's the CA PEM from the running proxy container to dest
-// on the host. It creates dest's parent directory first and returns dest.
-func ExtractCA(ctx context.Context, r DockerRunner, dest string) (string, error) {
-	if err := os.MkdirAll(filepath.Dir(dest), 0o755); err != nil {
-		return "", err
-	}
-	if err := r.Docker(ctx, "cp", ProxyContainerName+":"+caContainerPath, dest); err != nil {
-		return "", err
-	}
-	return dest, nil
-}

package/internal/devenv/proxy/ca_test.go

@@ -1,111 +0,0 @@
-package proxy
-
-import (
-	"context"
-	"strings"
-	"testing"
-)
-
-func TestProxyRunArgsMountsCertsVolume(t *testing.T) {
-	joined := strings.Join(proxyRunArgs(Ports{HTTP: 80, HTTPS: 443}, "vipdev.lndo.site"), " ")
-	if !strings.Contains(joined, ProxyCertsVolume+":/certs") {
-		t.Fatalf("proxy run args missing certs volume mount:\n%s", joined)
-	}
-	if strings.Contains(joined, "TODO") {
-		t.Fatalf("TODO placeholder still present:\n%s", joined)
-	}
-}
-
-func TestCAHostPathUnderXDG(t *testing.T) {
-	t.Setenv("XDG_DATA_HOME", "/data")
-	if got := CAHostPath(); got != "/data/vip/dev-env/proxy/ca.pem" {
-		t.Fatalf("CAHostPath = %q", got)
-	}
-}
-
-func TestEnsureCARunsGenScript(t *testing.T) {
-	r := &fakeRunner{}
-	if err := EnsureCA(context.Background(), r); err != nil {
-		t.Fatal(err)
-	}
-	if len(r.calls) != 1 {
-		t.Fatalf("expected 1 docker call, got %d: %v", len(r.calls), r.calls)
-	}
-	joined := strings.Join(r.calls[0], " ")
-	for _, want := range []string{"run", "--rm", "--entrypoint", "sh", ProxyCertsVolume + ":/certs", ProxyImage, "-c"} {
-		if !strings.Contains(joined, want) {
-			t.Fatalf("EnsureCA call missing %q:\n%s", want, joined)
-		}
-	}
-	// the embedded script must actually generate the CA
-	last := r.calls[0][len(r.calls[0])-1]
-	if !strings.Contains(last, "lndo.site.pem") {
-		t.Fatalf("gen script not passed as final arg:\n%s", last)
-	}
-}
-
-func TestEnsureCertBuildsEnvAndMounts(t *testing.T) {
-	r := &fakeRunner{}
-	err := EnsureCert(context.Background(), r, CertRequest{
-		Basename:   "example",
-		CommonName: "example.vipdev.lndo.site",
-		SANs:       []string{"example.vipdev.lndo.site", "*.vipdev.lndo.site", "localhost"},
-	})
-	if err != nil {
-		t.Fatal(err)
-	}
-	joined := strings.Join(r.calls[0], " ")
-	for _, want := range []string{
-		"proxy_config:/proxy_config",
-		"CERT_BASENAME=example",
-		"CERT_CN=example.vipdev.lndo.site",
-		"CERT_SANS=example.vipdev.lndo.site *.vipdev.lndo.site localhost",
-	} {
-		if !strings.Contains(joined, want) {
-			t.Fatalf("EnsureCert call missing %q:\n%s", want, joined)
-		}
-	}
-}
-
-func TestEnsureCertRejectsEmpty(t *testing.T) {
-	r := &fakeRunner{}
-	if err := EnsureCert(context.Background(), r, CertRequest{Basename: "x"}); err == nil {
-		t.Fatal("expected error when SANs empty")
-	}
-}
-
-func TestEnsureCertRejectsEmptyBasename(t *testing.T) {
-	r := &fakeRunner{}
-	if err := EnsureCert(context.Background(), r, CertRequest{SANs: []string{"foo.test"}}); err == nil {
-		t.Fatal("expected error when Basename empty")
-	}
-}
-
-func TestEnsureCertRejectsBadChars(t *testing.T) {
-	r := &fakeRunner{}
-	cases := []CertRequest{
-		{Basename: "a/b", SANs: []string{"foo.test"}},
-		{Basename: "ok", CommonName: "bad/cn", SANs: []string{"foo.test"}},
-		{Basename: "ok", SANs: []string{"foo bar"}},
-	}
-	for i, c := range cases {
-		if err := EnsureCert(context.Background(), r, c); err == nil {
-			t.Fatalf("case %d: expected validation error for %+v", i, c)
-		}
-	}
-}
-
-func TestExtractCACopiesFromProxy(t *testing.T) {
-	r := &fakeRunner{}
-	dest, err := ExtractCA(context.Background(), r, t.TempDir()+"/ca.pem")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if dest == "" {
-		t.Fatal("ExtractCA should return the dest path")
-	}
-	joined := strings.Join(r.calls[0], " ")
-	if !strings.Contains(joined, "cp") || !strings.Contains(joined, ProxyContainerName+":"+caContainerPath) {
-		t.Fatalf("ExtractCA should docker cp the CA from the proxy:\n%s", joined)
-	}
-}

package/internal/devenv/proxy/network.go

@@ -1,28 +0,0 @@
-package proxy
-
-import (
-	"context"
-
-	"github.com/Automattic/vip/internal/devenv/compose"
-)
-
-// DockerRunner is the slice of dockercli.Runner this package needs. The
-// concrete *dockercli.Runner satisfies it. Docker tees output to the terminal
-// and log; DockerOut captures stdout silently for read-only state queries.
-type DockerRunner interface {
-	Docker(ctx context.Context, args ...string) error
-	DockerOut(ctx context.Context, args ...string) ([]byte, error)
-}
-
-// EnsureNetwork creates the shared external bridge network if it is absent.
-// Ports Lando's bridge-network role onto our single shared network
-// (compose.ProxyNetwork). docker network inspect returns non-zero when the
-// network does not exist; we then create it. The inspect is a pure existence
-// probe, so its stdout (the full network JSON) is captured rather than teed to
-// the terminal.
-func EnsureNetwork(ctx context.Context, r DockerRunner) error {
-	if _, err := r.DockerOut(ctx, "network", "inspect", compose.ProxyNetwork); err == nil {
-		return nil
-	}
-	return r.Docker(ctx, "network", "create", "--driver", "bridge", compose.ProxyNetwork)
-}