Files
aevolution/tests/postgres_tests.cpp
T
dingoandClaude Opus 5.5 5d4f59f901 Implement M7.4a checkpoint publication and verified recovery
ADR-0061 publishes environmental-v1 full checkpoints. Manifest v1 is a
fixed 280-byte record (identity, chain, lease, versions, build, zero
RNG/history declarations, durability policy, payload length/SHA-256)
that PostgreSQL parses and digests itself. Schema v3 adds region_commits
with a digest CHECK and a composite head FK, owner-managed retained
builds, fenced publish/load functions and owner-only genesis; it drops
the bare v2 head kernel and fails closed while v2 heads exist.

Linux evo::region_store adds OpenSSL SHA-256, an immutable
content-addressed filesystem object store (temp+fsync+link, no
overwrite/delete, O_NOFOLLOW exact-length verified reads), and
publication (validate -> upload -> read back -> fenced transaction ->
receipt check) and recovery (re-digest, allowlist, verify, full restore).
Portable evo::region_checkpoint holds the codec and payload validation.

Validated: Windows CTest 56/56; WSL Release, clang-tidy and ASan/UBSan
private-PostgreSQL suites; four SQL and one host mutation each caught.
M7.4 stays open for 7.4b (lineage archive codec and history binding).
No Docker/Gitea CI, remote store, process kill or deployment.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-09-28 15:25:27 -04:00

84 lines
3.7 KiB
C++

#include "evo/persistence/postgres.hpp"
#include <cstdio>
#include <cstdlib>
#include <source_location>
#include <stdexcept>
void run_region_lease_store_tests();
void run_region_checkpoint_store_tests();
namespace {
using namespace evo::persistence;
using namespace std::chrono_literals;
void check(bool value, std::source_location at = std::source_location::current()) {
if (!value)
throw std::runtime_error("PostgreSQL test line " + std::to_string(at.line()));
}
#define CHECK(...) check(static_cast<bool>(__VA_ARGS__))
std::string env(const char* key) {
const auto* value = std::getenv(key);
if (!value)
throw std::runtime_error("missing test environment");
return value;
}
void run() {
PgOptions options{env("PGHOST"), {}, env("PGPORT"), env("PGDATABASE"), env("PGUSER"), {}, {}};
auto made = Postgres::connect(options, 5s);
CHECK(made);
auto db = std::move(*made);
const std::array<std::string, 1> hostile{"a'); DROP SCHEMA evolution CASCADE; --"};
auto rows = db->query("SELECT $1::text, NULL::text", hostile, 5s);
CHECK(rows && rows->size() == 1 && (*rows)[0].size() == 2);
CHECK((*rows)[0][0] == hostile[0] && !(*rows)[0][1]);
CHECK(db->query("BEGIN", {}, 5s));
CHECK(db->query(
"INSERT INTO evolution.region_leases(world_id,region_id,frame_id) VALUES (1,1,1)", {}, 5s));
auto duplicate = db->query(
"INSERT INTO evolution.region_leases(world_id,region_id,frame_id) VALUES (1,1,1)", {}, 5s);
CHECK(!duplicate && duplicate.error().kind == PgError::sql);
CHECK(std::string(duplicate.error().sqlstate.data()) == "23505");
CHECK(db->query("ROLLBACK", {}, 5s));
rows = db->query("SELECT count(*) FROM evolution.region_leases", {}, 5s);
CHECK(rows && (*rows)[0][0] == "0");
for (const auto& value :
{std::string{"-1"}, std::string{"18446744073709551616"}, std::string{"1.5"}}) {
const std::array<std::string, 1> parameter{value};
CHECK(!db->query("SELECT $1::evolution.u64", parameter, 5s));
}
rows = db->query("SELECT 18446744073709551615::evolution.u64", {}, 5s);
CHECK(rows && (*rows)[0][0] == "18446744073709551615");
CHECK(db->query("SET ROLE evo_runtime_test", {}, 5s));
auto denied = db->query(
"INSERT INTO evolution.region_leases(world_id,region_id,frame_id) VALUES (2,2,2)", {}, 5s);
CHECK(!denied && std::string(denied.error().sqlstate.data()) == "42501");
CHECK(db->query("RESET ROLE", {}, 5s));
auto timeout = db->query("SELECT pg_catalog.pg_sleep(2)", {}, 50ms);
CHECK(!timeout && timeout.error().kind == PgError::unknown);
auto closed = db->query("SELECT 1", {}, 5s);
CHECK(!closed && closed.error().kind == PgError::closed);
made = Postgres::connect(options, 5s);
CHECK(made);
auto oversized = (*made)->query("SELECT pg_catalog.generate_series(1,129)", {}, 5s);
CHECK(!oversized && oversized.error().kind == PgError::unknown);
made = Postgres::connect(options, 5s);
CHECK(made);
auto disconnected = (*made)->query(
"SELECT pg_catalog.pg_terminate_backend(pg_catalog.pg_backend_pid())", {}, 5s);
CHECK(!disconnected && disconnected.error().kind == PgError::unknown);
options.user = "no_such_evo_user";
CHECK(!Postgres::connect(options, 1s));
}
} // namespace
int main() {
try {
run();
std::puts("postgres adapter integration passed");
run_region_lease_store_tests();
std::puts("region lease fencing integration passed");
run_region_checkpoint_store_tests();
std::puts("region checkpoint publication integration passed");
return 0;
} catch (const std::exception& e) {
std::fprintf(stderr, "%s\n", e.what());
return 1;
}
}