The report that crashed on real data

import java.util.*;
import java.util.function.*;
import java.util.stream.*;

/**
 * Solution: the report that crashed on real data.
 *
 * Three defects, one theme: every collector has a failure mode, and the tidy
 * fixture exercised none of them. The staging data had one sale per region,
 * everything settled and every promo present — so the three assumptions were
 * never tested, only assumed.
 *
 *   Defect 1 — two-argument toMap on a key that repeats. It throws
 *   IllegalStateException naming both values. The two-argument form is not the
 *   simple version; it is an assertion that the key is unique. Where it is
 *   not, the three-argument form makes the collision rule explicit — and here
 *   a region genuinely has several reps, so the value should have been a
 *   collection in the first place.
 *
 *   Defect 2 — groupingBy on a boolean, then get(true). groupingBy only
 *   creates keys it actually encountered, so a day with nothing settled leaves
 *   get(true) returning null. partitioningBy always returns both keys, which
 *   is exactly what it exists for.
 *
 *   Defect 3 — toMap with a value that can be null. toMap is implemented with
 *   Map.merge, whose contract rejects null values, so it throws where a plain
 *   put would have accepted it. The fix is to decide what a missing promo
 *   means rather than to let a null through: here, filter it out.
 */
public class Solution {

    record Sale(String region, String rep, boolean settled, String promoCode, int amount) { }

    static List<Sale> fixture() {
        return List.of(
            new Sale("north", "Ana", true, "SPRING", 120),
            new Sale("south", "Bo", true, "SPRING", 95));
    }

    static List<Sale> production() {
        return List.of(
            new Sale("north", "Ana", false, "SPRING", 120),
            new Sale("north", "Bo", false, null, 95),
            new Sale("south", "Cy", false, null, 70));
    }

    /** FIX 1: a region has many reps, so the value is a collection. */
    static Map<String, List<String>> repByRegion(List<Sale> sales) {
        return sales.stream().collect(Collectors.groupingBy(Sale::region,
            Collectors.mapping(Sale::rep, Collectors.toList())));
    }

    /** FIX 2: partitioningBy always returns both keys. */
    static int settledCount(List<Sale> sales) {
        Map<Boolean, List<Sale>> split = sales.stream()
            .collect(Collectors.partitioningBy(Sale::settled));
        return split.get(true).size();
    }

    /** FIX 3: a missing promo is an absent entry, not a null value. */
    static Map<String, String> promoByRep(List<Sale> sales) {
        return sales.stream()
            .filter(s -> s.promoCode() != null)
            .collect(Collectors.toMap(Sale::rep, Sale::promoCode, (a, b) -> a));
    }

    public static void main(String[] args) {
        boolean ok = true;

        System.out.println("── against the staging fixture ──");
        System.out.println("  reps    : " + new TreeMap<>(repByRegion(fixture())));
        System.out.println("  settled : " + settledCount(fixture()));
        System.out.println("  promos  : " + new TreeMap<>(promoByRep(fixture())));

        System.out.println();
        System.out.println("── against production data ──");

        ok &= check("the report handles more than one sale per region",
            attempt("reps", () -> new TreeMap<>(repByRegion(production())).toString()));

        ok &= check("the report handles a day with nothing settled",
            attempt("settled", () -> String.valueOf(settledCount(production()))));

        ok &= check("the report handles a sale with no promo code",
            attempt("promos", () -> new TreeMap<>(promoByRep(production())).toString()));

        System.out.println();
        System.out.println(ok ? "PASS" : "FAIL");
    }

    static boolean attempt(String label, Supplier<String> body) {
        try {
            System.out.println("  " + label + " : " + body.get());
            return true;
        } catch (RuntimeException e) {
            System.out.println("  " + label + " : " + e.getClass().getSimpleName()
                + (e.getMessage() == null ? "" : " — " + e.getMessage()));
            return false;
        }
    }

    static boolean check(String what, boolean passed) {
        System.out.println((passed ? "  ok    " : "  FAIL  ") + what);
        return passed;
    }
}