Files
Dreierpack-Manager/tests/modern_entry_ui_tests.cpp
T

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;
}
}