/** * Cart storage mechanics (hooks/cart-query-hooks.tsx) — the local cart is a * JSON blob in StorageServiceCasual, so every write is read-modify-write. * * Covers the money-affecting edge cases the screen tests cannot reach: live * repricing, zero quantities, unknown products, concurrent writes and * useReconcileCartSlots' slot repair. Known bugs are pinned — see * tests/KNOWN-GAPS.md. */ import React from 'react' import { renderHook, waitFor } from '@testing-library/react-native' import { StorageServiceCasual } from 'common-ui/src/services/StorageServiceCasual' import { useAddToCart, useGetCart, useReconcileCartSlots, useUpdateCartItem, clearLocalCart, } from '@/hooks/cart-query-hooks' import { useCentralProductStore } from '@/src/store/centralProductStore' import { useCentralSlotStore } from '@/src/store/centralSlotStore' import { resetStorage } from '../mocks/api' import { Providers } from '../helpers/render' const SKU_IN_STOCK = 2 // Chicken Breast 500 g, price 215 const SKU_OTHER = 5 // Cucumber(Kheera), price 15 const SLOT_A = 1849 const SLOT_B = 1847 const product = (id: number, price: number, over: Record = {}) => ({ id, name: `Product ${id}`, price, marketPrice: price + 20, flashPrice: null, incrementStep: 1, images: [], productQuantity: 1, unitNotation: 'pc', isComboOnly: false, ...over, }) const slotInfo = (slots: number[], over: Record = {}) => ({ slots: slots.map((id) => ({ id, deliveryTime: new Date(Date.now() + 3 * 3600_000).toISOString(), freezeTime: new Date(Date.now() + 2 * 3600_000).toISOString(), products: [], })), isOutOfStock: false, isFlashAvailable: false, isSuspended: false, ...over, }) /** Point the central stores at a known product/slot universe. */ const setCentral = ( products: Record, slotMap: Record, isSlotsLoaded = true ) => { useCentralProductStore.setState({ products: Object.values(products) as never, productsById: products as never, }) useCentralSlotStore.setState({ slots: [], productSlotsMap: slotMap as never, isSlotsLoaded, }) } const readCart = async (key = 'cart_items') => { const raw = await StorageServiceCasual.getItem(key) return raw ? JSON.parse(raw) : [] } const seedCart = async (items: unknown[], key = 'cart_items') => StorageServiceCasual.setItem(key, JSON.stringify(items)) const line = (over: Record = {}) => ({ id: 1, skuId: SKU_IN_STOCK, quantity: 1, slotId: SLOT_A, addedAt: new Date().toISOString(), ...over, }) const wrapper = ({ children }: { children?: React.ReactNode }) => ( {children} ) const renderGetCart = (cartType: 'regular' | 'flash' = 'regular') => renderHook(() => useGetCart({}, cartType), { wrapper }) describe('cart storage', () => { beforeEach(async () => { await resetStorage() useCentralProductStore.setState({ products: [], productsById: {} }) useCentralSlotStore.setState({ slots: [], productSlotsMap: {}, isSlotsLoaded: false }) }) it('prices a line from the live product record, not the price at add time', async () => { setCentral( { [SKU_IN_STOCK]: product(SKU_IN_STOCK, 215) }, { [SKU_IN_STOCK]: slotInfo([SLOT_A]) } ) await seedCart([line()]) const first = renderGetCart() await waitFor(() => expect(first.result.current.totalPrice).toBe(215)) first.unmount() // The catalog reprices the SKU underneath the cart; storage is untouched. setCentral( { [SKU_IN_STOCK]: product(SKU_IN_STOCK, 300) }, { [SKU_IN_STOCK]: slotInfo([SLOT_A]) } ) expect(await readCart()).toEqual([expect.objectContaining({ quantity: 1 })]) const second = renderGetCart() await waitFor(() => expect(second.result.current.totalPrice).toBe(300)) }) it('multiplies price by quantity', async () => { setCentral( { [SKU_IN_STOCK]: product(SKU_IN_STOCK, 215) }, { [SKU_IN_STOCK]: slotInfo([SLOT_A]) } ) await seedCart([line({ quantity: 3 })]) const { result } = renderGetCart() await waitFor(() => expect(result.current.totalPrice).toBe(645)) expect(result.current.cartItems).toHaveLength(1) expect(result.current.totalItems).toBe(1) }) /** * KNOWN GAP: updateLocalCartItem writes the quantity through with no zero or * negative guard, so a 0-qty line stays in storage and keeps counting as a * cart row. The UI always routes deletion through removeFromCart, so this is * only reachable from a direct call. */ it('persists a zero quantity with no guard', async () => { setCentral( { [SKU_IN_STOCK]: product(SKU_IN_STOCK, 215) }, { [SKU_IN_STOCK]: slotInfo([SLOT_A]) } ) await seedCart([line()]) const { result } = renderHook(() => useUpdateCartItem({ showSuccessAlert: false, showErrorAlert: false }), { wrapper, }) await result.current.updateCartItemAsync(1, 0) expect(await readCart()).toEqual([ expect.objectContaining({ id: 1, skuId: SKU_IN_STOCK, quantity: 0 }), ]) }) /** * KNOWN GAP: useGetCart drops any line whose skuId is missing from * productsById or productSlotsMap. A cart written while one product was * absent from the cache renders fewer rows than storage holds, and the * dropped lines are never surfaced to the user. */ it('drops lines whose product is missing from the central stores', async () => { setCentral( { [SKU_IN_STOCK]: product(SKU_IN_STOCK, 215) }, { [SKU_IN_STOCK]: slotInfo([SLOT_A]) } ) await seedCart([line({ id: 1 }), line({ id: 2, skuId: SKU_OTHER })]) const { result } = renderGetCart() await waitFor(() => expect(result.current.cartItems).toHaveLength(1)) expect(result.current.cartItems[0].skuId).toBe(SKU_IN_STOCK) // The line is gone from the derived view but still on disk. expect(await readCart()).toHaveLength(2) }) it('ignores lines whose product has no slot entry', async () => { setCentral({ [SKU_IN_STOCK]: product(SKU_IN_STOCK, 215) }, {}) await seedCart([line()]) const { result } = renderGetCart() await waitFor(() => expect(result.current.isLoading).toBe(false)) expect(result.current.cartItems).toHaveLength(0) }) /** * KNOWN GAP: addToLocalCart is read-modify-write with no locking, so two adds * issued in the same tick both read the pre-add cart and the second write * erases the first. Adding two different SKUs back-to-back yields one line. */ it('loses the first of two concurrent adds', async () => { setCentral( { [SKU_IN_STOCK]: product(SKU_IN_STOCK, 215), [SKU_OTHER]: product(SKU_OTHER, 15), }, { [SKU_IN_STOCK]: slotInfo([SLOT_A]), [SKU_OTHER]: slotInfo([SLOT_A]), } ) const { result } = renderHook( () => useAddToCart({ showSuccessAlert: false, showErrorAlert: false }), { wrapper } ) // Neither is awaited before the second is fired: both read the empty cart. const first = result.current.addToCartAsync(SKU_IN_STOCK, 1, SLOT_A) const second = result.current.addToCartAsync(SKU_OTHER, 1, SLOT_A) await Promise.all([first, second]) const stored = await readCart() expect(stored).toHaveLength(1) expect(stored[0].skuId).toBe(SKU_OTHER) }) it('keeps the flash and regular carts in separate storage keys', async () => { setCentral( { [SKU_IN_STOCK]: product(SKU_IN_STOCK, 215) }, { [SKU_IN_STOCK]: slotInfo([SLOT_A]) } ) await seedCart([line()], 'cart_items') await seedCart([line({ id: 1, slotId: 0 })], 'flash_cart_items') const regular = renderGetCart('regular') const flash = renderGetCart('flash') await waitFor(() => expect(regular.result.current.cartItems).toHaveLength(1)) await waitFor(() => expect(flash.result.current.cartItems).toHaveLength(1)) expect(regular.result.current.cartItems[0].slotId).toBe(SLOT_A) expect(flash.result.current.cartItems[0].slotId).toBe(0) await clearLocalCart('regular') expect(await readCart('cart_items')).toEqual([]) expect(await readCart('flash_cart_items')).toHaveLength(1) }) }) describe('useReconcileCartSlots', () => { beforeEach(async () => { await resetStorage() }) it('re-points a line at the nearest slot when its stored slot is gone', async () => { setCentral( { [SKU_IN_STOCK]: product(SKU_IN_STOCK, 215) }, { [SKU_IN_STOCK]: slotInfo([SLOT_B]) } ) await seedCart([line({ slotId: 9999 })]) renderHook(() => useReconcileCartSlots(), { wrapper }) await waitFor(async () => expect(await readCart()).toHaveLength(1)) expect((await readCart())[0].slotId).toBe(SLOT_B) }) it('leaves a line alone when its stored slot is still valid', async () => { setCentral( { [SKU_IN_STOCK]: product(SKU_IN_STOCK, 215) }, { [SKU_IN_STOCK]: slotInfo([SLOT_A, SLOT_B]) } ) await seedCart([line({ slotId: SLOT_B })]) renderHook(() => useReconcileCartSlots(), { wrapper }) await waitFor(async () => expect(await readCart()).toHaveLength(1)) expect((await readCart())[0].slotId).toBe(SLOT_B) }) /** * KNOWN GAP: when a product has no slots at all, the line is neither kept nor * re-slotted — it is dropped and the shortened cart is persisted. The item * vanishes from the user's cart with no notice. */ it('drops a line whose product has no slots and persists the shortened cart', async () => { setCentral( { [SKU_IN_STOCK]: product(SKU_IN_STOCK, 215), [SKU_OTHER]: product(SKU_OTHER, 15), }, { [SKU_IN_STOCK]: slotInfo([SLOT_B]), [SKU_OTHER]: slotInfo([]), } ) await seedCart([line({ id: 1, slotId: 9999 }), line({ id: 2, skuId: SKU_OTHER, slotId: 9999 })]) renderHook(() => useReconcileCartSlots(), { wrapper }) await waitFor(async () => expect(await readCart()).toHaveLength(1)) const stored = await readCart() expect(stored[0].id).toBe(1) expect(stored[0].slotId).toBe(SLOT_B) // SKU_OTHER is gone from storage, not just from the derived view. expect(stored.some((i: { skuId: number }) => i.skuId === SKU_OTHER)).toBe(false) }) /** * KNOWN GAP: `hasRun` is a ref set on the first pass, so a later slot reload * never re-reconciles. A line left pointing at a slot that has since expired * is never repaired. */ it('reconciles once per mount and ignores later slot changes', async () => { setCentral( { [SKU_IN_STOCK]: product(SKU_IN_STOCK, 215) }, { [SKU_IN_STOCK]: slotInfo([SLOT_B]) } ) await seedCart([line({ slotId: 9999 })]) const { rerender } = renderHook(() => useReconcileCartSlots(), { wrapper }) await waitFor(async () => expect((await readCart())[0].slotId).toBe(SLOT_B)) // The cart is left pointing at a stale slot again, then slots change. await seedCart([line({ id: 1, slotId: 7777 })]) setCentral( { [SKU_IN_STOCK]: product(SKU_IN_STOCK, 215) }, { [SKU_IN_STOCK]: slotInfo([SLOT_A]) } ) rerender(undefined) await waitFor(async () => expect(await readCart()).toHaveLength(1)) expect((await readCart())[0].slotId).toBe(7777) }) })