/* eslint-disable @typescript-eslint/no-explicit-any */ /** * Section 25 — Cart hook contract. * * Covers `apps/user-ui/hooks/cart-query-hooks.tsx`: the local-cart CRUD helpers * behind `useAddToCart` / `useUpdateCartItem` / `useRemoveFromCart`, the * `useGetCart` enrichment + totals, `useReconcileCartSlots`, and the exported * per-region snapshot helpers (`clearLocalCart`, `stashRegionCarts`, * `restoreRegionCarts`). * * The helpers talk to `StorageServiceCasual` directly, so every write lands in * the in-memory secure-store mock and can be read back with `__snapshot()`. */ import * as React from 'react' import { act, waitFor } from '@testing-library/react-native' import { QueryClient } from '@tanstack/react-query' import { StorageServiceCasual } from 'common-ui' import { useGetCart, useAddToCart, useUpdateCartItem, useRemoveFromCart, useReconcileCartSlots, clearLocalCart, stashRegionCarts, restoreRegionCarts, type CartType, } from '@/hooks/cart-query-hooks' import { renderWithProviders, seedCentralStores, flush } from '../helpers/test-utils' import { resetAllMocks } from '../helpers/reset' import { __set, __snapshot } from '../mocks/secure-store-mock' import { MERGED_PRODUCTS } from '../fixtures' const ADDED_AT = '2024-01-01T00:00:00.000Z' const REGULAR_KEY = 'cart_items' const FLASH_KEY = 'flash_cart_items' const makeLine = (id: number, skuId: number, quantity: number, slotId: number) => ({ id, skuId, quantity, slotId, addedAt: ADDED_AT, }) function seedCart(key: string, lines: any[]) { __set(key, JSON.stringify(lines)) } /** Read a cart (or region snapshot) straight out of the storage mock. */ function stored(key = REGULAR_KEY): any[] { const raw = __snapshot()[key] return raw ? JSON.parse(raw) : [] } /* -------------------------------------------------------------------------- */ /* Probes: expose the hook's return value to the test body. */ /* -------------------------------------------------------------------------- */ interface ProbeApi { current: any } function GetCartProbe({ api, cartType = 'regular' as CartType }: { api: ProbeApi; cartType?: CartType }) { api.current = useGetCart({ refetchOnWindowFocus: false }, cartType) return null } function AddProbe({ api, cartType = 'regular' as CartType }: { api: ProbeApi; cartType?: CartType }) { api.current = useAddToCart({ showSuccessAlert: false, showErrorAlert: false }, cartType) return null } function UpdateProbe({ api, cartType = 'regular' as CartType }: { api: ProbeApi; cartType?: CartType }) { api.current = useUpdateCartItem({ showSuccessAlert: false, showErrorAlert: false }, cartType) return null } function RemoveProbe({ api, cartType = 'regular' as CartType }: { api: ProbeApi; cartType?: CartType }) { api.current = useRemoveFromCart({ showSuccessAlert: false, showErrorAlert: false }, cartType) return null } function ReconcileProbe() { useReconcileCartSlots() return null } /** Let an async mutation settle inside `act`. */ async function run(fn: () => Promise): Promise { let result: T | undefined await act(async () => { result = await fn() // Let react-query's notify manager `setTimeout(0)` flush inside `act`. await new Promise((resolve) => setTimeout(resolve, 0)) }) return result } /** * Same defaults as the shared harness client, except mutations use `gcTime: 0`. * React Query's `Mutation` otherwise schedules a 5-minute GC timeout on * unmount, which keeps the jest process alive after the run has finished. */ function createCartQueryClient(): QueryClient { return new QueryClient({ defaultOptions: { queries: { retry: false, gcTime: Infinity, staleTime: Infinity, refetchOnWindowFocus: false, }, mutations: { retry: false, gcTime: 0 }, }, }) } function mount(ui: React.ReactElement, queryClient: QueryClient = createCartQueryClient()) { return renderWithProviders(ui, { auth: false, queryClient }) } describe('Cart query hooks', () => { beforeEach(() => resetAllMocks()) it('CARTQ-01: add new item writes a storage line with id 1, quantity and slot', async () => { const api: ProbeApi = { current: null } mount() await run(() => api.current.addToCartAsync(2, 2, 1849)) const lines = stored() expect(lines).toHaveLength(1) expect(lines[0]).toMatchObject({ id: 1, skuId: 2, quantity: 2, slotId: 1849 }) expect(lines[0].addedAt).toEqual(expect.any(String)) }) it('CARTQ-02: add existing SKU increments the quantity and moves the slot when provided', async () => { seedCart(REGULAR_KEY, [makeLine(1, 2, 2, 1849)]) const api: ProbeApi = { current: null } mount() await run(() => api.current.addToCartAsync(2, 3, 1850)) expect(stored()).toHaveLength(1) expect(stored()[0]).toMatchObject({ id: 1, skuId: 2, quantity: 5, slotId: 1850 }) }) it('CARTQ-03: adding an existing SKU without a slot leaves the slot unchanged', async () => { seedCart(REGULAR_KEY, [makeLine(1, 2, 2, 1849)]) const api: ProbeApi = { current: null } mount() // The public `addToCart`/`addToCartAsync` guard slotId, but the raw mutation // passes `undefined` through to `addToLocalCart`, which then keeps the slot. await run(() => api.current.mutateAsync({ skuId: 2, quantity: 1, slotId: undefined } as any)) expect(stored()).toHaveLength(1) expect(stored()[0]).toMatchObject({ id: 1, skuId: 2, quantity: 3, slotId: 1849 }) }) it('CARTQ-04: adding without a slot throws "slotId is required for adding to cart"', async () => { const api: ProbeApi = { current: null } mount() expect(() => api.current.addToCart(2, 1)).toThrow('slotId is required for adding to cart') expect(() => api.current.addToCartAsync(2, 1)).toThrow('slotId is required for adding to cart') // Nothing reached storage. expect(stored()).toEqual([]) }) it('CARTQ-05: new ids are allocated from the current maximum, not the length', async () => { seedCart(REGULAR_KEY, [makeLine(1, 2, 1, 1849), makeLine(5, 5, 1, 1850)]) const api: ProbeApi = { current: null } mount() await run(() => api.current.addToCartAsync(8, 1, 1852)) expect(stored().map((item) => item.id)).toEqual([1, 5, 6]) }) it('CARTQ-06: update item persists the new quantity', async () => { seedCart(REGULAR_KEY, [makeLine(1, 2, 2, 1849)]) const api: ProbeApi = { current: null } mount() await run(() => api.current.updateCartItemAsync(1, 5)) expect(stored()).toHaveLength(1) expect(stored()[0].quantity).toBe(5) }) it('CARTQ-07: updating a missing item leaves the cart unchanged', async () => { const seeded = [makeLine(1, 2, 2, 1849)] seedCart(REGULAR_KEY, seeded) const api: ProbeApi = { current: null } mount() await run(() => api.current.updateCartItemAsync(999, 5)) expect(stored()).toEqual(seeded) }) it('CARTQ-08: remove filters the line out of the cart', async () => { seedCart(REGULAR_KEY, [makeLine(1, 2, 2, 1849), makeLine(2, 5, 1, 1850)]) const api: ProbeApi = { current: null } mount() await run(() => api.current.removeFromCartAsync(1)) expect(stored()).toEqual([makeLine(2, 5, 1, 1850)]) }) it('CARTQ-09: removing a missing item leaves the cart unchanged', async () => { const seeded = [makeLine(1, 2, 2, 1849)] seedCart(REGULAR_KEY, seeded) const api: ProbeApi = { current: null } mount() await run(() => api.current.removeFromCartAsync(999)) expect(stored()).toEqual(seeded) }) it('CARTQ-10: clearLocalCart stores an empty array', async () => { seedCart(REGULAR_KEY, [makeLine(1, 2, 2, 1849)]) await clearLocalCart('regular') expect(stored()).toEqual([]) expect(JSON.parse(__snapshot()[REGULAR_KEY])).toEqual([]) }) it('CARTQ-11: the flash cart is stored separately and leaves the regular cart alone', async () => { seedCart(REGULAR_KEY, [makeLine(1, 2, 2, 1849)]) const api: ProbeApi = { current: null } mount() await run(() => api.current.addToCartAsync(8, 3, 0)) expect(stored(FLASH_KEY)).toEqual([expect.objectContaining({ id: 1, skuId: 8, quantity: 3, slotId: 0 })]) expect(stored(REGULAR_KEY)).toEqual([makeLine(1, 2, 2, 1849)]) }) it('CARTQ-12: corrupt cart JSON surfaces as an error and is left in place (no fallback)', async () => { seedCentralStores() seedCart(REGULAR_KEY, [] as any) __set(REGULAR_KEY, '{not json') const api: ProbeApi = { current: null } mount() await waitFor(() => expect(api.current.error).toBeTruthy()) expect(api.current.error).toBeInstanceOf(Error) expect(api.current.data).toBeUndefined() // Current behaviour: no fallback — the corrupt blob is not repaired. expect(__snapshot()[REGULAR_KEY]).toBe('{not json') }) it('CARTQ-13: useGetCart enriches lines from the central product store', async () => { seedCentralStores() seedCart(REGULAR_KEY, [makeLine(1, 2, 2, 1849)]) const api: ProbeApi = { current: null } mount() await waitFor(() => expect(api.current.data).toBeDefined()) // P_CHICKEN (id 2) price 215 -> subtotal 215 * 2. // Current behaviour: the enriched line surfaces only the six cart fields; // the product's name / unitNotation / marketPrice feed the lookup but are // not part of the returned line shape. expect(api.current.cartItems).toEqual([ { id: 1, skuId: 2, quantity: 2, addedAt: ADDED_AT, subtotal: 430, slotId: 1849, }, ]) expect(api.current.data.items).toEqual(api.current.cartItems) }) it('CARTQ-14: a line whose product is missing from the store is hidden', async () => { seedCentralStores() seedCart(REGULAR_KEY, [makeLine(1, 999, 1, 1849)]) const api: ProbeApi = { current: null } mount() await waitFor(() => expect(api.current.data).toBeDefined()) expect(api.current.cartItems).toEqual([]) expect(api.current.isEmpty).toBe(true) expect(api.current.hasItems).toBe(false) }) it('CARTQ-15: a line whose SKU has no slot entry is hidden', async () => { // Product 777 exists in the product store but not in PRODUCT_AVAILABILITY, // so it never appears in `productSlotsMap`. const ghost = { ...MERGED_PRODUCTS[0], id: 777, name: 'Ghost Product' } seedCentralStores({ products: [...MERGED_PRODUCTS, ghost] }) seedCart(REGULAR_KEY, [makeLine(1, 777, 1, 1849)]) const api: ProbeApi = { current: null } mount() await waitFor(() => expect(api.current.data).toBeDefined()) expect(api.current.cartItems).toEqual([]) expect(api.current.isEmpty).toBe(true) }) it('CARTQ-16: a zero-quantity line is preserved', async () => { seedCentralStores() seedCart(REGULAR_KEY, [makeLine(1, 2, 0, 1849)]) const api: ProbeApi = { current: null } mount() await waitFor(() => expect(api.current.data).toBeDefined()) expect(api.current.cartItems).toHaveLength(1) expect(api.current.cartItems[0]).toMatchObject({ quantity: 0, subtotal: 0 }) expect(api.current.isEmpty).toBe(false) }) it('CARTQ-17: the query stays disabled (loading false, no data) until products load', async () => { seedCart(REGULAR_KEY, [makeLine(1, 2, 2, 1849)]) const api: ProbeApi = { current: null } mount() await flush() // No products in the central store -> `enabled` is false, so the query never // fetches: React Query reports `isLoading === false` and no data. expect(api.current.isLoading).toBe(false) expect(api.current.data).toBeUndefined() act(() => { seedCentralStores() }) await waitFor(() => expect(api.current.data).toBeDefined()) expect(api.current.cartItems).toHaveLength(1) }) it('CARTQ-18: totals sum the enriched subtotals', async () => { seedCentralStores() seedCart(REGULAR_KEY, [makeLine(1, 2, 2, 1849), makeLine(2, 5, 4, 1850)]) const api: ProbeApi = { current: null } mount() await waitFor(() => expect(api.current.data).toBeDefined()) // 215 * 2 + 15 * 4 = 490 expect(api.current.cartItems.map((item: any) => item.subtotal)).toEqual([430, 60]) expect(api.current.totalItems).toBe(2) expect(api.current.totalPrice).toBe(490) expect(api.current.data.totalItems).toBe(2) expect(api.current.data.totalAmount).toBe(490) }) it('CARTQ-19: reconcile keeps a line whose slot is still valid', async () => { seedCentralStores() seedCart(REGULAR_KEY, [makeLine(1, 2, 2, 1849)]) const queryClient = createCartQueryClient() const invalidate = jest.spyOn(queryClient, 'invalidateQueries') mount(, queryClient) await flush(3) expect(stored()).toEqual([makeLine(1, 2, 2, 1849)]) expect(invalidate).not.toHaveBeenCalled() }) it('CARTQ-20: reconcile moves an invalid slot to the nearest by delivery time', async () => { seedCentralStores() seedCart(REGULAR_KEY, [makeLine(1, 2, 2, 9999)]) const queryClient = createCartQueryClient() const invalidate = jest.spyOn(queryClient, 'invalidateQueries') mount(, queryClient) // SKU 2 is served by slots 1849/1850/1851/1852; 1851 has the earliest // deliveryTime (now - 2h), so it is the "nearest". await waitFor(() => expect(stored()[0].slotId).toBe(1851)) expect(invalidate).toHaveBeenCalledWith({ queryKey: ['local-cart-regular'] }) expect(stored()[0]).toMatchObject({ id: 1, skuId: 2, quantity: 2 }) }) it('CARTQ-21: reconcile keeps a line whose product has no slots at all', async () => { seedCentralStores() // P_NO_SLOT (id 10) exists in productAvailability but is in no delivery slot. seedCart(REGULAR_KEY, [makeLine(1, 10, 2, 7)]) const queryClient = createCartQueryClient() const invalidate = jest.spyOn(queryClient, 'invalidateQueries') mount(, queryClient) await flush(3) expect(stored()).toEqual([makeLine(1, 10, 2, 7)]) expect(invalidate).not.toHaveBeenCalled() }) it('CARTQ-22: reconcile does nothing while the slot store is not loaded', async () => { // No `seedCentralStores()` -> isSlotsLoaded false and an empty productSlotsMap. seedCart(REGULAR_KEY, [makeLine(1, 2, 2, 9999)]) const queryClient = createCartQueryClient() const invalidate = jest.spyOn(queryClient, 'invalidateQueries') const setItem = jest.spyOn(StorageServiceCasual, 'setItem') mount(, queryClient) await flush(3) expect(setItem).not.toHaveBeenCalled() expect(invalidate).not.toHaveBeenCalled() expect(stored()).toEqual([makeLine(1, 2, 2, 9999)]) }) it('CARTQ-23: reconcile writes nothing when every line is already valid', async () => { seedCentralStores() // SKU 2 is served by slots 1849/1850/1851/1852 and SKU 5 by 1849/1852, so // both of these lines are already valid. seedCart(REGULAR_KEY, [makeLine(1, 2, 2, 1849), makeLine(2, 5, 1, 1852)]) const queryClient = createCartQueryClient() const invalidate = jest.spyOn(queryClient, 'invalidateQueries') const setItem = jest.spyOn(StorageServiceCasual, 'setItem') mount(, queryClient) await flush(3) expect(setItem).not.toHaveBeenCalled() expect(invalidate).not.toHaveBeenCalled() }) it('CARTQ-24: stashRegionCarts snapshots sku, slot and quantity for both carts', async () => { seedCart(REGULAR_KEY, [makeLine(1, 2, 2, 1849), makeLine(2, 5, 4, 1850)]) seedCart(FLASH_KEY, [makeLine(1, 8, 3, 0)]) await stashRegionCarts(1) expect(stored('region_carts_1')).toEqual({ regular: [ { skuId: 2, slotId: 1849, quantity: 2 }, { skuId: 5, slotId: 1850, quantity: 4 }, ], flash: [{ skuId: 8, slotId: 0, quantity: 3 }], }) }) it('CARTQ-25: restoreRegionCarts reissues ids and defaults missing/invalid quantities to 1', async () => { __set( 'region_carts_2', JSON.stringify({ regular: [ { skuId: 2, slotId: 1849, quantity: 3 }, { skuId: 5, slotId: 1850, quantity: 0 }, ], flash: [{ skuId: 8, slotId: 0 }], }) ) await restoreRegionCarts(2) const regular = stored(REGULAR_KEY) expect(regular.map((item) => item.id)).toEqual([1, 2]) expect(regular.map((item) => [item.skuId, item.slotId, item.quantity])).toEqual([ [2, 1849, 3], [5, 1850, 1], ]) expect(regular.every((item) => typeof item.addedAt === 'string')).toBe(true) const flash = stored(FLASH_KEY) expect(flash).toHaveLength(1) expect(flash[0]).toMatchObject({ id: 1, skuId: 8, slotId: 0, quantity: 1 }) }) it('CARTQ-26: a corrupt region snapshot restores both carts to empty', async () => { seedCart(REGULAR_KEY, [makeLine(1, 2, 2, 1849)]) seedCart(FLASH_KEY, [makeLine(1, 8, 3, 0)]) __set('region_carts_3', '{not json') await restoreRegionCarts(3) expect(stored(REGULAR_KEY)).toEqual([]) expect(stored(FLASH_KEY)).toEqual([]) }) it('CARTQ-27: stash -> clear -> restore round-trips a region switch', async () => { const regular = [makeLine(1, 2, 2, 1849), makeLine(2, 5, 1, 1850)] const flash = [makeLine(1, 8, 3, 0)] seedCart(REGULAR_KEY, regular) seedCart(FLASH_KEY, flash) await stashRegionCarts(1) await clearLocalCart('regular') await clearLocalCart('flash') expect(stored(REGULAR_KEY)).toEqual([]) expect(stored(FLASH_KEY)).toEqual([]) await restoreRegionCarts(1) expect(stored(REGULAR_KEY).map((item) => [item.id, item.skuId, item.slotId, item.quantity])).toEqual([ [1, 2, 1849, 2], [2, 5, 1850, 1], ]) expect(stored(FLASH_KEY).map((item) => [item.id, item.skuId, item.slotId, item.quantity])).toEqual([ [1, 8, 0, 3], ]) }) })