338 lines
15 KiB
C++
338 lines
15 KiB
C++
// SPDX-License-Identifier: GPL-3.0-only
|
|
#include "modern/ui/desktop.hpp"
|
|
#include "modern/ui/model.hpp"
|
|
#include "modern/ui/demo_opening.hpp"
|
|
#include <iostream>
|
|
#include <stdexcept>
|
|
|
|
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<const Catalog> 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<Json> bad_values = {Json(), Json::array(), Json::object()};
|
|
for (const auto &[field, values] :
|
|
std::vector<std::pair<std::string, std::vector<Json>>>{
|
|
{"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<std::pair<std::string, std::vector<Json>>>{
|
|
{"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;
|
|
}
|
|
}
|