@automattic/vip 4.1.4 → 4.1.6

package/internal/devenv/e2esafety/safety_test.go

@@ -1,71 +0,0 @@
-package e2esafety
-
-import (
-	"bytes"
-	"strings"
-	"testing"
-)
-
-func TestEnabledRequiresExactOptIn(t *testing.T) {
-	for _, tc := range []struct {
-		value string
-		want  bool
-	}{{"", false}, {"0", false}, {"true", false}, {"1", true}} {
-		got := Enabled(func(string) string { return tc.value })
-		if got != tc.want {
-			t.Errorf("Enabled(%q) = %v, want %v", tc.value, got, tc.want)
-		}
-	}
-}
-
-func TestSkipPrintsExplicitMessage(t *testing.T) {
-	var out bytes.Buffer
-	if !Skip(func(string) string { return "" }, &out) {
-		t.Fatal("Skip must stop the package when opt-in is absent")
-	}
-	if !strings.Contains(out.String(), "VIP_DEVENV_E2E=1") {
-		t.Fatalf("skip message = %q", out.String())
-	}
-}
-
-func TestRequireCleanListsExistingResources(t *testing.T) {
-	s := Snapshot{
-		"proxy-container": "container-id",
-		"managed-hosts":   "hosts-sha256",
-	}
-	err := s.RequireClean()
-	if err == nil || !strings.Contains(err.Error(), "managed-hosts, proxy-container") {
-		t.Fatalf("RequireClean error = %v", err)
-	}
-}
-
-func TestRequireCleanAllowsEmptySnapshot(t *testing.T) {
-	if err := (Snapshot{}).RequireClean(); err != nil {
-		t.Fatalf("empty snapshot must be clean: %v", err)
-	}
-}
-
-func TestCanRemoveRequiresExactCreatedIdentity(t *testing.T) {
-	for _, tc := range []struct {
-		created string
-		current string
-		want    bool
-	}{{"", "x", false}, {"x", "", false}, {"x", "replacement", false}, {"x", "x", true}} {
-		if got := CanRemove(tc.created, tc.current); got != tc.want {
-			t.Errorf("CanRemove(%q, %q) = %v, want %v", tc.created, tc.current, got, tc.want)
-		}
-	}
-}
-
-func TestAllOwnedMatchRejectsReplacementAndMissingResources(t *testing.T) {
-	owned := Snapshot{"container": "container-1", "network": "network-1"}
-	if !AllOwnedMatch(owned, Snapshot{"container": "container-1", "network": "network-1"}) {
-		t.Fatal("exact identities must match")
-	}
-	if AllOwnedMatch(owned, Snapshot{"container": "container-2", "network": "network-1"}) {
-		t.Fatal("replacement container must not match")
-	}
-	if AllOwnedMatch(owned, Snapshot{"container": "container-1"}) {
-		t.Fatal("missing owned network must not match")
-	}
-}

package/internal/devenv/eachenv_test.go

@@ -1,132 +0,0 @@
-package devenv
-
-import (
-	"errors"
-	"strings"
-	"testing"
-)
-
-// Node's `dev-env stop --all` wraps each stopEnvironment in its own try/catch:
-// a failure prints an error, sets process.exitCode = 1, and the loop CONTINUES
-// to the next environment (vip-dev-env-stop.js:72-100). vip-next returned on
-// the first error, leaving the remaining environments running — so one broken
-// environment stopped `stop --all` from stopping anything after it.
-func TestStopAllContinuesPastAFailure(t *testing.T) {
-	var seen []string
-	err := stopEachEnv([]string{"a", "bad", "c"}, func(slug string) error {
-		seen = append(seen, slug)
-		if slug == "bad" {
-			return errors.New("container is wedged")
-		}
-		return nil
-	})
-	if err == nil {
-		t.Fatal("a failed environment must still fail the command (Node sets exitCode 1)")
-	}
-	if got := strings.Join(seen, ","); got != "a,bad,c" {
-		t.Errorf("visited %q; every environment must be attempted", got)
-	}
-	if !strings.Contains(err.Error(), "bad") || !strings.Contains(err.Error(), "container is wedged") {
-		t.Errorf("error %q should name the failing environment and its cause", err)
-	}
-}
-
-func TestStopAllSucceedsWhenAllSucceed(t *testing.T) {
-	if err := stopEachEnv([]string{"a", "b"}, func(string) error { return nil }); err != nil {
-		t.Fatalf("err = %v, want nil", err)
-	}
-}
-
-// Node's purge has the same shape (vip-dev-env-purge.js:85-98): each
-// destroyEnvironment is individually caught, exitCode is set to 1, and the loop
-// continues. vip-next aborted on the first failure, leaving a half-purged
-// machine that the user then had to clean up by hand.
-func TestPurgeContinuesPastAFailure(t *testing.T) {
-	var seen []string
-	err := purgeEachEnv([]string{"a", "bad", "c"}, func(slug string) error {
-		seen = append(seen, slug)
-		if slug == "bad" {
-			return errors.New("volume in use")
-		}
-		return nil
-	})
-	if err == nil {
-		t.Fatal("a failed environment must still fail purge")
-	}
-	if got := strings.Join(seen, ","); got != "a,bad,c" {
-		t.Errorf("visited %q; purge must attempt every environment", got)
-	}
-}
-
-// Node deletes the environment directory INSIDE destroyEnvironment, with a bare
-// `fs.promises.rm( instancePath, { recursive: true } )` — note: no
-// `force: true` (src/lib/dev-environment/dev-environment-core.ts:381-382). A
-// failed removal therefore rejects, and the purge bin catches it per environment
-// and sets `process.exitCode = 1` (src/bin/vip-dev-env-purge.js:92-97).
-//
-// vip-next's Purge did `_ = removeEnvFiles(slug)`. When removal failed (a
-// read-only parent, a busy or immutable file) the environment's config survived
-// — so it was still listed by `dev-env list` and still counted by
-// instancedata.AllNames() — while purge reported success and exited 0. Note the
-// single-environment Destroy path already propagated the same error, so this
-// was an inconsistency inside vip-next as well as against Node.
-func TestPurgeStepFailsWhenEnvFilesCannotBeRemoved(t *testing.T) {
-	removeCalls := 0
-	step := purgeEnvStep(
-		func(string) error { return nil },
-		func(string) error { removeCalls++; return errors.New("permission denied") },
-		false, // not a soft purge → files must be removed
-	)
-	err := step("wedged")
-	if err == nil {
-		t.Fatal("a failed environment-files removal must fail the purge (Node exits 1)")
-	}
-	if !strings.Contains(err.Error(), "permission denied") {
-		t.Errorf("error %q should carry the removal failure", err)
-	}
-	if removeCalls != 1 {
-		t.Errorf("removeEnvFiles called %d times, want 1", removeCalls)
-	}
-}
-
-// A soft purge keeps the config files (Node's `--soft`), so removal must not be
-// attempted at all — and its hypothetical failure must not surface.
-func TestPurgeStepSoftSkipsFileRemoval(t *testing.T) {
-	step := purgeEnvStep(
-		func(string) error { return nil },
-		func(string) error { t.Error("soft purge must not remove environment files"); return errors.New("boom") },
-		true,
-	)
-	if err := step("kept"); err != nil {
-		t.Fatalf("err = %v, want nil", err)
-	}
-}
-
-// A destroy failure short-circuits: removal is not attempted on an environment
-// whose containers are still up.
-func TestPurgeStepDestroyFailureSkipsRemoval(t *testing.T) {
-	step := purgeEnvStep(
-		func(string) error { return errors.New("volume in use") },
-		func(string) error { t.Error("must not remove files after a failed destroy"); return nil },
-		false,
-	)
-	err := step("busy")
-	if err == nil || !strings.Contains(err.Error(), "volume in use") {
-		t.Fatalf("err = %v, want the destroy failure", err)
-	}
-}
-
-// Every failure is reported, not just the first.
-func TestPurgeReportsEveryFailure(t *testing.T) {
-	err := purgeEachEnv([]string{"x", "y"}, func(slug string) error {
-		return errors.New("nope-" + slug)
-	})
-	if err == nil {
-		t.Fatal("want an error")
-	}
-	for _, want := range []string{"nope-x", "nope-y"} {
-		if !strings.Contains(err.Error(), want) {
-			t.Errorf("error %q missing %q", err, want)
-		}
-	}
-}

package/internal/devenv/editor.go

@@ -1,82 +0,0 @@
-package devenv
-
-import (
-	"encoding/json"
-	"fmt"
-	"os"
-	"path/filepath"
-
-	"github.com/Automattic/vip/internal/devenv/instancedata"
-	"github.com/Automattic/vip/internal/devenv/paths"
-)
-
-// vscodeStyleEditors share the .code-workspace format (Node SUPPORTED_EDITORS).
-var vscodeStyleEditors = map[string]bool{"vscode": true, "cursor": true, "windsurf": true}
-
-// GenerateEditorWorkspace writes an editor workspace file for the env and
-// returns its path (Node `start --editor=<name>`). Ports generateVSCodeWorkspace:
-// a .code-workspace with the env + local code folders and an Xdebug launch
-// config (port 9003) with container→host path mappings. vscode/cursor/windsurf
-// share the format; phpstorm (a different .iml format) is not yet supported.
-func GenerateEditorWorkspace(slug, editor string) (string, error) {
-	if !vscodeStyleEditors[editor] {
-		return "", fmt.Errorf("devenv: --editor=%s is not supported yet; use vscode, cursor, or windsurf", editor)
-	}
-	d, err := instancedata.Read(slug)
-	if err != nil {
-		return "", err
-	}
-	location := paths.EnvironmentPath(slug)
-
-	folders := []map[string]string{{"path": location}}
-	if d.MuPlugins.Dir != "" {
-		folders = append(folders, map[string]string{"path": d.MuPlugins.Dir})
-	}
-	if d.AppCode.Dir != "" {
-		folders = append(folders, map[string]string{"path": d.AppCode.Dir})
-	}
-
-	workspace := map[string]any{
-		"folders": folders,
-		"launch": map[string]any{
-			"version": "0.2.0",
-			"configurations": []map[string]any{{
-				"name":         "Debug " + slug,
-				"type":         "php",
-				"request":      "launch",
-				"port":         9003,
-				"pathMappings": editorPathMappings(location, d),
-			}},
-		},
-	}
-	b, err := json.MarshalIndent(workspace, "", "  ")
-	if err != nil {
-		return "", err
-	}
-	out := filepath.Join(location, slug+".code-workspace")
-	if err := os.WriteFile(out, b, 0o644); err != nil {
-		return "", err
-	}
-	return out, nil
-}
-
-// editorPathMappings maps container paths to host paths for the Xdebug launch
-// config (ports generatePathMappings).
-func editorPathMappings(location string, d *instancedata.InstanceData) map[string]string {
-	m := map[string]string{}
-	if d.MuPlugins.Dir != "" {
-		m["/wp/wp-content/mu-plugins"] = d.MuPlugins.Dir
-	}
-	if d.AppCode.Dir != "" {
-		base := d.AppCode.Dir
-		m["/wp/wp-content/client-mu-plugins"] = filepath.Join(base, "client-mu-plugins")
-		m["/wp/wp-content/images"] = filepath.Join(base, "images")
-		m["/wp/wp-content/languages"] = filepath.Join(base, "languages")
-		m["/wp/wp-content/plugins"] = filepath.Join(base, "plugins")
-		m["/wp/wp-content/private"] = filepath.Join(base, "private")
-		m["/wp/wp-content/themes"] = filepath.Join(base, "themes")
-		m["/wp/vip-config"] = filepath.Join(base, "vip-config")
-	}
-	m["/wp"] = filepath.Join(location, "wordpress")
-	return m
-}

package/internal/devenv/editor_test.go

@@ -1,60 +0,0 @@
-package devenv
-
-import (
-	"encoding/json"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/Automattic/vip/internal/devenv/instancedata"
-)
-
-func TestEditorPathMappingsAppCode(t *testing.T) {
-	d := &instancedata.InstanceData{
-		MuPlugins: instancedata.ComponentConfig{Mode: "local", Dir: "/srv/mu"},
-		AppCode:   instancedata.ComponentConfig{Mode: "local", Dir: "/srv/app"},
-	}
-	m := editorPathMappings("/loc", d)
-	if m["/wp/wp-content/mu-plugins"] != "/srv/mu" {
-		t.Fatalf("mu-plugins mapping wrong: %v", m)
-	}
-	if m["/wp/wp-content/plugins"] != "/srv/app/plugins" {
-		t.Fatalf("plugins mapping wrong: %v", m)
-	}
-	if m["/wp"] != "/loc/wordpress" {
-		t.Fatalf("/wp mapping wrong: %v", m)
-	}
-}
-
-func TestGenerateEditorWorkspace(t *testing.T) {
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-	if err := instancedata.Write("ws", &instancedata.InstanceData{SiteSlug: "ws", Multisite: []byte("false")}); err != nil {
-		t.Fatal(err)
-	}
-	path, err := GenerateEditorWorkspace("ws", "cursor")
-	if err != nil {
-		t.Fatal(err)
-	}
-	if !strings.HasSuffix(path, "ws.code-workspace") {
-		t.Fatalf("unexpected workspace path: %s", path)
-	}
-	b, err := os.ReadFile(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	var ws map[string]any
-	if err := json.Unmarshal(b, &ws); err != nil {
-		t.Fatalf("workspace not valid JSON: %v", err)
-	}
-	if _, ok := ws["folders"]; !ok {
-		t.Fatal("workspace missing folders")
-	}
-	if filepath.Base(path) != "ws.code-workspace" {
-		t.Fatal("workspace filename wrong")
-	}
-	// Unsupported editor errors.
-	if _, err := GenerateEditorWorkspace("ws", "phpstorm"); err == nil {
-		t.Fatal("phpstorm should be unsupported")
-	}
-}

package/internal/devenv/envfile.go

@@ -1,287 +0,0 @@
-package devenv
-
-import (
-	"os"
-	"path/filepath"
-	"strings"
-
-	"github.com/Automattic/vip/internal/devenv/compose"
-)
-
-// This file ports src/lib/dev-environment/env-vars.ts.
-//
-// <envdir>/.env is SHARED with the Node CLI: paths.EnvironmentPath is
-// byte-identical to Node's getEnvironmentPath, and Node's `vip dev-env envvar
-// set|delete|get|list` read and write exactly this file (env-vars.ts:66). It is
-// also the delivery mechanism on both sides — Node's Lando template declares
-// `env_file: - .env` and Go's php service does the same
-// (compose/services.go) — so a variable written here reaches the container
-// without any further plumbing.
-//
-// vip-next additionally needs LANDO_HOST_USER_ID/LANDO_HOST_GROUP_ID in this
-// file because docker-compose.yml substitutes ${LANDO_HOST_USER_ID} at parse
-// time and Compose resolves those from the project directory's .env. Node does
-// not write them here (it injects them through Lando's own config,
-// dev-environment-lando.ts:336) and only ever touches the file with
-// appendFileSync(path, '') on start. Those two keys are therefore treated as
-// "managed": vip-next rewrites them and leaves every other byte alone.
-
-// splitEnvLine ports Node's splitKeyValueString (src/lib/utils.ts:108): split on
-// the FIRST '=', trim both sides. A line with no '=' is a key with an empty
-// value.
-func splitEnvLine(line string) (key, value string) {
-	k, v, ok := strings.Cut(line, "=")
-	if !ok {
-		return strings.TrimSpace(line), ""
-	}
-	return strings.TrimSpace(k), strings.TrimSpace(v)
-}
-
-// parseManagedBlock turns the rendered managed block (compose.RenderEnvFile)
-// into ordered key/value pairs, so the set of Go-managed keys has exactly one
-// definition instead of being duplicated as a literal list here.
-func parseManagedBlock(block string) [][2]string {
-	var out [][2]string
-	for _, line := range strings.Split(block, "\n") {
-		line = strings.TrimSpace(line)
-		if line == "" || strings.HasPrefix(line, "#") {
-			continue
-		}
-		k, v := splitEnvLine(line)
-		if k != "" {
-			out = append(out, [2]string{k, v})
-		}
-	}
-	return out
-}
-
-// mergeEnvFile applies the managed key/values onto an existing .env, preserving
-// every other line verbatim — user variables, comments, blank lines and
-// ordering all survive. Managed keys already present are rewritten where they
-// stand; missing ones are appended. On an empty input the result is just the
-// managed block, i.e. identical to what Materialize used to write outright.
-//
-// This replaces an unconditional overwrite that destroyed variables set with
-// the Node CLI on every create/start/rebuild/update (parity blocker B3).
-func mergeEnvFile(existing, managedBlock string) string {
-	managed := parseManagedBlock(managedBlock)
-	if existing == "" {
-		return managedBlock
-	}
-
-	// Preserve the original line endings by splitting on "\n" and keeping any
-	// trailing "\r" attached to the content we don't rewrite.
-	lines := strings.Split(existing, "\n")
-	trailingNewline := len(lines) > 0 && lines[len(lines)-1] == ""
-	if trailingNewline {
-		lines = lines[:len(lines)-1]
-	}
-
-	seen := make(map[string]bool, len(managed))
-	for i, line := range lines {
-		trimmed := strings.TrimSpace(line)
-		if trimmed == "" || strings.HasPrefix(trimmed, "#") {
-			continue
-		}
-		key, _ := splitEnvLine(trimmed)
-		for _, kv := range managed {
-			if key == kv[0] && !seen[key] {
-				lines[i] = kv[0] + "=" + kv[1]
-				seen[key] = true
-			}
-		}
-	}
-	for _, kv := range managed {
-		if !seen[kv[0]] {
-			lines = append(lines, kv[0]+"="+kv[1])
-		}
-	}
-
-	out := strings.Join(lines, "\n")
-	if !strings.HasSuffix(out, "\n") {
-		out += "\n"
-	}
-	return out
-}
-
-// writeEnvFileAtomic writes .env through a sibling temp file and renames it into
-// place, mirroring Node's updateEnvFile (env-vars.ts:75-79). A crash mid-write
-// therefore leaves the previous file intact rather than a truncated one.
-func writeEnvFileAtomic(path, content string) error {
-	tmp := path + ".tmp"
-	if err := os.WriteFile(tmp, []byte(content), 0o644); err != nil { // #nosec G306 -- read by the container user
-		return err
-	}
-	if err := os.Rename(tmp, path); err != nil {
-		_ = os.Remove(tmp)
-		return err
-	}
-	return nil
-}
-
-// readEnvFileRaw returns the contents of <envdir>/.env, or "" when absent.
-func readEnvFileRaw(dir string) (string, error) {
-	b, err := os.ReadFile(filepath.Join(dir, ".env")) // #nosec G304 -- fixed name in our own data dir
-	if os.IsNotExist(err) {
-		return "", nil
-	}
-	if err != nil {
-		return "", err
-	}
-	return string(b), nil
-}
-
-// managedEnvKeys is the set of keys vip-next owns in .env. Derived from the
-// rendered managed block so the key list has exactly one definition
-// (compose.RenderEnvFile) rather than a literal copy that can drift.
-func managedEnvKeys() map[string]bool {
-	keys := make(map[string]bool)
-	for _, kv := range parseManagedBlock(compose.RenderEnvFile(compose.View{})) {
-		keys[kv[0]] = true
-	}
-	return keys
-}
-
-// parseEnvValue ports parseEnvValue (env-vars.ts:14): strip matching double or
-// single quotes and unescape. Bare values are returned as-is.
-func parseEnvValue(value string) string {
-	if len(value) >= 2 && strings.HasPrefix(value, `"`) && strings.HasSuffix(value, `"`) {
-		inner := value[1 : len(value)-1]
-		var b strings.Builder
-		for i := 0; i < len(inner); i++ {
-			if inner[i] != '\\' || i+1 >= len(inner) {
-				b.WriteByte(inner[i])
-				continue
-			}
-			switch c := inner[i+1]; c {
-			case '"', '$', '\\':
-				b.WriteByte(c)
-				i++
-			case 'n':
-				b.WriteByte('\n')
-				i++
-			case 'r':
-				b.WriteByte('\r')
-				i++
-			case 't':
-				b.WriteByte('\t')
-				i++
-			default:
-				b.WriteByte(inner[i])
-			}
-		}
-		return b.String()
-	}
-	if len(value) >= 2 && strings.HasPrefix(value, `'`) && strings.HasSuffix(value, `'`) {
-		return strings.ReplaceAll(value[1:len(value)-1], `\'`, `'`)
-	}
-	return value
-}
-
-// quoteEnvValue ports quoteEnvValue (env-vars.ts:41): always double-quote,
-// escaping backslash, quote, dollar and the three whitespace escapes.
-func quoteEnvValue(value string) string {
-	r := strings.NewReplacer(
-		`\`, `\\`,
-		`"`, `\"`,
-		`$`, `\$`,
-		"\n", `\n`,
-		"\r", `\r`,
-		"\t", `\t`,
-	)
-	return `"` + r.Replace(value) + `"`
-}
-
-// parseUserEnvVars returns the user-visible variables in raw .env content:
-// comments and blanks dropped (Node's preparseEnvData), values unquoted, and
-// the Go-managed LANDO_HOST_* keys excluded — those are ours, and Node's own
-// env file never contains them.
-func parseUserEnvVars(raw string) map[string]string {
-	managed := managedEnvKeys()
-	out := make(map[string]string)
-	for _, line := range preparseEnvData(raw) {
-		k, v := splitEnvLine(line)
-		if k == "" || managed[k] {
-			continue
-		}
-		out[k] = parseEnvValue(v)
-	}
-	return out
-}
-
-// preparseEnvData ports preparseEnvData (env-vars.ts:7): split on \r?\n, trim,
-// drop blank and #-comment lines.
-func preparseEnvData(data string) []string {
-	var out []string
-	for _, line := range strings.Split(data, "\n") {
-		line = strings.TrimSpace(strings.TrimSuffix(line, "\r"))
-		if line == "" || strings.HasPrefix(line, "#") {
-			continue
-		}
-		out = append(out, line)
-	}
-	return out
-}
-
-// setEnvVarLine rewrites raw .env content so name is bound to value, replacing
-// the existing definition where it stands or appending one. Unrelated lines —
-// including comments, which Node's own envvar set discards — are preserved.
-func setEnvVarLine(raw, name, value string) string {
-	quoted := quoteEnvValue(value)
-	lines, trailing := splitEnvLines(raw)
-	replaced := false
-	for i, line := range lines {
-		trimmed := strings.TrimSpace(line)
-		if trimmed == "" || strings.HasPrefix(trimmed, "#") {
-			continue
-		}
-		if k, _ := splitEnvLine(trimmed); k == name && !replaced {
-			lines[i] = name + "=" + quoted
-			replaced = true
-		}
-	}
-	if !replaced {
-		lines = append(lines, name+"="+quoted)
-	}
-	return joinEnvLines(lines, trailing)
-}
-
-// deleteEnvVarLine removes every line defining name from raw .env content and
-// reports whether any line matched — Node's `removed` flag
-// (src/bin/vip-dev-env-envvar-delete.js:39-49), which decides between a rewrite
-// and an exit-1 warning.
-func deleteEnvVarLine(raw, name string) (string, bool) {
-	lines, trailing := splitEnvLines(raw)
-	kept := make([]string, 0, len(lines))
-	removed := false
-	for _, line := range lines {
-		trimmed := strings.TrimSpace(line)
-		if trimmed != "" && !strings.HasPrefix(trimmed, "#") {
-			if k, _ := splitEnvLine(trimmed); k == name {
-				removed = true
-				continue
-			}
-		}
-		kept = append(kept, line)
-	}
-	return joinEnvLines(kept, trailing), removed
-}
-
-func splitEnvLines(raw string) (lines []string, hadTrailingNewline bool) {
-	if raw == "" {
-		return nil, true
-	}
-	lines = strings.Split(raw, "\n")
-	if len(lines) > 0 && lines[len(lines)-1] == "" {
-		return lines[:len(lines)-1], true
-	}
-	return lines, false
-}
-
-func joinEnvLines(lines []string, hadTrailingNewline bool) string {
-	out := strings.Join(lines, "\n")
-	if out != "" && (hadTrailingNewline || !strings.HasSuffix(out, "\n")) {
-		out += "\n"
-	}
-	return out
-}