diff --git a/src/core/tracking/origin_ledger.cpp b/src/core/tracking/origin_ledger.cpp index dbcafd4..82568b7 100644 --- a/src/core/tracking/origin_ledger.cpp +++ b/src/core/tracking/origin_ledger.cpp @@ -38,6 +38,7 @@ OriginKind kindFromInt(int v) { case 2: return OriginKind::Ingest; case 3: return OriginKind::Recapture; case 4: return OriginKind::Resample; + case 5: return OriginKind::PackageImport; default: return OriginKind::Unknown; } } diff --git a/src/core/tracking/origin_ledger.h b/src/core/tracking/origin_ledger.h index f04264e..da8d0e3 100644 --- a/src/core/tracking/origin_ledger.h +++ b/src/core/tracking/origin_ledger.h @@ -15,11 +15,12 @@ namespace reasampler::tracking { // lifted from a legacy path-only manifest, or one whose creator did not know. // PERSISTED AS INTEGERS: never renumber an existing value, only append. enum class OriginKind { - Unknown = 0, - Capture = 1, - Ingest = 2, - Recapture = 3, // regenerated in place from its recorded source recipe - Resample = 4, // baked from an instrument's own processing chain + Unknown = 0, + Capture = 1, + Ingest = 2, + Recapture = 3, // regenerated in place from its recorded source recipe + Resample = 4, // baked from an instrument's own processing chain + PackageImport = 5, // package-sourced vs Ingest's user-picked; unrecoverable once merged }; // One system-created file's birth record. `relativePath` is the key and is ALWAYS diff --git a/tests/test_origin_ledger.cpp b/tests/test_origin_ledger.cpp index ff2fb8f..aa1eecd 100644 --- a/tests/test_origin_ledger.cpp +++ b/tests/test_origin_ledger.cpp @@ -1,10 +1,9 @@ // Standalone tests for reasampler::tracking::OriginLedger — no REAPER, no framework. // -// The record family behind file tracking. Covers: the relative-paths-only invariant, -// exact-string ownership, dedup, insertion order, the JSON round-trip (incl. golden -// byte literals over every persisted enum value), the no-backfill rule, the legacy -// path-only lift, and the Fresh / Loaded / Unreadable / FutureVersion classification -// that keeps never-recorded apart from the two degraded states. +// Covers: relative-paths-only, exact-string ownership, dedup, insertion order, the +// JSON round-trip (incl. golden bytes over every persisted enum value), the append-a- +// kind rules, the no-backfill rule, the legacy path-only lift, and the Fresh / Loaded +// / Unreadable / FutureVersion classification. #include "../src/core/tracking/origin_ledger.h" @@ -162,13 +161,15 @@ static void testSerializeGoldenLiteralPinsEveryPersistedKind() { l.record(rec("bank/ingest.wav", OriginKind::Ingest, "S-b")); l.record(rec("bank/recapture.wav", OriginKind::Recapture, "S-c", "S-a")); l.record(rec("bank/resample.wav", OriginKind::Resample, "S-d", "S-a")); + l.record(rec("bank/import.wav", OriginKind::PackageImport, "S-e")); const std::string expected = "{\"v\":2,\"records\":[" "{\"path\":\"bank/unknown.wav\",\"kind\":0,\"sample\":\"\",\"parent\":\"\"}," "{\"path\":\"bank/capture.wav\",\"kind\":1,\"sample\":\"S-a\",\"parent\":\"\"}," "{\"path\":\"bank/ingest.wav\",\"kind\":2,\"sample\":\"S-b\",\"parent\":\"\"}," "{\"path\":\"bank/recapture.wav\",\"kind\":3,\"sample\":\"S-c\",\"parent\":\"S-a\"}," - "{\"path\":\"bank/resample.wav\",\"kind\":4,\"sample\":\"S-d\",\"parent\":\"S-a\"}" + "{\"path\":\"bank/resample.wav\",\"kind\":4,\"sample\":\"S-d\",\"parent\":\"S-a\"}," + "{\"path\":\"bank/import.wav\",\"kind\":5,\"sample\":\"S-e\",\"parent\":\"\"}" "]}"; CHECK(l.serialize() == expected); @@ -180,6 +181,71 @@ static void testSerializeGoldenLiteralPinsEveryPersistedKind() { CHECK(back->find("bank/ingest.wav")->kind == OriginKind::Ingest); CHECK(back->find("bank/recapture.wav")->kind == OriginKind::Recapture); CHECK(back->find("bank/resample.wav")->kind == OriginKind::Resample); + CHECK(back->find("bank/import.wav")->kind == OriginKind::PackageImport); + CHECK(*back == l); // every field, not just the kind, survives the trip +} + +// Pins the emitted "v" byte, not the internal constant — an older build reads bytes. +static void testAppendingAKindDoesNotMoveTheDocumentVersion() { + OriginLedger l; + l.record(rec("bank/import.wav", OriginKind::PackageImport, "S-e")); + const std::string json = l.serialize(); + CHECK(json.rfind("{\"v\":2,", 0) == 0); + CHECK(loadLedger(json).status == LedgerStatus::Loaded); + + // The ceiling did not move with it: v3 is still a future document shape. + CHECK(loadLedger("{\"v\":3,\"records\":[]}").status == LedgerStatus::FutureVersion); +} + +// Pins three unrecognized kind values (future, far-future, negative) all landing on +// Unknown with the ledger still Loaded and the path still owned. +static void testUnknownKindDegradesWithoutBlockingTheLedger() { + const std::string blob = + "{\"v\":2,\"records\":[" + "{\"path\":\"bank/next.wav\",\"kind\":6,\"sample\":\"S-1\",\"parent\":\"\"}," + "{\"path\":\"bank/far.wav\",\"kind\":99,\"sample\":\"S-2\",\"parent\":\"\"}," + "{\"path\":\"bank/bogus.wav\",\"kind\":-1,\"sample\":\"S-3\",\"parent\":\"\"}]}"; + + const LedgerLoad load = loadLedger(blob); + CHECK(load.status == LedgerStatus::Loaded); + CHECK(!ledgerDegraded(load.status)); + CHECK(load.ledger.size() == 3); + CHECK(load.ledger.find("bank/next.wav")->kind == OriginKind::Unknown); + CHECK(load.ledger.find("bank/far.wav")->kind == OriginKind::Unknown); + CHECK(load.ledger.find("bank/bogus.wav")->kind == OriginKind::Unknown); + + // Every path still owned, in order — the protection prune reads is untouched. + const std::vector paths = load.ledger.ownedPaths(); + CHECK(paths.size() == 3); + CHECK(paths[0] == "bank/next.wav"); + CHECK(paths[1] == "bank/far.wav"); + CHECK(paths[2] == "bank/bogus.wav"); + + // The rest of the record survives the degrade; only the kind is lost. + CHECK(load.ledger.find("bank/next.wav")->sampleId == "S-1"); +} + +// ownedPaths() is the ONLY thing pruneProtection reads out of a ledger, and it is +// kind-blind: two ledgers agreeing on paths and differing on every kind, new value +// included, yield identical protection input. Adding a kind therefore cannot change +// a prune decision for any existing kind. +static void testOwnedPathsAreKindIndependent() { + const OriginKind kinds[] = {OriginKind::Unknown, OriginKind::Capture, + OriginKind::Ingest, OriginKind::Recapture, + OriginKind::Resample, OriginKind::PackageImport}; + const std::size_t n = sizeof(kinds) / sizeof(kinds[0]); + + OriginLedger baseline; + OriginLedger varied; + for (std::size_t i = 0; i < n; ++i) { + const std::string path = "bank/f" + std::to_string(i) + ".wav"; + baseline.record(rec(path, OriginKind::Unknown, "S")); + varied.record(rec(path, kinds[i], "S")); + } + + CHECK(baseline.ownedPaths() == varied.ownedPaths()); + CHECK(baseline.ownedPaths().size() == n); + CHECK(!(baseline == varied)); // the ledgers really do differ, kind by kind } // contains() is an EXACT-string predicate, never a prefix or substring match — the @@ -383,6 +449,9 @@ int main() { testRoundTripWithLineage(); testRoundTripWithJsonMetacharacters(); testSerializeGoldenLiteralPinsEveryPersistedKind(); + testAppendingAKindDoesNotMoveTheDocumentVersion(); + testUnknownKindDegradesWithoutBlockingTheLedger(); + testOwnedPathsAreKindIndependent(); testMalformedParsesToNullopt(); testTrailingGarbageIsRejected(); testLegacyShapeTypeErrorsAreRejectedButEmptyIsValid();