summit-registration-lite 7.0.5 → 7.0.6

package/e2e/promo-code-date-filter.spec.js

@@ -0,0 +1,103 @@
+const { test, expect } = require('@playwright/test');
+const {
+    ticketType,
+    discoveredCode,
+    discoveryResponse,
+    ticketTypesResponse,
+    taxTypesResponse,
+    validationResponse,
+} = require('./fixtures');
+
+// Post-apply auto-select must scan the date-filtered ticket list (`allowedTicketTypes`),
+// not the raw Redux list (`originalTicketTypes`). Otherwise the widget could pick a ticket
+// that's outside its sales window — the dropdown can't display it and the user is stuck.
+
+const setupRoutes = async (page, { discovery, tickets, validation }) => {
+    await page.route('**/promo-codes/all/discover*', route =>
+        route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify(discoveryResponse(discovery)) })
+    );
+    await page.route('**/ticket-types/allowed*', route =>
+        route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify(ticketTypesResponse(tickets)) })
+    );
+    await page.route('**/tax-types*', route =>
+        route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify(taxTypesResponse()) })
+    );
+    if (validation) {
+        await page.route('**/promo-codes/*/apply*', route =>
+            route.fulfill({ status: validation.status, contentType: 'application/json', body: JSON.stringify(validation.body) })
+        );
+    }
+};
+
+test.describe('post-apply auto-select respects sales window', () => {
+    test('picks the in-window ticket when a discovered code matches both an expired and an active ticket', async ({ page }) => {
+        // Code matches both tickets, but Expired Ticket has a sales_end_date in the past.
+        // Pre-fix, the auto-select scanned originalTicketTypes (unfiltered) and would land
+        // on Expired Ticket — first match in iteration order. Post-fix, only Active Ticket
+        // can be auto-selected because Expired Ticket is excluded by the date filter.
+        const expiredTicket = ticketType({
+            id: 188,
+            name: 'Expired Ticket',
+            sales_start_date: 1000000,    // long ago
+            sales_end_date: 2000000,      // also long ago
+        });
+        const activeTicket = ticketType({
+            id: 200,
+            name: 'Active Ticket',
+            sales_start_date: null,
+            sales_end_date: null,
+        });
+        const code = discoveredCode({
+            auto_apply: true,
+            allowed_ticket_types: [188, 200],
+        });
+
+        await setupRoutes(page, {
+            tickets: [expiredTicket, activeTicket],
+            discovery: [code],
+            validation: { status: 200, body: validationResponse() },
+        });
+        await page.goto('/');
+
+        // Auto-apply runs on load; the post-apply effect picks a qualifying ticket.
+        // The dropdown's selected-ticket slot shows the chosen ticket's name.
+        await expect(page.locator('[data-testid="selected-ticket"]')).toContainText('Active Ticket');
+        await expect(page.locator('[data-testid="selected-ticket"]')).not.toContainText('Expired Ticket');
+    });
+
+    test('never picks an expired ticket even when it is the only qualifying one', async ({ page }) => {
+        // Code matches only the expired ticket. Two active tickets exist (so the
+        // "fall back to the single allowed option" clause cannot mask the bug).
+        // Pre-fix, the widget scanned originalTicketTypes and would land on
+        // Expired Ticket — the only qualifying one. Post-fix, the qualifying
+        // scan is bounded by allowedTicketTypes, so Expired Ticket is never
+        // selectable.
+        const expiredTicket = ticketType({
+            id: 188,
+            name: 'Expired Ticket',
+            sales_start_date: 1000000,
+            sales_end_date: 2000000,
+        });
+        const activeA = ticketType({ id: 200, name: 'Active A', sales_start_date: null, sales_end_date: null });
+        const activeB = ticketType({ id: 201, name: 'Active B', sales_start_date: null, sales_end_date: null });
+        const code = discoveredCode({
+            auto_apply: true,
+            allowed_ticket_types: [188], // only the expired one qualifies
+        });
+
+        await setupRoutes(page, {
+            tickets: [expiredTicket, activeA, activeB],
+            discovery: [code],
+            validation: { status: 200, body: validationResponse() },
+        });
+        await page.goto('/');
+
+        // Give the auto-apply + post-apply effects time to settle.
+        await page.waitForTimeout(500);
+        // Post-fix: no auto-selection happens because the only qualifying ticket
+        // is filtered out by date and the fallback ("if there's a single allowed
+        // option, pick it") cannot fire when more than one is allowed. The dropdown
+        // shows its placeholder. Pre-fix, this slot would have shown "Expired Ticket".
+        await expect(page.locator('[data-testid="no-ticket"]')).toBeVisible();
+    });
+});

package/e2e/promo-code-discovery.spec.js

@@ -124,6 +124,27 @@ test.describe('suggestion flow (auto_apply: false)', () => {
         await page.fill('input[placeholder="Enter your promo code"]', 'SUGGEST50');
         await expect(page.locator('text=You qualify for the following promo code:')).toBeVisible();
     });
+
+    test('banner swaps to "applies to a different ticket" copy after switching to a non-qualifying ticket', async ({ page }) => {
+        const qualifying = ticketType({ id: 188, name: 'Early Bird Ticket' });
+        const nonQualifying = ticketType({ id: 999, name: 'Standard Ticket' });
+        const code = discoveredCode({ auto_apply: false, code: 'SUGGEST50', allowed_ticket_types: [188] });
+
+        await setupRoutes(page, {
+            tickets: [qualifying, nonQualifying],
+            discovery: [code],
+        });
+        await page.goto('/');
+
+        await selectTicket(page, 'Early Bird Ticket');
+        await expect(page.locator('text=You qualify for the following promo code:')).toBeVisible();
+
+        await selectTicket(page, 'Standard Ticket');
+        await expect(page.locator('text=Following promo code applies to a different ticket. Apply to switch.')).toBeVisible();
+        // The personal "You qualify" copy must be gone — banner stays visible
+        // but accurate about the current pick.
+        await expect(page.locator('text=You qualify for the following promo code:')).toHaveCount(0);
+    });
 });
 
 test.describe('auto-apply flow (auto_apply: true)', () => {
@@ -154,15 +175,29 @@ test.describe('auto-apply flow (auto_apply: true)', () => {
         await expect(page.locator('text=You qualify for the following promo code:')).toBeVisible();
     });
 
-    test('does not auto-apply for non-qualifying ticket', async ({ page }) => {
+    test('auto-applies on load and surfaces INVALID when the only ticket is non-qualifying', async ({ page }) => {
         const nonQualifyingTicket = ticketType({ id: 999, name: 'Standard Ticket' });
         await setupRoutes(page, {
             tickets: [nonQualifyingTicket],
             discovery: [autoCode],
+            // Per the SDS, early auto-apply fires whenever a single auto_apply code
+            // exists — independent of which tickets are present. Re-validation against
+            // the lone non-qualifying ticket then catches the mismatch and the user
+            // sees the backend's rejection message.
+            validation: (route) => {
+                if (route.request().url().includes('ticket_type_id%3D%3D999')) {
+                    return route.fulfill({
+                        status: 412,
+                        contentType: 'application/json',
+                        body: JSON.stringify(validationError('Promo code AUTO100 can not be applied to Ticket Type Standard Ticket.')),
+                    });
+                }
+                return route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify(validationResponse()) });
+            },
         });
         await page.goto('/');
-        await selectTicket(page, 'Standard Ticket');
-        await expect(page.locator('text=Do you have a promo code?')).toBeVisible();
+        await expect(page.locator('input[placeholder="Enter your promo code"]')).toHaveValue('AUTO100');
+        await expect(page.locator('text=Promo code AUTO100 can not be applied to Ticket Type Standard Ticket.')).toBeVisible();
     });
 });
 
@@ -288,7 +323,7 @@ test.describe('no tickets available', () => {
 });
 
 test.describe('ticket switching with applied code', () => {
-    test('removes discovered code when switching to non-qualifying ticket', async ({ page }) => {
+    test('keeps code applied and surfaces INVALID when switching to non-qualifying ticket', async ({ page }) => {
         const qualifying = ticketType({ id: 188, name: 'Early Bird Ticket' });
         const nonQualifying = ticketType({ id: 999, name: 'Standard Ticket' });
         const code = discoveredCode({ auto_apply: true, allowed_ticket_types: [188] });
@@ -296,15 +331,28 @@ test.describe('ticket switching with applied code', () => {
         await setupRoutes(page, {
             tickets: [qualifying, nonQualifying],
             discovery: [code],
-            validation: { status: 200, body: validationResponse() },
+            // Reject the validate call when targeting the non-qualifying ticket type.
+            validation: (route) => {
+                if (route.request().url().includes('ticket_type_id%3D%3D999')) {
+                    return route.fulfill({
+                        status: 412,
+                        contentType: 'application/json',
+                        body: JSON.stringify(validationError('Promo code EARLYBIRD can not be applied to Ticket Type Standard Ticket.')),
+                    });
+                }
+                return route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify(validationResponse()) });
+            },
         });
         await page.goto('/');
         await selectTicket(page, 'Early Bird Ticket');
         await expect(page.locator('text=Following promo code was automatically applied:')).toBeVisible();
 
         await selectTicket(page, 'Standard Ticket');
-        await expect(page.locator('text=Do you have a promo code?')).toBeVisible();
-        await expect(page.locator('input[placeholder="Enter your promo code"]')).toHaveValue('');
+        // The code is no longer silently removed on a non-qualifying ticket switch;
+        // it stays applied and is re-validated, surfacing the backend rejection so
+        // the user can choose to Remove or pick another qualifying ticket.
+        await expect(page.locator('input[placeholder="Enter your promo code"]')).toHaveValue('EARLYBIRD');
+        await expect(page.locator('text=Promo code EARLYBIRD can not be applied to Ticket Type Standard Ticket.')).toBeVisible();
     });
 
     test('suggestion appears when switching back to qualifying ticket', async ({ page }) => {

package/e2e/promo-code-invalid-clears-warning.spec.js

@@ -0,0 +1,57 @@
+const { test, expect } = require('@playwright/test');
+const {
+    ticketType,
+    discoveryResponse,
+    ticketTypesResponse,
+    taxTypesResponse,
+    validationError,
+} = require('./fixtures');
+
+// The unapplied-code warning ("you typed a code but didn't click Apply") must yield
+// to the hook's own validation error once the backend rejects the code. Without the
+// fix, the warning kept its precedence in the merged display slot, masking the
+// more specific "Promo code entered is not valid" message after a failed Apply.
+
+const UNAPPLIED_WARNING = "You entered a promo code but it hasn't been applied";
+const INVALID_MESSAGE = 'Promo code entered is not valid.';
+
+test('INVALID status clears the unapplied-code warning', async ({ page }) => {
+    await page.route('**/promo-codes/all/discover*', route =>
+        route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify(discoveryResponse([])) })
+    );
+    await page.route('**/ticket-types/allowed*', route =>
+        route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify(ticketTypesResponse([ticketType()])) })
+    );
+    await page.route('**/tax-types*', route =>
+        route.fulfill({ status: 200, contentType: 'application/json', body: JSON.stringify(taxTypesResponse()) })
+    );
+    await page.route('**/promo-codes/*/apply*', route =>
+        route.fulfill({
+            status: 412,
+            contentType: 'application/json',
+            body: JSON.stringify(validationError('The Promo Code "BAD" is not a valid code.')),
+        })
+    );
+
+    await page.goto('/');
+
+    // Select a ticket so the Next button is enabled.
+    await page.locator('[data-testid="ticket-dropdown"]').click();
+    await page.locator('[data-testid="ticket-list"] >> text=Early Bird Ticket').click();
+
+    // Type a code WITHOUT clicking Apply, then hit Next.
+    // This is the trigger for the unapplied-code warning.
+    await page.fill('input[placeholder="Enter your promo code"]', 'BAD');
+    await page.click('button:has-text("Next")');
+
+    // Warning is visible, INVALID message is not.
+    await expect(page.locator(`text=${UNAPPLIED_WARNING}`)).toBeVisible();
+    await expect(page.locator(`text=${INVALID_MESSAGE}`)).not.toBeVisible();
+
+    // Now click Apply. Backend rejects with 412 — the hook surfaces the INVALID message.
+    await page.click('button:has-text("Apply")');
+
+    // The unapplied warning must give way to the more specific rejection reason.
+    await expect(page.locator(`text=${INVALID_MESSAGE}`)).toBeVisible();
+    await expect(page.locator(`text=${UNAPPLIED_WARNING}`)).not.toBeVisible();
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "summit-registration-lite",
-  "version": "7.0.5",
+  "version": "7.0.6",
   "description": "Summit Registration Lite",
   "main": "index.js",
   "scripts": {