test(cmd): cover --jq fail-fast wiring

Add a hermetic test proving the root command's PersistentPreRunE runs
GlobalOpts.PreRun and rejects an invalid --jq expression before any
subcommand's RunE builds a client or reaches the network. A test-only probe
subcommand records whether its RunE ran; the fail-fast path leaves it
untouched, and a control case confirms a valid expression lets it run.

Also note at the assignment that this is the sole PersistentPreRunE in the
tree, so a subcommand defining its own would silently disable --jq
fail-fast validation.

Author: a68366

internal/cmd/root.go

@@ -39,6 +39,9 @@ func NewRootCmd() *cobra.Command {
 	pf.BoolVarP(&g.Quiet, "quiet", "q", false, "Suppress non-essential output")
 	pf.StringVar(&g.JQ, "jq", "", "Filter JSON output with a jq expression")
 
+	// Sole PersistentPreRunE in the tree — cobra runs only the closest such hook,
+	// so a subcommand defining its own would silently suppress this and disable
+	// --jq fail-fast validation.
 	root.PersistentPreRunE = func(cmd *cobra.Command, args []string) error {
 		return g.PreRun()
 	}

internal/cmd/root_test.go

@@ -1,6 +1,12 @@
 package cmd
 
-import "testing"
+import (
+	"io"
+	"strings"
+	"testing"
+
+	"github.com/spf13/cobra"
+)
 
 func TestNewRootCmdRegistersJQFlag(t *testing.T) {
 	root := NewRootCmd()
@@ -9,3 +15,66 @@ func TestNewRootCmdRegistersJQFlag(t *testing.T) {
 		t.Fatal("expected root command to register a persistent --jq flag")
 	}
 }
+
+// newProbeRoot returns the real root command (with its PersistentPreRunE
+// wiring) plus a test-only "probe" subcommand that records whether its RunE
+// ran. The probe stands in for a real API-calling command (ping, task list, …)
+// but touches neither config nor the network, so the tests below stay
+// hermetic and deterministic in CI.
+func newProbeRoot(ran *bool) *cobra.Command {
+	root := NewRootCmd()
+	root.AddCommand(&cobra.Command{
+		Use:  "probe",
+		Args: cobra.NoArgs,
+		RunE: func(*cobra.Command, []string) error {
+			*ran = true
+			return nil
+		},
+	})
+	root.SetOut(io.Discard)
+	root.SetErr(io.Discard)
+	return root
+}
+
+// TestPersistentPreRunEFailsFastOnInvalidJQ proves the root command's
+// PersistentPreRunE wiring runs GlobalOpts.PreRun and rejects an invalid --jq
+// expression before any subcommand's RunE executes — i.e. before a client is
+// built or the network is reached. The probe subcommand inherits root's
+// PersistentPreRunE (cobra runs the closest hook), so its RunE must stay
+// untouched on the fail-fast path.
+func TestPersistentPreRunEFailsFastOnInvalidJQ(t *testing.T) {
+	var ranRunE bool
+	root := newProbeRoot(&ranRunE)
+	root.SetArgs([]string{"probe", "--jq", "("})
+
+	err := root.Execute()
+	if err == nil {
+		t.Fatal("expected an error from the invalid --jq expression")
+	}
+	// Assert the specific compile error, not merely that some error occurred, so
+	// this distinguishes a PreRun short-circuit from a RunE/config/network
+	// failure — only the former proves the wiring runs and fails fast.
+	if !strings.Contains(err.Error(), "invalid --jq expression") {
+		t.Fatalf("error = %q, want it to contain %q", err.Error(), "invalid --jq expression")
+	}
+	if ranRunE {
+		t.Fatal("subcommand RunE ran; PreRun did not short-circuit before the command executed")
+	}
+}
+
+// TestPersistentPreRunERunsRunEForValidJQ is the control for the fail-fast
+// test: with a valid --jq the same probe subcommand's RunE does run. Without
+// this, the fail-fast assertion could pass vacuously (e.g. if the probe never
+// ran for an unrelated reason).
+func TestPersistentPreRunERunsRunEForValidJQ(t *testing.T) {
+	var ranRunE bool
+	root := newProbeRoot(&ranRunE)
+	root.SetArgs([]string{"probe", "--jq", ".task.id"})
+
+	if err := root.Execute(); err != nil {
+		t.Fatalf("unexpected error with a valid --jq: %v", err)
+	}
+	if !ranRunE {
+		t.Fatal("probe RunE did not run with a valid --jq; the fail-fast assertion would be vacuous")
+	}
+}