Something went wrong. Try again.
Toolkit for tile-based quality reconstruction of astronomical image stacks
dwarf stacking two-seestar
Something went wrong. Try again.
29 kB · 444 lines
C++
at master
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445#include "backend_test_harness.hpp"
#include <cstdio>#include <cstdlib>#include <fstream>
static std::string test_phase_name(const nlohmann::json& item) { if (item.contains("phase") && item["phase"].is_string()) return item["phase"].get<std::string>(); if (item.contains("phase_name") && item["phase_name"].is_string()) return item["phase_name"].get<std::string>(); return "";}
static std::string test_error_code(const nlohmann::json& payload) { if (payload.contains("code") && payload["code"].is_string()) return payload["code"].get<std::string>(); if (payload.contains("error") && payload["error"].is_object() && payload["error"].contains("code") && payload["error"]["code"].is_string()) { return payload["error"]["code"].get<std::string>(); } return "";}
static const nlohmann::json& test_error_details(const nlohmann::json& payload) { static const nlohmann::json empty = nlohmann::json::object(); if (payload.contains("error") && payload["error"].is_object() && payload["error"].contains("details") && payload["error"]["details"].is_object()) { return payload["error"]["details"]; } if (payload.contains("details") && payload["details"].is_object()) return payload["details"]; return empty;}
int main(int argc, char** argv) { if (argc < 5) return 2; ::setenv("FAKE_TILE_COMPILE_RUNNER_SLEEP_MS", "1500", 1); BackendHarness harness(argv[1], argv[2], argv[3], argv[4]); try { harness.start();
harness.create_run("resume_progress_run", { {{"ts", "2026-03-10T10:00:00Z"}, {"type", "phase_start"}, {"phase_name", "ASTROMETRY"}}, {{"ts", "2026-03-10T10:00:10Z"}, {"type", "phase_end"}, {"phase_name", "ASTROMETRY"}, {"status", "ok"}}, {{"ts", "2026-03-10T10:00:20Z"}, {"type", "phase_start"}, {"phase_name", "BGE"}}, {{"ts", "2026-03-10T10:00:30Z"}, {"type", "phase_end"}, {"phase_name", "BGE"}, {"status", "ok"}}, {{"ts", "2026-03-10T10:01:00Z"}, {"type", "resume_start"}, {"from_phase", "BGE"}}, {{"ts", "2026-03-10T10:01:01Z"}, {"type", "phase_start"}, {"phase_name", "BGE"}} }, "OSC");
const auto status = harness.get_json("/api/runs/resume_progress_run/status"); expect_equal(status["_http_status"].get<long>(), 200L, "resume status code"); expect_equal(status["status"].get<std::string>(), "aborted", "stale resume run without live job becomes aborted"); expect_true(status["current_phase"].is_null(), "stale resume current phase cleared"); bool found_bge = false; for (const auto& item : status["phases"]) { if (test_phase_name(item) == "BGE") { found_bge = true; expect_equal(item["status"].get<std::string>(), "aborted", "bge stale resumed status"); expect_equal(item["pct"].get<double>(), 0.0, "bge resumed pct", 1e-9); } } expect_true(found_bge, "bge phase present");
const auto skipped_phase_run_dir = harness.create_run("skipped_phase_run", { {{"ts", "2026-03-10T11:00:00Z"}, {"type", "phase_start"}, {"phase_name", "STATE_CLUSTERING"}}, {{"ts", "2026-03-10T11:00:01Z"}, {"type", "phase_end"}, {"phase_name", "STATE_CLUSTERING"}, {"status", "skipped"}}, {{"ts", "2026-03-10T11:00:02Z"}, {"type", "run_end"}, {"success", true}} }, "OSC"); { std::ofstream config(skipped_phase_run_dir / "config.yaml"); config << "method: classic_tile_compile\n" << "data:\n color_mode: OSC\n"; }
const auto skipped_status = harness.get_json("/api/runs/skipped_phase_run/status"); expect_equal(skipped_status["_http_status"].get<long>(), 200L, "skipped status code"); bool found_skipped = false; for (const auto& item : skipped_status["phases"]) { if (test_phase_name(item) == "STATE_CLUSTERING") { found_skipped = true; expect_equal(item["status"].get<std::string>(), "skipped", "state clustering skipped status"); expect_equal(item["pct"].get<double>(), 1.0, "state clustering skipped pct", 1e-9); } } expect_true(found_skipped, "state clustering phase present");
const auto aqmh_run_dir = harness.create_run("aqmh_hides_classic_phases", { {{"ts", "2026-03-10T11:10:00Z"}, {"type", "phase_start"}, {"phase_name", "STATE_CLUSTERING"}}, {{"ts", "2026-03-10T11:10:01Z"}, {"type", "phase_end"}, {"phase_name", "STATE_CLUSTERING"}, {"status", "skipped"}}, {{"ts", "2026-03-10T11:10:02Z"}, {"type", "phase_start"}, {"phase_name", "SYNTHETIC_FRAMES"}}, {{"ts", "2026-03-10T11:10:03Z"}, {"type", "phase_end"}, {"phase_name", "SYNTHETIC_FRAMES"}, {"status", "skipped"}}, {{"ts", "2026-03-10T11:10:04Z"}, {"type", "run_end"}, {"success", true}} }, "OSC"); { std::ofstream config(aqmh_run_dir / "config.yaml"); config << "method: aqmh\n" << "data:\n color_mode: OSC\n"; }
const auto aqmh_status = harness.get_json("/api/runs/aqmh_hides_classic_phases/status"); expect_equal(aqmh_status["_http_status"].get<long>(), 200L, "aqmh status code"); expect_true(aqmh_status["aqmh_enabled"].is_boolean(), "aqmh flag is boolean"); expect_true(aqmh_status["aqmh_enabled"].get<bool>(), "aqmh flag derived from method"); expect_equal(aqmh_status["method"].get<std::string>(), "aqmh", "aqmh method parsed from config"); bool found_aqmh_maps = false; bool found_aqmh_local_metrics = false; bool found_aqmh_state_clustering = false; bool found_aqmh_synthetic_frames = false; for (const auto& item : aqmh_status["phases"]) { const std::string phase = test_phase_name(item); if (phase == "AQMH_MAPS") found_aqmh_maps = true; if (phase == "LOCAL_METRICS") found_aqmh_local_metrics = true; if (phase == "STATE_CLUSTERING") found_aqmh_state_clustering = true; if (phase == "SYNTHETIC_FRAMES") found_aqmh_synthetic_frames = true; } expect_true(found_aqmh_maps, "aqmh maps phase present"); expect_true(!found_aqmh_local_metrics, "aqmh hides classic local metrics phase"); expect_true(!found_aqmh_state_clustering, "aqmh hides state clustering"); expect_true(!found_aqmh_synthetic_frames, "aqmh hides synthetic frames");
harness.create_run("aqmh_hides_classic_phases_from_events", { {{"ts", "2026-03-10T11:20:00Z"}, {"type", "phase_start"}, {"phase_name", "AQMH_QUALITY_MAPS"}}, {{"ts", "2026-03-10T11:20:01Z"}, {"type", "phase_end"}, {"phase_name", "LOCAL_METRICS"}, {"status", "ok"}}, {{"ts", "2026-03-10T11:20:02Z"}, {"type", "phase_start"}, {"phase_name", "STATE_CLUSTERING"}}, {{"ts", "2026-03-10T11:20:03Z"}, {"type", "phase_end"}, {"phase_name", "STATE_CLUSTERING"}, {"status", "skipped"}}, {{"ts", "2026-03-10T11:20:04Z"}, {"type", "phase_start"}, {"phase_name", "SYNTHETIC_FRAMES"}}, {{"ts", "2026-03-10T11:20:05Z"}, {"type", "phase_end"}, {"phase_name", "SYNTHETIC_FRAMES"}, {"status", "skipped"}}, {{"ts", "2026-03-10T11:20:06Z"}, {"type", "run_end"}, {"success", true}} }, "OSC");
const auto aqmh_event_status = harness.get_json("/api/runs/aqmh_hides_classic_phases_from_events/status"); expect_equal(aqmh_event_status["_http_status"].get<long>(), 200L, "default-method aqmh status code"); expect_true(aqmh_event_status["aqmh_enabled"].is_boolean(), "default-method aqmh flag is boolean"); expect_true(aqmh_event_status["aqmh_enabled"].get<bool>(), "missing method defaults to aqmh"); expect_equal(aqmh_event_status["method"].get<std::string>(), "aqmh", "missing method reports aqmh"); bool found_event_aqmh_maps = false; bool found_event_local_metrics = false; for (const auto& item : aqmh_event_status["phases"]) { const std::string phase = test_phase_name(item); if (phase == "AQMH_MAPS") { found_event_aqmh_maps = true; expect_equal(item["status"].get<std::string>(), "ok", "aqmh maps consumes local_metrics phase_end"); expect_equal(item["pct"].get<double>(), 1.0, "aqmh maps done pct", 1e-9); } if (phase == "LOCAL_METRICS") found_event_local_metrics = true; expect_true(phase != "STATE_CLUSTERING", "event-derived aqmh hides state clustering"); expect_true(phase != "SYNTHETIC_FRAMES", "event-derived aqmh hides synthetic frames"); } expect_true(found_event_aqmh_maps, "event-derived aqmh maps phase present"); expect_true(!found_event_local_metrics, "event-derived aqmh hides classic local metrics");
const auto aqmh_reconstruction_run_dir = harness.create_run("aqmh_reconstruction_alias_status", { {{"ts", "2026-03-10T11:25:00Z"}, {"type", "phase_start"}, {"phase_name", "AQMH_QUALITY_MAPS"}}, {{"ts", "2026-03-10T11:25:01Z"}, {"type", "phase_end"}, {"phase_name", "LOCAL_METRICS"}, {"status", "ok"}}, {{"ts", "2026-03-10T11:25:02Z"}, {"type", "phase_start"}, {"phase_name", "TILE_RECONSTRUCTION"}}, {{"ts", "2026-03-10T11:25:03Z"}, {"type", "phase_end"}, {"phase_name", "TILE_RECONSTRUCTION"}, {"status", "ok"}}, {{"ts", "2026-03-10T11:25:04Z"}, {"type", "run_end"}, {"success", true}} }, "OSC"); { std::ofstream config(aqmh_reconstruction_run_dir / "config.yaml"); config << "method: aqmh\n" << "data:\n color_mode: OSC\n"; }
const auto aqmh_reconstruction_status = harness.get_json("/api/runs/aqmh_reconstruction_alias_status/status"); expect_equal(aqmh_reconstruction_status["_http_status"].get<long>(), 200L, "aqmh reconstruction alias status code"); bool found_aqmh_reconstruction = false; bool found_tile_reconstruction = false; for (const auto& item : aqmh_reconstruction_status["phases"]) { const std::string phase = test_phase_name(item); if (phase == "AQMH_RECONSTRUCTION") { found_aqmh_reconstruction = true; expect_equal(item["status"].get<std::string>(), "ok", "aqmh reconstruction consumes tile reconstruction phase_end"); expect_equal(item["pct"].get<double>(), 1.0, "aqmh reconstruction done pct", 1e-9); } if (phase == "TILE_RECONSTRUCTION") found_tile_reconstruction = true; } expect_true(found_aqmh_reconstruction, "aqmh reconstruction phase present"); expect_true(!found_tile_reconstruction, "aqmh hides classic tile reconstruction phase");
harness.create_run("completed_without_run_end", { {{"ts", "2026-03-10T11:30:00Z"}, {"type", "phase_start"}, {"phase_name", "ASTROMETRY"}}, {{"ts", "2026-03-10T11:30:01Z"}, {"type", "phase_end"}, {"phase_name", "ASTROMETRY"}, {"status", "ok"}}, {{"ts", "2026-03-10T11:30:02Z"}, {"type", "phase_start"}, {"phase_name", "BGE"}}, {{"ts", "2026-03-10T11:30:03Z"}, {"type", "phase_end"}, {"phase_name", "BGE"}, {"status", "ok"}}, {{"ts", "2026-03-10T11:30:04Z"}, {"type", "phase_start"}, {"phase_name", "PCC"}}, {{"ts", "2026-03-10T11:30:05Z"}, {"type", "phase_end"}, {"phase_name", "PCC"}, {"status", "ok"}} }, "OSC");
const auto completed_without_run_end = harness.get_json("/api/runs/completed_without_run_end/status"); expect_equal(completed_without_run_end["_http_status"].get<long>(), 200L, "completed without run_end status code"); expect_equal(completed_without_run_end["status"].get<std::string>(), "completed", "pcc terminal phase implies completed");
const auto aqmh_rerun_order_dir = harness.create_run("aqmh_rerun_resets_phase_status", { {{"ts", "2026-03-10T11:35:00Z"}, {"type", "run_start"}, {"run_id", "aqmh_rerun_resets_phase_status"}}, {{"ts", "2026-03-10T11:35:01Z"}, {"type", "phase_start"}, {"phase_name", "SCAN_INPUT"}}, {{"ts", "2026-03-10T11:35:02Z"}, {"type", "phase_end"}, {"phase_name", "SCAN_INPUT"}, {"status", "ok"}}, {{"ts", "2026-03-10T11:35:03Z"}, {"type", "phase_start"}, {"phase_name", "REGISTRATION"}}, {{"ts", "2026-03-10T11:35:04Z"}, {"type", "phase_end"}, {"phase_name", "REGISTRATION"}, {"status", "ok"}}, {{"ts", "2026-03-10T11:35:05Z"}, {"type", "phase_start"}, {"phase_name", "PREWARP"}}, {{"ts", "2026-03-10T11:35:06Z"}, {"type", "phase_end"}, {"phase_name", "PREWARP"}, {"status", "ok"}}, {{"ts", "2026-03-10T11:35:07Z"}, {"type", "run_end"}, {"success", true}}, {{"ts", "2026-03-10T11:40:00Z"}, {"type", "run_start"}, {"run_id", "aqmh_rerun_resets_phase_status"}}, {{"ts", "2026-03-10T11:40:01Z"}, {"type", "phase_start"}, {"phase_name", "SCAN_INPUT"}}, {{"ts", "2026-03-10T11:40:02Z"}, {"type", "phase_end"}, {"phase_name", "SCAN_INPUT"}, {"status", "ok"}}, {{"ts", "2026-03-10T11:40:03Z"}, {"type", "phase_start"}, {"phase_name", "CHANNEL_SPLIT"}}, {{"ts", "2026-03-10T11:40:04Z"}, {"type", "phase_end"}, {"phase_name", "CHANNEL_SPLIT"}, {"status", "ok"}}, {{"ts", "2026-03-10T11:40:05Z"}, {"type", "phase_start"}, {"phase_name", "NORMALIZATION"}} }, "OSC"); { std::ofstream config(aqmh_rerun_order_dir / "config.yaml"); config << "method: aqmh\n" << "data:\n color_mode: OSC\n"; }
const auto aqmh_rerun_status = harness.get_json("/api/runs/aqmh_rerun_resets_phase_status/status"); expect_equal(aqmh_rerun_status["_http_status"].get<long>(), 200L, "aqmh rerun status code"); int channel_split_index = -1; int registration_index = -1; bool found_pending_registration = false; bool found_pending_prewarp = false; for (size_t i = 0; i < aqmh_rerun_status["phases"].size(); ++i) { const auto& item = aqmh_rerun_status["phases"][i]; const std::string phase = test_phase_name(item); if (phase == "CHANNEL_SPLIT") channel_split_index = static_cast<int>(i); if (phase == "REGISTRATION") { registration_index = static_cast<int>(i); found_pending_registration = item["status"].get<std::string>() == "pending"; } if (phase == "PREWARP") { found_pending_prewarp = item["status"].get<std::string>() == "pending"; } } expect_true(channel_split_index >= 0 && registration_index >= 0 && channel_split_index < registration_index, "aqmh phase list follows runner order before registration"); expect_true(found_pending_registration, "new run_start resets stale registration status"); expect_true(found_pending_prewarp, "new run_start resets stale prewarp status");
harness.create_run("partial_without_run_end", { {{"ts", "2026-03-10T11:45:00Z"}, {"type", "phase_start"}, {"phase_name", "ASTROMETRY"}}, {{"ts", "2026-03-10T11:45:01Z"}, {"type", "phase_end"}, {"phase_name", "ASTROMETRY"}, {"status", "ok"}} }, "OSC");
const auto partial_without_run_end = harness.get_json("/api/runs/partial_without_run_end/status"); expect_equal(partial_without_run_end["_http_status"].get<long>(), 200L, "partial without run_end status code"); expect_equal(partial_without_run_end["status"].get<std::string>(), "unknown", "partial run without active phase must not imply running");
harness.create_run("skipped_then_resume_ok_run", { {{"ts", "2026-03-10T12:00:00Z"}, {"type", "phase_start"}, {"phase_name", "ASTROMETRY"}}, {{"ts", "2026-03-10T12:00:01Z"}, {"type", "phase_end"}, {"phase_name", "ASTROMETRY"}, {"status", "skipped"}}, {{"ts", "2026-03-10T12:00:02Z"}, {"type", "run_end"}, {"success", true}}, {{"ts", "2026-03-10T12:05:00Z"}, {"type", "resume_start"}, {"from_phase", "ASTROMETRY"}}, {{"ts", "2026-03-10T12:05:05Z"}, {"type", "resume_end"}, {"success", true}, {"status", "ok"}} }, "OSC");
const auto resumed_ok_status = harness.get_json("/api/runs/skipped_then_resume_ok_run/status"); expect_equal(resumed_ok_status["_http_status"].get<long>(), 200L, "resumed skipped phase status code"); expect_equal(resumed_ok_status["status"].get<std::string>(), "completed", "resumed skipped run completed status"); bool found_resumed_phase = false; for (const auto& item : resumed_ok_status["phases"]) { if (test_phase_name(item) == "ASTROMETRY") { found_resumed_phase = true; expect_equal(item["status"].get<std::string>(), "ok", "astrometry status upgraded after successful resume"); expect_equal(item["pct"].get<double>(), 1.0, "astrometry pct upgraded after successful resume", 1e-9); } } expect_true(found_resumed_phase, "astrometry phase present after successful resume");
harness.create_run("pcc_resume_keeps_target_running", { {{"ts", "2026-03-10T13:00:00Z"}, {"type", "phase_start"}, {"phase_name", "ASTROMETRY"}}, {{"ts", "2026-03-10T13:00:01Z"}, {"type", "phase_end"}, {"phase_name", "ASTROMETRY"}, {"status", "ok"}}, {{"ts", "2026-03-10T13:00:02Z"}, {"type", "phase_start"}, {"phase_name", "PCC"}}, {{"ts", "2026-03-10T13:00:03Z"}, {"type", "phase_end"}, {"phase_name", "PCC"}, {"status", "ok"}}, {{"ts", "2026-03-10T13:00:04Z"}, {"type", "run_end"}, {"success", true}}, {{"ts", "2026-03-10T13:05:00Z"}, {"type", "resume_start"}, {"from_phase", "PCC"}}, {{"ts", "2026-03-10T13:05:01Z"}, {"type", "phase_start"}, {"phase_name", "ASTROMETRY"}}, {{"ts", "2026-03-10T13:05:02Z"}, {"type", "phase_end"}, {"phase_name", "ASTROMETRY"}, {"status", "skipped"}, {"reason", "existing_wcs"}} }, "OSC");
const auto pcc_resume_status = harness.get_json("/api/runs/pcc_resume_keeps_target_running/status"); expect_equal(pcc_resume_status["_http_status"].get<long>(), 200L, "pcc resume status code"); expect_equal(pcc_resume_status["status"].get<std::string>(), "aborted", "stale pcc resume run becomes aborted"); expect_true(pcc_resume_status["current_phase"].is_null(), "stale pcc resume current phase cleared"); bool found_astrometry_after_pcc_resume = false; bool found_pcc_after_pcc_resume = false; for (const auto& item : pcc_resume_status["phases"]) { if (test_phase_name(item) == "ASTROMETRY") { found_astrometry_after_pcc_resume = true; expect_equal(item["status"].get<std::string>(), "ok", "astrometry keeps ok when existing wcs is reused for pcc resume"); } if (test_phase_name(item) == "PCC") { found_pcc_after_pcc_resume = true; expect_equal(item["status"].get<std::string>(), "aborted", "stale pcc phase becomes aborted without live job"); expect_equal(item["pct"].get<double>(), 0.0, "pcc remains at 0 pct before phase_start", 1e-9); } } expect_true(found_astrometry_after_pcc_resume, "astrometry phase present after pcc resume"); expect_true(found_pcc_after_pcc_resume, "pcc phase present after pcc resume");
harness.create_run("resume_overlay_without_events", { {{"ts", "2026-03-10T14:00:00Z"}, {"type", "phase_start"}, {"phase_name", "ASTROMETRY"}}, {{"ts", "2026-03-10T14:00:01Z"}, {"type", "phase_end"}, {"phase_name", "ASTROMETRY"}, {"status", "ok"}}, {{"ts", "2026-03-10T14:00:02Z"}, {"type", "phase_start"}, {"phase_name", "BGE"}}, {{"ts", "2026-03-10T14:00:03Z"}, {"type", "phase_end"}, {"phase_name", "BGE"}, {"status", "ok"}}, {{"ts", "2026-03-10T14:00:04Z"}, {"type", "phase_start"}, {"phase_name", "PCC"}}, {{"ts", "2026-03-10T14:00:05Z"}, {"type", "phase_end"}, {"phase_name", "PCC"}, {"status", "ok"}}, {{"ts", "2026-03-10T14:00:06Z"}, {"type", "run_end"}, {"success", true}} }, "OSC"); // Create required artifact so resume validation passes harness.make_file("runs/resume_overlay_without_events/outputs/stacked_rgb_solve.fits", "fixture");
const auto resumed = harness.post_json("/api/runs/resume_overlay_without_events/resume", { {"from_phase", "BGE"}, {"run_dir", "runs/resume_overlay_without_events"}, {"config_yaml", "data:\n color_mode: OSC\n"} }); expect_equal(resumed["_http_status"].get<long>(), 202L, "resume overlay launch status");
const auto overlay_status = harness.get_json("/api/runs/resume_overlay_without_events/status"); expect_equal(overlay_status["_http_status"].get<long>(), 200L, "resume overlay status code"); expect_equal(overlay_status["status"].get<std::string>(), "running", "resume overlay run status"); expect_equal(overlay_status["current_phase"].get<std::string>(), "BGE", "resume overlay current phase"); bool found_overlay_bge = false; bool found_overlay_pcc = false; for (const auto& item : overlay_status["phases"]) { if (test_phase_name(item) == "BGE") { found_overlay_bge = true; expect_equal(item["status"].get<std::string>(), "running", "resume overlay bge status"); expect_equal(item["pct"].get<double>(), 0.0, "resume overlay bge pct", 1e-9); } if (test_phase_name(item) == "PCC") { found_overlay_pcc = true; expect_equal(item["status"].get<std::string>(), "pending", "resume overlay resets later phases"); expect_equal(item["pct"].get<double>(), 0.0, "resume overlay resets later phase pct", 1e-9); } } expect_true(found_overlay_bge, "resume overlay target phase present"); expect_true(found_overlay_pcc, "resume overlay later phase present");
const auto overlay_logs = harness.get_json( "/api/runs/resume_overlay_without_events/logs?tail=20&run_dir=runs%2Fresume_overlay_without_events"); expect_equal(overlay_logs["_http_status"].get<long>(), 200L, "resume logs with run_dir status code"); expect_true(!overlay_logs["lines"].empty(), "resume logs with run_dir returns event lines");
const auto resumed_job = harness.wait_for_job(resumed["job_id"].get<std::string>(), 5.0); // fake_tile_compile_cli may not implement resume; accept ok or error expect_true(resumed_job["state"].get<std::string>() == "ok" || resumed_job["state"].get<std::string>() == "error", "resume overlay job terminates"); if (resumed_job["state"].get<std::string>() == "ok") { expect_equal(resumed_job["data"]["run_dir"].get<std::string>(), (harness.fixture_root() / "runs" / "resume_overlay_without_events").string(), "relative resume run_dir is normalized in job data"); const auto& resume_command = resumed_job["data"]["command"]; bool found_normalized_run_dir_arg = false; for (size_t i = 0; i + 1 < resume_command.size(); ++i) { if (resume_command[i].get<std::string>() == "--run-dir" && resume_command[i + 1].get<std::string>() == (harness.fixture_root() / "runs" / "resume_overlay_without_events").string()) { found_normalized_run_dir_arg = true; } } expect_true(found_normalized_run_dir_arg, "relative resume run_dir is normalized before runner launch"); }
const auto aqmh_resume_overlay_run_dir = harness.create_run("aqmh_resume_overlay_alias", { {{"ts", "2026-03-10T14:59:59Z"}, {"type", "run_start"}, {"input_dir", (harness.fixture_root() / "input").string()}}, {{"ts", "2026-03-10T15:00:00Z"}, {"type", "phase_start"}, {"phase_name", "AQMH_QUALITY_MAPS"}}, {{"ts", "2026-03-10T15:00:01Z"}, {"type", "phase_end"}, {"phase_name", "LOCAL_METRICS"}, {"status", "ok"}}, {{"ts", "2026-03-10T15:00:02Z"}, {"type", "phase_start"}, {"phase_name", "TILE_RECONSTRUCTION"}}, {{"ts", "2026-03-10T15:00:03Z"}, {"type", "phase_end"}, {"phase_name", "TILE_RECONSTRUCTION"}, {"status", "ok"}}, {{"ts", "2026-03-10T15:00:04Z"}, {"type", "run_end"}, {"success", true}} }, "OSC"); { std::ofstream config(aqmh_resume_overlay_run_dir / "config.yaml"); config << "method: aqmh\n" << "data:\n color_mode: OSC\n"; }
const auto aqmh_rerun_dry_run = harness.post_json("/api/runs/aqmh_resume_overlay_alias/resume", { {"from_phase", "TILE_RECONSTRUCTION"}, {"run_dir", (harness.fixture_root() / "runs" / "aqmh_resume_overlay_alias").string()}, {"config_yaml", "method: aqmh\ndata:\n color_mode: OSC\n"}, {"dry_run", true} }); expect_equal(aqmh_rerun_dry_run["_http_status"].get<long>(), 200L, "aqmh in-place rerun phase dry-run status"); expect_true(aqmh_rerun_dry_run["dry_run"].get<bool>(), "aqmh in-place rerun dry-run flag");
// AQMH runs can regenerate the missing immutable CFA artifact from // their reusable prewarp cache before entering STACKING. { const std::filesystem::path cache_dir = aqmh_resume_overlay_run_dir / "cache" / "prewarped_frames"; std::filesystem::create_directories(cache_dir); std::ofstream(cache_dir / "frame_0.fixture") << "fixture"; } const auto aqmh_legacy_stacking_dry_run = harness.post_json("/api/runs/aqmh_resume_overlay_alias/resume", { {"from_phase", "STACKING"}, {"run_dir", (harness.fixture_root() / "runs" / "aqmh_resume_overlay_alias").string()}, {"config_yaml", "method: aqmh\ndata:\n color_mode: OSC\n"}, {"dry_run", true} }); expect_equal(aqmh_legacy_stacking_dry_run["_http_status"].get<long>(), 200L, "legacy aqmh STACKING regenerates raw artifact from prewarp cache");
// AQMH STACKING resumes from the immutable raw CFA reconstruction. // reconstructed_L.fit is a downstream luminance output and must not be // debayered again. { const std::filesystem::path outputs_dir = aqmh_resume_overlay_run_dir / "outputs"; std::filesystem::create_directories(outputs_dir); std::ofstream(outputs_dir / "aqmh_reconstructed_raw.fit") << "fixture"; } const auto aqmh_stacking_dry_run = harness.post_json("/api/runs/aqmh_resume_overlay_alias/resume", { {"from_phase", "STACKING"}, {"run_dir", (harness.fixture_root() / "runs" / "aqmh_resume_overlay_alias").string()}, {"config_yaml", "method: aqmh\ndata:\n color_mode: OSC\n"}, {"dry_run", true} }); expect_equal(aqmh_stacking_dry_run["_http_status"].get<long>(), 200L, "aqmh resume from STACKING dry-run launch status"); expect_true(aqmh_stacking_dry_run["dry_run"].get<bool>(), "aqmh resume dry-run flag");
const auto aqmh_stacking_resumed = harness.post_json("/api/runs/aqmh_resume_overlay_alias/resume", { {"from_phase", "STACKING"}, {"run_dir", (harness.fixture_root() / "runs" / "aqmh_resume_overlay_alias").string()}, {"config_yaml", "method: aqmh\ndata:\n color_mode: OSC\n"} }); expect_equal(aqmh_stacking_resumed["_http_status"].get<long>(), 202L, "aqmh resume from STACKING launch status");
const auto aqmh_overlay_status = harness.get_json("/api/runs/aqmh_resume_overlay_alias/status"); expect_equal(aqmh_overlay_status["_http_status"].get<long>(), 200L, "aqmh resume overlay status code"); expect_equal(aqmh_overlay_status["status"].get<std::string>(), "running", "aqmh resume overlay run status"); bool found_overlay_stack = false; for (const auto& item : aqmh_overlay_status["phases"]) { if (test_phase_name(item) == "STACKING") { found_overlay_stack = true; } } expect_true(found_overlay_stack, "aqmh resume overlay from STACKING keeps stacking phase visible"); } catch (const std::exception& e) { harness.stop(); std::fprintf(stderr, "%s\n", e.what()); return 1; } return 0;}