freshyo/apps/user-ui/tests/mocks/api.ts
2026-10-02 00:25:43 +05:30

329 lines
12 KiB
TypeScript

/**
* Network-layer mocks for the user-ui tests.
*
* Everything the home page fetches goes through one of two doors:
* - tRPC -> global.fetch (common.essentialConsts, user.order.getOrders, ...)
* - axios -> the assets CDN (products.json, stores.json, slots.json, availability.json)
*
* Both are stubbed here and both fail loudly on an unmocked URL, so a new
* dependency introduced by app code surfaces as a test failure instead of a
* silent empty render.
*
* The tRPC URL is matched on the procedure path rather than the host, because
* BASE_API_URL (@packages/shared) is a local address during development.
* `jest.mock('axios')` lives in tests/setup.ts so it is registered before any
* app module imports axios.
*
* Fixtures are imported as JSON rather than read with `fs`: importing a Node
* builtin pulls @types/node into the typecheck program, which flips
* `setTimeout` from `number` to `NodeJS.Timeout` and breaks unrelated app types.
*
* NOTE: mock-slots-response.json is a snapshot of one real day, so its dates are
* rebased relative to the frozen clock below rather than used as-is.
*/
import essentialConsts from '../__fixtures__/essentialConsts.json'
import availability from './mock-availability-response.json'
import products from './mock-products-response.json'
import slotsRaw from './mock-slots-response.json'
import storeProducts from './mock-store-products-response.json'
import stores from './mock-stores-response.json'
import { StorageServiceCasual } from 'common-ui/src/services/StorageServiceCasual'
import { parseTrpcUrl } from './procedures'
/** The payload the common.essentialConsts procedure resolves to (unwrapped). */
export const ESSENTIAL_CONSTS_DATA = essentialConsts[0].result.data
/** essentialConsts with flash delivery switched on (flash-option tests). */
export const FLASH_ENABLED_CONSTS = {
...ESSENTIAL_CONSTS_DATA,
isFlashDeliveryEnabled: true,
}
/** products.json with no tags and no products (empty-state tests). */
export const EMPTY_PRODUCTS = { products: [], tags: [] }
/** A dashboard tag that points at no products (empty-tag-grid test). */
export const EMPTY_TAG = {
id: 9999,
tagName: 'Empty',
tagDescription: null,
imageUrl: null,
isDashboardTag: true,
productIds: [],
}
/**
* The mocked StorageServiceCasual keeps its map at module scope, so the cart
* survives from one test to the next. Call from beforeEach.
*
* `essential_consts` is deliberately NOT cleared here: when it is persisted,
* useGetEssentialConsts gets placeholderData synchronously, which
* tests/home-page/navigation.test.tsx (real router) relies on. A file that
* overrides the constants must clear it itself via resetEssentialConsts().
*/
export async function resetStorage() {
await StorageServiceCasual.clearAll(['cart_items', 'flash_cart_items'])
}
/** Clears the persisted essentialConsts so the next render refetches them. */
export async function resetEssentialConsts() {
await StorageServiceCasual.clearAll(['essential_consts'])
}
/**
* The slot fixture is a snapshot of a real day. The home page drops slots whose
* deliveryTime is not after `dayjs()`, so the fixture would silently expire.
* Shift every slot by the same delta so the earliest lands FIRST_SLOT_LEAD_MS
* ahead of now, keeping the relative spacing and the freeze-before-delivery
* offset intact. Ids and per-slot product lists are untouched.
*/
const FIRST_SLOT_LEAD_MS = 2 * 60 * 60 * 1000
/** How far in the past the synthetic expired slots freeze. */
const EXPIRED_FREEZE_MS = 2 * 60 * 1000
export const EXPIRED_HOME_SLOT_ID = 9001
export const EXPIRED_DIALOG_SLOT_ID = 9002
const rebaseSlots = (raw: typeof slotsRaw) => {
const offset =
Date.now() +
FIRST_SLOT_LEAD_MS -
new Date(raw.slots[0].deliveryTime).getTime()
return {
...raw,
slots: raw.slots.map((slot) => ({
...slot,
deliveryTime: new Date(
new Date(slot.deliveryTime).getTime() + offset
).toISOString(),
freezeTime: new Date(
new Date(slot.freezeTime).getTime() + offset
).toISOString(),
})),
}
}
/** Slots as the app will receive them (rebased), for building expectations. */
export const mockSlots = (() => { const rebased = rebaseSlots(slotsRaw)
const now = Date.now()
// Slots whose freezeTime has passed but whose delivery is still upcoming.
// The backend filters these out (scaffoldSlotsWithProducts) and the cart
// dialog filters them out too; these exist so the home strip can be shown to
// do the same. Delivery times are picked deliberately:
// 9001 earliest -> an unfiltered slot would sort first and fail loudly
// instead of hiding beyond the 5-item slice
// 9002 latest -> getQuickestSlot (which ignores freezeTime) still
// resolves product 23 to its real, earlier slot
const expiredSlot = (id: number, deliveryLeadMs: number, productIds: number[]) => ({
id,
deliveryTime: new Date(now + deliveryLeadMs).toISOString(),
freezeTime: new Date(now - EXPIRED_FREEZE_MS).toISOString(),
products: productIds.map((productId) => ({
id: productId,
images: [] as string[],
})),
})
return {
...rebased,
slots: [
...rebased.slots,
expiredSlot(EXPIRED_HOME_SLOT_ID, 60 * 60 * 1000, []),
expiredSlot(EXPIRED_DIALOG_SLOT_ID, 20 * 60 * 60 * 1000, [23]),
],
}
})()
const productsInAnySlot = new Set<number>()
mockSlots.slots.forEach((slot) =>
slot.products.forEach((p) => productsInAnySlot.add(p.id))
)
const flaggedOutOfStock = new Set(
availability.availability.filter((a) => a.isOutOfStock).map((a) => a.id)
)
/**
* The products the UI should treat as unavailable: flagged out of stock by the
* availability cache, or present in no upcoming slot. Mirrors
* displayIsOutOfStock / productsByTagId in the page. Combo-only SKUs are
* dropped because useAllProducts filters them out.
*/
export const outOfStockIds = new Set<number>(
products.products
.filter((p) => !p.isComboOnly)
.map((p) => p.id)
.filter((id) => flaggedOutOfStock.has(id) || !productsInAnySlot.has(id))
)
export const ESSENTIAL_CONSTS_URL =
'https://worker.freshyo.in/api/trpc/common.essentialConsts?batch=1&input=%7B%220%22%3A%7B%22json%22%3Anull%2C%22meta%22%3A%7B%22values%22%3A%5B%22undefined%22%5D%7D%7D%7D'
// Derived by useCacheUrl / useAvailabilityCacheUrl / useSlotsCacheUrl from the
// essentialConsts payload above (assetsDomain, apiCacheKey, cacheVersion,
// availabilityVersionNum, slotsVersionNum).
export const PRODUCTS_URL =
'https://assets.freshyo.in/api-cache/v-755/products.json'
export const AVAILABILITY_URL =
'https://assets.freshyo.in/av-72/availability.json'
export const STORES_URL = 'https://assets.freshyo.in/api-cache/v-755/stores.json'
export const SLOTS_URL = 'https://assets.freshyo.in/slots/v-401/slots.json?v=123'
/** useStoreWithProducts URL for a given store id. */
export const storeDetailUrl = (storeId: number | string) =>
`https://assets.freshyo.in/api-cache/v-755/stores/${storeId}.json`
const jsonResponse = (body: unknown) => ({
ok: true,
status: 200,
statusText: 'OK',
headers: new Map(),
url: '',
json: async () => body,
text: async () => JSON.stringify(body),
})
const errorResponse = (status: number, message: string) => ({
ok: false,
status,
statusText: message,
headers: new Map(),
url: '',
json: async () => ({ message }),
text: async () => message,
})
export interface ApiMockOptions {
/** Replace the products.json body entirely (e.g. EMPTY_PRODUCTS). */
products?: unknown
/** Append tags to the products.json body's `tags` (empty-tag-grid test). */
extraTags?: unknown[]
/** Override the stores.json body. */
stores?: unknown
/** Override the stores/<id>.json body (useStoreWithProducts). */
storeProducts?: unknown
/** Override the essentialConsts payload (unwrapped procedure data). */
consts?: unknown
/** user.order.getOrders data (NextOrderGlimpse). */
orders?: unknown[]
/**
* tRPC procedure registry: name -> data, or (input) => data. Merged over the
* built-in essentials (common.essentialConsts, user.order.getOrders/orders).
* An unknown procedure throws, so a new dependency surfaces loudly.
*/
procedures?: Record<string, unknown | ((input: unknown) => unknown)>
/** axios.get(products.json) rejects -> the products query errors. */
failProducts?: boolean
/** axios.get(stores.json) rejects -> the stores query errors. */
failStores?: boolean
/** axios.get(slots.json) rejects -> the slots query errors. */
failSlots?: boolean
/** The essentialConsts fetch resolves non-ok -> the consts query errors. */
failConsts?: boolean
/** axios.get(products.json) never resolves -> the products query stays loading. */
pendingProducts?: boolean
/** axios.get(slots.json) never resolves -> the slots query stays loading. */
pendingSlots?: boolean
}
/**
* Install the fetch + axios stubs and return the handles for assertions.
* Call from beforeEach so each test starts from a clean call history.
*/
export function setupApiMocks(opts: ApiMockOptions = {}) {
const axios = require('axios')
const constsData = opts.consts ?? ESSENTIAL_CONSTS_DATA
const orders = opts.orders ?? []
const baseProducts = (opts.products ?? products) as { tags?: unknown[] }
const productsBody = opts.extraTags?.length
? { ...baseProducts, tags: [...(baseProducts.tags ?? []), ...opts.extraTags] }
: baseProducts
/** Route a CDN file name to its mock response. */
const mockForCacheFile = (url: string): unknown => {
if (url.includes('products.json')) return productsBody
if (/stores\/\d+\.json/.test(url)) return opts.storeProducts ?? storeProducts
if (url.includes('stores.json')) return opts.stores ?? stores
if (url.includes('slots.json')) return mockSlots
if (url.includes('availability.json')) return availability
throw new Error(`[tests] unmocked assets request: ${url}`)
}
axios.get.mockImplementation(async (url: string) => {
const target = String(url)
if (target.includes('products.json')) {
if (opts.pendingProducts) return new Promise(() => {})
if (opts.failProducts) throw new Error('products request failed')
}
if (opts.failStores && target.includes('stores')) {
throw new Error('stores request failed')
}
if (target.includes('slots.json')) {
if (opts.pendingSlots) return new Promise(() => {})
if (opts.failSlots) throw new Error('slots request failed')
}
return {
data: mockForCacheFile(target),
status: 200,
statusText: 'OK',
headers: {},
config: {},
}
})
/** Resolve one procedure name from a (possibly batched) tRPC request. */
const resolveProcedure = (name: string, input: unknown): unknown => {
const override = opts.procedures?.[name]
if (override !== undefined) {
return typeof override === 'function'
? (override as (value: unknown) => unknown)(input)
: override
}
if (name === 'common.essentialConsts') return constsData
if (name === 'user.order.getOrders' && opts.orders !== undefined) {
return { data: orders }
}
throw new Error(
`[tests] unmocked trpc procedure: ${name} (add it to setupApiMocks({ procedures }))`
)
}
const fetchMock = jest.fn(
async (url: string, options?: { method?: string; body?: unknown }) => {
const target = String(url)
if (opts.failConsts && target.includes('common.essentialConsts')) {
return errorResponse(500, 'consts request failed')
}
// The path after /api/trpc/ is a comma-separated list of procedure names
// (httpBatchLink batches every operation issued in the same tick).
const calls = parseTrpcUrl(target, options?.body)
if (calls.length === 0) {
// Presigned S3 uploads (useUploadToObjectStorage) PUT straight to a URL.
if (options?.method === 'PUT') return jsonResponse({})
throw new Error(`[tests] unmocked fetch: ${url}`)
}
const batch = calls.map(({ name, input }) => ({
result: { data: resolveProcedure(name, input) },
}))
return jsonResponse(batch)
}
)
;(global as unknown as { fetch: unknown }).fetch = fetchMock
return { fetchMock, axiosGet: axios.get }
}