The bank read lists account, fixed deposit, credit line, investments, the 12 stocks with their price history and the offered funds as Money. bank.commit moves money to or from the fixed deposit and buys or sells shares and fund units through the desk's own checks. Credits follow; the stock tip draws a random number and will be a quote.request. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
245 lines
16 KiB
C++
245 lines
16 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");
|
|
}
|
|
} 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;
|
|
}
|