Files
Dreierpack-Manager/tests/modern_engine_dto_tests.cpp

454 lines
49 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
#include "modern/ui/engine_bridge.hpp"
#include <iostream>
#include <algorithm>
#include <array>
#include <limits>
#include <stdexcept>
using namespace bmh::modern_ui;
namespace {
void require(bool v, const char *why) { if (!v) throw std::runtime_error(why); }
template<class F> void rejects(F f) { bool rejected = false; try { f(); } catch (const std::exception &) { rejected = true; } require(rejected, "invalid DTO accepted"); }
Json fixture() {
const Json meta = {{"contractVersion", "bmh-modern-ui@draft1"}, {"careerId", "career:synthetic"},
{"worldId", "world:synthetic"}, {"worldRevision", "1"}, {"stateRevision", "18446744073709551615"},
{"scope", {{"role", "club"}, {"managerId", "manager:99"}, {"teamId", "club:6"}, {"scopeId", "scope:test"}, {"allowedCommands", {"camp.book"}}}}};
Json out;
for (const auto *kind : {"session", "desktop", "camps"}) out[kind] = {{"messageType", "snapshot"}, {"meta", meta}, {"data", {{"kind", kind}}}};
out["desktop"]["data"].update({{"manager", {{"id", "manager:99"}}}, {"team", {{"id", "club:6"}}},
{"accounts", {{"cash", {{"minor", "9007199254740993"}, {"currency", "EUR"}, {"minorUnits", 2}}}}}});
out["camps"]["data"]["camps"] = Json::array({{{"id", "resort:16"}, {"quote", {{"allowed", true}, {"expectedRevision", meta.at("stateRevision")},
{"ownerManagerId", "manager:99"}, {"teamId", "club:6"}, {"scopeId", "scope:test"},
{"total", {{"minor", "123400"}, {"currency", "EUR"}, {"minorUnits", 2}}}}}}});
return out;
}
}
int main() {
try {
const auto bundle = fixture(), original = bundle;
validate_engine_desk(bundle);
require(engine_money_minor(bundle.at("desktop").at("data").at("accounts").at("cash")) == 9007199254740993LL, "money rounded through double");
const auto focus = Json{{"condition", 0}, {"technique", 15}, {"play", 5}};
const auto command = engine_camp_command(bundle, "resort:16", focus, "request:stable");
require(command.at("owner").at("managerId") == "manager:99" && command.at("expectedRevision") == "18446744073709551615" &&
command.at("payload").at("focus") == focus && bundle == original, "command lost authoritative identity/revision or changed snapshot");
for (const auto &v : Json::array({Json{{"minor", "9223372036854775808"}, {"currency", "EUR"}, {"minorUnits", 2}},
Json{{"minor", "10.25"}, {"currency", "EUR"}, {"minorUnits", 2}},
Json{{"minor", "1000"}, {"currency", "GBP"}, {"minorUnits", 2}}}))
rejects([&] { engine_money_minor(v); });
for (int fault = 0; fault < 10; ++fault) {
auto bad = bundle;
if (fault == 0) bad["camps"]["meta"]["stateRevision"] = "2";
if (fault == 1) bad["session"]["meta"]["careerId"] = "career:other";
if (fault == 2) bad["desktop"]["data"]["manager"]["id"] = "manager:portrait-0";
if (fault == 3) bad["camps"]["data"]["camps"][0]["quote"]["ownerManagerId"] = "manager:1";
if (fault == 4) bad["camps"]["data"]["camps"][0]["quote"]["expectedRevision"] = "2";
if (fault == 5) bad["camps"]["data"]["camps"][0]["quote"]["allowed"] = false;
if (fault == 6) bad["camps"]["data"]["camps"][0]["quote"] = nullptr;
if (fault == 7) for (auto &item : bad) item["meta"]["scope"]["role"] = "national";
if (fault == 8) bad["camps"]["data"]["camps"].push_back(bad["camps"]["data"]["camps"][0]);
if (fault == 9) for (auto &item : bad) item["meta"]["stateRevision"] = "18446744073709551616";
rejects([&] { engine_camp_command(bad, "resort:16", focus, "request:stable"); });
}
rejects([&] { engine_camp_command(bundle, "resort:unknown", focus, "request:stable"); });
auto invalid_focus = focus; invalid_focus["play"] = 16;
rejects([&] { engine_camp_command(bundle, "resort:16", invalid_focus, "request:stable"); });
auto squad_bundle = fixture();
for (auto &item : squad_bundle) item["meta"]["scope"]["allowedCommands"].push_back("lineup.commit");
const auto meta = squad_bundle.at("desktop").at("meta");
Json players = Json::array(), order = Json::array(), role_rows = Json::array();
for (int i = 0; i < 4; ++i) {
const auto id = "player:" + std::to_string(i);
order.push_back(id); role_rows.push_back({{"playerId", id}, {"role", i < 2 ? "starter" : i == 2 ? "bench" : "reserve"}});
players.push_back({{"player", {{"id", id}, {"name", "Engine Name " + std::to_string(i)}, {"positions", {"gk"}}, {"nationIds", {"nation:de"}}}},
{"availability", "fit"}, {"age", 37}, {"skills", {{"speed", 2}}},
{"metrics", {{"strength", {{"value", 91}, {"availability", {{"status", "available"}}}}},
{"condition", {{"value", 0}}}}}});
}
squad_bundle["squad"] = {{"messageType", "snapshot"}, {"meta", meta},
{"data", {{"kind", "squad"}, {"team", {{"id", "club:6"}}}, {"players", players}}}};
squad_bundle["lineup"] = {{"messageType", "snapshot"}, {"meta", meta}, {"data", {{"kind", "lineup"}, {"teamId", "club:6"},
{"order", order}, {"rows", role_rows}, {"positions", Json::array({{{"playerId", "player:0"}, {"depth", 19}, {"lane", 8}},
{{"playerId", "player:1"}, {"depth", 0}, {"lane", 4}}})}, {"depthMax", 19}, {"laneMax", 8}}}};
const auto source_bundle = squad_bundle;
const auto projected = engine_lineup_projection(squad_bundle);
require(projected.at("rows")[0].at("strength") == 91 && projected.at("rows")[0].at("condition") == 0 &&
projected.at("rows")[0].at("goals").is_null() && projected.at("rows")[0].at("grade").is_null(),
"projection invented catalogue/season values or discarded known zero");
require(projected.at("rows")[2].at("status") == "Ersatzbank" && projected.at("rows")[3].at("status") == "—" &&
projected.at("board").at("points")[0] == Json::array({19,8}), "roles/coordinate bounds inferred from demo rules");
auto changed_order = order; std::swap(changed_order[0], changed_order[2]);
const auto lineup_command = engine_lineup_command(squad_bundle, changed_order, "request:lineup");
require(lineup_command.at("payload").at("order") == changed_order && lineup_command.at("owner").at("managerId") == "manager:99" &&
lineup_command.at("expectedRevision") == "18446744073709551615" && squad_bundle == source_bundle,
"lineup command lost complete identities/revision or changed read source");
for (int fault = 0; fault < 6; ++fault) {
auto bad_order = changed_order;
if (fault == 0) bad_order[0] = bad_order[1];
if (fault == 1) bad_order.erase(0);
if (fault == 2) bad_order[0] = "player:foreign";
if (fault == 3) bad_order[0] = 3;
if (fault == 4) bad_order.push_back("player:extra");
if (fault == 5) bad_order = Json::object();
rejects([&] { engine_lineup_command(squad_bundle, bad_order, "request:lineup"); });
}
auto wrong_context = squad_bundle; wrong_context["squad"]["meta"]["stateRevision"] = "2";
rejects([&] { engine_lineup_projection(wrong_context); });
wrong_context = squad_bundle; wrong_context["lineup"]["data"]["teamId"] = "club:other";
rejects([&] { engine_lineup_command(wrong_context, order, "request:lineup"); });
auto hidden_metric = squad_bundle; hidden_metric["squad"]["data"]["players"][0]["metrics"]["strength"]["availability"]["status"] = "unavailable";
require(engine_lineup_projection(hidden_metric).at("rows")[0].at("strength").is_null(), "unavailable metric exposed its stale numeric value");
auto unknown_point = squad_bundle; unknown_point["lineup"]["data"]["positions"][0]["depth"] = -1;
require(engine_lineup_projection(unknown_point).at("board").at("points")[0].is_null(), "unknown pitch position was fabricated");
// Indoor keeps the complete eleven-player order and validates actual pair references.
{
auto hall = squad_bundle;
auto &hl = hall["lineup"]["data"], &hp = hall["squad"]["data"]["players"];
for (int i = 4; i < 11; ++i) {
auto person = hp[0]; person["player"]["id"] = "player:" + std::to_string(i); hp.push_back(person);
hl["order"].push_back(person["player"]["id"]);
hl["rows"].push_back({{"playerId",person["player"]["id"]},{"role","starter"}});
}
hl["positions"] = Json::array(); hl["pairs"] = Json::array();
hl["surface"] = "indoor"; hl["durationMinutes"] = 40; hl["starterCount"] = 11;
for (int i = 0; i < 11; ++i) {
hl["rows"][size_t(i)]["row"] = i;
hl["positions"].push_back({{"playerId","player:"+std::to_string(i)},{"depth",i},{"lane",i%9},{"partnerId",nullptr}});
}
for (int a = 1; a < 11; a += 2) {
const auto one="player:"+std::to_string(a), two="player:"+std::to_string(a+1);
hl["positions"][size_t(a)]["partnerId"]=two; hl["positions"][size_t(a+1)]["partnerId"]=one;
hl["pairs"].push_back({{"rows",{a,a+1}},{"playerIds",{one,two}}});
}
const auto hall_before=hall; const auto hv=engine_lineup_projection(hall);
require(hv.at("surface")=="indoor"&&hv.at("duration")==40&&hv.at("field_count")==11&&hv.at("rows").size()==11&&hv.at("pairs").size()==5,"indoor truncated the stored eleven");
require(hv.at("rows")[0].at("partner").is_null()&&hv.at("rows")[1].at("partner")=="player:2"&&hv.at("rows")[2].at("status")=="Ersatzbank"&&hall==hall_before,"indoor invented partner/roles or mutated read");
require(engine_lineup_command(hall,hl.at("order"),"request:hall").at("payload").at("order").size()==11,"indoor command truncated order");
auto outdoor=hall;outdoor["lineup"]["data"]["surface"]="outdoor";outdoor["lineup"]["data"]["durationMinutes"]=90;
require(engine_lineup_projection(outdoor).at("pairs").empty()&&engine_lineup_projection(outdoor).at("rows")[1].at("partner").is_null(),"stale outdoor partner bytes rendered as indoor pairs");
for(int fault=0;fault<11;++fault){auto bad=hall;auto &d=bad["lineup"]["data"];
if(fault==0)d["surface"]="sand";
if(fault==1)d["durationMinutes"]=90;
if(fault==2)d["starterCount"]=6;
if(fault==3)d["pairs"][0]["playerIds"][1]="player:foreign";
if(fault==4)d["pairs"].push_back(d["pairs"][0]);
if(fault==5)d["pairs"][0]["rows"][0]=0;
if(fault==6)d["positions"][1]["partnerId"]=nullptr;
if(fault==7)d["positions"][2]["partnerId"]="player:3";
if(fault==8)d["pairs"][0]["rows"][0]=11;
if(fault==9){d["rows"][1]["row"]=0;d["pairs"][0]["rows"][0]=0;}
if(fault==10)d["rows"][0]["row"]=INT64_MAX;
rejects([&]{engine_lineup_projection(bad);});
}
}
auto sports = squad_bundle;
for (auto &item : sports) { item["meta"]["scope"]["allowedCommands"].push_back("training.commit"); item["meta"]["scope"]["allowedCommands"].push_back("tactics.commit"); }
const auto sports_meta = sports.at("desktop").at("meta");
// Eleven real identifiers/positions are required by the existing tactical board.
auto &sl = sports["lineup"]["data"]; auto &sp = sports["squad"]["data"]["players"];
for (int i = 4; i < 11; ++i) { auto p = sp[0]; p["player"]["id"] = "player:" + std::to_string(i); sp.push_back(p); sl["order"].push_back(p["player"]["id"]); sl["rows"].push_back({{"playerId",p["player"]["id"]},{"role","starter"}}); }
sl["positions"] = Json::array();
for (int i = 0; i < 11; ++i) sl["positions"].push_back({{"playerId","player:"+std::to_string(i)},{"depth",i},{"lane",i%9}});
Json controls = Json::array(); const std::array<int,8> ranges{3,3,3,3,1,1,1,11};
for (int i = 0; i < 8; ++i) controls.push_back({{"id","tactic:"+std::to_string(i)},{"label",{{"text","Backend label "+std::to_string(i)}}},{"value",0},{"range",{{"min",0},{"max",ranges[size_t(i)]},{"step",1}}}});
sports["tactics"] = {{"messageType","snapshot"},{"meta",sports_meta},{"data",{{"kind","tactics"},{"teamId","club:6"},{"controls",controls}}}};
Json types = Json::array(), areas = Json::array(), training_players = Json::array();
for (const auto &name : {"goalkeepers","defence","midfield","attack"}) types.push_back({{"id",std::string("training:type/")+name},{"allocation",2},{"min",1},{"max",3}});
for (const auto &name : {"fitness","skill","corner","free_kick","tackling","pass","shot","speed","game"}) areas.push_back({{"id",std::string("training:area/")+name},{"allocation",2},{"min",1},{"max",3}});
for (const auto &p : sports.at("squad").at("data").at("players")) training_players.push_back({{"playerId",p["player"]["id"]},{"focus",0},{"intensity",2}});
sports["training"] = {{"messageType","snapshot"},{"meta",sports_meta},{"data",{{"kind","training"},{"teamId","club:6"},{"types",types},{"areas",areas},{"players",training_players},{"limits",{{"types",8},{"fitnessAndSkill",4},{"otherAreas",18}}},{"initialized",false},{"automation",0}}}};
const auto sports_original = sports;
auto tactics = engine_tactics_projection(sports);
require(tactics.at("labels")[3] == "Backend label 3" && tactics.at("values")[0] == 0, "tactics invented labels or discarded known zero");
tactics["values"][7] = 11;
require(engine_tactics_command(sports,tactics.at("values"),"request:t").at("payload").at("values")[7] == 11,"tactics payload wrong");
tactics["values"][7] = 12; rejects([&] { engine_tactics_command(sports,tactics.at("values"),"request:t"); });
auto training = engine_training_projection(sports);
require(training.at("roster").size() == 11 && training.at("roster")[0].at("attributes").at("strength") == 91,"training used catalogue values or a guessed roster");
training["types"][0] = 1; training["players"]["player:0"]["intensity"] = 3;
auto training_cmd = engine_training_command(sports,training,"request:p");
require(training_cmd.at("payload").at("players").size() == 1 && training_cmd.at("owner").at("managerId") == "manager:99" && sports == sports_original,"training query mutated source or payload lost identities");
training["types"] = Json::array({3,3,3,3}); rejects([&] { engine_training_command(sports,training,"request:p"); });
training = engine_training_projection(sports); training["players"]["player:0"]["focus"] = 1; rejects([&] { engine_training_command(sports,training,"request:p"); });
training = engine_training_projection(sports); training["players"]["foreign"] = {{"focus",0},{"intensity",2}}; rejects([&] { engine_training_command(sports,training,"request:p"); });
auto different = sports; different["training"]["meta"]["scope"]["managerId"] = "manager:1"; rejects([&] { engine_training_projection(different); });
auto bank = fixture();
const auto M = [](int64_t v) { return Json{{"currency","EUR"},{"minorUnits",2},{"minor",std::to_string(v)}}; };
bank["desktop"]["data"]["accounts"]["cash"] = M(1000000);
for (auto &[kind,row] : bank.items()) row["meta"]["scope"]["allowedCommands"] = {"bank.commit","ticket.commit"};
const auto bm = bank["desktop"]["meta"];
bank["bank"] = {{"messageType","snapshot"},{"meta",bm},{"data",{{"kind","bank"},{"teamId","club:6"},
{"accounts",{{"cash",M(1000000)},{"deposit",M(50000)},{"creditLine",M(9000)}}},
{"stocks",Json::array({{{"id","stock:8"},{"name",""},{"price",M(900)},{"previousPrice",M(1000)},{"history",{M(0),M(900),M(850)}},{"owned",2},{"maxToBuy",10}}})},
{"funds",Json::array({{{"id","fund:4"},{"name","Office"},{"price",M(400000)},{"owned",1},{"maxToBuy",2}}})}}}};
bank["stadium"] = {{"messageType","snapshot"},{"meta",bm},{"data",{{"kind","stadium"},{"teamId","club:6"},{"ticketPrice",M(2000)},{"ticketPriceRange",{{"min",M(800)},{"max",M(2500)}}}}}};
const auto bp = engine_bank_projection(bank);
require(bp.at("assets").at("properties")[0].at("image") == "bank.property.4" && bp.at("summary").at("stocks") == 1800, "asset identity or minor units lost");
require(bp.at("assets").at("stocks")[0].at("history") == Json::array({0,900,850}) && bp.at("assets").at("stocks")[0].at("name") == "Aktie · stock:8", "invented bank labels or history");
auto bc = engine_bank_command(bank,{{"action","deposit"},{"amount",M(1000)}},"request:bank");
require(bc.at("owner").at("managerId") == "manager:99" && bc.at("expectedRevision") == bm.at("stateRevision"), "bank scope lost");
rejects([&] { engine_bank_command(bank,{{"action","withdraw"},{"amount",M(50001)}},"r"); });
rejects([&] { engine_bank_command(bank,{{"action","deposit"},{"amount",M(1000100)}},"r"); });
rejects([&] { engine_bank_command(bank,{{"action","buy"},{"assetId","stock:0"},{"count",1}},"r"); });
rejects([&] { engine_bank_command(bank,{{"action","sell"},{"assetId","stock:8"},{"count",3}},"r"); });
require(engine_bank_command(bank,{{"action","sell"},{"assetId","stock:8"},{"count",2}},"r").at("payload").at("count") == 2, "sell count changed");
require(engine_ticket_command(bank,25,"r").at("payload").at("price") == M(2500), "ticket conversion wrong");
rejects([&] { engine_ticket_command(bank,7,"r"); });
auto formatted_bank = bank; formatted_bank["bank"]["data"]["stocks"][0]["name"] = "%%10 COMPANY";
require(engine_bank_projection(formatted_bank).at("assets").at("stocks")[0].at("name") == "Aktie · stock:8", "legacy formatting displayed as company name");
auto credit = Json{{"messageType","snapshot"},{"meta",bm},{"data",{{"kind","credit"},{"lenderId","bank"},{"fields",Json::array()},
{"saved",{0,0,0,0,0,0}},{"fees",M(100)},{"refund",M(0)},{"principalPaid",M(0)}}}};
for (int i=0;i<8;++i) credit["data"]["fields"].push_back({{"field",i},{"label","Field"},{"value",0},{"editable",i==0},{"min",i==0?Json(1000):Json()},{"max",i==0?Json(5000):Json()}});
const auto edits = Json::array({{{"field",0},{"value",2000}}});
require(engine_credit_command(bank,credit,edits,"r").at("payload").at("acceptFees") == true,"confirmed fee consent lost");
rejects([&] { engine_credit_command(bank,credit,Json::array(),"r"); });
auto active_credit=credit; active_credit["data"]["saved"][0]=2000;
rejects([&] { engine_credit_command(bank,active_credit,edits,"r"); });
auto foreign_credit=credit; foreign_credit["meta"]["scope"]["managerId"]="foreign";
rejects([&] { engine_credit_command(bank,foreign_credit,edits,"r"); });
auto broken_bank = bank; broken_bank["bank"]["meta"]["stateRevision"] = "1"; rejects([&] { engine_bank_projection(broken_bank); });
broken_bank = bank; broken_bank["bank"]["data"]["teamId"] = "foreign"; rejects([&] { engine_bank_projection(broken_bank); });
broken_bank = bank; broken_bank["stadium"]["data"]["ticketPrice"] = M(2001); rejects([&] { engine_ticket_projection(broken_bank); });
broken_bank = bank; broken_bank["desktop"]["meta"]["scope"]["allowedCommands"] = Json::array();
for (auto &[kind,row] : broken_bank.items()) row["meta"]["scope"]["allowedCommands"] = Json::array();
rejects([&] { engine_ticket_command(broken_bank,10,"r"); });
auto commerce = fixture();
for (auto &[kind,row] : commerce.items()) row["meta"]["scope"]["allowedCommands"] = {"environment.commit","advertising.accept","budget.commit"};
const auto cm = commerce.at("desktop").at("meta");
Json items = Json::array(), youth = Json::array();
const std::array<std::string,6> ek{"youth_youngest","youth_academy","youth_oldest","co_trainer","doctor","physio"};
for (int i=0;i<6;++i) {
items.push_back({{"id","environment:"+ek[i]},{"level",1},{"maxLevel",6},{"monthly",M(1000000+i)},{"stepCost",M(200000+i)}});
if(i<3) youth.push_back({{"id","youth:"+ek[i]},{"place",i},{"league",i},{"strength",80}});
}
commerce["environment"]={{"messageType","snapshot"},{"meta",cm},{"data",{{"kind","environment"},{"items",items},{"youth",youth},{"academyActive",true}}}};
auto ep = engine_environment_projection(commerce);
require(ep.at("rows")[1].at("cost")==1000001 && ep.at("rows")[2].at("rank")==3 && ep.at("rows")[2].at("league")==3,"environment replaced actual budgets or used zero-based display positions");
std::reverse(commerce["environment"]["data"]["items"].begin(),commerce["environment"]["data"]["items"].end());
require(engine_environment_projection(commerce)==ep,"environment IDs depend on transport order");
require(engine_environment_command(commerce,"environment:doctor",6,"r").at("payload").at("level")==6,"environment level wrong");
rejects([&]{engine_environment_command(commerce,"environment:unknown",1,"r");});
rejects([&]{engine_environment_command(commerce,"environment:doctor",7,"r");});
Json boards=Json::array();
auto contract=[&](const std::string &id) {return Json{{"id",id},{"active",false},{"sponsor",nullptr},{"monthly",M(0)},{"monthsRemaining",0},{"offers",Json::array()}};};
for(int i=0;i<14;++i)boards.push_back(contract("ad:board/"+std::to_string(i)));
boards[0]["offers"]={{{"id","offer:ad-0-7"},{"sponsor","Synthetic & Co"},{"monthly",M(123400)},{"months",18},{"boards",2},{"allowed",true}},{{"id","offer:ad-0-9"},{"sponsor","Unavailable"},{"monthly",M(120000)},{"months",12},{"boards",1},{"allowed",false}}};
auto shirt=contract("ad:shirt"),tv=contract("ad:tv");shirt["active"]=true;shirt["sponsor"]="Existing";shirt["monthly"]=M(200000);shirt["monthsRemaining"]=5;
shirt["offers"]={{{"id","offer:ad-14-4"},{"sponsor","Extension"},{"monthly",M(220000)},{"months",12},{"boards",1},{"allowed",true}}};
Json budgets=Json::array();for(const auto *id:{"budget:merchandise","budget:press","budget:fans"})budgets.push_back({{"id",id},{"current",M(1000)},{"maximum",M(50000)},{"available",true},{"deliveryWeeks",0}});
commerce["advertising"]={{"messageType","snapshot"},{"meta",cm},{"data",{{"kind","advertising"},{"teamId","club:6"},{"boards",boards},{"shirt",shirt},{"television",tv},{"budgets",budgets},{"preview",{{"income",M(11)},{"expenses",M(99)},{"balance",M(-88)}}}}}};
const auto unchanged_commerce=commerce,ap=engine_advertising_projection(commerce);
require(ap.at("balance")==-88 && ap.at("slots")[0].at("choices").size()==2,"advertising invented preview or offers");
require(engine_advertising_quote(commerce,0,0).at("boards")==2 && engine_advertising_quote(commerce,0,1).at("can_accept")==false,"bundle size or offer restriction lost");
require(engine_advertising_quote(commerce,14,0).at("active")==true && engine_advertising_quote(commerce,14,1).at("can_accept")==true,"existing contract hides valid extension");
require(engine_advertising_quote(commerce,15,0).at("can_accept")==false,"empty TV offer fabricated");
require(engine_advertising_command(commerce,"offer:ad-0-7","r").at("payload").at("offerId")=="offer:ad-0-7","sparse offer ID replaced by index");
rejects([&]{engine_advertising_command(commerce,"offer:ad-0-9","r");});
rejects([&]{engine_advertising_command(commerce,"offer:ad-0-0","r");});
require(engine_budget_command(commerce,"budget:press",500,"r").at("payload").at("amount")==M(50000),"budget money converted twice");
rejects([&]{engine_budget_command(commerce,"budget:press",501,"r");});
auto blocked=commerce;blocked["advertising"]["data"]["budgets"][0]["deliveryWeeks"]=2;
rejects([&]{engine_budget_command(blocked,"budget:merchandise",1,"r");});
blocked=commerce;blocked["advertising"]["meta"]["scope"]["managerId"]="foreign";
rejects([&]{engine_advertising_projection(blocked);});
blocked=commerce;blocked["environment"]["meta"]["stateRevision"]="1";
rejects([&]{engine_environment_projection(blocked);});
blocked=commerce;
for (auto &[kind,row] : blocked.items()) row["meta"]["scope"]["allowedCommands"]=Json::array();
require(engine_advertising_quote(blocked,0,0).at("can_accept")==false && engine_advertising_projection(blocked).at("spending")[0].at("available")==false,"missing capabilities remain interactively enabled");
rejects([&]{engine_environment_command(blocked,"environment:doctor",2,"r");});
rejects([&]{engine_budget_command(blocked,"budget:press",0,"r");});
require(commerce==unchanged_commerce,"commerce projections mutated source data");
auto contracts = sports;
for(auto &[kind,row]:contracts.items())row["meta"]["scope"]["allowedCommands"]={"quote.request","contract.offer","contract.cancel"};
const auto contract_squad=engine_lineup_projection(contracts);
Json cp=Json::array();for(const auto &row:contract_squad.at("rows"))cp.push_back({{"playerId",row.at("id")},{"name",row.at("name")},{"age",20},{"position","mid"},{"contractRemaining",{{"value",17},{"unit","months"}}},{"salaryMonthly",M(123400)},{"insuranceMonths",3},{"insuranceFee",M(50000)},{"offerBlocked",false},{"bonuses",{0,1,2,3,4,5,6}}});
contracts["contracts"]={{"messageType","snapshot"},{"meta",contracts.at("desktop").at("meta")},{"data",{{"kind","contracts"},{"teamId","club:6"},{"players",cp},{"quote",nullptr}}}};
const auto contract_before=contracts;const auto cv=engine_contracts_projection(contracts);
require(cv.at("salary_total")==int64_t(cp.size())*123400 && cv.at("rows")[0].at("months")==17 && cv.at("rows")[0].at("games").is_null(),"contract salaries/terms guessed or absent stats fabricated");
const auto pid=cp[0].at("playerId").get<std::string>();
require(engine_contract_request(contracts,pid,"r").at("payload").at("playerId")==pid,"contract request lost player identity");
rejects([&]{engine_contract_request(contracts,"foreign","r");});
auto cb=contracts;cb["contracts"]["data"]["players"][0]["offerBlocked"]=true;rejects([&]{engine_contract_request(cb,pid,"r");});
cb=contracts;cb["contracts"]["data"]["players"][1]["playerId"]=pid;rejects([&]{engine_contracts_projection(cb);});
Json cd=Json::array();const std::array<int64_t,4> demands{123400,0,429496729500LL,999900};
for(int i=0;i<4;++i)cd.push_back({{"years",i+1},{"monthlyDemand",M(demands[size_t(i)])}});
contracts["contracts"]["data"]["quote"]={{"id","quote:contract-9"},{"playerId",pid},{"maxMonthlySalary",M(20000000)},{"demands",cd}};
const auto quoted=engine_contracts_projection(contracts).at("quote");require(quoted.at("demands")[1].is_null()&&quoted.at("demands")[2].is_null(),"unavailable term shown as free salary");
require(engine_contract_offer(contracts,pid,"quote:contract-9",1,1234,"r").at("payload").at("monthlySalary")==M(123400),"salary conversion rounded or repeated");
rejects([&]{engine_contract_offer(contracts,pid,"quote:contract-9",2,1234,"r");});
rejects([&]{engine_contract_offer(contracts,pid,"quote:contract-9",1,200001,"r");});
rejects([&]{engine_contract_offer(contracts,"foreign","quote:contract-9",1,1234,"r");});
rejects([&]{engine_contract_request(contracts,pid,"r");});
require(engine_contract_cancel(contracts,"quote:contract-9","r").at("payload").at("quoteId")=="quote:contract-9","cancel lost exact quote binding");
rejects([&]{engine_contract_cancel(contracts,"quote:contract-8","r");});
cb=contracts;cb["contracts"]["meta"]["scope"]["managerId"]="foreign";rejects([&]{engine_contracts_projection(cb);});
cb=contract_before;for(auto &[kind,row]:cb.items())row["meta"]["scope"]["allowedCommands"]={"quote.request","contract.offer"};require(!engine_contracts_projection(cb).at("rows")[0].at("can_request").get<bool>(),"quote opened without cancellation capability");
auto cal=fixture();const Json season={{"startDate","2026-07-01"},{"endDate","2027-06-30"}};
for(auto &[kind,row]:cal.items()){row["meta"]["season"]=season;row["meta"]["date"]="2026-07-01";row["meta"]["scope"]["allowedCommands"]={"fixture.reschedule"};}
const auto meta_cal=cal.at("desktop").at("meta");
const Json home={{"id","club:6"},{"name","Actual home"}},away={{"id","club:7"},{"name","Actual away"}};
Json fx={{"id","fixture:real"},{"competition",{{"id","league:real"},{"kind","league"}}},{"round",3},{"scheduledDate","2026-08-05"},{"originalDate","2026-08-05"},{"home",home},{"away",away},{"status","scheduled"},{"result",nullptr}};
const Json event={{"date","2026-08-05"},{"seasonDay",35},{"eventKinds",{"league"}},{"fixtureIds",{"fixture:real"}}};
cal["calendar"]={{"messageType","snapshot"},{"meta",meta_cal},{"data",{{"kind","calendar"},{"from","2026-07-01"},{"until","2027-06-30"},{"days",{event}},{"fixtures",{fx}}}}};
const Json move={{"id","opaque:source-42"},{"date","2026-08-05"},{"round",3},{"home",home},{"away",away},{"targetDates",{"2026-07-21","2027-01-18"}}};
cal["scheduling"]={{"messageType","snapshot"},{"meta",meta_cal},{"data",{{"kind","scheduling"},{"movable",{move}},{"moved",Json::array()}}}};
const auto initial_cal=cal;auto calendar=engine_calendar_projection(cal);
require(calendar.at("count")==365&&calendar.at("today")==0&&calendar.at("fixtures")[0].at("day")==35,"calendar guessed an artificial fixture date");
auto schedule=engine_scheduling_projection(cal);require(schedule.at("movable")[0].at("targets")==Json::array({20,201}),"target date mapping wrong");
const auto move_cmd=engine_reschedule_command(cal,"opaque:source-42","2026-07-21","r");require(move_cmd.at("payload").at("matchId")=="opaque:source-42"&&move_cmd.at("expectedRevision")==meta_cal.at("stateRevision"),"move ID or revision reconstructed");
rejects([&]{engine_reschedule_command(cal,"opaque:source-42","2026-07-22","r");});
rejects([&]{engine_reschedule_command(cal,"invented","2026-07-21","r");});
rejects([&]{engine_reschedule_undo(cal,"2026-08-05","r");});
auto bad_cal=cal;bad_cal["calendar"]["data"]["days"][0]["fixtureIds"]={"ghost"};rejects([&]{engine_calendar_projection(bad_cal);});
bad_cal=cal;bad_cal["calendar"]["data"]["from"]="2026-08-01";rejects([&]{engine_calendar_projection(bad_cal);});
bad_cal=cal;bad_cal["calendar"]["data"]["fixtures"][0]["home"]["id"]="foreign";rejects([&]{engine_calendar_projection(bad_cal);});
bad_cal=cal;bad_cal["scheduling"]["meta"]["scope"]["managerId"]="foreign";rejects([&]{engine_scheduling_projection(bad_cal);});
bad_cal=cal;bad_cal["scheduling"]["data"]["movable"][0]["date"]="2026-08-06";rejects([&]{engine_scheduling_projection(bad_cal);});
bad_cal=cal;for(auto &[kind,row]:bad_cal.items())row["meta"]["scope"]["allowedCommands"]=Json::array();require(!engine_scheduling_projection(bad_cal).at("allowed").get<bool>(),"calendar enables missing permission");rejects([&]{engine_reschedule_command(bad_cal,"opaque:source-42","2026-07-21","r");});
auto moved_cal=cal;auto &moved_data=moved_cal["calendar"]["data"];moved_data["fixtures"][0]["scheduledDate"]="2026-07-21";moved_data["fixtures"][0]["status"]="rescheduled";moved_data["days"][0]["date"]="2026-07-21";moved_data["days"][0]["seasonDay"]=20;
moved_cal["scheduling"]["data"]["movable"]=Json::array();moved_cal["scheduling"]["data"]["moved"]={{{"date","2026-07-21"},{"round",3},{"home",home},{"away",away}}};
require(engine_reschedule_undo(moved_cal,"2026-07-21","r").at("payload").at("date")=="2026-07-21","undo used original or last-guessed date");
require(cal==initial_cal,"calendar projections mutated source");
auto leap=cal;for(auto &[kind,row]:leap.items()){row["meta"]["season"]={{"startDate","2027-07-01"},{"endDate","2028-06-30"}};row["meta"]["date"]="2028-02-29";}
leap["calendar"]["data"]["from"]="2027-07-01";leap["calendar"]["data"]["until"]="2028-06-30";leap["calendar"]["data"]["fixtures"]=Json::array();leap["calendar"]["data"]["days"]={{{"date","2028-02-29"},{"seasonDay",243},{"eventKinds",{"national"}},{"fixtureIds",Json::array()}}};
require(engine_calendar_projection(leap).at("count")==366&&engine_calendar_projection(leap).at("today")==243,"leap day lost in calendar geometry");
auto fp=cal;for(auto &[kind,r]:fp.items())r["meta"]["scope"]["allowedCommands"]={"friendly.book","fixture.reschedule"};
const auto fm=fp.at("desktop").at("meta");
fp["session"]["data"]["activeManagerId"]="manager:99";fp["session"]["data"]["humanOwnership"]={{{"controller","human"},{"teamId","club:6"},{"managerId","manager:99"}}};
fp["session"]["data"]["managers"]={{{"id","manager:99"},{"name","Own manager"},{"status","active"},{"control","human"}}};
Json ft={{"id","club:7"},{"name","Actual opponent"},{"nationId","nation:de"}};
fp["friendly-plan"]={{"messageType","snapshot"},{"meta",fm},{"data",{{"kind","friendly-plan"},{"teamId","club:6"},{"opponents",{{{"team",ft},{"competitionId","league:real"},{"strength",88}}}},{"bookings",Json::array()}}}};
auto fq=Json{{"messageType","snapshot"},{"meta",fm},{"data",{{"kind","friendly"},{"home",home},{"away",ft},{"cost",M(123400)},{"payerManagerId","manager:99"},{"opponentHuman",false},{"dates",{{{"date","2026-07-03"},{"withCalendarEvent",false}},{{"date","2026-07-21"},{"withCalendarEvent",true}}}}}}};
auto fv=engine_friendly_projection(fp,fq,"club:7",true);require(fv.at("days")==Json::array({2,20})&&fv.at("flagged_days")==Json::array({20}),"friendly date rules guessed or flagged date discarded");
require(engine_friendly_plan(fp).at("opponents")[0].at("rank").is_null(),"friendly picker invented standings");
require(engine_friendly_command(fp,fq,"club:7",true,"2026-07-03",true,false,"r").at("payload").at("acceptCost")==true,"cost approval missing");
rejects([&]{engine_friendly_command(fp,fq,"club:7",true,"2026-07-03",false,false,"r");});
rejects([&]{engine_friendly_command(fp,fq,"club:7",true,"2026-07-04",true,false,"r");});
rejects([&]{engine_friendly_projection(fp,fq,"club:7",false);});
auto foreign_quote=fq;foreign_quote["meta"]["scope"]["managerId"]="foreign";rejects([&]{engine_friendly_projection(fp,foreign_quote,"club:7",true);});
auto hp=fp;hp["session"]["data"]["humanOwnership"].push_back({{"controller","human"},{"teamId","club:7"},{"managerId","manager:2"}});hp["session"]["data"]["managers"].push_back({{"id","manager:2"},{"name","Other manager"},{"status","active"},{"control","human"}});
auto hq=fq;hq["data"]["home"]=ft;hq["data"]["away"]=home;hq["data"]["payerManagerId"]="manager:2";hq["data"]["opponentHuman"]=true;
require(engine_friendly_projection(hp,hq,"club:7",false).at("other_name")=="Other manager","human approver identity lost");
rejects([&]{engine_friendly_command(hp,hq,"club:7",false,"2026-07-03",true,false,"r");});
require(engine_friendly_command(hp,hq,"club:7",false,"2026-07-03",true,true,"r").at("payload").at("opponentConsent")==true,"explicit hotseat consent lost");
auto bad_payer=hq;bad_payer["data"]["payerManagerId"]="manager:99";rejects([&]{engine_friendly_projection(hp,bad_payer,"club:7",false);});
// National planning has no league/ranking or pre-rolled strengths. Both
// quote identity and the engine's explicit day whitelist remain mandatory.
auto np=fp;
for(auto &[kind,r]:np.items()) {r["meta"]["scope"]["role"]="national";r["meta"]["scope"]["teamId"]="nt:one";r["meta"]["scope"]["allowedCommands"]={"friendly.book"};}
const Json nown={{"id","nt:one"},{"kind","national"},{"name","One"},{"nationId","nation:one"}};
const Json nopp={{"id","nt:two"},{"kind","national"},{"name","Two"},{"nationId","nation:two"}};
np["desktop"]["data"]["team"]=nown;np["session"]["data"]["humanOwnership"][0]["teamId"]="nt:one";
np["calendar"]["data"]["fixtures"]=Json::array();
np["calendar"]["data"]["days"]={{{"date","2026-07-21"},{"seasonDay",20},{"eventKinds",{"national","league"}},{"fixtureIds",Json::array()}}};
np["friendly-plan"]["data"].update({{"national",true},{"teamId","nt:one"},{"opponents",{{{"team",nopp},{"competitionId",nullptr},{"strength",nullptr}}}}});
auto nq=fq;nq["meta"]=np["desktop"]["meta"];nq["data"].update({{"national",true},{"ratings",{73,81}},{"home",nown},{"away",nopp}});
const auto nv=engine_friendly_projection(np,nq,"nt:two",true),nc=engine_calendar_projection(np);
require(nv.at("national")==true && nv.at("ratings")==Json::array({73,81}) && nv.at("days")==Json::array({2,20}),"national quote/rating/date lost");
require(nc.at("league").is_null() && nc.at("events").at("20").at("kinds")==Json::array({"national"}),"national calendar leaked club events");
require(engine_friendly_command(np,nq,"nt:two",true,"2026-07-21",true,false,"r").at("owner").at("managerId")=="manager:99","national command lost owner");
rejects([&]{engine_friendly_command(np,nq,"nt:two",true,"2026-07-21",false,false,"r");});
rejects([&]{engine_friendly_command(np,nq,"nt:two",true,"2026-07-04",true,false,"r");});
auto bad_nation=np;bad_nation["friendly-plan"]["data"]["opponents"][0]["team"]["kind"]="club";rejects([&]{engine_friendly_plan(bad_nation);});
bad_nation=np;bad_nation["friendly-plan"]["data"]["opponents"][0]["strength"]=81;rejects([&]{engine_friendly_plan(bad_nation);});
auto bad_nq=nq;bad_nq["data"]["national"]=false;rejects([&]{engine_friendly_projection(np,bad_nq,"nt:two",true);});
bad_nq=nq;bad_nq["data"]["ratings"]={73};rejects([&]{engine_friendly_projection(np,bad_nq,"nt:two",true);});
bad_nq=nq;bad_nq["data"]["ratings"]={73,-1};rejects([&]{engine_friendly_projection(np,bad_nq,"nt:two",true);});
bad_nq=nq;bad_nq["meta"]["stateRevision"]="0";rejects([&]{engine_friendly_projection(np,bad_nq,"nt:two",true);});
// Archive DTOs retain historic names and unknown fields; only their bound
// owner/revision/query may supply a record to the existing presenter.
auto archive_bundle=cal;for(auto &[kind,r]:archive_bundle.items())r["meta"]["date"]="2027-01-02";
const Json archived_person={{"id","player:archived"},{"name","Historical Player"}};
const Json archived_record={{"id","match:2026-1"},{"date","2026-08-01"},{"season","2026/27"},{"round",1},
{"competition",{{"id","league:old"},{"name","Historical League"},{"type","league"}}},
{"home",{{"id","club:old-a"},{"name","Historical Home"},{"crest",nullptr},{"manager",{{"id","manager:old"},{"name","Historical Manager"}}}}},
{"away",{{"id","club:old-b"},{"name","Historical Away"},{"crest",nullptr},{"manager",nullptr}}},
{"result",{{"final",{2,1}},{"regulation",nullptr},{"extra",nullptr},{"penalties",nullptr},{"extra_played",false},{"penalties_played",false}}},
{"referee",nullptr},{"attendance",12000},{"weather",{{"temperature",19},{"rain",2}}},
{"lineups",{{"home",{{"starters",{archived_person}},{"bench",Json::array()}}},{"away",nullptr}}},
{"events",{{{"kind","goal"},{"minute",82},{"side","home"},{"player",archived_person},{"other",nullptr},{"detail",0}}}}};
const auto archived_read=[&](const Json &query,const Json &result){return Json{{"messageType","snapshot"},{"meta",archive_bundle.at("desktop").at("meta")},{"data",{{"kind","almanac"},{"query",query},{"result",result}}}};};
const Json archive_match_query={{"kind","match"},{"id","match:2026-1"}};
const Json archive_match_result={{"ok",true},{"match",archived_record}};
const auto archive_reply=archived_read(archive_match_query,archive_match_result);
const auto archive_value=engine_almanac_projection(archive_bundle,archive_reply,archive_match_query);
require(archive_value==archive_match_result && archive_value.at("match").at("result").at("regulation").is_null() && !archive_value.at("match").at("lineups").at("home").at("starters")[0].contains("position"),"archive presentation invented phase or current player data");
const Json archive_index_query={{"kind","index"}},archive_index={{"ok",true},{"years",{2026}},{"match_count",1},{"first_date","2026-08-01"},{"last_date","2026-08-01"}};
require(engine_almanac_projection(archive_bundle,archived_read(archive_index_query,archive_index),archive_index_query)==archive_index,"archive index lost");
const Json archive_calendar_query={{"kind","calendar"},{"year",2026}},archive_calendar={{"ok",true},{"year",2026},{"days",{{{"date","2026-08-01"},{"count",1},{"highlights",{"match:2026-1"}}}}}};
(void)engine_almanac_projection(archive_bundle,archived_read(archive_calendar_query,archive_calendar),archive_calendar_query);
const Json archive_day_query={{"kind","day"},{"date","2026-08-01"}},archive_day={{"ok",true},{"date","2026-08-01"},{"matches",{archived_record}}};
(void)engine_almanac_projection(archive_bundle,archived_read(archive_day_query,archive_day),archive_day_query);
auto bad_archive=archive_reply;bad_archive["meta"]["careerId"]="other";rejects([&]{engine_almanac_projection(archive_bundle,bad_archive,archive_match_query);});
bad_archive=archive_reply;bad_archive["meta"]["stateRevision"]="42";rejects([&]{engine_almanac_projection(archive_bundle,bad_archive,archive_match_query);});
bad_archive=archive_reply;bad_archive["data"]["query"]["id"]="match:other";rejects([&]{engine_almanac_projection(archive_bundle,bad_archive,archive_match_query);});
bad_archive=archive_reply;bad_archive["data"]["result"]["match"]["id"]="match:other";rejects([&]{engine_almanac_projection(archive_bundle,bad_archive,archive_match_query);});
bad_archive=archive_reply;bad_archive["data"]["result"]["match"]["date"]="2028-08-01";rejects([&]{engine_almanac_projection(archive_bundle,bad_archive,archive_match_query);});
auto bad_archive_day=archive_day;bad_archive_day["matches"].push_back(archived_record);rejects([&]{engine_almanac_projection(archive_bundle,archived_read(archive_day_query,bad_archive_day),archive_day_query);});
bad_archive_day=archive_day;bad_archive_day["matches"][0]["date"]="2026-08-02";rejects([&]{engine_almanac_projection(archive_bundle,archived_read(archive_day_query,bad_archive_day),archive_day_query);});
auto bad_archive_calendar=archive_calendar;bad_archive_calendar["year"]=2025;rejects([&]{engine_almanac_projection(archive_bundle,archived_read(archive_calendar_query,bad_archive_calendar),archive_calendar_query);});
rejects([&]{engine_almanac_key({{"kind","calendar"},{"year",2026.5}});});
rejects([&]{engine_almanac_key({{"kind","day"},{"date","2026-02-30"}});});
rejects([&]{engine_almanac_key({{"kind","match"},{"id",""}});});
auto report_bundle=fixture();
const auto report_wrap=[&](const char*,const Json &data){return Json{{"messageType","snapshot"},{"meta",report_bundle.at("desktop").at("meta")},{"data",data}};};
const Json report_index_data={{"kind","report-index"},{"leagues",{{{"id","league:live"},{"name","Live League"},{"nationId","nation:test"},{"members",{"club:6","club:7"}},{"clubCount",2},{"matchdays",2},{"played",1},{"own",true}}}}};
const auto report_index_read=report_wrap("report-index",report_index_data);
Json report_rows=Json::array(),strength_rows=Json::array();
for(int n=0;n<2;++n){const auto id=n?"club:7":"club:6";Json team={{"id",id},{"name",n?"Live B":"Live A"}};
report_rows.push_back({{"team",team},{"original",n},{"rank",n+1},{"played",1},{"wins",n?0:1},{"draw",0},{"loss",n?1:0},{"gf",n?0:2},{"ga",n?2:0},{"diff",n?-2:2},{"points",n?0:3},{"form",n?0:3},{"form_text",n?"N":"S"}});
strength_rows.push_back({{"team",team},{"original",n},{"basis","squad"},{"keeper",nullptr},{"defence",71},{"midfield",72},{"attack",73},{"strength",72}});
}
const Json report_data={{"kind","league-report"},{"leagueId","league:live"},{"filter",0},{"table",report_rows},{"strengths",strength_rows},{"zones",nullptr}};
const auto report_read=report_wrap("league-report",report_data);const auto report_value=engine_report_projection(report_bundle,report_index_read,report_read,"league:live",0);
require(report_value.at("table")[0].at("name")=="Live A"&&report_value.at("strengths")[0].at("keeper").is_null(),"live report name/unknown position was fabricated");
auto bad_report=report_read;bad_report["meta"]["careerId"]="other";rejects([&]{engine_report_projection(report_bundle,report_index_read,bad_report,"league:live",0);});
bad_report=report_read;bad_report["data"]["table"][0]["team"]["id"]="club:other";rejects([&]{engine_report_projection(report_bundle,report_index_read,bad_report,"league:live",0);});
bad_report=report_read;bad_report["data"]["table"][1]["rank"]=1;rejects([&]{engine_report_projection(report_bundle,report_index_read,bad_report,"league:live",0);});
bad_report=report_read;bad_report["data"]["filter"]=3;rejects([&]{engine_report_projection(report_bundle,report_index_read,bad_report,"league:live",0);});
auto bad_index=report_index_read;bad_index["data"]["leagues"][0]["members"][1]="club:6";rejects([&]{engine_report_index(report_bundle,bad_index);});
const Json fixture_read_data={{"kind","league-fixtures"},{"leagueId","league:live"},{"league",{{"id","league:live"},{"name","Live League"}}},{"round",1},{"rounds",2},{"matches",{{{"id","fixture:one"},{"home",{{"id","club:6"},{"name","Live A"}}},{"away",{{"id","club:7"},{"name","Live B"}}},{"status","open"},{"result",nullptr}}}}};
const auto fixture_read=report_wrap("league-fixtures",fixture_read_data);const auto fixture_value=engine_fixtures_projection(report_bundle,report_index_read,fixture_read,"league:live",1);
require(fixture_value.at("matches")[0].at("home_goals").is_null()&&fixture_value.at("matches")[0].at("home")=="club:6","fixture adapter invented an open result");
auto bad_fixture=fixture_read;bad_fixture["data"]["matches"][0]["result"]={12,14};rejects([&]{engine_fixtures_projection(report_bundle,report_index_read,bad_fixture,"league:live",1);});
bad_fixture=fixture_read;bad_fixture["data"]["round"]=2;rejects([&]{engine_fixtures_projection(report_bundle,report_index_read,bad_fixture,"league:live",1);});
bad_fixture=fixture_read;bad_fixture["data"]["matches"][0]["away"]["id"]="club:6";rejects([&]{engine_fixtures_projection(report_bundle,report_index_read,bad_fixture,"league:live",1);});
bad_fixture=fixture_read;bad_fixture["meta"]["stateRevision"]="42";rejects([&]{engine_fixtures_projection(report_bundle,report_index_read,bad_fixture,"league:live",1);});
const auto other_index=report_wrap("other-index",{{"kind","other-index"},{"views",{{{"id","cup-view:0:0"},{"name","Synthetic Cup"},{"entry",0},{"rounds",2},{"currentRound",1},{"knockout",true},{"twoLegs",false}}}},{"defaultViewId","cup-view:0:0"}});
auto other_data=fixture_read_data;other_data["kind"]="other-fixtures";other_data["viewId"]="cup-view:0:0";other_data["entry"]=0;other_data["available"]=true;other_data["heading"]="Round 1";
auto &om=other_data["matches"][0];om["homeHasSquad"]=true;om["awayHasSquad"]=false;om["secondLegVisible"]=false;om["secondLeg"]=nullptr;om["phase"]=nullptr;om["secondLegPhase"]=nullptr;om["date"]=nullptr;
const auto other_read=report_wrap("other-fixtures",other_data);require(engine_other_projection(report_bundle,other_index,other_read,"cup-view:0:0",1).at("matches")[0].at("home_goals").is_null(),"open cup got a score");
auto bad_other=other_read;bad_other["data"]["available"]=false;rejects([&]{engine_other_projection(report_bundle,other_index,bad_other,"cup-view:0:0",1);});
bad_other=other_read;bad_other["data"]["matches"][0]["result"]={1,2};rejects([&]{engine_other_projection(report_bundle,other_index,bad_other,"cup-view:0:0",1);});
bad_other=other_read;bad_other["data"]["entry"]=1;rejects([&]{engine_other_projection(report_bundle,other_index,bad_other,"cup-view:0:0",1);});
bad_other=other_read;bad_other["meta"]["stateRevision"]="42";rejects([&]{engine_other_projection(report_bundle,other_index,bad_other,"cup-view:0:0",1);});
auto rankings_bundle=report_bundle;for(auto &r:rankings_bundle)r["meta"]["season"]={{"label","2026/27"}};
const auto rw=[&](const Json &d){return Json{{"messageType","snapshot"},{"meta",rankings_bundle.at("desktop").at("meta")},{"data",d}};};const auto ri=rw(report_index_data);
Json ranking_row={{"rank",1},{"player",{{"id","player:score"},{"name","Synthetic Scorer"}}},{"club",{{"id","club:6"},{"name","Live A"}}},{"goals",2},{"assists",1},{"yellow",0},{"red",0},{"second_yellow",0},{"appearances",3},{"value",2},{"photoAssetId",nullptr},{"currentTeam",{{"id","club:7"},{"name","Live B"}}}};
Json rc=Json::array({Json::array({ranking_row}),Json::array(),Json::array(),Json::array()});const auto rr=rw({{"kind","player-rankings"},{"requestLeagueId","league:live"},{"leagueId","league:live"},{"scope",0},{"season","2026/27"},{"team",{{"id","club:6"},{"name","Live A"}}},{"categories",rc}});
require(engine_rankings_projection(rankings_bundle,ri,rr,"league:live",0).at("categories")[0][0].at("player")=="player:score","ranked player identity lost");
auto archived_rank=rr;archived_rank["data"]["categories"][0][0]["currentTeam"]=nullptr;require(engine_rankings_projection(rankings_bundle,ri,archived_rank,"league:live",0).at("categories")[0][0].at("currentTeam").is_null(),"archived-only identity received a fake current team");
auto bad_rank=rr;bad_rank["data"]["categories"][0][0]["rank"]=2;rejects([&]{engine_rankings_projection(rankings_bundle,ri,bad_rank,"league:live",0);});
bad_rank=rr;bad_rank["data"]["categories"][0][0]["value"]=5;rejects([&]{engine_rankings_projection(rankings_bundle,ri,bad_rank,"league:live",0);});
bad_rank=rr;bad_rank["data"]["season"]="2025/26";rejects([&]{engine_rankings_projection(rankings_bundle,ri,bad_rank,"league:live",0);});
bad_rank=rr;bad_rank["meta"]["stateRevision"]="42";rejects([&]{engine_rankings_projection(rankings_bundle,ri,bad_rank,"league:live",0);});
const auto fr=rw({{"kind","fairplay"},{"leagueId","league:live"},{"season","2026/27"},{"weights",{{"yellow",1},{"red",4}}},{"recordedMatches",1},{"rows",{{{"rank",1},{"team",{{"id","club:6"},{"name","Live A"}}},{"yellow",1},{"red",0},{"points",1}},{{"rank",2},{"team",{{"id","club:7"},{"name","Live B"}}},{"yellow",0},{"red",1},{"points",4}}}}});
require(engine_fairplay_projection(rankings_bundle,ri,fr).at("rows").size()==2,"fairplay rows lost");auto bad_fair=fr;bad_fair["data"]["rows"][1]["points"]=1;rejects([&]{engine_fairplay_projection(rankings_bundle,ri,bad_fair);});
auto opening_bundle=fixture();opening_bundle["desktop"]["meta"]["date"]="2026-07-01";opening_bundle["session"]["data"]["managers"]={{{"teamId","club:6"}}};
const auto ow=[&](const Json &d){return Json{{"messageType","snapshot"},{"meta",opening_bundle.at("desktop").at("meta")},{"data",d}};};
Json opening_data={{"kind","opening"},{"enabled",true},{"showEntrants",true}};
opening_data["entrants"]={{"uefa",Json::array({Json{{"id","club:7"},{"name","Live B"}}})},{"champions",Json::array()},{"winners",Json::array()}};
opening_data["order"]=Json::array({Json{{"id","club:6"},{"name","Live A"}},Json{{"id","club:7"},{"name","Live B"}}});
opening_data["fixtureIds"]={"fixture:cup-0-1-0"};const auto oi=ow(opening_data);
require(engine_opening_projection(opening_bundle,oi).at("opening_flow").at("order")[0]=="club:6","opening ignored authoritative pair order");auto bad_opening=oi;bad_opening["data"]["order"][1]["id"]="club:6";rejects([&]{engine_opening_projection(opening_bundle,bad_opening);});bad_opening=oi;bad_opening["meta"]["stateRevision"]="42";rejects([&]{engine_opening_projection(opening_bundle,bad_opening);});
std::cout << "engine DTO, exact money, scope and booking tests passed\n";
return 0;
} catch (const std::exception &e) { std::cerr << e.what() << '\n'; return 1; }
}