init

app/lib/grocery.test.ts

@@ -0,0 +1,112 @@
+import { describe, expect, test } from "bun:test";
+import type { ItemId, StoreItem } from "@/app/types";
+import { CATALOG_BY_ID } from "./catalog";
+import { Cart, buildGroceryList } from "./grocery";
+import type { PriceProvider } from "./pricing";
+import { RECIPES, RECIPES_BY_ID } from "./recipes";
+import { sanitizeState } from "./sanitize";
+import { toBaseUnit } from "./units";
+
+// ---------------------------------------------------------------------------
+// The money math. These are the numbers people budget against, so they get
+// pinned down here rather than eyeballed in the UI.
+//
+// Trick: buildGroceryList accepts a price provider. We hand it a fake store
+// that stocks ONE item with a package size we choose, so we control exactly
+// how many packages a real recipe needs. Every other ingredient is "not
+// stocked" and skipped, which keeps the arithmetic to a single line.
+// ---------------------------------------------------------------------------
+
+const RECIPE = RECIPES_BY_ID.get("chicken-tikka-masala")!;
+const INGREDIENT = RECIPE.ingredients[0];
+const REAL_ITEM = CATALOG_BY_ID.get(INGREDIENT.itemId)!;
+
+/** How much of the item one batch of the recipe needs, in the item's base unit. */
+const NEEDED = toBaseUnit(INGREDIENT.amount, INGREDIENT.unit, REAL_ITEM);
+
+/** A store that only sells our one item, sized so the recipe needs `packagesNeeded` packages. */
+function storeWhereRecipeNeeds(packagesNeeded: number, price = 10): PriceProvider {
+  const item: StoreItem = { ...REAL_ITEM, packageSize: NEEDED / packagesNeeded, price };
+  return { label: "test", getItem: (id: ItemId) => (id === item.id ? item : undefined) };
+}
+
+/** Cook the recipe once, for exactly as many people as it serves (scale = 1). */
+function groceryList(provider: PriceProvider, onHandItems: ItemId[] = []) {
+  return buildGroceryList([RECIPE.id], { householdSize: RECIPE.servings, onHandItems, provider });
+}
+
+describe("whole-package pricing", () => {
+  test("1.2 packages' worth bills 2 packages", () => {
+    const { lines, checkoutTotal, usedTotal, carryoverValue } = groceryList(storeWhereRecipeNeeds(1.2));
+
+    expect(lines).toHaveLength(1);
+    expect(lines[0].packages).toBe(2);
+    expect(checkoutTotal).toBe(20); // 2 × $10 at the register
+    expect(usedTotal).toBe(12); // 1.2 × $10 actually eaten
+    expect(carryoverValue).toBe(8); // the rest goes to the pantry
+  });
+
+  test("float noise doesn't buy an extra package (2.000000001 → 2)", () => {
+    const { lines } = groceryList(storeWhereRecipeNeeds(2 + 1e-9));
+    expect(lines[0].packages).toBe(2);
+  });
+
+  test("a tiny amount still buys one whole package", () => {
+    const { lines } = groceryList(storeWhereRecipeNeeds(0.01));
+    expect(lines[0].packages).toBe(1);
+  });
+
+  test("an on-hand item is listed but costs $0", () => {
+    const { lines, checkoutTotal, usedTotal } = groceryList(storeWhereRecipeNeeds(1.2), [REAL_ITEM.id]);
+
+    expect(lines[0].onHand).toBe(true);
+    expect(lines[0].packages).toBe(2); // still shown, so you can check your shelf
+    expect(lines[0].checkoutCost).toBe(0);
+    expect(checkoutTotal).toBe(0);
+    expect(usedTotal).toBe(0);
+  });
+});
+
+describe("Cart (the fast path auto-fill and the meal picker use)", () => {
+  // Cart only looks at the new recipe's ingredients. It must still agree with
+  // the slow, obvious way: build the whole list with and without, subtract.
+  test("marginal cost matches building the list with and without the recipe", () => {
+    const options = { householdSize: 3, onHandItems: [REAL_ITEM.id] };
+    const planned = RECIPES.filter((_, i) => i % 37 === 0).map((r) => r.id); // a varied ~12-meal plan
+    const cart = new Cart(options, planned);
+    const baseline = buildGroceryList(planned, options);
+
+    for (const recipe of RECIPES) {
+      const withIt = buildGroceryList([...planned, recipe.id], options);
+      const { checkout, eaten } = cart.marginal(recipe.id);
+      expect(checkout).toBeCloseTo(withIt.checkoutTotal - baseline.checkoutTotal, 1);
+      expect(eaten).toBeCloseTo(withIt.usedTotal - baseline.usedTotal, 1);
+    }
+  });
+
+  test("a recipe that reuses an open package adds less than it costs alone", () => {
+    const cart = new Cart({ householdSize: 2, onHandItems: [] });
+    const alone = cart.marginal(RECIPE.id).checkout;
+    cart.add(RECIPE.id);
+    expect(cart.marginal(RECIPE.id).checkout).toBeLessThan(alone);
+  });
+});
+
+describe("sanitizeState", () => {
+  test("clamps days and drops slots outside the grid", () => {
+    const state = sanitizeState({ daysCount: 99, slots: { "9-9": "x" } });
+    expect(state.daysCount).toBe(7);
+    expect(state.slots).toEqual({});
+  });
+
+  test("drops slots that point at recipes that don't exist", () => {
+    const state = sanitizeState({ slots: { "0-3": "not-a-real-recipe", "1-3": RECIPE.id } });
+    expect(state.slots).toEqual({ "1-3": RECIPE.id });
+  });
+
+  test("survives garbage input", () => {
+    expect(() => sanitizeState(null)).not.toThrow();
+    expect(() => sanitizeState("nope")).not.toThrow();
+    expect(sanitizeState({ mealsPerDay: Number.NaN }).mealsPerDay).toBeGreaterThanOrEqual(1);
+  });
+});