freshyo/apps/backend/tests/unit/order-items-archive.test.ts
2026-10-20 16:13:09 +05:30

395 lines
12 KiB
TypeScript

/**
* Unit tests for the order-items archive helpers.
*
* These exercise the pure pieces only (calendar cutoff + snapshot validation);
* the DB write/delete is covered by the archive route during live runs.
*/
import {
archiveOrderItems,
buildSnapshot,
istCalendarCutoffUtc,
runOrderItemsArchive,
validateSnapshot,
type ArchiveSkuRow,
type ArchiveSourceRow,
type ArchiveStore,
} from '@/src/dbService'
function sourceRow(over: Partial<ArchiveSourceRow> = {}): ArchiveSourceRow {
return {
id: 1,
orderId: 10,
skuId: 100,
quantity: '2',
price: '199',
discountedPrice: null,
is_packaged: false,
is_package_verified: false,
packagedAt: null,
...over,
}
}
function snapshot(over: Record<string, any> = {}) {
return {
id: 1,
skuId: 100,
quantity: '2',
price: '199',
discountedPrice: null,
isPackaged: false,
isPackageVerified: false,
packagedAt: null,
productName: 'Chicken Breast',
skuName: '1kg',
image: 'chicken.jpg',
features: [{ featureName: 'quantity', featureValue: '1kg' }],
...over,
}
}
describe('istCalendarCutoffUtc', () => {
it('returns the start of the IST day two days before now', () => {
// 12:00 UTC = 17:30 IST on Oct 20; keep Oct 18-20 IST.
const cutoff = istCalendarCutoffUtc(new Date('2026-10-20T12:00:00.000Z'))
expect(cutoff.toISOString()).toBe('2026-10-17T18:30:00.000Z')
})
it('treats 23:59:59 IST as the previous day (archived) and 00:00 IST as kept', () => {
const cutoff = istCalendarCutoffUtc(new Date('2026-10-20T12:00:00.000Z'))
expect(new Date('2026-10-17T18:29:59.000Z').getTime()).toBeLessThan(cutoff.getTime())
expect(new Date('2026-10-17T18:30:00.000Z').getTime()).toBe(cutoff.getTime())
})
})
function skuRow(over: Partial<ArchiveSkuRow> = {}): ArchiveSkuRow {
return {
id: 100,
name: '1kg',
images: ['chicken.jpg'],
isDeleted: false,
product: { name: 'Chicken Breast' },
features: [{ featureName: 'quantity', featureValue: '1kg' }],
...over,
}
}
describe('buildSnapshot', () => {
it('keeps raw quantity/price strings, booleans, null discount and nested features', () => {
const { snapshot } = buildSnapshot([sourceRow()], new Map([[100, skuRow()]]))
expect(snapshot).toEqual([
{
id: 1,
skuId: 100,
quantity: '2',
price: '199',
discountedPrice: null,
isPackaged: false,
isPackageVerified: false,
packagedAt: null,
productName: 'Chicken Breast',
skuName: '1kg',
image: 'chicken.jpg',
features: [{ featureName: 'quantity', featureValue: '1kg' }],
},
])
expect(typeof snapshot![0].quantity).toBe('string')
expect(typeof snapshot![0].price).toBe('string')
expect(snapshot![0].discountedPrice).toBeNull()
expect(snapshot![0].isPackaged).toBe(false)
expect(Array.isArray(snapshot![0].features)).toBe(true)
})
it('keeps an explicit discounted price and packaged flags', () => {
const { snapshot } = buildSnapshot(
[sourceRow({ discountedPrice: '149', is_packaged: true, is_package_verified: true })],
new Map([[100, skuRow()]])
)
expect(snapshot![0].discountedPrice).toBe('149')
expect(snapshot![0].isPackaged).toBe(true)
expect(snapshot![0].isPackageVerified).toBe(true)
})
it('reports a missing catalogue row instead of dropping the line', () => {
const built = buildSnapshot([sourceRow()], new Map())
expect(built.snapshot).toBeUndefined()
expect(built.reason).toMatch(/missing catalogue/)
})
})
describe('validateSnapshot', () => {
it('accepts a valid single-item snapshot and null discountedPrice', () => {
expect(validateSnapshot([sourceRow()], [snapshot()])).toBeNull()
})
it('accepts a populated discountedPrice', () => {
expect(
validateSnapshot(
[sourceRow({ discountedPrice: '149' })],
[snapshot({ discountedPrice: '149' })]
)
).toBeNull()
})
it('rejects an order with no source items', () => {
expect(validateSnapshot([], [])).toMatch(/no items/)
})
it('rejects an empty snapshot', () => {
expect(validateSnapshot([sourceRow()], [])).toMatch(/empty/)
})
it('rejects a count mismatch', () => {
expect(validateSnapshot([sourceRow()], [snapshot(), snapshot({ id: 2 })])).toMatch(
/length/
)
})
it('rejects duplicate ids', () => {
expect(
validateSnapshot(
[sourceRow(), sourceRow({ id: 2 })],
[snapshot(), snapshot()]
)
).toMatch(/duplicate/)
})
it('rejects missing source ids', () => {
expect(
validateSnapshot(
[sourceRow(), sourceRow({ id: 2 })],
[snapshot(), snapshot({ id: 3 })]
)
).toMatch(/unknown item id/)
})
it('rejects a missing productName', () => {
expect(validateSnapshot([sourceRow()], [snapshot({ productName: '' })])).toMatch(
/productName/
)
})
it('rejects non-numeric or non-positive quantity/price', () => {
expect(validateSnapshot([sourceRow()], [snapshot({ quantity: 'abc' })])).toMatch(
/quantity/
)
expect(validateSnapshot([sourceRow()], [snapshot({ quantity: '0' })])).toMatch(
/quantity/
)
expect(validateSnapshot([sourceRow()], [snapshot({ price: '-1' })])).toMatch(
/price/
)
})
it('rejects 0/1 or string flags', () => {
expect(validateSnapshot([sourceRow()], [snapshot({ isPackaged: 1 })])).toMatch(
/isPackaged/
)
expect(
validateSnapshot([sourceRow()], [snapshot({ isPackageVerified: 'true' })])
).toMatch(/isPackageVerified/)
})
it('rejects a stringified features array', () => {
expect(
validateSnapshot([sourceRow()], [snapshot({ features: '[]' })])
).toMatch(/features/)
})
it('rejects invalid feature entries', () => {
expect(
validateSnapshot(
[sourceRow()],
[snapshot({ features: [{ featureName: 'quantity', featureValue: 1 }] })]
)
).toMatch(/feature/)
})
it('rejects an invalid packagedAt', () => {
expect(
validateSnapshot([sourceRow()], [snapshot({ packagedAt: 'not-a-date' })])
).toMatch(/packagedAt/)
})
})
function makeStore(options: {
rowsByOrder: Record<number, ArchiveSourceRow[]>
skuById?: Map<number, ArchiveSkuRow>
apply?: (orderId: number, snapshot: unknown[], verifiedIds: number[]) => boolean | Promise<boolean>
eligibleBatches?: number[][]
}) {
const applyCalls: { orderId: number; snapshot: unknown[]; verifiedIds: number[] }[] = []
const listCursors: number[] = []
let listCall = 0
const store: ArchiveStore = {
loadSource: async (ids) => ({
rows: ids.flatMap((id) => options.rowsByOrder[id] ?? []),
skuById: options.skuById ?? new Map([[100, skuRow()]]),
}),
applyArchive: async (orderId, snapshot, verifiedIds) => {
applyCalls.push({ orderId, snapshot, verifiedIds })
return options.apply ? await options.apply(orderId, snapshot, verifiedIds) : true
},
listEligibleOrderIds: async (_cutoff, cursor, _limit) => {
listCursors.push(cursor)
return options.eligibleBatches?.[listCall++] ?? []
},
}
return { store, applyCalls, listCursors }
}
describe('archiveOrderItems', () => {
it('applies a valid order and keeps raw strings/booleans/features', async () => {
const { store, applyCalls } = makeStore({
rowsByOrder: { 10: [sourceRow()] },
})
const summary = await archiveOrderItems([10], store)
expect(summary).toEqual({ scanned: 1, archived: 1, skipped: [] })
expect(applyCalls).toHaveLength(1)
expect(applyCalls[0].orderId).toBe(10)
expect(applyCalls[0].verifiedIds).toEqual([1])
expect(applyCalls[0].snapshot[0]).toMatchObject({
id: 1,
skuId: 100,
quantity: '2',
price: '199',
isPackaged: false,
productName: 'Chicken Breast',
})
})
it('skips an order with no items and never calls applyArchive', async () => {
const { store, applyCalls } = makeStore({ rowsByOrder: { 10: [] } })
const summary = await archiveOrderItems([10], store)
expect(summary.archived).toBe(0)
expect(summary.skipped).toEqual([{ orderId: 10, reason: 'order has no items' }])
expect(applyCalls).toHaveLength(0)
})
it('skips an order with a missing catalogue row and never calls applyArchive', async () => {
const { store, applyCalls } = makeStore({
rowsByOrder: { 10: [sourceRow()] },
skuById: new Map(),
})
const summary = await archiveOrderItems([10], store)
expect(summary.archived).toBe(0)
expect(summary.skipped[0].orderId).toBe(10)
expect(summary.skipped[0].reason).toMatch(/missing catalogue/)
expect(applyCalls).toHaveLength(0)
})
it('reports a guard failure (concurrent change) without counting it as archived', async () => {
const { store } = makeStore({
rowsByOrder: { 10: [sourceRow()] },
apply: async () => false,
})
const summary = await archiveOrderItems([10], store)
expect(summary.archived).toBe(0)
expect(summary.skipped).toEqual([
{ orderId: 10, reason: 'source changed during archive' },
])
})
it('handles a mixed batch and deduplicates ids', async () => {
const { store, applyCalls } = makeStore({
rowsByOrder: {
10: [sourceRow()],
20: [sourceRow({ id: 2, orderId: 20 })],
},
skuById: new Map(),
})
const summary = await archiveOrderItems([10, 10, 20], store)
expect(summary.scanned).toBe(2)
expect(summary.archived).toBe(0)
expect(summary.skipped.map((entry) => entry.orderId).sort()).toEqual([10, 20])
expect(applyCalls).toHaveLength(0)
})
})
describe('runOrderItemsArchive', () => {
beforeEach(() => {
jest.spyOn(console, 'log').mockImplementation(() => undefined)
})
afterEach(() => {
jest.restoreAllMocks()
})
it('walks batches by cursor and stops on a short batch', async () => {
const { store, listCursors, applyCalls } = makeStore({
rowsByOrder: {
1: [sourceRow({ id: 1, orderId: 1 })],
2: [sourceRow({ id: 2, orderId: 2 })],
3: [sourceRow({ id: 3, orderId: 3 })],
},
eligibleBatches: [[1, 2], [3]],
})
const summary = await runOrderItemsArchive({ batchSize: 2, maxBatches: 5 }, store)
expect(summary).toMatchObject({ scanned: 3, archived: 3, skipped: [] })
expect(listCursors).toEqual([0, 2])
expect(applyCalls.map((call) => call.orderId)).toEqual([1, 2, 3])
})
it('respects maxBatches', async () => {
const { store, listCursors } = makeStore({
rowsByOrder: {
1: [sourceRow({ id: 1, orderId: 1 })],
2: [sourceRow({ id: 2, orderId: 2 })],
3: [sourceRow({ id: 3, orderId: 3 })],
},
eligibleBatches: [[1], [2], [3]],
})
const summary = await runOrderItemsArchive({ batchSize: 1, maxBatches: 2 }, store)
expect(summary.scanned).toBe(2)
expect(listCursors).toEqual([0, 1])
})
it('advances past skipped orders and reports them', async () => {
const { store, listCursors } = makeStore({
rowsByOrder: { 10: [sourceRow()], 20: [] },
skuById: new Map(),
eligibleBatches: [[10, 20]],
})
const summary = await runOrderItemsArchive({ batchSize: 5, maxBatches: 1 }, store)
expect(summary.scanned).toBe(2)
expect(summary.archived).toBe(0)
expect(summary.skipped.map((entry) => entry.orderId).sort()).toEqual([10, 20])
expect(listCursors).toEqual([0])
})
it('passes the IST calendar cutoff to the store', async () => {
const now = new Date('2026-10-20T12:00:00.000Z')
const cutoff = istCalendarCutoffUtc(now)
const observed: Date[] = []
const store: ArchiveStore = {
loadSource: async () => ({ rows: [], skuById: new Map() }),
applyArchive: async () => true,
listEligibleOrderIds: async (value) => {
observed.push(value)
return []
},
}
await runOrderItemsArchive({ now }, store)
expect(observed).toEqual([cutoff])
})
})