624 lines
21 KiB
Go
624 lines
21 KiB
Go
package json
|
|
|
|
import (
|
|
"context"
|
|
stdjson "encoding/json"
|
|
"reflect"
|
|
"strings"
|
|
"testing"
|
|
|
|
"gitea.maximumdirect.net/eric/notarius/internal/core/artifacts"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/core/source"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/framework/chunkmap"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/framework/contracts"
|
|
"gitea.maximumdirect.net/eric/notarius/internal/framework/pipeline"
|
|
)
|
|
|
|
func TestModuleSpecAndRegister(t *testing.T) {
|
|
want := pipeline.ModuleSpec{
|
|
Key: Key,
|
|
Stage: pipeline.StageOutput,
|
|
Requires: []string{"normalized"},
|
|
Provides: []string{"encoded"},
|
|
}
|
|
if got := ModuleSpec(); !reflect.DeepEqual(got, want) {
|
|
t.Fatalf("ModuleSpec() = %#v, want %#v", got, want)
|
|
}
|
|
|
|
registry := pipeline.NewOutputEncoderRegistry()
|
|
if err := Register(registry); err != nil {
|
|
t.Fatalf("Register() error = %v, want nil", err)
|
|
}
|
|
spec, ok := registry.Spec(Key)
|
|
if !ok {
|
|
t.Fatalf("Spec(%q) ok = false, want true", Key)
|
|
}
|
|
if !reflect.DeepEqual(spec, want) {
|
|
t.Fatalf("registered spec = %#v, want %#v", spec, want)
|
|
}
|
|
if err := registry.ValidateOptions(Key, map[string]any{"unexpected": true}); err == nil || !strings.Contains(err.Error(), "unknown option") {
|
|
t.Fatalf("ValidateOptions() error = %v, want unknown option error", err)
|
|
}
|
|
if err := registry.ValidateOptions(Key, map[string]any{"include_chunk_map": true}); err != nil {
|
|
t.Fatalf("ValidateOptions() error = %v, want nil", err)
|
|
}
|
|
}
|
|
|
|
func TestDecodeOptions(t *testing.T) {
|
|
for _, test := range []struct {
|
|
name string
|
|
options map[string]any
|
|
want Options
|
|
wantErr string
|
|
}{
|
|
{name: "omitted", want: Options{}},
|
|
{name: "disabled", options: map[string]any{"include_chunk_map": false}, want: Options{}},
|
|
{name: "enabled", options: map[string]any{"include_chunk_map": true}, want: Options{IncludeChunkMap: true}},
|
|
{name: "wrong type", options: map[string]any{"include_chunk_map": "true"}, wantErr: "must be a boolean"},
|
|
{name: "unknown", options: map[string]any{"unknown": true}, wantErr: "unknown option"},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
got, err := DecodeOptions(test.options)
|
|
if test.wantErr != "" {
|
|
if err == nil || !strings.Contains(err.Error(), test.wantErr) {
|
|
t.Fatalf("DecodeOptions() error = %v, want %q", err, test.wantErr)
|
|
}
|
|
return
|
|
}
|
|
if err != nil {
|
|
t.Fatalf("DecodeOptions() error = %v, want nil", err)
|
|
}
|
|
if got != test.want {
|
|
t.Fatalf("DecodeOptions() = %#v, want %#v", got, test.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEncodeReturnsLogicalFilesForNormalizedOutputs(t *testing.T) {
|
|
req := contracts.OutputRequest{
|
|
Manifest: artifacts.RunManifest{RunID: "run-1", PipelineID: "pipeline-1"},
|
|
NormalizeOutputs: []contracts.SerializedOutput{
|
|
normalizeOutput("spells", `{"spell_casts":[{"spell":"Cure Wounds"}]}`),
|
|
normalizeOutput("notes/items", `{"items":[{"name":"Torch"}]}`),
|
|
},
|
|
Rejected: []contracts.RejectedOutput{
|
|
{
|
|
Stage: "extract",
|
|
LaneID: "spells",
|
|
ModuleKey: "dnd/spells",
|
|
ChunkID: "chunk-1",
|
|
ChunkIndex: 1,
|
|
ReasonCode: "invalid",
|
|
Message: "not accepted",
|
|
AttemptCount: 1,
|
|
ValidatorName: "validator",
|
|
},
|
|
},
|
|
Warnings: []contracts.Warning{{ReasonCode: "warning", Message: "check source"}},
|
|
}
|
|
|
|
result, err := New().Encode(context.Background(), req)
|
|
if err != nil {
|
|
t.Fatalf("Encode() error = %v, want nil", err)
|
|
}
|
|
|
|
wantNames := []string{
|
|
"index.json",
|
|
"lanes/notes_items.json",
|
|
"lanes/spells.json",
|
|
"manifest.json",
|
|
"rejected.json",
|
|
"warnings.json",
|
|
}
|
|
if got := outputFileNames(result.Files); !reflect.DeepEqual(got, wantNames) {
|
|
t.Fatalf("file names = %#v, want %#v", got, wantNames)
|
|
}
|
|
|
|
for _, file := range result.Files {
|
|
if !strings.HasSuffix(string(file.Bytes), "\n") {
|
|
t.Fatalf("%s does not end with newline: %q", file.Name, string(file.Bytes))
|
|
}
|
|
if file.ContentType == contentTypeJSON && !stdjson.Valid(file.Bytes) {
|
|
t.Fatalf("%s has invalid JSON: %s", file.Name, file.Bytes)
|
|
}
|
|
}
|
|
|
|
spells := decodeObject(t, fileBytes(t, result.Files, "lanes/spells.json"))
|
|
spellCasts := spells["spell_casts"].([]any)
|
|
if spellCasts[0].(map[string]any)["spell"] != "Cure Wounds" {
|
|
t.Fatalf("spells output = %#v, want raw normalized content", spells)
|
|
}
|
|
|
|
index := decodeObject(t, fileBytes(t, result.Files, "index.json"))
|
|
outputFiles := index["output_files"].([]any)
|
|
if len(outputFiles) != 2 {
|
|
t.Fatalf("len(index output_files) = %d, want 2", len(outputFiles))
|
|
}
|
|
firstIndex := outputFiles[0].(map[string]any)
|
|
secondIndex := outputFiles[1].(map[string]any)
|
|
if firstIndex["lane_id"] != "notes/items" || secondIndex["lane_id"] != "spells" {
|
|
t.Fatalf("output_files = %#v, want sorted by lane id", outputFiles)
|
|
}
|
|
|
|
rejected := decodeObject(t, fileBytes(t, result.Files, "rejected.json"))
|
|
if got := rejected["rejected"].([]any); len(got) != 1 {
|
|
t.Fatalf("rejected = %#v, want one rejected output", got)
|
|
}
|
|
}
|
|
|
|
func TestEncodeIncludesRejectedAndWarningsWhenEmpty(t *testing.T) {
|
|
result, err := New().Encode(context.Background(), contracts.OutputRequest{
|
|
Manifest: artifacts.RunManifest{RunID: "run-1"},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("Encode() error = %v, want nil", err)
|
|
}
|
|
|
|
rejected := decodeObject(t, fileBytes(t, result.Files, "rejected.json"))
|
|
if got := rejected["rejected"].([]any); len(got) != 0 {
|
|
t.Fatalf("rejected = %#v, want empty array", got)
|
|
}
|
|
warnings := decodeObject(t, fileBytes(t, result.Files, "warnings.json"))
|
|
if got := warnings["warnings"].([]any); len(got) != 0 {
|
|
t.Fatalf("warnings = %#v, want empty array", got)
|
|
}
|
|
}
|
|
|
|
func TestEncodeChunkMapExportIsOptIn(t *testing.T) {
|
|
artifact := acceptedChunkMapArtifact(t)
|
|
request := contracts.OutputRequest{
|
|
Manifest: artifacts.RunManifest{RunID: "run-1"},
|
|
ChunkMap: &artifact,
|
|
}
|
|
for _, test := range []struct {
|
|
name string
|
|
encoder *Encoder
|
|
}{
|
|
{name: "default", encoder: New()},
|
|
{name: "explicitly disabled", encoder: NewWithOptions(Options{IncludeChunkMap: false})},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
result, err := test.encoder.Encode(context.Background(), request)
|
|
if err != nil {
|
|
t.Fatalf("Encode() error = %v, want nil", err)
|
|
}
|
|
if got, want := outputFileNames(result.Files), []string{"index.json", "manifest.json", "rejected.json", "warnings.json"}; !reflect.DeepEqual(got, want) {
|
|
t.Fatalf("file names = %#v, want %#v", got, want)
|
|
}
|
|
index := decodeObject(t, fileBytes(t, result.Files, "index.json"))
|
|
if _, ok := index["chunk_map"]; ok {
|
|
t.Fatalf("index = %#v, want no chunk map descriptor", index)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEncodeIncludesValidatedChunkMap(t *testing.T) {
|
|
artifact := acceptedChunkMapArtifact(t)
|
|
result, err := NewWithOptions(Options{IncludeChunkMap: true}).Encode(context.Background(), contracts.OutputRequest{
|
|
Manifest: artifacts.RunManifest{RunID: "run-1"},
|
|
NormalizeOutputs: []contracts.SerializedOutput{
|
|
normalizeOutput("spells", `{"spell_casts":[]}`),
|
|
},
|
|
ChunkMap: &artifact,
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("Encode() error = %v, want nil", err)
|
|
}
|
|
if got, want := outputFileNames(result.Files), []string{"chunk-map.json", "index.json", "lanes/spells.json", "manifest.json", "rejected.json", "warnings.json"}; !reflect.DeepEqual(got, want) {
|
|
t.Fatalf("file names = %#v, want %#v", got, want)
|
|
}
|
|
chunkMapFile := fileBytes(t, result.Files, chunkMapFileName)
|
|
if !stdjson.Valid(chunkMapFile) || !strings.HasSuffix(string(chunkMapFile), "\n") || !strings.Contains(string(chunkMapFile), "\n \"source_id\"") {
|
|
t.Fatalf("chunk map file = %q, want pretty valid newline-terminated JSON", chunkMapFile)
|
|
}
|
|
if _, err := chunkmap.New().Decode(chunkMapFile); err != nil {
|
|
t.Fatalf("Decode(chunk map file) error = %v, want nil", err)
|
|
}
|
|
index := decodeObject(t, fileBytes(t, result.Files, "index.json"))
|
|
if got, want := index["chunk_map"], map[string]any{
|
|
"artifact_kind": "source/chunk-map",
|
|
"file": chunkMapFileName,
|
|
"media_type": chunkmap.MediaType,
|
|
"schema_id": chunkmap.SchemaID,
|
|
"schema_name": chunkmap.SchemaName,
|
|
"schema_version": chunkmap.SchemaVersion,
|
|
}; !reflect.DeepEqual(got, want) {
|
|
t.Fatalf("chunk map descriptor = %#v, want %#v", got, want)
|
|
}
|
|
for _, entry := range index["output_files"].([]any) {
|
|
if entry.(map[string]any)["file"] == chunkMapFileName {
|
|
t.Fatalf("output_files = %#v, want no chunk map", index["output_files"])
|
|
}
|
|
}
|
|
}
|
|
|
|
func TestEncodeOmitsChunkMapWithoutAcceptedArtifact(t *testing.T) {
|
|
result, err := NewWithOptions(Options{IncludeChunkMap: true}).Encode(context.Background(), contracts.OutputRequest{
|
|
Manifest: artifacts.RunManifest{RunID: "run-1"},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("Encode() error = %v, want nil", err)
|
|
}
|
|
if got := outputFileNames(result.Files); containsString(got, chunkMapFileName) {
|
|
t.Fatalf("file names = %#v, want no chunk map", got)
|
|
}
|
|
index := decodeObject(t, fileBytes(t, result.Files, "index.json"))
|
|
if _, ok := index["chunk_map"]; ok {
|
|
t.Fatalf("index = %#v, want no chunk map descriptor", index)
|
|
}
|
|
}
|
|
|
|
func TestEncodeRejectsInvalidChunkMapArtifact(t *testing.T) {
|
|
artifact := acceptedChunkMapArtifact(t)
|
|
for _, test := range []struct {
|
|
name string
|
|
mutate func(*contracts.SerializedArtifact)
|
|
}{
|
|
{name: "kind", mutate: func(artifact *contracts.SerializedArtifact) { artifact.Kind = "other/chunk-map" }},
|
|
{name: "schema", mutate: func(artifact *contracts.SerializedArtifact) { artifact.Schema.Version = "v2" }},
|
|
{name: "media type", mutate: func(artifact *contracts.SerializedArtifact) { artifact.MediaType = "text/plain" }},
|
|
{name: "content", mutate: func(artifact *contracts.SerializedArtifact) { artifact.Content = []byte(`{}`) }},
|
|
} {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
candidate := contracts.CloneSerializedArtifact(artifact)
|
|
test.mutate(&candidate)
|
|
_, err := NewWithOptions(Options{IncludeChunkMap: true}).Encode(context.Background(), contracts.OutputRequest{ChunkMap: &candidate})
|
|
if err == nil {
|
|
t.Fatal("Encode() error = nil, want invalid chunk map error")
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEncodeChunkMapDoesNotMutateRequest(t *testing.T) {
|
|
artifact := acceptedChunkMapArtifact(t)
|
|
artifact.Metadata = map[string]any{"owner": "caller"}
|
|
request := contracts.OutputRequest{ChunkMap: &artifact}
|
|
before := contracts.CloneSerializedArtifact(artifact)
|
|
result, err := NewWithOptions(Options{IncludeChunkMap: true}).Encode(context.Background(), request)
|
|
if err != nil {
|
|
t.Fatalf("Encode() error = %v, want nil", err)
|
|
}
|
|
if !reflect.DeepEqual(*request.ChunkMap, before) {
|
|
t.Fatalf("chunk map artifact mutated:\nbefore: %#v\nafter: %#v", before, *request.ChunkMap)
|
|
}
|
|
request.ChunkMap.Content[0] = '['
|
|
request.ChunkMap.Schema.JSONSchema[0] = '['
|
|
request.ChunkMap.Metadata["owner"] = "changed"
|
|
if _, err := chunkmap.New().Decode(fileBytes(t, result.Files, chunkMapFileName)); err != nil {
|
|
t.Fatalf("chunk map output changed after request mutation: %v", err)
|
|
}
|
|
}
|
|
|
|
func TestEncodePrettyPrintsJSON(t *testing.T) {
|
|
result, err := New().Encode(context.Background(), contracts.OutputRequest{
|
|
Manifest: artifacts.RunManifest{RunID: "run-1"},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("Encode() error = %v, want nil", err)
|
|
}
|
|
|
|
manifest := string(fileBytes(t, result.Files, "manifest.json"))
|
|
if !strings.Contains(manifest, "\n \"run_id\": \"run-1\"\n") {
|
|
t.Fatalf("manifest JSON = %q, want two-space indentation", manifest)
|
|
}
|
|
}
|
|
|
|
func TestEncodeIncludesManifestReferences(t *testing.T) {
|
|
result, err := New().Encode(context.Background(), contracts.OutputRequest{
|
|
Manifest: artifacts.RunManifest{
|
|
RunID: "run-1",
|
|
References: []artifacts.ReferenceProvenance{
|
|
{
|
|
Stage: "extract",
|
|
LaneID: "events",
|
|
SlotName: "roster",
|
|
OriginType: "file",
|
|
OriginURI: "file:///tmp/roster.txt",
|
|
Digest: "sha256:reference",
|
|
MediaType: "text/plain; charset=utf-8",
|
|
SizeBytes: 12,
|
|
BindingSource: "config",
|
|
},
|
|
},
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("Encode() error = %v, want nil", err)
|
|
}
|
|
|
|
manifest := decodeObject(t, fileBytes(t, result.Files, "manifest.json"))
|
|
references := manifest["references"].([]any)
|
|
if len(references) != 1 {
|
|
t.Fatalf("references = %#v, want one entry", references)
|
|
}
|
|
reference := references[0].(map[string]any)
|
|
if reference["lane_id"] != "events" || reference["slot_name"] != "roster" || reference["digest"] != "sha256:reference" {
|
|
t.Fatalf("reference manifest = %#v, want lane slot digest", reference)
|
|
}
|
|
if _, ok := reference["content"]; ok {
|
|
t.Fatalf("reference manifest = %#v, want no content field", reference)
|
|
}
|
|
}
|
|
|
|
func TestEncodeIncludesManifestRawOutputProvenance(t *testing.T) {
|
|
result, err := New().Encode(context.Background(), contracts.OutputRequest{
|
|
Manifest: artifacts.RunManifest{
|
|
RunID: "run-1",
|
|
NormalizedOutputs: []artifacts.NormalizedOutputManifest{
|
|
{
|
|
LaneID: "spells",
|
|
ModuleKey: "noop",
|
|
SourceID: "source-1",
|
|
MediaType: contentTypeJSON,
|
|
Schema: artifacts.OutputSchemaProvenance{
|
|
ID: "schema-id",
|
|
Name: "schema-name",
|
|
Version: "v1",
|
|
},
|
|
},
|
|
},
|
|
RejectedOutputs: []artifacts.RejectedOutputManifest{
|
|
{
|
|
Stage: "extract",
|
|
LaneID: "spells",
|
|
ModuleKey: "dnd/spells",
|
|
ChunkID: "chunk-0",
|
|
ReasonCode: "raw_output_rejected",
|
|
AttemptCount: 2,
|
|
},
|
|
},
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("Encode() error = %v, want nil", err)
|
|
}
|
|
|
|
manifest := decodeObject(t, fileBytes(t, result.Files, "manifest.json"))
|
|
normalized := manifest["normalized_outputs"].([]any)
|
|
if len(normalized) != 1 {
|
|
t.Fatalf("normalized_outputs = %#v, want one entry", normalized)
|
|
}
|
|
normalizedEntry := normalized[0].(map[string]any)
|
|
if normalizedEntry["lane_id"] != "spells" || normalizedEntry["media_type"] != contentTypeJSON {
|
|
t.Fatalf("normalized output manifest = %#v, want lane and media type", normalizedEntry)
|
|
}
|
|
rejected := manifest["rejected_outputs"].([]any)
|
|
if len(rejected) != 1 {
|
|
t.Fatalf("rejected_outputs = %#v, want one entry", rejected)
|
|
}
|
|
rejectedEntry := rejected[0].(map[string]any)
|
|
if rejectedEntry["attempt_count"] != float64(2) || rejectedEntry["chunk_id"] != "chunk-0" {
|
|
t.Fatalf("rejected output manifest = %#v, want attempt count and chunk", rejectedEntry)
|
|
}
|
|
}
|
|
|
|
func TestEncodeRejectsLaneIDWithoutSafeFileName(t *testing.T) {
|
|
_, err := New().Encode(context.Background(), contracts.OutputRequest{
|
|
NormalizeOutputs: []contracts.SerializedOutput{normalizeOutput("///", `{"value":true}`)},
|
|
})
|
|
if err == nil {
|
|
t.Fatal("Encode() error = nil, want unsafe lane id error")
|
|
}
|
|
if !strings.Contains(err.Error(), "json output encoder") || !strings.Contains(err.Error(), "safe file name") {
|
|
t.Fatalf("Encode() error = %q, want safe file name context", err.Error())
|
|
}
|
|
}
|
|
|
|
func TestEncodeSanitizesParentPathSequences(t *testing.T) {
|
|
result, err := New().Encode(context.Background(), contracts.OutputRequest{
|
|
NormalizeOutputs: []contracts.SerializedOutput{normalizeOutput("dnd..spell.", `{"value":true}`)},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("Encode() error = %v, want nil", err)
|
|
}
|
|
|
|
if got := outputFileNames(result.Files); !containsString(got, "lanes/dnd__spell.json") {
|
|
t.Fatalf("file names = %#v, want sanitized output filename", got)
|
|
}
|
|
}
|
|
|
|
func TestEncodeRejectsInvalidJSONAndUnsupportedMediaTypes(t *testing.T) {
|
|
tests := []struct {
|
|
name string
|
|
output contracts.SerializedOutput
|
|
want string
|
|
}{
|
|
{
|
|
name: "invalid JSON",
|
|
output: normalizeOutput("spells", `{"spell_casts":[`),
|
|
want: "invalid JSON",
|
|
},
|
|
{
|
|
name: "unsupported media type",
|
|
output: func() contracts.SerializedOutput {
|
|
output := normalizeOutput("spells", `{"spell_casts":[]}`)
|
|
output.Artifact.MediaType = "text/plain"
|
|
return output
|
|
}(),
|
|
want: "unsupported media type",
|
|
},
|
|
}
|
|
|
|
for _, test := range tests {
|
|
t.Run(test.name, func(t *testing.T) {
|
|
_, err := New().Encode(context.Background(), contracts.OutputRequest{
|
|
NormalizeOutputs: []contracts.SerializedOutput{test.output},
|
|
})
|
|
if err == nil {
|
|
t.Fatal("Encode() error = nil, want error")
|
|
}
|
|
if !strings.Contains(err.Error(), test.want) {
|
|
t.Fatalf("Encode() error = %q, want %q", err.Error(), test.want)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestEncodeRejectsSanitizedFilenameCollisions(t *testing.T) {
|
|
_, err := New().Encode(context.Background(), contracts.OutputRequest{
|
|
NormalizeOutputs: []contracts.SerializedOutput{
|
|
normalizeOutput("a/b", `{"value":"slash"}`),
|
|
normalizeOutput("a?b", `{"value":"question"}`),
|
|
},
|
|
})
|
|
if err == nil {
|
|
t.Fatal("Encode() error = nil, want duplicate file error")
|
|
}
|
|
if !strings.Contains(err.Error(), "duplicate output file") {
|
|
t.Fatalf("Encode() error = %q, want duplicate file context", err.Error())
|
|
}
|
|
}
|
|
|
|
func TestEncodeDoesNotMutateInputs(t *testing.T) {
|
|
req := contracts.OutputRequest{
|
|
Manifest: artifacts.RunManifest{RunID: "run-1"},
|
|
NormalizeOutputs: []contracts.SerializedOutput{
|
|
normalizeOutput("spells", `{"name":"original"}`),
|
|
},
|
|
Rejected: []contracts.RejectedOutput{
|
|
{Stage: "extract", LaneID: "spells", Message: "not accepted"},
|
|
},
|
|
Warnings: []contracts.Warning{{ReasonCode: "warning", Message: "message"}},
|
|
}
|
|
before := mustMarshal(t, req)
|
|
|
|
result, err := New().Encode(context.Background(), req)
|
|
if err != nil {
|
|
t.Fatalf("Encode() error = %v, want nil", err)
|
|
}
|
|
after := mustMarshal(t, req)
|
|
if before != after {
|
|
t.Fatalf("request mutated:\nbefore: %s\nafter: %s", before, after)
|
|
}
|
|
|
|
req.NormalizeOutputs[0].Artifact.Content[0] = '['
|
|
req.NormalizeOutputs[0].Artifact.Metadata["name"] = "changed"
|
|
req.Rejected[0].Message = "changed"
|
|
req.Warnings[0].Message = "changed"
|
|
|
|
if !stdjson.Valid(fileBytes(t, result.Files, "lanes/spells.json")) {
|
|
t.Fatal("output changed after request mutation")
|
|
}
|
|
warnings := decodeObject(t, fileBytes(t, result.Files, "warnings.json"))
|
|
gotWarnings := warnings["warnings"].([]any)
|
|
if gotWarnings[0].(map[string]any)["message"] != "message" {
|
|
t.Fatalf("warnings output changed after request mutation: %#v", gotWarnings)
|
|
}
|
|
}
|
|
|
|
func TestOutputFilesDoNotContainWarnings(t *testing.T) {
|
|
result, err := New().Encode(context.Background(), contracts.OutputRequest{
|
|
NormalizeOutputs: []contracts.SerializedOutput{normalizeOutput("spells", `{"spell":"Shield"}`)},
|
|
Warnings: []contracts.Warning{
|
|
{ReasonCode: "pipeline-warning", Message: "warning"},
|
|
},
|
|
})
|
|
if err != nil {
|
|
t.Fatalf("Encode() error = %v, want nil", err)
|
|
}
|
|
|
|
outputFile := decodeObject(t, fileBytes(t, result.Files, "lanes/spells.json"))
|
|
if _, ok := outputFile["warnings"]; ok {
|
|
t.Fatalf("output file contains warnings: %#v", outputFile)
|
|
}
|
|
}
|
|
|
|
func normalizeOutput(laneID string, content string) contracts.SerializedOutput {
|
|
return contracts.SerializedOutput{
|
|
LaneID: laneID,
|
|
NormalizerKey: "noop",
|
|
SourceID: "source-1",
|
|
Artifact: contracts.SerializedArtifact{Schema: contracts.ArtifactSchema{
|
|
ID: "schema-id",
|
|
Name: "schema-name",
|
|
Version: "v1",
|
|
},
|
|
Content: []byte(content),
|
|
MediaType: contentTypeJSON,
|
|
Metadata: map[string]any{"name": laneID},
|
|
},
|
|
}
|
|
}
|
|
|
|
func acceptedChunkMapArtifact(t *testing.T) contracts.SerializedArtifact {
|
|
t.Helper()
|
|
document := &source.SourceDocument{
|
|
ID: "source-1",
|
|
Kind: "text",
|
|
Format: "text/plain",
|
|
Units: []source.SourceUnit{{
|
|
ID: 1,
|
|
Kind: "text",
|
|
Text: "Accepted source content.",
|
|
Ref: source.SourceRef{SourceID: "source-1", StartUnitID: 1, EndUnitID: 1},
|
|
}},
|
|
}
|
|
digest, err := source.DigestDocument(document)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
document.Digest = digest
|
|
plan := source.ChunkPlan{SourceDigest: digest, Ranges: []source.ChunkRange{{StartUnitID: 1, EndUnitID: 1}}}
|
|
chunks, err := source.MaterializeChunkPlan(document, plan)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
artifact, err := chunkmap.Serialize(chunkmap.BuildRequest{
|
|
Source: document, Plan: plan, Chunks: chunks, RequestedChunker: "generic/units",
|
|
Producer: chunkmap.Producer{InputModule: "test/input", ChunkModule: "generic/units"},
|
|
})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return artifact
|
|
}
|
|
|
|
func outputFileNames(files []contracts.OutputFile) []string {
|
|
names := make([]string, 0, len(files))
|
|
for _, file := range files {
|
|
names = append(names, file.Name)
|
|
}
|
|
return names
|
|
}
|
|
|
|
func containsString(values []string, want string) bool {
|
|
for _, value := range values {
|
|
if value == want {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func fileBytes(t *testing.T, files []contracts.OutputFile, name string) []byte {
|
|
t.Helper()
|
|
for _, file := range files {
|
|
if file.Name == name {
|
|
return file.Bytes
|
|
}
|
|
}
|
|
t.Fatalf("file %q not found in %#v", name, outputFileNames(files))
|
|
return nil
|
|
}
|
|
|
|
func decodeObject(t *testing.T, data []byte) map[string]any {
|
|
t.Helper()
|
|
var got map[string]any
|
|
if err := stdjson.Unmarshal(data, &got); err != nil {
|
|
t.Fatalf("Unmarshal() error = %v, want nil\n%s", err, data)
|
|
}
|
|
return got
|
|
}
|
|
|
|
func mustMarshal(t *testing.T, value any) string {
|
|
t.Helper()
|
|
data, err := stdjson.Marshal(value)
|
|
if err != nil {
|
|
t.Fatalf("Marshal() error = %v, want nil", err)
|
|
}
|
|
return string(data)
|
|
}
|