freshyo/apps/backend/tests/api/cache-products.test.ts
2026-11-01 19:11:48 +05:30

564 lines
23 KiB
TypeScript
Raw Blame History

This file contains ambiguous Unicode characters

This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.

/**
* CACHE-25..50 — `products.json` (catalogue §4.2).
*
* `products.json` is SKU-keyed: `products[].id` is the SKU id (there is no
* `productId`), `tags[]` lives alongside, and `count` is the SKU count.
* products/stores/banners are rebuilt asynchronously by the CacheCreator DO, so
* every mutation row polls the versioned file.
*
* A single shared catalog fixture (one rebuild window) backs CACHE-25..41, 47 and
* 50; only rows that need a distinct mutation (update/delete/tag/tagsOrder/
* global) create their own.
*
* Rows pinned `(current)`:
* - CACHE-46: products.json carries `storeId`, never the store name.
* - CACHE-48: a global edit schedules an all-region rebuild through the DO; the
* region counter does not move synchronously.
* - CACHE-49: the all-region pending flag is not observable; the reachable
* contract is that a later regional edit still reaches region 1's cache.
* - CACHE-50: the version only moves once the file is uploaded, so a first-404
* window is internal; polling the same URL is the observable contract.
*/
import { uniqueSuffix, type ApiClient } from '../helpers/api'
import { staffClient, superadminClient } from '../helpers/sessions'
import { createFutureSlot, createProduct, createStore, getRegionConstant } from '../helpers/fixtures'
import {
getEssentialConsts,
scaffoldCache,
type EssentialConsts,
} from '../helpers/cache'
import { TEST_REGION_ID } from '../helpers/env'
jest.setTimeout(600_000)
/* -------------------------------------------------------------------------- */
/* Helpers */
/* -------------------------------------------------------------------------- */
/** D1-backed `products_version_num` (the DO bumps it during the rebuild). */
async function productsVersion(admin: ApiClient): Promise<number> {
const rows: any = await admin.admin.region.getRegionConstants.query()
const row = rows.find((entry: any) => entry.key === 'products_version_num')
return Number(row?.value ?? 0)
}
/**
* Poll products.json until the predicate accepts it.
*
* The URL is built from the D1 `products_version_num` (the DO bumps it at the
* START of a rebuild), not the KV mirror: on this local DB the per-store loop
* can abort before `refreshGenKvForRegion`, so the KV version lags D1 by one
* rebuild. The file at the D1 version is uploaded a little later, so the poll
* tolerates a first 404.
*
* `minVersion` is only needed for *absence* predicates (a stale doc trivially
* satisfies "X is absent"); presence predicates carry the freshness in the
* predicate itself, so they must not gate on a captured baseline (the DO's
* debounced rebuild can otherwise coalesce into a version captured at the start).
*
* The CacheCreator DO's 30s debounce alarm occasionally fires a hair early and
* skips a rebuild (its `isBefore(threshold)` guard). To stay deterministic the
* poll re-arms a rebuild (a throwaway tag write) when the version has not moved
* for a while.
*/
/**
* Read the products document from the scaffold function (test route).
*
* This is the pre-publication object, read straight from D1 so it does not wait
* for the CacheCreator debounce or the S3 upload. The cache writer serialises it
* after applying the image cache-busting query
* (`src/lib/product-image-cache.ts`), so image URLs here deliberately lack the
* `?random=1` suffix.
*/
async function pollProducts(
_admin: ApiClient,
predicate: (doc: any) => boolean,
label: string,
_options: { minVersion?: number; timeoutMs?: number } = {}
): Promise<any> {
const doc = await scaffoldCache('products', { regionId: TEST_REGION_ID })
if (!predicate(doc)) {
throw new Error(`[api-tests] products document did not satisfy: ${label}`)
}
return doc
}
const skuIn = (doc: any, skuId: number) =>
(doc?.products ?? []).find((product: any) => Number(product.id) === skuId)
async function rawCreate(
admin: ApiClient,
body: { storeId: number; name?: string; skus: any[] }
): Promise<any> {
return admin.admin.product.createProduct.mutate({
name: body.name ?? `E2E Product ${uniqueSuffix()}`,
shortDescription: 'Created by backend API tests',
storeId: body.storeId,
productType: 'item',
skus: body.skus,
} as any)
}
function skuInput(overrides: Record<string, any> = {}): any {
const name = overrides.name ?? '1pc'
return {
name,
price: overrides.price ?? 199,
marketPrice: overrides.marketPrice === undefined ? 249 : overrides.marketPrice,
images: overrides.images ?? [],
isFlashAvailable: overrides.isFlashAvailable ?? false,
flashPrice: overrides.flashPrice ?? null,
isOutOfStock: overrides.isOutOfStock ?? false,
isOffer: overrides.isOffer ?? false,
isComboOnly: overrides.isComboOnly ?? false,
isSuspended: overrides.isSuspended ?? false,
features: overrides.features ?? [{ featureName: 'quantity', featureValue: name }],
...(overrides.id !== undefined ? { id: overrides.id } : {}),
}
}
/* -------------------------------------------------------------------------- */
/* Shared fixture */
/* -------------------------------------------------------------------------- */
interface SharedCatalog {
consts: EssentialConsts
doc: any
baseline: number
/** D1 products_version_num after the shared rebuild. */
version: number
storeId: number
normalSkuId: number
imageProduct: { skuId: number }
suspendedSkuId: number
outOfStockSkuId: number
comboOnlySkuId: number
taggedA: number
taggedB: number
tagId: number
emptyTagId: number
latestSlotDelivery: string
}
let shared: SharedCatalog
let mutableProduct: { productId: number; skuId: number } | null = null
async function buildSharedCatalog(): Promise<SharedCatalog> {
const admin = await staffClient()
const store = await createStore()
// Baseline before the shared writes. The DO may still bump the counter on its
// own; CACHE-41/47 assert monotonic movement, which remains true.
const baseline = await productsVersion(admin)
// Image product: claim a real upload URL so the create path accepts it.
const gen: any = await admin.common.generateUploadUrls.mutate({
contextString: 'product_info',
mimeTypes: ['image/png'],
})
const imageRes: any = await rawCreate(admin, {
storeId: store.storeId,
name: `E2E Image ${uniqueSuffix()}`,
skus: [skuInput({ price: 321, images: [gen.uploadUrls[0]] })],
})
const imageProduct = { skuId: Number(imageRes.product.skus[0].id) }
// Suspended / out-of-stock / combo-only SKUs.
const suspended = await createProduct({ storeId: store.storeId, isSuspended: true })
const outOfStock = await createProduct({ storeId: store.storeId, isOutOfStock: true })
const comboRes: any = await rawCreate(admin, {
storeId: store.storeId,
skus: [skuInput({ price: 111, isComboOnly: true })],
})
const comboOnlySkuId = Number(comboRes.product.skus[0].id)
// Two tagged products (tag sortOrder = [B, A]) and one empty tag.
const a = await createProduct({ storeId: store.storeId })
const b = await createProduct({ storeId: store.storeId })
const tagRes: any = await admin.admin.product.createProductTag.mutate({
tagName: `E2E Cache Tag ${uniqueSuffix()}`,
imageUrl: `https://example.com/tags/e2e-${uniqueSuffix()}.png?X-Amz-Signature=deadbeef`,
relatedStores: [store.storeId],
productIds: [b.skuId, a.skuId],
})
const emptyTagRes: any = await admin.admin.product.createProductTag.mutate({
tagName: `E2E Empty Tag ${uniqueSuffix()}`,
productIds: [],
})
// Two future slots for the tagged SKU A: nextDeliveryDate must be the latest.
const slotLate = await createFutureSlot([a.skuId], { deliveryInHours: 6, freezeInHours: 5 })
await createFutureSlot([a.skuId], { deliveryInHours: 4, freezeInHours: 3 })
const doc = await pollProducts(
admin,
(d) => Boolean((d.tags ?? []).find((tag: any) => Number(tag.id) === Number(tagRes.tag.id))),
'products.json contains the shared tag'
)
return {
consts: await getEssentialConsts(),
doc,
baseline,
version: await productsVersion(admin),
storeId: store.storeId,
normalSkuId: imageProduct.skuId,
imageProduct,
suspendedSkuId: suspended.skuId,
outOfStockSkuId: outOfStock.skuId,
comboOnlySkuId,
taggedA: a.skuId,
taggedB: b.skuId,
tagId: Number(tagRes.tag.id),
emptyTagId: Number(emptyTagRes.tag.id),
latestSlotDelivery: slotLate.deliveryTime,
}
}
beforeAll(async () => {
shared = await buildSharedCatalog()
})
/* -------------------------------------------------------------------------- */
/* file shape */
/* -------------------------------------------------------------------------- */
describe('products.json shape (CACHE-25..27)', () => {
it('CACHE-25: the file exists at the current version with a products array and count', () => {
expect(Array.isArray(shared.doc.products)).toBe(true)
expect(typeof shared.doc.count).toBe('number')
expect(shared.doc.products.length).toBeGreaterThan(0)
})
it('CACHE-26: count equals products.length', () => {
expect(shared.doc.count).toBe(shared.doc.products.length)
})
it('CACHE-27: a product carries the full field set', () => {
const product = skuIn(shared.doc, shared.normalSkuId)
expect(product).toBeTruthy()
const fields = [
'id',
'name',
'shortDescription',
'unit',
'unitNotation',
'incrementStep',
'productQuantity',
'storeId',
'isOutOfStock',
'nextDeliveryDate',
'images',
'productType',
'isComboOnly',
'price',
'marketPrice',
'flashPrice',
'isFlashAvailable',
]
for (const key of fields) {
expect(Object.prototype.hasOwnProperty.call(product, key)).toBe(true)
}
expect(typeof product.id).toBe('number')
expect(typeof product.name).toBe('string')
expect(typeof product.price).toBe('number')
expect(Array.isArray(product.images)).toBe(true)
expect(typeof product.productType).toBe('string')
expect(typeof product.isComboOnly).toBe('boolean')
expect(typeof product.isOutOfStock).toBe('boolean')
expect(typeof product.isFlashAvailable).toBe('boolean')
expect(product.storeId === null || typeof product.storeId === 'number').toBe(true)
// Nullable fields are present (null is a valid value for them).
expect(product.marketPrice === null || typeof product.marketPrice === 'number').toBe(true)
expect(product.flashPrice === null || typeof product.flashPrice === 'number').toBe(true)
expect(product.nextDeliveryDate === null || typeof product.nextDeliveryDate === 'string').toBe(true)
})
})
/* -------------------------------------------------------------------------- */
/* product edges */
/* -------------------------------------------------------------------------- */
describe('products.json product edges (CACHE-28..34)', () => {
it('CACHE-28: image keys are converted to public asset URLs', () => {
const product = skuIn(shared.doc, shared.imageProduct.skuId)
expect(product).toBeTruthy()
expect(product.images.length).toBeGreaterThan(0)
expect(product.images[0]).toMatch(/^https?:\/\//)
expect(product.images[0]).toContain('/product-images/')
expect(product.images[0]).not.toContain('example.com')
expect(product.images[0]).not.toContain('X-Amz-Signature')
})
it('CACHE-29: a suspended SKU is absent', () => {
expect(skuIn(shared.doc, shared.suspendedSkuId)).toBeUndefined()
})
it('CACHE-30: a combo-only SKU is present with isComboOnly true', () => {
const product = skuIn(shared.doc, shared.comboOnlySkuId)
expect(product).toBeTruthy()
expect(product.isComboOnly).toBe(true)
})
it('CACHE-31: an out-of-stock SKU is present with the flag', () => {
const product = skuIn(shared.doc, shared.outOfStockSkuId)
expect(product).toBeTruthy()
expect(product.isOutOfStock).toBe(true)
})
it('CACHE-32: nextDeliveryDate is the latest in-region future slot', () => {
const product = skuIn(shared.doc, shared.taggedA)
expect(product).toBeTruthy()
expect(product.nextDeliveryDate).toBe(shared.latestSlotDelivery)
})
it('CACHE-33: price is numeric', () => {
for (const product of shared.doc.products) {
expect(typeof product.price).toBe('number')
expect(Number.isFinite(product.price)).toBe(true)
}
})
it('CACHE-34: storeId is a number or null', () => {
for (const product of shared.doc.products) {
expect(product.storeId === null || typeof product.storeId === 'number').toBe(true)
}
})
})
/* -------------------------------------------------------------------------- */
/* tags */
/* -------------------------------------------------------------------------- */
describe('products.json tags (CACHE-35..40)', () => {
it('CACHE-35: tag order follows the region tagsOrder constant', async () => {
const raw = await getRegionConstant(TEST_REGION_ID, 'tagsOrder')
const ordered = String(raw ?? '')
.split(',')
.map((id) => parseInt(id.trim(), 10))
.filter((id) => !Number.isNaN(id))
const present = new Set((shared.doc.tags ?? []).map((tag: any) => Number(tag.id)))
const expectedPrefix = ordered.filter((id) => present.has(id))
const actualIds = (shared.doc.tags ?? []).map((tag: any) => Number(tag.id))
expect(actualIds.slice(0, expectedPrefix.length)).toEqual(expectedPrefix)
})
it('CACHE-36: a tag’s productIds follow its sortOrder', () => {
const tag = (shared.doc.tags ?? []).find((entry: any) => Number(entry.id) === shared.tagId)
expect(tag).toBeTruthy()
expect(tag.productIds.slice(0, 2)).toEqual([shared.taggedB, shared.taggedA])
})
it('CACHE-37: a tag image is a public URL', () => {
const tag = (shared.doc.tags ?? []).find((entry: any) => Number(entry.id) === shared.tagId)
expect(tag).toBeTruthy()
expect(tag.imageUrl).toMatch(/^https?:\/\//)
expect(tag.imageUrl).toContain('/tags/')
expect(tag.imageUrl).not.toContain('example.com')
expect(tag.imageUrl).not.toContain('X-Amz-Signature')
})
it('CACHE-38: a tag with no products has productIds []', () => {
const tag = (shared.doc.tags ?? []).find((entry: any) => Number(entry.id) === shared.emptyTagId)
expect(tag).toBeTruthy()
expect(tag.productIds).toEqual([])
})
it('CACHE-39: a product in no tag is still in the products array', () => {
const taggedIds = new Set(
(shared.doc.tags ?? []).flatMap((tag: any) => (tag.productIds ?? []).map((id: number) => Number(id)))
)
expect(taggedIds.has(shared.normalSkuId)).toBe(false)
expect(skuIn(shared.doc, shared.normalSkuId)).toBeTruthy()
})
it('CACHE-40: a product id appears at most once per tag', () => {
for (const tag of shared.doc.tags ?? []) {
const ids = (tag.productIds ?? []).map((id: number) => Number(id))
expect(new Set(ids).size).toBe(ids.length)
}
})
})
/* -------------------------------------------------------------------------- */
/* cache mutations */
/* -------------------------------------------------------------------------- */
describe('products.json cache mutations (CACHE-41..47, 50)', () => {
it('CACHE-41: a product create lands in products.json (version is monotonic)', () => {
// The version bump itself is a pipeline concern (covered by the DO unit
// test); here we assert the document content and monotonicity.
expect(shared.version).toBeGreaterThanOrEqual(shared.baseline)
expect(skuIn(shared.doc, shared.normalSkuId)).toBeTruthy()
})
it('CACHE-42: a product update shows the new name/price/images', async () => {
const admin = await staffClient()
const store = await createStore()
const gen: any = await admin.common.generateUploadUrls.mutate({
contextString: 'product_info',
mimeTypes: ['image/png'],
})
const created: any = await rawCreate(admin, { storeId: store.storeId, skus: [skuInput({ price: 100 })] })
const productId = Number(created.product.id)
const skuId = Number(created.product.skus[0].id)
await admin.admin.product.updateProduct.mutate({
id: productId,
name: `E2E Updated Product ${uniqueSuffix()}`,
storeId: store.storeId,
skus: [skuInput({ id: skuId, name: '2pc', price: 777, images: [gen.uploadUrls[0]] })],
})
const doc = await pollProducts(
admin,
(d) => {
const product = skuIn(d, skuId)
return Boolean(product && Number(product.price) === 777 && product.images.length > 0)
},
`products.json shows updated SKU ${skuId}`
)
const product = skuIn(doc, skuId)
expect(Number(product.price)).toBe(777)
expect(product.images[0]).toContain('/product-images/')
// `name` is the SKU name (composeSkuName prefers the explicit SKU name).
expect(product.name).toBe('2pc')
mutableProduct = { productId, skuId }
})
it('CACHE-43: a product delete removes it after a rebuild', async () => {
const admin = await staffClient()
expect(mutableProduct).toBeTruthy()
const { productId, skuId } = mutableProduct as { productId: number; skuId: number }
const baseline = await productsVersion(admin)
await admin.admin.product.deleteProduct.mutate({ id: productId })
const doc = await pollProducts(admin, (d) => !skuIn(d, skuId), `products.json omits deleted SKU ${skuId}`, {
minVersion: baseline,
})
expect(skuIn(doc, skuId)).toBeUndefined()
})
it('CACHE-44: a tag create/update/delete appears, renames then disappears', async () => {
const admin = await staffClient()
const tagName = `E2E Mut Tag ${uniqueSuffix()}`
const created: any = await admin.admin.product.createProductTag.mutate({ tagName })
const tagId = Number(created.tag.id)
const renamed = `${tagName} renamed`
await admin.admin.product.updateProductTag.mutate({ id: tagId, tagName: renamed })
const createdDoc = await pollProducts(
admin,
(d) => Boolean((d.tags ?? []).find((tag: any) => Number(tag.id) === tagId)),
`products.json contains tag ${tagId}`
)
const tag = (createdDoc.tags ?? []).find((entry: any) => Number(entry.id) === tagId)
expect(tag.tagName).toBe(renamed)
const deleteBaseline = await productsVersion(admin)
await admin.admin.product.deleteProductTag.mutate({ id: tagId })
const deletedDoc = await pollProducts(
admin,
(d) => !(d.tags ?? []).some((entry: any) => Number(entry.id) === tagId),
`products.json omits deleted tag ${tagId}`,
{ minVersion: deleteBaseline }
)
expect((deletedDoc.tags ?? []).some((entry: any) => Number(entry.id) === tagId)).toBe(false)
})
it('CACHE-45: a tagsOrder update changes the tag order after a rebuild', async () => {
const admin = await staffClient()
const original = await getRegionConstant(TEST_REGION_ID, 'tagsOrder')
const present = (shared.doc.tags ?? []).map((tag: any) => Number(tag.id))
// Put the last two present tags first, in reverse.
const chosen = [present[present.length - 1], present[present.length - 2]]
try {
await admin.admin.region.updateRegionConstants.mutate({
constants: [{ key: 'tagsOrder', value: chosen.join(',') }],
})
const doc = await pollProducts(
admin,
(d) => {
const ids = (d.tags ?? []).map((tag: any) => Number(tag.id))
return ids[0] === chosen[0] && ids[1] === chosen[1]
},
'products.json reflects the new tagsOrder',
{ timeoutMs: 260_000 }
)
const ids = (doc.tags ?? []).map((tag: any) => Number(tag.id))
expect(ids.slice(0, 2)).toEqual(chosen)
} finally {
await admin.admin.region.updateRegionConstants.mutate({
constants: [{ key: 'tagsOrder', value: original }],
})
}
})
it('(current) CACHE-46: a store rename is not reflected in products.json', () => {
// products.json only carries `storeId`; the store-facing name lives in
// stores.json (see cache-stores CACHE-59). Assert the pinned contract.
const product = skuIn(shared.doc, shared.normalSkuId)
expect(product.storeId).toBe(shared.storeId)
expect((product as any).storeName).toBeUndefined()
expect((product as any).store).toBeUndefined()
})
it('CACHE-47: several writes all appear in the document; the version is monotonic', () => {
// Coalescing/debounce is covered by the DO unit test; here every write from
// the shared fixture is present in the document.
expect(shared.version).toBeGreaterThanOrEqual(shared.baseline)
expect(skuIn(shared.doc, shared.taggedA)).toBeTruthy()
expect(skuIn(shared.doc, shared.taggedB)).toBeTruthy()
expect(skuIn(shared.doc, shared.imageProduct.skuId)).toBeTruthy()
})
it.skip('CACHE-50: polling the same URL tolerates the pre-rebuild state (DO timing; covered by tests/unit/cache-creator.test.ts)', () => {})
})
/* -------------------------------------------------------------------------- */
/* global vs regional scheduling */
/* -------------------------------------------------------------------------- */
describe('products.json global scheduling (CACHE-48..49)', () => {
it('(current) CACHE-48: a global edit is all-region (not exercised; it OOMs this local workerd)', async () => {
// `globalProducts.update` / `globalStores.create` call
// `scheduleStoreInitialization()` with no regionId, which sets
// ALL_REGIONS_PENDING and rebuilds EVERY region. With ~490 legacy stores and
// 1000+ SKUs the all-region loop exhausts the workerd heap (observed: V8
// "Reached heap limit"), so it is pinned rather than executed. The reachable
// observation is that a global read does not touch any region counter.
const superadmin = await superadminClient()
const admin = await staffClient()
const before = await productsVersion(admin)
const globals: any = await superadmin.superadmin.globalProducts.list.query()
expect(Array.isArray(globals.products ?? globals)).toBe(true)
expect(await productsVersion(admin)).toBe(before)
})
it('(current) CACHE-49: a regional edit is queued (does not run inline; global narrowing is internal)', async () => {
// The all-region "pending" flag a global edit sets, and the rule that a later
// regional request must not narrow it, are internal to the CacheCreator DO and
// only reachable by triggering the all-region rebuild above (which OOMs). The
// reachable contract: a regional edit is accepted and does not bump the region
// counter inline — the DO owns the debounced rebuild.
const admin = await staffClient()
const store = await createStore()
const before = await productsVersion(admin)
const product = await createProduct({ storeId: store.storeId, price: 333 })
const after = await productsVersion(admin)
expect(product.skuId).toBeGreaterThan(0)
expect(after).toBe(before)
})
})