120 lines
5.4 KiB
C++
120 lines
5.4 KiB
C++
#include <faset/authoring/service.hpp>
|
|
#include <faset/core/io.hpp>
|
|
#include <faset/editor/autosave.hpp>
|
|
#include <chrono>
|
|
#include <iostream>
|
|
|
|
using namespace faset;
|
|
using namespace std::chrono_literals;
|
|
namespace fs = std::filesystem;
|
|
|
|
namespace {
|
|
void check(bool value, std::string_view message) {
|
|
if (!value)
|
|
throw std::runtime_error(std::string(message));
|
|
}
|
|
void contracts(const fs::path& root) {
|
|
authoring::AuthoringService service(root);
|
|
const auto created = service.create("Before", 2);
|
|
const auto id = created.at("id").get<std::string>();
|
|
const auto path = root / "Scenes/main.scene.json";
|
|
service.save(id, "Scenes/main.scene.json");
|
|
int saves{};
|
|
editor::AutosaveController autosave([&](const std::string& document, std::uint64_t revision) {
|
|
++saves;
|
|
return service.save(document, {}, revision);
|
|
});
|
|
using Clock = editor::AutosaveController::Clock;
|
|
const auto start = Clock::time_point{};
|
|
autosave.observe(service.documents(), start, true);
|
|
for (int index = 1; index <= 3; ++index) {
|
|
const auto revision = service.query(id).at("revision").get<std::uint64_t>();
|
|
service.transact(id, revision,
|
|
Json::array({{{"op", "scene.rename"},
|
|
{"name", "Edit " + std::to_string(index)}}}));
|
|
autosave.observe(service.documents(), start + index * 100ms, true);
|
|
}
|
|
const auto play_snapshot = service.query(id).at("scene");
|
|
autosave.observe(service.documents(), start + 2299ms, true);
|
|
check(saves == 0 && read_json(path).at("name") == "Before",
|
|
"Rapid edits coalesce until the last revision is idle for two seconds");
|
|
autosave.observe(service.documents(), start + 2301ms, true);
|
|
check(saves == 1 && read_json(path).at("name") == "Edit 3" &&
|
|
service.query(id).at("scene") == play_snapshot &&
|
|
autosave.status().at("documents")[0].at("state") == "saved",
|
|
"Named scene saves once without changing the Play snapshot");
|
|
const auto current_revision = service.query(id).at("revision").get<std::uint64_t>();
|
|
check(service.undo(id, current_revision).at("scene").at("name") == "Edit 2",
|
|
"Undo remains available after autosave");
|
|
bool stale_rejected{};
|
|
try {
|
|
service.save(id, {}, current_revision);
|
|
} catch (const Error& error) {
|
|
stale_rejected = error.code() == "revision.conflict";
|
|
}
|
|
check(stale_rejected, "A stale autosave revision cannot save a newer document");
|
|
|
|
const auto external = read_text(path) + " \n";
|
|
atomic_write(path, external);
|
|
const auto revision = service.query(id).at("revision").get<std::uint64_t>();
|
|
service.transact(id, revision,
|
|
Json::array({{{"op", "scene.rename"}, {"name", "After external edit"}}}));
|
|
autosave.observe(service.documents(), start + 3000ms, true);
|
|
autosave.observe(service.documents(), start + 5100ms, true);
|
|
check(saves == 2 && read_text(path) == external &&
|
|
autosave.status().at("documents")[0].at("state") == "conflict",
|
|
"Disk conflict does not overwrite external changes");
|
|
autosave.observe(service.documents(), start + 10000ms, true);
|
|
check(saves == 2, "A failed autosave does not retry every polling frame");
|
|
|
|
const auto unnamed = service.create("Unnamed", 2);
|
|
autosave.observe(service.documents(), start + 10100ms, true);
|
|
bool found_unnamed{};
|
|
const auto unnamed_status = autosave.status();
|
|
for (const auto& row : unnamed_status.at("documents"))
|
|
if (row.at("id") == unnamed.at("id"))
|
|
found_unnamed = row.at("state") == "save_as_required";
|
|
check(found_unnamed &&
|
|
fs::is_regular_file(root / ".faset/recovery" /
|
|
(unnamed.at("id").get<std::string>() + ".json")),
|
|
"Unnamed scene remains recoverable without receiving an implicit save path");
|
|
autosave.observe(service.documents(), start + 10200ms, false);
|
|
check(!autosave.status().at("enabled").get<bool>() && saves == 2,
|
|
"Disabled autosave leaves recovery journaling active");
|
|
|
|
int failed_attempts{};
|
|
editor::AutosaveController failing([&](const std::string&, std::uint64_t) -> Json {
|
|
++failed_attempts;
|
|
throw Error("io.write", "Synthetic read-only destination");
|
|
});
|
|
Json fake_documents = Json::array(
|
|
{{{"id", "failure-fixture"}, {"revision", 1},
|
|
{"path", "Scenes/fixture.scene.json"}, {"dirty", true}}});
|
|
failing.observe(fake_documents, start, true);
|
|
failing.observe(fake_documents, start + 2100ms, true);
|
|
check(failed_attempts == 1 &&
|
|
failing.status().at("documents")[0].at("state") == "failed",
|
|
"Write failures remain visible");
|
|
failing.observe(fake_documents, start + 10000ms, true);
|
|
check(failed_attempts == 1, "A failed write does not retry on every frame");
|
|
fake_documents[0]["revision"] = 2;
|
|
failing.observe(fake_documents, start + 10100ms, true);
|
|
failing.observe(fake_documents, start + 12200ms, true);
|
|
check(failed_attempts == 2, "A newer revision receives a fresh autosave deadline");
|
|
}
|
|
} // namespace
|
|
|
|
int main() {
|
|
const auto root = fs::temp_directory_path() / ("faset-autosave-" + new_id());
|
|
try {
|
|
contracts(root);
|
|
fs::remove_all(root);
|
|
std::cout << "Revision-aware autosave contracts passed\n";
|
|
return 0;
|
|
} catch (const std::exception& error) {
|
|
std::cerr << error.what() << '\n';
|
|
fs::remove_all(root);
|
|
return 1;
|
|
}
|
|
}
|