760 lines
25 KiB
TypeScript
760 lines
25 KiB
TypeScript
/* eslint-disable @typescript-eslint/no-explicit-any */
|
|
/**
|
|
* Section 21 — My orders list (`tests/pages/my-orders.test.tsx`, ORDERS-01..35).
|
|
*
|
|
* The page keeps its own infinite-scroll state (`allOrders` / `currentPage`) and
|
|
* folds every `getOrders({ page, pageSize })` response into it. It is not
|
|
* filtered by the browsing region: the region name is a per-card pill.
|
|
*
|
|
* Rows marked "(current)" pin a documented behaviour instead of an ideal one.
|
|
*/
|
|
import * as React from 'react'
|
|
import { DeviceEventEmitter, RefreshControl, StyleSheet } from 'react-native'
|
|
import { act, fireEvent, waitFor } from '@testing-library/react-native'
|
|
import dayjs from 'dayjs'
|
|
import { REFRESH_EVENT } from 'common-ui/src/lib/const-strs'
|
|
|
|
import MyOrders from '@/app/(drawer)/(tabs)/me/my-orders/index'
|
|
|
|
import { flush, renderWithProviders } from '../helpers/test-utils'
|
|
import { resetAllMocks } from '../helpers/reset'
|
|
import { router } from '../mocks/expo-router-mock'
|
|
import {
|
|
lastProcedureInput,
|
|
procedureQueryCalls,
|
|
setProcedure,
|
|
} from '../mocks/trpc-client'
|
|
import { O1 } from '../fixtures'
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
/* Focus listeners (useMarkDataFetchers) */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
const mockFocusCallbacks = new Set<() => void>()
|
|
|
|
jest.mock('@react-navigation/native', () => {
|
|
const React = require('react')
|
|
const actual = jest.requireActual(__dirname + '/../mocks/react-navigation-mock')
|
|
return {
|
|
...actual,
|
|
useFocusEffect: (callback: () => void | (() => void)) => {
|
|
React.useEffect(() => {
|
|
mockFocusCallbacks.add(callback)
|
|
const cleanup = callback()
|
|
return () => {
|
|
mockFocusCallbacks.delete(callback)
|
|
if (typeof cleanup === 'function') cleanup()
|
|
}
|
|
// eslint-disable-next-line react-hooks/exhaustive-deps
|
|
}, [callback])
|
|
},
|
|
}
|
|
})
|
|
|
|
async function emitFocus() {
|
|
await act(async () => {
|
|
Array.from(mockFocusCallbacks).forEach((callback) => callback())
|
|
})
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
/* Builders */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
const ORDER_DATE = '2026-03-14T10:30:00.000Z'
|
|
const DELIVERY_DATE = '2026-03-14T12:30:00.000Z'
|
|
|
|
function item(overrides: any = {}) {
|
|
return {
|
|
id: 1,
|
|
skuId: 2,
|
|
productName: 'Chicken Breast',
|
|
name: 'Chicken Breast',
|
|
quantity: 2,
|
|
unit: '500g',
|
|
unitNotation: '500g',
|
|
price: 215,
|
|
amount: 430,
|
|
image: 'chicken.jpg',
|
|
isPackaged: false,
|
|
isVerified: false,
|
|
...overrides,
|
|
}
|
|
}
|
|
|
|
function ord(overrides: any = {}) {
|
|
return {
|
|
...O1,
|
|
items: [item()],
|
|
orderDate: ORDER_DATE,
|
|
createdAt: ORDER_DATE,
|
|
deliveryDate: DELIVERY_DATE,
|
|
...overrides,
|
|
}
|
|
}
|
|
|
|
/**
|
|
* A page-aware `getOrders` implementation.
|
|
*
|
|
* The payload objects are cached per page: the trpc mock recomputes `data` on
|
|
* every render, and a fresh object identity each time would re-trigger the
|
|
* page's `useEffect(() => setAllOrders(...), [ordersData])` forever.
|
|
*/
|
|
function setOrderPages(pages: Record<number, any[]>, totalPages: number | undefined) {
|
|
const cache = new Map<number, any>()
|
|
setProcedure('user.order.getOrders', {
|
|
impl: (input: any) => {
|
|
const page = input?.page ?? 1
|
|
if (!cache.has(page)) {
|
|
cache.set(page, {
|
|
data: pages[page] ?? [],
|
|
pagination: totalPages === undefined ? undefined : { totalPages },
|
|
})
|
|
}
|
|
return cache.get(page)
|
|
},
|
|
})
|
|
}
|
|
|
|
function seedOrders(orders: any[] = [ord()]) {
|
|
setProcedure('user.order.getOrders', {
|
|
data: { data: orders, pagination: { totalPages: 1, total: orders.length, page: 1, pageSize: 10 } },
|
|
})
|
|
}
|
|
|
|
function renderPage() {
|
|
return renderWithProviders(<MyOrders />, { auth: 'out' })
|
|
}
|
|
|
|
async function load() {
|
|
await flush(3)
|
|
}
|
|
|
|
function cards(view: ReturnType<typeof renderPage>) {
|
|
return view.queryAllByTestId(/^order-card-/)
|
|
}
|
|
|
|
async function pullToRefresh(view: ReturnType<typeof renderPage>) {
|
|
const [refreshControl] = view.UNSAFE_getAllByType(RefreshControl)
|
|
await act(async () => {
|
|
fireEvent(refreshControl, 'refresh')
|
|
})
|
|
await flush(3)
|
|
}
|
|
|
|
/**
|
|
* Emit the manual-refresh event the way `RefreshProvider.refreshAll` does: clear
|
|
* the query cache, then notify the screen. Clearing is what makes the reset
|
|
* page-1 query hit the network again (the test client's `staleTime` is Infinity).
|
|
*/
|
|
async function manualRefresh(view: ReturnType<typeof renderPage>) {
|
|
view.queryClient.clear()
|
|
await act(async () => {
|
|
DeviceEventEmitter.emit(REFRESH_EVENT)
|
|
})
|
|
await flush(3)
|
|
}
|
|
|
|
async function endReached(view: ReturnType<typeof renderPage>) {
|
|
await act(async () => {
|
|
fireEvent(view.getByTestId('orders-list'), 'onEndReached')
|
|
})
|
|
await flush(3)
|
|
}
|
|
|
|
function pageCalls(page: number) {
|
|
return procedureQueryCalls('user.order.getOrders').filter((input) => input?.page === page)
|
|
}
|
|
|
|
/**
|
|
* Requests for a page as they landed on the network, including `mode: 'pending'`
|
|
* batches (the registry only records a call once a batch is answered).
|
|
*/
|
|
function pageNetworkRequests(page: number) {
|
|
return ((global as any).fetch as jest.Mock).mock.calls.filter(([input]: any[]) => {
|
|
const url = typeof input === 'string' ? input : input?.url
|
|
if (typeof url !== 'string' || !url.includes('/api/trpc/user.order.getOrders')) return false
|
|
const raw = new URL(url).searchParams.get('input')
|
|
if (!raw) return false
|
|
return Object.values(JSON.parse(raw) as Record<string, any>).some(
|
|
(entry) => entry?.page === page
|
|
)
|
|
})
|
|
}
|
|
|
|
function styleColor(testInstance: any) {
|
|
return StyleSheet.flatten(testInstance.props.style)?.color
|
|
}
|
|
|
|
/* -------------------------------------------------------------------------- */
|
|
/* Tests */
|
|
/* -------------------------------------------------------------------------- */
|
|
|
|
describe('My orders list (ORDERS)', () => {
|
|
beforeEach(() => {
|
|
resetAllMocks()
|
|
mockFocusCallbacks.clear()
|
|
})
|
|
|
|
it('ORDERS-01: page 1 pending shows "Loading your orders..."', async () => {
|
|
setProcedure('user.order.getOrders', { mode: 'pending' })
|
|
const view = renderPage()
|
|
|
|
await flush(2)
|
|
|
|
expect(view.getByTestId('orders-loading')).toBeTruthy()
|
|
expect(view.getByText('Loading your orders...')).toBeTruthy()
|
|
})
|
|
|
|
it('ORDERS-02: a failing page 1 shows the full error screen and a Retry button', async () => {
|
|
setProcedure('user.order.getOrders', { mode: 'error', error: new Error('offline') })
|
|
const view = renderPage()
|
|
|
|
await flush(2)
|
|
|
|
expect(view.getByTestId('orders-error')).toBeTruthy()
|
|
expect(view.getByText('Unable to load orders')).toBeTruthy()
|
|
|
|
// Retry calls the hook's real `refetch`, which sends a second request for
|
|
// the same page. The fixture still fails, so the error screen stays.
|
|
fireEvent.press(view.getByTestId('orders-retry'))
|
|
await flush(2)
|
|
|
|
expect(view.getByText('Unable to load orders')).toBeTruthy()
|
|
expect(procedureQueryCalls('user.order.getOrders')).toHaveLength(2)
|
|
expect(pageCalls(1)).toHaveLength(2)
|
|
})
|
|
|
|
it('ORDERS-03: an empty page shows "No orders yet" and Start Shopping goes home', async () => {
|
|
setProcedure('user.order.getOrders', { data: { data: [], pagination: { totalPages: 0 } } })
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
|
|
expect(view.getByTestId('orders-empty')).toBeTruthy()
|
|
expect(view.getByText('No orders yet')).toBeTruthy()
|
|
|
|
fireEvent.press(view.getByTestId('orders-start-shopping'))
|
|
|
|
expect(router.push).toHaveBeenCalledWith('/(drawer)/(tabs)/home')
|
|
})
|
|
|
|
it('ORDERS-04: one order shows the id, item summary, amount, delivery status and placed date', async () => {
|
|
seedOrders([ord({ orderId: 'ORD-1001', id: 1001, totalAmount: 445, orderAmount: 445 })])
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
|
|
expect(view.getByText('#ORD-1001')).toBeTruthy()
|
|
expect(view.getByText('Chicken Breast')).toBeTruthy()
|
|
expect(view.getByText('Unit Price: ₹215')).toBeTruthy()
|
|
expect(view.getByText('₹445')).toBeTruthy()
|
|
expect(view.getByText('Confirmed')).toBeTruthy()
|
|
expect(view.getByText(dayjs(ORDER_DATE).format('DD MMM YYYY, hh:mm A'))).toBeTruthy()
|
|
})
|
|
|
|
it('ORDERS-05: the item count is singular for one item and plural otherwise', async () => {
|
|
seedOrders([
|
|
ord({ orderId: 'ORD-1', id: 1, items: [item()] }),
|
|
ord({ orderId: 'ORD-2', id: 2, items: [item(), item({ id: 2, skuId: 5, productName: 'Cucumber' })] }),
|
|
])
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
|
|
expect(view.getByText('1 Item')).toBeTruthy()
|
|
expect(view.getByText('2 Items')).toBeTruthy()
|
|
})
|
|
|
|
it('ORDERS-06: more than two items shows two rows plus the remaining count', async () => {
|
|
seedOrders([
|
|
ord({
|
|
orderId: 'ORD-3',
|
|
id: 3,
|
|
items: [
|
|
item(),
|
|
item({ id: 2, productName: 'Cucumber' }),
|
|
item({ id: 3, productName: 'Paneer' }),
|
|
],
|
|
}),
|
|
])
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
|
|
expect(view.getByText('Chicken Breast')).toBeTruthy()
|
|
expect(view.getByText('Cucumber')).toBeTruthy()
|
|
expect(view.queryByText('Paneer')).toBeNull()
|
|
expect(view.getByText('+ 1 more item in this order')).toBeTruthy()
|
|
})
|
|
|
|
it('ORDERS-07: tapping the more-items row routes to the order detail', async () => {
|
|
seedOrders([
|
|
ord({
|
|
orderId: 'ORD-4',
|
|
id: 4,
|
|
items: [item(), item({ id: 2 }), item({ id: 3 }), item({ id: 4 })],
|
|
}),
|
|
])
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
fireEvent.press(view.getByTestId('order-more-items-ORD-4'))
|
|
|
|
expect(router.push).toHaveBeenCalledWith('/(drawer)/(tabs)/me/my-orders/4')
|
|
})
|
|
|
|
it('ORDERS-08: tapping the card routes to the order detail', async () => {
|
|
seedOrders([ord({ orderId: 'ORD-5', id: 5 })])
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
fireEvent.press(view.getByTestId('order-card-ORD-5'))
|
|
|
|
expect(router.push).toHaveBeenCalledWith('/(drawer)/(tabs)/me/my-orders/5')
|
|
})
|
|
|
|
it('ORDERS-09: a scheduled delivery shows its slot as "DD MMM, hh:mm A - hh:mm A"', async () => {
|
|
seedOrders([ord({ deliveryDate: DELIVERY_DATE })])
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
|
|
const start = dayjs(DELIVERY_DATE)
|
|
const expected = `${start.format('DD MMM, hh:mm A')} - ${start.add(1, 'hour').format('hh:mm A')}`
|
|
expect(view.getByText('Delivery Time')).toBeTruthy()
|
|
expect(view.getByText(expected)).toBeTruthy()
|
|
})
|
|
|
|
it('ORDERS-10: a flash order shows "1 Hr Delivery", created +30m and the FLASH badge', async () => {
|
|
seedOrders([ord({ isFlashDelivery: true, deliveryType: 'flash' })])
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
|
|
expect(view.getByText('1 Hr Delivery')).toBeTruthy()
|
|
expect(view.getByText('FLASH')).toBeTruthy()
|
|
expect(view.getByText(dayjs(ORDER_DATE).add(30, 'minutes').format('DD MMM, hh:mm A'))).toBeTruthy()
|
|
})
|
|
|
|
it('ORDERS-11: flash without createdAt falls back to orderDate for the estimate', async () => {
|
|
seedOrders([ord({ isFlashDelivery: true, createdAt: null, orderDate: ORDER_DATE })])
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
|
|
expect(view.getByText(dayjs(ORDER_DATE).add(30, 'minutes').format('DD MMM, hh:mm A'))).toBeTruthy()
|
|
})
|
|
|
|
it('ORDERS-12: regionName renders as a region pill', async () => {
|
|
seedOrders([ord({ regionName: 'Hyderabad' })])
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
|
|
expect(view.getByText('Hyderabad')).toBeTruthy()
|
|
})
|
|
|
|
it('ORDERS-13: no regionName renders no pill', async () => {
|
|
seedOrders([ord({ regionName: null })])
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
|
|
expect(view.getByText('#ORD-1001')).toBeTruthy()
|
|
expect(view.queryByText('Mahabubnagar')).toBeNull()
|
|
})
|
|
|
|
it('ORDERS-14: a cancelled order shows the cancelled chip and the cancel reason', async () => {
|
|
seedOrders([
|
|
ord({
|
|
orderStatus: 'cancelled',
|
|
deliveryStatus: 'cancelled',
|
|
cancelReason: 'Changed my mind',
|
|
}),
|
|
])
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
|
|
// The header chip uses the mapped "Cancelled" label; the delivery line
|
|
// passes the raw status through `orderStatusManipulator` (unchanged).
|
|
expect(view.getByText('Cancelled')).toBeTruthy()
|
|
expect(view.getByTestId('order-delivery-status-ORD-1001')).toHaveTextContent('cancelled')
|
|
expect(view.getByTestId('order-status-chip-ORD-1001')).toBeTruthy()
|
|
expect(view.getByText('Cancellation Details')).toBeTruthy()
|
|
expect(view.getByText('Changed my mind')).toBeTruthy()
|
|
})
|
|
|
|
it('ORDERS-15: pending delivery is displayed as "Confirmed" through the manipulator', async () => {
|
|
seedOrders([ord({ deliveryStatus: 'pending' })])
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
|
|
expect(view.getByTestId('order-delivery-status-ORD-1001')).toHaveTextContent('Confirmed')
|
|
expect(view.queryByText('Pending')).toBeNull()
|
|
})
|
|
|
|
it('ORDERS-16: packaged / delivered / cancelled each get their label and colour', async () => {
|
|
seedOrders([
|
|
ord({ orderId: 'ORD-P', id: 10, deliveryStatus: 'packaged' }),
|
|
ord({ orderId: 'ORD-D', id: 11, deliveryStatus: 'success' }),
|
|
ord({ orderId: 'ORD-C', id: 12, deliveryStatus: 'cancelled' }),
|
|
])
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
|
|
const packaged = view.getByTestId('order-delivery-status-ORD-P')
|
|
// `orderStatusManipulator` only rewrites "pending"; "packaged" stays as-is.
|
|
expect(packaged).toHaveTextContent('packaged')
|
|
expect(styleColor(packaged)).toBe('#1570EF')
|
|
|
|
const delivered = view.getByTestId('order-delivery-status-ORD-D')
|
|
// Only "pending" is rewritten by the manipulator; other raw statuses pass
|
|
// through (the "Delivered" label is only used by the cancelled chip).
|
|
expect(delivered).toHaveTextContent('success')
|
|
expect(styleColor(delivered)).toBe('#059669')
|
|
|
|
const cancelled = view.getByTestId('order-delivery-status-ORD-C')
|
|
expect(cancelled).toHaveTextContent('cancelled')
|
|
expect(styleColor(cancelled)).toBe('#E11D48')
|
|
})
|
|
|
|
it('ORDERS-17: a discount renders as "Saved ₹..."', async () => {
|
|
seedOrders([ord({ discountAmount: 43 })])
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
|
|
expect(view.getByText('Saved ₹43')).toBeTruthy()
|
|
})
|
|
|
|
it('ORDERS-18: a positive delivery charge renders as "Delivery: ₹..."', async () => {
|
|
seedOrders([ord({ deliveryCharge: 15 })])
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
|
|
expect(view.getByText('Delivery: ₹15')).toBeTruthy()
|
|
})
|
|
|
|
it('ORDERS-19: user notes render under "Your Instructions"', async () => {
|
|
seedOrders([ord({ userNotes: 'Leave at the door' })])
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
|
|
expect(view.getByText('Your Instructions')).toBeTruthy()
|
|
expect(view.getByText('Leave at the door')).toBeTruthy()
|
|
})
|
|
|
|
it('ORDERS-20: OrderMenu renders and its actions work', async () => {
|
|
seedOrders([ord({ orderId: 'ORD-9', id: 9 })])
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
fireEvent.press(view.getByTestId('order-menu-trigger'))
|
|
|
|
expect(view.getByText('Order Options')).toBeTruthy()
|
|
expect(view.getByTestId('order-menu-edit-notes')).toBeTruthy()
|
|
expect(view.getByTestId('order-menu-raise-complaint')).toBeTruthy()
|
|
expect(view.getByTestId('order-menu-cancel-order')).toBeTruthy()
|
|
|
|
// "View Details" closes the menu and routes to the detail screen.
|
|
fireEvent.press(view.getByTestId('order-menu-view-details'))
|
|
expect(router.push).toHaveBeenCalledWith('/(drawer)/(tabs)/me/my-orders/9')
|
|
|
|
// "Edit Notes" re-opens after the menu's 300ms close animation.
|
|
fireEvent.press(view.getByTestId('order-menu-trigger'))
|
|
fireEvent.press(view.getByTestId('order-menu-edit-notes'))
|
|
await waitFor(() => expect(view.getByTestId('order-menu-notes-input')).toBeTruthy(), {
|
|
timeout: 2000,
|
|
})
|
|
fireEvent.changeText(view.getByTestId('order-menu-notes-input'), 'Ring the bell')
|
|
fireEvent.press(view.getByTestId('order-menu-save-notes'))
|
|
await flush(3)
|
|
|
|
expect(lastProcedureInput('user.order.updateUserNotes')).toEqual({
|
|
id: 9,
|
|
userNotes: 'Ring the bell',
|
|
})
|
|
})
|
|
|
|
it('ORDERS-21: onEndReached requests page 2 with pageSize 10 and appends it', async () => {
|
|
setOrderPages({ 1: [ord({ orderId: 'ORD-A', id: 21 })], 2: [ord({ orderId: 'ORD-B', id: 22 })] }, 2)
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
expect(cards(view)).toHaveLength(1)
|
|
|
|
await endReached(view)
|
|
|
|
expect(lastProcedureInput('user.order.getOrders')).toEqual({ page: 2, pageSize: 10 })
|
|
expect(cards(view)).toHaveLength(2)
|
|
expect(view.getByText('#ORD-B')).toBeTruthy()
|
|
})
|
|
|
|
it('ORDERS-22: hasNextPage false renders the "End of list" footer', async () => {
|
|
seedOrders([ord()])
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
|
|
expect(view.getByTestId('orders-end-of-list')).toBeTruthy()
|
|
expect(view.getByText('End of list')).toBeTruthy()
|
|
})
|
|
|
|
it('ORDERS-23: while page 2 is pending the footer shows "Loading more orders..."', async () => {
|
|
setOrderPages({ 1: [ord({ orderId: 'ORD-A', id: 31 })], 2: [] }, 2)
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
|
|
// Batching the page bump and the pending switch in one act keeps the list
|
|
// mounted while `isLoadingMore` is true.
|
|
act(() => {
|
|
fireEvent(view.getByTestId('orders-list'), 'onEndReached')
|
|
setProcedure('user.order.getOrders', { mode: 'pending' })
|
|
})
|
|
await flush(2)
|
|
|
|
expect(view.getByTestId('orders-loading-more')).toBeTruthy()
|
|
expect(view.getByText('Loading more orders...')).toBeTruthy()
|
|
})
|
|
|
|
it('ORDERS-24: a failing page 2 leaves the full error screen (footer error unreachable) (current)', async () => {
|
|
setOrderPages({ 1: [ord({ orderId: 'ORD-A', id: 41 })], 2: [] }, 2)
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
|
|
act(() => {
|
|
fireEvent(view.getByTestId('orders-list'), 'onEndReached')
|
|
setProcedure('user.order.getOrders', { mode: 'error', error: new Error('offline') })
|
|
})
|
|
await flush(2)
|
|
|
|
// The top-level `if (error)` branch wins, so the ListFooterComponent's
|
|
// "Failed to load more orders..." is never rendered while the error persists.
|
|
expect(view.getByTestId('orders-error')).toBeTruthy()
|
|
expect(view.getByText('Unable to load orders')).toBeTruthy()
|
|
expect(view.queryByTestId('orders-load-more-error')).toBeNull()
|
|
})
|
|
|
|
it('ORDERS-25: retrying from the page-2 error keeps currentPage at 2 (current)', async () => {
|
|
setOrderPages({ 1: [ord({ orderId: 'ORD-A', id: 51 })], 2: [] }, 2)
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
act(() => {
|
|
fireEvent(view.getByTestId('orders-list'), 'onEndReached')
|
|
setProcedure('user.order.getOrders', { mode: 'error', error: new Error('offline') })
|
|
})
|
|
await flush(2)
|
|
|
|
fireEvent.press(view.getByTestId('orders-retry'))
|
|
await flush(2)
|
|
|
|
// Retry only calls the hook's `refetch`; it does not reset `currentPage`,
|
|
// so the recorded input is still page 2 (not page 1).
|
|
expect(lastProcedureInput('user.order.getOrders')).toEqual({ page: 2, pageSize: 10 })
|
|
expect(pageCalls(1)).toHaveLength(1)
|
|
})
|
|
|
|
it('ORDERS-26: onEndReached does not fetch again while loading or when there is no next page', async () => {
|
|
// (a) hasNextPage is false: two triggers fetch only page 1.
|
|
seedOrders([ord()])
|
|
const first = renderPage()
|
|
await load()
|
|
|
|
await endReached(first)
|
|
await endReached(first)
|
|
|
|
expect(pageCalls(2)).toHaveLength(0)
|
|
first.unmount()
|
|
|
|
// (b) page 2 is still loading: the isLoadingMore guard blocks the second trigger.
|
|
resetAllMocks()
|
|
setOrderPages({ 1: [ord({ orderId: 'ORD-A', id: 61 })], 2: [] }, 2)
|
|
const second = renderPage()
|
|
await load()
|
|
|
|
act(() => {
|
|
fireEvent(second.getByTestId('orders-list'), 'onEndReached')
|
|
setProcedure('user.order.getOrders', { mode: 'pending' })
|
|
})
|
|
await flush(2)
|
|
|
|
await endReached(second)
|
|
|
|
// `mode: 'pending'` never reaches the registry, so count the page-2 request
|
|
// off the network mock: the second trigger must not add another one.
|
|
expect(pageNetworkRequests(2)).toHaveLength(1)
|
|
})
|
|
|
|
it('ORDERS-27: a response without pagination has no next page', async () => {
|
|
setProcedure('user.order.getOrders', { data: { data: [ord()] } })
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
|
|
expect(view.getByTestId('orders-end-of-list')).toBeTruthy()
|
|
|
|
await endReached(view)
|
|
|
|
expect(pageCalls(2)).toHaveLength(0)
|
|
})
|
|
|
|
it('ORDERS-28: a page 1 response replaces the accumulated list', async () => {
|
|
setOrderPages(
|
|
{
|
|
1: [ord({ orderId: 'ORD-A', id: 71 }), ord({ orderId: 'ORD-B', id: 72 })],
|
|
2: [ord({ orderId: 'ORD-C', id: 73 })],
|
|
},
|
|
2
|
|
)
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
await endReached(view)
|
|
expect(cards(view)).toHaveLength(3)
|
|
|
|
const before = pageCalls(1).length
|
|
await manualRefresh(view)
|
|
|
|
expect(pageCalls(1).length).toBeGreaterThan(before)
|
|
expect(cards(view)).toHaveLength(2)
|
|
expect(view.queryByText('#ORD-C')).toBeNull()
|
|
})
|
|
|
|
it('ORDERS-29: a page >1 response appends (no dedupe against repeated rows)', async () => {
|
|
setOrderPages(
|
|
{
|
|
1: [ord({ orderId: 'ORD-A', id: 81 })],
|
|
2: [ord({ orderId: 'ORD-B', id: 82 }), ord({ orderId: 'ORD-C', id: 83 })],
|
|
},
|
|
2
|
|
)
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
await endReached(view)
|
|
|
|
expect(cards(view)).toHaveLength(3)
|
|
expect(view.getByText('#ORD-B')).toBeTruthy()
|
|
expect(view.getByText('#ORD-C')).toBeTruthy()
|
|
// The page concatenates blindly; a repeated row would appear twice. That
|
|
// documented behaviour is pinned by ORDERS-33.
|
|
})
|
|
|
|
it('ORDERS-30: pull to refresh resets page/list/flags and refetches page 1', async () => {
|
|
setOrderPages(
|
|
{
|
|
1: [ord({ orderId: 'ORD-A', id: 91 })],
|
|
2: [ord({ orderId: 'ORD-B', id: 92 })],
|
|
},
|
|
2
|
|
)
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
await endReached(view)
|
|
expect(cards(view)).toHaveLength(2)
|
|
|
|
const before = pageCalls(1).length
|
|
await pullToRefresh(view)
|
|
|
|
expect(pageCalls(1).length).toBeGreaterThan(before)
|
|
expect(lastProcedureInput('user.order.getOrders')).toEqual({ page: 1, pageSize: 10 })
|
|
expect(cards(view)).toHaveLength(1)
|
|
expect(view.queryByText('#ORD-B')).toBeNull()
|
|
})
|
|
|
|
it('ORDERS-31: a re-focus through useMarkDataFetchers performs the same reset', async () => {
|
|
setOrderPages(
|
|
{
|
|
1: [ord({ orderId: 'ORD-A', id: 93 })],
|
|
2: [ord({ orderId: 'ORD-B', id: 94 })],
|
|
},
|
|
2
|
|
)
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
await endReached(view)
|
|
expect(cards(view)).toHaveLength(2)
|
|
|
|
const before = procedureQueryCalls('user.order.getOrders').length
|
|
await emitFocus()
|
|
await flush(3)
|
|
|
|
// Re-focus resets `currentPage` to 1 and refetches; the list falls back to
|
|
// the page-1 response instead of keeping the appended page.
|
|
expect(procedureQueryCalls('user.order.getOrders').length).toBeGreaterThan(before)
|
|
expect(cards(view)).toHaveLength(1)
|
|
expect(view.queryByText('#ORD-B')).toBeNull()
|
|
})
|
|
|
|
it('ORDERS-32: pull to refresh while on page 2 returns to page 1', async () => {
|
|
setOrderPages(
|
|
{
|
|
1: [ord({ orderId: 'ORD-A', id: 95 })],
|
|
2: [ord({ orderId: 'ORD-B', id: 96 }), ord({ orderId: 'ORD-C', id: 97 })],
|
|
},
|
|
3
|
|
)
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
await endReached(view)
|
|
expect(cards(view)).toHaveLength(3)
|
|
|
|
await pullToRefresh(view)
|
|
|
|
expect(lastProcedureInput('user.order.getOrders')).toEqual({ page: 1, pageSize: 10 })
|
|
expect(cards(view)).toHaveLength(1)
|
|
expect(view.getByText('#ORD-A')).toBeTruthy()
|
|
})
|
|
|
|
it('ORDERS-33: the key is the orderId string, so a repeated id does not crash (current)', async () => {
|
|
const consoleError = jest.spyOn(console, 'error').mockImplementation(() => undefined)
|
|
setOrderPages(
|
|
{
|
|
1: [ord({ orderId: 'ORD-DUP', id: 101 })],
|
|
2: [ord({ orderId: 'ORD-DUP', id: 102 })],
|
|
},
|
|
2
|
|
)
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
await endReached(view)
|
|
|
|
// Both rows render; the duplicate `key` only produces a React warning.
|
|
expect(view.getAllByTestId('order-card-ORD-DUP')).toHaveLength(2)
|
|
consoleError.mockRestore()
|
|
})
|
|
|
|
it('ORDERS-34: a flash card renders the FAST badge', async () => {
|
|
seedOrders([ord({ isFlashDelivery: true })])
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
|
|
expect(view.getByText('⚡ FAST')).toBeTruthy()
|
|
expect(view.getByText('1 Hr Delivery:')).toBeTruthy()
|
|
})
|
|
|
|
it('ORDERS-35: there is no payment or refund UI (COD only)', async () => {
|
|
seedOrders([ord()])
|
|
const view = renderPage()
|
|
|
|
await load()
|
|
|
|
expect(view.getByText('#ORD-1001')).toBeTruthy()
|
|
expect(view.queryByText(/refund/i)).toBeNull()
|
|
expect(view.queryByText(/payment/i)).toBeNull()
|
|
})
|
|
})
|