@jackwener/opencli 1.5.4 → 1.5.6

package/dist/{weread-private-api-regression.test.js → clis/weread/private-api-regression.test.js}

@@ -1,7 +1,8 @@
 import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { getRegistry } from './registry.js';
-import { fetchPrivateApi } from './clis/weread/utils.js';
-import './clis/weread/shelf.js';
+import { getRegistry } from '../../registry.js';
+import { log } from '../../logger.js';
+import { fetchPrivateApi } from './utils.js';
+import './shelf.js';
 describe('weread private API regression', () => {
     beforeEach(() => {
         vi.restoreAllMocks();
@@ -10,8 +11,10 @@ describe('weread private API regression', () => {
         const mockPage = {
             getCookies: vi.fn()
                 .mockResolvedValueOnce([
-                { name: 'wr_name', value: 'alice', domain: 'weread.qq.com' },
                 { name: 'wr_vid', value: 'vid123', domain: 'i.weread.qq.com' },
+            ])
+                .mockResolvedValueOnce([
+                { name: 'wr_name', value: 'alice', domain: 'weread.qq.com' },
             ]),
             evaluate: vi.fn(),
         };
@@ -23,8 +26,9 @@ describe('weread private API regression', () => {
         vi.stubGlobal('fetch', fetchMock);
         const result = await fetchPrivateApi(mockPage, '/book/info', { bookId: '123' });
         expect(result.title).toBe('Test Book');
-        expect(mockPage.getCookies).toHaveBeenCalledTimes(1);
+        expect(mockPage.getCookies).toHaveBeenCalledTimes(2);
         expect(mockPage.getCookies).toHaveBeenCalledWith({ url: 'https://i.weread.qq.com/book/info?bookId=123' });
+        expect(mockPage.getCookies).toHaveBeenCalledWith({ domain: 'weread.qq.com' });
         expect(mockPage.evaluate).not.toHaveBeenCalled();
         expect(fetchMock).toHaveBeenCalledWith('https://i.weread.qq.com/book/info?bookId=123', expect.objectContaining({
             headers: expect.objectContaining({
@@ -32,6 +36,58 @@ describe('weread private API regression', () => {
             }),
         }));
     });
+    it('merges host-only main-domain cookies into private API requests', async () => {
+        // Simulates host-only cookies on weread.qq.com that don't match i.weread.qq.com by URL
+        const mockPage = {
+            getCookies: vi.fn()
+                .mockResolvedValueOnce([]) // URL lookup returns nothing for i.weread.qq.com
+                .mockResolvedValueOnce([
+                { name: 'wr_skey', value: 'skey-host', domain: 'weread.qq.com' },
+                { name: 'wr_vid', value: 'vid-host', domain: 'weread.qq.com' },
+            ]),
+            evaluate: vi.fn(),
+        };
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            status: 200,
+            json: () => Promise.resolve({ title: 'Book', errcode: 0 }),
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        await fetchPrivateApi(mockPage, '/book/info', { bookId: '42' });
+        expect(mockPage.getCookies).toHaveBeenCalledTimes(2);
+        expect(mockPage.getCookies).toHaveBeenCalledWith({ url: 'https://i.weread.qq.com/book/info?bookId=42' });
+        expect(mockPage.getCookies).toHaveBeenCalledWith({ domain: 'weread.qq.com' });
+        expect(fetchMock).toHaveBeenCalledWith('https://i.weread.qq.com/book/info?bookId=42', expect.objectContaining({
+            headers: expect.objectContaining({
+                Cookie: 'wr_skey=skey-host; wr_vid=vid-host',
+            }),
+        }));
+    });
+    it('prefers API-subdomain cookies over main-domain cookies on name collision', async () => {
+        const mockPage = {
+            getCookies: vi.fn()
+                .mockResolvedValueOnce([
+                { name: 'wr_skey', value: 'from-api', domain: 'i.weread.qq.com' },
+            ])
+                .mockResolvedValueOnce([
+                { name: 'wr_skey', value: 'from-main', domain: 'weread.qq.com' },
+                { name: 'wr_vid', value: 'vid-main', domain: 'weread.qq.com' },
+            ]),
+            evaluate: vi.fn(),
+        };
+        const fetchMock = vi.fn().mockResolvedValue({
+            ok: true,
+            status: 200,
+            json: () => Promise.resolve({ title: 'Book', errcode: 0 }),
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        await fetchPrivateApi(mockPage, '/book/info', { bookId: '99' });
+        expect(fetchMock).toHaveBeenCalledWith('https://i.weread.qq.com/book/info?bookId=99', expect.objectContaining({
+            headers: expect.objectContaining({
+                Cookie: 'wr_skey=from-api; wr_vid=vid-main',
+            }),
+        }));
+    });
     it('maps unauthenticated private API responses to AUTH_REQUIRED', async () => {
         const mockPage = {
             getCookies: vi.fn().mockResolvedValue([]),
@@ -101,8 +157,10 @@ describe('weread private API regression', () => {
         const mockPage = {
             getCookies: vi.fn()
                 .mockResolvedValueOnce([
-                { name: 'wr_name', value: 'alice', domain: 'weread.qq.com' },
                 { name: 'wr_vid', value: 'vid123', domain: 'i.weread.qq.com' },
+            ])
+                .mockResolvedValueOnce([
+                { name: 'wr_name', value: 'alice', domain: 'weread.qq.com' },
             ]),
             evaluate: vi.fn(),
         };
@@ -122,9 +180,11 @@ describe('weread private API regression', () => {
         const result = await command.func(mockPage, { limit: 1 });
         expect(mockPage.evaluate).not.toHaveBeenCalled();
         expect(fetchMock).toHaveBeenCalledWith('https://i.weread.qq.com/shelf/sync?synckey=0&lectureSynckey=0', expect.any(Object));
+        expect(mockPage.getCookies).toHaveBeenCalledTimes(2);
         expect(mockPage.getCookies).toHaveBeenCalledWith({
             url: 'https://i.weread.qq.com/shelf/sync?synckey=0&lectureSynckey=0',
         });
+        expect(mockPage.getCookies).toHaveBeenCalledWith({ domain: 'weread.qq.com' });
         expect(result).toEqual([
             {
                 title: 'Deep Work',
@@ -137,14 +197,15 @@ describe('weread private API regression', () => {
     it('falls back to structured shelf cache when the private API reports AUTH_REQUIRED', async () => {
         const command = getRegistry().get('weread/shelf');
         expect(command?.func).toBeTypeOf('function');
+        const warnSpy = vi.spyOn(log, 'warn').mockImplementation(() => { });
         const mockPage = {
             getCookies: vi.fn()
-                .mockResolvedValueOnce([
-                { name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' },
-            ])
-                .mockResolvedValueOnce([
-                { name: 'wr_vid', value: 'vid-current', domain: '.weread.qq.com' },
-            ]),
+                // fetchPrivateApi: URL lookup (i.weread.qq.com)
+                .mockResolvedValueOnce([{ name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' }])
+                // fetchPrivateApi: domain lookup (weread.qq.com)
+                .mockResolvedValueOnce([{ name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' }])
+                // loadWebShelfSnapshot: domain lookup for wr_vid
+                .mockResolvedValueOnce([{ name: 'wr_vid', value: 'vid-current', domain: '.weread.qq.com' }]),
             goto: vi.fn().mockResolvedValue(undefined),
             evaluate: vi.fn().mockImplementation(async (source) => {
                 expect(source).toContain('shelf:rawBooks:vid-current');
@@ -183,6 +244,7 @@ describe('weread private API regression', () => {
         expect(mockPage.goto).toHaveBeenCalledWith('https://weread.qq.com/web/shelf');
         expect(mockPage.getCookies).toHaveBeenCalledWith({ domain: 'weread.qq.com' });
         expect(mockPage.evaluate).toHaveBeenCalledTimes(1);
+        expect(warnSpy).toHaveBeenCalledWith('WeRead private API auth expired; showing cached shelf data from localStorage. Results may be stale, and detail commands may still require re-login.');
         expect(result).toEqual([
             {
                 title: '文明、现代化、价值投资与中国',
@@ -197,12 +259,12 @@ describe('weread private API regression', () => {
         expect(command?.func).toBeTypeOf('function');
         const mockPage = {
             getCookies: vi.fn()
-                .mockResolvedValueOnce([
-                { name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' },
-            ])
-                .mockResolvedValueOnce([
-                { name: 'wr_vid', value: 'vid-current', domain: '.weread.qq.com' },
-            ]),
+                // fetchPrivateApi: URL lookup (i.weread.qq.com)
+                .mockResolvedValueOnce([{ name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' }])
+                // fetchPrivateApi: domain lookup (weread.qq.com)
+                .mockResolvedValueOnce([{ name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' }])
+                // loadWebShelfSnapshot: domain lookup for wr_vid
+                .mockResolvedValueOnce([{ name: 'wr_vid', value: 'vid-current', domain: '.weread.qq.com' }]),
             goto: vi.fn().mockResolvedValue(undefined),
             evaluate: vi.fn().mockResolvedValue({
                 cacheFound: false,
@@ -228,12 +290,12 @@ describe('weread private API regression', () => {
         expect(command?.func).toBeTypeOf('function');
         const mockPage = {
             getCookies: vi.fn()
-                .mockResolvedValueOnce([
-                { name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' },
-            ])
-                .mockResolvedValueOnce([
-                { name: 'wr_vid', value: 'vid-current', domain: '.weread.qq.com' },
-            ]),
+                // fetchPrivateApi: URL lookup (i.weread.qq.com)
+                .mockResolvedValueOnce([{ name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' }])
+                // fetchPrivateApi: domain lookup (weread.qq.com)
+                .mockResolvedValueOnce([{ name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' }])
+                // loadWebShelfSnapshot: domain lookup for wr_vid
+                .mockResolvedValueOnce([{ name: 'wr_vid', value: 'vid-current', domain: '.weread.qq.com' }]),
             goto: vi.fn().mockResolvedValue(undefined),
             evaluate: vi.fn().mockResolvedValue({
                 cacheFound: true,
@@ -257,12 +319,12 @@ describe('weread private API regression', () => {
         expect(command?.func).toBeTypeOf('function');
         const mockPage = {
             getCookies: vi.fn()
-                .mockResolvedValueOnce([
-                { name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' },
-            ])
-                .mockResolvedValueOnce([
-                { name: 'wr_vid', value: 'vid-current', domain: '.weread.qq.com' },
-            ]),
+                // fetchPrivateApi: URL lookup (i.weread.qq.com)
+                .mockResolvedValueOnce([{ name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' }])
+                // fetchPrivateApi: domain lookup (weread.qq.com)
+                .mockResolvedValueOnce([{ name: 'wr_skey', value: 'skey123', domain: '.weread.qq.com' }])
+                // loadWebShelfSnapshot: domain lookup for wr_vid
+                .mockResolvedValueOnce([{ name: 'wr_vid', value: 'vid-current', domain: '.weread.qq.com' }]),
             goto: vi.fn().mockResolvedValue(undefined),
             evaluate: vi.fn().mockResolvedValue({
                 cacheFound: true,

package/dist/clis/weread/search-regression.test.d.ts

@@ -0,0 +1 @@
+import './search.js';

package/dist/clis/weread/search-regression.test.js

@@ -0,0 +1,407 @@
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { getRegistry } from '../../registry.js';
+import './search.js';
+describe('weread/search regression', () => {
+    beforeEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('uses the query argument for the search API and returns reader urls from search html', async () => {
+        const command = getRegistry().get('weread/search');
+        expect(command?.func).toBeTypeOf('function');
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                books: [
+                    {
+                        bookInfo: {
+                            title: 'Deep Work',
+                            author: 'Cal Newport',
+                            bookId: 'abc123',
+                        },
+                    },
+                ],
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            text: () => Promise.resolve(`
+          <ul class="search_bookDetail_list">
+            <li class="wr_bookList_item">
+              <a class="wr_bookList_item_link" href="/web/reader/reader123"></a>
+              <p class="wr_bookList_item_title">Deep Work</p>
+            </li>
+          </ul>
+        `),
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const result = await command.func(null, { query: 'deep work', limit: 5 });
+        expect(fetchMock).toHaveBeenCalledTimes(2);
+        expect(String(fetchMock.mock.calls[0][0])).toContain('keyword=deep+work');
+        expect(String(fetchMock.mock.calls[1][0])).toContain('/web/search/books?keyword=deep+work');
+        expect(result).toEqual([
+            {
+                rank: 1,
+                title: 'Deep Work',
+                author: 'Cal Newport',
+                bookId: 'abc123',
+                url: 'https://weread.qq.com/web/reader/reader123',
+            },
+        ]);
+    });
+    it('does not emit stale bookDetail urls when the reader url is unavailable', async () => {
+        const command = getRegistry().get('weread/search');
+        expect(command?.func).toBeTypeOf('function');
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                books: [
+                    {
+                        bookInfo: {
+                            title: 'Deep Work',
+                            author: 'Cal Newport',
+                            bookId: 'abc123',
+                        },
+                    },
+                ],
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            text: () => Promise.resolve('<html><body><p>no search cards</p></body></html>'),
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const result = await command.func(null, { query: 'deep work', limit: 5 });
+        expect(result).toEqual([
+            {
+                rank: 1,
+                title: 'Deep Work',
+                author: 'Cal Newport',
+                bookId: 'abc123',
+                url: '',
+            },
+        ]);
+    });
+    it('matches reader urls by title queue instead of assuming identical result order', async () => {
+        const command = getRegistry().get('weread/search');
+        expect(command?.func).toBeTypeOf('function');
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                books: [
+                    {
+                        bookInfo: {
+                            title: 'Deep Work',
+                            author: 'Cal Newport',
+                            bookId: 'abc123',
+                        },
+                    },
+                    {
+                        bookInfo: {
+                            title: 'Digital Minimalism',
+                            author: 'Cal Newport',
+                            bookId: 'xyz789',
+                        },
+                    },
+                ],
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            text: () => Promise.resolve(`
+          <ul class="search_bookDetail_list">
+            <li class="wr_bookList_item">
+              <a class="wr_bookList_item_link" href="/web/reader/unrelated111"></a>
+              <p class="wr_bookList_item_title">Atomic Habits</p>
+            </li>
+            <li class="wr_bookList_item">
+              <a class="wr_bookList_item_link" href="/web/reader/digital222"></a>
+              <p class="wr_bookList_item_title">Digital Minimalism</p>
+            </li>
+            <li class="wr_bookList_item">
+              <a class="wr_bookList_item_link" href="/web/reader/deep333"></a>
+              <p class="wr_bookList_item_title">Deep Work</p>
+            </li>
+          </ul>
+        `),
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const result = await command.func(null, { query: 'cal newport', limit: 5 });
+        expect(result).toEqual([
+            {
+                rank: 1,
+                title: 'Deep Work',
+                author: 'Cal Newport',
+                bookId: 'abc123',
+                url: 'https://weread.qq.com/web/reader/deep333',
+            },
+            {
+                rank: 2,
+                title: 'Digital Minimalism',
+                author: 'Cal Newport',
+                bookId: 'xyz789',
+                url: 'https://weread.qq.com/web/reader/digital222',
+            },
+        ]);
+    });
+    it('falls back to empty urls when the search html request fails', async () => {
+        const command = getRegistry().get('weread/search');
+        expect(command?.func).toBeTypeOf('function');
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                books: [
+                    {
+                        bookInfo: {
+                            title: 'Deep Work',
+                            author: 'Cal Newport',
+                            bookId: 'abc123',
+                        },
+                    },
+                ],
+            }),
+        })
+            .mockRejectedValueOnce(new Error('network timeout'));
+        vi.stubGlobal('fetch', fetchMock);
+        const result = await command.func(null, { query: 'deep work', limit: 5 });
+        expect(result).toEqual([
+            {
+                rank: 1,
+                title: 'Deep Work',
+                author: 'Cal Newport',
+                bookId: 'abc123',
+                url: '',
+            },
+        ]);
+    });
+    it('binds reader urls with title and author instead of title alone', async () => {
+        const command = getRegistry().get('weread/search');
+        expect(command?.func).toBeTypeOf('function');
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                books: [
+                    {
+                        bookInfo: {
+                            title: '文明',
+                            author: '作者甲',
+                            bookId: 'book-a',
+                        },
+                    },
+                    {
+                        bookInfo: {
+                            title: '文明',
+                            author: '作者乙',
+                            bookId: 'book-b',
+                        },
+                    },
+                ],
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            text: () => Promise.resolve(`
+          <ul class="search_bookDetail_list">
+            <li class="wr_bookList_item">
+              <a class="wr_bookList_item_link" href="/web/reader/book-b-reader"></a>
+              <p class="wr_bookList_item_title">文明</p>
+              <p class="wr_bookList_item_author"><a href="/web/search/books?author=%E4%BD%9C%E8%80%85%E4%B9%99">作者乙</a></p>
+            </li>
+            <li class="wr_bookList_item">
+              <a class="wr_bookList_item_link" href="/web/reader/book-a-reader"></a>
+              <p class="wr_bookList_item_title">文明</p>
+              <p class="wr_bookList_item_author"><a href="/web/search/books?author=%E4%BD%9C%E8%80%85%E7%94%B2">作者甲</a></p>
+            </li>
+          </ul>
+        `),
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const result = await command.func(null, { query: '文明', limit: 5 });
+        expect(result).toEqual([
+            {
+                rank: 1,
+                title: '文明',
+                author: '作者甲',
+                bookId: 'book-a',
+                url: 'https://weread.qq.com/web/reader/book-a-reader',
+            },
+            {
+                rank: 2,
+                title: '文明',
+                author: '作者乙',
+                bookId: 'book-b',
+                url: 'https://weread.qq.com/web/reader/book-b-reader',
+            },
+        ]);
+    });
+    it('leaves urls empty when same-title results are ambiguous and html cards have no author', async () => {
+        const command = getRegistry().get('weread/search');
+        expect(command?.func).toBeTypeOf('function');
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                books: [
+                    {
+                        bookInfo: {
+                            title: '文明',
+                            author: '作者甲',
+                            bookId: 'book-a',
+                        },
+                    },
+                    {
+                        bookInfo: {
+                            title: '文明',
+                            author: '作者乙',
+                            bookId: 'book-b',
+                        },
+                    },
+                ],
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            text: () => Promise.resolve(`
+          <ul class="search_bookDetail_list">
+            <li class="wr_bookList_item">
+              <a class="wr_bookList_item_link" href="/web/reader/book-b-reader"></a>
+              <p class="wr_bookList_item_title">文明</p>
+            </li>
+            <li class="wr_bookList_item">
+              <a class="wr_bookList_item_link" href="/web/reader/book-a-reader"></a>
+              <p class="wr_bookList_item_title">文明</p>
+            </li>
+          </ul>
+        `),
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const result = await command.func(null, { query: '文明', limit: 5 });
+        expect(result).toEqual([
+            {
+                rank: 1,
+                title: '文明',
+                author: '作者甲',
+                bookId: 'book-a',
+                url: '',
+            },
+            {
+                rank: 2,
+                title: '文明',
+                author: '作者乙',
+                bookId: 'book-b',
+                url: '',
+            },
+        ]);
+    });
+    it('leaves urls empty when exact author matching fails and multiple html cards share the same title', async () => {
+        const command = getRegistry().get('weread/search');
+        expect(command?.func).toBeTypeOf('function');
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                books: [
+                    {
+                        bookInfo: {
+                            title: '文明',
+                            author: '作者甲',
+                            bookId: 'book-a',
+                        },
+                    },
+                ],
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            text: () => Promise.resolve(`
+          <ul class="search_bookDetail_list">
+            <li class="wr_bookList_item">
+              <a class="wr_bookList_item_link" href="/web/reader/book-a-reader"></a>
+              <p class="wr_bookList_item_title">文明</p>
+              <p class="wr_bookList_item_author"><a href="/web/search/books?author=%E4%BD%9C%E8%80%85%E4%B9%99">作者乙</a></p>
+            </li>
+            <li class="wr_bookList_item">
+              <a class="wr_bookList_item_link" href="/web/reader/book-a-reader-2"></a>
+              <p class="wr_bookList_item_title">文明</p>
+            </li>
+          </ul>
+        `),
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const result = await command.func(null, { query: '文明', limit: 5 });
+        expect(result).toEqual([
+            {
+                rank: 1,
+                title: '文明',
+                author: '作者甲',
+                bookId: 'book-a',
+                url: '',
+            },
+        ]);
+    });
+    it('leaves urls empty when multiple results share the same title and author identity', async () => {
+        const command = getRegistry().get('weread/search');
+        expect(command?.func).toBeTypeOf('function');
+        const fetchMock = vi.fn()
+            .mockResolvedValueOnce({
+            ok: true,
+            json: () => Promise.resolve({
+                books: [
+                    {
+                        bookInfo: {
+                            title: '文明',
+                            author: '作者甲',
+                            bookId: 'book-a',
+                        },
+                    },
+                    {
+                        bookInfo: {
+                            title: '文明',
+                            author: '作者甲',
+                            bookId: 'book-b',
+                        },
+                    },
+                ],
+            }),
+        })
+            .mockResolvedValueOnce({
+            ok: true,
+            text: () => Promise.resolve(`
+          <ul class="search_bookDetail_list">
+            <li class="wr_bookList_item">
+              <a class="wr_bookList_item_link" href="/web/reader/book-b-reader"></a>
+              <p class="wr_bookList_item_title">文明</p>
+              <p class="wr_bookList_item_author"><a href="/web/search/books?author=%E4%BD%9C%E8%80%85%E7%94%B2">作者甲</a></p>
+            </li>
+            <li class="wr_bookList_item">
+              <a class="wr_bookList_item_link" href="/web/reader/book-a-reader"></a>
+              <p class="wr_bookList_item_title">文明</p>
+              <p class="wr_bookList_item_author"><a href="/web/search/books?author=%E4%BD%9C%E8%80%85%E7%94%B2">作者甲</a></p>
+            </li>
+          </ul>
+        `),
+        });
+        vi.stubGlobal('fetch', fetchMock);
+        const result = await command.func(null, { query: '文明', limit: 5 });
+        expect(result).toEqual([
+            {
+                rank: 1,
+                title: '文明',
+                author: '作者甲',
+                bookId: 'book-a',
+                url: '',
+            },
+            {
+                rank: 2,
+                title: '文明',
+                author: '作者甲',
+                bookId: 'book-b',
+                url: '',
+            },
+        ]);
+    });
+});