audita/internal/cli/process_command_integration_test.go

package cli

import (
	"bytes"
	"context"
	"errors"
	"os"
	"path/filepath"
	"strings"
	"testing"

	commandkit "go.maximumdirect.net/commandkit"
	ck "go.maximumdirect.net/configkit"
)

func TestProcessShowsConfigurationLoadDiagnostics(t *testing.T) {
	app, err := buildApplication()
	if err != nil {
		t.Fatal(err)
	}
	for _, tc := range []struct {
		name, config, finding string
	}{
		{"obsolete version", "version: 2\n", "docs/migrations/v3.md"},
		{"invalid retry budget", "version: 3\nllm: {transient_retries: -1}\n", "retry budget must be non-negative"},
	} {
		t.Run(tc.name, func(t *testing.T) {
			dir := t.TempDir()
			configPath := filepath.Join(dir, "config.yml")
			if err := os.WriteFile(configPath, []byte(tc.config), 0600); err != nil {
				t.Fatal(err)
			}
			output := filepath.Join(dir, "out.json")
			var out, stderr bytes.Buffer
			args := []string{"process", "--quiet", "--config", configPath, "--output", output, filepath.Join(dir, "transcript.json")}
			result := app.Execute(context.Background(), args, commandkit.Streams{Out: &out, Err: &stderr})
			var loadErr *ck.LoadError
			if result.Status != 2 || !errors.As(result.Cause, &loadErr) || out.Len() != 0 ||
				!strings.Contains(stderr.String(), tc.finding) || !strings.Contains(stderr.String(), configPath) {
				t.Fatalf("status=%d cause=%v out=%q err=%q", result.Status, result.Cause, out.String(), stderr.String())
			}
			entries, err := os.ReadDir(dir)
			if err != nil || len(entries) != 1 {
				t.Fatalf("outputs created on load failure: %v, err=%v", entries, err)
			}
		})
	}
}

func TestProcessUsesResolvedReportingMode(t *testing.T) {
	dir := t.TempDir()
	for name, contents := range map[string]string{
		"config.yml":      "version: 3\npipeline:\n  stages: []\nreporting:\n  enabled: false\n",
		"transcript.json": `[{"speaker":"Alice","start":0,"end":1,"text":"hello"}]`,
		"blocked":         "file",
	} {
		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0644); err != nil {
			t.Fatal(err)
		}
	}
	app, err := buildApplication()
	if err != nil {
		t.Fatal(err)
	}
	for _, tc := range []struct {
		name    string
		flags   []string
		status  int
		stdout  bool
		info    bool
		warning bool
	}{
		{"ordinary", nil, 0, true, false, false},
		{"verbose", []string{"--verbose"}, 0, true, true, false},
		{"quiet stdout", []string{"--quiet"}, 2, false, false, false},
		{"quiet file", []string{"--quiet", "--output", filepath.Join(dir, "quiet.json")}, 0, false, false, false},
		{"verbose after quiet", []string{"--quiet", "--verbose"}, 0, true, true, false},
		{"quiet after verbose", []string{"--verbose", "--quiet", "--output", filepath.Join(dir, "ordered.json")}, 0, false, false, false},
		{"debug disabled", []string{"--debug=false", "--work-dir", filepath.Join(dir, "blocked")}, 0, true, false, false},
		{"debug failure", []string{"--debug", "--work-dir", filepath.Join(dir, "blocked")}, 0, true, true, true},
		{"debug quiet", []string{"--debug", "--quiet", "--output", filepath.Join(dir, "debug-quiet.json"), "--work-dir", filepath.Join(dir, "blocked")}, 0, false, false, false},
	} {
		t.Run(tc.name, func(t *testing.T) {
			var out, stderr bytes.Buffer
			args := []string{"process", "--config", filepath.Join(dir, "config.yml")}
			args = append(args, tc.flags...)
			args = append(args, filepath.Join(dir, "transcript.json"))
			result := app.Execute(context.Background(), args, commandkit.Streams{Out: &out, Err: &stderr})
			if result.Status != tc.status || (out.Len() > 0) != tc.stdout || strings.Contains(stderr.String(), "Completed:") != tc.info || strings.Contains(stderr.String(), "Debug artifact:") != tc.warning {
				t.Fatalf("status=%d out=%q err=%q", result.Status, out.String(), stderr.String())
			}
		})
	}
}

func TestProcessChecksOnlyTheActiveReportDirectory(t *testing.T) {
	for _, tc := range []struct {
		name       string
		flags      []string
		wantReport bool
		wantError  bool
	}{
		{"file output ignores blank configured directory", nil, true, false},
		{"explicit blank directory", []string{"--report-dir="}, false, true},
		{"disabled reporting ignores explicit blank directory", []string{"--reporting=false", "--report-dir="}, false, false},
	} {
		t.Run(tc.name, func(t *testing.T) {
			dir := t.TempDir()
			configPath := filepath.Join(dir, "config.yml")
			if err := os.WriteFile(configPath, []byte("version: 3\npipeline: {stages: []}\nreporting: {stdout_dir: ''}\n"), 0600); err != nil {
				t.Fatal(err)
			}
			transcript := filepath.Join(dir, "transcript.json")
			if err := os.WriteFile(transcript, []byte(`[{"speaker":"Alice","start":0,"end":1,"text":"hello"}]`), 0600); err != nil {
				t.Fatal(err)
			}
			output := filepath.Join(dir, "output.json")
			args := append([]string{"process", "--config", configPath, "--output", output}, tc.flags...)
			var stdout, stderr bytes.Buffer
			status := Run(context.Background(), append(args, transcript), &stdout, &stderr)
			if (status != 0) != tc.wantError || (tc.wantError && !strings.Contains(stderr.String(), "report directory is required")) {
				t.Fatalf("status=%d stdout=%q stderr=%q", status, stdout.String(), stderr.String())
			}
			_, err := os.Stat(filepath.Join(dir, "errors.yml"))
			if (tc.wantReport && err != nil) || (!tc.wantReport && !os.IsNotExist(err)) {
				t.Fatalf("report file: %v, want present=%t", err, tc.wantReport)
			}
		})
	}
}

func TestProcessCollectionFlags(t *testing.T) {
	dir := t.TempDir()
	for name, contents := range map[string]string{
		"config.yml":      "version: 3\npipeline:\n  stages: []\nreporting:\n  enabled: false\nglossary_collections:\n  party: {entries: []}\n",
		"transcript.json": `[{"speaker":"Alice","start":0,"end":1,"text":"hello"}]`,
	} {
		if err := os.WriteFile(filepath.Join(dir, name), []byte(contents), 0644); err != nil {
			t.Fatal(err)
		}
	}
	app, err := buildApplication()
	if err != nil {
		t.Fatal(err)
	}
	for _, tc := range []struct {
		value  string
		status int
	}{{`["party"]`, 0}, {`[]`, 0}, {`null`, 0}, {`[1]`, 2}, {`"party"`, 2}} {
		var out, stderr bytes.Buffer
		args := []string{"process", "--config", filepath.Join(dir, "config.yml"), "--glossaries", tc.value, filepath.Join(dir, "transcript.json")}
		outcome := app.Execute(context.Background(), args, commandkit.Streams{Out: &out, Err: &stderr})
		if outcome.Status != tc.status {
			t.Fatalf("value=%q status=%d out=%q err=%q", tc.value, outcome.Status, out.String(), stderr.String())
		}
	}
}