338 lines
11 KiB
TypeScript
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()
|
|
})
|
|
})
|