/** * Coupon discount maths at placeOrder time. * * The discount is computed server-side in placeOrderUtil * (apps/backend/src/trpc/apis/user-apis/apis/order.ts) and persisted to * orders.totalAmount. These tests read the order row returned by placeOrder * (totalAmount is the stored string). * * The backend mirrors the customer app's model: the coupon discounts the whole * cart subtotal, and delivery is decided on the post-discount total. Remaining * KNOWN BUGS are pinned here (negative totals for >=100% coupons, no rounding). * See tests/BUGS.md. */ import { apiClient, captureError, uniqueSuffix } from '../helpers/api' import { asNumber, getConstants } from '../helpers/consts' import { createFutureSlot, createStoreWithSku, registerUserWithAddress, } from '../helpers/fixtures' import { staffSession } from '../helpers/sessions' type OrderRow = { id: number; totalAmount: string; slotId: number | null } type Placed = { success: boolean; data: OrderRow[] } const couponCode = () => `CM${uniqueSuffix()}`.toUpperCase().replace(/[^A-Z0-9]/g, '').slice(0, 20) /** price 5 is used so quantities map straight onto the totals below. */ const UNIT_PRICE = 5 describe('coupon discount maths', () => { let admin: ReturnType let userToken = '' let addressId = 0 let skuId = 0 let slotId = 0 let secondSlotId = 0 let roundingSkuId = 0 let roundingSlotId = 0 let deliveryCharge = 0 let freeDeliveryThreshold = 0 beforeAll(async () => { const staff = await staffSession() admin = apiClient(staff.token) const store = await createStoreWithSku({ price: UNIT_PRICE }) const slot = await createFutureSlot([store.skuId]) const second = await createFutureSlot([store.skuId], { deliveryInHours: 6, freezeInHours: 5, }) // A second store at 333 so 3 units = 999 exercises float maths. const rounding = await createStoreWithSku({ price: 333 }) const roundingSlot = await createFutureSlot([rounding.skuId]) const buyer = await registerUserWithAddress() const consts = await getConstants() userToken = buyer.token addressId = buyer.addressId skuId = store.skuId slotId = slot.slotId secondSlotId = second.slotId roundingSkuId = rounding.skuId roundingSlotId = roundingSlot.slotId deliveryCharge = asNumber(consts.deliveryCharge) freeDeliveryThreshold = asNumber(consts.freeDeliveryThreshold) // The totals below assume these thresholds. expect(freeDeliveryThreshold).toBeGreaterThan(UNIT_PRICE) expect(freeDeliveryThreshold).toBeLessThan(500) }) const createCoupon = async (over: Record = {}) => { const created = await admin.admin.coupon.create.mutate({ couponCode: couponCode(), minOrder: 1, isApplyForAll: true, validTill: new Date(Date.now() + 24 * 3600_000).toISOString(), ...over, }) return created[0] } const place = ( items: { skuId: number; quantity: number; slotId: number | null }[], couponId?: number ): Promise => apiClient(userToken).user.order.placeOrder.mutate({ selectedItems: items, addressId, regionId: 1, paymentMethod: 'cod', ...(couponId ? { couponIds: [couponId] } : {}), }) as unknown as Promise const total = (res: Placed) => parseFloat(res.data[0].totalAmount) it('applies an uncapped percentage discount', async () => { const coupon = await createCoupon({ discountPercent: 10 }) const res = await place([{ skuId, quantity: 100, slotId }], coupon.id) // 500 >= freeDeliveryThreshold -> free delivery; 10% of 500 = 50. expect(total(res)).toBe(450) }) it('caps a percentage discount at maxValue', async () => { const coupon = await createCoupon({ discountPercent: 50, maxValue: 100 }) const res = await place([{ skuId, quantity: 100, slotId }], coupon.id) // min(50% of 500 = 250, maxValue 100) = 100. expect(total(res)).toBe(400) }) it('caps a flat discount at maxValue', async () => { const coupon = await createCoupon({ flatDiscount: 200, maxValue: 30 }) const res = await place([{ skuId, quantity: 100, slotId }], coupon.id) // min(flat 200, maxValue 30) = 30. expect(total(res)).toBe(470) }) /** * KNOWN BUG: the percentage branch caps at `maxValue * proportion` or * Infinity and never at orderTotal, so a >=100% coupon drives totalAmount to * zero or negative. The flat branch does cap at the order total. */ it('pins: a 150% coupon produces a negative total', async () => { const coupon = await createCoupon({ discountPercent: 150 }) const res = await place([{ skuId, quantity: 100, slotId }], coupon.id) // 500 - 150% (750) = -250. expect(total(res)).toBeLessThan(0) }) it('a 100% coupon zeroes the goods but delivery still applies', async () => { const coupon = await createCoupon({ discountPercent: 100 }) const res = await place([{ skuId, quantity: 100, slotId }], coupon.id) // Goods 500 - 100% = 0; 0 is below the free-delivery threshold, so the // delivery charge is added on top (matching the customer app). expect(total(res)).toBe(deliveryCharge) }) it('accepts a cart exactly at the coupon minOrder and rejects below it', async () => { const coupon = await createCoupon({ flatDiscount: 10, minOrder: 500 }) // 100 * 5 = 500 == minOrder -> the guard is `minOrder > total`, so it passes. const ok = await place([{ skuId, quantity: 100, slotId }], coupon.id) expect(ok.success).toBe(true) expect(total(ok)).toBe(490) // 99 * 5 = 495 < 500 -> rejected. const error = await captureError(() => place([{ skuId, quantity: 99, slotId }], coupon.id) ) expect(error.message).toMatch(/minimum requirement/i) }) it('applies a percentage coupon to the goods subtotal only', async () => { const coupon = await createCoupon({ discountPercent: 10 }) // 1 * 5 = 5; 10% off the goods = 4.5. Delivery is decided on 4.5, which is // below the free-delivery threshold, so the charge is added on top. const res = await place([{ skuId, quantity: 1, slotId }], coupon.id) expect(total(res)).toBeCloseTo(UNIT_PRICE * 0.9 + deliveryCharge, 6) }) it('splits a flat discount across slots by orderGroupProportion', async () => { const coupon = await createCoupon({ flatDiscount: 20 }) const res = await place( [ { skuId, quantity: 40, slotId }, // 200 { skuId, quantity: 60, slotId: secondSlotId }, // 300 ], coupon.id ) // 500 >= freeDeliveryThreshold -> no delivery, so both sub-orders are the plain // subtotal. Proportions 0.4 / 0.6 -> discounts 8 / 12. const totals = res.data .map((order) => parseFloat(order.totalAmount)) .sort((a, b) => a - b) expect(totals).toEqual([192, 288]) expect(totals[0] + totals[1]).toBe(480) }) /** * KNOWN BUG: money is never rounded, so a percentage discount leaves float * noise in orders.totalAmount (here 849.15 is not representable exactly). */ it('pins: amounts are stored unrounded', async () => { const coupon = await createCoupon({ discountPercent: 15 }) const res = await place( [{ skuId: roundingSkuId, quantity: 3, slotId: roundingSlotId }], coupon.id ) // 999 - 15%. Assert the exact JS string, i.e. no rounding was applied. expect(res.data[0].totalAmount).toBe(String(999 - (999 * 15) / 100)) }) it('enforces maxLimitForUser', async () => { const coupon = await createCoupon({ flatDiscount: 5, maxLimitForUser: 1 }) await place([{ skuId, quantity: 100, slotId }], coupon.id) const error = await captureError(() => place([{ skuId, quantity: 100, slotId }], coupon.id) ) expect(error.message).toMatch(/usage limit/i) }) it('rejects an expired coupon at order time', async () => { const coupon = await createCoupon({ flatDiscount: 5, validTill: new Date(Date.now() - 3600_000).toISOString(), }) const error = await captureError(() => place([{ skuId, quantity: 100, slotId }], coupon.id) ) expect(error.message).toMatch(/expired/i) }) it('rejects an unknown coupon id', async () => { const error = await captureError(() => place([{ skuId, quantity: 100, slotId }], 99_999_999) ) expect(error.message).toMatch(/invalid coupon/i) }) })