@jackwener/opencli 1.7.21 → 1.8.0

package/clis/bilibili/summary.test.js

@@ -0,0 +1,210 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { ArgumentError, AuthRequiredError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+
+const { mockApiGet, mockResolveBvid } = vi.hoisted(() => ({
+    mockApiGet: vi.fn(),
+    mockResolveBvid: vi.fn(),
+}));
+
+vi.mock('./utils.js', async (importOriginal) => ({
+    ...(await importOriginal()),
+    apiGet: mockApiGet,
+    resolveBvid: mockResolveBvid,
+}));
+
+import { getRegistry } from '@jackwener/opencli/registry';
+import './summary.js';
+
+describe('bilibili summary', () => {
+    const command = getRegistry().get('bilibili/summary');
+    const page = {};
+
+    beforeEach(() => {
+        mockApiGet.mockReset();
+        mockResolveBvid.mockReset();
+        mockResolveBvid.mockRejectedValue(new Error('short link not found'));
+    });
+
+    function mockView(data = { aid: 114, cid: 222, owner: { mid: 333 } }) {
+        mockApiGet.mockResolvedValueOnce({ code: 0, data });
+    }
+
+    function mockConclusion(modelResult) {
+        mockApiGet.mockResolvedValueOnce({
+            code: 0,
+            data: {
+                code: 0,
+                model_result: modelResult,
+            },
+        });
+    }
+
+    it('returns the summary plus timestamped outline rows', async () => {
+        mockView();
+        mockConclusion({
+            summary: '整体总结',
+            outline: [
+                {
+                    title: '第一节',
+                    timestamp: 0,
+                    part_outline: [
+                        { timestamp: 12, content: '要点A' },
+                        { timestamp: 3725, content: '要点B' },
+                    ],
+                },
+            ],
+        });
+
+        const result = await command.func(page, { bvid: 'BV1xxx' });
+
+        expect(mockApiGet).toHaveBeenNthCalledWith(1, page, '/x/web-interface/view', { params: { bvid: 'BV1xxx' } });
+        expect(mockApiGet).toHaveBeenNthCalledWith(2, page, '/x/web-interface/view/conclusion/get', {
+            params: { bvid: 'BV1xxx', cid: 222, up_mid: 333 },
+            signed: true,
+        });
+        expect(result).toEqual([
+            { time: '', content: '整体总结' },
+            { time: '00:00', content: '# 第一节' },
+            { time: '00:12', content: '要点A' },
+            { time: '1:02:05', content: '要点B' },
+        ]);
+    });
+
+    it('returns just the summary when the video has no outline', async () => {
+        mockView({ aid: 1, cid: 2, owner: { mid: 3 } });
+        mockConclusion({ summary: '只有总结', outline: [] });
+
+        await expect(command.func(page, { bvid: 'BV1xxx' })).resolves.toEqual([
+            { time: '', content: '只有总结' },
+        ]);
+    });
+
+    it('parses model_result when Bilibili returns it as a JSON string', async () => {
+        mockView({ aid: 1, cid: 2, owner: { mid: 3 } });
+        mockConclusion(JSON.stringify({ summary: '字符串总结', outline: [] }));
+
+        await expect(command.func(page, { bvid: 'BV1xxx' })).resolves.toEqual([
+            { time: '', content: '字符串总结' },
+        ]);
+    });
+
+    it('normalizes Bilibili video URLs before calling the APIs', async () => {
+        mockView({ aid: 1, cid: 2, owner: { mid: 3 } });
+        mockConclusion({ summary: 'URL 总结', outline: [] });
+
+        await command.func(page, {
+            bvid: 'https://www.bilibili.com/video/BV1abc12345/?spm_id_from=333.1007',
+        });
+
+        expect(mockApiGet).toHaveBeenNthCalledWith(1, page, '/x/web-interface/view', { params: { bvid: 'BV1abc12345' } });
+    });
+
+    it('resolves b23.tv short links through the shared resolver', async () => {
+        mockResolveBvid.mockResolvedValueOnce('BVshort12345');
+        mockView({ aid: 1, cid: 2, owner: { mid: 3 } });
+        mockConclusion({ summary: '短链总结', outline: [] });
+
+        await command.func(page, { bvid: 'https://b23.tv/abc' });
+
+        expect(mockResolveBvid).toHaveBeenCalledWith('https://b23.tv/abc');
+        expect(mockApiGet).toHaveBeenNthCalledWith(1, page, '/x/web-interface/view', { params: { bvid: 'BVshort12345' } });
+    });
+
+    it('rejects invalid inputs before calling Bilibili APIs', async () => {
+        const cases = [
+            '',
+            'javascript:alert(1)',
+            'https://example.com/video/BV1abc12345',
+            'https://share.note.youdao.com/video/BV1abc12345',
+            'https://www.bilibili.com/read/cv12345',
+        ];
+
+        for (const bvid of cases) {
+            await expect(command.func(page, { bvid })).rejects.toBeInstanceOf(ArgumentError);
+        }
+        expect(mockApiGet).not.toHaveBeenCalled();
+    });
+
+    it('maps unresolved short-code inputs to ArgumentError without calling APIs', async () => {
+        await expect(command.func(page, { bvid: 'not-a-bv' })).rejects.toBeInstanceOf(ArgumentError);
+
+        expect(mockResolveBvid).toHaveBeenCalledWith('not-a-bv');
+        expect(mockApiGet).not.toHaveBeenCalled();
+    });
+
+    it('throws EmptyResultError when Bilibili has not generated an AI summary for the video', async () => {
+        mockView({ aid: 1, cid: 2, owner: { mid: 3 } });
+        mockApiGet.mockResolvedValueOnce({ code: 0, data: { code: 1, model_result: {} } });
+
+        await expect(command.func(page, { bvid: 'BV1xxx' })).rejects.toBeInstanceOf(EmptyResultError);
+    });
+
+    it('throws CommandExecutionError when the view payload is malformed', async () => {
+        mockApiGet.mockResolvedValueOnce({ code: 0, data: {} });
+
+        await expect(command.func(page, { bvid: 'BVbroken' })).rejects.toSatisfy(
+            (err) => err instanceof CommandExecutionError && /cid\/up_mid/.test(err.message),
+        );
+    });
+
+    it('throws CommandExecutionError when the view API returns a non-auth error', async () => {
+        mockApiGet.mockResolvedValueOnce({ code: -404, message: '啥都木有' });
+
+        await expect(command.func(page, { bvid: 'BVbroken' })).rejects.toSatisfy(
+            (err) => err instanceof CommandExecutionError && /啥都木有.*-404/.test(err.message),
+        );
+    });
+
+    it('maps conclusion auth or permission errors to AuthRequiredError', async () => {
+        mockView({ aid: 1, cid: 2, owner: { mid: 3 } });
+        mockApiGet.mockResolvedValueOnce({ code: -403, message: '访问权限不足' });
+
+        await expect(command.func(page, { bvid: 'BV1xxx' })).rejects.toBeInstanceOf(AuthRequiredError);
+    });
+
+    it('maps conclusion non-auth API errors to CommandExecutionError', async () => {
+        mockView({ aid: 1, cid: 2, owner: { mid: 3 } });
+        mockApiGet.mockResolvedValueOnce({ code: -500, message: 'server error' });
+
+        await expect(command.func(page, { bvid: 'BV1xxx' })).rejects.toSatisfy(
+            (err) => err instanceof CommandExecutionError && /server error.*-500/.test(err.message),
+        );
+    });
+
+    it('throws CommandExecutionError for malformed conclusion API payloads', async () => {
+        mockView({ aid: 1, cid: 2, owner: { mid: 3 } });
+        mockApiGet.mockResolvedValueOnce(null);
+
+        await expect(command.func(page, { bvid: 'BV1xxx' })).rejects.toBeInstanceOf(CommandExecutionError);
+    });
+
+    it('throws CommandExecutionError for malformed model_result JSON', async () => {
+        mockView({ aid: 1, cid: 2, owner: { mid: 3 } });
+        mockConclusion('{bad json');
+
+        await expect(command.func(page, { bvid: 'BV1xxx' })).rejects.toSatisfy(
+            (err) => err instanceof CommandExecutionError && /model_result JSON/.test(err.message),
+        );
+    });
+
+    it('throws CommandExecutionError for malformed outline shapes', async () => {
+        mockView({ aid: 1, cid: 2, owner: { mid: 3 } });
+        mockConclusion({ summary: '坏 outline', outline: {} });
+
+        await expect(command.func(page, { bvid: 'BV1xxx' })).rejects.toSatisfy(
+            (err) => err instanceof CommandExecutionError && /outline/.test(err.message),
+        );
+    });
+
+    it('throws CommandExecutionError for malformed part outline shapes', async () => {
+        mockView({ aid: 1, cid: 2, owner: { mid: 3 } });
+        mockConclusion({
+            summary: '坏 part_outline',
+            outline: [{ title: '段落', timestamp: 0, part_outline: {} }],
+        });
+
+        await expect(command.func(page, { bvid: 'BV1xxx' })).rejects.toSatisfy(
+            (err) => err instanceof CommandExecutionError && /part outline/.test(err.message),
+        );
+    });
+});

package/clis/booking/booking.test.js

@@ -0,0 +1,356 @@
+import { describe, expect, it } from 'vitest';
+import { ArgumentError, CommandExecutionError, EmptyResultError } from '@jackwener/opencli/errors';
+import { getRegistry } from '@jackwener/opencli/registry';
+import './search.js';
+import { __test__ } from './search.js';
+
+const {
+    normalizePositiveInt,
+    normalizeNonNegativeInt,
+    normalizeDate,
+    normalizeCurrency,
+    normalizeLang,
+    hasPositiveResultCount,
+    buildSearchUrl,
+} = __test__;
+
+describe('booking helpers — normalizePositiveInt (no silent clamp)', () => {
+    it('returns default when value is undefined/null/empty', () => {
+        expect(normalizePositiveInt(undefined, 2, 'adults', 30)).toBe(2);
+        expect(normalizePositiveInt(null, 2, 'adults', 30)).toBe(2);
+    });
+
+    it('accepts integers in range', () => {
+        expect(normalizePositiveInt(1, 2, 'adults', 30)).toBe(1);
+        expect(normalizePositiveInt(30, 2, 'adults', 30)).toBe(30);
+    });
+
+    it('rejects zero / negative / out-of-range / non-integer (no silent clamp)', () => {
+        expect(() => normalizePositiveInt(0, 2, 'adults', 30)).toThrow(ArgumentError);
+        expect(() => normalizePositiveInt(-1, 2, 'adults', 30)).toThrow(ArgumentError);
+        expect(() => normalizePositiveInt(31, 2, 'adults', 30)).toThrow(ArgumentError);
+        expect(() => normalizePositiveInt(1.5, 2, 'adults', 30)).toThrow(ArgumentError);
+        expect(() => normalizePositiveInt('abc', 2, 'adults', 30)).toThrow(ArgumentError);
+    });
+});
+
+describe('booking helpers — normalizeNonNegativeInt', () => {
+    it('accepts zero', () => {
+        expect(normalizeNonNegativeInt(0, 0, 'children', 10)).toBe(0);
+    });
+
+    it('rejects negative / out-of-range (no silent clamp)', () => {
+        expect(() => normalizeNonNegativeInt(-1, 0, 'children', 10)).toThrow(ArgumentError);
+        expect(() => normalizeNonNegativeInt(11, 0, 'children', 10)).toThrow(ArgumentError);
+    });
+});
+
+describe('booking helpers — normalizeDate', () => {
+    it('accepts YYYY-MM-DD', () => {
+        expect(normalizeDate('2026-06-15', 'checkin')).toBe('2026-06-15');
+    });
+
+    it('rejects bad format / nonsense dates with ArgumentError', () => {
+        expect(() => normalizeDate('', 'checkin')).toThrow(ArgumentError);
+        expect(() => normalizeDate('06/15/2026', 'checkin')).toThrow(ArgumentError);
+        expect(() => normalizeDate('2026-13-40', 'checkin')).toThrow(ArgumentError);
+        expect(() => normalizeDate('2026-02-31', 'checkin')).toThrow(ArgumentError);
+    });
+});
+
+describe('booking helpers — normalizeCurrency', () => {
+    it('passes 3-letter codes uppercased', () => {
+        expect(normalizeCurrency('usd')).toBe('USD');
+        expect(normalizeCurrency('JPY')).toBe('JPY');
+    });
+
+    it('returns empty for unset', () => {
+        expect(normalizeCurrency(undefined)).toBe('');
+        expect(normalizeCurrency('')).toBe('');
+    });
+
+    it('rejects non-3-letter codes', () => {
+        expect(() => normalizeCurrency('US')).toThrow(ArgumentError);
+        expect(() => normalizeCurrency('US$')).toThrow(ArgumentError);
+        expect(() => normalizeCurrency('USDX')).toThrow(ArgumentError);
+    });
+});
+
+describe('booking helpers — normalizeLang whitelist', () => {
+    it('lowercases supported langs', () => {
+        expect(normalizeLang('EN-US')).toBe('en-us');
+        expect(normalizeLang('zh-cn')).toBe('zh-cn');
+    });
+
+    it('rejects unknown langs', () => {
+        expect(() => normalizeLang('xx-yy')).toThrow(ArgumentError);
+        expect(() => normalizeLang('en')).toThrow(ArgumentError);
+    });
+});
+
+describe('booking helpers — buildSearchUrl', () => {
+    it('constructs canonical search URL with required params', () => {
+        const url = buildSearchUrl({
+            destination: 'Tokyo',
+            checkin: '2026-06-15',
+            checkout: '2026-06-17',
+            adults: 2,
+            rooms: 1,
+            children: 0,
+            offset: 0,
+            currency: 'USD',
+            lang: 'en-us',
+        });
+        expect(url).toContain('https://www.booking.com/searchresults.en-us.html');
+        expect(url).toContain('ss=Tokyo');
+        expect(url).toContain('checkin=2026-06-15');
+        expect(url).toContain('checkout=2026-06-17');
+        expect(url).toContain('group_adults=2');
+        expect(url).toContain('no_rooms=1');
+        expect(url).toContain('group_children=0');
+        expect(url).toContain('selected_currency=USD');
+        expect(url).not.toContain('offset=');
+    });
+
+    it('omits lang file segment when lang is empty', () => {
+        const url = buildSearchUrl({
+            destination: 'Paris', checkin: '2026-06-15', checkout: '2026-06-17',
+            adults: 2, rooms: 1, children: 0, offset: 0, currency: '', lang: '',
+        });
+        expect(url).toMatch(/booking\.com\/searchresults\.html\?/);
+    });
+
+    it('emits offset only when > 0', () => {
+        const url = buildSearchUrl({
+            destination: 'Paris', checkin: '2026-06-15', checkout: '2026-06-17',
+            adults: 2, rooms: 1, children: 0, offset: 25, currency: '', lang: '',
+        });
+        expect(url).toContain('offset=25');
+    });
+});
+
+describe('booking helpers — hasPositiveResultCount', () => {
+    it('detects positive Booking result-count evidence', () => {
+        expect(hasPositiveResultCount('Tokyo: 1,234 properties found')).toBe(true);
+        expect(hasPositiveResultCount('1 stay found')).toBe(true);
+    });
+
+    it('does not treat no-results text as positive evidence', () => {
+        expect(hasPositiveResultCount('No properties found')).toBe(false);
+        expect(hasPositiveResultCount('0 properties found')).toBe(false);
+    });
+});
+
+describe('booking adapter registry shape', () => {
+    it('search is registered as read with id-shaped column for round-trip', () => {
+        const search = getRegistry().get('booking/search');
+        expect(search).toBeDefined();
+        expect(search.access).toBe('read');
+        expect(search.browser).toBe(true);
+        // slug + country together form the round-trip identity (URL: /hotel/<country>/<slug>.html)
+        expect(search.columns).toContain('slug');
+        expect(search.columns).toContain('country');
+        expect(search.columns).toContain('url');
+    });
+
+    it('search columns stay <= 12 to honor agent-native row shape', () => {
+        const search = getRegistry().get('booking/search');
+        expect(search.columns.length).toBeLessThanOrEqual(12);
+    });
+});
+
+describe('booking search — typed errors (no silent fallback)', () => {
+    const fakePage = { goto: () => { throw new Error('should not navigate'); } };
+
+    it('rejects empty destination with ArgumentError', async () => {
+        const search = getRegistry().get('booking/search');
+        await expect(search.func(fakePage, { destination: '   ', checkin: '2026-06-15', checkout: '2026-06-17' })).rejects.toThrow(ArgumentError);
+    });
+
+    it('rejects missing checkin/checkout with ArgumentError', async () => {
+        const search = getRegistry().get('booking/search');
+        await expect(search.func(fakePage, { destination: 'Tokyo' })).rejects.toThrow(ArgumentError);
+        await expect(search.func(fakePage, { destination: 'Tokyo', checkin: '2026-06-15' })).rejects.toThrow(ArgumentError);
+    });
+
+    it('rejects checkout <= checkin with ArgumentError', async () => {
+        const search = getRegistry().get('booking/search');
+        await expect(search.func(fakePage, { destination: 'Tokyo', checkin: '2026-06-17', checkout: '2026-06-15' })).rejects.toThrow(ArgumentError);
+        await expect(search.func(fakePage, { destination: 'Tokyo', checkin: '2026-06-15', checkout: '2026-06-15' })).rejects.toThrow(ArgumentError);
+    });
+
+    it('rejects out-of-range --limit with ArgumentError (no silent clamp to 100)', async () => {
+        const search = getRegistry().get('booking/search');
+        await expect(search.func(fakePage, { destination: 'Tokyo', checkin: '2026-06-15', checkout: '2026-06-17', limit: 999 })).rejects.toThrow(ArgumentError);
+    });
+
+    it('rejects negative --offset with ArgumentError', async () => {
+        const search = getRegistry().get('booking/search');
+        await expect(search.func(fakePage, { destination: 'Tokyo', checkin: '2026-06-15', checkout: '2026-06-17', offset: -1 })).rejects.toThrow(ArgumentError);
+    });
+
+    it('rejects unsupported --lang with ArgumentError', async () => {
+        const search = getRegistry().get('booking/search');
+        await expect(search.func(fakePage, { destination: 'Tokyo', checkin: '2026-06-15', checkout: '2026-06-17', lang: 'xx-yy' })).rejects.toThrow(ArgumentError);
+    });
+
+    it('rejects malformed --currency with ArgumentError', async () => {
+        const search = getRegistry().get('booking/search');
+        await expect(search.func(fakePage, { destination: 'Tokyo', checkin: '2026-06-15', checkout: '2026-06-17', currency: 'US$' })).rejects.toThrow(ArgumentError);
+    });
+
+    it('wraps browser navigation failures as CommandExecutionError', async () => {
+        const search = getRegistry().get('booking/search');
+        const downPage = { goto: () => Promise.reject(new Error('browser down')) };
+        await expect(search.func(downPage, { destination: 'Tokyo', checkin: '2026-06-15', checkout: '2026-06-17' })).rejects.toThrow(CommandExecutionError);
+    });
+
+    it('throws EmptyResultError when extractor returns no cards', async () => {
+        const search = getRegistry().get('booking/search');
+        const emptyPage = {
+            goto: async () => {},
+            wait: async () => {},
+            evaluate: async () => ({ ok: true, items: [], blocked: false, totalText: 'No properties found' }),
+        };
+        await expect(search.func(emptyPage, { destination: 'Tokyo', checkin: '2026-06-15', checkout: '2026-06-17' })).rejects.toThrow(EmptyResultError);
+    });
+
+    it('throws CommandExecutionError when result-count evidence exists but no cards were parsed', async () => {
+        const search = getRegistry().get('booking/search');
+        const driftPage = {
+            goto: async () => {},
+            wait: async () => {},
+            evaluate: async () => ({ ok: true, items: [], blocked: false, totalText: 'Tokyo: 1,234 properties found' }),
+        };
+        await expect(search.func(driftPage, { destination: 'Tokyo', checkin: '2026-06-15', checkout: '2026-06-17' })).rejects.toThrow(CommandExecutionError);
+    });
+
+    it('throws CommandExecutionError when captcha is detected', async () => {
+        const search = getRegistry().get('booking/search');
+        const blockedPage = {
+            goto: async () => {},
+            wait: async () => {},
+            evaluate: async () => ({ ok: true, items: [], blocked: true, totalText: 'Verify you are human' }),
+        };
+        await expect(search.func(blockedPage, { destination: 'Tokyo', checkin: '2026-06-15', checkout: '2026-06-17' })).rejects.toThrow(CommandExecutionError);
+    });
+
+    it('throws CommandExecutionError when extractor payload is malformed instead of treating it as empty', async () => {
+        const search = getRegistry().get('booking/search');
+        const malformedPage = {
+            goto: async () => {},
+            wait: async () => {},
+            evaluate: async () => ({ ok: true, blocked: false, totalText: 'Tokyo hotels' }),
+        };
+        await expect(search.func(malformedPage, { destination: 'Tokyo', checkin: '2026-06-15', checkout: '2026-06-17' })).rejects.toThrow(CommandExecutionError);
+    });
+
+    it('throws CommandExecutionError when rendered cards lack stable hotel URL identity', async () => {
+        const search = getRegistry().get('booking/search');
+        const driftPage = {
+            goto: async () => {},
+            wait: async () => {},
+            evaluate: async () => ({
+                ok: true,
+                blocked: false,
+                totalText: 'Tokyo hotels',
+                items: [{
+                    name: 'Unlinked Hotel',
+                    country: '',
+                    slug: '',
+                    url: '',
+                    distance: '',
+                    review_score: null,
+                    review_count: null,
+                    star_rating: null,
+                    price_currency: '',
+                    price_amount: null,
+                    recommended_room: '',
+                }],
+            }),
+        };
+        await expect(search.func(driftPage, { destination: 'Tokyo', checkin: '2026-06-15', checkout: '2026-06-17' })).rejects.toThrow(CommandExecutionError);
+    });
+
+    it('unwraps {session, data} envelope from CDP bridge before validating', async () => {
+        const search = getRegistry().get('booking/search');
+        const envelopePage = {
+            goto: async () => {},
+            wait: async () => {},
+            evaluate: async () => ({
+                session: 1,
+                data: {
+                    ok: true,
+                    blocked: false,
+                    totalText: '',
+                    items: [{
+                        name: 'Test Hotel',
+                        country: 'jp',
+                        slug: 'test-hotel',
+                        url: 'https://www.booking.com/hotel/jp/test-hotel.html',
+                        distance: '1 km from centre',
+                        review_score: 8.6,
+                        review_count: 100,
+                        star_rating: 4,
+                        price_currency: 'USD',
+                        price_amount: 120,
+                        recommended_room: 'Standard double',
+                    }],
+                },
+            }),
+        };
+        const rows = await search.func(envelopePage, { destination: 'Tokyo', checkin: '2026-06-15', checkout: '2026-06-17' });
+        expect(rows).toHaveLength(1);
+        expect(rows[0].rank).toBe(1);
+        expect(rows[0].slug).toBe('test-hotel');
+        expect(rows[0].url).toBe('https://www.booking.com/hotel/jp/test-hotel.html');
+    });
+
+    it('uses requested selected_currency as the output source when price is present', async () => {
+        const search = getRegistry().get('booking/search');
+        const currencyPage = {
+            goto: async () => {},
+            wait: async () => {},
+            evaluate: async () => ({
+                ok: true,
+                blocked: false,
+                totalText: '',
+                items: [{
+                    name: 'Currency Hotel',
+                    country: 'cn',
+                    slug: 'currency-hotel',
+                    url: 'https://www.booking.com/hotel/cn/currency-hotel.html',
+                    distance: '',
+                    review_score: null,
+                    review_count: null,
+                    star_rating: null,
+                    price_currency: 'JPY',
+                    price_amount: 880,
+                    recommended_room: '',
+                }],
+            }),
+        };
+        const rows = await search.func(currencyPage, { destination: 'Shanghai', checkin: '2026-06-15', checkout: '2026-06-17', currency: 'CNY' });
+        expect(rows[0].price_currency).toBe('CNY');
+    });
+
+    it('respects offset for rank numbering when paginating', async () => {
+        const search = getRegistry().get('booking/search');
+        const pagedPage = {
+            goto: async () => {},
+            wait: async () => {},
+            evaluate: async () => ({
+                ok: true,
+                blocked: false,
+                totalText: '',
+                items: [
+                    { name: 'A', country: 'jp', slug: 'a', url: 'https://www.booking.com/hotel/jp/a.html', distance: '', review_score: null, review_count: null, star_rating: null, price_currency: '', price_amount: null, recommended_room: '' },
+                    { name: 'B', country: 'jp', slug: 'b', url: 'https://www.booking.com/hotel/jp/b.html', distance: '', review_score: null, review_count: null, star_rating: null, price_currency: '', price_amount: null, recommended_room: '' },
+                ],
+            }),
+        };
+        const rows = await search.func(pagedPage, { destination: 'Tokyo', checkin: '2026-06-15', checkout: '2026-06-17', offset: 50 });
+        expect(rows[0].rank).toBe(51);
+        expect(rows[1].rank).toBe(52);
+    });
+});