Add sortable editor ratings and payroll comparisons (by Codex)
This commit is contained in:
1 parent
a447d9282a
commit
221478b629
26 files changed
+1311
-43
No files matched your search
@@ -0,0 +1,258 @@
|
||||
// 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;
|
||||
}
|
||||
}
|
||||
Reference in new issue
Block a user