package pipeline import ( "context" "encoding/json" "strings" "testing" "gitea.maximumdirect.net/eric/notarius/internal/core/source" "gitea.maximumdirect.net/eric/notarius/internal/framework/contracts" ) func TestChunkCanonicalizationAndClonePreserveAnnotationScopes(t *testing.T) { doc := validSourceDocument() plan := source.ChunkPlan{ SourceDigest: doc.Digest, Ranges: []source.ChunkRange{{ StartUnitID: doc.Units[0].ID, EndUnitID: doc.Units[0].ID, Annotations: source.ChunkAnnotations{"shared": json.RawMessage(` {"range": true} `)}, }}, Annotations: source.ChunkAnnotations{"shared": json.RawMessage(` {"plan": true} `)}, } canonical, chunks, err := validateAndMaterializeChunkPlan(doc, plan) if err != nil { t.Fatalf("validateAndMaterializeChunkPlan() error = %v", err) } if got := string(canonical.Ranges[0].Annotations["shared"]); got != `{"range":true}` { t.Fatalf("range annotation = %q", got) } if got := string(canonical.Annotations["shared"]); got != `{"plan":true}` { t.Fatalf("plan annotation = %q", got) } cloned, err := cloneSourceChunk(chunks[0]) if err != nil { t.Fatal(err) } cloned.Annotations["shared"][0] = '[' cloned.PlanAnnotations["shared"][0] = '[' if string(chunks[0].Annotations["shared"]) != `{"range":true}` || string(chunks[0].PlanAnnotations["shared"]) != `{"plan":true}` { t.Fatal("cloneSourceChunk() shares annotation bytes") } } func TestSerializedChunkValidationRepresentationIncludesAnnotationScopes(t *testing.T) { doc := validSourceDocument() chunks := []source.Chunk{{ ID: "chunk-1", SourceID: doc.ID, Ref: doc.Units[0].Ref, MediaType: "application/json", Units: doc.Units[:1], Annotations: source.ChunkAnnotations{"same": json.RawMessage(`{"range":1}`)}, PlanAnnotations: source.ChunkAnnotations{"same": json.RawMessage(`{"plan":2}`)}, }} encoded, err := json.Marshal(chunks) if err != nil { t.Fatalf("json.Marshal(chunks) error = %v", err) } got := string(encoded) if !strings.Contains(got, `"annotations":{"same":{"range":1}}`) || !strings.Contains(got, `"plan_annotations":{"same":{"plan":2}}`) { t.Fatalf("serialized chunks = %s, want both annotation scopes", got) } } func TestDebugChunkEnvelopeClonesAnnotationScopes(t *testing.T) { chunk := source.Chunk{ ID: "chunk-1", SourceID: "source-1", Annotations: source.ChunkAnnotations{"same": json.RawMessage(`{"range":1}`)}, PlanAnnotations: source.ChunkAnnotations{"same": json.RawMessage(`{"plan":2}`)}, } envelope := debugSourceChunkEnvelope(chunk) if string(envelope.Annotations["same"]) != `{"range":1}` || string(envelope.PlanAnnotations["same"]) != `{"plan":2}` { t.Fatalf("debug annotations = %#v / %#v", envelope.Annotations, envelope.PlanAnnotations) } envelope.Annotations["same"][0] = '[' envelope.PlanAnnotations["same"][0] = '[' if string(chunk.Annotations["same"]) != `{"range":1}` || string(chunk.PlanAnnotations["same"]) != `{"plan":2}` { t.Fatal("debugSourceChunkEnvelope() shares annotation bytes") } } type observingChunkValidator struct { request contracts.ChunkValidationRequest } func (*observingChunkValidator) Name() string { return "observing/chunk-validator" } func (*observingChunkValidator) ExecutionClass() contracts.ExecutionClass { return contracts.ExecutionClassDeterministic } func (v *observingChunkValidator) Validate(_ context.Context, request contracts.ChunkValidationRequest) (contracts.ValidationResult, error) { v.request = request return contracts.ValidationResult{Approved: true}, nil } func TestRunnerMaterializesAnnotatedPlanBeforeChunkValidation(t *testing.T) { prepared := preparedConcurrentPipeline(t, 1) plan := prepared.chunker.(*typedTestChunker).plan plan.Annotations = source.ChunkAnnotations{"same": []byte(`{"plan":1}`)} plan.Ranges[0].Annotations = source.ChunkAnnotations{"same": []byte(`{"range":2}`)} prepared.chunker = &typedTestChunker{key: prepared.resolved.Chunk.Module, plan: plan} validator := &observingChunkValidator{} prepared.chunkValidators.validators = []preparedValidator{{ resolved: ResolvedValidator{Binding: Binding(validator.Name()), Target: ValidatorTargetChunk}, chunk: validator, }} if _, err := New().Run(context.Background(), RunInput{Prepared: prepared, RawInput: []byte("input")}); err != nil { t.Fatalf("Run() error = %v, want nil", err) } if len(validator.request.Chunks) != 1 { t.Fatalf("validator chunks = %#v, want one", validator.request.Chunks) } chunk := validator.request.Chunks[0] if chunk.ID != "chunk-000001" || chunk.Index != 0 || chunk.MediaType != "application/json" { t.Fatalf("materialized chunk identity = %#v", chunk) } if string(chunk.Annotations["same"]) != `{"range":2}` || string(chunk.PlanAnnotations["same"]) != `{"plan":1}` { t.Fatalf("materialized annotations = %s / %s", chunk.Annotations["same"], chunk.PlanAnnotations["same"]) } if chunk.Metadata["start_unit_id"] != 1 || chunk.Metadata["end_unit_id"] != 1 || chunk.Metadata["unit_count"] != 1 { t.Fatalf("materialized metadata = %#v", chunk.Metadata) } }