Files
Dreierpack-Manager/tests/modern_ui_contract_tests.cpp
T
ClaudeandClaude Opus 5.5 015fa65f56 Modern UI: the statistics screen reads the almanac
ModernSession::read_statistics_screen answers the statistics screen's filters
with real data: eternal table, national tournaments (winners, scorers,
history), series and records, winners by season and the own club per five
minutes. Views the engine does not record yet (title chances, transfers,
weekly curves, season finances) answer available false, reason not_recorded.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
2026-10-27 09:00:22 +01:00

288 lines
19 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
// The engine side of the Modern interface contract (docs/new_engine/ui-anbindung.md): the
// envelope, identities, money, errors and that a read changes nothing. Needs game data
// (a Modern session on the Classic data).
#include <cstdio>
#include <string>
#include <variant>
#include "cli/json.hpp"
#include "modern/app/modern_session.hpp"
#include "modern/content/ui_contract.hpp"
#include "modern/game/save.hpp"
using namespace bmh;
using J = cli::Json;
using O = J::Object;
namespace {
int failures = 0;
void check(bool ok, const char* what) {
if (!ok) {
std::fprintf(stderr, "FAIL: %s\n", what);
++failures;
}
}
const J& at(const J& j, const char* key) {
static const J none;
const auto* o = j.object();
if (!o) return none;
const auto it = o->find(key);
return it == o->end() ? none : it->second;
}
std::string s(const J& j) { return j.string() ? *j.string() : std::string{}; }
bool truth(const J& j) { const bool* b = std::get_if<bool>(&j.value); return b && *b; }
} // namespace
int main(int argc, char** argv) {
if (argc < 2) {
std::fprintf(stderr, "usage: modern_ui_contract_tests <BMH data>\n");
return 2;
}
try {
modern::app::ModernSession session(argv[1], 1u);
ui::SetupOptions options;
ui::ManagerChoice choice;
choice.name = "TEST";
choice.master_club = 0;
std::string error;
if (!session.confirm_manager(options, choice, error)) throw std::runtime_error("manager: " + error);
ui::CareerInitializationResult init;
if (!session.finish(init, error)) throw std::runtime_error("career start: " + error);
const uint64_t revision = init.desktop.revision;
const auto before = modern::save_stream(session.state());
const std::string career = session.state().career_id;
// session: envelope and identities
const J sess = session.ui_read(O{{"kind", "session"}, {"requestId", "request:1"}}, revision);
check(s(at(sess, "messageType")) == "snapshot", "session is a snapshot");
check(s(at(sess, "requestId")) == "request:1", "request id echoed");
const J& meta = at(sess, "meta");
check(s(at(meta, "contractVersion")) == "bmh-modern-ui@draft1", "contract version");
check(s(at(meta, "careerId")).starts_with("career:") && s(at(meta, "careerId")).size() == 23, "career id");
check(s(at(meta, "stateRevision")) == std::to_string(revision), "state revision as decimal string");
check(s(at(at(meta, "scope"), "managerId")) == "manager:1", "first manager id");
check(s(at(at(meta, "currency"), "code")) == "EUR" && at(at(meta, "currency"), "minorUnits").integer() &&
*at(at(meta, "currency"), "minorUnits").integer() == 2, "currency");
const auto* managers = at(at(sess, "data"), "managers").array();
check(managers && managers->size() == 1 && s(at((*managers)[0], "status")) == "active", "one active manager");
// desktop: money in minor units, menus
const J desk = session.ui_read(O{{"kind", "desktop"}}, revision);
const J status = session.read(O{{"kind", "status"}});
const int64_t euros = at(status, "money").integer() ? *at(status, "money").integer() : -1;
check(s(at(at(at(at(desk, "data"), "accounts"), "cash"), "minor")) == std::to_string(euros * 100), "cash in cents");
const auto* menus = at(at(desk, "data"), "menuAvailability").object();
check(menus && menus->size() == 16 && s(at(menus->at("bank"), "status")) == "available", "menus at a club desk");
// squad: own club with salaries, another club without
const J own = session.ui_read(O{{"kind", "squad"}}, revision);
const auto* players = at(at(own, "data"), "players").array();
check(players && players->size() >= 11, "own squad");
check(players && !players->empty() && at((*players)[0], "salaryMonthly").object(), "own salaries known");
const J other = session.ui_read(O{{"kind", "squad"}, {"teamId", "team:5"}}, revision);
const auto* others = at(at(other, "data"), "players").array();
check(others && !others->empty() && std::holds_alternative<std::nullptr_t>(at((*others)[0], "salaryMonthly").value), "foreign salaries unknown");
// errors
check(s(at(session.ui_read(O{{"kind", "nonsense"}}, revision), "code")) == "unknown_read", "unknown read");
check(s(at(session.ui_read(O{{"kind", "desktop"}, {"managerId", "manager:7"}}, revision), "code")) ==
"manager_not_active", "other manager refused");
check(s(at(session.ui_read(O{{"kind", "squad"}, {"teamId", "club:none"}}, revision), "code")) == "unknown_team",
"unknown team");
// reads change nothing
check(modern::save_stream(session.state()) == before, "reads leave the state unchanged");
check(session.state().career_id == career, "career id unchanged");
// identities: never reused, nothing set is replaced
modern::ModernState copy = session.state();
modern::ensure_ui_identities(copy);
check(copy.manager_ids == session.state().manager_ids && copy.career_id == career, "identities stable");
copy.manager_ids.clear();
modern::ensure_ui_identities(copy);
check(copy.manager_ids.size() == 1 && copy.manager_ids[0] == "manager:2", "a freed slot gets a new id");
// money
check(s(at(modern::ui_money(15), "minor")) == "1500" && s(at(modern::ui_money(-3), "minor")) == "-300", "money");
// camps: read with binding quotes, then camp.book as the first command
const J camps = session.ui_read(O{{"kind", "camps"}}, revision);
const auto* list = at(at(camps, "data"), "camps").array();
check(list && list->size() == session.state().training_camps.size() && !list->empty(), "camp catalogue");
const std::string camp_id = list && !list->empty() ? s(at((*list)[0], "id")) : "";
const std::string price = list && !list->empty() ? s(at(at(at((*list)[0], "quote"), "total"), "minor")) : "";
check(list && !list->empty() && truth(at(at((*list)[0], "quote"), "allowed")), "camp quote allowed");
uint64_t rev = revision;
const auto command = [&](const std::string& id, const std::string& expected, const std::string& manager,
const std::string& camp) {
return J(O{{"messageType", "command"}, {"requestId", id}, {"expectedRevision", expected},
{"owner", O{{"managerId", manager}}}, {"kind", "camp.book"}, {"payload", O{{"campId", camp}}}});
};
const auto unchanged = modern::save_stream(session.state());
check(s(at(session.ui_command(command("request:c1", "999", "manager:1", camp_id), rev), "code")) == "stale_revision",
"stale revision refused");
check(s(at(session.ui_command(command("request:c2", std::to_string(rev), "manager:9", camp_id), rev), "code")) ==
"manager_not_active", "foreign owner refused");
check(s(at(session.ui_command(command("request:c3", std::to_string(rev), "manager:1", "resort:none"), rev), "code")) ==
"unknown_camp", "unknown camp refused");
check(rev == revision && modern::save_stream(session.state()) == unchanged, "refused commands change nothing");
const int64_t cash_before = *at(session.read(O{{"kind", "status"}}), "money").integer();
const J booked = session.ui_command(command("request:c4", std::to_string(rev), "manager:1", camp_id), rev);
check(s(at(booked, "messageType")) == "command_result" && s(at(booked, "newRevision")) == std::to_string(revision + 1) &&
rev == revision + 1, "camp booked, one revision");
const int64_t cash_after = *at(session.read(O{{"kind", "status"}}), "money").integer();
check(std::to_string((cash_before - cash_after) * 100) == price, "the quoted price was charged");
const J again = session.ui_command(command("request:c4", std::to_string(revision), "manager:1", camp_id), rev);
check(cli::dump_json(again) == cli::dump_json(booked) && rev == revision + 1 &&
*at(session.read(O{{"kind", "status"}}), "money").integer() == cash_after, "repeated request answered, not booked twice");
check(s(at(session.ui_command(command("request:c4", std::to_string(rev), "manager:1", camp_id), rev), "code")) ==
"duplicate_request", "same id, other command");
const auto after_booking = modern::save_stream(session.state());
check(s(at(session.ui_command(command("request:c5", std::to_string(rev), "manager:1", camp_id), rev), "code")) ==
"booked_this_week" && modern::save_stream(session.state()) == after_booking && rev == revision + 1,
"second booking in a week refused without change");
const J after = session.ui_read(O{{"kind", "camps"}}, rev);
check(at(at(after, "data"), "staysThisSeason").integer() && *at(at(after, "data"), "staysThisSeason").integer() == 1 &&
truth(at(at(after, "data"), "bookedThisWeek")), "camp read shows the stay");
// lineup, tactics, training: read, one accepted and one refused command each
const auto cmd = [&](const std::string& id, const char* kind, J payload) {
return J(O{{"messageType", "command"}, {"requestId", id}, {"expectedRevision", std::to_string(rev)},
{"owner", O{{"managerId", "manager:1"}}}, {"kind", kind}, {"payload", std::move(payload)}});
};
const J lineup = session.ui_read(O{{"kind", "lineup"}}, rev);
const auto* order = at(at(lineup, "data"), "order").array();
check(order && order->size() >= 12 && at(at(lineup, "data"), "positions").array() &&
at(at(lineup, "data"), "positions").array()->size() == 11, "lineup read");
if (order && order->size() >= 12) {
J::Array wanted = *order;
std::swap(wanted[0], wanted[1]);
std::swap(wanted[10], wanted[11]);
const uint64_t before_lineup = rev;
const J done = session.ui_command(cmd("request:l1", "lineup.commit", O{{"order", wanted}}), rev);
if (s(at(done, "messageType")) != "command_result") std::fprintf(stderr, "lineup: %s\n", cli::dump_json(done).c_str());
const J reread = session.ui_read(O{{"kind", "lineup"}}, rev);
const auto* now = at(at(reread, "data"), "order").array();
if (now && (s((*now)[0]) != s(wanted[0]) || s((*now)[10]) != s(wanted[10]) || rev != before_lineup + 1))
std::fprintf(stderr, "lineup: rev %llu/%llu, now %s %s %s, wanted %s %s %s\n", (unsigned long long)rev,
(unsigned long long)before_lineup, s((*now)[0]).c_str(), s((*now)[1]).c_str(), s((*now)[10]).c_str(),
s(wanted[0]).c_str(), s(wanted[1]).c_str(), s(wanted[10]).c_str());
check(s(at(done, "messageType")) == "command_result" && rev == before_lineup + 1 && now &&
s((*now)[0]) == s(wanted[0]) && s((*now)[10]) == s(wanted[10]),
"lineup committed");
const auto kept = modern::save_stream(session.state());
check(s(at(session.ui_command(cmd("request:l2", "lineup.commit", O{{"order", J::Array{J("player:none")}}}), rev),
"code")) == "unknown_player" && modern::save_stream(session.state()) == kept && rev == before_lineup + 1,
"unknown player refused without change");
}
const J tactics = session.ui_read(O{{"kind", "tactics"}}, rev);
const auto* controls = at(at(tactics, "data"), "controls").array();
check(controls && controls->size() == 8, "tactics read");
if (controls && controls->size() == 8) {
J::Array values;
for (const auto& c : *controls) values.push_back(at(c, "value"));
const int64_t max7 = *at(at((*controls)[7], "range"), "max").integer();
const int64_t v7 = *values[7].integer();
values[7] = J(v7 == max7 ? v7 - 1 : v7 + 1);
const uint64_t before_tactics = rev;
const J done = session.ui_command(cmd("request:t1", "tactics.commit", O{{"values", values}}), rev);
const J reread = session.ui_read(O{{"kind", "tactics"}}, rev);
const auto* now = at(at(reread, "data"), "controls").array();
check(s(at(done, "messageType")) == "command_result" && rev == before_tactics + 1 && now &&
*at((*now)[7], "value").integer() == *values[7].integer(), "tactics committed");
values[7] = J(max7 + 1);
const auto kept = modern::save_stream(session.state());
check(s(at(session.ui_command(cmd("request:t2", "tactics.commit", O{{"values", values}}), rev), "code")) ==
"invalid_tactic" && modern::save_stream(session.state()) == kept, "tactic above its maximum refused");
}
const J training = session.ui_read(O{{"kind", "training"}}, rev);
check(s(at(training, "messageType")) == "snapshot" && at(at(training, "data"), "areas").array() &&
at(at(training, "data"), "areas").array()->size() == 9, "training read");
{
const uint64_t before_training = rev;
const J done = session.ui_command(cmd("request:p1", "training.commit",
O{{"types", J::Array{J(2), J(2), J(2), J(2)}},
{"areas", J::Array{J(2), J(2), J(2), J(2), J(2), J(2), J(2), J(2), J(2)}}}), rev);
const J now = session.ui_read(O{{"kind", "training"}}, rev);
const auto* areas = at(at(now, "data"), "areas").array();
check(s(at(done, "messageType")) == "command_result" && rev == before_training + 1 && areas &&
*at((*areas)[8], "allocation").integer() == 2, "training committed");
const auto kept = modern::save_stream(session.state());
check(s(at(session.ui_command(cmd("request:p2", "training.commit", O{{"types", J::Array{J(3), J(3), J(3), J(3)}}}), rev),
"messageType")) == "error" && modern::save_stream(session.state()) == kept && rev == before_training + 1,
"training over the limit refused without change");
}
// bank: read, fixed deposit, a share, a refused withdrawal
{
const J bank = session.ui_read(O{{"kind", "bank"}}, rev);
const J& accounts = at(at(bank, "data"), "accounts");
const auto* stocks = at(at(bank, "data"), "stocks").array();
check(s(at(bank, "messageType")) == "snapshot" && stocks && stocks->size() == 12, "bank read");
const std::string deposit_before = s(at(at(accounts, "deposit"), "minor"));
const uint64_t before_bank = rev;
const J done = session.ui_command(cmd("request:b1", "bank.commit",
O{{"action", "deposit"}, {"amount", O{{"minor", "10000000"}, {"currency", "EUR"}, {"minorUnits", 2}}}}), rev);
const J after = session.ui_read(O{{"kind", "bank"}}, rev);
check(s(at(done, "messageType")) == "command_result" && rev == before_bank + 1 &&
std::stoll(s(at(at(at(at(after, "data"), "accounts"), "deposit"), "minor"))) ==
std::stoll(deposit_before) + 10000000, "100000 euros to the fixed deposit");
const J share = session.ui_command(cmd("request:b2", "bank.commit", O{{"action", "buy"}, {"assetId", "stock:0"}, {"count", 1}}), rev);
check(s(at(share, "messageType")) == "command_result" && rev == before_bank + 2, "one share bought");
const auto kept = modern::save_stream(session.state());
const J refused = session.ui_command(cmd("request:b3", "bank.commit",
O{{"action", "withdraw"}, {"amount", O{{"minor", "99999999900"}, {"currency", "EUR"}, {"minorUnits", 2}}}}), rev);
check(s(at(refused, "messageType")) == "error" && modern::save_stream(session.state()) == kept && rev == before_bank + 2,
"withdrawal above the deposit refused without change");
}
// session.advance: three kickoffs, each one revision, the date moves on
{
const std::string date_before = s(at(at(session.ui_read(O{{"kind", "desktop"}}, rev), "meta"), "date"));
for (int k = 0; k < 3; ++k) {
const uint64_t before = rev;
const J done = session.ui_command(cmd("request:a" + std::to_string(k), "session.advance", O{}), rev);
if (s(at(done, "messageType")) != "command_result")
std::fprintf(stderr, "advance: %s\n", cli::dump_json(done).c_str());
check(s(at(done, "messageType")) == "command_result" && rev == before + 1, "advance accepted");
}
const std::string date_after = s(at(at(session.ui_read(O{{"kind", "desktop"}}, rev), "meta"), "date"));
check(date_after > date_before, "the date moved on");
}
// almanac view after the kickoffs: index, calendar, day, match
{
const J index = session.read_almanac(O{{"kind", "index"}});
const auto* years = at(index, "years").array();
check(truth(at(index, "ok")) && years && !years->empty() && *at(index, "match_count").integer() > 0, "almanac index");
const J cal = years && !years->empty() ? session.read_almanac(O{{"kind", "calendar"}, {"year", (*years)[0]}}) : J{};
const auto* days = at(cal, "days").array();
check(days && !days->empty(), "almanac calendar");
const J day = days && !days->empty() ? session.read_almanac(O{{"kind", "day"}, {"date", at((*days)[0], "date")}}) : J{};
const auto* matches = at(day, "matches").array();
check(matches && !matches->empty(), "almanac day");
if (matches && !matches->empty()) {
const J& m = (*matches)[0];
const auto* final_score = at(at(m, "result"), "final").array();
check(final_score && final_score->size() == 2 && at(at(m, "home"), "id").string() &&
at(m, "events").array(), "almanac match form");
const J one = session.read_almanac(O{{"kind", "match"}, {"id", at(m, "id")}});
check(truth(at(one, "ok")) && s(at(at(one, "match"), "id")) == s(at(m, "id")), "almanac match by id");
}
check(s(at(session.read_almanac(O{{"kind", "match"}, {"id", "match:0-0"}}), "error")) == "almanac_match_not_found",
"unknown match");
// the statistics screen: real data (fictional false), unrecorded views say so
const J minutes = session.read_statistics_screen(O{{"section", 8}});
check(truth(at(minutes, "ok")) && !truth(at(minutes, "fictional")) && at(minutes, "rows").array() &&
at(minutes, "rows").array()->size() == 4, "minute statistics");
const J transfers = session.read_statistics_screen(O{{"section", 1}});
check(truth(at(transfers, "ok")) && !truth(at(transfers, "available")) && s(at(transfers, "reason")) == "not_recorded",
"transfer history not recorded");
check(s(at(session.read_statistics_screen(O{{"section", 9}}), "error")) == "invalid_statistics_filter", "bad section");
}
} catch (const std::exception& ex) {
std::fprintf(stderr, "FAIL: %s\n", ex.what());
return 1;
}
if (failures == 0) std::printf("modern ui contract tests passed\n");
return failures == 0 ? 0 : 1;
}