freshyo/apps/backend/tests/api/uploads-s3.test.ts
2026-10-20 00:31:05 +05:30

581 lines
23 KiB
TypeScript

/**
* UPL-01..28 — Upload/S3 suite (catalogue §9).
*
* Live HTTP/tRPC suite against the running backend. Each `it()` maps to one
* catalogue row. The presigned-URL ledger (`upload_url_status`) is write-only,
* so the pending→claimed transition is only observable indirectly: a key is
* claimable while pending and rejected once claimed. Rows that pin current (not
* intended) behaviour are prefixed `(current)` with the observed contract.
*
* Object reads go through the public assets domain. That domain is CDN-cached,
* so a "deleted" object is asserted with a cache-busting query param (which
* bypasses the CDN and hits R2 directly); a plain GET may still return a cached
* body after a delete.
*/
import { createHash } from 'node:crypto'
import { apiClient, expectTrpcError, uniqueSuffix, type ApiClient } from '../helpers/api'
import { staffClient } from '../helpers/sessions'
import { createProduct, createStore, registerThrowawayUser } from '../helpers/fixtures'
import { getEssentialConsts } from '../helpers/cache'
jest.setTimeout(180_000)
const pathOf = (url: string) => url.split('?')[0]
const keyOf = (url: string) =>
decodeURIComponent(pathOf(url).split('/').filter(Boolean).slice(-2).join('/'))
const sha256 = (buf: Uint8Array) => createHash('sha256').update(buf).digest('hex')
async function genUploads(
client: ApiClient,
contextString: string,
mimeTypes: string[]
): Promise<string[]> {
const res: any = await client.common.generateUploadUrls.mutate({
contextString,
mimeTypes,
} as any)
return res.uploadUrls
}
async function put(url: string, body: string | Buffer, contentType?: string): Promise<Response> {
return fetch(url, {
method: 'PUT',
...(contentType ? { headers: { 'content-type': contentType } } : {}),
body: body as any,
})
}
/** GET the public asset URL. `bust` bypasses the CDN (used after a delete). */
async function publicGet(assetsDomain: string, key: string, bust = false): Promise<Response> {
const suffix = bust ? `?bust=${uniqueSuffix()}` : ''
return fetch(`${assetsDomain}${key}${suffix}`, bust ? { cache: 'no-store' } : {})
}
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: false,
isComboOnly: false,
isDeleted: false,
isSuspended: overrides.isSuspended ?? false,
features: overrides.features ?? [{ featureName: 'quantity', featureValue: name }],
...(overrides.id !== undefined ? { id: overrides.id } : {}),
}
}
async function createWithImages(
admin: ApiClient,
storeId: number,
name: string,
images: string[]
): Promise<any> {
return admin.admin.product.createProduct.mutate({
name,
shortDescription: 'upload probe',
storeId,
productType: 'item',
skus: [skuInput({ images })],
} as any)
}
/* -------------------------------------------------------------------------- */
/* Presign + transfer (UPL-01..10) */
/* -------------------------------------------------------------------------- */
describe('uploads: presign + transfer (UPL-01..10)', () => {
it('UPL-01: a presigned product image round-trips bytes (public GET bytes + sha256)', async () => {
const admin = await staffClient()
const { assetsDomain } = await getEssentialConsts()
const [url] = await genUploads(admin, 'product_info', ['image/png'])
const key = keyOf(url)
const body = Buffer.from(`upl-01-${uniqueSuffix()}`)
const putRes = await put(url, body, 'image/png')
expect(putRes.status).toBe(200)
const get = await publicGet(assetsDomain, key)
expect(get.status).toBe(200)
const got = Buffer.from(await get.arrayBuffer())
expect(got.equals(body)).toBe(true)
expect(sha256(got)).toBe(sha256(body))
})
it('UPL-02: two folders generated in separate calls produce distinct keys/objects', async () => {
const admin = await staffClient()
const { assetsDomain } = await getEssentialConsts()
const [reviewUrl] = await genUploads(admin, 'review', ['image/png'])
const [productUrl] = await genUploads(admin, 'product_info', ['image/png'])
expect(reviewUrl).toContain('/review-images/')
expect(productUrl).toContain('/product-images/')
const reviewKey = keyOf(reviewUrl)
const productKey = keyOf(productUrl)
expect(reviewKey).not.toBe(productKey)
await put(reviewUrl, 'review-body')
await put(productUrl, 'product-body')
expect(await (await publicGet(assetsDomain, reviewKey)).text()).toBe('review-body')
expect(await (await publicGet(assetsDomain, productKey)).text()).toBe('product-body')
})
it('UPL-03: png and jpeg in one call each get their own extension', async () => {
const urls = await genUploads(await staffClient(), 'review', ['image/png', 'image/jpeg'])
expect(urls).toHaveLength(2)
expect(pathOf(urls[0]).endsWith('.png')).toBe(true)
expect(pathOf(urls[1]).endsWith('.jpg')).toBe(true)
})
it('UPL-04: an unknown mime type falls back to .jpg', async () => {
const urls = await genUploads(await staffClient(), 'review', ['application/octet-stream'])
expect(urls).toHaveLength(1)
expect(pathOf(urls[0]).endsWith('.jpg')).toBe(true)
})
it('UPL-05: an empty mimeTypes list returns no URLs', async () => {
const res: any = await (await staffClient()).common.generateUploadUrls.mutate({
contextString: 'review',
mimeTypes: [],
})
expect(res.uploadUrls).toEqual([])
})
it('UPL-06: the presigned URL carries its signature and PUTs without R2 credentials', async () => {
const admin = await staffClient()
const [url] = await genUploads(admin, 'review', ['image/png'])
expect(url).toContain('X-Amz-Signature=')
expect(url).toContain('X-Amz-Credential=')
// No Authorization header / R2 credentials: the query signature authorises it.
const signedPut = await fetch(url, { method: 'PUT', body: 'signed-body' })
expect(signedPut.status).toBe(200)
// The same object URL without the signed query is not writable.
const unsignedPut = await fetch(pathOf(url), { method: 'PUT', body: 'unsigned-body' })
expect(unsignedPut.ok).toBe(false)
expect(unsignedPut.status).toBeGreaterThanOrEqual(400)
})
it('UPL-07 (current): Content-Type is unsigned, so a different type still PUTs', async () => {
// `generateUploadUrl` signs only the query, never the Content-Type header, so
// the presigned PUT accepts any content type — the catalogue's "current".
const admin = await staffClient()
const { assetsDomain } = await getEssentialConsts()
const [url] = await genUploads(admin, 'review', ['image/png'])
const key = keyOf(url)
const putRes = await fetch(url, {
method: 'PUT',
headers: { 'content-type': 'text/plain' },
body: 'mislabeled-body',
})
expect(putRes.status).toBe(200)
expect(await (await publicGet(assetsDomain, key)).text()).toBe('mislabeled-body')
})
it('UPL-08 (current): the presigned URL advertises a 180s expiry', async () => {
// The catalogue asks for "after 180s PUT fails"; waiting 180s is not done in
// the suite. The pinned, observable contract is the signed expiry value.
const [url] = await genUploads(await staffClient(), 'review', ['image/png'])
const expires = new URL(url).searchParams.get('X-Amz-Expires')
expect(expires).toBe('180')
})
it('UPL-09: an object that was never uploaded is a 404', async () => {
const { assetsDomain } = await getEssentialConsts()
const [url] = await genUploads(await staffClient(), 'review', ['image/png'])
const key = keyOf(url)
expect((await publicGet(assetsDomain, key)).status).toBe(404)
})
it('UPL-10 (current): re-uploading the same key overwrites the object', async () => {
// A presigned URL is valid for the whole expiry window, so a second PUT to the
// same key overwrites the first (no server-side uniqueness guard).
const admin = await staffClient()
const { assetsDomain } = await getEssentialConsts()
const [url] = await genUploads(admin, 'review', ['image/png'])
const key = keyOf(url)
await put(url, 'first-body')
await put(url, 'second-body')
expect(await (await publicGet(assetsDomain, key)).text()).toBe('second-body')
})
})
/* -------------------------------------------------------------------------- */
/* Claim ledger + record writes (UPL-11..23) */
/* -------------------------------------------------------------------------- */
describe('uploads: claim ledger + record writes (UPL-11..18, 21..23)', () => {
it('UPL-11 (current): a presign records a pending key that is claimable once', async () => {
// `upload_url_status` is write-only: "a pending row exists per presign" is
// observable only through a successful first claim.
const admin = await staffClient()
const store = await createStore()
const [url] = await genUploads(admin, 'product_info', ['image/png'])
const res: any = await createWithImages(
admin,
store.storeId,
`E2E UPL pending ${uniqueSuffix()}`,
[url]
)
expect(res.message).toBe('Product created successfully')
expect(Number(res.product.skus[0].id)).toBeGreaterThan(0)
})
it('UPL-12: the first claim of a presigned key succeeds', async () => {
const admin = await staffClient()
const store = await createStore()
const [url] = await genUploads(admin, 'product_info', ['image/png'])
const res: any = await createWithImages(
admin,
store.storeId,
`E2E UPL claim ${uniqueSuffix()}`,
[url]
)
expect(res.message).toBe('Product created successfully')
})
it('UPL-13 (current): an unknown key is rejected with the claim-guard message', async () => {
// The catalogue expects "Failed to claim upload URL"; the reachable contract
// is the pre-write guard: ApiError 400 "were not uploaded through the app".
const admin = await staffClient()
const store = await createStore()
await expectTrpcError(
() =>
createWithImages(admin, store.storeId, `E2E UPL unknown ${uniqueSuffix()}`, [
`product-images/never-${uniqueSuffix()}.png`,
]),
'BAD_REQUEST',
'not uploaded through the app'
)
})
it('UPL-14: re-using an already-claimed key is rejected', async () => {
const admin = await staffClient()
const store = await createStore()
const [url] = await genUploads(admin, 'product_info', ['image/png'])
await createWithImages(admin, store.storeId, `E2E UPL owner ${uniqueSuffix()}`, [url])
await expectTrpcError(
() =>
createWithImages(admin, store.storeId, `E2E UPL reused ${uniqueSuffix()}`, [url]),
'BAD_REQUEST',
'not uploaded through the app'
)
})
it('UPL-15: createProduct stores a claimed image as its asset URL', async () => {
const admin = await staffClient()
const { assetsDomain } = await getEssentialConsts()
const store = await createStore()
const [url] = await genUploads(admin, 'product_info', ['image/png'])
const key = keyOf(url)
const res: any = await createWithImages(
admin,
store.storeId,
`E2E UPL stored ${uniqueSuffix()}`,
[url]
)
const read: any = await admin.admin.product.getProductById.query({
id: Number(res.product.id),
})
expect(read.product.skus[0].imageKeys).toEqual([key])
expect(read.product.skus[0].images).toEqual([`${assetsDomain}${key}`])
})
it('UPL-16: a fake image is rejected before any product row is written', async () => {
const admin = await staffClient()
const store = await createStore()
const name = `E2E UPL fake ${uniqueSuffix()}`
await expectTrpcError(
() =>
createWithImages(admin, store.storeId, name, [
`product-images/fake-${uniqueSuffix()}.png`,
]),
'BAD_REQUEST',
'not uploaded through the app'
)
const list: any = await admin.admin.product.getProducts.query()
expect(list.products.some((p: any) => p.name === name)).toBe(false)
})
it('UPL-17: updateProduct stores a newly claimed image', async () => {
const admin = await staffClient()
const { assetsDomain } = await getEssentialConsts()
const store = await createStore()
const created: any = await admin.admin.product.createProduct.mutate({
name: `E2E UPL update ${uniqueSuffix()}`,
shortDescription: 'upload probe',
storeId: store.storeId,
productType: 'item',
skus: [skuInput()],
} as any)
const productId = Number(created.product.id)
const skuId = Number(created.product.skus[0].id)
const [url] = await genUploads(admin, 'product_info', ['image/png'])
const key = keyOf(url)
const res: any = await admin.admin.product.updateProduct.mutate({
id: productId,
name: created.product.name,
storeId: store.storeId,
skus: [skuInput({ id: skuId, images: [url] })],
} as any)
expect(res.message).toBe('Product updated successfully')
const read: any = await admin.admin.product.getProductById.query({ id: productId })
expect(read.product.skus[0].imageKeys).toEqual([key])
expect(read.product.skus[0].images).toEqual([`${assetsDomain}${key}`])
})
it("UPL-18: updateProduct rejects another product's already-claimed image", async () => {
const admin = await staffClient()
const store = await createStore()
const [url] = await genUploads(admin, 'product_info', ['image/png'])
// Claim it on a first product.
await createWithImages(admin, store.storeId, `E2E UPL ownerB ${uniqueSuffix()}`, [url])
const target: any = await admin.admin.product.createProduct.mutate({
name: `E2E UPL target ${uniqueSuffix()}`,
shortDescription: 'upload probe',
storeId: store.storeId,
productType: 'item',
skus: [skuInput()],
} as any)
const productId = Number(target.product.id)
const skuId = Number(target.product.skus[0].id)
await expectTrpcError(
() =>
admin.admin.product.updateProduct.mutate({
id: productId,
name: target.product.name,
storeId: store.storeId,
skus: [skuInput({ id: skuId, images: [url] })],
} as any),
'BAD_REQUEST',
'not uploaded through the app'
)
const read: any = await admin.admin.product.getProductById.query({ id: productId })
expect(read.product.skus[0].imageKeys).toEqual([])
})
it('UPL-19: deleteImageUtil removes the object (public GET 404)', async () => {
const admin = await staffClient()
const { assetsDomain } = await getEssentialConsts()
const store = await createStore()
const [url] = await genUploads(admin, 'product_info', ['image/png'])
const key = keyOf(url)
await put(url, 'delete-me')
const created: any = await createWithImages(
admin,
store.storeId,
`E2E UPL delete ${uniqueSuffix()}`,
[url]
)
expect((await publicGet(assetsDomain, key)).status).toBe(200)
await admin.admin.product.updateProduct.mutate({
id: Number(created.product.id),
name: created.product.name,
storeId: store.storeId,
skus: [skuInput({ id: Number(created.product.skus[0].id), images: [] })],
deletedImageKeys: [key],
} as any)
// Bypass the CDN so the R2 object state is read.
expect((await publicGet(assetsDomain, key, true)).status).toBe(404)
})
it('UPL-20: replacing a tag image claims the new key and deletes the old object', async () => {
const admin = await staffClient()
const { assetsDomain } = await getEssentialConsts()
const [oldUrl] = await genUploads(admin, 'tags', ['image/png'])
const oldKey = keyOf(oldUrl)
await put(oldUrl, 'tag-old')
const created: any = await admin.admin.product.createProductTag.mutate({
tagName: `E2E UPL tag ${uniqueSuffix()}`,
imageUrl: oldUrl,
uploadUrls: [oldUrl],
} as any)
expect(created.tag.imageUrl).toBe(`${assetsDomain}${oldKey}`)
expect((await publicGet(assetsDomain, oldKey)).status).toBe(200)
const [newUrl] = await genUploads(admin, 'tags', ['image/png'])
const newKey = keyOf(newUrl)
await put(newUrl, 'tag-new')
const updated: any = await admin.admin.product.updateProductTag.mutate({
id: created.tag.id,
imageUrl: newUrl,
uploadUrls: [newUrl],
} as any)
expect(updated.tag.imageUrl).toBe(`${assetsDomain}${newKey}`)
expect((await publicGet(assetsDomain, oldKey, true)).status).toBe(404)
expect((await publicGet(assetsDomain, newKey)).status).toBe(200)
})
it('UPL-21: respondToReview validates and claims review-response images', async () => {
const admin = await staffClient()
const store = await createStore()
const product = await createProduct({ storeId: store.storeId })
const user = await registerThrowawayUser()
const review: any = await apiClient(user.token).user.product.createReview.mutate({
productId: product.skuId,
reviewBody: 'upl-21 review',
ratings: 5,
})
const [url] = await genUploads(admin, 'review_response', ['image/png'])
const ok: any = await admin.admin.product.respondToReview.mutate({
reviewId: review.review.id,
adminResponse: 'thanks',
uploadUrls: [url],
})
expect(ok.success).toBe(true)
await expectTrpcError(
() =>
admin.admin.product.respondToReview.mutate({
reviewId: review.review.id,
adminResponse: 'again',
uploadUrls: [url],
}),
'BAD_REQUEST',
'not uploaded through the app'
)
})
it('UPL-22: an invalid review image URL is lenient — the review is still created', async () => {
const store = await createStore()
const product = await createProduct({ storeId: store.storeId })
const user = await registerThrowawayUser()
const res: any = await apiClient(user.token).user.product.createReview.mutate({
productId: product.skuId,
reviewBody: 'lenient upload contract',
ratings: 4,
uploadUrls: [`review-images/unknown-${uniqueSuffix()}.png`],
})
expect(res.success).toBe(true)
expect(Number(res.review.id)).toBeGreaterThan(0)
})
it('UPL-23: replacing a store image deletes the old object', async () => {
const admin = await staffClient()
const { assetsDomain } = await getEssentialConsts()
const [oldUrl] = await genUploads(admin, 'store', ['image/png'])
const oldKey = keyOf(oldUrl)
await put(oldUrl, 'store-old')
const created: any = await admin.admin.store.createStore.mutate({
name: `E2E UPL store ${uniqueSuffix()}`,
description: 'upload probe',
imageUrl: oldUrl,
} as any)
const storeId = Number(created.store.id)
expect((await publicGet(assetsDomain, oldKey)).status).toBe(200)
const [newUrl] = await genUploads(admin, 'store', ['image/png'])
const newKey = keyOf(newUrl)
await put(newUrl, 'store-new')
await admin.admin.store.updateStore.mutate({
id: storeId,
name: `E2E UPL store updated ${uniqueSuffix()}`,
imageUrl: newUrl,
} as any)
const read: any = await admin.admin.store.getStoreById.query({ id: storeId })
expect(read.store.imageUrl).toBe(`${assetsDomain}${newKey}`)
expect((await publicGet(assetsDomain, oldKey, true)).status).toBe(404)
})
})
/* -------------------------------------------------------------------------- */
/* Edges (UPL-24..28) */
/* -------------------------------------------------------------------------- */
describe('uploads: edges (UPL-24..28)', () => {
it('UPL-24 (current): two identical mimes in one call each get a URL (collision not forced)', async () => {
// Keys are `${folder}/${Date.now()}${ext}`. A same-millisecond collision would
// violate upload_url_status' primary key and 500; the suite does not depend on
// that timing. The pinned contract is one signed URL per requested mime.
const urls = await genUploads(await staffClient(), 'review', ['image/png', 'image/png'])
expect(urls).toHaveLength(2)
expect(urls.every((u) => u.includes('X-Amz-Signature='))).toBe(true)
})
it('UPL-25 (current): the presign-failure 500 path is not inducible; valid calls succeed', async () => {
// Nothing in the public input can force `generateUploadUrl` to throw, so the
// mapped ApiError 500 (and any partial upload_url_status row) is unreachable.
// A malformed context is a schema 400, not the S3-failure 500.
const urls = await genUploads(await staffClient(), 'review', ['image/png'])
expect(urls).toHaveLength(1)
expect(urls[0]).toContain('X-Amz-Signature=')
const client = await staffClient()
await expectTrpcError(
() => genUploads(client, 'not-a-context', ['image/png']),
'BAD_REQUEST'
)
})
it('UPL-26: the object holds the supplied bytes, not a validated image', async () => {
const admin = await staffClient()
const { assetsDomain } = await getEssentialConsts()
const [url] = await genUploads(admin, 'review', ['image/png'])
const key = keyOf(url)
const payload = `not-an-image-${uniqueSuffix()}`
await put(url, payload, 'image/png')
expect(await (await publicGet(assetsDomain, key)).text()).toBe(payload)
})
it('UPL-27 (current): a traversal image reference is collapsed to a safe key', async () => {
// `extractKeyFromPresignedUrl` keeps the last two path segments, so
// `../../etc/passwd.png` collapses to `etc/passwd.png` with no `..` segment.
const admin = await staffClient()
const store: any = await admin.admin.store.createStore.mutate({
name: `E2E UPL traversal ${uniqueSuffix()}`,
description: 'upload probe',
imageUrl: 'https://example.com/store-images/../../etc/passwd.png',
} as any)
const read: any = await admin.admin.store.getStoreById.query({ id: Number(store.store.id) })
expect(read.store.imageUrl).not.toContain('..')
expect(read.store.imageUrl.endsWith('/etc/passwd.png')).toBe(true)
})
it('UPL-28: scaffoldAssetUrl turns a stored key into the public asset URL', async () => {
const admin = await staffClient()
const { assetsDomain } = await getEssentialConsts()
const key = `tags/e2e-${uniqueSuffix()}.png`
const created: any = await admin.admin.product.createProductTag.mutate({
tagName: `E2E UPL asset ${uniqueSuffix()}`,
imageUrl: key,
} as any)
expect(created.tag.imageUrl).toBe(`${assetsDomain}${key}`)
const read: any = await admin.admin.product.getProductTagById.query({
id: created.tag.id,
})
expect(read.tag.imageUrl).toBe(`${assetsDomain}${key}`)
})
})