@bash-app/bash-common 30.116.0 → 30.118.0

package/src/utils/discountEngine/__tests__/bestPriceResolver.test.ts

@@ -0,0 +1,558 @@
+import {
+  findBestPrice,
+  applyGuardrails,
+  calculateEffectiveRate,
+  BestPriceOptions,
+} from "../bestPriceResolver";
+import { BashEventPromoCode, SpecialOffer, SpecialOfferType } from "@prisma/client";
+
+describe("bestPriceResolver", () => {
+  const mockPromoCode: BashEventPromoCode = {
+    id: "promo-1",
+    code: "SUMMER20",
+    bashEventId: "event-1",
+    discountAmountPercentage: 20,
+    discountAmountInCents: null,
+    maxRedemptions: null,
+    redeemBy: null,
+    promoterId: null,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  } as any;
+
+  const mockSpecialOffer: SpecialOffer = {
+    id: "offer-1",
+    ticketTierId: "tier-1",
+    offerType: SpecialOfferType.EARLY_BIRD,
+    title: "Early Bird",
+    description: null,
+    discountType: "PERCENTAGE" as any,
+    discountValue: 15,
+    isActive: true,
+    canStackWithPromoCodes: true,
+    canStackWithOtherOffers: false,
+    displayBadge: true,
+    badgeText: "EARLY BIRD",
+    maxRedemptions: null,
+    currentRedemptions: 0,
+    createdAt: new Date(),
+    updatedAt: new Date(),
+  } as any;
+
+  describe("findBestPrice - No Discounts", () => {
+    it("should return original price when no discounts available", () => {
+      const options: BestPriceOptions = {
+        ticketPrice: 5000, // $50
+        quantity: 2,
+        promoCodes: [],
+        specialOffers: [],
+        allowStacking: true,
+      };
+
+      const result = findBestPrice(options);
+
+      expect(result.originalTotal).toBe(10000); // $100
+      expect(result.finalTotal).toBe(10000);
+      expect(result.totalSavings).toBe(0);
+      expect(result.appliedDiscounts).toHaveLength(0);
+      expect(result.explanation).toBe("No discounts applied");
+    });
+
+    it("should handle zero quantity", () => {
+      const options: BestPriceOptions = {
+        ticketPrice: 5000,
+        quantity: 0,
+        promoCodes: [],
+        specialOffers: [],
+        allowStacking: true,
+      };
+
+      const result = findBestPrice(options);
+
+      expect(result.originalTotal).toBe(0);
+      expect(result.finalTotal).toBe(0);
+    });
+  });
+
+  describe("findBestPrice - Promo Code Only", () => {
+    it("should apply single promo code discount", () => {
+      const options: BestPriceOptions = {
+        ticketPrice: 5000, // $50
+        quantity: 2,
+        promoCodes: [mockPromoCode], // 20% off
+        specialOffers: [],
+        allowStacking: true,
+      };
+
+      const result = findBestPrice(options);
+
+      expect(result.originalTotal).toBe(10000); // $100
+      expect(result.finalTotal).toBe(8000); // $80 after 20% off
+      expect(result.totalSavings).toBe(2000); // Saved $20
+      expect(result.appliedDiscounts).toHaveLength(1);
+      expect(result.appliedDiscounts[0].sourceName).toBe("SUMMER20");
+    });
+
+    it("should select best promo code from multiple options", () => {
+      const promo30: BashEventPromoCode = {
+        ...mockPromoCode,
+        id: "promo-2",
+        code: "MEGA30",
+        discountAmountPercentage: 30,
+      };
+
+      const options: BestPriceOptions = {
+        ticketPrice: 5000,
+        quantity: 2,
+        promoCodes: [mockPromoCode, promo30], // 20% vs 30%
+        specialOffers: [],
+        allowStacking: false,
+      };
+
+      const result = findBestPrice(options);
+
+      expect(result.finalTotal).toBe(7000); // Best: 30% off
+      expect(result.appliedDiscounts[0].sourceName).toBe("MEGA30");
+    });
+
+    it("should handle fixed amount promo code", () => {
+      const fixedPromo: BashEventPromoCode = {
+        ...mockPromoCode,
+        discountAmountPercentage: null,
+        discountAmountInCents: 1500, // $15 off
+      };
+
+      const options: BestPriceOptions = {
+        ticketPrice: 5000,
+        quantity: 2,
+        promoCodes: [fixedPromo],
+        specialOffers: [],
+        allowStacking: true,
+      };
+
+      const result = findBestPrice(options);
+
+      expect(result.originalTotal).toBe(10000);
+      expect(result.finalTotal).toBe(8500); // $100 - $15
+      expect(result.totalSavings).toBe(1500);
+    });
+  });
+
+  describe("findBestPrice - Special Offer Only", () => {
+    it("should apply single special offer discount", () => {
+      const options: BestPriceOptions = {
+        ticketPrice: 5000,
+        quantity: 2,
+        promoCodes: [],
+        specialOffers: [mockSpecialOffer], // 15% off
+        allowStacking: true,
+      };
+
+      const result = findBestPrice(options);
+
+      expect(result.finalTotal).toBe(8500); // $85 after 15% off
+      expect(result.totalSavings).toBe(1500); // Saved $15
+      expect(result.appliedDiscounts).toHaveLength(1);
+    });
+
+    it("should select best offer from multiple options", () => {
+      const betterOffer: SpecialOffer = {
+        ...mockSpecialOffer,
+        id: "offer-2",
+        discountValue: 25, // 25% off
+      };
+
+      const options: BestPriceOptions = {
+        ticketPrice: 5000,
+        quantity: 2,
+        promoCodes: [],
+        specialOffers: [mockSpecialOffer, betterOffer], // 15% vs 25%
+        allowStacking: false,
+      };
+
+      const result = findBestPrice(options);
+
+      expect(result.finalTotal).toBe(7500); // Best: 25% off = $75
+      expect(result.appliedDiscounts[0].sourceId).toBe("offer-2");
+    });
+  });
+
+  describe("findBestPrice - Stacking Discounts", () => {
+    it("should stack promo code with special offer when allowed", () => {
+      const stackableOffer: SpecialOffer = {
+        ...mockSpecialOffer,
+        canStackWithPromoCodes: true,
+      };
+
+      const options: BestPriceOptions = {
+        ticketPrice: 5000, // $50 per ticket
+        quantity: 2, // $100 total
+        promoCodes: [mockPromoCode], // 20% off
+        specialOffers: [stackableOffer], // 15% off
+        allowStacking: true,
+      };
+
+      const result = findBestPrice(options);
+
+      // Stacked: 20% off $100 = $80, then 15% off $80 = $68
+      expect(result.finalTotal).toBeLessThan(8000); // Better than single discount
+      expect(result.appliedDiscounts).toHaveLength(2);
+    });
+
+    it("should not stack when offer disallows stacking", () => {
+      const nonStackableOffer: SpecialOffer = {
+        ...mockSpecialOffer,
+        canStackWithPromoCodes: false,
+      };
+
+      const options: BestPriceOptions = {
+        ticketPrice: 5000,
+        quantity: 2,
+        promoCodes: [mockPromoCode], // 20% off
+        specialOffers: [nonStackableOffer], // 15% off, no stacking
+        allowStacking: true,
+      };
+
+      const result = findBestPrice(options);
+
+      // Should pick the better single discount (20%)
+      expect(result.appliedDiscounts).toHaveLength(1);
+      expect(result.finalTotal).toBe(8000); // 20% off
+    });
+
+    it("should not stack when global stacking is disabled", () => {
+      const stackableOffer: SpecialOffer = {
+        ...mockSpecialOffer,
+        canStackWithPromoCodes: true,
+      };
+
+      const options: BestPriceOptions = {
+        ticketPrice: 5000,
+        quantity: 2,
+        promoCodes: [mockPromoCode],
+        specialOffers: [stackableOffer],
+        allowStacking: false, // Global override
+      };
+
+      const result = findBestPrice(options);
+
+      // Should pick best single discount
+      expect(result.appliedDiscounts).toHaveLength(1);
+    });
+
+    it("should stack multiple offers when both allow it", () => {
+      const offer1: SpecialOffer = {
+        ...mockSpecialOffer,
+        id: "offer-1",
+        discountValue: 10,
+        canStackWithOtherOffers: true,
+      };
+
+      const offer2: SpecialOffer = {
+        ...mockSpecialOffer,
+        id: "offer-2",
+        discountValue: 15,
+        canStackWithOtherOffers: true,
+      };
+
+      const options: BestPriceOptions = {
+        ticketPrice: 5000,
+        quantity: 2,
+        promoCodes: [],
+        specialOffers: [offer1, offer2],
+        allowStacking: true,
+      };
+
+      const result = findBestPrice(options);
+
+      // Should stack both offers
+      expect(result.appliedDiscounts.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("findBestPrice - Edge Cases", () => {
+    it("should handle 100% discount (free tickets)", () => {
+      const freePromo: BashEventPromoCode = {
+        ...mockPromoCode,
+        discountAmountPercentage: 100,
+      };
+
+      const options: BestPriceOptions = {
+        ticketPrice: 5000,
+        quantity: 2,
+        promoCodes: [freePromo],
+        specialOffers: [],
+        allowStacking: true,
+      };
+
+      const result = findBestPrice(options);
+
+      expect(result.finalTotal).toBe(0);
+      expect(result.totalSavings).toBe(10000);
+    });
+
+    it("should not allow negative final price", () => {
+      const overDiscount: BashEventPromoCode = {
+        ...mockPromoCode,
+        discountAmountPercentage: null,
+        discountAmountInCents: 15000, // $150 off on $100 order
+      };
+
+      const options: BestPriceOptions = {
+        ticketPrice: 5000,
+        quantity: 2, // Total: $100
+        promoCodes: [overDiscount],
+        specialOffers: [],
+        allowStacking: true,
+      };
+
+      const result = findBestPrice(options);
+
+      expect(result.finalTotal).toBe(0); // Floor at 0, not negative
+      expect(result.totalSavings).toBe(10000); // Capped at original price
+    });
+
+    it("should handle very large quantities", () => {
+      const options: BestPriceOptions = {
+        ticketPrice: 5000,
+        quantity: 1000, // Large order
+        promoCodes: [mockPromoCode],
+        specialOffers: [],
+        allowStacking: true,
+      };
+
+      const result = findBestPrice(options);
+
+      expect(result.originalTotal).toBe(5000000); // $50,000
+      expect(result.finalTotal).toBe(4000000); // 20% off
+    });
+
+    it("should handle rounding correctly", () => {
+      const options: BestPriceOptions = {
+        ticketPrice: 3333, // $33.33
+        quantity: 3, // Total: $99.99
+        promoCodes: [mockPromoCode], // 20% off
+        specialOffers: [],
+        allowStacking: true,
+      };
+
+      const result = findBestPrice(options);
+
+      // Should round down to nearest cent
+      expect(Number.isInteger(result.finalTotal)).toBe(true);
+      expect(result.finalTotal).toBeGreaterThan(0);
+    });
+  });
+
+  describe("applyGuardrails", () => {
+    const mockDiscountResult = {
+      sourceType: "PROMO_CODE" as const,
+      sourceId: "promo-1",
+      sourceName: "TEST",
+      discountType: "PERCENTAGE" as const,
+      discountValue: 50,
+      amountDiscounted: 5000,
+      originalPrice: 10000,
+      finalPrice: 5000,
+    };
+
+    it("should enforce minimum price floor", () => {
+      const result = applyGuardrails(mockDiscountResult, 6000); // Min $60
+
+      expect(result.finalPrice).toBe(6000); // Capped at min
+      expect(result.amountDiscounted).toBe(4000); // Adjusted discount
+    });
+
+    it("should enforce maximum discount percentage", () => {
+      const result = applyGuardrails(mockDiscountResult, undefined, 30); // Max 30% off
+
+      expect(result.amountDiscounted).toBeLessThanOrEqual(3000); // 30% of $100
+      expect(result.finalPrice).toBeGreaterThanOrEqual(7000); // At least $70
+    });
+
+    it("should apply both guardrails", () => {
+      const result = applyGuardrails(mockDiscountResult, 7500, 30);
+
+      expect(result.finalPrice).toBeGreaterThanOrEqual(7500); // Min floor
+      expect(result.amountDiscounted).toBeLessThanOrEqual(3000); // Max discount
+    });
+
+    it("should not modify result when within bounds", () => {
+      const result = applyGuardrails(mockDiscountResult, 4000, 60);
+
+      expect(result.finalPrice).toBe(5000); // Unchanged
+      expect(result.amountDiscounted).toBe(5000); // Unchanged
+    });
+  });
+
+  describe("calculateEffectiveRate", () => {
+    it("should calculate effective discount percentage", () => {
+      const result = {
+        appliedDiscounts: [],
+        originalTotal: 10000, // $100
+        finalTotal: 7500, // $75
+        totalSavings: 2500, // $25
+        explanation: "",
+      };
+
+      const rate = calculateEffectiveRate(result);
+
+      expect(rate).toBe(25); // 25% effective discount
+    });
+
+    it("should handle zero original price", () => {
+      const result = {
+        appliedDiscounts: [],
+        originalTotal: 0,
+        finalTotal: 0,
+        totalSavings: 0,
+        explanation: "",
+      };
+
+      const rate = calculateEffectiveRate(result);
+
+      expect(rate).toBe(0);
+    });
+
+    it("should round down to whole percentage", () => {
+      const result = {
+        appliedDiscounts: [],
+        originalTotal: 10000,
+        finalTotal: 6666, // 33.34% off
+        totalSavings: 3334,
+        explanation: "",
+      };
+
+      const rate = calculateEffectiveRate(result);
+
+      expect(rate).toBe(33); // Rounded down
+    });
+
+    it("should handle 100% discount", () => {
+      const result = {
+        appliedDiscounts: [],
+        originalTotal: 10000,
+        finalTotal: 0,
+        totalSavings: 10000,
+        explanation: "",
+      };
+
+      const rate = calculateEffectiveRate(result);
+
+      expect(rate).toBe(100);
+    });
+  });
+
+  describe("findBestPrice - Complex Scenarios", () => {
+    it("should choose best combination among many options", () => {
+      const promo10: BashEventPromoCode = {
+        ...mockPromoCode,
+        id: "promo-10",
+        discountAmountPercentage: 10,
+      };
+
+      const promo25: BashEventPromoCode = {
+        ...mockPromoCode,
+        id: "promo-25",
+        discountAmountPercentage: 25,
+      };
+
+      const offer15: SpecialOffer = {
+        ...mockSpecialOffer,
+        id: "offer-15",
+        discountValue: 15,
+        canStackWithPromoCodes: false,
+      };
+
+      const offer20: SpecialOffer = {
+        ...mockSpecialOffer,
+        id: "offer-20",
+        discountValue: 20,
+        canStackWithPromoCodes: true,
+      };
+
+      const options: BestPriceOptions = {
+        ticketPrice: 10000, // $100
+        quantity: 1,
+        promoCodes: [promo10, promo25],
+        specialOffers: [offer15, offer20],
+        allowStacking: true,
+      };
+
+      const result = findBestPrice(options);
+
+      // Best should be: 25% promo + 20% offer (if stacked)
+      // Or 25% promo alone = $75
+      // Stacked: 25% off $100 = $75, then 20% off $75 = $60
+      expect(result.finalTotal).toBeLessThanOrEqual(7500);
+    });
+
+    it("should generate correct explanation string", () => {
+      const options: BestPriceOptions = {
+        ticketPrice: 5000,
+        quantity: 2,
+        promoCodes: [mockPromoCode],
+        specialOffers: [],
+        allowStacking: true,
+      };
+
+      const result = findBestPrice(options);
+
+      expect(result.explanation).toContain("SUMMER20");
+      expect(result.explanation).not.toBe("No discounts applied");
+    });
+
+    it("should handle mixed discount types in stacking", () => {
+      const percentPromo: BashEventPromoCode = {
+        ...mockPromoCode,
+        discountAmountPercentage: 20,
+        discountAmountInCents: null,
+      };
+
+      const fixedOffer: SpecialOffer = {
+        ...mockSpecialOffer,
+        discountType: "FIXED_AMOUNT" as any,
+        discountValue: 500, // $5 off (in cents)
+        canStackWithPromoCodes: true,
+      };
+
+      const options: BestPriceOptions = {
+        ticketPrice: 5000,
+        quantity: 2,
+        promoCodes: [percentPromo],
+        specialOffers: [fixedOffer],
+        allowStacking: true,
+      };
+
+      const result = findBestPrice(options);
+
+      // Should stack: 20% off $100 = $80, then $5 off = $75
+      expect(result.finalTotal).toBeLessThan(8000);
+      expect(result.appliedDiscounts.length).toBeGreaterThan(0);
+    });
+  });
+
+  describe("findBestPrice - Attribution", () => {
+    it("should track promoter attribution", () => {
+      const promoWithPromoter: BashEventPromoCode = {
+        ...mockPromoCode,
+        promoterId: "promoter-123",
+      };
+
+      const options: BestPriceOptions = {
+        ticketPrice: 5000,
+        quantity: 2,
+        userId: "user-456",
+        promoCodes: [promoWithPromoter],
+        specialOffers: [],
+        allowStacking: true,
+      };
+
+      const result = findBestPrice(options);
+
+      expect(result.appliedDiscounts[0]).toHaveProperty("attribution");
+      expect(result.appliedDiscounts[0].attribution?.userId).toBe("promoter-123");
+      expect(result.appliedDiscounts[0].attribution?.commissionAmount).toBeGreaterThan(0);
+    });
+  });
+});