tracking: one ledger, one authority — prune protection and replace-vs-add answered from the same records, fail-safe on unreadable state
This commit is contained in:
@@ -0,0 +1,274 @@
|
||||
// Standalone tests for reasampler::tracking::OriginLedger — no REAPER, no framework.
|
||||
//
|
||||
// The record family behind file tracking. Covers: the relative-paths-only invariant,
|
||||
// dedup, insertion order, the JSON round-trip (incl. a golden byte literal), the
|
||||
// no-backfill rule, the legacy path-only lift, and the three-way Fresh /
|
||||
// Loaded / Unreadable classification that keeps never-recorded apart from
|
||||
// unreadable.
|
||||
|
||||
#include "../src/core/tracking/origin_ledger.h"
|
||||
|
||||
#include <cstdio>
|
||||
#include <string>
|
||||
|
||||
using namespace reasampler::tracking;
|
||||
|
||||
static int g_fail = 0;
|
||||
#define CHECK(cond) do { if(!(cond)) { \
|
||||
std::printf("FAIL line %d: %s\n", __LINE__, #cond); ++g_fail; } } while(0)
|
||||
|
||||
static OriginRecord rec(const std::string& path, OriginKind kind,
|
||||
const std::string& id = "", const std::string& parent = "") {
|
||||
OriginRecord r;
|
||||
r.relativePath = path;
|
||||
r.kind = kind;
|
||||
r.sampleId = id;
|
||||
r.parentSampleId = parent;
|
||||
return r;
|
||||
}
|
||||
|
||||
// --- empty ledger ------------------------------------------------------------
|
||||
|
||||
static void testEmptyLedger() {
|
||||
OriginLedger l;
|
||||
CHECK(l.empty());
|
||||
CHECK(l.size() == 0);
|
||||
CHECK(l.ownedPaths().empty());
|
||||
CHECK(!l.contains("anything.wav"));
|
||||
CHECK(l.find("anything.wav") == nullptr);
|
||||
|
||||
const std::string json = l.serialize();
|
||||
auto back = OriginLedger::deserialize(json);
|
||||
CHECK(back.has_value());
|
||||
CHECK(*back == l);
|
||||
CHECK(back->empty());
|
||||
}
|
||||
|
||||
// --- the relative-paths-only invariant ---------------------------------------
|
||||
|
||||
static void testRejectsEmptyAndAbsolutePaths() {
|
||||
OriginLedger l;
|
||||
CHECK(l.record(rec("", OriginKind::Capture)) == RecordResult::RejectedEmptyPath);
|
||||
CHECK(l.record(rec("/abs/a.wav", OriginKind::Capture)) ==
|
||||
RecordResult::RejectedAbsolutePath);
|
||||
CHECK(l.record(rec("\\\\server\\share\\a.wav", OriginKind::Capture)) ==
|
||||
RecordResult::RejectedAbsolutePath);
|
||||
CHECK(l.record(rec("C:/bank/a.wav", OriginKind::Capture)) ==
|
||||
RecordResult::RejectedAbsolutePath);
|
||||
CHECK(l.record(rec("C:rel.wav", OriginKind::Capture)) ==
|
||||
RecordResult::RejectedAbsolutePath);
|
||||
CHECK(l.empty()); // no mutation on any rejection
|
||||
|
||||
CHECK(l.record(rec("reasampler_bank/a.wav", OriginKind::Capture)) ==
|
||||
RecordResult::Recorded);
|
||||
CHECK(l.size() == 1);
|
||||
}
|
||||
|
||||
// --- dedup + insertion order -------------------------------------------------
|
||||
|
||||
static void testDedupPreservesInsertionOrder() {
|
||||
OriginLedger l;
|
||||
CHECK(l.record(rec("b.wav", OriginKind::Capture)) == RecordResult::Recorded);
|
||||
CHECK(l.record(rec("a.wav", OriginKind::Ingest)) == RecordResult::Recorded);
|
||||
CHECK(l.record(rec("b.wav", OriginKind::Capture)) == RecordResult::AlreadyPresent);
|
||||
|
||||
const std::vector<std::string> paths = l.ownedPaths();
|
||||
CHECK(paths.size() == 2);
|
||||
CHECK(paths[0] == "b.wav"); // insertion order, not sorted
|
||||
CHECK(paths[1] == "a.wav");
|
||||
}
|
||||
|
||||
// --- lineage is written at birth and NEVER backfilled ------------------------
|
||||
// A second record() for the same path must leave the stored record untouched, so a
|
||||
// later, less-informed (or differently-informed) writer can never rewrite history.
|
||||
|
||||
static void testLineageIsNeverBackfilled() {
|
||||
OriginLedger l;
|
||||
CHECK(l.record(rec("child.wav", OriginKind::Resample, "S-child", "S-parent")) ==
|
||||
RecordResult::Recorded);
|
||||
|
||||
// A later write with different lineage is refused outright.
|
||||
CHECK(l.record(rec("child.wav", OriginKind::Capture, "S-other", "S-wrong")) ==
|
||||
RecordResult::AlreadyPresent);
|
||||
|
||||
const OriginRecord* stored = l.find("child.wav");
|
||||
CHECK(stored != nullptr);
|
||||
CHECK(stored->kind == OriginKind::Resample);
|
||||
CHECK(stored->sampleId == "S-child");
|
||||
CHECK(stored->parentSampleId == "S-parent");
|
||||
|
||||
// The same holds in the other direction: a never-recorded (Unknown) record is
|
||||
// not upgraded by a later lineage-bearing write.
|
||||
OriginLedger legacy;
|
||||
CHECK(legacy.record(rec("old.wav", OriginKind::Unknown)) == RecordResult::Recorded);
|
||||
CHECK(legacy.record(rec("old.wav", OriginKind::Resample, "S1", "S0")) ==
|
||||
RecordResult::AlreadyPresent);
|
||||
CHECK(legacy.find("old.wav")->parentSampleId.empty());
|
||||
}
|
||||
|
||||
// --- lineage present at creation, queryable immediately ----------------------
|
||||
// The no-silent-gaps property at the record layer: nothing intervenes between
|
||||
// record() and a successful find().
|
||||
|
||||
static void testLineageQueryableImmediatelyAfterRecording() {
|
||||
OriginLedger l;
|
||||
l.record(rec("bake-1.wav", OriginKind::Resample, "S-1", "S-src"));
|
||||
const OriginRecord* r = l.find("bake-1.wav");
|
||||
CHECK(r != nullptr);
|
||||
CHECK(r->parentSampleId == "S-src");
|
||||
|
||||
// A second creation immediately after does not disturb the first.
|
||||
l.record(rec("bake-2.wav", OriginKind::Resample, "S-2", "S-1"));
|
||||
CHECK(l.find("bake-1.wav")->parentSampleId == "S-src");
|
||||
CHECK(l.find("bake-2.wav")->parentSampleId == "S-1");
|
||||
CHECK(l.ownedPaths().size() == 2);
|
||||
}
|
||||
|
||||
// --- JSON round-trip ---------------------------------------------------------
|
||||
|
||||
static void testRoundTripWithLineage() {
|
||||
OriginLedger l;
|
||||
l.record(rec("reasampler_bank/a.wav", OriginKind::Capture, "S-a"));
|
||||
l.record(rec("reasampler_bank/b.wav", OriginKind::Resample, "S-b", "S-a"));
|
||||
l.record(rec("reasampler_bank/c.wav", OriginKind::Ingest, "S-c"));
|
||||
l.record(rec("reasampler_bank/d.wav", OriginKind::Recapture, "S-d", "S-a"));
|
||||
|
||||
auto back = OriginLedger::deserialize(l.serialize());
|
||||
CHECK(back.has_value());
|
||||
CHECK(*back == l);
|
||||
}
|
||||
|
||||
// Metacharacters must survive: a path or id is written through the escaper, so a
|
||||
// quote or backslash cannot break the surrounding document.
|
||||
static void testRoundTripWithJsonMetacharacters() {
|
||||
OriginLedger l;
|
||||
l.record(rec("bank/quote\".wav", OriginKind::Capture, "id\\with\\slashes"));
|
||||
l.record(rec("bank/tab\tnewline\n.wav", OriginKind::Capture, "", "par\"ent"));
|
||||
|
||||
auto back = OriginLedger::deserialize(l.serialize());
|
||||
CHECK(back.has_value());
|
||||
CHECK(*back == l);
|
||||
}
|
||||
|
||||
// Golden byte literal: pins the EXACT serialized bytes, so a format drift both
|
||||
// writer and reader agree on still fails here.
|
||||
static void testSerializeGoldenLiteral() {
|
||||
OriginLedger l;
|
||||
l.record(rec("reasampler_bank/a.wav", OriginKind::Capture, "S-a"));
|
||||
l.record(rec("reasampler_bank/b.wav", OriginKind::Resample, "S-b", "S-a"));
|
||||
const std::string expected =
|
||||
"{\"v\":2,\"records\":["
|
||||
"{\"path\":\"reasampler_bank/a.wav\",\"kind\":1,\"sample\":\"S-a\",\"parent\":\"\"},"
|
||||
"{\"path\":\"reasampler_bank/b.wav\",\"kind\":4,\"sample\":\"S-b\",\"parent\":\"S-a\"}"
|
||||
"]}";
|
||||
CHECK(l.serialize() == expected);
|
||||
}
|
||||
|
||||
// --- malformed input ---------------------------------------------------------
|
||||
|
||||
static void testMalformedParsesToNullopt() {
|
||||
CHECK(!OriginLedger::deserialize("").has_value());
|
||||
CHECK(!OriginLedger::deserialize("not json").has_value());
|
||||
CHECK(!OriginLedger::deserialize("{\"v\":2,\"records\":[").has_value());
|
||||
CHECK(!OriginLedger::deserialize("{\"records\":[{\"path\":]}").has_value());
|
||||
CHECK(!OriginLedger::deserialize("[]").has_value());
|
||||
|
||||
// Unknown keys are tolerated (forward-compat), unknown kind values degrade to
|
||||
// Unknown rather than failing the whole ledger — a vocabulary gap must not halt
|
||||
// the prune.
|
||||
auto tolerated = OriginLedger::deserialize(
|
||||
"{\"v\":3,\"future\":{\"x\":1},\"records\":[{\"path\":\"a.wav\",\"kind\":99}]}");
|
||||
CHECK(tolerated.has_value());
|
||||
CHECK(tolerated->size() == 1);
|
||||
CHECK(tolerated->find("a.wav")->kind == OriginKind::Unknown);
|
||||
}
|
||||
|
||||
// A hand-edited or corrupt blob cannot smuggle an absolute or duplicate path past
|
||||
// the load — record() re-asserts the invariants on the way in.
|
||||
static void testLoadReassertsInvariants() {
|
||||
auto loaded = OriginLedger::deserialize(
|
||||
"{\"v\":2,\"records\":["
|
||||
"{\"path\":\"a.wav\",\"kind\":1},"
|
||||
"{\"path\":\"/etc/passwd\",\"kind\":1},"
|
||||
"{\"path\":\"a.wav\",\"kind\":2},"
|
||||
"{\"path\":\"\",\"kind\":1}]}");
|
||||
CHECK(loaded.has_value());
|
||||
CHECK(loaded->size() == 1);
|
||||
CHECK(loaded->contains("a.wav"));
|
||||
CHECK(!loaded->contains("/etc/passwd"));
|
||||
CHECK(loaded->find("a.wav")->kind == OriginKind::Capture); // first wins
|
||||
}
|
||||
|
||||
// --- the pre-existing bank lifts in ------------------------------------------
|
||||
// A legacy path-only manifest keeps every protection it had (the paths stay owned,
|
||||
// so prune still reclaims them and still refuses hand-dropped files) and gains NO
|
||||
// invented lineage.
|
||||
|
||||
static void testLegacyPathOnlyManifestLiftsIn() {
|
||||
const std::string legacy =
|
||||
"{\"owned\":[\"reasampler_bank/a.wav\",\"reasampler_bank/b.wav\"]}";
|
||||
LedgerLoad load = loadLedger(legacy);
|
||||
CHECK(load.status == LedgerStatus::Loaded);
|
||||
CHECK(load.ledger.size() == 2);
|
||||
|
||||
const std::vector<std::string> paths = load.ledger.ownedPaths();
|
||||
CHECK(paths.size() == 2);
|
||||
CHECK(paths[0] == "reasampler_bank/a.wav");
|
||||
CHECK(paths[1] == "reasampler_bank/b.wav");
|
||||
|
||||
for (const OriginRecord& r : load.ledger.records()) {
|
||||
CHECK(r.kind == OriginKind::Unknown); // no invented origin
|
||||
CHECK(r.sampleId.empty());
|
||||
CHECK(r.parentSampleId.empty()); // no spurious lineage
|
||||
}
|
||||
|
||||
// Re-saving upgrades the shape without losing or inventing anything.
|
||||
auto resaved = OriginLedger::deserialize(load.ledger.serialize());
|
||||
CHECK(resaved.has_value());
|
||||
CHECK(*resaved == load.ledger);
|
||||
}
|
||||
|
||||
// --- never-recorded vs unreadable --------------------------------------------
|
||||
// The two absences demand opposite treatment, so they must be distinguishable at
|
||||
// the load boundary — this is the only place that distinction is made.
|
||||
|
||||
static void testFreshLoadedUnreadableAreDistinct() {
|
||||
// Absent key: an empty string is not valid JSON, so only the loader can tell
|
||||
// "no key yet" from "corrupt value".
|
||||
CHECK(loadLedger("").status == LedgerStatus::Fresh);
|
||||
CHECK(loadLedger("").ledger.empty());
|
||||
|
||||
// A well-formed empty ledger is Loaded, not Fresh — it is a positive record
|
||||
// that nothing has been created, not an absence.
|
||||
const LedgerLoad emptyButStored = loadLedger(OriginLedger{}.serialize());
|
||||
CHECK(emptyButStored.status == LedgerStatus::Loaded);
|
||||
CHECK(emptyButStored.ledger.empty());
|
||||
|
||||
const LedgerLoad broken = loadLedger("{\"records\":[{oops");
|
||||
CHECK(broken.status == LedgerStatus::Unreadable);
|
||||
CHECK(broken.ledger.empty()); // never a partial value
|
||||
|
||||
OriginLedger real;
|
||||
real.record(rec("a.wav", OriginKind::Capture, "S-a"));
|
||||
const LedgerLoad good = loadLedger(real.serialize());
|
||||
CHECK(good.status == LedgerStatus::Loaded);
|
||||
CHECK(good.ledger == real);
|
||||
}
|
||||
|
||||
int main() {
|
||||
testEmptyLedger();
|
||||
testRejectsEmptyAndAbsolutePaths();
|
||||
testDedupPreservesInsertionOrder();
|
||||
testLineageIsNeverBackfilled();
|
||||
testLineageQueryableImmediatelyAfterRecording();
|
||||
testRoundTripWithLineage();
|
||||
testRoundTripWithJsonMetacharacters();
|
||||
testSerializeGoldenLiteral();
|
||||
testMalformedParsesToNullopt();
|
||||
testLoadReassertsInvariants();
|
||||
testLegacyPathOnlyManifestLiftsIn();
|
||||
testFreshLoadedUnreadableAreDistinct();
|
||||
|
||||
if (g_fail == 0) std::printf("origin_ledger: all tests passed\n");
|
||||
return g_fail == 0 ? 0 : 1;
|
||||
}
|
||||
Reference in New Issue
Block a user