WeKnora deployment source with the reviewed wiki identity, summary and recovery fixes

cli/internal/cmdutil/format_test.go

@@ -0,0 +1,276 @@
+package cmdutil
+
+import (
+	"bytes"
+	"encoding/json"
+	"errors"
+	"strings"
+	"testing"
+
+	"github.com/spf13/cobra"
+)
+
+func TestCheckFormatFlags(t *testing.T) {
+	cases := []struct {
+		name     string
+		args     []string
+		wantMode FormatMode // FormatText | FormatJSON | FormatNDJSON | "" (unset)
+		wantErr  bool
+	}{
+		// Unset → Mode is "" (caller resolves default via ResolveDefault).
+		{"default", []string{}, "", false},
+		{"explicit text", []string{"--format", "text"}, FormatText, false},
+		{"json", []string{"--format", "json"}, FormatJSON, false},
+		{"ndjson", []string{"--format", "ndjson"}, FormatNDJSON, false},
+		{"invalid value", []string{"--format", "yaml"}, "", true},
+		{"human rejected", []string{"--format", "human"}, "", true},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			cmd := &cobra.Command{}
+			// --format / --jq are persistent root flags in production; register
+			// them on this bare cmd so the test can exercise CheckFormatFlag in
+			// isolation.
+			cmd.PersistentFlags().String("format", "", "")
+			cmd.PersistentFlags().String("jq", "", "")
+			cmd.SetArgs(tc.args)
+			cmd.RunE = func(c *cobra.Command, _ []string) error {
+				opts, err := CheckFormatFlag(c)
+				if (err != nil) != tc.wantErr {
+					t.Fatalf("err=%v wantErr=%v", err, tc.wantErr)
+				}
+				if err == nil && opts.Mode != tc.wantMode {
+					t.Errorf("mode=%q want %q", opts.Mode, tc.wantMode)
+				}
+				return nil
+			}
+			_ = cmd.Execute()
+		})
+	}
+}
+
+func TestFormatOptions_NDJSONSplitsList(t *testing.T) {
+	var buf bytes.Buffer
+	fopts := &FormatOptions{Mode: FormatNDJSON}
+	arr := []map[string]string{{"id": "a"}, {"id": "b"}}
+	if err := fopts.Emit(&buf, arr, nil); err != nil {
+		t.Fatalf("Emit: %v", err)
+	}
+	want := `{"id":"a"}` + "\n" + `{"id":"b"}` + "\n"
+	if buf.String() != want {
+		t.Errorf("got %q want %q", buf.String(), want)
+	}
+}
+
+func TestFormatOptions_JSONEmitsArray(t *testing.T) {
+	var buf bytes.Buffer
+	fopts := &FormatOptions{Mode: FormatJSON}
+	arr := []map[string]string{{"id": "a"}, {"id": "b"}}
+	if err := fopts.Emit(&buf, arr, nil); err != nil {
+		t.Fatalf("Emit: %v", err)
+	}
+	// v0.7: JSON path wraps in success envelope {ok:true, data:[...]}.
+	// Unmarshal the envelope and check data array length.
+	var env struct {
+		OK   bool                `json:"ok"`
+		Data []map[string]string `json:"data"`
+	}
+	if err := json.Unmarshal(buf.Bytes(), &env); err != nil {
+		t.Fatalf("not valid envelope JSON: %v\n%s", err, buf.String())
+	}
+	if !env.OK {
+		t.Errorf("expected ok:true in envelope")
+	}
+	if len(env.Data) != 2 {
+		t.Errorf("got %d items, want 2", len(env.Data))
+	}
+}
+
+func TestFormatOptions_TextModeReturnsError(t *testing.T) {
+	fopts := &FormatOptions{Mode: FormatText}
+	err := fopts.Emit(&bytes.Buffer{}, map[string]string{"a": "b"}, nil)
+	if err == nil {
+		t.Error("expected error for text mode, got nil")
+	}
+}
+
+// TestResolveDefault_AlwaysJSON verifies v0.7 semantics: default is FormatJSON
+// regardless of whether stdout is a TTY (BREAKING change from v0.6).
+// TestResolveDefault_AlwaysJSON pins the deliberate JSON-always default (no
+// TTY switch to text): the default output never depends on whether stdout is a
+// TTY, so agents get predictable JSON. Humans opt into text with --format text.
+func TestResolveDefault_AlwaysJSON(t *testing.T) {
+	for _, isTTY := range []bool{true, false} {
+		o := &FormatOptions{}
+		o.ResolveDefault(isTTY)
+		if o.Mode != FormatJSON {
+			t.Errorf("isTTY=%v: expected default FormatJSON, got %v", isTTY, o.Mode)
+		}
+		if o.TTY != isTTY {
+			t.Errorf("isTTY=%v: TTY field not propagated", isTTY)
+		}
+	}
+}
+
+func TestResolveDefault(t *testing.T) {
+	cases := []struct {
+		name     string
+		mode     FormatMode // pre-set Mode
+		jq       string
+		isTTY    bool
+		wantMode FormatMode
+	}{
+		// JSON-always default regardless of TTY (predictable for agents).
+		{"empty isTTY", "", "", true, FormatJSON},
+		{"empty no-tty", "", "", false, FormatJSON},
+		{"already set keeps value tty", FormatNDJSON, "", true, FormatNDJSON},
+		{"already set keeps value no-tty", FormatJSON, "", false, FormatJSON},
+		// --jq with unset --format promotes to JSON regardless of TTY so the
+		// filter has somewhere to apply (silent text drop would surprise users).
+		{"jq forces json on TTY", "", ".[]", true, FormatJSON},
+		{"jq with explicit ndjson preserved", FormatNDJSON, ".[]", true, FormatNDJSON},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			o := &FormatOptions{Mode: tc.mode, JQ: tc.jq}
+			o.ResolveDefault(tc.isTTY)
+			if o.Mode != tc.wantMode {
+				t.Errorf("mode=%q want %q", o.Mode, tc.wantMode)
+			}
+		})
+	}
+}
+
+// TestCheckFormatFlag_InvalidExitTwo guards the contract that flag-value
+// validation maps to exit 2 (FlagError class), not the unclassified bucket.
+func TestCheckFormatFlag_InvalidExitTwo(t *testing.T) {
+	cases := []struct {
+		name string
+		args []string
+	}{
+		{"invalid format value", []string{"--format", "yaml"}},
+		{"human rejected as invalid", []string{"--format", "human"}},
+		{"jq with explicit text mode", []string{"--format", "text", "--jq", ".id"}},
+	}
+	for _, tc := range cases {
+		t.Run(tc.name, func(t *testing.T) {
+			cmd := &cobra.Command{}
+			// --format / --jq are persistent root flags in production; register
+			// them on this bare cmd so the test can exercise CheckFormatFlag in
+			// isolation.
+			cmd.PersistentFlags().String("format", "", "")
+			cmd.PersistentFlags().String("jq", "", "")
+			cmd.SetArgs(tc.args)
+			var got error
+			cmd.RunE = func(c *cobra.Command, _ []string) error {
+				_, err := CheckFormatFlag(c)
+				got = err
+				return err
+			}
+			_ = cmd.Execute()
+			if got == nil {
+				t.Fatal("expected error, got nil")
+			}
+			var fe *FlagError
+			if !errors.As(got, &fe) {
+				t.Fatalf("error %v is not a *FlagError; would map to exit 1 instead of 2", got)
+			}
+			if ExitCode(got) != 2 {
+				t.Errorf("ExitCode=%d, want 2", ExitCode(got))
+			}
+		})
+	}
+}
+
+func TestCheckFormatFlag_InvalidValueRejected(t *testing.T) {
+	for _, v := range []string{"human", "yaml", "xml", "table"} {
+		v := v
+		t.Run(v, func(t *testing.T) {
+			cmd := &cobra.Command{}
+			cmd.Flags().String("format", "", "")
+			_ = cmd.Flags().Set("format", v)
+			_, err := CheckFormatFlag(cmd)
+			if err == nil {
+				t.Fatalf("expected error for --format %q", v)
+			}
+			if !strings.Contains(err.Error(), "text | json | ndjson") {
+				t.Errorf("expected enum hint for --format %q; got %v", v, err)
+			}
+		})
+	}
+}
+
+func TestCheckFormatFlag_TextAccepted(t *testing.T) {
+	cmd := &cobra.Command{}
+	cmd.Flags().String("format", "", "")
+	_ = cmd.Flags().Set("format", "text")
+	o, err := CheckFormatFlag(cmd)
+	if err != nil {
+		t.Fatalf("unexpected error: %v", err)
+	}
+	if o.Mode != FormatText {
+		t.Errorf("got %v, want FormatText", o.Mode)
+	}
+}
+
+func TestFromEnv_AppliesWEKNORA_FORMAT(t *testing.T) {
+	t.Setenv("WEKNORA_FORMAT", "ndjson")
+	o := &FormatOptions{}
+	o.FromEnv()
+	if o.Mode != FormatNDJSON {
+		t.Errorf("expected FormatNDJSON from env; got %v", o.Mode)
+	}
+}
+
+func TestFromEnv_PrecedenceFlagOverridesEnv(t *testing.T) {
+	t.Setenv("WEKNORA_FORMAT", "ndjson")
+	o := &FormatOptions{Mode: FormatJSON}
+	o.FromEnv()
+	if o.Mode != FormatJSON {
+		t.Errorf("flag should win over env; got %v", o.Mode)
+	}
+}
+
+func TestFromEnv_InvalidValueIgnored(t *testing.T) {
+	t.Setenv("WEKNORA_FORMAT", "yaml")
+	o := &FormatOptions{}
+	o.FromEnv()
+	if o.Mode != "" {
+		t.Errorf("invalid env should be ignored; got %v", o.Mode)
+	}
+}
+
+// TestResolveDefault_AppliesEnv pins that ResolveDefault honours
+// WEKNORA_FORMAT. Regression: commands call CheckFormatFlag + ResolveDefault
+// but (nearly) none called FromEnv, so the documented env var was silently
+// ignored on success output across the whole CLI until ResolveDefault folded
+// it in. This is the path every command's RunE actually takes.
+func TestResolveDefault_AppliesEnv(t *testing.T) {
+	t.Setenv("WEKNORA_FORMAT", "text")
+	o := &FormatOptions{} // no --format → Mode empty, as after CheckFormatFlag
+	o.ResolveDefault(false)
+	if o.Mode != FormatText {
+		t.Errorf("WEKNORA_FORMAT=text must drive ResolveDefault to text; got %v", o.Mode)
+	}
+}
+
+// TestResolveDefault_FlagBeatsEnv pins precedence: an explicit --format
+// (Mode already set) wins over WEKNORA_FORMAT.
+func TestResolveDefault_FlagBeatsEnv(t *testing.T) {
+	t.Setenv("WEKNORA_FORMAT", "text")
+	o := &FormatOptions{Mode: FormatJSON} // --format json supplied
+	o.ResolveDefault(false)
+	if o.Mode != FormatJSON {
+		t.Errorf("explicit --format json must beat WEKNORA_FORMAT=text; got %v", o.Mode)
+	}
+}
+
+// TestResolveDefault_NoEnvNoFlag_UsesDefault pins the fallback.
+func TestResolveDefault_NoEnvNoFlag_UsesDefault(t *testing.T) {
+	t.Setenv("WEKNORA_FORMAT", "")
+	o := &FormatOptions{}
+	o.ResolveDefault(false)
+	if o.Mode != DefaultFormatMode {
+		t.Errorf("no flag + no env must fall back to default %v; got %v", DefaultFormatMode, o.Mode)
+	}
+}