Files
Dreierpack-Manager/tests/editor_comparison_tests.cpp
Codex 221478b629
OBW Editor / editor (linux-x64, ubuntu-24.04) (push) Waiting to run
OBW Editor / editor (macos-arm64, macos-14) (push) Waiting to run
OBW Editor / editor (windows-x64, windows-2022) (push) Waiting to run
Add sortable editor ratings and payroll comparisons (by Codex)
2026-10-23 05:26:10 +02:00

259 lines
14 KiB
C++

// SPDX-License-Identifier: GPL-3.0-only
#include "editor/comparison.hpp"
#include "editor/mcp.hpp"
#include "editor/session.hpp"
#include <cmath>
#include <iostream>
#include <limits>
using namespace bmh::editor;
namespace {
int checks = 0;
void check(bool value, const char *message) {
++checks;
if (!value)
throw std::runtime_error(message);
}
template <class Fn> void rejects(const char *code, Fn fn) {
try {
fn();
} catch (const Error &error) {
check(error.code == code, "unexpected rejection");
return;
}
throw std::runtime_error(std::string("accepted: ") + code);
}
Json find(const Json &items, const std::string &id) {
for (const auto &row : items)
if (str(row, "id") == id)
return row;
throw std::runtime_error("missing fixture row " + id);
}
World fixture() {
auto world = World::blank("Synthetic comparison");
world.rows("nations").push_back({{"id", "nation:de"}, {"name", "Testland"}});
world.rows("competitions") = Json::array({{{"id", "comp:first"},
{"name", {{"de", "Testliga"}, {"en", "Test league"}}},
{"nation", "nation:de"},
{"type", "league"},
{"members", {"club:north", "club:south"}}},
{{"id", "comp:empty"},
{"name", "Empty league"},
{"nation", "nation:de"},
{"type", "league"},
{"members", {"club:empty"}}},
{{"id", "comp:cup"},
{"name", "Not a league"},
{"nation", "nation:de"},
{"type", "cup"},
{"members", {"club:north"}}}});
for (const std::string id : {"north", "south", "empty"})
world.rows("clubs").push_back(
{{"id", "club:" + id}, {"name", id}, {"type", "club"}, {"nation", "nation:de"}});
// No club.competition: membership-only imported worlds must work too.
world.rows("rules").push_back(
{{"id", "rule:bmh-classic@1"},
{"type", "attribute_set"},
{"fields", {{"strength", {{"min", 0}, {"max", 99}}}, {"form", {{"min", 0}, {"max", 127}}}}}});
const Json ratings{90, 70, 50, nullptr, 90, 99};
const std::vector<std::string> ids{"a", "b", "c", "d", "free", "duplicate"};
for (size_t i = 0; i < ids.size(); ++i) {
const auto team = i < 2 || i == 5 ? Json("club:north") : i < 4 ? Json("club:south") : Json();
world.rows("players").push_back(
{{"id", "player:" + ids[i]},
{"name", ids[i]},
{"team", team},
{"born", "2000-01-01"},
{"positions", {"mid"}},
{"attribute_set", "bmh-classic@1"},
{"attributes", {{"strength", ratings[i]}, {"form", i ? Json(100) : Json()}}}});
}
world.rows("players")[1]["x-simulation"]["squad_role"] = "source-reserve";
world.rows("players")[5]["x-simulation"]["squad_role"] = "source-only-duplicate";
auto contract = [&](std::string id, std::string person, std::string team, int64_t salary,
std::string start = "2026-07-01", std::string end = "2027-06-30") {
world.rows("contracts")
.push_back({{"id", "contract:" + id},
{"name", id},
{"person", "player:" + person},
{"team", "club:" + team},
{"salary", salary},
{"start", start},
{"end", end}});
};
contract("a", "a", "north", 9000);
contract("b", "b", "north", 10000);
contract("c", "c", "south", 50000);
contract("c-conflict", "c", "south", 60000);
contract("d", "d", "south", 0); // Explicit zero is known, not missing.
contract("duplicate", "duplicate", "north", 99999999);
contract("a-expired", "a", "north", 1000000, "2025-07-01", "2026-06-30");
contract("a-future", "a", "north", 2000000, "2026-07-02", "2027-06-30");
contract("a-old-team", "a", "south", 3000000);
world.rows("staff").push_back({{"id", "staff:test"}, {"name", "Staff"}});
world.rows("contracts")
.push_back({{"id", "contract:staff"},
{"name", "Staff contract"},
{"person", "staff:test"},
{"team", "club:north"},
{"salary", 9999999}});
return world;
}
Json compare(const World &world, Json args = Json::object()) {
return query_comparison(comparison_data(world, args), args);
}
} // namespace
int main() {
const auto root = fs::temp_directory_path() / new_id("comparison-tests-");
fs::create_directory(root);
struct Cleanup {
fs::path root;
~Cleanup() {
std::error_code ec;
fs::remove_all(root, ec);
}
} cleanup{root};
try {
auto world = fixture();
const auto original_players = world.rows("players"), original_contracts = world.rows("contracts");
auto players = compare(world, {{"sort", "salary"}, {"descending", true}});
check(players["total"] == 5 && players["excluded_players"] == 1,
"all real rows, reserve included, source duplicate excluded");
check(players["items"][0]["id"] == "player:b" && players["items"][1]["salary"] == 9000,
"numeric salary sort and active current-team contracts");
check(players["items"][2]["salary"] == 0 && players["items"][3]["salary"].is_null(),
"zero before missing salary descending");
check(find(players["items"], "player:c")["salary_ambiguous"] == 1,
"conflicting active contracts stay unknown");
check(players["currency"]["minor_units"] == 2, "integer currency units retained");
players = compare(world, {{"sort", "salary"}});
check(players["items"][0]["id"] == "player:d" && players["items"][4]["salary"].is_null(),
"missing salary last ascending too");
auto rating = compare(
world, {{"sort", "attributes.strength"}, {"descending", true}, {"offset", 1}, {"limit", 1}});
check(rating["items"][0]["id"] == "player:free" && rating["total"] == 5,
"stable tie by ID and full-result sort before paging");
check(compare(world, {{"team", "club:north"}})["total"] == 2,
"team filter excludes source duplicate");
check(compare(world, {{"nation", "nation:de"}, {"competition", "comp:first"}})["total"] == 4,
"league and nation follow membership fallback");
auto teams =
compare(world, {{"table", "clubs"}, {"sort", "attributes.strength"}, {"descending", true}});
auto north = find(teams["items"], "club:north"), south = find(teams["items"], "club:south");
check(north["attributes"]["strength"] == 80 && north["salary_total"] == 19000,
"club means and player-only payroll");
check(north["salary_average"] == 9500 && north["salary_complete"] == true,
"mean wage and coverage complete");
check(south["attributes"]["strength"] == 50 && south["attribute_counts"]["strength"] == 1,
"unknown attributes excluded from mean denominator");
check(south["salary_total"] == 0 && south["salary_known"] == 1 && south["salary_unknown"] == 1 &&
south["salary_complete"] == false,
"partial payroll distinguished from complete zero");
check(find(teams["items"], "club:empty")["salary_total"].is_null(),
"empty team is not a zero-payroll team");
auto leagues = compare(world, {{"table", "leagues"}, {"language", "en"}});
auto league = find(leagues["items"], "comp:first");
check(leagues["total"] == 2 && league["club_count"] == 2 && league["player_count"] == 4,
"cups excluded; exact unique league population");
check(league["attributes"]["strength"] == 70,
"league strength is player-weighted, not a mean of club means");
check(league["salary_total"] == 19000 && league["salary_average"] == 6333 &&
league["salary_known"] == 3,
"league payroll uses known contracts once and integer rounded mean");
check(league["name"] == "Test league", "localized names");
check(world.rows("players") == original_players && world.rows("contracts") == original_contracts,
"comparison never changes source records");
auto classic = world;
classic.rows("contracts") = Json::array();
classic.manifest["currency"] = {{"code", "GBP"}, {"minor_units", 0}};
check(compare(classic)["items"][0]["salary"].is_null() &&
compare(classic)["currency"]["code"] == "GBP",
"Classic without contracts remains unknown in its actual currency");
world.rows("rules").push_back(
{{"id", "rule:fc@1"},
{"type", "attribute_set"},
{"attribute_set", "fc@1"},
{"fields", {{"overall", {{"min", 0}, {"max", 99}}}, {"strength", {{"min", 0}, {"max", 99}}}}}});
auto &modern = world.rows("players")[1];
modern["attribute_set"] = "fc@1";
modern["attributes"] = {{"overall", 85}, {"strength", 35}};
check(compare(world)["mixed_attribute_sets"] == true && compare(world)["attributes"].empty(),
"different strength systems are never implicitly combined");
rejects("invalid_comparison_sort", [&] { compare(world, {{"sort", "attributes.strength"}}); });
auto fc = compare(world, {{"table", "clubs"}, {"attribute_set", "fc@1"}});
check(find(fc["items"], "club:north")["attributes"]["overall"] == 85 &&
find(fc["items"], "club:north")["player_count"] == 1,
"attribute system filter also defines aggregation population");
rejects("invalid_attribute_set", [&] { compare(world, {{"attribute_set", "unknown@1"}}); });
rejects("unknown_table", [&] { compare(world, {{"table", "staff"}}); });
auto many = fixture();
many.rows("players") = Json::array();
many.rows("contracts") = Json::array();
for (int i = 0; i < 231; ++i)
many.rows("players").push_back({{"id", "player:" + std::to_string(i)},
{"name", std::to_string(i)},
{"attribute_set", "synthetic@1"},
{"attributes", {{"rating", i}}}});
const auto second_page =
compare(many, {{"sort", "attributes.rating"}, {"descending", true}, {"offset", 200}});
check(second_page["total"] == 231 && second_page["items"].size() == 31 &&
second_page["items"][0]["attributes"]["rating"] == 30,
"sorting spans all pages, no 200-row truncation");
auto overflow = fixture();
overflow.rows("contracts")[0]["salary"] = std::numeric_limits<int64_t>::max();
const auto extreme = find(compare(overflow, {{"table", "clubs"}})["items"], "club:north");
check(extreme["salary_overflow"] == true && extreme["salary_total"].is_null(),
"payroll overflow never wraps into a plausible negative value");
auto invalid = fixture();
invalid.rows("contracts")[0]["start"] = 20260701;
check(find(compare(invalid)["items"], "player:a")["salary"].is_null(),
"malformed contract dates are not silently treated as open bounds");
invalid.rows("contracts")[1]["salary"] = -1;
check(find(compare(invalid)["items"], "player:b")["salary"].is_null(),
"invalid salary is unknown, not a negative payroll credit");
invalid.manifest["start_date"] = nullptr;
check(find(compare(invalid)["items"], "player:d")["salary"].is_null(),
"unknown world date does not substitute the wall clock");
invalid.manifest["x-simulation"] = nullptr;
check(compare(invalid)["fictional_completion"] == false,
"unrecognized optional extension metadata does not break comparisons");
auto saved = fixture();
saved.save(root / "fixture.obw");
Session session;
session.execute("open", {{"path", utf8(root / "fixture.obw")}});
const auto info = session.execute("info");
const auto projection = session.execute("compare", {{"table", "clubs"}});
check(info == session.execute("info") && info["dirty"] == false,
"session comparison is read-only including revision and undo state");
session.execute("apply", {{"changes", Json::array({{{"table", "players"},
{"id", "player:a"},
{"set", {{"/attributes/strength", 80}}}}})}});
check(find(session.execute("compare", {{"table", "clubs"}})["items"],
"club:north")["attributes"]["strength"] == 75,
"cached comparison refreshes after an edit");
session.execute("undo");
check(session.execute("compare", {{"table", "clubs"}})["items"] == projection["items"],
"cached comparison refreshes after undo");
McpServer server(session);
const auto reply =
server.dispatch({{"jsonrpc", "2.0"},
{"id", 1},
{"method", "tools/call"},
{"params",
{{"name", "editor_compare"},
{"arguments", {{"table", "leagues"}, {"sort", "salary_total"}}}}}});
check(!reply["result"].value("isError", false) && reply["result"]["structuredContent"]["total"] == 2,
"MCP uses the same comparison projection");
bool read_only = false;
for (const auto &tool : McpServer::tools())
if (tool["name"] == "editor_compare")
read_only = tool["annotations"]["readOnlyHint"] == true;
check(read_only, "MCP comparison advertises read-only semantics");
std::cout << checks << " editor comparison checks passed\n";
return 0;
} catch (const std::exception &error) {
std::cerr << error.what() << '\n';
return 1;
}
}