notarius/internal/core/config/redaction_test.go

package config

import (
	"testing"

	"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
	"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
)

func TestRedactedConfigCopiesScriptoriumConfig(t *testing.T) {
	cfg := Default()
	cfg.Scriptorium.ProfileDir = "./profiles"

	redacted := cfg.Redacted()

	if redacted.Scriptorium.ProfileDir != "./profiles" {
		t.Fatalf("expected Scriptorium profile source preserved, got %+v", redacted.Scriptorium)
	}
	redacted.Scriptorium.ProfileDir = "./changed"
	if cfg.Scriptorium.ProfileDir != "./profiles" {
		t.Fatalf("redaction mutated original config")
	}
}

func TestConfigRedactedDiagnosticsPayloadCopiesConfig(t *testing.T) {
	cfg := Default()
	cfg.Scriptorium.ProfileFile = "./profiles.yml"

	payload, ok := cfg.RedactedDiagnosticsPayload().(Config)
	if !ok {
		t.Fatalf("expected Config payload, got %T", cfg.RedactedDiagnosticsPayload())
	}
	if payload.Scriptorium.ProfileFile != "./profiles.yml" {
		t.Fatalf("expected Scriptorium profile file preserved, got %+v", payload.Scriptorium)
	}
}

func TestEffectiveConfigRedactedDiagnosticsPayloadCopies(t *testing.T) {
	cfg := validConfig()
	lane := cfg.Pipelines["example"].Artifacts["events"]
	lane.Extract.Options = map[string]any{"temperature": 0.2}
	lane.References = map[string]string{"roster": "./roster.yml"}
	lane.Extract.References = map[string]string{"glossary": "./glossary.md"}
	lane.Normalize.References = map[string]string{"notes": "./normalize.md"}
	cfg.Pipelines["example"].Artifacts["events"] = lane
	pipelineProfile := cfg.Pipelines["example"]
	pipelineProfile.Chunk.References = map[string]string{"scene_guide": "./scene.md"}
	cfg.Pipelines["example"] = pipelineProfile

	effective, err := cfg.Resolve(ResolveInput{
		PipelineID: "example",
		Only:       []string{"events"},
		Catalog: fakeCatalog(t,
			pipeline.ModuleSpec{
				Key:      "generic",
				Stage:    pipeline.StageChunk,
				Requires: []string{"source"},
				Provides: []string{"chunks"},
				ReferenceSlots: []contracts.ReferenceSlot{
					{Name: "scene_guide"},
				},
			},
			pipeline.ModuleSpec{
				Key:      "fake/extract",
				Stage:    pipeline.StageExtract,
				Requires: []string{"chunks"},
				Provides: []string{"artifact"},
				ReferenceSlots: []contracts.ReferenceSlot{
					{Name: "glossary"},
					{Name: "roster"},
				},
			},
			pipeline.ModuleSpec{
				Key:      "noop",
				Stage:    pipeline.StageNormalize,
				Requires: []string{"merged"},
				Provides: []string{"normalized"},
				ReferenceSlots: []contracts.ReferenceSlot{
					{Name: "notes"},
				},
			},
		),
	})
	if err != nil {
		t.Fatalf("Resolve: %v", err)
	}

	payload, ok := effective.RedactedDiagnosticsPayload().(EffectiveConfig)
	if !ok {
		t.Fatalf("expected EffectiveConfig payload, got %T", effective.RedactedDiagnosticsPayload())
	}
	if payload.PipelineID != effective.PipelineID || payload.ResolvedPipeline.Digest != effective.ResolvedPipeline.Digest {
		t.Fatalf("expected pipeline metadata preserved, got %+v", payload)
	}

	payload.Only[0] = "changed"
	if effective.Only[0] != "events" {
		t.Fatalf("expected only lanes to be copied")
	}
	payload.ResolvedPipeline.ArtifactLanes[0].Extract.Options["temperature"] = 1.0
	if effective.ResolvedPipeline.ArtifactLanes[0].Extract.Options["temperature"] != 0.2 {
		t.Fatalf("expected resolved pipeline options to be copied")
	}
	payload.ResolvedPipeline.ArtifactLanes[0].ExtractReferences.Bindings[0].Source = "./changed.yml"
	if referenceBindingSource(effective.ResolvedPipeline.ArtifactLanes[0].ExtractReferences.Bindings, "roster") != "./roster.yml" {
		t.Fatalf("expected resolved pipeline references to be copied")
	}
	payload.ResolvedPipeline.Chunk.References["scene_guide"] = "./changed-scene.md"
	if effective.ResolvedPipeline.Chunk.References["scene_guide"] != "./scene.md" {
		t.Fatalf("expected chunk references to be copied")
	}
	payload.ResolvedPipeline.ArtifactLanes[0].Extract.References["glossary"] = "./changed-glossary.md"
	if effective.ResolvedPipeline.ArtifactLanes[0].Extract.References["glossary"] != "./glossary.md" {
		t.Fatalf("expected extract references to be copied")
	}
	payload.ResolvedPipeline.ArtifactLanes[0].Normalize.References["notes"] = "./changed-normalize.md"
	if effective.ResolvedPipeline.ArtifactLanes[0].Normalize.References["notes"] != "./normalize.md" {
		t.Fatalf("expected normalize references to be copied")
	}

	effective.ResolvedPipeline.ArtifactLanes[0].ExtractReferences.ReferenceSet = contracts.ReferenceSet{
		Slots: map[string]contracts.ResolvedReferenceSlot{
			"roster": {
				Slot: contracts.ReferenceSlot{Name: "roster"},
				Items: []contracts.ReferenceItem{
					{
						SlotName: "roster",
						Content:  []byte("reference content"),
					},
				},
			},
		},
	}
	payload, ok = effective.RedactedDiagnosticsPayload().(EffectiveConfig)
	if !ok {
		t.Fatalf("expected EffectiveConfig payload, got %T", effective.RedactedDiagnosticsPayload())
	}
	payload.ResolvedPipeline.ArtifactLanes[0].ExtractReferences.ReferenceSet.Slots["roster"].Items[0].Content[0] = 'X'
	got := effective.ResolvedPipeline.ArtifactLanes[0].ExtractReferences.ReferenceSet.Slots["roster"].Items[0].Content
	if string(got) != "reference content" {
		t.Fatalf("expected materialized reference content to be copied, got %q", got)
	}
}

func referenceBindingSource(bindings []pipeline.ReferenceBinding, slotName string) string {
	for _, binding := range bindings {
		if binding.SlotName == slotName {
			return binding.Source
		}
	}
	return ""
}