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

188 lines
5.9 KiB
TypeScript

/**
* Rebalance orders (app/(drawer)/dashboard/rebalance-orders/index.tsx) —
* upcoming-slot list, past-slot filtering, selection, the rebalanceSlots
* mutation and the +N-more product dialog.
*/
import React from 'react'
import { Alert } from 'react-native'
import { fireEvent, screen, waitFor } from '@testing-library/react-native'
import RebalanceOrders from '@/app/(drawer)/dashboard/rebalance-orders/index'
import { resetStorage, setupApiMocks } from '../mocks/api'
import {
expectProcedureCalled,
lastProcedureInput,
procCount,
} from '../mocks/procedures'
import { resetStaffAuthMock } from '../mocks/staff-auth'
import { renderWithProviders } from '../helpers/render'
const futureSlot = (overrides: Record<string, unknown> = {}) => ({
id: 1,
deliveryTime: '2099-01-01T10:00:00.000Z',
freezeTime: '2099-01-01T09:00:00.000Z',
isActive: true,
products: [
{ id: 10, name: 'Chicken' },
{ id: 11, name: 'Mutton' },
{ id: 12, name: 'Fish' },
],
...overrides,
})
const slotsResult = (slots: unknown[]) => ({ slots, count: slots.length })
describe('Rebalance orders', () => {
beforeEach(async () => {
resetStaffAuthMock()
await resetStorage()
setupApiMocks()
jest.spyOn(Alert, 'alert').mockImplementation(() => {})
})
it('shows the loading state while slots are pending', () => {
setupApiMocks({
procedures: { 'admin.slots.getAll': () => new Promise(() => {}) },
})
renderWithProviders(<RebalanceOrders />)
expect(screen.getByText('Loading slots...')).toBeVisible()
})
it('renders an upcoming slot row with products and status', async () => {
setupApiMocks({
procedures: { 'admin.slots.getAll': slotsResult([futureSlot()]) },
})
renderWithProviders(<RebalanceOrders />)
await waitFor(() => expect(screen.getByText('Slot #1')).toBeVisible())
expect(screen.getByText('Active')).toBeVisible()
// Only the first two product names are shown.
expect(screen.getByText('Chicken, Mutton')).toBeVisible()
expect(screen.getByText('+1 more')).toBeVisible()
})
it('marks an inactive slot as Inactive', async () => {
setupApiMocks({
procedures: {
'admin.slots.getAll': slotsResult([futureSlot({ isActive: false })]),
},
})
renderWithProviders(<RebalanceOrders />)
await waitFor(() => expect(screen.getByText('Inactive')).toBeVisible())
})
it('hides slots whose delivery time has already passed', async () => {
setupApiMocks({
procedures: {
'admin.slots.getAll': slotsResult([
futureSlot({ id: 1, deliveryTime: '2099-01-01T10:00:00.000Z' }),
futureSlot({ id: 2, deliveryTime: '2000-01-01T10:00:00.000Z' }),
]),
},
})
renderWithProviders(<RebalanceOrders />)
await waitFor(() => expect(screen.getByText('Slot #1')).toBeVisible())
expect(screen.queryByText('Slot #2')).toBeNull()
})
it('shows the empty state when there are no upcoming slots', async () => {
setupApiMocks({
procedures: {
'admin.slots.getAll': slotsResult([
futureSlot({ deliveryTime: '2000-01-01T10:00:00.000Z' }),
]),
},
})
renderWithProviders(<RebalanceOrders />)
expect(
await screen.findByText('No upcoming slots available for rebalancing.')
).toBeVisible()
})
it('does not rebalance while nothing is selected', async () => {
const { fetchMock } = setupApiMocks({
procedures: { 'admin.slots.getAll': slotsResult([futureSlot()]) },
})
renderWithProviders(<RebalanceOrders />)
await screen.findByText('Slot #1')
fireEvent.press(screen.getByTestId('mock-linear-gradient'))
expect(procCount(fetchMock, 'admin.order.rebalanceSlots')).toBe(0)
})
it('rebalances the selected slots through rebalanceSlots', async () => {
const { fetchMock } = setupApiMocks({
procedures: {
'admin.slots.getAll': slotsResult([futureSlot(), futureSlot({ id: 2 })]),
'admin.order.rebalanceSlots': {
message: 'Rebalanced',
updatedSlotIds: [1],
},
},
})
renderWithProviders(<RebalanceOrders />)
await screen.findByText('Slot #1')
fireEvent.press(screen.getByText('Slot #1'))
fireEvent.press(screen.getByText('Slot #2'))
fireEvent.press(screen.getByTestId('mock-linear-gradient'))
expect(Alert.alert).toHaveBeenCalledWith(
'Rebalancing...',
'Please wait while we rebalance the selected slots.',
[{ text: 'OK' }]
)
await waitFor(() =>
expectProcedureCalled(fetchMock, 'admin.order.rebalanceSlots')
)
expect(lastProcedureInput(fetchMock, 'admin.order.rebalanceSlots')).toEqual({
slotIds: [1, 2],
})
await waitFor(() =>
expect(Alert.alert).toHaveBeenCalledWith(
'Rebalance Complete',
'Slots have been rebalanced.'
)
)
// onSuccess refetches the slot list.
await waitFor(() =>
expect(procCount(fetchMock, 'admin.slots.getAll')).toBeGreaterThan(1)
)
})
it('toggles a slot back off when pressed twice', async () => {
const { fetchMock } = setupApiMocks({
procedures: {
'admin.slots.getAll': slotsResult([futureSlot()]),
'admin.order.rebalanceSlots': { message: 'Rebalanced' },
},
})
renderWithProviders(<RebalanceOrders />)
await screen.findByText('Slot #1')
fireEvent.press(screen.getByText('Slot #1'))
fireEvent.press(screen.getByText('Slot #1'))
fireEvent.press(screen.getByTestId('mock-linear-gradient'))
expect(procCount(fetchMock, 'admin.order.rebalanceSlots')).toBe(0)
})
it('opens the full product list from the +N more link', async () => {
setupApiMocks({
procedures: { 'admin.slots.getAll': slotsResult([futureSlot()]) },
})
renderWithProviders(<RebalanceOrders />)
await screen.findByText('+1 more')
fireEvent.press(screen.getByText('+1 more'))
expect(await screen.findByText('All Products')).toBeVisible()
expect(screen.getByText('Fish')).toBeVisible()
})
})