package v071 import ( "os" "path/filepath" "testing" "time" "knowledge-governance/internal/releasebundle" releaseworkflow "knowledge-governance/internal/workflows/release" ) func TestBundleArchiveRoundTripUsesRestrictedAtomicFiles(t *testing.T) { root := t.TempDir() if err := os.Chmod(root, 0o700); err != nil { t.Fatal(err) } bundle := testDocumentBundle(t) archive, err := NewBundleArchive(root, 16*1024*1024) if err != nil { t.Fatal(err) } if err := archive.Save(bundle); err != nil { t.Fatal(err) } path := filepath.Join(root, "review-v1.bundle.json") info, err := os.Lstat(path) if err != nil { t.Fatal(err) } if info.Mode().Perm() != 0o600 || !info.Mode().IsRegular() { t.Fatalf("mode=%v", info.Mode()) } loaded, err := archive.Load("review-v1") if err != nil { t.Fatal(err) } if loaded.Manifest.BundleSHA256 != bundle.Manifest.BundleSHA256 || len(loaded.Search.Documents) != 1 || loaded.Postgres.Table("chunks").RowCount != 1 { t.Fatalf("loaded=%#v", loaded) } if err := archive.Save(bundle); err != nil { t.Fatalf("idempotent save: %v", err) } } func TestBundleArchiveRejectsSymlinkRootAndRevisionCollision(t *testing.T) { parent := t.TempDir() realRoot := filepath.Join(parent, "real") if err := os.Mkdir(realRoot, 0o700); err != nil { t.Fatal(err) } link := filepath.Join(parent, "link") if err := os.Symlink(realRoot, link); err != nil { t.Fatal(err) } if _, err := NewBundleArchive(link, 1024); err == nil { t.Fatal("symlink root accepted") } archive, err := NewBundleArchive(realRoot, 16*1024*1024) if err != nil { t.Fatal(err) } bundle := testDocumentBundle(t) if err := archive.Save(bundle); err != nil { t.Fatal(err) } // A retry re-seals the same publication with a new digest: it must replace // cleanly rather than dead-lock the release revision forever. retry := testDocumentBundle(t) retryManifest := retry.Manifest retryManifest.CreatedAt = retryManifest.CreatedAt.Add(time.Hour) sealed, err := releasebundle.Seal(retryManifest) if err != nil { t.Fatal(err) } retry.Manifest = sealed if retry.Manifest.BundleSHA256 == bundle.Manifest.BundleSHA256 { t.Fatal("re-seal produced identical digest") } if err := archive.Save(retry); err != nil { t.Fatalf("retry save rejected: %v", err) } // The same revision carrying a different publication identity is a real // collision and must still fail closed. foreign := testDocumentBundle(t) foreignManifest := foreign.Manifest foreignManifest.PublicationID = "tp-other" foreign.Manifest, err = releasebundle.Seal(foreignManifest) if err != nil { t.Fatal(err) } if err := archive.Save(foreign); err == nil { t.Fatal("cross-publication revision collision accepted") } } func TestBundleArchiveRejectsTrailingJSON(t *testing.T) { root := t.TempDir() if err := os.Chmod(root, 0o700); err != nil { t.Fatal(err) } archive, err := NewBundleArchive(root, 16*1024*1024) if err != nil { t.Fatal(err) } if err := archive.Save(testDocumentBundle(t)); err != nil { t.Fatal(err) } file, err := os.OpenFile(filepath.Join(root, "review-v1.bundle.json"), os.O_APPEND|os.O_WRONLY, 0) if err != nil { t.Fatal(err) } if _, err := file.WriteString(`{}`); err != nil { t.Fatal(err) } if err := file.Close(); err != nil { t.Fatal(err) } if _, err := archive.Load("review-v1"); err == nil { t.Fatal("trailing JSON accepted") } } func testDocumentBundle(t *testing.T) *DocumentBundle { t.Helper() pg := PostgresSnapshot{Tables: []TableSnapshot{ newTableSnapshot("knowledges", mustCanonicalRows(t, `{"id":"knowledge-safe","title":"synthetic release marker"}`)), newTableSnapshot("chunks", mustCanonicalRows(t, `{"id":"chunk-safe"}`)), }} search := SearchSnapshot{Documents: []SearchDocument{{ ID: "es-safe", Source: mustCanonicalRows(t, `{"tenant_id":10000,"knowledge_base_id":"kb-safe","knowledge_id":"knowledge-safe","content":"synthetic release marker"}`)[0], }}} search.DocumentsSHA256, _ = searchDocumentsDigest(search.Documents) search.MappingSHA256 = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa" objects := ObjectSnapshot{SHA256: objectSnapshotDigest(nil)} exporter, err := NewDocumentExporter(DocumentExporterConfig{ Contract: &stubSourceContract{contract: sourceContractFixture(search.MappingSHA256)}, Postgres: &stubPGExporter{snapshot: pg}, Search: &stubSearchExporter{snapshot: search}, Objects: &stubObjectExporter{snapshot: objects}, TenantID: 10000, EmbeddingModel: "bge-m3", Now: fixedArchiveTime, }) if err != nil { t.Fatal(err) } value, err := exporter.Export(t.Context(), releasePlanForArchive()) if err != nil { t.Fatal(err) } return value.(*DocumentBundle) } func fixedArchiveTime() time.Time { return time.Date(2026, 9, 6, 11, 0, 0, 0, time.UTC) } func releasePlanForArchive() releaseworkflow.PlanItem { return releaseworkflow.PlanItem{ReleaseExecutionID: "rx-safe", PublicationID: "tp-safe", SourceItemVersionID: "sv-safe", SourceRevision: "source-v1", ParseRevision: "parser-v1@index-v1", ReleaseRevision: "review-v1", TestKnowledgeBaseID: "kb-safe", KnowledgeID: "knowledge-safe", DecidedVisibility: "internal"} }