catcrafts.net/tests/ShouldComputeMoney/main.cpp

/*
catcrafts.net
Copyright (C) 2026 Catcrafts

The source code of this website is made available for viewing purposes only.
No permission is granted to copy, modify, distribute, or create derivative works.
*/

// The money layer: formatting, the VAT arithmetic, zones and the sale policy,
// the carrier weight brackets, order totals, indicative currency conversion
// and the ECB rates loader. Every price the site shows or charges goes
// through these functions.

import std;
import Catcrafts.Shared;

using namespace Catcrafts;

namespace {

int failures = 0;

void Check(bool ok, std::string_view what, std::string_view got = {}) {
    if (ok) return;
    ++failures;
    std::println(std::cerr, "FAIL: {}{}{}", what,
                 got.empty() ? "" : "  got: ", got);
}

} // namespace

int main() {
    using namespace Catcrafts::Money;

    // ── formatting ────────────────────────────────────────────────────
    Check(FormatMinor(58000) == "580.00", "money: wire format");
    Check(FormatMinor(47934) == "479.34", "money: wire format with cents");
    Check(FormatMinor(5) == "0.05", "money: sub-unit");
    Check(FormatMinor(0) == "0.00", "money: zero");
    Check(FormatEuro(58000) == "€580", "money: whole euros displayed bare");
    Check(FormatEuro(47934) == "€479.34", "money: cents displayed when present");

    // ── VAT arithmetic ────────────────────────────────────────────────
    // €580.00 gross at 21%: net = 58000/1.21 = 47933.88... -> 47934 half-up.
    Check(NetFromGross(58000) == 47934, "vat: net from €580 gross");
    // The derived pair must reconstruct plausibly: net + vat == gross.
    Check(58000 - NetFromGross(58000) == 10066, "vat: vat portion exact");
    Check(NetFromGross(0) == 0, "vat: zero");
    Check(NetFromGross(121) == 100, "vat: €1.21 -> €1.00 exactly");
    // The gross-up direction, used to charge carrier costs without eating
    // the VAT slice: €7.13 cost -> €8.63 charged, and the pair round-trips.
    Check(GrossFromNet(713) == 863, "vat: gross from €7.13 net");
    Check(NetFromGross(GrossFromNet(713)) == 713, "vat: gross-up round-trips");
    Check(GrossFromNet(100) == 121, "vat: €1.00 -> €1.21 exactly");
    Check(GrossFromNet(0) == 0, "vat: gross-up zero");
    // The half-up term (+5000) caught at sub-cent scale, once each way:
    // 3 × 1.21 = 3.63 must land on 4, 2 × 1.21 = 2.42 must land on 2. Plain
    // truncation would give 3 for the first, so this is what pins the term.
    Check(GrossFromNet(3) == 4, "vat: gross-up rounds .63 up");
    Check(GrossFromNet(2) == 2, "vat: gross-up rounds .42 down");
    // The round-trip is the property that makes "cost plus, eat nothing" true,
    // and it is applied to every EU carrier bracket — so it sets the shipping
    // cents on every EU order. If either rounding constant drifted, the shop
    // would remit VAT on a grossed-up rate that no longer nets back to the
    // carrier's own cost, losing or pocketing a cent on every parcel. A single
    // case cannot catch that; sweep the range a shipping rate lives in.
    //
    // Why it must hold for every n: GrossFromNet(n) is 1.21n rounded half up,
    // so it sits within 0.5 of 1.21n. Dividing back by 1.21 therefore lands
    // within 0.5/1.21 ≈ 0.413 of n — never far enough to reach the next
    // half-up boundary, so NetFromGross returns n exactly.
    {
        std::string broke;
        for (std::int64_t n = 0; n <= 2000; ++n) {
            if (NetFromGross(GrossFromNet(n)) != n && broke.empty()) {
                broke = std::format("net {} -> gross {} -> net {}", n,
                                    GrossFromNet(n), NetFromGross(GrossFromNet(n)));
            }
        }
        Check(broke.empty(),
              "vat: gross-up round-trips for every net from €0.00 to €20.00", broke);
    }

    // ── zones and membership ──────────────────────────────────────────
    Check(IsEuCountry("NL") && IsEuCountry("DE") && IsEuCountry("FR"), "eu: members");
    // The whole roster, restated here rather than borrowed from EuCountries()
    // — a list that checks itself proves nothing. IsEuCountry is the single
    // switch in ComputeTotals between charging the VAT-inclusive price and
    // charging a zero-rated export net, so a member quietly lost to a rebase,
    // or typed as EL instead of GR, bills that country's buyers ~17% under the
    // order's worth while the shop still owes NL OSS VAT on the sale. Money
    // out the door, per order, with nothing else in the repo watching.
    constexpr std::array<std::string_view, 27> members{
        "AT", "BE", "BG", "HR", "CY", "CZ", "DE", "DK", "EE", "ES", "FI",
        "FR", "GR", "HU", "IE", "IT", "LT", "LU", "LV", "MT", "NL", "PL",
        "PT", "RO", "SE", "SI", "SK",
    };
    Check(EuCountries().size() == 27, "eu: 27 member states, no more and no fewer");
    for (const std::string_view cc : members) {
        Check(IsEuCountry(cc), "eu: member state recognised", cc);
    }
    Check(!IsEuCountry("GB"), "eu: UK left");
    Check(!IsEuCountry("CH") && !IsEuCountry("NO"), "eu: EFTA is not EU");
    // Three of the easiest false positives: IS shares the single market
    // through the EEA, UA and TR are candidates (TR is even in the customs
    // union). None of that is membership, and none of it makes a sale
    // domestic for VAT.
    Check(!IsEuCountry("IS"), "eu: EEA membership is not EU membership");
    Check(!IsEuCountry("UA") && !IsEuCountry("TR"), "eu: candidates are not members");
    Check(!IsEuCountry("CA") && !IsEuCountry("US"), "eu: north america");
    Check(!IsEuCountry("nl"), "eu: lowercase is not a member (normalise first)");
    Check(ZoneFor("NL") == Zone::Nl, "zone: home");
    Check(ZoneFor("DE") == Zone::Eu, "zone: eu");
    Check(ZoneFor("GB") == Zone::World, "zone: world");

    // ── destinations the shop refuses ─────────────────────────────────
    // Zones still classify US and CA (the arithmetic is destination-blind, and
    // keeping it that way means one policy switch, not two); the sale is what
    // stops, in SellsTo.
    Check(!SellsTo("US") && !SellsTo("CA"), "policy: north america refused");
    Check(SellsTo("NL") && SellsTo("DE"), "policy: EU sells");
    Check(SellsTo("GB") && SellsTo("CH") && SellsTo("AU"),
          "policy: the rest of the world still sells");
    Check(SellsTo("us"), "policy: matched on the normalised code, like membership");
    Check(ZoneFor("US") == Zone::World, "zone: refused countries still classify");
    // Sanctioned destinations refuse through the same gate, but the two lists
    // stay distinguishable — the checkout error names the law for one and the
    // shop's own choice for the other.
    Check(!SellsTo("RU") && !SellsTo("BY") && !SellsTo("KP"),
          "sanctions: RU, BY and KP refused");
    Check(IsSanctioned("RU") && IsSanctioned("BY") && IsSanctioned("KP"),
          "sanctions: the list knows its members");
    Check(!IsSanctioned("US") && !IsSanctioned("NL"),
          "sanctions: the insurance refusal is not a sanctions refusal");

    // ── carrier weight brackets ───────────────────────────────────────
    // The only shipping prices that exist. A ladder covering 2 kg / 10 kg /
    // 20 kg, with the 20 kg band deliberately CHEAPER than the 10 kg one —
    // real carrier tariffs do that, and picking the tightest band rather than
    // the cheapest one that carries the parcel would overcharge for it.
    {
        const std::vector<ShipBracket> ladder{ { 2000, 895 }, { 10000, 1650 },
                                               { 20000, 1490 } };
        Check(RateFor(ladder, 700) == 895, "brackets: one unit takes the 2 kg band");
        Check(RateFor(ladder, 2000) == 895, "brackets: the ceiling is inclusive");
        Check(RateFor(ladder, 2001) == 1490,
              "brackets: cheapest band that CARRIES it, not the tightest");
        Check(RateFor(ladder, 20001) == 0, "brackets: above every band is no price");
        Check(RateFor({}, 700) == 0, "brackets: an uncovered country has no price");

        Check(MaxUnitsFor(ladder, 700) == 28, "brackets: units that fit one parcel");
        Check(MaxUnitsFor(ladder, 25000) == 0,
              "brackets: a unit heavier than every band fits nothing");
        Check(MaxUnitsFor(ladder, 0) == 0, "brackets: no weight, no answer");
        Check(MaxUnitsFor({}, 700) == 0, "brackets: no ladder, nothing fits");

        // The table-level lookups the handler and the page both go through.
        const std::vector<ShipRates> table{ { "NL", ladder }, { "JP", { { 2000, 4250 } } } };
        Check(RateFor(LadderFor(table, "NL"), 700) == 895, "table: NL priced");
        Check(RateFor(LadderFor(table, "JP"), 2100) == 0,
              "table: JP has one light band, so two units are unshippable");
        Check(LadderFor(table, "BR").empty(), "table: unlisted country is empty");
    }

    // A zero-priced bracket, which is what a Sendcloud row with a missing or
    // unparseable price field becomes by the time it reaches here. RateFor
    // spends `best == 0` as its "nothing covers this weight" sentinel, so a
    // zero-cent band can never win — and that collision is doing real work: it
    // makes the lookup fail CLOSED (ShippingTable::Find returns 0, checkout
    // answers 422 and refuses) instead of shipping a €580 parcel worldwide for
    // nothing. It is an accident of the sentinel choice rather than a stated
    // rule, which is exactly why it needs a test standing over it: "prefer the
    // cheapest band" is a tempting simplification that would give the parcel
    // away.
    {
        const std::vector<ShipBracket> onlyFree{ { 2000, 0 } };
        Check(RateFor(onlyFree, 700) == 0,
              "brackets: a zero-priced band reads as no price, never as free");
        const std::vector<ShipBracket> withFree{ { 2000, 0 }, { 10000, 1650 } };
        Check(RateFor(withFree, 700) == 1650,
              "brackets: a real price wins over a zero-priced band that also carries it");
    }

    // ── order totals ──────────────────────────────────────────────────

    // NL: gross + shipping, VAT included in both.
    auto nl = ComputeTotals(58000, 1, 1500, "NL");
    Check(nl.goods == 58000 && nl.shipping == 1500 && nl.total == 59500,
          "totals: NL");
    Check(nl.vatIncluded, "totals: NL includes VAT");
    Check(nl.vatCharged == 59500 - NetFromGross(59500), "totals: NL VAT covers shipping");

    auto de = ComputeTotals(58000, 1, 2500, "DE");
    Check(de.goods == 58000 && de.shipping == 2500 && de.total == 60500,
          "totals: EU");

    // Export: net goods, world shipping, no VAT.
    auto gb = ComputeTotals(58000, 1, 5500, "GB");
    Check(gb.goods == 47934 && gb.shipping == 5500 && gb.total == 53434,
          "totals: export");
    Check(!gb.vatIncluded && gb.vatCharged == 0, "totals: export carries no VAT");

    // Quantity: the export net is derived from the LINE total, not per unit —
    // per-unit rounding times qty would differ by a cent here, and the JS
    // preview mirrors this exact formula.
    auto gb2 = ComputeTotals(57500, 2, 5500, "GB");
    Check(gb2.goods == NetFromGross(115000), "totals: qty nets the line, not the unit");
    Check(gb2.goods == 95041, "totals: 2× green export net exact");
    auto nl2 = ComputeTotals(57500, 3, 1500, "NL");
    Check(nl2.goods == 172500 && nl2.total == 174000, "totals: qty multiplies gross");

    // VAT is derived ONCE, from the taxable total — never from a sum of line
    // nets. ComputeTotals says so above (nl.vatCharged comes off goods +
    // shipping as one number); these four make the reason a test rather than a
    // comment, because NetFromGross is NOT additive across lines. Each division
    // rounds half up on its own remainder, and the remainders do not have to
    // agree:
    //
    //   NetFromGross(56330) = (563'300'000 + 6050) / 12100 = 46554  rem  2650
    //   NetFromGross(  400) = (  4'000'000 + 6050) / 12100 =   331  rem   950
    //   NetFromGross(56730) = (567'300'000 + 6050) / 12100 = 46884  rem  9650
    //
    // 56330 + 400 is 56730, but 46554 + 331 is 46885 — one cent ABOVE the net
    // the combined total yields. That gap is not exotic: across the real price
    // grid (three variants × 1..28 units × the shipping ladder) roughly a
    // quarter of the combinations hit it.
    //
    // It matters because the invoice prints a "Subtotal (ex VAT)" that is
    // NetFromGross of the whole total, with the VAT line derived from that
    // subtotal — and non-additivity is exactly why its shipping line is the
    // REMAINDER of that subtotal after the goods net, never NetFromGross of
    // the shipping on its own. The day someone "tidies" the remainder into a
    // third independent rounding, a GPG-signed tax document starts
    // disagreeing with itself by a cent on a quarter of the price grid.
    Check(NetFromGross(56330) == 46554, "vat: net of a goods line");
    Check(NetFromGross(400) == 331, "vat: net of a shipping line");
    Check(NetFromGross(56730) == 46884, "vat: net of the two taken together");
    Check(NetFromGross(56330) + NetFromGross(400) != NetFromGross(56730),
          "vat: line nets do not sum to the total net — derive VAT once, from the total");

    // ── indicative conversion ─────────────────────────────────────────
    // €580.00 at 1.0834 USD/EUR = $628.37 -> 628 whole units.
    Check(ConvertIndicative(58000, 1'083'400) == 628, "fx: converts to whole units");
    Check(ConvertIndicative(58000, 1'000'000) == 580, "fx: identity rate");
    // Both cases above land far from the rounding boundary and would pass
    // under plain truncation too, which leaves the +50'000'000 term — the only
    // thing making this round rather than truncate — entirely unpinned. Drop
    // it and every quoted foreign price shifts DOWN by up to a whole unit, on
    // the number a non-euro buyer reads before deciding to order. So take the
    // boundary head-on: €1.00 at a rate of exactly 1.5 is 1.5 units.
    Check(ConvertIndicative(100, 1'500'000) == 2, "fx: exactly half rounds up");
    Check(ConvertIndicative(100, 1'499'999) == 1,
          "fx: one millionth below half rounds down");
    Check(ConvertIndicative(100, 1'400'000) == 1, "fx: .4 of a unit rounds down");
    // The term must not conjure a unit out of nothing, either.
    Check(ConvertIndicative(0, 1'083'400) == 0, "fx: zero converts to zero");
    auto gbp = CurrencyFor("GB");
    Check(gbp.has_value() && gbp->code == "GBP", "fx: GB -> GBP");
    Check(!CurrencyFor("DE").has_value(), "fx: euro country has no conversion");
    Check(!CurrencyFor("XX").has_value(), "fx: unknown country has no conversion");
    if (gbp) {
        Check(FormatIndicative(*gbp, 920) == "≈ £920", "fx: display form");
    }
    // A country the shop refuses gets no localised price either — the two
    // tables are kept consistent on purpose, so this is a real invariant and
    // not a coincidence of the current list.
    for (const std::string_view cc : NoSaleCountries()) {
        Check(!CurrencyFor(cc).has_value(),
              "fx: refused destinations have no display currency", cc);
    }
    for (const std::string_view cc : SanctionedCountries()) {
        Check(!CurrencyFor(cc).has_value(),
              "fx: sanctioned destinations have no display currency", cc);
    }

    // ── rates loader ──────────────────────────────────────────────────
    const Rates r = LoadRates(
        R"({"date":"2026-08-04","micro_per_eur":{"USD":1083400,"CAD":1489000}})");
    Check(r.date == "2026-08-04", "rates: date");
    Check(r.Find("USD") == 1'083'400, "rates: lookup");
    Check(r.Find("XXX") == 0, "rates: absent is zero");
    Check(LoadRates("garbage").microPerEur.empty(), "rates: malformed input yields none");

    // Above is the whole-document failure; this is the per-ENTRY one, which is
    // the case CI actually produces. LoadRates admits a rate only when it is a
    // JSON number AND strictly positive, and that guard is the single thing
    // standing between a bad rates.json and a printed price: the views and the
    // order handler only re-check `rate > 0` before formatting, so a negative
    // that slipped through here would render "≈ £-628" on every shop card.
    // One entry per rejected shape — zero, negative, a number sent as a
    // string, and null.
    const Rates bad = LoadRates(
        R"({"date":"2026-08-04","micro_per_eur":{"USD":0,"GBP":-860000,)"
        R"("CHF":"940000","SEK":null}})");
    Check(bad.date == "2026-08-04", "rates: a readable date survives unusable entries");
    Check(bad.microPerEur.empty(),
          "rates: zero, negative, string and null entries are all refused");
    Check(bad.Find("USD") == 0 && bad.Find("GBP") == 0 && bad.Find("CHF") == 0 &&
              bad.Find("SEK") == 0,
          "rates: a refused entry is indistinguishable from an absent one");
    // Refusal is per entry, not per document — one unusable rate must not take
    // its healthy siblings down with it, or a single ECB hiccup blanks every
    // localised price on the site instead of just the one currency's.
    const Rates partial = LoadRates(
        R"({"date":"2026-08-04","micro_per_eur":{"GBP":-860000,"NOK":11700000}})");
    Check(partial.microPerEur.size() == 1, "rates: only the bad entry is dropped");
    Check(partial.Find("NOK") == 11'700'000, "rates: the valid sibling still loads");
    Check(partial.Find("GBP") == 0, "rates: the negative sibling does not");

    if (failures != 0) {
        std::println(std::cerr, "{} check(s) failed", failures);
        return 1;
    }
    return 0;
}