@automattic/vip 4.1.5 → 4.1.6

package/internal/appctx/env_resolver_test.go

@@ -1,215 +0,0 @@
-package appctx
-
-import (
-	"context"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-
-	"github.com/spf13/cobra"
-)
-
-func makeEnvCmd(app, env string, nonInteractive bool) *cobra.Command {
-	cmd := &cobra.Command{Use: "x"}
-	cmd.PersistentFlags().String("app", app, "")
-	cmd.PersistentFlags().String("env", env, "")
-	cmd.PersistentFlags().Bool("non-interactive", false, "")
-	if nonInteractive {
-		_ = cmd.PersistentFlags().Set("non-interactive", "true")
-	}
-	cmd.SetContext(context.Background())
-	return cmd
-}
-
-// TestWithEnvContextResolvesByTypeMainEnv reproduces the @app.production
-// alias case: env.name = app slug, env.type = "production", env.appId =
-// env.id (main env). Node's getEnvIdentifier returns env.type here, so
-// `--env=production` must match.
-func TestWithEnvContextResolvesByTypeMainEnv(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		_, _ = w.Write([]byte(`{"data":{"apps":{"edges":[{"id":3453,"name":"cantina-trunk-staging","environments":[{"id":3453,"appId":3453,"name":"cantina-trunk-staging","type":"production","defaultDomain":"www.example"}]}]}}}`))
-	}))
-	defer srv.Close()
-	cmd := makeEnvCmd("cantina-trunk-staging", "production", true)
-	mw := Chain(
-		WithAppContext(AppContextConfig{Client: gqlClientForServer(srv)}),
-		WithEnvContext(),
-	)
-	run := mw(func(cmd *cobra.Command, args []string) error {
-		ae := FromContext(cmd.Context())
-		if ae == nil || ae.Env.Type != "production" || ae.Env.ID != 3453 {
-			t.Errorf("Env = %+v", ae)
-		}
-		return nil
-	})
-	if err := run(cmd, nil); err != nil {
-		t.Fatalf("run: %v", err)
-	}
-}
-
-func TestWithEnvContextResolves(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		_, _ = w.Write([]byte(`{"data":{"apps":{"edges":[{"id":42,"name":"myapp","environments":[{"id":7,"name":"develop","type":"develop","defaultDomain":"d.example"},{"id":1,"name":"production","type":"production","defaultDomain":"p.example"}]}]}}}`))
-	}))
-	defer srv.Close()
-	cmd := makeEnvCmd("myapp", "develop", true)
-	mw := Chain(
-		WithAppContext(AppContextConfig{Client: gqlClientForServer(srv)}),
-		WithEnvContext(),
-	)
-	run := mw(func(cmd *cobra.Command, args []string) error {
-		ae := FromContext(cmd.Context())
-		if ae == nil || ae.Env.ID != 7 || ae.Env.Name != "develop" || ae.Env.Type != "develop" {
-			t.Errorf("Env = %+v", ae)
-		}
-		return nil
-	})
-	if err := run(cmd, nil); err != nil {
-		t.Fatalf("run: %v", err)
-	}
-}
-
-func TestWithEnvContextEnvNotFound(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		_, _ = w.Write([]byte(`{"data":{"apps":{"edges":[{"id":42,"name":"myapp","environments":[{"id":7,"name":"develop","type":"develop"}]}]}}}`))
-	}))
-	defer srv.Close()
-	cmd := makeEnvCmd("myapp", "ghostenv", true)
-	mw := Chain(
-		WithAppContext(AppContextConfig{Client: gqlClientForServer(srv)}),
-		WithEnvContext(),
-	)
-	run := mw(func(cmd *cobra.Command, args []string) error {
-		t.Error("must not be called")
-		return nil
-	})
-	err := run(cmd, nil)
-	if err == nil || !strings.Contains(err.Error(), "ghostenv") {
-		t.Errorf("err = %v, want not-found", err)
-	}
-	if !strings.Contains(err.Error(), "develop") {
-		t.Errorf("err should list available envs; got %v", err)
-	}
-}
-
-func TestWithEnvContextAutoSelectsSingleEnv(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		_, _ = w.Write([]byte(`{"data":{"apps":{"edges":[{"id":42,"name":"myapp","environments":[{"id":7,"name":"develop","type":"develop"}]}]}}}`))
-	}))
-	defer srv.Close()
-	cmd := makeEnvCmd("myapp", "", true)
-	mw := Chain(
-		WithAppContext(AppContextConfig{Client: gqlClientForServer(srv)}),
-		WithEnvContext(),
-	)
-	run := mw(func(cmd *cobra.Command, args []string) error {
-		ae := FromContext(cmd.Context())
-		if ae == nil || ae.Env.ID != 7 {
-			t.Errorf("Env = %+v", ae)
-		}
-		return nil
-	})
-	if err := run(cmd, nil); err != nil {
-		t.Fatalf("run: %v", err)
-	}
-}
-
-func TestWithEnvContextMultipleNonInteractiveRequiresFlag(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		_, _ = w.Write([]byte(`{"data":{"apps":{"edges":[{"id":42,"name":"myapp","environments":[{"id":7,"name":"develop","type":"develop"},{"id":1,"name":"production","type":"production"}]}]}}}`))
-	}))
-	defer srv.Close()
-	cmd := makeEnvCmd("myapp", "", true)
-	mw := Chain(
-		WithAppContext(AppContextConfig{Client: gqlClientForServer(srv)}),
-		WithEnvContext(),
-	)
-	run := mw(func(cmd *cobra.Command, args []string) error {
-		t.Error("must not be called without --env")
-		return nil
-	})
-	err := run(cmd, nil)
-	if err == nil {
-		t.Fatal("expected error when --env required and not set in non-interactive mode")
-	}
-	if !strings.Contains(err.Error(), "develop") || !strings.Contains(err.Error(), "production") {
-		t.Errorf("err should list available envs; got %v", err)
-	}
-}
-
-func TestWithEnvContextNoEnvs(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		_, _ = w.Write([]byte(`{"data":{"apps":{"edges":[{"id":42,"name":"myapp","environments":[]}]}}}`))
-	}))
-	defer srv.Close()
-	cmd := makeEnvCmd("myapp", "", true)
-	mw := Chain(
-		WithAppContext(AppContextConfig{Client: gqlClientForServer(srv)}),
-		WithEnvContext(),
-	)
-	run := mw(func(cmd *cobra.Command, args []string) error {
-		t.Error("must not be called")
-		return nil
-	})
-	err := run(cmd, nil)
-	if err == nil || !strings.Contains(err.Error(), "myapp") {
-		t.Errorf("err = %v, want error mentioning the app has no envs", err)
-	}
-}
-
-func TestWithEnvContextMissingAppCtxErrors(t *testing.T) {
-	cmd := makeEnvCmd("myapp", "develop", true)
-	mw := WithEnvContext()
-	run := mw(func(cmd *cobra.Command, args []string) error {
-		t.Error("must not be called when AppContext missing")
-		return nil
-	})
-	err := run(cmd, nil)
-	if err == nil || !strings.Contains(err.Error(), "WithAppContext") {
-		t.Errorf("err = %v, want a clear 'WithAppContext required earlier in chain' error", err)
-	}
-}
-
-func TestWithChildEnvContextRejectsProduction(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		_, _ = w.Write([]byte(`{"data":{"apps":{"edges":[{"id":42,"name":"myapp","environments":[{"id":1,"name":"production","type":"production"}]}]}}}`))
-	}))
-	defer srv.Close()
-	cmd := makeEnvCmd("myapp", "production", true)
-	mw := Chain(
-		WithAppContext(AppContextConfig{Client: gqlClientForServer(srv)}),
-		WithChildEnvContext(),
-	)
-	run := mw(func(cmd *cobra.Command, args []string) error {
-		t.Error("must not be called for production")
-		return nil
-	})
-	err := run(cmd, nil)
-	if err == nil || !strings.Contains(err.Error(), "production") {
-		t.Errorf("err = %v, want production rejection", err)
-	}
-}
-
-func TestWithChildEnvContextAllowsDevelop(t *testing.T) {
-	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		_, _ = w.Write([]byte(`{"data":{"apps":{"edges":[{"id":42,"name":"myapp","environments":[{"id":7,"name":"develop","type":"develop"}]}]}}}`))
-	}))
-	defer srv.Close()
-	cmd := makeEnvCmd("myapp", "develop", true)
-	mw := Chain(
-		WithAppContext(AppContextConfig{Client: gqlClientForServer(srv)}),
-		WithChildEnvContext(),
-	)
-	called := false
-	run := mw(func(cmd *cobra.Command, args []string) error {
-		called = true
-		return nil
-	})
-	if err := run(cmd, nil); err != nil {
-		t.Fatalf("run: %v", err)
-	}
-	if !called {
-		t.Error("inner not called on develop env")
-	}
-}

package/internal/appctx/format.go

@@ -1,72 +0,0 @@
-package appctx
-
-import (
-	"context"
-	"fmt"
-	"strings"
-
-	"github.com/spf13/cobra"
-
-	"github.com/Automattic/vip/internal/output"
-)
-
-// RenderableRunFunc is the handler shape WithFormat wraps. Handlers return
-// data (one of output.HeaderData | output.OrderedRows | output.Rows | nil)
-// plus an error. WithFormat dispatches the data to output.Render with the
-// validated format.
-type RenderableRunFunc func(cmd *cobra.Command, args []string) (any, error)
-
-type formatKey struct{}
-
-// WithFormat adds the --format flag (default defaultFormat), validates against
-// `allowed`, stashes the resolved format in cmd.Context() (read via
-// FormatFromContext), and wraps the handler return through output.Render.
-//
-// cmd is the cobra.Command the flag should be registered on. --format is
-// registered immediately at apply time (not lazily inside RunE) so cobra can
-// parse it before the command runs.
-//
-// Use via Builder.WithRenderableRun so the (any, error) shape is preserved.
-func WithFormat(cmd *cobra.Command, defaultFormat string, allowed ...string) func(RenderableRunFunc) RenderableRunFunc {
-	allowedSet := make(map[string]bool, len(allowed))
-	for _, a := range allowed {
-		allowedSet[a] = true
-	}
-	// Register the flag immediately at apply time so cobra can parse it before
-	// RunE is invoked. Previously this was done lazily inside the closure,
-	// which caused "unknown flag: --format" errors at parse time.
-	ensureFormatFlag(cmd, defaultFormat)
-	return func(next RenderableRunFunc) RenderableRunFunc {
-		return func(cmd *cobra.Command, args []string) (any, error) {
-			f, _ := cmd.Flags().GetString("format")
-			if f == "" {
-				f = defaultFormat
-			}
-			if !allowedSet[f] {
-				return nil, fmt.Errorf("Invalid format: %s. The supported formats are: %s.",
-					f, strings.Join(allowed, ", "))
-			}
-			cmd.SetContext(context.WithValue(cmd.Context(), formatKey{}, output.Format(f)))
-			data, err := next(cmd, args)
-			if err != nil {
-				return nil, err
-			}
-			return data, output.Render(cmd.OutOrStdout(), output.Format(f), data)
-		}
-	}
-}
-
-func ensureFormatFlag(cmd *cobra.Command, defaultFormat string) {
-	if cmd.Flags().Lookup("format") == nil {
-		cmd.Flags().String("format", defaultFormat,
-			"Render output in a particular format.")
-	}
-}
-
-// FormatFromContext returns the format resolved by WithFormat, or empty.
-func FormatFromContext(ctx context.Context) output.Format {
-	if v, ok := ctx.Value(formatKey{}).(output.Format); ok {
-		return v
-	}
-	return ""
-}

package/internal/appctx/format_test.go

@@ -1,75 +0,0 @@
-package appctx
-
-import (
-	"bytes"
-	"context"
-	"strings"
-	"testing"
-
-	"github.com/spf13/cobra"
-
-	"github.com/Automattic/vip/internal/output"
-)
-
-// TestWithFormatRegistersFlagBeforeParse pins the bug where ensureFormatFlag
-// was called lazily inside the RunE closure. With the fix, WithFormat must
-// register --format at apply time so cobra can parse it before RunE runs.
-func TestWithFormatRegistersFlagBeforeParse(t *testing.T) {
-	cmd := &cobra.Command{Use: "x"}
-	WithFormat(cmd, "table", "table", "json")
-	if cmd.Flag("format") == nil {
-		t.Fatal("WithFormat must register --format at apply time, not lazily inside RunE")
-	}
-}
-
-func TestWithFormatDefaultsRendersTable(t *testing.T) {
-	cmd := &cobra.Command{Use: "x"}
-	var buf bytes.Buffer
-	cmd.SetOut(&buf)
-	cmd.SetContext(context.Background())
-
-	mw := WithFormat(cmd, "table", "table", "csv", "json")
-	run := mw(func(cmd *cobra.Command, args []string) (any, error) {
-		return output.OrderedRows{{{Key: "id", Value: 1}}}, nil
-	})
-	if _, err := run(cmd, nil); err != nil {
-		t.Fatalf("run: %v", err)
-	}
-	if !strings.Contains(buf.String(), "1") {
-		t.Errorf("table output missing data: %s", buf.String())
-	}
-}
-
-func TestWithFormatRejectsUnknownFormat(t *testing.T) {
-	cmd := &cobra.Command{Use: "x"}
-	cmd.SetContext(context.Background())
-	cmd.Flags().String("format", "yaml", "")
-	mw := WithFormat(cmd, "table", "table", "csv")
-	run := mw(func(cmd *cobra.Command, args []string) (any, error) {
-		t.Error("handler must not run on rejected format")
-		return nil, nil
-	})
-	_, err := run(cmd, nil)
-	wantSubstr := "Invalid format: yaml. The supported formats are: table, csv."
-	if err == nil || !strings.Contains(err.Error(), wantSubstr) {
-		t.Errorf("err = %v, want contains %q", err, wantSubstr)
-	}
-}
-
-func TestWithFormatExposesViaFormatFromContext(t *testing.T) {
-	cmd := &cobra.Command{Use: "x"}
-	cmd.SetContext(context.Background())
-	cmd.Flags().String("format", "json", "")
-	mw := WithFormat(cmd, "table", "table", "json")
-	var seen output.Format
-	run := mw(func(cmd *cobra.Command, args []string) (any, error) {
-		seen = FormatFromContext(cmd.Context())
-		return nil, nil
-	})
-	if _, err := run(cmd, nil); err != nil {
-		t.Fatalf("run: %v", err)
-	}
-	if seen != output.FormatJSON {
-		t.Errorf("FormatFromContext = %q, want json", seen)
-	}
-}

package/internal/appctx/interactive.go

@@ -1,50 +0,0 @@
-package appctx
-
-import (
-	"os"
-
-	"github.com/spf13/cobra"
-	"golang.org/x/term"
-)
-
-// IsInteractive reports whether prompts and browser opens are appropriate for
-// the current invocation. Single source of truth for anything cobra drives; it
-// replaced defensivemode.IsInteractive, since deleted along with the rest of an
-// unused helper file. rechallenge.IsInteractiveContext survives as the fallback
-// for the step-up middleware, which is built before any command is parsed and
-// so has no *cobra.Command to read.
-//
-// Precedence:
-//  1. VIP_NON_INTERACTIVE=1 -> false
-//  2. --non-interactive flag (on cmd or any ancestor via PersistentFlags) -> false
-//  3. stdin is a TTY -> true; otherwise false.
-//
-// The sensor is STDIN because that is the descriptor an answer has to arrive
-// on. It used to be stdout, which meant `vip sync … | tee`, `> log` or `| less`
-// reported "Command cancelled" and exited 0 with the mutation never issued
-// (parity blocker B5). Node's enquirer reads stdin and is likewise unaffected
-// by stdout redirection.
-//
-// This is deliberately NOT the same question as "can I render progress?" —
-// that one is about where bytes are safe to draw and is sensed separately on
-// os.Stderr (commands/progress_renderer.go, commands/sync.go), so that progress
-// stays out of a redirected stdout and can never corrupt --format json.
-func IsInteractive(cmd *cobra.Command) bool {
-	return isInteractiveCheck(cmd, term.IsTerminal(int(os.Stdin.Fd())))
-}
-
-func isInteractiveCheck(cmd *cobra.Command, tty bool) bool {
-	if os.Getenv("VIP_NON_INTERACTIVE") == "1" {
-		return false
-	}
-	if cmd != nil {
-		// cmd.Flag walks the local + persistent flag tables — covers ancestors
-		// when PersistentFlags propagation has merged through ParseFlags. Read
-		// the value off the *pflag.Flag directly (Flags().GetBool fails before
-		// Cobra's lazy persistent-flag merge has run).
-		if f := cmd.Flag("non-interactive"); f != nil && f.Changed && f.Value.String() == "true" {
-			return false
-		}
-	}
-	return tty
-}

package/internal/appctx/interactive_test.go

@@ -1,134 +0,0 @@
-package appctx
-
-import (
-	"os"
-	"testing"
-
-	"github.com/creack/pty"
-	"github.com/spf13/cobra"
-)
-
-// swapStdio points os.Stdin/os.Stdout at the given files for the duration of
-// the test. The existing isInteractiveCheck tests inject the tty bool, so they
-// pass no matter WHICH descriptor the real IsInteractive senses — these two
-// tests pin that down.
-func swapStdio(t *testing.T, in, out *os.File) {
-	t.Helper()
-	origIn, origOut := os.Stdin, os.Stdout
-	os.Stdin, os.Stdout = in, out
-	t.Cleanup(func() { os.Stdin, os.Stdout = origIn, origOut })
-}
-
-func openPTY(t *testing.T) *os.File {
-	t.Helper()
-	ptmx, tty, err := pty.Open()
-	if err != nil {
-		t.Skipf("pty unavailable: %v", err)
-	}
-	t.Cleanup(func() { _ = ptmx.Close(); _ = tty.Close() })
-	return tty
-}
-
-func regularFile(t *testing.T) *os.File {
-	t.Helper()
-	f, err := os.CreateTemp(t.TempDir(), "redirected")
-	if err != nil {
-		t.Fatal(err)
-	}
-	t.Cleanup(func() { _ = f.Close() })
-	return f
-}
-
-func interactiveTestCmd() *cobra.Command {
-	cmd := &cobra.Command{Use: "x"}
-	cmd.PersistentFlags().Bool("non-interactive", false, "")
-	return cmd
-}
-
-// Regression for parity blocker B5. Interactivity was sensed on os.Stdout, so
-// `vip sync … > log`, `| tee` or `| less` printed "Command cancelled" and exited
-// 0 with the mutation never issued — the user believed the sync had run. Node's
-// enquirer reads stdin and is unaffected by stdout redirection.
-func TestIsInteractiveSensesStdinNotStdout(t *testing.T) {
-	swapStdio(t, openPTY(t), regularFile(t))
-	if !IsInteractive(interactiveTestCmd()) {
-		t.Error("stdin is a TTY and only stdout is redirected: prompting must still be possible")
-	}
-}
-
-// The converse: a piped stdin cannot answer a prompt, even when stdout is a
-// terminal (`vip sync < /dev/null` must not block waiting for an answer).
-func TestIsInteractiveFalseWhenStdinIsNotATTY(t *testing.T) {
-	swapStdio(t, regularFile(t), openPTY(t))
-	if IsInteractive(interactiveTestCmd()) {
-		t.Error("stdin is not a TTY: prompting is impossible regardless of stdout")
-	}
-}
-
-func TestIsInteractiveDefaults(t *testing.T) {
-	cmd := &cobra.Command{Use: "x"}
-	cmd.PersistentFlags().Bool("non-interactive", false, "")
-	if got := isInteractiveCheck(cmd, true); !got {
-		t.Errorf("interactive in a TTY with no overrides should be true, got %v", got)
-	}
-	if got := isInteractiveCheck(cmd, false); got {
-		t.Errorf("non-TTY should be false")
-	}
-}
-
-func TestIsInteractiveHonorsFlag(t *testing.T) {
-	cmd := &cobra.Command{Use: "x"}
-	cmd.PersistentFlags().Bool("non-interactive", false, "")
-	// Set via the PersistentFlags bucket the flag was defined on. Cobra only
-	// merges persistent flags into the local Flags() set lazily (during
-	// ParseFlags/Execute), so a direct Flags().Set on a never-executed command
-	// would fail. By real-command-execution time the merge has happened and
-	// cmd.Flag("non-interactive") finds it regardless.
-	if err := cmd.PersistentFlags().Set("non-interactive", "true"); err != nil {
-		t.Fatalf("flag set: %v", err)
-	}
-	if isInteractiveCheck(cmd, true) {
-		t.Error("--non-interactive must disable interactivity even on TTY")
-	}
-}
-
-func TestIsInteractiveHonorsEnv(t *testing.T) {
-	t.Setenv("VIP_NON_INTERACTIVE", "1")
-	cmd := &cobra.Command{Use: "x"}
-	cmd.PersistentFlags().Bool("non-interactive", false, "")
-	if isInteractiveCheck(cmd, true) {
-		t.Error("VIP_NON_INTERACTIVE=1 must disable interactivity")
-	}
-}
-
-// PersistentFlags propagation: a flag defined on parent must be honored when
-// the test passes the child command in. (Cobra resolves PersistentFlags
-// through cmd.Flag() on subcommands; this test pins the contract that the
-// implementation walks the command tree correctly.)
-func TestIsInteractiveHonorsPersistentFlagOnParent(t *testing.T) {
-	parent := &cobra.Command{Use: "parent"}
-	parent.PersistentFlags().Bool("non-interactive", false, "")
-	child := &cobra.Command{Use: "child"}
-	parent.AddCommand(child)
-	// Cobra normally executes the full command tree (which propagates flags);
-	// in unit tests we trigger the merge by calling Execute or ParseFlags.
-	parent.SetArgs([]string{"child", "--non-interactive=true"})
-	if err := parent.Execute(); err != nil {
-		// child has no RunE — Execute returns the "no RunE" error or similar;
-		// that's fine, we only need the flag-parsing side-effect.
-		_ = err
-	}
-	if isInteractiveCheck(child, true) {
-		t.Error("--non-interactive defined on parent (PersistentFlags) must disable interactivity for child")
-	}
-}
-
-func TestIsInteractiveNilCmd(t *testing.T) {
-	// Defensive: a nil cobra command shouldn't panic; treat as if no flag is set.
-	if got := isInteractiveCheck(nil, true); !got {
-		t.Errorf("nil cmd + TTY should default to interactive=true, got %v", got)
-	}
-	if got := isInteractiveCheck(nil, false); got {
-		t.Errorf("nil cmd + non-TTY should be false, got %v", got)
-	}
-}

package/internal/appctx/middleware.go

@@ -1,56 +0,0 @@
-// Package appctx composes command middleware. In M2 the only middleware is
-// WithTelemetry; later milestones add WithAppContext / WithEnvContext /
-// WithFormat / WithConfirm. Spec §4.3.
-package appctx
-
-import "github.com/spf13/cobra"
-
-type RunFunc func(cmd *cobra.Command, args []string) error
-
-type Middleware func(next RunFunc) RunFunc
-
-type Builder struct {
-	cmd        *cobra.Command
-	middleware []Middleware
-}
-
-func Build(cmd *cobra.Command, mw ...Middleware) *Builder {
-	return &Builder{cmd: cmd, middleware: mw}
-}
-
-func (b *Builder) WithRun(base RunFunc) *cobra.Command {
-	chain := base
-	for i := len(b.middleware) - 1; i >= 0; i-- {
-		chain = b.middleware[i](chain)
-	}
-	b.cmd.RunE = chain
-	return b.cmd
-}
-
-// WithRenderableRun finalizes the builder for handlers that return (any, error).
-// Use this when the chain includes WithFormat. Pure-error handlers use WithRun.
-//
-// The base RenderableRunFunc should ALREADY be wrapped with WithFormat (the
-// innermost middleware closest to the handler) so output.Render runs against
-// the data return. Builder's outer middleware slice receives a RunFunc
-// adapter that discards the any return after rendering.
-func (b *Builder) WithRenderableRun(base RenderableRunFunc) *cobra.Command {
-	finalAsRun := RunFunc(func(cmd *cobra.Command, args []string) error {
-		_, err := base(cmd, args)
-		return err
-	})
-	return b.WithRun(finalAsRun)
-}
-
-// Chain composes middlewares left-to-right: Chain(a, b)(next) == a(b(next)).
-// Useful when a handler needs multiple middlewares but they're not wrapped
-// by a Builder.
-func Chain(mw ...Middleware) Middleware {
-	return func(next RunFunc) RunFunc {
-		chain := next
-		for i := len(mw) - 1; i >= 0; i-- {
-			chain = mw[i](chain)
-		}
-		return chain
-	}
-}

package/internal/appctx/middleware_test.go

@@ -1,88 +0,0 @@
-package appctx
-
-import (
-	"testing"
-
-	"github.com/spf13/cobra"
-)
-
-func TestMiddlewareChainExecutionOrder(t *testing.T) {
-	var calls []string
-	mw1 := func(next RunFunc) RunFunc {
-		return func(cmd *cobra.Command, args []string) error {
-			calls = append(calls, "mw1-before")
-			err := next(cmd, args)
-			calls = append(calls, "mw1-after")
-			return err
-		}
-	}
-	mw2 := func(next RunFunc) RunFunc {
-		return func(cmd *cobra.Command, args []string) error {
-			calls = append(calls, "mw2-before")
-			err := next(cmd, args)
-			calls = append(calls, "mw2-after")
-			return err
-		}
-	}
-	base := func(cmd *cobra.Command, args []string) error {
-		calls = append(calls, "handler")
-		return nil
-	}
-	cmd := &cobra.Command{Use: "test"}
-	wrapped := Build(cmd, mw1, mw2).WithRun(base)
-	if err := wrapped.RunE(wrapped, []string{}); err != nil {
-		t.Fatalf("RunE: %v", err)
-	}
-	want := []string{"mw1-before", "mw2-before", "handler", "mw2-after", "mw1-after"}
-	if !equalStrings(calls, want) {
-		t.Errorf("calls = %v, want %v", calls, want)
-	}
-}
-
-func equalStrings(a, b []string) bool {
-	if len(a) != len(b) {
-		return false
-	}
-	for i := range a {
-		if a[i] != b[i] {
-			return false
-		}
-	}
-	return true
-}
-
-func TestChainComposesLeftToRight(t *testing.T) {
-	var calls []string
-	a := func(next RunFunc) RunFunc {
-		return func(cmd *cobra.Command, args []string) error {
-			calls = append(calls, "a-pre")
-			err := next(cmd, args)
-			calls = append(calls, "a-post")
-			return err
-		}
-	}
-	b := func(next RunFunc) RunFunc {
-		return func(cmd *cobra.Command, args []string) error {
-			calls = append(calls, "b-pre")
-			err := next(cmd, args)
-			calls = append(calls, "b-post")
-			return err
-		}
-	}
-	core := func(cmd *cobra.Command, args []string) error {
-		calls = append(calls, "core")
-		return nil
-	}
-	if err := Chain(a, b)(core)(&cobra.Command{}, nil); err != nil {
-		t.Fatalf("err: %v", err)
-	}
-	want := []string{"a-pre", "b-pre", "core", "b-post", "a-post"}
-	if len(calls) != len(want) {
-		t.Fatalf("len(calls) = %d, want %d (calls=%v)", len(calls), len(want), calls)
-	}
-	for i := range want {
-		if calls[i] != want[i] {
-			t.Errorf("calls[%d] = %q, want %q", i, calls[i], want[i])
-		}
-	}
-}