The dedupe job that stopped deduping

import java.util.*;

/**
 * Root cause: the release added `period` to InvoiceKey and to equals(), but the
 * class never had a hashCode() at all. It inherited Object.hashCode(), which is
 * identity-based — so two rows with identical contents hash to different
 * buckets, HashSet never compares them with equals(), and every row looks
 * unique.
 *
 * Why nothing failed loudly: HashSet.add() computes the hash, picks a bucket,
 * and only then calls equals(). A wrong hash means the comparison never
 * happens. There is nothing to throw. size() answers confidently and wrongly.
 *
 * Why it worked for eight months: it did not. The eight-month-old version had
 * the same missing hashCode(). It only became visible when the overlap window
 * grew — before the release the two feeds were deduplicated upstream by
 * account alone, so this set was never load-bearing.
 *
 * The fix is one method, and the rule it enforces is: equals() and hashCode()
 * must read exactly the same fields.
 *
 * What would have caught it on the release commit: a unit test asserting
 * two separately constructed keys with identical contents are interchangeable
 * in a Set —
 *
 *     var a = new InvoiceKey("ACC1", "2026-08");
 *     var b = new InvoiceKey("ACC1", "2026-08");
 *     assertEquals(a, b);
 *     assertEquals(a.hashCode(), b.hashCode());   // this is the one that fails
 *     assertEquals(1, new HashSet<>(List.of(a, b)).size());
 *
 * assertEquals(a, b) alone passes, which is exactly why "we have tests for the
 * key class" was not enough. The hashCode assertion is the test that matters,
 * and EqualsVerifier (nl.jqno.equalsverifier) writes it for you.
 */
public class Solution {

    static final class InvoiceKey {
        private final String account;
        private final String period;

        InvoiceKey(String account, String period) {
            this.account = account;
            this.period = period;
        }

        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof InvoiceKey other)) return false;
            return account.equals(other.account) && period.equals(other.period);
        }

        /**
         * THE FIX. Same two fields equals() reads, in the same order.
         *
         * Objects.hash allocates a varargs array and boxes nothing here, since
         * both fields are already references. On a hot path you would write
         * `31 * account.hashCode() + period.hashCode()` and skip the array;
         * this job runs nightly, so readability wins.
         */
        @Override
        public int hashCode() {
            return Objects.hash(account, period);
        }

        @Override
        public String toString() {
            return account + "@" + period;
        }
    }

    /*
     * The structural fix, which is what I would actually ship:
     *
     *     record InvoiceKey(String account, String period) {}
     *
     * Both methods are generated from all components, so they cannot drift when
     * the next field is added — which is precisely the failure above.
     *
     * What you give up by using a record:
     *   - the class is final, so no subclass can extend the key
     *   - every component is final and public via an accessor
     *   - you cannot hash a subset of fields (legal, and occasionally wanted:
     *     hashing fewer fields than equals() compares is contract-safe, since
     *     equal objects still agree on the hash)
     */

    private static final String PERIOD = "2026-08";

    static List<InvoiceKey> ingest() {
        List<InvoiceKey> rows = new ArrayList<>();
        for (int i = 0; i < 5000; i++) rows.add(new InvoiceKey("ACC" + i, PERIOD));
        for (int i = 2500; i < 7500; i++) rows.add(new InvoiceKey("ACC" + i, PERIOD));
        return rows;
    }

    public static void main(String[] args) {
        List<InvoiceKey> ingested = ingest();
        Set<InvoiceKey> distinct = new HashSet<>(ingested);

        int expected = 7500;
        int billed = distinct.size();

        System.out.println("rows ingested     = " + ingested.size());
        System.out.println("expected distinct = " + expected);
        System.out.println("actually billed   = " + billed);
        System.out.println("duplicate charges = " + (billed - expected));
        System.out.println("job's own log     : deduplicated "
            + (ingested.size() - billed) + " rows");

        InvoiceKey a = new InvoiceKey("ACC3000", PERIOD);
        InvoiceKey b = new InvoiceKey("ACC3000", PERIOD);
        System.out.println("a.equals(b)       = " + a.equals(b));
        System.out.println("same hash         = " + (a.hashCode() == b.hashCode()));
        System.out.println("set finds a via b = " + distinct.contains(b));

        System.out.println(billed == expected ? "PASS" : "FAIL");
    }
}