#include <catch2/catch_test_macros.hpp>
#include "EphemeralRelation.h"
#include "InMemoryBackend.h"
#include "LifecycleManager.h"
#include "ObjectManager.h"
#include <memory>
// Ephemeral relations — writer path, tiered ownership, and GC cascade.
//
// nt::Ephemeral::Register lands an EPHEMERAL_RELATION in the object manager,
// pins the base relations it depends on, and (for the Named tier) takes a
// session-ownership pin so the entry outlives its cursor. Collection unpins
// the base relations via LifecycleManager::CascadeEphemeral.
namespace {
using Card = nt::ObjectManager::ephemeral_object_type::Cardinality;
std::unique_ptr<nt::ObjectManager::object_type> make_relation_type() {
auto t = std::make_unique<nt::ObjectManager::object_type>();
t->label = RELATION;
t->methods = {OPEN, CLOSE};
return t;
}
// Registers a stored base relation at the given registry path and sets its
// merkle_root. Takes one baseline pin to model the owning multigroup
// snapshot, so the relation survives an ephemeral releasing its own pin —
// the reference_count then returns to 1 rather than dropping to 0 and being
// collected. Returns the slash-joined logical path for use as a dependency.
std::string make_base(nt::ObjectManager& om, nt::LifecycleManager& lm,
const std::vector<std::string>& path, const std::string& root) {
auto rel = std::make_unique<nt::ObjectManager::Relation>();
rel->merkle_root = root;
om.Register(path, std::move(rel), make_relation_type());
lm.Pin(om.Find(path)); // baseline pin: the snapshot that owns this relation
std::string joined;
for (const auto& seg : path) {
if (!joined.empty())
joined.push_back('/');
joined += seg;
}
return joined;
}
// A trivial generator: yields nothing. Lifetime tests do not scan.
nt::ObjectManager::ephemeral_object_type::Generator empty_generator() {
return [](const std::vector<std::string>&, std::size_t, std::size_t) {
return std::vector<nt::Tuple>{};
};
}
} // namespace
TEST_CASE("ComposeRoot is deterministic and order-independent", "[ephemeral][hash]") {
const std::vector<std::pair<std::string, std::string>> schema_a = {{"left", "natural"},
{"right", "natural"}};
const std::vector<std::pair<std::string, std::string>> schema_b = {{"right", "natural"},
{"left", "natural"}};
const std::string h1 = nt::Ephemeral::ComposeRoot("eq", schema_a, {"aaa", "bbb"});
const std::string h2 = nt::Ephemeral::ComposeRoot("eq", schema_b, {"bbb", "aaa"});
REQUIRE(h1 == h2); // schema + base-root order must not matter
REQUIRE(h1.size() == 64);
// Identity, schema, or base roots each change the digest.
REQUIRE(nt::Ephemeral::ComposeRoot("lt", schema_a, {"aaa", "bbb"}) != h1);
REQUIRE(nt::Ephemeral::ComposeRoot("eq", schema_a, {"aaa", "ccc"}) != h1);
REQUIRE(nt::Ephemeral::ComposeRoot("eq", {{"left", "natural"}}, {"aaa", "bbb"}) != h1);
}
TEST_CASE("Scratch tier pins deps but is not session-owned", "[ephemeral][scratch]") {
nt::InMemoryBackend store;
nt::ObjectManager om;
nt::LifecycleManager lm(om, store);
const std::string dep =
make_base(om, lm, {"system", "snapshots", "h", "relations", "r1"}, "root1");
auto* eph = nt::Ephemeral::Register(om, lm, "sess", nt::Ephemeral::Tier::Scratch, "",
empty_generator(), Card::Finite, "select",
{{"a", "abstract"}}, {dep});
REQUIRE(eph != nullptr);
// Registered under the session's scratch subdir, keyed by composed root.
REQUIRE(eph->head->path[0] == "system");
REQUIRE(eph->head->path[3] == "scratch");
// Base relation gains the ephemeral's pin atop its snapshot baseline (1+1);
// the ephemeral itself carries no ownership pin.
REQUIRE(om.Find({"system", "snapshots", "h", "relations", "r1"})->head->reference_count == 2);
REQUIRE(eph->head->reference_count == 0);
}
TEST_CASE("Scratch ephemeral is collected by counters and unpins its base",
"[ephemeral][scratch][gc]") {
nt::InMemoryBackend store;
nt::ObjectManager om;
nt::LifecycleManager lm(om, store);
const std::string dep =
make_base(om, lm, {"system", "snapshots", "h", "relations", "r1"}, "root1");
auto* eph = nt::Ephemeral::Register(om, lm, "sess", nt::Ephemeral::Tier::Scratch, "",
empty_generator(), Card::Finite, "select",
{{"a", "abstract"}}, {dep});
const auto eph_path = eph->head->path;
// A cursor opens (Monitor) then closes (Unmonitor) over the scratch result.
lm.Monitor(eph);
REQUIRE(om.Find(eph_path) != nullptr);
lm.Unmonitor(eph);
// Gone by counters, and the cascade released the ephemeral's pin on the
// base, returning it to its snapshot baseline (still alive at 1).
REQUIRE(om.Find(eph_path) == nullptr);
REQUIRE(om.Find({"system", "snapshots", "h", "relations", "r1"})->head->reference_count == 1);
}
TEST_CASE("Named ephemeral survives its cursor and is freed at session release",
"[ephemeral][named][gc]") {
nt::InMemoryBackend store;
nt::ObjectManager om;
nt::LifecycleManager lm(om, store);
const std::string dep =
make_base(om, lm, {"system", "snapshots", "h", "relations", "r1"}, "root1");
auto* eph = nt::Ephemeral::Register(om, lm, "sess", nt::Ephemeral::Tier::Named, "myview",
empty_generator(), Card::Finite, "join",
{{"a", "abstract"}}, {dep});
REQUIRE(eph != nullptr);
REQUIRE(eph->head->path[3] == "ephemeral");
REQUIRE(eph->head->path[4] == "myview");
REQUIRE(eph->head->reference_count == 1); // session-ownership pin
const auto eph_path = eph->head->path;
// A cursor opens and closes; the session pin keeps the named view alive.
lm.Monitor(eph);
lm.Unmonitor(eph);
REQUIRE(om.Find(eph_path) != nullptr);
// Session close releases it; the base relation's pin cascades free.
const std::size_t freed = nt::Ephemeral::ReleaseSession(om, lm, "sess");
REQUIRE(freed == 1);
REQUIRE(om.Find(eph_path) == nullptr);
REQUIRE(om.Find({"system", "snapshots", "h", "relations", "r1"})->head->reference_count == 1);
}
TEST_CASE("Identical scratch results dedup and do not double-pin", "[ephemeral][dedup]") {
nt::InMemoryBackend store;
nt::ObjectManager om;
nt::LifecycleManager lm(om, store);
const std::string dep =
make_base(om, lm, {"system", "snapshots", "h", "relations", "r1"}, "root1");
auto* first = nt::Ephemeral::Register(om, lm, "sess", nt::Ephemeral::Tier::Scratch, "",
empty_generator(), Card::Finite, "select",
{{"a", "abstract"}}, {dep});
auto* second = nt::Ephemeral::Register(om, lm, "sess", nt::Ephemeral::Tier::Scratch, "",
empty_generator(), Card::Finite, "select",
{{"a", "abstract"}}, {dep});
REQUIRE(first == second); // same composed root → same entry
// The ephemeral pinned the base exactly once (atop the baseline), not once
// per Register call.
REQUIRE(om.Find({"system", "snapshots", "h", "relations", "r1"})->head->reference_count == 2);
}
