freshyo/apps/user-ui/tests/pages/my-orders.test.tsx
2026-10-20 11:19:25 +05:30

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()
})
})