@automattic/vip 4.1.4 → 4.1.6

package/cmd/vip-next/commands/devenv_envvar.go

@@ -1,180 +0,0 @@
-package commands
-
-import (
-	"errors"
-	"fmt"
-	"os"
-	"strings"
-
-	"github.com/spf13/cobra"
-
-	"github.com/Automattic/vip/internal/appctx"
-	"github.com/Automattic/vip/internal/debuglog"
-	"github.com/Automattic/vip/internal/devenv"
-	"github.com/Automattic/vip/internal/envvar"
-	"github.com/Automattic/vip/internal/output"
-)
-
-// addEnvvarFormatFlag registers the shared --format flag for the listing envvar
-// leaves (table/csv/json/ids), defaulting to table like Node.
-func addEnvvarFormatFlag(c *cobra.Command, format *string) {
-	c.Flags().StringVarP(format, "format", "f", "table", "Render output in a particular format: table, csv, json, or ids.")
-}
-
-func newDevEnvEnvvarCmd() *cobra.Command {
-	ev := &cobra.Command{Use: "envvar", Short: "Manage environment variables for a local environment"}
-	ev.AddCommand(
-		envvarGetCmd(), envvarGetAllCmd(), envvarListCmd(), envvarSetCmd(), envvarDeleteCmd(),
-	)
-	return ev
-}
-
-func envvarGetCmd() *cobra.Command {
-	c := &cobra.Command{Use: "get <name>", Short: "Get a variable", Args: cobra.ExactArgs(1), SilenceUsage: true, SilenceErrors: true,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			slug, err := ResolveSlug(cmd)
-			if err != nil {
-				return err
-			}
-			// Node trims but does NOT validate here (vip-dev-env-envvar-get.js:33).
-			name := strings.TrimSpace(args[0])
-			debuglog.Printf(cmd.Context(), "@automattic/vip:bin:config:envvar", "Will get variable %q for environment %q", name, slug)
-			v, ok, err := devenv.EnvVarGet(slug, name)
-			if err != nil {
-				return err
-			}
-			if !ok {
-				return fmt.Errorf("variable %q is not set", name)
-			}
-			fmt.Fprintln(cmd.OutOrStdout(), v)
-			return nil
-		}}
-	addSlugFlag(c)
-	return c
-}
-
-func envvarGetAllCmd() *cobra.Command {
-	var format string
-	c := &cobra.Command{Use: "get-all", Short: "Get all variables", SilenceUsage: true, SilenceErrors: true,
-		RunE: func(cmd *cobra.Command, _ []string) error {
-			slug, err := ResolveSlug(cmd)
-			if err != nil {
-				return err
-			}
-			debuglog.Printf(cmd.Context(), "@automattic/vip:bin:config:envvar", "Will get all variables for environment %q", slug)
-			all, err := devenv.EnvVarGetAll(slug)
-			if err != nil {
-				return err
-			}
-			names, _ := devenv.EnvVarList(slug)
-			rows := make(output.OrderedRows, 0, len(names))
-			for _, k := range names {
-				rows = append(rows, output.OrderedRow{{Key: "name", Value: k}, {Key: "value", Value: all[k]}})
-			}
-			return output.Render(cmd.OutOrStdout(), output.Format(format), rows)
-		}}
-	addSlugFlag(c)
-	addEnvvarFormatFlag(c, &format)
-	return c
-}
-
-func envvarListCmd() *cobra.Command {
-	var format string
-	c := &cobra.Command{Use: "list", Short: "List variable names", SilenceUsage: true, SilenceErrors: true,
-		RunE: func(cmd *cobra.Command, _ []string) error {
-			slug, err := ResolveSlug(cmd)
-			if err != nil {
-				return err
-			}
-			debuglog.Printf(cmd.Context(), "@automattic/vip:bin:config:envvar", "Will list variable names for environment %q", slug)
-			names, err := devenv.EnvVarList(slug)
-			if err != nil {
-				return err
-			}
-			rows := make(output.OrderedRows, 0, len(names))
-			for _, k := range names {
-				rows = append(rows, output.OrderedRow{{Key: "name", Value: k}})
-			}
-			return output.Render(cmd.OutOrStdout(), output.Format(format), rows)
-		}}
-	addSlugFlag(c)
-	addEnvvarFormatFlag(c, &format)
-	return c
-}
-
-func envvarSetCmd() *cobra.Command {
-	var fromFile string
-	c := &cobra.Command{Use: "set <name> [value]", Short: "Set a variable", Args: cobra.RangeArgs(1, 2), SilenceUsage: true, SilenceErrors: true,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			slug, err := ResolveSlug(cmd)
-			if err != nil {
-				return err
-			}
-			// Node trims the name and then runs validateNameWithMessage,
-			// exiting 1 on failure (vip-dev-env-envvar-set.js:46,52). Without
-			// it a lowercase or hyphenated name lands in .env, where it is not
-			// a valid shell identifier and the container silently ignores it.
-			name := strings.TrimSpace(args[0])
-			if name == "" {
-				return errors.New("variable name is required")
-			}
-			if err := envvar.ValidateName(name); err != nil {
-				return err
-			}
-			debuglog.Printf(cmd.Context(), "@automattic/vip:bin:config:envvar", "Will set variable %q for environment %q: fromFile=%t", name, slug, fromFile != "")
-			var value string
-			switch {
-			case len(args) == 2:
-				value = args[1]
-			case fromFile != "":
-				b, err := os.ReadFile(fromFile)
-				if err != nil {
-					return fmt.Errorf("reading --from-file %q: %w", fromFile, err)
-				}
-				// Node's readFromFile TRIMS (src/lib/read-file.ts:8). Skipping
-				// the trim makes a trailing newline part of the value, so an
-				// API token read from a file is silently wrong.
-				value = strings.TrimSpace(string(b))
-			default:
-				value, err = appctx.Input(cmd, fmt.Sprintf("Value for %s", name), "")
-				if err != nil {
-					return err
-				}
-			}
-			if err := devenv.EnvVarSet(slug, name, value); err != nil {
-				return err
-			}
-			fmt.Fprintf(cmd.OutOrStdout(), "Set %q. Restart the environment for the change to take effect.\n", name)
-			return nil
-		}}
-	addSlugFlag(c)
-	c.Flags().StringVarP(&fromFile, "from-file", "f", "", "Read the variable value from a UTF-8 text file (useful for multiline values).")
-	return c
-}
-
-func envvarDeleteCmd() *cobra.Command {
-	c := &cobra.Command{Use: "delete <name>", Short: "Delete a variable", Args: cobra.ExactArgs(1), SilenceUsage: true, SilenceErrors: true,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			slug, err := ResolveSlug(cmd)
-			if err != nil {
-				return err
-			}
-			// Node trims but does NOT validate here (vip-dev-env-envvar-delete.js:32).
-			name := strings.TrimSpace(args[0])
-			debuglog.Printf(cmd.Context(), "@automattic/vip:bin:config:envvar", "Will delete variable %q for environment %q", name, slug)
-			removed, err := devenv.EnvVarDelete(slug, name)
-			if err != nil {
-				return err
-			}
-			// Node exits 1 on a name that was not there
-			// (vip-dev-env-envvar-delete.js:51-54). Reporting success for a
-			// delete that removed nothing hides a typo'd name in a script.
-			if !removed {
-				return fmt.Errorf("The environment variable %q does not exist", name)
-			}
-			fmt.Fprintf(cmd.OutOrStdout(), "Deleted %q. Restart the environment for the change to take effect.\n", name)
-			return nil
-		}}
-	addSlugFlag(c)
-	return c
-}

package/cmd/vip-next/commands/devenv_envvar_test.go

@@ -1,183 +0,0 @@
-package commands
-
-import (
-	"bytes"
-	"os"
-	"path/filepath"
-	"strings"
-	"testing"
-
-	"github.com/Automattic/vip/internal/devenv"
-	"github.com/Automattic/vip/internal/devenv/instancedata"
-	"github.com/Automattic/vip/internal/devenv/paths"
-)
-
-// seedEnvvarEnv creates one on-disk environment so ResolveSlug finds it.
-func seedEnvvarEnv(t *testing.T) {
-	t.Helper()
-	t.Setenv("XDG_DATA_HOME", t.TempDir())
-	t.Chdir(t.TempDir()) // no .wpvip config file in scope
-	if err := instancedata.Write("only-one", &instancedata.InstanceData{
-		SiteSlug: "only-one", Multisite: []byte("false"),
-	}); err != nil {
-		t.Fatal(err)
-	}
-}
-
-func runEnvvar(t *testing.T, args ...string) (string, error) {
-	t.Helper()
-	root := newDevEnvEnvvarCmd()
-	var out bytes.Buffer
-	root.SetOut(&out)
-	root.SetErr(&out)
-	root.SetArgs(args)
-	err := root.Execute()
-	return out.String(), err
-}
-
-// Node validates every dev-env envvar name through validateNameWithMessage
-// (vip-dev-env-envvar-set.js:52) and exits 1 on failure. vip-next accepted
-// anything, so a lowercase or hyphenated name landed in .env where it is not a
-// valid shell identifier and is silently ignored by the container.
-func TestEnvvarSetRejectsInvalidNames(t *testing.T) {
-	for _, name := range []string{"lower_case", "MY-VAR", "1STVAR", "_LEADING", "HAS SPACE"} {
-		t.Run(name, func(t *testing.T) {
-			seedEnvvarEnv(t)
-			_, err := runEnvvar(t, "set", name, "value")
-			if err == nil {
-				t.Fatalf("name %q must be rejected", name)
-			}
-			if !strings.Contains(err.Error(), "must consist of A-Z, 0-9, or _") {
-				t.Errorf("error = %q, want Node's message", err)
-			}
-			if v, ok, _ := devenv.EnvVarGet("only-one", name); ok {
-				t.Errorf("invalid name was written anyway: %q", v)
-			}
-		})
-	}
-}
-
-func TestEnvvarSetAcceptsValidNames(t *testing.T) {
-	for _, name := range []string{"MY_VAR", "A", "X1_2"} {
-		t.Run(name, func(t *testing.T) {
-			seedEnvvarEnv(t)
-			if _, err := runEnvvar(t, "set", name, "value"); err != nil {
-				t.Fatalf("name %q must be accepted: %v", name, err)
-			}
-		})
-	}
-}
-
-// Node trims the name before validating and storing (`args[0]?.trim()`).
-func TestEnvvarSetTrimsName(t *testing.T) {
-	seedEnvvarEnv(t)
-	if _, err := runEnvvar(t, "set", "  MY_VAR  ", "value"); err != nil {
-		t.Fatal(err)
-	}
-	if _, ok, _ := devenv.EnvVarGet("only-one", "MY_VAR"); !ok {
-		t.Error("the trimmed name should have been stored")
-	}
-}
-
-// Node's readFromFile TRIMS the file contents (src/lib/read-file.ts:8). Without
-// it a trailing newline becomes part of the value, so an API token read from a
-// file is silently wrong.
-func TestEnvvarSetFromFileTrims(t *testing.T) {
-	seedEnvvarEnv(t)
-	f := filepath.Join(t.TempDir(), "token.txt")
-	if err := os.WriteFile(f, []byte("  sk-secret-token\n\n"), 0o600); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := runEnvvar(t, "set", "API_TOKEN", "--from-file", f); err != nil {
-		t.Fatal(err)
-	}
-	v, ok, err := devenv.EnvVarGet("only-one", "API_TOKEN")
-	if err != nil || !ok {
-		t.Fatalf("not set: %v %v", ok, err)
-	}
-	if v != "sk-secret-token" {
-		t.Errorf("value = %q, want the trimmed token", v)
-	}
-}
-
-// `get` and `delete` do NOT validate in Node (only `set` calls
-// validateNameWithMessage) — they just trim and report "does not exist".
-// Matched deliberately: adding validation there would reject names a user could
-// legitimately have on disk from an older CLI.
-func TestEnvvarGetAndDeleteTrimButDoNotValidate(t *testing.T) {
-	seedEnvvarEnv(t)
-	if _, err := runEnvvar(t, "set", "MY_VAR", "value"); err != nil {
-		t.Fatal(err)
-	}
-	if _, err := runEnvvar(t, "get", "  MY_VAR  "); err != nil {
-		t.Errorf("get should trim the name: %v", err)
-	}
-	if _, err := runEnvvar(t, "delete", "  MY_VAR  "); err != nil {
-		t.Errorf("delete should trim the name: %v", err)
-	}
-	if _, ok, _ := devenv.EnvVarGet("only-one", "MY_VAR"); ok {
-		t.Error("delete with a padded name should have removed the variable")
-	}
-}
-
-// Node EXITS 1 when the variable does not exist: it writes
-// `The environment variable "<name>" does not exist` to stderr and sets
-// process.exitCode = 1, and — note — never calls updateEnvFile, so .env is left
-// byte-for-byte alone (src/bin/vip-dev-env-envvar-delete.js:51-54).
-//
-// vip-next printed "Deleted …" and exited 0, so a typo'd variable name in a CI
-// script reported a successful delete that never happened.
-func TestEnvvarDeleteMissingVariableExitsNonZero(t *testing.T) {
-	seedEnvvarEnv(t)
-	if _, err := runEnvvar(t, "set", "KEEP_ME", "value"); err != nil {
-		t.Fatal(err)
-	}
-	envFile := filepath.Join(paths.EnvironmentPath("only-one"), ".env")
-	before, err := os.ReadFile(envFile)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	out, err := runEnvvar(t, "delete", "NOT_THERE")
-	if err == nil {
-		t.Fatal("deleting a variable that does not exist must fail (Node exits 1)")
-	}
-	if !strings.Contains(err.Error(), `The environment variable "NOT_THERE" does not exist`) {
-		t.Errorf("err = %q, want Node's does-not-exist message", err)
-	}
-	if strings.Contains(out, "Deleted") {
-		t.Errorf("a failed delete must not claim success; output = %q", out)
-	}
-
-	// The delete demonstrably did not happen: .env is untouched and the other
-	// variable is intact.
-	after, err := os.ReadFile(envFile)
-	if err != nil {
-		t.Fatal(err)
-	}
-	if string(after) != string(before) {
-		t.Errorf(".env was rewritten on a no-op delete:\n before %q\n after  %q", before, after)
-	}
-	if v, ok, _ := devenv.EnvVarGet("only-one", "KEEP_ME"); !ok || v != "value" {
-		t.Errorf("unrelated variable was disturbed: %q ok=%v", v, ok)
-	}
-}
-
-// Guard against over-correcting the fix above: a delete that DOES remove
-// something still succeeds, prints the success line, and drops the variable.
-func TestEnvvarDeleteExistingVariableSucceeds(t *testing.T) {
-	seedEnvvarEnv(t)
-	if _, err := runEnvvar(t, "set", "GONE_SOON", "value"); err != nil {
-		t.Fatal(err)
-	}
-	out, err := runEnvvar(t, "delete", "GONE_SOON")
-	if err != nil {
-		t.Fatalf("deleting an existing variable must succeed: %v", err)
-	}
-	if !strings.Contains(out, "Deleted") {
-		t.Errorf("output = %q, want the success line", out)
-	}
-	if _, ok, _ := devenv.EnvVarGet("only-one", "GONE_SOON"); ok {
-		t.Error("the variable is still set after a successful delete")
-	}
-}

package/cmd/vip-next/commands/devenv_exec.go

@@ -1,75 +0,0 @@
-package commands
-
-import (
-	"errors"
-
-	"github.com/spf13/cobra"
-
-	"github.com/Automattic/vip/internal/devenv"
-)
-
-// argsAfterDashes returns the args following the cobra `--` terminator. cobra
-// stores them via ArgsLenAtDash; everything at/after that index is post-`--`.
-func argsAfterDashes(cmd *cobra.Command, args []string) []string {
-	n := cmd.ArgsLenAtDash()
-	if n < 0 {
-		return nil
-	}
-	return args[n:]
-}
-
-func newDevEnvExecCmd() *cobra.Command {
-	c := &cobra.Command{
-		Use:           "exec",
-		Short:         "Run a WP-CLI command against a local environment",
-		Long:          "Run a WP-CLI command. A double dash (\"--\") must separate vip args from the wp command:\n  vip dev-env exec --slug=example -- wp post list",
-		SilenceUsage:  true,
-		SilenceErrors: true,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			slug, err := ResolveSlug(cmd)
-			if err != nil {
-				return err
-			}
-			wpArgs := argsAfterDashes(cmd, args)
-			if len(wpArgs) == 0 {
-				return errors.New(`a double dash ("--") must separate vip args from the wp command; run "vip dev-env exec --help"`)
-			}
-			return devenv.Exec(cmd.Context(), slug, wpArgs)
-		},
-	}
-	addSlugFlag(c)
-	// --force/--quiet are registered for Node flag-parity. The behaviors they
-	// gate (the pre-exec running-env check that --force skips, and --quiet's
-	// message suppression) are part of the devenv_e2e runtime path and are not
-	// wired in the Docker-free cutover; they are accepted but currently no-ops.
-	// TODO(devenv): honor --force/--quiet when the running-env check lands.
-	c.Flags().BoolP("force", "f", false, "Skip the running-environment check.")
-	c.Flags().BoolP("quiet", "q", false, "Suppress informational messages.")
-	return c
-}
-
-func newDevEnvShellCmd() *cobra.Command {
-	var root bool
-	var service string
-	c := &cobra.Command{
-		Use:           "shell",
-		Short:         "Open a shell in a local environment",
-		SilenceUsage:  true,
-		SilenceErrors: true,
-		RunE: func(cmd *cobra.Command, args []string) error {
-			slug, err := ResolveSlug(cmd)
-			if err != nil {
-				return err
-			}
-			svc := service
-			if svc == "" {
-				svc = "php"
-			}
-			return devenv.Shell(cmd.Context(), slug, svc, root, argsAfterDashes(cmd, args))
-		},
-	}
-	addSlugFlag(c)
-	c.Flags().BoolVarP(&root, "root", "r", false, "Open the shell with root privileges.")
-	c.Flags().StringVar(&service, "service", "", "Restrict to a single service (default php).")
-	return c
-}

package/cmd/vip-next/commands/devenv_exec_test.go

@@ -1,39 +0,0 @@
-package commands
-
-import (
-	"testing"
-
-	"github.com/spf13/cobra"
-)
-
-func TestArgsAfterDashes(t *testing.T) {
-	// Build a command and parse args containing a `--` terminator.
-	c := &cobra.Command{Use: "exec", RunE: func(*cobra.Command, []string) error { return nil }}
-	c.Flags().String("slug", "", "")
-	if err := c.ParseFlags([]string{"--slug", "x", "--", "wp", "post", "list"}); err != nil {
-		t.Fatal(err)
-	}
-	// After ParseFlags, c.Flags().Args() holds the positional args and
-	// ArgsLenAtDash marks the `--` split. Simulate cobra's RunE args.
-	args := c.Flags().Args()
-	got := argsAfterDashes(c, args)
-	want := []string{"wp", "post", "list"}
-	if len(got) != len(want) {
-		t.Fatalf("argsAfterDashes = %v, want %v", got, want)
-	}
-	for i := range want {
-		if got[i] != want[i] {
-			t.Fatalf("argsAfterDashes[%d] = %q, want %q", i, got[i], want[i])
-		}
-	}
-}
-
-func TestArgsAfterDashesNoDash(t *testing.T) {
-	c := &cobra.Command{Use: "exec"}
-	if err := c.ParseFlags([]string{"foo", "bar"}); err != nil {
-		t.Fatal(err)
-	}
-	if got := argsAfterDashes(c, c.Flags().Args()); got != nil {
-		t.Fatalf("argsAfterDashes without `--` should be nil, got %v", got)
-	}
-}