ModernSession::read_almanac answers the almanac screen's request kinds (index, calendar, day, match) from the engine's almanac in the demo's match form: competition, sides with human managers, result split into regulation, extra time (by the goal minutes) and shoot-out, referee, attendance, weather, line-ups and events. Unknown line-ups stay null. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
280 lines
19 KiB
C++
280 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");
|
|
}
|
|
} 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;
|
|
}
|