@curless/hotel-storefront 0.18.2 → 0.19.0

package/dist/__tests__/tools.test.js

@@ -2,6 +2,7 @@ import { fileURLToPath } from 'node:url';
 import { beforeEach, describe, expect, it } from 'vitest';
 import { loadHotelData } from '../data.js';
 import { createDemoHotels } from '../demo-hotels.js';
+import { MAX_MISSES, Misses } from '../limits.js';
 import { MemberStore } from '../members.js';
 import { handleTool } from '../tools.js';
 import { TripStore } from '../trip.js';
@@ -195,7 +196,7 @@ describe('building a trip', () => {
         expect(both.structured.currencies).toEqual(['HKD', 'CNY']);
         const groups = both.structured.groups;
         expect(groups.map((g) => g.currency)).toEqual(['HKD', 'CNY']);
-        expect(both.structured.total).toBe(`${groups[0]?.total} + ${groups[1]?.total}`);
+        expect(both.structured.total).toBe(`${groups[0]?.total} · ${groups[1]?.total}`);
         expect(both.structured.dropped).toBeUndefined();
         expect(both.text).toMatch(/2 currencies, priced separately and not converted/);
         const made = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
@@ -835,7 +836,16 @@ describe('add-ons on a booking already made', () => {
         expect(again.structured.forBooking.held).toEqual({
             'airport-transfer': 1,
         });
-        // And off again.
+        // And off again - once the guest has seen what that does. A confirmation
+        // with no preview before it IS the preview (2026-09-28 audit).
+        const unseen = await call(t.changeBooking, {
+            booking: code,
+            extra: 'airport-transfer',
+            quantity: 0,
+            confirmed: true,
+        });
+        expect(unseen.structured.view).toBe('change-preview');
+        expect(unseen.text).toMatch(/Nothing has changed yet/);
         const off = await call(t.changeBooking, {
             booking: code,
             extra: 'airport-transfer',
@@ -1024,7 +1034,9 @@ describe('choosing where before which hotel', () => {
         // Every hotel counted once, down to its city.
         const cities = china?.countries.flatMap((c) => c.cities) ?? [];
         expect(cities.reduce((n, c) => n + c.count, 0)).toBe(res.structured.total);
-        expect(res.text).toMatch(/the card sets them out by region, country and city/);
+        expect(res.text).toMatch(/to choose from by region, country and city - /);
+        // Every place, for a host with no card.
+        expect(res.text).toMatch(/China \(5\)/);
         expect(res.structured.hotels).toBeUndefined();
     });
     it('answers a country of many cities with its cities, and `all` with its hotels', async () => {
@@ -1053,7 +1065,7 @@ describe('choosing where before which hotel', () => {
         const scope = res.structured.scope;
         expect(scope.name).toBe('China');
         expect(scope.cities.length).toBeGreaterThanOrEqual(4);
-        expect(res.text).toMatch(/`all` lists the hotels themselves/);
+        expect(res.text).toMatch(/`all` lists every one in China/);
         const all = await call(t.listHotels, { city: 'China', all: true });
         expect(all.structured.view).toBe('hotels');
     });
@@ -1079,9 +1091,61 @@ describe('finding a booking made elsewhere', () => {
         expect(byEmail.structured.count).toBe(0);
         const both = await handleTool(deps, t.listBookings, { email: 'robin@example.com', booking: code }, elsewhere);
         expect(both.structured.count).toBe(1);
-        const wrong = await handleTool(deps, t.listBookings, { email: 'someone@example.com', booking: code }, elsewhere);
+        // Found, it is this conversation's now: its code alone opens it here, so
+        // the card's Cancel - which sends nothing more - works on it.
+        const cancel = await handleTool(deps, t.previewCancellation, { booking: code }, elsewhere);
+        expect(cancel.structured.view).toBe('cancellation-preview');
+        // And nothing in any answer carries the conversation it was made in.
+        expect(JSON.stringify(both.structured)).not.toContain('session-');
+        expect(JSON.stringify(both.structured)).not.toContain('owners');
+        const third = { session: 'session-third' };
+        const wrong = await handleTool(deps, t.listBookings, { email: 'someone@example.com', booking: code }, third);
         expect(wrong.structured.count).toBe(0);
+        expect(wrong.structured.notFound).toBe(code);
         expect(wrong.text).toMatch(/Both are needed/);
+        // The id is not a code: with an email, only the code opens a booking.
+        const id = both.structured.bookings[0]?.id ?? '';
+        const byId = await handleTool(deps, t.listBookings, { email: 'robin@example.com', booking: id }, third);
+        expect(byId.structured.count).toBe(0);
+    });
+    it('says a miss even when the conversation has bookings to list', async () => {
+        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
+        await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
+        const res = await call(t.listBookings, { booking: 'SL-NOPE00', email: 'robin@example.com' });
+        expect(res.structured.count).toBe(1);
+        expect(res.structured.notFound).toBe('SL-NOPE00');
+        expect(res.text).toMatch(/^No booking matches that confirmation code and email/);
+    });
+    it('stops taking guesses at a code and an email after a few misses', async () => {
+        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
+        const made = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
+        const code = made.structured.booking.confirmationCode;
+        const guessing = { deps: { ...deps, misses: new Misses(() => clock) } };
+        const guess = (booking, session) => handleTool(guessing.deps, t.listBookings, { email: 'robin@example.com', booking }, { session });
+        for (let i = 0; i < MAX_MISSES; i += 1)
+            await guess(`SL-WRONG${i}`, 'session-guesser');
+        // The right code now waits too - from this conversation, and for this
+        // email from another one.
+        const blocked = await guess(code, 'session-guesser');
+        expect(blocked.structured.count).toBe(0);
+        expect(blocked.structured.tooMany).toBe(true);
+        expect(blocked.text).toMatch(/paused for a quarter of an hour/);
+        expect((await guess(code, 'session-other')).structured.tooMany).toBe(true);
+        // A conversation's own booking, with no email, is never a guess.
+        expect((await call(t.listBookings, {})).structured.count).toBe(1);
+    });
+});
+// ⚠️ A CONFIRMATION CONFIRMS WHAT WAS SHOWN (2026-09-28 audit).
+describe('confirming a cancellation', () => {
+    it('shows the fee first when nothing was previewed, then cancels on the next confirmation', async () => {
+        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
+        const made = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
+        const code = made.structured.booking.confirmationCode;
+        const first = await call(t.cancelBooking, { booking: code, confirmed: true });
+        expect(first.structured.view).toBe('cancellation-preview');
+        expect(first.text).toMatch(/Nothing is cancelled yet/);
+        const second = await call(t.cancelBooking, { booking: code, confirmed: true });
+        expect(second.structured.view).toBe('cancelled');
     });
 });
 // ⚠️ A PLACE, THEN THE DATES, THEN HOTELS PRICED FOR THEM (robin, 2026-09-28,
@@ -1177,4 +1241,217 @@ describe('a list one filter emptied', () => {
         expect(res.text).not.toMatch(/together/);
     });
 });
+// ⚠️ THE 2026-09-28 FULL AUDIT, server side: each of these was reproduced
+// against the running connector before it was fixed.
+describe('the audit of 2026-09-28', () => {
+    const pressed = (c, group) => group === 'brands'
+        ? { brand: c.name }
+        : group === 'facilities'
+            ? { facilities: [c.key] }
+            : { [String(c.key)]: true };
+    it.each([
+        ['a ceiling', { city: 'Hong Kong', maxNightly: 3000 }],
+        ['a ceiling on named nights', { city: 'Hong Kong', maxNightly: 3000, ...STAY }],
+    ])('counts every filter chip as what pressing it lists, under %s', async (_, args) => {
+        const res = await call(t.listHotels, args);
+        const refine = res.structured.refine;
+        for (const group of ['brands', 'facilities', 'room']) {
+            for (const chip of refine[group]) {
+                if (chip.on)
+                    continue;
+                const after = await call(t.listHotels, { ...args, ...pressed(chip, group) });
+                expect([group, chip.name ?? chip.key, after.structured.total ?? 0]).toEqual([
+                    group,
+                    chip.name ?? chip.key,
+                    chip.count,
+                ]);
+            }
+        }
+    });
+    it('says a ceiling emptied a filtered list, not the filter', async () => {
+        const res = await call(t.listHotels, { city: 'Hong Kong', brand: 'Kerry', maxNightly: 1000 });
+        expect(res.text).toMatch(/^Nothing under HK\$1,000 a night/);
+        expect(res.text).not.toMatch(/None of the/);
+    });
+    it('keeps the order and the ceiling on the way out of a filter that emptied the list', async () => {
+        const res = await call(t.listHotels, {
+            city: 'Hong Kong',
+            brand: 'Kerry',
+            facilities: ['spa'],
+            sort: 'rating',
+            ...STAY,
+        });
+        if (res.structured.ask) {
+            expect(res.structured.ask).toMatchObject({ sort: 'rating', city: 'Hong Kong' });
+            expect(res.structured.stay).toMatchObject(STAY);
+        }
+    });
+    it('keeps `all` on the search it echoes, so a re-query stays a list', async () => {
+        const res = await call(t.listHotels, { all: true });
+        expect(res.structured.view).toBe('hotels');
+        expect(res.structured.ask).toMatchObject({ all: true });
+        const again = await call(t.listHotels, res.structured.ask);
+        expect(again.structured.view).toBe('hotels');
+    });
+    it('puts hotels with no room for the nights last, and never counts them over a ceiling', async () => {
+        const three = { ...STAY, guests: 3 };
+        const high = await call(t.listHotels, { city: 'Hong Kong', ...three, sort: 'price-high' });
+        const tiles = high.structured.hotels;
+        const firstFull = tiles.findIndex((h) => h.noRoomsForStay);
+        expect(firstFull).toBeGreaterThan(0);
+        expect(tiles.slice(firstFull).every((h) => h.noRoomsForStay)).toBe(true);
+        const capped = await call(t.listHotels, { city: 'Hong Kong', ...three, maxNightly: 100000 });
+        expect(capped.structured.overBudget).toBeUndefined();
+        expect(capped.text).not.toMatch(/over the ceiling/);
+    });
+    it('quotes the misses on named nights at what those nights cost', async () => {
+        const weekend = { checkIn: '2026-10-23', checkOut: '2026-10-25', guests: 2 };
+        const res = await call(t.listHotels, { city: 'Hong Kong', ...weekend, maxNightly: 500 });
+        const [first] = res.structured.nearest;
+        expect(first?.forStay?.nightly).toBeDefined();
+        expect(res.text).toContain(`at ${first?.forStay?.nightly}`);
+    });
+    it('says a widened search came back over the ceiling rather than empty', async () => {
+        const res = await call(t.listHotels, { city: 'Hong Kong', query: 'helipad', maxNightly: 500 });
+        expect(res.text).toMatch(/Nothing matched Hong Kong and "helipad", so this looked in Hong Kong/);
+        expect(res.text).toMatch(/Nothing under HK\$500 a night/);
+        expect(res.text).not.toMatch(/found nothing either/);
+    });
+    it('offers no free cancellation once the window has closed', async () => {
+        // Arriving tomorrow: a 48-hour rule closed yesterday; a 24-hour one has not.
+        const soon = { checkIn: '2026-10-02', checkOut: '2026-10-03', guests: 2 };
+        const island = await call(t.getHotel, { hotel: 'hong-kong-island', ...soon });
+        const rooms = island.structured.rooms;
+        expect(rooms.some((r) => r.refundable)).toBe(true);
+        expect(rooms.every((r) => !r.freeCancellationUntil)).toBe(true);
+        expect(island.text).not.toMatch(/free to cancel/);
+        const free = await call(t.listHotels, { city: 'Hong Kong', ...soon, freeCancellation: true });
+        const ids = free.structured.hotels.map((h) => h.id).sort();
+        expect(ids).toEqual(['hong-kong-jen', 'hong-kong-kowloon']);
+    });
+    it('adds an add-on without re-pricing the room, whoever is signed in now', async () => {
+        await call(t.signIn, { number: 'SLC-4471-8820', surname: 'Ruan' });
+        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'horizon-club', ...STAY });
+        const made = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
+        const booking = made.structured.booking;
+        await call(t.signOut);
+        const extras = await call(t.listExtras, { booking: booking.confirmationCode });
+        const transfer = extras.structured.extras.find((e) => e.id === 'airport-transfer');
+        const pre = await call(t.previewChange, {
+            booking: booking.confirmationCode,
+            extra: 'airport-transfer',
+            quantity: 1,
+        });
+        // The difference is the transfer and its tax - nothing from the room.
+        const price = Number(String(transfer?.price).replace(/[^\d.]/g, ''));
+        const diff = Number(String(pre.structured.difference).replace(/[^\d.]/g, ''));
+        expect(diff).toBe(price + Math.round((price * 13) / 100));
+        expect(pre.structured.refundDue).toBe(false);
+    });
+    it('names what a change changes', async () => {
+        await call(t.addToTrip, { hotel: 'hong-kong-kowloon', room: 'deluxe', rooms: 2, ...STAY });
+        const made = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
+        const code = made.structured.booking.confirmationCode;
+        const fewer = await call(t.previewChange, { booking: code, rooms: 1 });
+        expect(fewer.text).toMatch(/would go from 2 rooms to 1 room\./);
+        const none = await call(t.previewChange, { booking: code, rooms: 0 });
+        expect(none.structured.changeable).toBe(false);
+        expect(none.text).toMatch(/at least one room/);
+        const same = await call(t.previewChange, {
+            booking: code,
+            checkOut: '2026-10-22',
+            extra: 'airport-transfer',
+            quantity: 0,
+        });
+        expect(same.text).toMatch(/would move to 2026-10-19 - 2026-10-22\./);
+    });
+    it('charges a non-refundable cancellation exactly what was booked', async () => {
+        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'horizon-club', ...STAY });
+        const made = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
+        const booking = made.structured.booking;
+        const pre = await call(t.previewCancellation, { booking: booking.confirmationCode });
+        expect(pre.structured.fee).toBe(booking.quote.total);
+        expect(pre.structured.refund).toBe('HK$0');
+    });
+    it('makes a trip total exactly the sum of the bookings it becomes', async () => {
+        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
+        await call(t.addToTrip, { hotel: 'hong-kong-island', extra: 'airport-transfer', quantity: 1 });
+        const later = { checkIn: '2026-10-21', checkOut: '2026-10-23', guests: 2 };
+        await call(t.addToTrip, { hotel: 'hong-kong-kowloon', room: 'deluxe', ...later });
+        await call(t.addToTrip, { hotel: 'hong-kong-kowloon', extra: 'airport-transfer', quantity: 1 });
+        const trip = await call(t.viewTrip);
+        const made = await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
+        const amount = (x) => Number(x.replace(/[^\d.]/g, ''));
+        const sum = made.structured.bookings.reduce((n, b) => n + amount(b.total), 0);
+        expect(sum).toBe(amount(String(trip.structured.total)));
+    });
+    it('forgets preferences on every conversation signed in as that member', async () => {
+        const other = { session: 'session-other' };
+        const member = { number: 'SLC-4471-8820', surname: 'Ruan' };
+        await call(t.signIn, member);
+        await handleTool(deps, t.signIn, member, other);
+        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
+        await call(t.requestBooking, {
+            name: 'Robin Ruan',
+            email: 'robin@example.com',
+            requests: ['king-bed', 'high-floor'],
+            rememberRequests: true,
+        });
+        await handleTool(deps, t.forgetPreferences, {}, other);
+        const here = await call(t.viewTrip);
+        expect(here.structured.member.preferences).toBeUndefined();
+    });
+    it('adds to saved preferences rather than replacing them, and never keeps an accessible room', async () => {
+        await call(t.signIn, { number: 'SLC-4471-8820', surname: 'Ruan' });
+        const book = async (requests) => {
+            await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'deluxe-city', ...STAY });
+            return call(t.requestBooking, {
+                name: 'Robin Ruan',
+                email: 'robin@example.com',
+                requests,
+                rememberRequests: true,
+            });
+        };
+        await book(['king-bed', 'high-floor']);
+        const second = await book(['quiet-room', 'accessible-room', 'twin-beds']);
+        expect(second.structured.remembered).toEqual(['high-floor', 'quiet-room', 'twin-beds']);
+    });
+    it('compares at the member rate the list and the hotel show', async () => {
+        await call(t.signIn, { number: 'SLC-4471-8820', surname: 'Ruan' });
+        const hotel = await call(t.getHotel, { hotel: 'hong-kong-kerry', ...STAY });
+        const cheapest = hotel.structured.rooms
+            .map((r) => r.stayTotal)
+            .sort((a, b) => Number(a.replace(/\D/g, '')) - Number(b.replace(/\D/g, '')))[0];
+        const compared = await call(t.compare, {
+            entries: [{ hotel: 'hong-kong-kerry' }, { hotel: 'hong-kong-jen' }],
+            ...STAY,
+        });
+        const columns = compared.structured.columns;
+        expect(columns.find((c) => c.hotel.id === 'hong-kong-kerry')?.price?.stayTotal).toBe(cheapest);
+    });
+    it('clamps the room count it says and echoes, and spells a brand as the data does', async () => {
+        const many = await call(t.listHotels, { city: 'Hong Kong', ...STAY, rooms: 9 });
+        expect(many.structured.ask).toMatchObject({ rooms: 5 });
+        expect(many.text).toMatch(/5 rooms/);
+        const kerry = await call(t.listHotels, { city: 'Hong Kong', brand: 'kerry' });
+        const chip = kerry.structured.refine.brands.find((b) => b.name === 'Kerry');
+        expect(chip?.on).toBe(true);
+    });
+    it('says a page past the end is past the end', async () => {
+        const res = await call(t.listHotels, { city: 'Hong Kong', offset: 10 });
+        expect(res.text).toMatch(/past the end: 4 match/);
+    });
+    it('lets a lapsed hold go before pricing a list', async () => {
+        const three = { ...STAY, guests: 3 };
+        await call(t.addToTrip, { hotel: 'hong-kong-island', room: 'suite', ...three });
+        await call(t.requestBooking, { name: 'Robin Ruan', email: 'robin@example.com' });
+        const held = await call(t.listHotels, { city: 'Hong Kong', ...three });
+        const island = () => held.structured.hotels;
+        expect(island().find((h) => h.id === 'hong-kong-island')?.noRoomsForStay).toBeDefined();
+        clock += 3 * 3_600_000;
+        const lapsed = await call(t.listHotels, { city: 'Hong Kong', ...three });
+        const tile = lapsed.structured.hotels.find((h) => h.id === 'hong-kong-island');
+        expect(tile?.noRoomsForStay).toBeUndefined();
+    });
+});
 //# sourceMappingURL=tools.test.js.map