281 lines
11 KiB
Go
281 lines
11 KiB
Go
package cli
|
|
|
|
import (
|
|
"errors"
|
|
"io"
|
|
"os"
|
|
"path/filepath"
|
|
"strings"
|
|
"testing"
|
|
|
|
ck "gitea.maximumdirect.net/eric/ConfigKit"
|
|
"gitea.maximumdirect.net/eric/audita/v3/internal/core/config"
|
|
)
|
|
|
|
func TestSharedConfigInput(t *testing.T) {
|
|
for _, command := range []string{"process", "validate", "print-effective"} {
|
|
t.Run(command, func(t *testing.T) {
|
|
args := []string{"--config", "main.yml", "--overlay", "testing", "--proposal-profile", "economy", "--modules", "", "--target-sections", "0"}
|
|
if command == "process" {
|
|
args = append([]string{"transcript.json", "--glossary", "glossary.yml"}, args...)
|
|
}
|
|
input, help, err := parseConfigInput(command, args, io.Discard)
|
|
if err != nil || help {
|
|
t.Fatalf("parse: %+v %v %v", input, help, err)
|
|
}
|
|
if !input.ConfigPathSet || input.ConfigPath != "main.yml" || input.Overlay != "testing" || len(input.Overrides) != 3 {
|
|
t.Fatalf("selection: %+v", input)
|
|
}
|
|
for _, override := range input.Overrides {
|
|
switch override.Path.String() {
|
|
case ck.Keys("pipeline", "modules").String():
|
|
if values, ok := override.Value.([]any); !ok || len(values) != 0 {
|
|
t.Fatalf("empty modules: %#v", override.Value)
|
|
}
|
|
case ck.Keys("chunking", "target_sections").String():
|
|
if override.Value != 0 {
|
|
t.Fatalf("zero target: %#v", override.Value)
|
|
}
|
|
}
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestConfigInputRejectsRemovedAndProcessOnlyFlags(t *testing.T) {
|
|
for _, command := range []string{"process", "validate", "print-effective"} {
|
|
for _, flag := range []string{"--model", "--llm-api-key", "--max-retries", "--llm-concurrency", "--report-json", "--work-dir-retention"} {
|
|
args := []string{flag, "value"}
|
|
if command == "process" {
|
|
args = append([]string{"transcript.json", "--glossary", "glossary.yml"}, args...)
|
|
}
|
|
if _, _, err := parseConfigInput(command, args, io.Discard); err == nil {
|
|
t.Fatalf("%s accepted %s", command, flag)
|
|
}
|
|
}
|
|
}
|
|
for _, command := range []string{"validate", "print-effective"} {
|
|
if _, _, err := parseConfigInput(command, []string{"--glossary", "glossary.yml"}, io.Discard); err == nil {
|
|
t.Fatalf("%s accepted process path", command)
|
|
}
|
|
if _, _, err := parseConfigInput(command, []string{"transcript.json"}, io.Discard); err == nil {
|
|
t.Fatalf("%s accepted positional", command)
|
|
}
|
|
}
|
|
for _, command := range []string{"process", "validate", "print-effective"} {
|
|
_, help, err := parseConfigInput(command, []string{"--help"}, io.Discard)
|
|
if err != nil || !help {
|
|
t.Fatalf("%s help: %v %v", command, help, err)
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestConfigSelection(t *testing.T) {
|
|
dir := t.TempDir()
|
|
first, second := filepath.Join(dir, "first.yml"), filepath.Join(dir, "second.yml")
|
|
if err := os.WriteFile(second, []byte("version: 2\n"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
path, source, err := selectConfigPath("", false, os.Stat, []string{first, second})
|
|
if err != nil || path != second || source != "default" {
|
|
t.Fatalf("discovery: %q %q %v", path, source, err)
|
|
}
|
|
for _, tc := range []struct {
|
|
explicit string
|
|
set bool
|
|
candidates []string
|
|
}{
|
|
{"", true, []string{second}}, {first, true, []string{second}}, {"", false, []string{first}},
|
|
} {
|
|
if _, _, err := selectConfigPath(tc.explicit, tc.set, os.Stat, tc.candidates); err == nil {
|
|
t.Fatalf("accepted unavailable selection: %+v", tc)
|
|
}
|
|
}
|
|
statDenied := func(string) (os.FileInfo, error) { return nil, os.ErrPermission }
|
|
if _, _, err := selectConfigPath("", false, statDenied, []string{first}); !errors.Is(err, os.ErrPermission) {
|
|
t.Fatalf("inaccessible candidate: %v", err)
|
|
}
|
|
path, source, err = selectConfigPath(second, true, os.Stat, []string{first})
|
|
if err != nil || path != second || source != "flag" {
|
|
t.Fatalf("explicit path: %q %q %v", path, source, err)
|
|
}
|
|
}
|
|
|
|
func TestLegacyEnvironmentDoesNotSelectConfig(t *testing.T) {
|
|
t.Setenv("AUDITA_CONFIG", filepath.Join(t.TempDir(), "legacy.yml"))
|
|
_, _, err := selectConfigPath("", false, os.Stat, []string{filepath.Join(t.TempDir(), "missing.yml")})
|
|
if err == nil || !strings.Contains(err.Error(), "no configuration file") {
|
|
t.Fatalf("legacy environment changed discovery: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestEffectiveViewParsing(t *testing.T) {
|
|
for _, view := range []string{"settings", "profiles", "explain"} {
|
|
input, _, err := parseConfigInput("print-effective", []string{"--view", view}, io.Discard)
|
|
if err != nil || input.View != view {
|
|
t.Fatalf("%q: %+v %v", view, input, err)
|
|
}
|
|
}
|
|
if _, _, err := parseConfigInput("print-effective", []string{"--view", "raw"}, io.Discard); err == nil {
|
|
t.Fatal("unknown view accepted")
|
|
}
|
|
if _, _, err := parseConfigInput("validate", []string{"--view", "profiles"}, io.Discard); err == nil {
|
|
t.Fatal("validate accepted inspection-only flag")
|
|
}
|
|
}
|
|
|
|
func TestSharedLoadingUsesSelectedFileOverlayAndVisitedOverrides(t *testing.T) {
|
|
dir := t.TempDir()
|
|
if err := os.Mkdir(filepath.Join(dir, "overlays"), 0700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
main := filepath.Join(dir, "config.yml")
|
|
base := "version: 2\nbackends:\n local:\n endpoint: https://local.invalid/v1\nllm:\n proposal_profile: base\nchunking:\n max_section_tokens: 900\n"
|
|
if err := os.WriteFile(main, []byte(base), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "overlays", "testing.yml"), []byte("llm:\n proposal_profile: testing\n"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
for _, command := range []string{"process", "validate", "print-effective"} {
|
|
args := []string{"--config", main, "--overlay", "testing", "--min-section-tokens", "500"}
|
|
if command == "process" {
|
|
args = append([]string{"input.json", "--glossary", "glossary.yml"}, args...)
|
|
}
|
|
input, _, err := parseConfigInput(command, args, io.Discard)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
selected, err := loadConfigInput(input, command)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
c := selected.Result.Config
|
|
if c.LLM.ProposalProfile != "testing" || c.LLM.ValidationProfile != "testing" || c.Chunking.MinSectionTokens != 500 || c.Chunking.MaxSectionTokens != 900 {
|
|
t.Fatalf("%s resolved %+v", command, c)
|
|
}
|
|
}
|
|
input, _, err := parseConfigInput("validate", []string{"--overlay", "testing"}, io.Discard)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := loadConfigInput(input, "validate"); err == nil {
|
|
t.Fatal("validate accepted discovery")
|
|
}
|
|
input, _, err = parseConfigInput("validate", []string{"--config", main}, io.Discard)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := loadConfigInput(input, "validate"); err == nil {
|
|
t.Fatal("unmodified invalid lower-precedence section relation accepted")
|
|
}
|
|
}
|
|
|
|
func TestReportingAndDebugOverridesRemainIndependent(t *testing.T) {
|
|
dir := t.TempDir()
|
|
if err := os.Mkdir(filepath.Join(dir, "overlays"), 0700); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
main := filepath.Join(dir, "config.yml")
|
|
base := "version: 2\nbackends:\n local:\n endpoint: https://local.invalid/v1\nllm:\n proposal_profile: base\n"
|
|
if err := os.WriteFile(main, []byte(base), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(dir, "overlays", "testing.yml"), []byte("reporting:\n enabled: true\n stdout_dir: reports\ndiagnostics:\n debug: true\n"), 0600); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defaultInput, _, err := parseConfigInput("validate", []string{"--config", main}, io.Discard)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defaults, err := loadConfigInput(defaultInput, "validate")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !defaults.Result.Config.Reporting.Enabled || defaults.Result.Config.Reporting.StdoutDir != "." || defaults.Result.Config.Diagnostics.Debug {
|
|
t.Fatalf("unexpected defaults: %+v", defaults.Result.Config)
|
|
}
|
|
for _, command := range []string{"process", "validate", "print-effective"} {
|
|
args := []string{"--config", main, "--overlay", "testing", "--reporting=false", "--debug=false"}
|
|
if command == "process" {
|
|
args = append([]string{"input.json", "--glossary", "glossary.yml"}, args...)
|
|
}
|
|
input, _, err := parseConfigInput(command, args, io.Discard)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(input.Overrides) != 2 || input.Overrides[0].Value != false || input.Overrides[1].Value != false {
|
|
t.Fatalf("boolean overrides must remain typed: %+v", input.Overrides)
|
|
}
|
|
selected, err := loadConfigInput(input, command)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if selected.Result.Config.Reporting.Enabled || selected.Result.Config.Diagnostics.Debug || selected.Result.Config.Reporting.StdoutDir != "reports" {
|
|
t.Fatalf("%s did not honor explicit false: %+v", command, selected.Result.Config)
|
|
}
|
|
}
|
|
processInput, _, err := parseConfigInput("process", []string{"input.json", "--glossary", "glossary.yml", "--config", main, "--overlay", "testing"}, io.Discard)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
processConfig, err := loadConfigInput(processInput, "process")
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if got, err := selectedReportDir(processConfig.Result.Config, filepath.Join("out", "corrected.json"), processInput.ReportDirSet); err != nil || got != "out" {
|
|
t.Fatalf("overlay stdout directory redirected file output: %q %v", got, err)
|
|
}
|
|
}
|
|
|
|
func TestReportDirectorySelectionOnlyUsesActiveDestination(t *testing.T) {
|
|
cfg := config.Config{Reporting: config.Reporting{Enabled: true, StdoutDir: "reports"}}
|
|
if got, err := selectedReportDir(cfg, "", false); err != nil || got != "reports" {
|
|
t.Fatalf("stdout destination: %q %v", got, err)
|
|
}
|
|
if got, err := selectedReportDir(cfg, filepath.Join("out", "corrected.json"), false); err != nil || got != "out" {
|
|
t.Fatalf("file destination ignored stdout setting: %q %v", got, err)
|
|
}
|
|
if got, err := selectedReportDir(cfg, filepath.Join("out", "corrected.json"), true); err != nil || got != "reports" {
|
|
t.Fatalf("explicit file report directory: %q %v", got, err)
|
|
}
|
|
cfg.Reporting.StdoutDir = ""
|
|
if got, err := selectedReportDir(cfg, filepath.Join("out", "corrected.json"), false); err != nil || got != "out" {
|
|
t.Fatalf("inactive blank configured report directory rejected for file output: %q %v", got, err)
|
|
}
|
|
if _, err := selectedReportDir(cfg, filepath.Join("out", "corrected.json"), true); err == nil {
|
|
t.Fatal("active explicit blank report directory accepted for file output")
|
|
}
|
|
if _, err := selectedReportDir(cfg, "", false); err == nil {
|
|
t.Fatal("enabled stdout reporting accepted blank destination")
|
|
}
|
|
cfg.Reporting.Enabled = false
|
|
if got, err := selectedReportDir(cfg, filepath.Join("out", "corrected.json"), true); err != nil || got != "" {
|
|
t.Fatalf("disabled reporting probed destination: %q %v", got, err)
|
|
}
|
|
}
|
|
|
|
func TestBareBooleanFlagsAndReportDirectoryOverride(t *testing.T) {
|
|
input, _, err := parseConfigInput("process", []string{"input.json", "--glossary", "glossary.yml", "--reporting", "--debug", "--report-dir", "reports"}, io.Discard)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
values := map[string]any{}
|
|
for _, override := range input.Overrides {
|
|
values[override.Path.String()] = override.Value
|
|
}
|
|
if values[ck.Keys("reporting", "enabled").String()] != true || values[ck.Keys("diagnostics", "debug").String()] != true || values[ck.Keys("reporting", "stdout_dir").String()] != "reports" {
|
|
t.Fatalf("incorrect visited overrides: %+v", values)
|
|
}
|
|
if !input.ReportDirSet {
|
|
t.Fatal("explicit --report-dir presence was not recorded")
|
|
}
|
|
withoutReportDir, _, err := parseConfigInput("process", []string{"input.json", "--glossary", "glossary.yml"}, io.Discard)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if withoutReportDir.ReportDirSet {
|
|
t.Fatal("absent --report-dir was recorded as explicit")
|
|
}
|
|
}
|