The config that vanished from its own cache

import java.util.*;

/**
 * Solution: the config that vanished from its own cache.
 *
 * The record was declared correctly and the caller did nothing unusual. The
 * defect is that a record is only as immutable as its components, and a
 * record with a List component is freely mutable through the list the caller
 * still holds.
 *
 * Everything a record generates — equals, hashCode, toString — is derived
 * from the components' CURRENT contents. So when the caller added an item to
 * its basket, the stored key's hashCode changed while the entry sat in the
 * bucket chosen by the old one. HashMap looks in the bucket the new hash
 * points at, finds nothing, and reports a miss.
 *
 * The entry is not gone. size() still counts it, iterating the entrySet
 * still yields it, and it still holds memory. It is simply unreachable by
 * key, forever, which is the same failure as any mutable HashMap key —
 * see /java/collections/hashmap-internals.
 *
 * THE FIX
 *   A compact constructor with List.copyOf. That severs the caller's list
 *   from the record, so nothing outside can change what the key hashes to.
 *   It also rejects nulls, which is a second small win.
 *
 *   Note what is NOT the fix: making the field final (it already is),
 *   copying in the accessor (too late — the damage is on the way in), or
 *   telling callers not to reuse lists (a convention, not a mechanism).
 *
 * THE DESIGN QUESTION
 *   A record whose components are all immutable is a genuinely safe map key.
 *   That is the shape to aim for, and it is worth checking every component
 *   type at the point you declare the record rather than at 3am.
 */
public class Solution {

    /**
     * FIX: copy the component in, so the record's contents cannot be changed
     * by anyone who kept a reference to the list they passed.
     *
     * List.copyOf returns the input unchanged when it is already immutable,
     * so callers passing List.of(...) pay nothing for this.
     */
    record PriceRequest(String tenant, List<String> skus) {
        PriceRequest {
            skus = List.copyOf(skus);
        }
    }

    static final class PriceCache {
        private final Map<PriceRequest, Integer> computed = new HashMap<>();
        int hits = 0;
        int misses = 0;

        int priceFor(PriceRequest request) {
            Integer cached = computed.get(request);
            if (cached != null) {
                hits++;
                return cached;
            }
            misses++;
            int price = request.skus().size() * 1000;   // "expensive"
            computed.put(request, price);
            return price;
        }

        boolean knows(PriceRequest request) {
            return computed.containsKey(request);
        }

        int size() {
            return computed.size();
        }
    }

    public static void main(String[] args) {
        PriceCache cache = new PriceCache();

        // The caller builds a basket and prices it. Entirely ordinary.
        List<String> basket = new ArrayList<>(List.of("SKU-1"));
        cache.priceFor(new PriceRequest("acme", basket));

        // Control: a fresh, equal request finds the cached answer.
        boolean foundBefore = cache.knows(new PriceRequest("acme", List.of("SKU-1")));
        System.out.println("  before: an equal request is found : " + foundBefore);

        // The caller adds an item to the basket. One line, and nothing in
        // this file is touching the cache.
        basket.add("SKU-2");
        System.out.println("  caller added SKU-2 to its basket");

        // Now look for both the old contents and the new contents.
        boolean foundOld = cache.knows(new PriceRequest("acme", List.of("SKU-1")));
        boolean foundNew = cache.knows(new PriceRequest("acme", List.of("SKU-1", "SKU-2")));

        System.out.println("  after : old contents found        : " + foundOld);
        System.out.println("  after : new contents found        : " + foundNew);

        // Every subsequent request misses and stores another entry.
        for (int i = 0; i < 3; i++) {
            cache.priceFor(new PriceRequest("acme", List.of("SKU-1", "SKU-2")));
        }

        System.out.println();
        System.out.printf("  hits=%d misses=%d cacheSize=%d%n",
                cache.hits, cache.misses, cache.size());

        System.out.println();
        boolean entriesStayReachable = foundBefore && (foundOld || foundNew);
        boolean cacheWorks = cache.hits > 0;

        System.out.println("stored entries stay reachable : " + entriesStayReachable);
        System.out.println("cache is ever hit             : " + cacheWorks);
        System.out.println(entriesStayReachable && cacheWorks ? "PASS" : "FAIL");
    }
}