freshyo/apps/admin-ui/tests/screens/manage-orders-orders.test.tsx
2026-10-01 00:33:03 +05:30

338 lines
11 KiB
TypeScript

/**
* Orders list (app/(drawer)/dashboard/manage-orders/orders/index.tsx) — rows,
* loading/empty/error, delivered toggle, item packaging, admin notes, filters,
* pagination and navigation.
*/
jest.mock('expo-router', () => require('../mocks/router').expoRouterMock())
import React from 'react'
import { Alert, FlatList } from 'react-native'
import { fireEvent, screen, waitFor } from '@testing-library/react-native'
import MaterialIcons from '@expo/vector-icons/MaterialIcons'
import Entypo from '@expo/vector-icons/Entypo'
import Orders from '@/app/(drawer)/dashboard/manage-orders/orders'
import { setupApiMocks, resetStorage } from '../mocks/api'
import { resetStaffAuthMock } from '../mocks/staff-auth'
import { resetRouterMock, routerMock, searchParamsMock } from '../mocks/router'
import { lastProcedureInput, procCount } from '../mocks/procedures'
import { renderWithProviders } from '../helpers/render'
const makeOrder = (overrides: Record<string, unknown> = {}) => ({
id: 11,
orderId: '11',
readableId: 11,
customerName: 'Alice',
customerMobile: '9999999999',
address: '12 Main St, City, State - 500001, Phone: 9876543210',
addressId: 3,
latitude: null,
longitude: null,
totalAmount: 500,
deliveryCharge: 20,
items: [
{
id: 101,
name: 'Chicken',
quantity: 2,
price: 100,
amount: 200,
unit: 'kg',
skuName: 'Chicken',
features: [],
productSize: 1,
isPackaged: false,
isPackageVerified: false,
},
],
createdAt: '2026-01-01T10:00:00.000Z',
deliveryTime: null,
status: 'pending',
isPackaged: false,
isDelivered: false,
isCod: true,
isFlashDelivery: false,
userNotes: null,
adminNotes: 'call before delivery',
userNegativityScore: 0,
...overrides,
})
const mutateProcedures = {
'admin.order.updateDelivered': { success: true, userId: 1 },
'admin.order.updatePackaged': { success: true, userId: 1 },
'admin.order.updateOrderItemPackaging': { success: true, updated: true },
'admin.order.updateNotes': { id: 11 },
'admin.order.cancelOrder': { success: true, message: 'cancelled' },
}
const renderOrders = (procedures: Record<string, unknown> = {}) => {
const { fetchMock } = setupApiMocks({
procedures: {
'admin.slots.getAll': { slots: [], count: 0 },
'admin.order.getAll': { orders: [makeOrder()], nextCursor: null },
...procedures,
},
})
renderWithProviders(<Orders />)
return { fetchMock }
}
// Checkboxes render in tree order: row [Packaged, Delivered] then the filter
// dialog rows [Packaged, Not Packaged, Delivered, Not Delivered, Cancelled,
// Not Cancelled, ⚡ 1 Hr, Regular].
const checkboxAt = (index: number) => screen.getAllByRole('checkbox')[index]
const openFilter = () => {
const icon = screen
.UNSAFE_getAllByType(MaterialIcons)
.find((node) => node.props.name === 'filter-list')!
fireEvent.press(icon)
}
const FILTER_INDEX = {
packaged: 2,
notPackaged: 3,
delivered: 4,
notDelivered: 5,
cancelled: 6,
notCancelled: 7,
flash: 8,
regular: 9,
} as const
describe('Orders list', () => {
beforeEach(async () => {
resetStaffAuthMock()
await resetStorage()
resetRouterMock()
searchParamsMock.current = {}
jest.spyOn(Alert, 'alert').mockImplementation(() => {})
})
it('shows a loading indicator while the list is pending', () => {
renderOrders()
expect(screen.getByText('Loading orders...')).toBeVisible()
})
it('renders a populated row', async () => {
renderOrders()
await waitFor(() => expect(screen.getByText('Alice')).toBeVisible())
expect(screen.getByText('#11')).toBeVisible()
expect(screen.getByText('1 item')).toBeVisible()
expect(screen.getByText('₹500')).toBeVisible()
expect(screen.getByText('₹20')).toBeVisible()
expect(screen.getByText('Admin Notes')).toBeVisible()
})
it('renders an empty list when there are no orders', async () => {
renderOrders({ 'admin.order.getAll': { orders: [], nextCursor: null } })
await waitFor(() => expect(screen.queryByText('Loading orders...')).toBeNull())
expect(screen.queryByText('Alice')).toBeNull()
})
it('renders flash and cancelled order badges', async () => {
renderOrders({
'admin.order.getAll': {
orders: [
makeOrder({ isFlashDelivery: true, status: 'cancelled', readableId: 42, id: 42, orderId: '42' }),
],
nextCursor: null,
},
})
await waitFor(() => expect(screen.getByText('FLASH')).toBeVisible())
expect(screen.getByText('CANCELLED')).toBeVisible()
})
it('marks an order delivered from the row checkbox', async () => {
const { fetchMock } = renderOrders(mutateProcedures)
await waitFor(() => expect(screen.getByText('Alice')).toBeVisible())
fireEvent.press(checkboxAt(1))
await waitFor(() => expect(lastProcedureInput(fetchMock, 'admin.order.updateDelivered')).toEqual({
orderId: '11',
isDelivered: true,
}))
})
it('does not toggle packaged from the (inert) inline row checkbox', async () => {
const { fetchMock } = renderOrders(mutateProcedures)
await waitFor(() => expect(screen.getByText('Alice')).toBeVisible())
fireEvent.press(checkboxAt(0))
expect(procCount(fetchMock, 'admin.order.updatePackaged')).toBe(0)
})
it('updates per-item packaging from the items dialog', async () => {
const { fetchMock } = renderOrders(mutateProcedures)
await waitFor(() => expect(screen.getByText('Alice')).toBeVisible())
fireEvent.press(screen.getByText('1 item'))
fireEvent.press(checkboxAt(2))
await waitFor(() =>
expect(lastProcedureInput(fetchMock, 'admin.order.updateOrderItemPackaging')).toEqual({
orderItemId: 101,
isPackaged: true,
})
)
})
it('applies the packaged filter to the query input', async () => {
const { fetchMock } = renderOrders(mutateProcedures)
await waitFor(() => expect(screen.getByText('Alice')).toBeVisible())
openFilter()
fireEvent.press(checkboxAt(FILTER_INDEX.packaged))
await waitFor(() => {
const input = lastProcedureInput(fetchMock, 'admin.order.getAll') as Record<string, unknown>
expect(input.packagedFilter).toBe('packaged')
})
})
it('applies the delivered and cancellation filters', async () => {
const { fetchMock } = renderOrders(mutateProcedures)
await waitFor(() => expect(screen.getByText('Alice')).toBeVisible())
openFilter()
fireEvent.press(checkboxAt(FILTER_INDEX.delivered))
await waitFor(() => {
const input = lastProcedureInput(fetchMock, 'admin.order.getAll') as Record<string, unknown>
expect(input.deliveredFilter).toBe('delivered')
})
})
it('applies the flash delivery type filter', async () => {
const { fetchMock } = renderOrders(mutateProcedures)
await waitFor(() => expect(screen.getByText('Alice')).toBeVisible())
openFilter()
fireEvent.press(checkboxAt(FILTER_INDEX.flash))
await waitFor(() => {
const input = lastProcedureInput(fetchMock, 'admin.order.getAll') as Record<string, unknown>
expect(input.flashDeliveryFilter).toBe('flash')
})
})
it('saves admin notes through the notes dialog', async () => {
const { fetchMock } = renderOrders(mutateProcedures)
await waitFor(() => expect(screen.getByText('Alice')).toBeVisible())
fireEvent.press(screen.getByText('Admin Notes'))
fireEvent.changeText(
screen.getByPlaceholderText('Enter admin notes...'),
'leave at gate'
)
fireEvent.press(screen.getByText('Save'))
await waitFor(() =>
expect(lastProcedureInput(fetchMock, 'admin.order.updateNotes')).toEqual({
orderId: 11,
adminNotes: 'leave at gate',
})
)
})
it('opens the user notes dialog', async () => {
renderOrders({
'admin.order.getAll': {
orders: [makeOrder({ userNotes: 'ring the bell' })],
nextCursor: null,
},
})
await waitFor(() => expect(screen.getByText('User Notes')).toBeVisible())
fireEvent.press(screen.getByText('User Notes'))
expect(await screen.findByText('ring the bell')).toBeVisible()
})
it('navigates to order details when a row is pressed', async () => {
renderOrders()
await waitFor(() => expect(screen.getByText('Alice')).toBeVisible())
fireEvent.press(screen.getByText('Alice'))
expect(routerMock.push).toHaveBeenCalledWith(
'/(drawer)/dashboard/manage-orders/order-details/11'
)
})
it('opens the options menu and navigates via View Details', async () => {
renderOrders()
await waitFor(() => expect(screen.getByText('Alice')).toBeVisible())
const dots = screen.UNSAFE_getAllByType(Entypo)[0]
fireEvent.press(dots)
expect(await screen.findByText('Select an action to perform')).toBeVisible()
fireEvent.press(screen.getByText('View Details'))
expect(routerMock.push).toHaveBeenCalledWith(
'/(drawer)/dashboard/manage-orders/order-details/11'
)
})
it('opens the cancel dialog from the options menu', async () => {
renderOrders()
await waitFor(() => expect(screen.getByText('Alice')).toBeVisible())
fireEvent.press(screen.UNSAFE_getAllByType(Entypo)[0])
fireEvent.press(await screen.findByText('Cancel Order'))
expect(await screen.findByPlaceholderText('Enter reason for cancellation...')).toBeVisible()
})
it('loads the next page when the list end is reached', async () => {
const { fetchMock } = setupApiMocks({
procedures: {
'admin.slots.getAll': { slots: [], count: 0 },
'admin.order.getAll': (input: unknown) => {
const cursor = (input as { cursor?: number } | undefined)?.cursor
if (cursor) {
return {
orders: [makeOrder({ id: 5, orderId: '5', readableId: 5, customerName: 'Fish Order' })],
nextCursor: null,
}
}
return { orders: [makeOrder()], nextCursor: 5 }
},
},
})
renderWithProviders(<Orders />)
await waitFor(() => expect(screen.getByText('Alice')).toBeVisible())
fireEvent(screen.UNSAFE_getByType(FlatList), 'endReached')
await waitFor(() => expect(screen.getByText('Fish Order')).toBeVisible())
const input = lastProcedureInput(fetchMock, 'admin.order.getAll') as Record<string, unknown>
expect(input.cursor).toBe(5)
})
it('falls back to an empty list when the query fails', async () => {
setupApiMocks({
procedures: {
'admin.slots.getAll': { slots: [], count: 0 },
'admin.order.getAll': () => {
throw new Error('boom')
},
},
})
renderWithProviders(<Orders />)
await waitFor(() => expect(screen.queryByText('Loading orders...')).toBeNull())
expect(screen.queryByText('Alice')).toBeNull()
})
})