@bash-app/bash-common 30.235.0 → 30.237.0

package/src/utils/service/__tests__/eventPromoterPhase3.test.ts

@@ -0,0 +1,296 @@
+/**
+ * Phase 3 of the unified-pricing roadmap — tests for the
+ *   - counting basis chooser,
+ *   - locked-models set / validator update,
+ *   - mixed USD + BashPoints settlement math,
+ *   - BashPoints payout source resolver (pool-then-wallet).
+ *
+ * Lives next to `eventPromoterUtils.test.ts` so it picks up the same Jest
+ * config; pure-function-only, no Prisma.
+ */
+import { describe, expect, it } from "@jest/globals";
+import {
+  EVENT_PROMOTER_LOCKED_PRICING_MODELS,
+  computeEventPromoterMixedSettlement,
+  eventPromoterCountingBasisFor,
+  pickCheckedInForBasis,
+  resolveBashPointsPayoutSources,
+  validateEventPromoterPricing,
+} from "../eventPromoterUtils.js";
+
+describe("EVENT_PROMOTER_LOCKED_PRICING_MODELS", () => {
+  it("contains PER_ATTENDEE, PER_PAID_ATTENDEE, PER_BASHPOINTS_ATTENDEE in that order", () => {
+    expect([...EVENT_PROMOTER_LOCKED_PRICING_MODELS]).toEqual([
+      "PER_ATTENDEE",
+      "PER_PAID_ATTENDEE",
+      "PER_BASHPOINTS_ATTENDEE",
+    ]);
+  });
+});
+
+describe("validateEventPromoterPricing (Phase 3 model set)", () => {
+  it("accepts PER_ATTENDEE for Promoter subtype", () => {
+    expect(
+      validateEventPromoterPricing({
+        eventServiceSubType: "Promoter",
+        pricingModel: "PER_ATTENDEE",
+      }).ok
+    ).toBe(true);
+  });
+  it("accepts PER_PAID_ATTENDEE for Promoter subtype", () => {
+    expect(
+      validateEventPromoterPricing({
+        eventServiceSubType: "Promoter",
+        pricingModel: "PER_PAID_ATTENDEE",
+      }).ok
+    ).toBe(true);
+  });
+  it("accepts PER_BASHPOINTS_ATTENDEE for Promoter subtype", () => {
+    expect(
+      validateEventPromoterPricing({
+        eventServiceSubType: "Promoter",
+        pricingModel: "PER_BASHPOINTS_ATTENDEE",
+      }).ok
+    ).toBe(true);
+  });
+  it("rejects FLAT_FEE for Promoter subtype", () => {
+    const r = validateEventPromoterPricing({
+      eventServiceSubType: "Promoter",
+      pricingModel: "FLAT_FEE",
+    });
+    expect(r.ok).toBe(false);
+  });
+});
+
+describe("eventPromoterCountingBasisFor", () => {
+  it("PER_ATTENDEE → AllCheckedIn", () => {
+    expect(
+      eventPromoterCountingBasisFor({ pricingModel: "PER_ATTENDEE" })
+    ).toBe("AllCheckedIn");
+  });
+  it("PER_PAID_ATTENDEE without BP knob → PaidUsdOnly", () => {
+    expect(
+      eventPromoterCountingBasisFor({
+        pricingModel: "PER_PAID_ATTENDEE",
+        countsBashPointsTickets: false,
+      })
+    ).toBe("PaidUsdOnly");
+  });
+  it("PER_PAID_ATTENDEE with countsBashPointsTickets → PaidAny", () => {
+    expect(
+      eventPromoterCountingBasisFor({
+        pricingModel: "PER_PAID_ATTENDEE",
+        countsBashPointsTickets: true,
+      })
+    ).toBe("PaidAny");
+  });
+  it("PER_BASHPOINTS_ATTENDEE → PaidBpOnly regardless of knob", () => {
+    expect(
+      eventPromoterCountingBasisFor({
+        pricingModel: "PER_BASHPOINTS_ATTENDEE",
+        countsBashPointsTickets: true,
+      })
+    ).toBe("PaidBpOnly");
+  });
+  it("unknown / null pricing → AllCheckedIn (legacy fallback)", () => {
+    expect(eventPromoterCountingBasisFor({ pricingModel: null })).toBe(
+      "AllCheckedIn"
+    );
+  });
+});
+
+describe("pickCheckedInForBasis", () => {
+  const SNAPS = {
+    totalCheckedInAttendees: 220,
+    paidAttendeesAtSettle: 180,
+    paidInBashPointsAttendeesAtSettle: 30,
+  };
+  it("AllCheckedIn → total", () => {
+    expect(pickCheckedInForBasis("AllCheckedIn", SNAPS)).toBe(220);
+  });
+  it("PaidUsdOnly → paid USD", () => {
+    expect(pickCheckedInForBasis("PaidUsdOnly", SNAPS)).toBe(180);
+  });
+  it("PaidBpOnly → paid BP", () => {
+    expect(pickCheckedInForBasis("PaidBpOnly", SNAPS)).toBe(30);
+  });
+  it("PaidAny → USD + BP", () => {
+    expect(pickCheckedInForBasis("PaidAny", SNAPS)).toBe(210);
+  });
+  it("treats missing snapshots as zero", () => {
+    expect(
+      pickCheckedInForBasis("PaidUsdOnly", {
+        totalCheckedInAttendees: 100,
+      })
+    ).toBe(0);
+  });
+});
+
+describe("computeEventPromoterMixedSettlement", () => {
+  const baseSnaps = {
+    totalCheckedInAttendees: 250,
+    paidAttendeesAtSettle: 200,
+    paidInBashPointsAttendeesAtSettle: 50,
+  };
+
+  it("computes a positive USD delta when more USD attendees show up than expected", () => {
+    const r = computeEventPromoterMixedSettlement({
+      baseRateCents: 500,
+      expectedPaidAttendeesAtBooking: 150,
+      snapshots: baseSnaps,
+    });
+    expect(r.usdTotalCents).toBe(200 * 500);
+    expect(r.usdDeltaCents).toBe((200 - 150) * 500);
+    expect(r.cappedUsd).toBe(false);
+  });
+
+  it("respects the USD ceiling (maxUsdAttendeesAttributable)", () => {
+    const r = computeEventPromoterMixedSettlement({
+      baseRateCents: 500,
+      expectedPaidAttendeesAtBooking: 150,
+      maxUsdAttendeesAttributable: 175,
+      snapshots: baseSnaps,
+    });
+    expect(r.usdTotalCents).toBe(175 * 500);
+    expect(r.cappedUsd).toBe(false); // ceiling, not dollar cap
+  });
+
+  it("flags cappedUsd when maxBillableCents bites", () => {
+    const r = computeEventPromoterMixedSettlement({
+      baseRateCents: 500,
+      expectedPaidAttendeesAtBooking: 150,
+      maxBillableCents: 80_000, // < 200 * 500 = 100_000
+      snapshots: baseSnaps,
+    });
+    expect(r.usdTotalCents).toBe(80_000);
+    expect(r.cappedUsd).toBe(true);
+  });
+
+  it("computes the BP side independently from USD", () => {
+    const r = computeEventPromoterMixedSettlement({
+      baseRateBashPoints: 10,
+      expectedBpAttendeesAtBooking: 30,
+      snapshots: baseSnaps,
+    });
+    expect(r.usdTotalCents).toBe(0);
+    expect(r.bpTotal).toBe(50 * 10);
+    expect(r.bpDelta).toBe(20 * 10);
+  });
+
+  it("caps BP via maxBillableBashPoints", () => {
+    const r = computeEventPromoterMixedSettlement({
+      baseRateBashPoints: 10,
+      expectedBpAttendeesAtBooking: 30,
+      maxBillableBashPoints: 400,
+      snapshots: baseSnaps,
+    });
+    expect(r.bpTotal).toBe(400);
+    expect(r.cappedBp).toBe(true);
+  });
+
+  it("returns all zeros when neither side has a rate", () => {
+    const r = computeEventPromoterMixedSettlement({
+      snapshots: baseSnaps,
+    });
+    expect(r.usdTotalCents).toBe(0);
+    expect(r.usdDeltaCents).toBe(0);
+    expect(r.bpTotal).toBe(0);
+    expect(r.bpDelta).toBe(0);
+  });
+});
+
+describe("resolveBashPointsPayoutSources", () => {
+  it("HostWallet path drains wallet only", () => {
+    expect(
+      resolveBashPointsPayoutSources({
+        source: "HostWallet",
+        payoutBp: 100,
+        hostWalletBp: 500,
+        bashPoolBp: 9999, // ignored
+      })
+    ).toEqual({
+      fromPoolBp: 0,
+      fromWalletBp: 100,
+      shortfallBp: 0,
+      walletDebited: true,
+    });
+  });
+
+  it("HostWallet path with insufficient wallet returns shortfall", () => {
+    expect(
+      resolveBashPointsPayoutSources({
+        source: "HostWallet",
+        payoutBp: 100,
+        hostWalletBp: 60,
+      })
+    ).toEqual({
+      fromPoolBp: 0,
+      fromWalletBp: 60,
+      shortfallBp: 40,
+      walletDebited: true,
+    });
+  });
+
+  it("BashBpPool drains pool first, wallet covers the rest", () => {
+    expect(
+      resolveBashPointsPayoutSources({
+        source: "BashBpPool",
+        payoutBp: 100,
+        hostWalletBp: 500,
+        bashPoolBp: 70,
+      })
+    ).toEqual({
+      fromPoolBp: 70,
+      fromWalletBp: 30,
+      shortfallBp: 0,
+      walletDebited: true,
+    });
+  });
+
+  it("BashBpPool fully covered by pool leaves wallet untouched", () => {
+    expect(
+      resolveBashPointsPayoutSources({
+        source: "BashBpPool",
+        payoutBp: 50,
+        hostWalletBp: 500,
+        bashPoolBp: 100,
+      })
+    ).toEqual({
+      fromPoolBp: 50,
+      fromWalletBp: 0,
+      shortfallBp: 0,
+      walletDebited: false,
+    });
+  });
+
+  it("BashBpPool with empty pool falls through to wallet", () => {
+    expect(
+      resolveBashPointsPayoutSources({
+        source: "BashBpPool",
+        payoutBp: 100,
+        hostWalletBp: 50,
+        bashPoolBp: 0,
+      })
+    ).toEqual({
+      fromPoolBp: 0,
+      fromWalletBp: 50,
+      shortfallBp: 50,
+      walletDebited: true,
+    });
+  });
+
+  it("clamps negative inputs to zero", () => {
+    expect(
+      resolveBashPointsPayoutSources({
+        source: "HostWallet",
+        payoutBp: -10,
+        hostWalletBp: -5,
+      })
+    ).toEqual({
+      fromPoolBp: 0,
+      fromWalletBp: 0,
+      shortfallBp: 0,
+      walletDebited: false,
+    });
+  });
+});

package/src/utils/service/__tests__/eventPromoterUtils.test.ts

@@ -0,0 +1,396 @@
+import { describe, expect, it } from "@jest/globals";
+import {
+  EVENT_PROMOTER_LATE_CANCEL_HOURS,
+  EVENT_PROMOTER_LATE_CANCEL_PENALTY_FRACTION,
+  EVENT_PROMOTER_LOCKED_PRICING_MODEL,
+  buildIssuePromoCodeDeepLink,
+  computeEventPromoterDepositCents,
+  computeEventPromoterSettlement,
+  decideEventPromoterCancellation,
+  isPerAttendeeLockedPromotionSubType,
+  validateEventPromoterPricing,
+} from "../eventPromoterUtils.js";
+
+describe("isPerAttendeeLockedPromotionSubType", () => {
+  it("returns true for Promoter subtype", () => {
+    expect(isPerAttendeeLockedPromotionSubType("Promoter")).toBe(true);
+  });
+
+  it("returns false for other Promotion subtypes", () => {
+    expect(isPerAttendeeLockedPromotionSubType("Influencer")).toBe(false);
+    expect(isPerAttendeeLockedPromotionSubType("ContentCreator")).toBe(false);
+    expect(isPerAttendeeLockedPromotionSubType("CelebrityAppearance")).toBe(
+      false
+    );
+  });
+
+  it("returns false for null / undefined / unrelated strings", () => {
+    expect(isPerAttendeeLockedPromotionSubType(null)).toBe(false);
+    expect(isPerAttendeeLockedPromotionSubType(undefined)).toBe(false);
+    expect(isPerAttendeeLockedPromotionSubType("AnythingElse")).toBe(false);
+  });
+});
+
+describe("validateEventPromoterPricing", () => {
+  it("passes when subtype is locked and pricing is PER_ATTENDEE", () => {
+    expect(
+      validateEventPromoterPricing({
+        eventServiceSubType: "Promoter",
+        pricingModel: EVENT_PROMOTER_LOCKED_PRICING_MODEL,
+      })
+    ).toEqual({ ok: true });
+  });
+
+  it("rejects PROMOTER + non-PER_ATTENDEE pricing model", () => {
+    const result = validateEventPromoterPricing({
+      eventServiceSubType: "Promoter",
+      pricingModel: "HOURLY",
+    });
+    expect(result.ok).toBe(false);
+    if (!result.ok) {
+      expect(result.expected).toEqual([
+        "PER_ATTENDEE",
+        "PER_PAID_ATTENDEE",
+        "PER_BASHPOINTS_ATTENDEE",
+      ]);
+      expect(result.reason).toContain("PER_ATTENDEE");
+    }
+  });
+
+  it("rejects PROMOTER + null pricing model", () => {
+    const result = validateEventPromoterPricing({
+      eventServiceSubType: "Promoter",
+      pricingModel: null,
+    });
+    expect(result.ok).toBe(false);
+  });
+
+  it("passes any pricing model for non-Promoter subtypes", () => {
+    expect(
+      validateEventPromoterPricing({
+        eventServiceSubType: "Influencer",
+        pricingModel: "HOURLY",
+      })
+    ).toEqual({ ok: true });
+    expect(
+      validateEventPromoterPricing({
+        eventServiceSubType: "ContentCreator",
+        pricingModel: "FLAT_FEE",
+      })
+    ).toEqual({ ok: true });
+  });
+});
+
+describe("computeEventPromoterDepositCents", () => {
+  it("returns expected attendees * baseRate when minimum is below expected", () => {
+    expect(
+      computeEventPromoterDepositCents({
+        bashExpectedAttendees: 200,
+        baseRateCents: 500,
+        minimumQuantity: 50,
+      })
+    ).toBe(100_000);
+  });
+
+  it("uses minimumQuantity floor when expected is below it", () => {
+    expect(
+      computeEventPromoterDepositCents({
+        bashExpectedAttendees: 30,
+        baseRateCents: 500,
+        minimumQuantity: 100,
+      })
+    ).toBe(50_000);
+  });
+
+  it("returns null when baseRateCents is missing or 0", () => {
+    expect(
+      computeEventPromoterDepositCents({
+        bashExpectedAttendees: 200,
+        baseRateCents: null,
+        minimumQuantity: 100,
+      })
+    ).toBeNull();
+    expect(
+      computeEventPromoterDepositCents({
+        bashExpectedAttendees: 200,
+        baseRateCents: 0,
+        minimumQuantity: 100,
+      })
+    ).toBeNull();
+  });
+
+  it("treats negative expected attendees as 0", () => {
+    expect(
+      computeEventPromoterDepositCents({
+        bashExpectedAttendees: -10,
+        baseRateCents: 500,
+        minimumQuantity: null,
+      })
+    ).toBe(0);
+  });
+});
+
+describe("computeEventPromoterSettlement", () => {
+  const baseInput = {
+    baseRateCents: 500,
+    expectedAttendeesAtBooking: 200,
+  };
+
+  it("returns zero delta when checked-in matches expected exactly", () => {
+    const result = computeEventPromoterSettlement({
+      ...baseInput,
+      totalCheckedInAttendees: 200,
+    });
+    expect(result.finalCount).toBe(200);
+    expect(result.settlementDeltaCents).toBe(0);
+    expect(result.totalCents).toBe(100_000);
+    expect(result.ceilingHit).toBe(false);
+  });
+
+  it("returns positive delta when more attendees show up than expected", () => {
+    const result = computeEventPromoterSettlement({
+      ...baseInput,
+      totalCheckedInAttendees: 250,
+    });
+    expect(result.finalCount).toBe(250);
+    expect(result.settlementDeltaCents).toBe(25_000);
+    expect(result.totalCents).toBe(125_000);
+    expect(result.ceilingHit).toBe(false);
+  });
+
+  it("returns negative delta (refund) when fewer attendees show up", () => {
+    const result = computeEventPromoterSettlement({
+      ...baseInput,
+      totalCheckedInAttendees: 150,
+    });
+    expect(result.finalCount).toBe(150);
+    expect(result.settlementDeltaCents).toBe(-25_000);
+    expect(result.totalCents).toBe(75_000);
+  });
+
+  it("caps finalCount at maxAttendeesAttributable and sets ceilingHit", () => {
+    const result = computeEventPromoterSettlement({
+      ...baseInput,
+      totalCheckedInAttendees: 500,
+      maxAttendeesAttributable: 250,
+    });
+    expect(result.finalCount).toBe(250);
+    expect(result.ceilingHit).toBe(true);
+    expect(result.settlementDeltaCents).toBe(25_000);
+  });
+
+  it("does not set ceilingHit when checked-in is exactly the ceiling", () => {
+    const result = computeEventPromoterSettlement({
+      ...baseInput,
+      totalCheckedInAttendees: 250,
+      maxAttendeesAttributable: 250,
+    });
+    expect(result.finalCount).toBe(250);
+    expect(result.ceilingHit).toBe(false);
+  });
+
+  it("applies minimumQuantity floor when checked-in is below it", () => {
+    const result = computeEventPromoterSettlement({
+      ...baseInput,
+      totalCheckedInAttendees: 50,
+      minimumQuantity: 100,
+    });
+    expect(result.finalCount).toBe(100);
+    expect(result.settlementDeltaCents).toBe(-50_000);
+  });
+
+  it("worked example A: 200 expected / 250 ceiling / 220 checked-in", () => {
+    const result = computeEventPromoterSettlement({
+      baseRateCents: 500,
+      expectedAttendeesAtBooking: 200,
+      totalCheckedInAttendees: 220,
+      maxAttendeesAttributable: 250,
+    });
+    expect(result.finalCount).toBe(220);
+    expect(result.settlementDeltaCents).toBe(10_000);
+    expect(result.ceilingHit).toBe(false);
+  });
+
+  it("worked example B: 100 expected / 150 ceiling / 220 checked-in (capped)", () => {
+    const result = computeEventPromoterSettlement({
+      baseRateCents: 500,
+      expectedAttendeesAtBooking: 100,
+      totalCheckedInAttendees: 220,
+      maxAttendeesAttributable: 150,
+    });
+    expect(result.finalCount).toBe(150);
+    expect(result.settlementDeltaCents).toBe(25_000);
+    expect(result.ceilingHit).toBe(true);
+  });
+
+  it("treats negative checked-in as 0", () => {
+    const result = computeEventPromoterSettlement({
+      ...baseInput,
+      totalCheckedInAttendees: -10,
+    });
+    expect(result.finalCount).toBe(0);
+    expect(result.settlementDeltaCents).toBe(-100_000);
+  });
+
+  it("treats null ceiling as no cap", () => {
+    const result = computeEventPromoterSettlement({
+      ...baseInput,
+      totalCheckedInAttendees: 999,
+      maxAttendeesAttributable: null,
+    });
+    expect(result.finalCount).toBe(999);
+    expect(result.ceilingHit).toBe(false);
+  });
+});
+
+describe("buildIssuePromoCodeDeepLink", () => {
+  it("includes bashEventId, promoterUserId, and source param", () => {
+    const url = buildIssuePromoCodeDeepLink({
+      bashEventId: "bash-1",
+      promoterUserId: "user-9",
+    });
+    expect(url).toContain("/bashes/bash-1/edit");
+    expect(url).toContain("step=how");
+    expect(url).toContain("open=promo-codes");
+    expect(url).toContain("promoterUserId=user-9");
+    expect(url).toContain("source=event-promoter-booking");
+    expect(url).not.toContain("ticketTierId=");
+  });
+
+  it("adds ticketTierId when provided", () => {
+    const url = buildIssuePromoCodeDeepLink({
+      bashEventId: "bash-1",
+      promoterUserId: "user-9",
+      ticketTierId: "tier-42",
+    });
+    expect(url).toContain("ticketTierId=tier-42");
+  });
+
+  it("omits ticketTierId when null/undefined", () => {
+    const urlNull = buildIssuePromoCodeDeepLink({
+      bashEventId: "bash-1",
+      promoterUserId: "user-9",
+      ticketTierId: null,
+    });
+    const urlUndef = buildIssuePromoCodeDeepLink({
+      bashEventId: "bash-1",
+      promoterUserId: "user-9",
+    });
+    expect(urlNull).not.toContain("ticketTierId=");
+    expect(urlUndef).not.toContain("ticketTierId=");
+  });
+});
+
+describe("decideEventPromoterCancellation", () => {
+  const HOUR = 60 * 60 * 1000;
+  const now = Date.parse("2026-05-12T12:00:00Z");
+
+  it("blocks any cancellation once the booking is settled", () => {
+    const result = decideEventPromoterCancellation({
+      who: "host",
+      nowMs: now,
+      bashStartMs: now + 100 * HOUR,
+      bashEndMs: now + 105 * HOUR,
+      depositCents: 100_000,
+      alreadySettled: true,
+    });
+    expect(result.allow).toBe(false);
+    expect(result.outcome).toBe("Blocked");
+    expect(result.refundCents).toBe(0);
+  });
+
+  it("host: full refund when bash is far in the future", () => {
+    const result = decideEventPromoterCancellation({
+      who: "host",
+      nowMs: now,
+      bashStartMs: now + 100 * HOUR,
+      bashEndMs: now + 105 * HOUR,
+      depositCents: 100_000,
+      alreadySettled: false,
+    });
+    expect(result.allow).toBe(true);
+    expect(result.outcome).toBe("FullRefund");
+    expect(result.refundCents).toBe(100_000);
+    expect(result.penaltyFraction).toBe(0);
+  });
+
+  it("host: partial refund inside the late-cancel window", () => {
+    const result = decideEventPromoterCancellation({
+      who: "host",
+      nowMs: now,
+      bashStartMs: now + (EVENT_PROMOTER_LATE_CANCEL_HOURS - 6) * HOUR,
+      bashEndMs: now + (EVENT_PROMOTER_LATE_CANCEL_HOURS - 1) * HOUR,
+      depositCents: 100_000,
+      alreadySettled: false,
+    });
+    expect(result.outcome).toBe("PartialRefund");
+    expect(result.penaltyFraction).toBe(
+      EVENT_PROMOTER_LATE_CANCEL_PENALTY_FRACTION
+    );
+    expect(result.refundCents).toBe(75_000);
+  });
+
+  it("host: NoRefund once the bash has started — settlement handles money", () => {
+    const result = decideEventPromoterCancellation({
+      who: "host",
+      nowMs: now,
+      bashStartMs: now - 1 * HOUR,
+      bashEndMs: now + 4 * HOUR,
+      depositCents: 100_000,
+      alreadySettled: false,
+    });
+    expect(result.allow).toBe(false);
+    expect(result.outcome).toBe("NoRefund");
+  });
+
+  it("promoter: full refund any time before the bash starts", () => {
+    const result = decideEventPromoterCancellation({
+      who: "promoter",
+      nowMs: now,
+      bashStartMs: now + 3 * HOUR,
+      bashEndMs: now + 8 * HOUR,
+      depositCents: 100_000,
+      alreadySettled: false,
+    });
+    expect(result.allow).toBe(true);
+    expect(result.outcome).toBe("FullRefund");
+    expect(result.refundCents).toBe(100_000);
+  });
+
+  it("promoter: blocked once the bash has started", () => {
+    const result = decideEventPromoterCancellation({
+      who: "promoter",
+      nowMs: now,
+      bashStartMs: now - 1 * HOUR,
+      bashEndMs: now + 4 * HOUR,
+      depositCents: 100_000,
+      alreadySettled: false,
+    });
+    expect(result.allow).toBe(false);
+    expect(result.outcome).toBe("Blocked");
+  });
+
+  it("admin: always allowed, full refund before bash, NoRefund after", () => {
+    const before = decideEventPromoterCancellation({
+      who: "admin",
+      nowMs: now,
+      bashStartMs: now + 100 * HOUR,
+      bashEndMs: now + 105 * HOUR,
+      depositCents: 100_000,
+      alreadySettled: false,
+    });
+    expect(before.allow).toBe(true);
+    expect(before.outcome).toBe("FullRefund");
+
+    const after = decideEventPromoterCancellation({
+      who: "admin",
+      nowMs: now,
+      bashStartMs: now - 5 * HOUR,
+      bashEndMs: now - 1 * HOUR,
+      depositCents: 100_000,
+      alreadySettled: false,
+    });
+    expect(after.allow).toBe(true);
+    expect(after.outcome).toBe("NoRefund");
+  });
+});