// SPDX-License-Identifier: GPL-3.0-only #include "modern/ui/desktop.hpp" #include "modern/ui/model.hpp" #include "modern/ui/demo_opening.hpp" #include #include using namespace bmh::modern_ui; namespace { void require(bool yes, const char *message) { if (!yes) throw std::runtime_error(message); } struct Fixture { fs::path root; std::shared_ptr world; Fixture() : root(fs::temp_directory_path() / bmh::editor::new_id("openbmh-entry-test-")) { fs::create_directories(root / "world"); const auto write = [&](const char *path, const Json &data) { bmh::editor::write_atomic(root / path, data.dump()); }; write("manifest.json", {{"format", "openbmh-world"}, {"kind", "world"}, {"format_version", "1.1"}, {"id", "world:synthetic-entry"}, {"start_date", "2032-07-01"}, {"requires", {"editor:world-v1"}}, {"x-editor", {{"profile", "editor-world-v1"}}}}); write("world/nations.json", {{"items", {{{"id", "nation:de"}, {"name", "Synthetic Germany"}}, {{"id", "nation:es"}, {"name", "Synthetic Spain"}}}}}); write("world/competitions.json", {{"items", {{{"id", "competition:de"}, {"name", "Synthetic DE"}, {"nation", "nation:de"}, {"type", "league"}}, {{"id", "competition:es"}, {"name", "Synthetic ES"}, {"nation", "nation:es"}, {"type", "league"}}}}}); Json clubs = Json::array(); for (int index = 0; index < 5; ++index) clubs.push_back({{"id", "club:entry-" + std::to_string(index)}, {"name", "Synthetic club " + std::to_string(index)}, {"nation", "nation:de"}, {"competition", "competition:de"}}); clubs.push_back({{"id", "club:foreign"}, {"name", "Foreign club"}, {"nation", "nation:es"}, {"competition", "competition:es"}}); write("world/clubs.json", {{"items", clubs}}); write("world/players.json", {{"items", Json::array()}}); world = Catalog::open(root); } ~Fixture() { std::error_code error; fs::remove_all(root, error); } }; Json setup(int players = 2, bool league = true, bool world = true) { return {{"duration", 5}, {"difficulty", 3}, {"players", players}, {"mode", 3}, {"league", league}, {"world", world}}; } Json manager(int index, const std::string &name = {}) { return {{"name", name.empty() ? "Manager " + std::to_string(index) : name}, {"club", "club:entry-" + std::to_string(index)}, {"portrait", index}, {"portrait_style", index % 2 ? "painted" : "photo"}, {"strength_choice", index % 3}}; } Json start(int players = 2) { Json managers = Json::array(); for (int index = 0; index < players; ++index) managers.push_back(manager(index)); return {{"setup", setup(players)}, {"managers", managers}}; } void rejected(DemoSource &source, const std::string &kind, const Json &value, uint64_t revision) { const auto before = source.snapshot(); const bool dirty = source.dirty(); const auto result = source.apply({revision, kind, value}); require(!result.ok && result.revision == before.revision, "Invalid/stale entry action accepted or returned wrong revision"); require(source.snapshot().state == before.state && source.snapshot().revision == before.revision && source.dirty() == dirty, "Rejected entry action changed state, revision or clean marker"); } void names() { require(normalized_manager_name(" Änne Öster ") == "Änne Öster", "Manager name not trimmed"); require(normalized_manager_name("\xc2\xa0" "Robin" "\xe3\x80\x80") == "Robin", "Unicode edge whitespace not trimmed"); require(normalized_manager_name("Alex Berger") == "Alex Berger", "Internal whitespace was changed"); std::string umlauts, emoji; for (int index = 0; index < 24; ++index) { umlauts += "Ä"; emoji += "\xf0\x9f\x98\x80"; } require(normalized_manager_name(umlauts) == umlauts && normalized_manager_name(emoji) == emoji, "24 Unicode codepoints were counted as UTF8 bytes/UTF16 units"); require(!normalized_manager_name(umlauts + "Ä") && !normalized_manager_name(emoji + "x"), "25 codepoints accepted"); require(!normalized_manager_name("") && !normalized_manager_name(" ") && !normalized_manager_name("Name\n") && !normalized_manager_name("\tName") && !normalized_manager_name(std::string("N\0ame", 5)) && !normalized_manager_name("Name\xc2\x85"), "Empty/control manager name accepted"); require(!normalized_manager_name("\xc0\xaf") && !normalized_manager_name("\xed\xa0\x80") && !normalized_manager_name("\xf4\x90\x80\x80") && !normalized_manager_name("\xe2\x82"), "Malformed UTF8 manager name accepted"); } void transactions(const Fixture &fixture) { DemoSource source(fixture.world); const auto base = source.snapshot(); auto valid = start(); valid["managers"][0]["name"] = " Alex Öster "; const auto committed = source.apply({base.revision, "start", valid}); const auto current = source.snapshot(); require(committed.ok && committed.revision == base.revision + 1 && current.revision == committed.revision && source.dirty(), "Start did not atomically publish exactly one dirty revision"); require(current.state.at("edits").at("setup") == valid.at("setup") && current.state.at("managers").size() == 2 && current.state.at("managers")[0].at("name") == "Alex Öster" && current.state.at("managers")[1].at("portrait_style") == "painted" && current.state.at("managers")[1].at("strength_choice") == 1, "Start lost setup, normalized name, style or strength"); require(current.state.at("opening") == "pending" && current.state.at("opening_created") == false, "League start did not stage presentation opening"); for (const auto *field : {"cash", "deposit", "debt", "date", "ticket", "preferences"}) require(current.state.at(field) == base.state.at(field), "Presentation start changed unrelated career/global values"); rejected(source, "start", valid, base.revision); require(source.mark_saved(current.revision) && !source.dirty(), "Cannot checkpoint accepted start"); auto bad = valid; bad["setup"]["players"] = 3; rejected(source, "start", bad, current.revision); require(!source.dirty(), "Rejected start dirtied a clean source"); auto world_only = start(1); world_only["setup"] = setup(1, false, true); require( source.apply({current.revision, "start", world_only}).ok && source.snapshot().state.at("opening") == "complete" && source.snapshot().state.at("opening_created") == false, "World-only single-manager start incorrectly opens league presentation"); } void invalid(const Fixture &fixture) { DemoSource source(fixture.world); const auto valid = start(); std::vector bad_values = {Json(), Json::array(), Json::object()}; for (const auto &[field, values] : std::vector>>{ {"duration", {0, 6, 2.5, true}}, {"difficulty", {0, 11, "3"}}, {"players", {0, 5, 2.0}}, {"mode", {0, 4, false}}}) for (const auto &value : values) { auto bad = valid; bad["setup"][field] = value; bad_values.push_back(bad); } for (const auto *field : {"duration", "difficulty", "players", "mode", "league", "world"}) { auto bad = valid; bad["setup"].erase(field); bad_values.push_back(bad); } auto bad = valid; bad["setup"]["league"] = 1; bad_values.push_back(bad); bad = valid; bad["setup"]["world"] = "true"; bad_values.push_back(bad); bad = valid; bad["setup"]["league"] = false; bad["setup"]["world"] = false; bad_values.push_back(bad); bad = valid; bad["setup"]["league"] = false; bad_values.push_back(bad); bad = valid; bad["managers"].push_back(manager(2)); bad_values.push_back(bad); bad = valid; bad["managers"] = Json::array(); bad_values.push_back(bad); for (const auto &value : bad_values) rejected(source, "start", value, source.snapshot().revision); for (const auto &[field, values] : std::vector>>{ {"name", {"", " ", "Name\n", std::string(25, 'x'), 17}}, {"club", {"club:foreign", "club:missing", 1}}, {"portrait", {-1, 12, 1.5, true}}, {"portrait_style", {"", "drawing", 1}}, {"strength_choice", {-1, 3, 1.5, false}}}) for (const auto &value : values) { auto request = valid; request["managers"][1][field] = value; rejected(source, "start", request, source.snapshot().revision); rejected(source, "managers", request.at("managers"), source.snapshot().revision); } for (const auto *field : {"club", "portrait"}) { auto request = valid; request["managers"][1][field] = request["managers"][0][field]; rejected(source, "start", request, source.snapshot().revision); rejected(source, "managers", request.at("managers"), source.snapshot().revision); } require(source.snapshot().revision == 0 && !source.dirty(), "Invalid entries accumulated hidden revisions"); } void additional_managers(const Fixture &fixture) { DemoSource source(fixture.world); auto baseline = source.snapshot(); auto values = baseline.state.at("managers"); auto second = manager(1, " Chris Winter "); second["synthetic_extra"] = "retained"; values.push_back(second); require(source.apply({baseline.revision, "managers", values}).ok, "Adding valid second manager failed"); auto after = source.snapshot(); require(after.state.at("managers")[0] == baseline.state.at("managers")[0] && after.state.at("managers")[1].at("name") == "Chris Winter" && after.state.at("managers")[1].at("synthetic_extra") == "retained", "Add mutated earlier manager or lost normalized/extra data"); auto previous = after.state.at("managers"); values = previous; values.push_back(manager(2)); require(source.apply({after.revision, "managers", values}).ok, "Adding third manager failed"); after = source.snapshot(); require(after.state.at("managers")[0] == previous[0] && after.state.at("managers")[1] == previous[1], "Third manager changed earlier manager choices"); values = after.state.at("managers"); values.push_back(manager(3)); require(source.apply({after.revision, "managers", values}).ok, "Adding fourth manager failed"); after = source.snapshot(); values = after.state.at("managers"); values.push_back(manager(4)); rejected(source, "managers", values, after.revision); rejected(source, "managers", after.state.at("managers"), after.revision - 1); for (const auto &[field, value] : baseline.state.items()) if (field != "managers") require(after.state.at(field) == value, "Adding managers changed first-club state, setup or presentation " "phase"); auto checkpoint = after.state; checkpoint["desktop"] = default_desktop(); DemoSource restored(fixture.world); restored.load_data(checkpoint); require(restored.snapshot().state == after.state && !restored.dirty(), "Additional managers' styles/strengths/extras changed across load"); auto legacy = checkpoint; for (auto &row : legacy["managers"]) { row.erase("portrait_style"); row.erase("strength_choice"); } restored.load_data(legacy); const auto migrated = restored.snapshot(); for (const auto &row : migrated.state.at("managers")) require(row.at("portrait_style") == "photo" && row.at("strength_choice") == 1, "Legacy manager defaults missing"); } void club_migration(const Fixture &fixture) { DemoSource started(fixture.world), edited(fixture.world); const auto historical_news = edited.snapshot().state.at("news"); auto rows = Json::array({manager(1), manager(2)}); require(edited.apply({0, "managers", rows}).ok, "Reference manager club switch failed"); require( started.apply({0, "start", {{"setup", setup()}, {"managers", rows}}}).ok, "Start manager club switch failed"); auto reference = edited.snapshot().state, actual = started.snapshot().state; reference["edits"]["setup"] = setup(); reference["opening"] = "pending"; reference["opening_created"] = false; reference["opening_flow"] = make_demo_opening(*fixture.world, reference, true); require(reference.at("news") == historical_news, "Changing participants rewrote historical news"); const auto &fresh_news = actual.at("news").at("items"); require(!fresh_news.empty() && actual.at("news") != historical_news && std::all_of(fresh_news.begin(), fresh_news.end(), [&](const auto &item) { return item.at("scope").at("id") == "club:entry-1" && item.at("owner").at("name") == actual.at("managers")[0].at("name"); }), "New career did not bind fresh news to its confirmed first manager"); // A new career creates its own journal; changing participants preserves it. // The remaining club-dependent presentation migrations must still agree. reference.erase("news"); actual.erase("news"); require( reference == actual, "Start diverges from established club-change presentation migrations"); require(actual.at("training").at("club") == "club:entry-1", "Start retained previous club's training"); } } // namespace int main() { try { names(); Fixture fixture; transactions(fixture); invalid(fixture); additional_managers(fixture); club_migration(fixture); std::cout << "PASS entry model: atomic setup/managers start, UTF8 names, " "constraints, stale/invalid rollback, stable additions and " "shared club migration\n"; return 0; } catch (const std::exception &error) { std::cerr << error.what() << '\n'; return 1; } }