508 lines
17 KiB
TypeScript
508 lines
17 KiB
TypeScript
/* eslint-disable @typescript-eslint/no-explicit-any */
|
|
/**
|
|
* Catalogue section 8.3 — Flash products (`tests/pages/flash-products.test.tsx`,
|
|
* FLASH-01..25).
|
|
*
|
|
* The page is `flash-delivery/(products)/index.tsx` plus `FlashDeliveryProducts`
|
|
* in `components/SlotSpecificView.tsx`. The screen has two independently paged
|
|
* sections: products by tag (tabs mirror the home page order) and products by
|
|
* store ("Shop by Store", one tab per store).
|
|
*/
|
|
import * as React from 'react'
|
|
import { Alert, RefreshControl } from 'react-native'
|
|
import { act, fireEvent, waitFor, within } from '@testing-library/react-native'
|
|
import { QueryClient } from '@tanstack/react-query'
|
|
import { StorageServiceCasual } from 'common-ui'
|
|
|
|
import FlashDeliveryView from '@/app/(drawer)/(tabs)/flash-delivery/(products)/index'
|
|
import { useFlashCartStore } from '@/src/store/flashCartStore'
|
|
import { useFlashNavigationStore } from '@/components/stores/flashNavigationStore'
|
|
import { useCentralSlotStore } from '@/src/store/centralSlotStore'
|
|
|
|
import { flush, renderWithProviders, seedBoot, seedEmptyCatalogue } from '../helpers/test-utils'
|
|
import { resetAllMocks } from '../helpers/reset'
|
|
import { router } from '../mocks/expo-router-mock'
|
|
import { jsonCallsFor, setJsonError, setJsonPending, setJsonResponse } from '../mocks/fetch-json'
|
|
import { __snapshot } from '../mocks/secure-store-mock'
|
|
import {
|
|
AVAILABILITY,
|
|
P_FLASH,
|
|
PRODUCT_AVAILABILITY,
|
|
PRODUCTS_RESPONSE,
|
|
SLOTS,
|
|
TAGS,
|
|
productsCacheUrl,
|
|
storesCacheUrl,
|
|
} from '../fixtures'
|
|
|
|
const FLASH_CART_ROUTE = '/(drawer)/(tabs)/flash-delivery/(cart)/cart'
|
|
const SEARCH_INPUT = 'flash-product-search-input'
|
|
const EMPTY_COPY = 'No 1 Hr Delivery products available.'
|
|
|
|
type AvailabilityEntry = (typeof AVAILABILITY)[number]
|
|
|
|
/** Availability document with per-id overrides (flash/stock flags). */
|
|
function availabilityWith(overrides: Record<number, Partial<AvailabilityEntry>>) {
|
|
return AVAILABILITY.map((entry) =>
|
|
overrides[entry.id] ? { ...entry, ...overrides[entry.id] } : entry
|
|
)
|
|
}
|
|
|
|
/** Drive the flash eligibility map straight into the central slot store. */
|
|
function seedFlashAvailability(entries: any[]) {
|
|
useCentralSlotStore.getState().setSlotsData(SLOTS as any, PRODUCT_AVAILABILITY as any, entries as any)
|
|
}
|
|
|
|
/** Replace the cache's tag document (tabs and per-tag product ids). */
|
|
function seedTags(tags: any[]) {
|
|
setJsonResponse(productsCacheUrl(), { ...PRODUCTS_RESPONSE, tags })
|
|
}
|
|
|
|
async function load() {
|
|
await flush(3)
|
|
}
|
|
|
|
function renderFlash(queryClient?: QueryClient) {
|
|
return renderWithProviders(<FlashDeliveryView />, { auth: false, queryClient, withProductStore: true })
|
|
}
|
|
|
|
type FlashView = ReturnType<typeof renderFlash>
|
|
|
|
/** Product assertions are scoped: both sections can show the same card. */
|
|
const tagSection = (view: FlashView) => within(view.getByTestId('flash-tag-section'))
|
|
const storeSection = (view: FlashView) => within(view.getByTestId('flash-store-section'))
|
|
|
|
/**
|
|
* Flash cart mutations otherwise schedule React Query's 5-minute GC timer, which
|
|
* keeps the jest process alive long after the run has finished.
|
|
*/
|
|
function createMutationQueryClient(): QueryClient {
|
|
return new QueryClient({
|
|
defaultOptions: {
|
|
queries: {
|
|
retry: false,
|
|
gcTime: Infinity,
|
|
staleTime: Infinity,
|
|
refetchOnWindowFocus: false,
|
|
},
|
|
mutations: { retry: false, gcTime: 0 },
|
|
},
|
|
})
|
|
}
|
|
|
|
describe('Flash products (FLASH)', () => {
|
|
beforeEach(() => {
|
|
resetAllMocks()
|
|
seedBoot()
|
|
})
|
|
|
|
it('FLASH-01: a pending products request shows the flash loading state', async () => {
|
|
setJsonPending(productsCacheUrl())
|
|
const { getByText } = renderFlash()
|
|
|
|
await load()
|
|
|
|
expect(getByText('Loading 1 Hr Delivery...')).toBeTruthy()
|
|
})
|
|
|
|
it('FLASH-02: a failed request with no cache shows the flash failure state', async () => {
|
|
seedEmptyCatalogue()
|
|
setJsonError(productsCacheUrl(), new Error('offline'))
|
|
const { getByText } = renderFlash()
|
|
|
|
await load()
|
|
|
|
expect(getByText('Oops!')).toBeTruthy()
|
|
expect(getByText('Failed to load 1 Hr Delivery')).toBeTruthy()
|
|
})
|
|
|
|
it('FLASH-03: the first tag is selected and the tabs keep the cache order', async () => {
|
|
seedFlashAvailability(
|
|
availabilityWith({
|
|
2: { isFlashAvailable: true },
|
|
5: { isFlashAvailable: true },
|
|
})
|
|
)
|
|
const view = renderFlash()
|
|
|
|
await load()
|
|
|
|
expect(view.getByTestId('flash-tag-strip')).toBeTruthy()
|
|
expect(view.getByTestId('flash-tag-tab-1')).toBeTruthy()
|
|
expect(view.getByTestId('flash-tag-tab-2')).toBeTruthy()
|
|
// The "Empty" tag has no eligible product, so it gets no tab.
|
|
expect(view.queryByTestId('flash-tag-tab-3')).toBeNull()
|
|
|
|
// Chicken is tag 1, so its product shows and Vegetables stays out of it.
|
|
expect(tagSection(view).getByText('Chicken Breast')).toBeTruthy()
|
|
expect(tagSection(view).queryByText('Cucumber')).toBeNull()
|
|
})
|
|
|
|
it('FLASH-04: the active tag keeps only flash-available, in-stock products', async () => {
|
|
seedFlashAvailability(
|
|
availabilityWith({
|
|
2: { isFlashAvailable: true },
|
|
6: { isFlashAvailable: true, isOutOfStock: true },
|
|
9: { isFlashAvailable: true },
|
|
})
|
|
)
|
|
const view = renderFlash()
|
|
|
|
await load()
|
|
|
|
const grid = tagSection(view)
|
|
expect(grid.getByText('Chicken Breast')).toBeTruthy()
|
|
expect(grid.getByText('No Image Item')).toBeTruthy()
|
|
// Flash available but out of stock.
|
|
expect(grid.queryByText('Mutton')).toBeNull()
|
|
})
|
|
|
|
it('FLASH-05: selecting another tab swaps the feed to that tag', async () => {
|
|
seedFlashAvailability(
|
|
availabilityWith({
|
|
2: { isFlashAvailable: true },
|
|
5: { isFlashAvailable: true },
|
|
})
|
|
)
|
|
const view = renderFlash()
|
|
|
|
await load()
|
|
expect(tagSection(view).getByText('Chicken Breast')).toBeTruthy()
|
|
|
|
fireEvent.press(view.getByTestId('flash-tag-tab-2'))
|
|
|
|
expect(tagSection(view).getByText('Cucumber')).toBeTruthy()
|
|
expect(tagSection(view).queryByText('Chicken Breast')).toBeNull()
|
|
})
|
|
|
|
it('FLASH-06: the search box filters case-insensitively within the tag', async () => {
|
|
seedFlashAvailability(
|
|
availabilityWith({
|
|
2: { isFlashAvailable: true },
|
|
5: { isFlashAvailable: true },
|
|
})
|
|
)
|
|
const view = renderFlash()
|
|
|
|
await load()
|
|
fireEvent.press(view.getByTestId('flash-tag-tab-2'))
|
|
|
|
fireEvent.changeText(view.getByTestId(SEARCH_INPUT), 'cuc')
|
|
expect(tagSection(view).getByText('Cucumber')).toBeTruthy()
|
|
|
|
fireEvent.changeText(view.getByTestId(SEARCH_INPUT), 'chick')
|
|
expect(tagSection(view).getByText(EMPTY_COPY)).toBeTruthy()
|
|
})
|
|
|
|
it('FLASH-07: a whitespace-only search keeps every product in the tag', async () => {
|
|
seedFlashAvailability(
|
|
availabilityWith({
|
|
2: { isFlashAvailable: true },
|
|
9: { isFlashAvailable: true },
|
|
})
|
|
)
|
|
const view = renderFlash()
|
|
|
|
await load()
|
|
|
|
fireEvent.changeText(view.getByTestId(SEARCH_INPUT), ' ')
|
|
|
|
expect(tagSection(view).getByText('Chicken Breast')).toBeTruthy()
|
|
expect(tagSection(view).getByText('No Image Item')).toBeTruthy()
|
|
})
|
|
|
|
it('FLASH-08: tags and stores with no flash products get no tab', async () => {
|
|
// Only Chicken Breast (tag 1, store 1) is flash-eligible.
|
|
seedFlashAvailability(availabilityWith({ 2: { isFlashAvailable: true } }))
|
|
const view = renderFlash()
|
|
|
|
await load()
|
|
|
|
expect(view.getByTestId('flash-tag-tab-1')).toBeTruthy()
|
|
// Vegetables only sells Cucumber, which is not flash-eligible.
|
|
expect(view.queryByTestId('flash-tag-tab-2')).toBeNull()
|
|
expect(view.queryByTestId('flash-tag-tab-3')).toBeNull()
|
|
// Freshyo Greens has no flash products either.
|
|
expect(view.getByTestId('flash-store-tab-1')).toBeTruthy()
|
|
expect(view.queryByTestId('flash-store-tab-2')).toBeNull()
|
|
})
|
|
|
|
it('FLASH-09: tapping add writes to the flash cart and alerts for 1hr delivery', async () => {
|
|
const alertSpy = jest.spyOn(Alert, 'alert').mockImplementation(() => {})
|
|
seedTags([{ ...TAGS[0], productIds: [8] }])
|
|
seedFlashAvailability(availabilityWith({ 8: { isFlashAvailable: true } }))
|
|
const view = renderFlash(createMutationQueryClient())
|
|
await load()
|
|
|
|
fireEvent.press(tagSection(view).getAllByTestId('add-to-cart-icon')[0])
|
|
|
|
await waitFor(() =>
|
|
expect(JSON.parse(__snapshot().flash_cart_items ?? '[]')).toHaveLength(1)
|
|
)
|
|
const line = JSON.parse(__snapshot().flash_cart_items)[0]
|
|
expect(line.skuId).toBe(8)
|
|
expect(line.quantity).toBe(1)
|
|
expect(line.slotId).toBe(0)
|
|
|
|
await waitFor(() =>
|
|
expect(alertSpy).toHaveBeenCalledWith('Added to Cart', 'Added Paneer for delivery in 1hr')
|
|
)
|
|
alertSpy.mockRestore()
|
|
})
|
|
|
|
it('FLASH-10: tapping a card pushes the flash product-detail route', async () => {
|
|
seedTags([{ ...TAGS[0], productIds: [8] }])
|
|
seedFlashAvailability(availabilityWith({ 8: { isFlashAvailable: true } }))
|
|
const view = renderFlash()
|
|
await load()
|
|
|
|
fireEvent.press(tagSection(view).getAllByTestId('product-card')[0])
|
|
|
|
expect(router.push).toHaveBeenCalledWith(
|
|
'/(drawer)/(tabs)/flash-delivery/product-detail/8'
|
|
)
|
|
})
|
|
|
|
it('FLASH-11: the card uses the flash price when present and the regular one otherwise', async () => {
|
|
seedTags([{ ...TAGS[0], productIds: [5, 8] }])
|
|
seedFlashAvailability(
|
|
availabilityWith({ 5: { isFlashAvailable: true }, 8: { isFlashAvailable: true } })
|
|
)
|
|
const view = renderFlash()
|
|
|
|
await load()
|
|
|
|
// P_FLASH (8): price 90, flashPrice 75. P_CUCUMBER (5): price 15, no flash price.
|
|
expect(tagSection(view).getByText('₹75')).toBeTruthy()
|
|
expect(tagSection(view).getByText('₹15')).toBeTruthy()
|
|
})
|
|
|
|
it('FLASH-12: pull to refresh refetches the products document', async () => {
|
|
const view = renderFlash()
|
|
await load()
|
|
const before = jsonCallsFor(productsCacheUrl()).length
|
|
|
|
await act(async () => {
|
|
view.UNSAFE_getAllByType(RefreshControl)[0].props.onRefresh()
|
|
})
|
|
await flush(3)
|
|
|
|
expect(jsonCallsFor(productsCacheUrl()).length).toBeGreaterThan(before)
|
|
})
|
|
|
|
it('FLASH-13: without tags the strip is hidden and every flash product shows', async () => {
|
|
seedTags([])
|
|
seedFlashAvailability(availabilityWith({ 8: { isFlashAvailable: true } }))
|
|
const view = renderFlash()
|
|
|
|
await load()
|
|
|
|
expect(view.queryByTestId('flash-tag-strip')).toBeNull()
|
|
expect(tagSection(view).getByText('Paneer')).toBeTruthy()
|
|
})
|
|
|
|
it('FLASH-14: a queued flash product is auto-added once and alerts after 300ms', async () => {
|
|
const alertSpy = jest.spyOn(Alert, 'alert').mockImplementation(() => {})
|
|
useFlashCartStore.getState().setAddedFlashProduct({ productId: 8, product: P_FLASH })
|
|
|
|
renderFlash(createMutationQueryClient())
|
|
await load()
|
|
|
|
await waitFor(() => expect(useFlashCartStore.getState().addedFlashProduct).toBeNull())
|
|
expect(JSON.parse(__snapshot().flash_cart_items ?? '[]')).toHaveLength(1)
|
|
expect(alertSpy).not.toHaveBeenCalled()
|
|
|
|
await waitFor(
|
|
() =>
|
|
expect(alertSpy).toHaveBeenCalledWith(
|
|
'Added to Cart',
|
|
'Added Paneer for delivery in 1hr'
|
|
),
|
|
{ timeout: 2000 }
|
|
)
|
|
expect(alertSpy).toHaveBeenCalledTimes(1)
|
|
alertSpy.mockRestore()
|
|
})
|
|
|
|
it('FLASH-15: a failed auto-add keeps the dialog product and skips the alert', async () => {
|
|
const alertSpy = jest.spyOn(Alert, 'alert').mockImplementation(() => {})
|
|
// Fail only the flash cart write: the essential-consts cache write is
|
|
// fire-and-forget and would otherwise surface as an unhandled rejection.
|
|
const originalSetItem = StorageServiceCasual.setItem
|
|
const setItem = jest
|
|
.spyOn(StorageServiceCasual, 'setItem')
|
|
.mockImplementation(async (key: string, value: string) => {
|
|
if (key === 'flash_cart_items') throw new Error('boom')
|
|
return originalSetItem.call(StorageServiceCasual, key, value)
|
|
})
|
|
useFlashCartStore.getState().setAddedFlashProduct({ productId: 8, product: P_FLASH })
|
|
|
|
renderFlash(createMutationQueryClient())
|
|
await load()
|
|
|
|
expect(useFlashCartStore.getState().addedFlashProduct).not.toBeNull()
|
|
expect(alertSpy).not.toHaveBeenCalled()
|
|
setItem.mockRestore()
|
|
alertSpy.mockRestore()
|
|
})
|
|
|
|
it('FLASH-16: focusing with shouldNavigateToCart resets the flag and pushes the flash cart', async () => {
|
|
useFlashNavigationStore.setState({ shouldNavigateToCart: true })
|
|
|
|
renderFlash()
|
|
await load()
|
|
|
|
expect(useFlashNavigationStore.getState().shouldNavigateToCart).toBe(false)
|
|
expect(router.push).toHaveBeenCalledWith(FLASH_CART_ROUTE)
|
|
})
|
|
|
|
it('FLASH-17: without shouldNavigateToCart the page does not push the cart', async () => {
|
|
renderFlash()
|
|
await load()
|
|
|
|
expect(router.push).not.toHaveBeenCalledWith(FLASH_CART_ROUTE)
|
|
})
|
|
|
|
it('FLASH-18: switching tags stays client-side and never rewrites the route', async () => {
|
|
seedFlashAvailability(
|
|
availabilityWith({
|
|
2: { isFlashAvailable: true },
|
|
5: { isFlashAvailable: true },
|
|
})
|
|
)
|
|
const view = renderFlash()
|
|
await load()
|
|
|
|
fireEvent.press(view.getByTestId('flash-tag-tab-2'))
|
|
|
|
expect(router.replace).not.toHaveBeenCalled()
|
|
expect(router.push).not.toHaveBeenCalled()
|
|
})
|
|
|
|
it('FLASH-19: nine products render first and Show More reveals the rest', async () => {
|
|
const generated = Array.from({ length: 12 }, (_, index) => ({
|
|
...P_FLASH,
|
|
id: 800 + index,
|
|
name: `Flash ${index + 1}`,
|
|
}))
|
|
setJsonResponse(productsCacheUrl(), {
|
|
products: generated,
|
|
count: generated.length,
|
|
tags: [{ ...TAGS[0], productIds: generated.map((product) => product.id) }],
|
|
})
|
|
// The generated ids need their own productAvailability rows so the central
|
|
// slot store builds productSlotsMap entries for them.
|
|
useCentralSlotStore.getState().setSlotsData(
|
|
SLOTS as any,
|
|
generated.map((product) => ({ id: product.id })) as any,
|
|
generated.map((product) => ({
|
|
id: product.id,
|
|
price: 90,
|
|
marketPrice: 100,
|
|
flashPrice: 75,
|
|
isFlashAvailable: true,
|
|
isOutOfStock: false,
|
|
isSuspended: false,
|
|
isOffer: false,
|
|
})) as any
|
|
)
|
|
|
|
const view = renderFlash()
|
|
await load()
|
|
|
|
expect(tagSection(view).getAllByTestId('product-card')).toHaveLength(9)
|
|
|
|
fireEvent.press(view.getByTestId('flash-products-show-more'))
|
|
|
|
expect(tagSection(view).getAllByTestId('product-card')).toHaveLength(12)
|
|
expect(view.queryByTestId('flash-products-show-more')).toBeNull()
|
|
})
|
|
|
|
it('FLASH-20: Shop by Store shows a tab only for stores with flash products', async () => {
|
|
seedFlashAvailability(
|
|
availabilityWith({
|
|
2: { isFlashAvailable: true },
|
|
5: { isFlashAvailable: true },
|
|
})
|
|
)
|
|
const view = renderFlash()
|
|
|
|
await load()
|
|
|
|
expect(view.getByText('Shop by Store')).toBeTruthy()
|
|
expect(view.getByTestId('flash-store-strip')).toBeTruthy()
|
|
expect(view.getByTestId('flash-store-tab-1')).toBeTruthy()
|
|
// Freshyo Greens only sells Cucumber, which is not flash-eligible.
|
|
expect(view.queryByTestId('flash-store-tab-2')).toBeNull()
|
|
|
|
// Both fixtures belong to store 1.
|
|
expect(storeSection(view).getByText('Chicken Breast')).toBeTruthy()
|
|
expect(storeSection(view).getByText('Cucumber')).toBeTruthy()
|
|
})
|
|
|
|
it('FLASH-21: a store with flash products gets its own tab and grid', async () => {
|
|
setJsonResponse(productsCacheUrl(), {
|
|
...PRODUCTS_RESPONSE,
|
|
products: PRODUCTS_RESPONSE.products.map((product) =>
|
|
product.id === 5 ? { ...product, storeId: 2 } : product
|
|
),
|
|
})
|
|
seedFlashAvailability(
|
|
availabilityWith({
|
|
2: { isFlashAvailable: true },
|
|
5: { isFlashAvailable: true },
|
|
})
|
|
)
|
|
const view = renderFlash()
|
|
|
|
await load()
|
|
fireEvent.press(view.getByTestId('flash-store-tab-2'))
|
|
|
|
expect(storeSection(view).getByText('Cucumber')).toBeTruthy()
|
|
expect(storeSection(view).queryByText('Chicken Breast')).toBeNull()
|
|
})
|
|
|
|
it('FLASH-22: with no stores the Shop by Store section is hidden', async () => {
|
|
setJsonResponse(storesCacheUrl(), { stores: [] })
|
|
seedFlashAvailability(availabilityWith({ 2: { isFlashAvailable: true } }))
|
|
const view = renderFlash()
|
|
|
|
await load()
|
|
|
|
expect(view.queryByText('Shop by Store')).toBeNull()
|
|
expect(view.queryByTestId('flash-store-strip')).toBeNull()
|
|
// The tag section still renders.
|
|
expect(tagSection(view).getByText('Chicken Breast')).toBeTruthy()
|
|
})
|
|
|
|
it('FLASH-24: a background refetch leaves the pull-to-refresh spinner idle', async () => {
|
|
const view = renderFlash()
|
|
await load()
|
|
|
|
const control = () => view.UNSAFE_getAllByType(RefreshControl)[0]
|
|
expect(control().props.refreshing).toBe(false)
|
|
|
|
// Something else refetches the catalogue (remount after the stale window,
|
|
// an invalidation, a version bump). It must not drive the user's control.
|
|
setJsonPending(productsCacheUrl())
|
|
await act(async () => {
|
|
void view.queryClient.refetchQueries({ queryKey: ['all-products'] })
|
|
})
|
|
await flush(2)
|
|
|
|
expect(control().props.refreshing).toBe(false)
|
|
})
|
|
|
|
it('FLASH-25: pulling down keeps the spinner up until the refresh settles', async () => {
|
|
const view = renderFlash()
|
|
await load()
|
|
|
|
setJsonPending(productsCacheUrl())
|
|
await act(async () => {
|
|
void view.UNSAFE_getAllByType(RefreshControl)[0].props.onRefresh()
|
|
})
|
|
await flush(1)
|
|
|
|
expect(view.UNSAFE_getAllByType(RefreshControl)[0].props.refreshing).toBe(true)
|
|
})
|
|
})
|