@ticketboothapp/booking 1.2.166 → 1.2.167

package/test/change-booking-helpers.test.ts

@@ -11,9 +11,29 @@ import {
 } from '../src/lib/booking/change-flow-pricing';
 import {
   mapAdminChangeBookingQuoteV2Data,
+  type Availability,
   type ChangeBookingQuoteResponse,
 } from '../src/lib/booking-api';
-import { buildAdminChangeQuoteRequestKey } from '../src/components/booking/admin-change-quote-request-key';
+import {
+  filterAvailabilitiesAfterCurrentTime,
+  filterAvailabilitiesAfterPublicBookingCutoff,
+} from '../src/lib/booking/booking-cutoffs';
+import {
+  findFirstDateWithBookableAvailability,
+  selectedDateHasVisibleAvailability,
+} from '../src/components/booking/availability-date-selection';
+import {
+  buildChangeBookingServerPreview,
+  mapQuoteLineItemsToPriceSummaryLines,
+} from '../src/lib/booking/change-booking-server-preview';
+import {
+  buildAdminChangeQuoteRequestKey,
+  canReuseCompletedAdminChangeQuote,
+} from '../src/components/booking/admin-change-quote-request-key';
+import {
+  buildAdminChangeV2QuoteRequest,
+  quoteAdminChangeV2ForUi,
+} from '../src/components/booking/admin-change-v2-quote-request';
 import {
   noRefundRemovedValue,
   normalizeReturnPriceTreatment,
@@ -21,6 +41,10 @@ import {
   releaseRefundDispositionOptions,
   returnPriceTreatmentOptions,
 } from '../src/components/booking/admin-refund-disposition';
+import {
+  mergeAdminRefundDecisionContext,
+  selectRefundDispositionsForOperations,
+} from '../src/components/booking/admin-refund-decision-context';
 import {
   applyResourceAdjustments,
   privateShuttlePriceChanged,
@@ -34,6 +58,7 @@ import {
 } from '../src/components/booking/reservation-hold';
 import { buildAdminChangeProviderPayload } from '../src/components/booking/admin-change-provider-payload';
 import { buildPublicChangeAmountDueSummary } from '../src/components/booking/change-booking-flow-helpers';
+import { collapseAdminPromoLines } from '../src/components/booking/admin-change-receipt-lines';
 import {
   buildAdminChangePaymentChoiceData,
   buildAdminChangePayNowCheckoutModalData,
@@ -57,16 +82,103 @@ function quoteSlice(overrides: Partial<ChangeQuoteUiSlice>): ChangeQuoteUiSlice
   };
 }
 
-function test(name: string, fn: () => void): void {
+function test(name: string, fn: () => void | Promise<void>): void {
   try {
-    fn();
-    console.log(`ok - ${name}`);
+    const result = fn();
+    if (result instanceof Promise) {
+      void result.then(
+        () => console.log(`ok - ${name}`),
+        (error) => {
+          console.error(`not ok - ${name}`);
+          throw error;
+        },
+      );
+    } else {
+      console.log(`ok - ${name}`);
+    }
   } catch (error) {
     console.error(`not ok - ${name}`);
     throw error;
   }
 }
 
+function calendarAvailability(dateTime: string, vacancies: number): Availability {
+  return { dateTime, vacancies, currency: 'CAD' };
+}
+
+test('admin amendment display combines one promo allocation across component rows', () => {
+  const lines = collapseAdminPromoLines([
+    { kind: 'ticket', category: 'ADULT', qty: 1, itemTotal: 170.49 },
+    { kind: 'line', label: 'Moraine Lake Road Access Fee', amount: 15.99, type: 'FEE' },
+    { kind: 'line', label: 'Discount · Moraine Lake Road Access Fee', amount: -2.4, type: 'DISCOUNT' },
+    { kind: 'line', label: 'Discount · ADULT', amount: -25.57, type: 'DISCOUNT' },
+  ], 'banffblog15');
+
+  assert.deepEqual(lines, [
+    { kind: 'ticket', category: 'ADULT', qty: 1, itemTotal: 170.49 },
+    { kind: 'line', label: 'Moraine Lake Road Access Fee', amount: 15.99, type: 'FEE' },
+    { kind: 'line', label: 'Promo: BANFFBLOG15', amount: -27.97, type: 'PROMO_CODE' },
+  ]);
+});
+
+test('admin amendment display leaves unrelated manual discounts separate', () => {
+  const lines = collapseAdminPromoLines([
+    { kind: 'line', label: 'Promo retained booking value', amount: -10, type: 'DISCOUNT' },
+    { kind: 'line', label: 'Manager courtesy', amount: -5, type: 'DISCOUNT' },
+    { kind: 'line', label: 'Discount · ADULT', amount: -20, type: 'PROMO_CODE' },
+  ], 'SAVE20');
+
+  assert.deepEqual(lines, [
+    { kind: 'line', label: 'Promo: SAVE20', amount: -30, type: 'PROMO_CODE' },
+    { kind: 'line', label: 'Manager courtesy', amount: -5, type: 'DISCOUNT' },
+  ]);
+});
+
+test('admin availability filtering removes only starts that have passed', () => {
+  const now = new Date('2026-07-21T17:00:00-06:00');
+  const rows = [
+    calendarAvailability('2026-07-21T16:59:00-06:00', 4),
+    calendarAvailability('2026-07-21T17:01:00-06:00', 4),
+    calendarAvailability('2026-07-22T08:00:00-06:00', 4),
+  ];
+
+  assert.deepEqual(
+    filterAvailabilitiesAfterCurrentTime(rows, now).map((row) => row.dateTime),
+    ['2026-07-21T17:01:00-06:00', '2026-07-22T08:00:00-06:00'],
+  );
+});
+
+test('public availability filtering keeps its stricter advance cutoff', () => {
+  const now = new Date('2026-07-21T17:00:00-06:00');
+  const rows = [
+    calendarAvailability('2026-07-21T17:30:00-06:00', 4),
+    calendarAvailability('2026-07-21T18:30:00-06:00', 4),
+  ];
+
+  assert.deepEqual(
+    filterAvailabilitiesAfterPublicBookingCutoff(rows, now, 60).map((row) => row.dateTime),
+    ['2026-07-21T18:30:00-06:00'],
+  );
+});
+
+test('calendar auto-selection advances when the selected day has no visible starts', () => {
+  const rowsByDate: Record<string, Availability[]> = {
+    '2026-07-22': [calendarAvailability('2026-07-22T08:00:00-06:00', 0)],
+    '2026-07-23': [calendarAvailability('2026-07-23T08:00:00-06:00', 3)],
+  };
+  const getRowsForDate = (date: string) => rowsByDate[date] ?? [];
+
+  assert.equal(selectedDateHasVisibleAvailability('2026-07-21', getRowsForDate), false);
+  assert.equal(
+    findFirstDateWithBookableAvailability(
+      ['2026-07-22', '2026-07-23'],
+      getRowsForDate,
+      (availability) => availability.vacancies > 0,
+    ),
+    '2026-07-23',
+  );
+});
+
 test('admin payment choice countdown expires exactly at the reservation deadline', () => {
   const expiration = '2026-07-16T15:46:44+00:00';
   assert.equal(
@@ -206,6 +318,100 @@ test('admin quote response display state cannot invalidate its request identity'
   assert.equal(keyAfterResponse, keyBeforeResponse);
 });
 
+test('admin quote dedupe refetches unchanged inputs after the published quote is cleared', () => {
+  const inputKey = 'same-admin-change-inputs';
+  assert.equal(canReuseCompletedAdminChangeQuote(inputKey, inputKey, true), true);
+  assert.equal(canReuseCompletedAdminChangeQuote(inputKey, inputKey, false), false);
+  assert.equal(canReuseCompletedAdminChangeQuote(inputKey, 'different-inputs', true), false);
+});
+
+test('admin preview and checkout share the Pricing V2 request shape', () => {
+  const request = buildAdminChangeV2QuoteRequest({
+    bookingReference: ' VFSCAEKQ ',
+    lastName: ' Tauro ',
+    parentProductId: 'product_1',
+    optionId: 'option_1',
+    selectedAvailability: {
+      availabilityId: 'availability_1',
+      productId: 'option_1',
+      dateTime: '2026-07-28T08:35:00-06:00',
+      vacancies: 10,
+    } as Parameters<typeof buildAdminChangeV2QuoteRequest>[0]['selectedAvailability'],
+    pickupLocationId: 'pickup_1',
+    returnAvailabilityId: null,
+    bookingItems: [{ category: 'ADULT', count: 3 }],
+    addOnSelections: [],
+    cancellationPolicyId: 'policy_1',
+    promoCode: ' banffblog15 ',
+    promoApplicationScope: 'ENTIRE_BOOKING',
+    structuredAdjustments: [{ type: 'CUSTOM', amount: 5 }],
+    refundDispositionsByOperationId: { remove_1: 'PENDING_REFUND' },
+    previousPassengerCount: 2,
+    previousAvailabilityId: 'availability_old',
+    previousReturnAvailabilityId: null,
+  });
+
+  assert.equal(request.bookingReference, 'VFSCAEKQ');
+  assert.equal(request.lastName, 'Tauro');
+  assert.equal(request.newProductId, 'option_1');
+  assert.deepEqual(request.newPassengerCounts, [{ category: 'ADULT', count: 3 }]);
+  assert.equal(request.promoCode, 'banffblog15');
+  assert.equal(request.promoApplicationScope, 'ENTIRE_BOOKING');
+  assert.deepEqual(request.refundDispositionsByOperationId, { remove_1: 'PENDING_REFUND' });
+  assert.deepEqual(request.capacitySeatCredit, {
+    enabled: true,
+    previousPassengerCount: 2,
+    previousAvailabilityId: 'availability_old',
+    previousReturnAvailabilityId: null,
+  });
+  assert.equal('clientProposedTotal' in request, false);
+});
+
+test('admin checkout maps the fresh Pricing V2 quote id instead of a legacy response', async () => {
+  const request = buildAdminChangeV2QuoteRequest({
+    bookingReference: 'VFSCAEKQ',
+    lastName: 'Tauro',
+    parentProductId: 'product_1',
+    optionId: 'option_1',
+    selectedAvailability: {
+      availabilityId: 'availability_1',
+      productId: 'option_1',
+      dateTime: '2026-07-28T08:35:00-06:00',
+      vacancies: 10,
+    } as Parameters<typeof buildAdminChangeV2QuoteRequest>[0]['selectedAvailability'],
+    pickupLocationId: 'pickup_1',
+    returnAvailabilityId: null,
+    bookingItems: [{ category: 'ADULT', count: 3 }],
+    addOnSelections: [],
+    cancellationPolicyId: 'policy_1',
+    structuredAdjustments: [],
+    refundDispositionsByOperationId: {},
+    previousPassengerCount: 2,
+    previousAvailabilityId: 'availability_old',
+    previousReturnAvailabilityId: null,
+  });
+  const mergedQuote = await quoteAdminChangeV2ForUi(
+    request,
+    { total: 768.11, subtotal: 707.94, tax: 60.17 },
+    'CAD',
+    async () => quote({
+      pricingQuote: {
+        quoteId: 'quote_v2_checkout',
+        currency: 'CAD',
+        payableTotal: 768.11,
+        amountToCharge: 256.03,
+        balanceDelta: 256.03,
+        lines: [],
+      },
+      balanceDeltaMajorUnits: 256.03,
+    }),
+  );
+
+  assert.equal(mergedQuote.quoteId, 'quote_v2_checkout');
+  assert.equal(mergedQuote.priceDiff, 256.03);
+  assert.equal(mergedQuote.quotedTotal, 768.11);
+});
+
 test('admin no-charge provider payload carries the selected pickup itinerary', () => {
   const itineraryDisplay: NonNullable<
     Parameters<typeof buildAdminChangeProviderPayload>[0]['itineraryDisplay']
@@ -235,6 +441,7 @@ test('admin no-charge provider payload carries the selected pickup itinerary', (
     cancellationPolicyId: 'standard',
     initialCancellationPolicyId: 'standard',
     appliedPromoCode: null,
+    promoApplicationScope: 'CHANGE_ONLY',
     newTotalAmount: 202.87,
     providerPricingOverrides: [],
     mergedProviderAdditionalAdjustments: [],
@@ -255,6 +462,7 @@ test('admin no-charge provider payload carries the selected pickup itinerary', (
   assert.deepEqual(payload?.addOnSelections, []);
   assert.equal(payload?.pricingV2QuoteId, 'quote_reviewed');
   assert.equal(payload?.pricingV2QuotedTotal, 202.87);
+  assert.equal(payload?.promoApplicationScope, null);
 });
 
 test('public paid change preview shows amendment-only charges before combined tax', () => {
@@ -349,6 +557,249 @@ test('admin removal quote preserves explicit release refund decisions for the pr
   );
 });
 
+test('admin refund decisions remain stable when successive quotes return only unresolved operations', () => {
+  const removeReturn = {
+    operationId: 'op_remove_return',
+    type: 'REMOVE_RETURN',
+    componentKey: 'return:rt_morning',
+    quantityDelta: -1,
+  };
+  const removeAdult = {
+    operationId: 'op_remove_adult',
+    type: 'REMOVE_QUANTITY',
+    componentKey: 'ticket:ADULT',
+    quantityDelta: -1,
+  };
+  const allowed = ['PENDING_REFUND', 'NO_REFUND'] as const;
+
+  const initial = mergeAdminRefundDecisionContext({
+    current: null,
+    selectionKey: 'selection-a',
+    operations: [removeReturn, removeAdult],
+    allowedByOperationId: {
+      [removeReturn.operationId]: [...allowed],
+      [removeAdult.operationId]: [...allowed],
+    },
+    removedValueByOperationId: {
+      [removeReturn.operationId]: 42.32,
+      [removeAdult.operationId]: 220.83,
+    },
+  });
+  const afterReturnDecision = mergeAdminRefundDecisionContext({
+    current: initial,
+    selectionKey: 'selection-a',
+    // The server now returns only the still-unanswered quantity removal.
+    operations: [removeAdult],
+    allowedByOperationId: { [removeAdult.operationId]: [...allowed] },
+    removedValueByOperationId: { [removeAdult.operationId]: 220.83 },
+  });
+
+  assert.deepEqual(
+    afterReturnDecision?.operations.map((operation) => operation.operationId),
+    [removeReturn.operationId, removeAdult.operationId],
+  );
+  assert.deepEqual(
+    selectRefundDispositionsForOperations(afterReturnDecision, [], {
+      [removeReturn.operationId]: 'PENDING_REFUND',
+    }),
+    { [removeReturn.operationId]: 'PENDING_REFUND' },
+  );
+
+  const complete = mergeAdminRefundDecisionContext({
+    current: afterReturnDecision,
+    selectionKey: 'selection-a',
+    operations: [],
+    allowedByOperationId: {},
+    removedValueByOperationId: {},
+  });
+  assert.deepEqual(
+    selectRefundDispositionsForOperations(complete, [], {
+      [removeReturn.operationId]: 'PENDING_REFUND',
+      [removeAdult.operationId]: 'NO_REFUND',
+    }),
+    {
+      [removeReturn.operationId]: 'PENDING_REFUND',
+      [removeAdult.operationId]: 'NO_REFUND',
+    },
+  );
+
+  const nextSelection = mergeAdminRefundDecisionContext({
+    current: complete,
+    selectionKey: 'selection-b',
+    operations: [removeAdult],
+    allowedByOperationId: { [removeAdult.operationId]: [...allowed] },
+    removedValueByOperationId: { [removeAdult.operationId]: 220.83 },
+  });
+  assert.deepEqual(
+    nextSelection?.operations.map((operation) => operation.operationId),
+    [removeAdult.operationId],
+  );
+  assert.deepEqual(
+    selectRefundDispositionsForOperations(nextSelection, [], {
+      [removeReturn.operationId]: 'PENDING_REFUND',
+      [removeAdult.operationId]: 'NO_REFUND',
+    }),
+    { [removeAdult.operationId]: 'NO_REFUND' },
+  );
+});
+
+test('admin move-service quote labels only its ticket price difference', () => {
+  const moveOperation = {
+    operationId: 'op_move_service',
+    type: 'MOVE_SERVICE',
+    componentKey: 'service',
+  };
+  const addOperation = {
+    operationId: 'op_add_adult',
+    type: 'ADD_QUANTITY',
+    componentKey: 'ticket:ADULT',
+    quantityDelta: 1,
+  };
+  const mapped = mapAdminChangeBookingQuoteV2Data({
+    oldReceipt: {
+      currency: 'CAD',
+      grossSubtotal: 247.96,
+      taxAmount: 21.08,
+      payableTotal: 269.04,
+      lines: [
+        {
+          type: 'TICKET',
+          label: 'ADULT',
+          quantity: 2,
+          amount: 215.98,
+          billable: true,
+          priceBasis: {
+            baseUnitAmount: 139.99,
+            finalUnitAmount: 107.99,
+            currency: 'CAD',
+            adjustments: [
+              {
+                type: 'DYNAMIC_PRICING',
+                id: 'rule_early_booking',
+                name: 'Early booking discount',
+                amount: -32,
+                adjustmentType: 'FIXED',
+                adjustmentValue: 32,
+              },
+            ],
+          },
+        },
+      ],
+    },
+    newQuote: {
+      currency: 'CAD',
+      payableTotal: 455.64,
+      balanceDelta: 186.60,
+      amendment: { operations: [moveOperation, addOperation] },
+      lines: [
+        {
+          type: 'TICKET',
+          label: 'ADULT',
+          quantity: 2,
+          amount: 48,
+          billable: true,
+          metadata: { category: 'ADULT', operationId: moveOperation.operationId },
+          priceBasis: {
+            baseUnitAmount: 149.99,
+            finalUnitAmount: 131.99,
+            currency: 'CAD',
+            adjustments: [
+              {
+                type: 'dynamic',
+                id: 'rule_new_date',
+                name: 'New-date adjustment',
+                amount: -18,
+                adjustmentType: 'fixed',
+                adjustmentValue: -18,
+              },
+            ],
+          },
+        },
+        {
+          type: 'TICKET',
+          label: 'ADULT',
+          quantity: 1,
+          amount: 124,
+          billable: true,
+          metadata: { category: 'ADULT', operationId: addOperation.operationId },
+        },
+      ],
+    },
+    canApply: true,
+  });
+  assert.deepEqual(mapped.originalReceipt?.lineItems?.[0]?.priceBasis, {
+    baseUnitAmount: 139.99,
+    finalUnitAmount: 107.99,
+    currency: 'CAD',
+    adjustments: [
+      {
+        type: 'DYNAMIC_PRICING',
+        id: 'rule_early_booking',
+        name: 'Early booking discount',
+        amount: -32,
+        adjustmentType: 'FIXED',
+        adjustmentValue: 32,
+      },
+    ],
+  });
+  const existingPurchaseLines = mapQuoteLineItemsToPriceSummaryLines(
+    mapped.originalReceipt?.lineItems,
+  );
+  assert.deepEqual(
+    existingPurchaseLines[0]?.kind === 'ticket'
+      ? existingPurchaseLines[0].breakdown?.lineItems
+      : null,
+    [
+      { type: 'base', name: 'Base price', amountInDisplayCurrency: 139.99 },
+      {
+        type: 'adjustment',
+        id: 'rule_early_booking',
+        name: 'Early booking discount',
+        amountInDisplayCurrency: -32,
+        adjustmentType: 'FIXED',
+        adjustmentValue: 32,
+        sourceType: 'dynamic',
+      },
+    ],
+  );
+  const preview = buildChangeBookingServerPreview(
+    mapped,
+    { total: 455.64, subtotal: 419.94, tax: 35.70 },
+    'CAD',
+  );
+  const lines = preview?.priceSummaryLines ?? [];
+
+  assert.equal(lines[0]?.kind, 'ticket');
+  assert.equal(lines[0]?.kind === 'ticket' ? lines[0].category : null, 'ADULT — new date price difference');
+  assert.deepEqual(
+    lines[0]?.kind === 'ticket' ? lines[0].unitPriceComparison : null,
+    {
+      previousLabel: 'Existing adult price',
+      updatedLabel: 'New-date adult price',
+      differenceLabel: 'Difference per adult',
+      previousUnitAmount: 107.99,
+      updatedUnitAmount: 131.99,
+      differenceUnitAmount: 24,
+    },
+  );
+  assert.deepEqual(
+    lines[0]?.kind === 'ticket' ? lines[0].breakdown?.lineItems : null,
+    [
+      { type: 'base', name: 'Base price', amountInDisplayCurrency: 149.99 },
+      {
+        type: 'adjustment',
+        id: 'rule_new_date',
+        name: 'New-date adjustment',
+        amountInDisplayCurrency: -18,
+        adjustmentType: 'fixed',
+        adjustmentValue: -18,
+        sourceType: 'dynamic',
+      },
+    ],
+  );
+  assert.equal(lines[1]?.kind === 'ticket' ? lines[1].category : null, 'ADULT');
+});
+
 test('admin return price treatment defaults to keep floor and maps optional reprice choices', () => {
   const operation = {
     operationId: 'op_change_return',
@@ -443,9 +894,20 @@ test('admin cancellation policy and structured adjustments are authoritative quo
     ...base,
     structuredAdjustments: [{ adjustmentId: 'adj_1', mode: 'FIXED_AMOUNT', fixedAmount: 10 }],
   });
+  const wholeBookingPromo = buildAdminChangeQuoteRequestKey({
+    ...base,
+    promoCode: 'BANFFBLOG15',
+    promoApplicationScope: 'ENTIRE_BOOKING',
+  });
+  const changeOnlyPromo = buildAdminChangeQuoteRequestKey({
+    ...base,
+    promoCode: 'BANFFBLOG15',
+    promoApplicationScope: 'CHANGE_ONLY',
+  });
 
   assert.notEqual(original, policyChanged);
   assert.notEqual(original, adjustmentChanged);
+  assert.notEqual(changeOnlyPromo, wholeBookingPromo);
 });
 
 test('private shuttle pricing replaces the selected calendar summary with hydrated rate details', () => {