@sovovs/bycli 1.8.0 → 2.1.0

package/clis/osv/osv.test.js

@@ -1,97 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import { ArgumentError, CommandExecutionError, EmptyResultError } from '@sovovs/bycli/errors';
-import './vulnerability.js';
-import './query.js';
-
-afterEach(() => {
-    vi.unstubAllGlobals();
-    vi.restoreAllMocks();
-});
-
-describe('osv vulnerability adapter', () => {
-    const cmd = getRegistry().get('osv/vulnerability');
-
-    it('rejects empty / malformed id before fetching', async () => {
-        const fetchMock = vi.fn();
-        vi.stubGlobal('fetch', fetchMock);
-
-        await expect(cmd.func({ id: '' })).rejects.toThrow(ArgumentError);
-        await expect(cmd.func({ id: 'has spaces' })).rejects.toThrow(ArgumentError);
-        expect(fetchMock).not.toHaveBeenCalled();
-    });
-
-    it('maps HTTP 404 to EmptyResultError', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('not found', { status: 404 })));
-        await expect(cmd.func({ id: 'GHSA-aaaa-bbbb-cccc' })).rejects.toThrow(EmptyResultError);
-    });
-
-    it('returns flattened affected packages with severity from database_specific', async () => {
-        const vuln = {
-            id: 'GHSA-29mw-wpgm-hmr9',
-            summary: 'ReDoS in lodash',
-            aliases: ['CVE-2020-28500'],
-            published: '2022-01-06T20:30:46Z',
-            modified: '2025-09-29T21:12:31.102523Z',
-            database_specific: { severity: 'MODERATE', cwe_ids: ['CWE-1333', 'CWE-400'] },
-            severity: [{ type: 'CVSS_V3', score: 'CVSS:3.1/...' }],
-            affected: [
-                { package: { name: 'lodash', ecosystem: 'npm' } },
-                { package: { name: 'lodash-rails', ecosystem: 'RubyGems' } },
-            ],
-            references: [{ url: 'https://example' }],
-        };
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify(vuln), { status: 200 })));
-
-        const rows = await cmd.func({ id: 'GHSA-29mw-wpgm-hmr9' });
-        expect(rows).toEqual([expect.objectContaining({
-            id: 'GHSA-29mw-wpgm-hmr9',
-            severity: 'MODERATE',
-            aliases: 'CVE-2020-28500',
-            affectedPackages: 'npm:lodash, RubyGems:lodash-rails',
-            cwes: 'CWE-1333, CWE-400',
-            referenceCount: 1,
-            modified: '2025-09-29T21:12:31Z',
-        })]);
-    });
-});
-
-describe('osv query adapter', () => {
-    const cmd = getRegistry().get('osv/query');
-
-    it('rejects bad ecosystem and bad limit before fetching', async () => {
-        const fetchMock = vi.fn();
-        vi.stubGlobal('fetch', fetchMock);
-
-        await expect(cmd.func({ package: 'lodash', ecosystem: 'foo', limit: 5 })).rejects.toThrow(ArgumentError);
-        await expect(cmd.func({ package: 'django', ecosystem: 'pypi', limit: 5 })).rejects.toThrow(ArgumentError);
-        await expect(cmd.func({ package: 'lodash', ecosystem: 'npm', limit: 0 })).rejects.toThrow(ArgumentError);
-        await expect(cmd.func({ package: '', ecosystem: 'npm', limit: 5 })).rejects.toThrow(ArgumentError);
-        expect(fetchMock).not.toHaveBeenCalled();
-    });
-
-    it('maps HTTP 429 to CommandExecutionError', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response('rate limited', { status: 429 })));
-        await expect(cmd.func({ package: 'lodash', ecosystem: 'npm', limit: 5 })).rejects.toThrow(CommandExecutionError);
-    });
-
-    it('throws EmptyResultError when no vulns reported', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify({}), { status: 200 })));
-        await expect(cmd.func({ package: 'lodash', ecosystem: 'npm', limit: 5 })).rejects.toThrow(EmptyResultError);
-    });
-
-    it('sorts by published date descending and rows have id round-tripable into osv vulnerability', async () => {
-        const body = {
-            vulns: [
-                { id: 'GHSA-old', summary: 'old', published: '2020-01-01T00:00:00Z', affected: [{ package: { name: 'django', ecosystem: 'PyPI' } }] },
-                { id: 'GHSA-new', summary: 'new', published: '2026-01-01T00:00:00Z', affected: [{ package: { name: 'django', ecosystem: 'PyPI' } }] },
-            ],
-        };
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValue(new Response(JSON.stringify(body), { status: 200 })));
-
-        const rows = await cmd.func({ package: 'django', ecosystem: 'PyPI', limit: 5 });
-        expect(rows[0]).toMatchObject({ rank: 1, id: 'GHSA-new', published: '2026-01-01T00:00:00Z' });
-        expect(rows[1]).toMatchObject({ rank: 2, id: 'GHSA-old' });
-        expect(rows[0].url).toBe('https://osv.dev/vulnerability/GHSA-new');
-    });
-});

package/clis/paperreview/commands.test.js

@@ -1,243 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const { mockReadPdfFile, mockRequestJson, mockUploadPresignedPdf, mockValidateHelpfulness, mockParseYesNo, } = vi.hoisted(() => ({
-    mockReadPdfFile: vi.fn(),
-    mockRequestJson: vi.fn(),
-    mockUploadPresignedPdf: vi.fn(),
-    mockValidateHelpfulness: vi.fn(),
-    mockParseYesNo: vi.fn(),
-}));
-vi.mock('./utils.js', async () => {
-    const actual = await vi.importActual('./utils.js');
-    return {
-        ...actual,
-        readPdfFile: mockReadPdfFile,
-        requestJson: mockRequestJson,
-        uploadPresignedPdf: mockUploadPresignedPdf,
-        validateHelpfulness: mockValidateHelpfulness,
-        parseYesNo: mockParseYesNo,
-    };
-});
-import { getRegistry } from '@sovovs/bycli/registry';
-import './submit.js';
-import './review.js';
-import './feedback.js';
-describe('paperreview submit command', () => {
-    beforeEach(() => {
-        mockReadPdfFile.mockReset();
-        mockRequestJson.mockReset();
-        mockUploadPresignedPdf.mockReset();
-        mockValidateHelpfulness.mockReset();
-        mockParseYesNo.mockReset();
-    });
-    it('supports dry run without any remote request', async () => {
-        const cmd = getRegistry().get('paperreview/submit');
-        expect(cmd?.func).toBeTypeOf('function');
-        mockReadPdfFile.mockResolvedValue({
-            buffer: Buffer.from('%PDF'),
-            fileName: 'paper.pdf',
-            resolvedPath: '/tmp/paper.pdf',
-            sizeBytes: 4096,
-        });
-        const result = await cmd.func({
-            pdf: './paper.pdf',
-            email: 'wang2629651228@gmail.com',
-            venue: 'RAL',
-            'dry-run': true,
-            'prepare-only': false,
-        });
-        expect(mockRequestJson).not.toHaveBeenCalled();
-        expect(result).toMatchObject({
-            status: 'dry-run',
-            file: 'paper.pdf',
-            email: 'wang2629651228@gmail.com',
-            venue: 'RAL',
-        });
-    });
-    it('treats explicit false flags as false and performs the real submission path', async () => {
-        const cmd = getRegistry().get('paperreview/submit');
-        expect(cmd?.func).toBeTypeOf('function');
-        mockReadPdfFile.mockResolvedValue({
-            buffer: Buffer.from('%PDF'),
-            fileName: 'paper.pdf',
-            resolvedPath: '/tmp/paper.pdf',
-            sizeBytes: 4096,
-        });
-        mockRequestJson
-            .mockResolvedValueOnce({
-            response: { ok: true, status: 200 },
-            payload: {
-                success: true,
-                presigned_url: 'https://upload.example.com',
-                presigned_fields: { key: 'uploads/paper.pdf' },
-                s3_key: 'uploads/paper.pdf',
-            },
-        })
-            .mockResolvedValueOnce({
-            response: { ok: true, status: 200 },
-            payload: {
-                success: true,
-                token: 'tok_false',
-                message: 'Submission accepted',
-            },
-        });
-        const result = await cmd.func({
-            pdf: './paper.pdf',
-            email: 'wang2629651228@gmail.com',
-            venue: 'RAL',
-            'dry-run': false,
-            'prepare-only': false,
-        });
-        expect(mockUploadPresignedPdf).toHaveBeenCalledTimes(1);
-        expect(result).toMatchObject({
-            status: 'submitted',
-            token: 'tok_false',
-            review_url: 'https://paperreview.ai/review?token=tok_false',
-        });
-    });
-    it('supports prepare-only without uploading the PDF', async () => {
-        const cmd = getRegistry().get('paperreview/submit');
-        expect(cmd?.func).toBeTypeOf('function');
-        mockReadPdfFile.mockResolvedValue({
-            buffer: Buffer.from('%PDF'),
-            fileName: 'paper.pdf',
-            resolvedPath: '/tmp/paper.pdf',
-            sizeBytes: 4096,
-        });
-        mockRequestJson.mockResolvedValueOnce({
-            response: { ok: true, status: 200 },
-            payload: {
-                success: true,
-                presigned_url: 'https://upload.example.com',
-                presigned_fields: { key: 'uploads/paper.pdf' },
-                s3_key: 'uploads/paper.pdf',
-            },
-        });
-        const result = await cmd.func({
-            pdf: './paper.pdf',
-            email: 'wang2629651228@gmail.com',
-            venue: 'RAL',
-            'dry-run': false,
-            'prepare-only': true,
-        });
-        expect(mockUploadPresignedPdf).not.toHaveBeenCalled();
-        expect(mockRequestJson).toHaveBeenCalledTimes(1);
-        expect(result).toMatchObject({
-            status: 'prepared',
-            s3_key: 'uploads/paper.pdf',
-        });
-    });
-    it('requests an upload URL, uploads the PDF, and confirms the submission', async () => {
-        const cmd = getRegistry().get('paperreview/submit');
-        expect(cmd?.func).toBeTypeOf('function');
-        mockReadPdfFile.mockResolvedValue({
-            buffer: Buffer.from('%PDF'),
-            fileName: 'paper.pdf',
-            resolvedPath: '/tmp/paper.pdf',
-            sizeBytes: 4096,
-        });
-        mockRequestJson
-            .mockResolvedValueOnce({
-            response: { ok: true, status: 200 },
-            payload: {
-                success: true,
-                presigned_url: 'https://upload.example.com',
-                presigned_fields: { key: 'uploads/paper.pdf' },
-                s3_key: 'uploads/paper.pdf',
-            },
-        })
-            .mockResolvedValueOnce({
-            response: { ok: true, status: 200 },
-            payload: {
-                success: true,
-                token: 'tok_123',
-                message: 'Submission accepted',
-            },
-        });
-        const result = await cmd.func({
-            pdf: './paper.pdf',
-            email: 'wang2629651228@gmail.com',
-            venue: 'RAL',
-            'dry-run': false,
-            'prepare-only': false,
-        });
-        expect(mockRequestJson).toHaveBeenNthCalledWith(1, '/api/get-upload-url', expect.objectContaining({
-            method: 'POST',
-            body: JSON.stringify({
-                filename: 'paper.pdf',
-                venue: 'RAL',
-            }),
-        }));
-        expect(mockUploadPresignedPdf).toHaveBeenCalledWith('https://upload.example.com', expect.objectContaining({ fileName: 'paper.pdf' }), expect.objectContaining({ s3_key: 'uploads/paper.pdf' }));
-        expect(mockRequestJson).toHaveBeenNthCalledWith(2, '/api/confirm-upload', expect.objectContaining({
-            method: 'POST',
-            body: expect.any(FormData),
-        }));
-        expect(result).toMatchObject({
-            status: 'submitted',
-            token: 'tok_123',
-            review_url: 'https://paperreview.ai/review?token=tok_123',
-        });
-    });
-});
-describe('paperreview review command', () => {
-    beforeEach(() => {
-        mockRequestJson.mockReset();
-    });
-    it('returns processing status when the review is not ready yet', async () => {
-        const cmd = getRegistry().get('paperreview/review');
-        expect(cmd?.func).toBeTypeOf('function');
-        mockRequestJson.mockResolvedValue({
-            response: { status: 202 },
-            payload: { detail: 'Review is still processing.' },
-        });
-        const result = await cmd.func({ token: 'tok_123' });
-        expect(result).toMatchObject({
-            status: 'processing',
-            token: 'tok_123',
-            review_url: 'https://paperreview.ai/review?token=tok_123',
-            message: 'Review is still processing.',
-        });
-    });
-});
-describe('paperreview feedback command', () => {
-    beforeEach(() => {
-        mockRequestJson.mockReset();
-        mockValidateHelpfulness.mockReset();
-        mockParseYesNo.mockReset();
-    });
-    it('normalizes feedback inputs and posts them to the API', async () => {
-        const cmd = getRegistry().get('paperreview/feedback');
-        expect(cmd?.func).toBeTypeOf('function');
-        mockValidateHelpfulness.mockReturnValue(4);
-        mockParseYesNo.mockReturnValueOnce(true).mockReturnValueOnce(false);
-        mockRequestJson.mockResolvedValue({
-            response: { ok: true, status: 200 },
-            payload: { message: 'Thanks for the feedback.' },
-        });
-        const result = await cmd.func({
-            token: 'tok_123',
-            helpfulness: 4,
-            'critical-error': 'yes',
-            'actionable-suggestions': 'no',
-            'additional-comments': 'Helpful summary, but the contribution section needs more detail.',
-        });
-        expect(mockRequestJson).toHaveBeenCalledWith('/api/feedback/tok_123', {
-            method: 'POST',
-            headers: { 'Content-Type': 'application/json' },
-            body: JSON.stringify({
-                helpfulness: 4,
-                has_critical_error: true,
-                has_actionable_suggestions: false,
-                additional_comments: 'Helpful summary, but the contribution section needs more detail.',
-            }),
-        });
-        expect(result).toMatchObject({
-            status: 'submitted',
-            token: 'tok_123',
-            helpfulness: 4,
-            critical_error: true,
-            actionable_suggestions: false,
-            message: 'Thanks for the feedback.',
-        });
-    });
-});

package/clis/paperreview/utils.test.js

@@ -1,49 +0,0 @@
-import * as fs from 'node:fs/promises';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-import { CliError } from '@sovovs/bycli/errors';
-import { MAX_PDF_BYTES, buildReviewUrl, parseYesNo, readPdfFile, requestJson, validateHelpfulness, } from './utils.js';
-describe('paperreview utils', () => {
-    beforeEach(() => {
-        vi.restoreAllMocks();
-    });
-    it('builds review URLs from the token', () => {
-        expect(buildReviewUrl('tok 123')).toBe('https://paperreview.ai/review?token=tok%20123');
-    });
-    it('parses yes/no flags', () => {
-        expect(parseYesNo('yes', 'critical-error')).toBe(true);
-        expect(parseYesNo('NO', 'critical-error')).toBe(false);
-    });
-    it('rejects invalid yes/no flags with CliError', () => {
-        expect(() => parseYesNo('maybe', 'critical-error')).toThrow(CliError);
-        expect(() => parseYesNo('maybe', 'critical-error')).toThrow('"critical-error" must be either "yes" or "no".');
-    });
-    it('validates helpfulness scores', () => {
-        expect(validateHelpfulness(5)).toBe(5);
-        expect(() => validateHelpfulness(0)).toThrow(CliError);
-    });
-    it('reads a valid PDF file and returns metadata', async () => {
-        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'paperreview-'));
-        const pdfPath = path.join(tempDir, 'sample.pdf');
-        const pdfBytes = Buffer.concat([Buffer.from('%PDF-1.4\n'), Buffer.alloc(256, 1)]);
-        await fs.writeFile(pdfPath, pdfBytes);
-        const result = await readPdfFile(pdfPath);
-        expect(result.fileName).toBe('sample.pdf');
-        expect(result.resolvedPath).toBe(pdfPath);
-        expect(result.sizeBytes).toBe(pdfBytes.length);
-        expect(result.buffer.equals(pdfBytes)).toBe(true);
-    });
-    it('rejects PDFs larger than the paperreview.ai size limit', async () => {
-        const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'paperreview-'));
-        const pdfPath = path.join(tempDir, 'large.pdf');
-        await fs.writeFile(pdfPath, Buffer.alloc(MAX_PDF_BYTES + 1, 1));
-        await expect(readPdfFile(pdfPath)).rejects.toThrow(CliError);
-        await expect(readPdfFile(pdfPath)).rejects.toThrow('The PDF is larger than paperreview.ai\'s 10MB limit.');
-    });
-    it('normalizes fetch failures into CliError', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('socket hang up')));
-        await expect(requestJson('/api/review/token')).rejects.toThrow(CliError);
-        await expect(requestJson('/api/review/token')).rejects.toThrow('Unable to reach paperreview.ai');
-    });
-});

package/clis/pixiv/download.test.js

@@ -1,87 +0,0 @@
-import { beforeAll, beforeEach, describe, expect, it, vi } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import { AuthRequiredError, CommandExecutionError } from '@sovovs/bycli/errors';
-import { createPageMock } from '../test-utils.js';
-// Mock download dependencies before importing the adapter
-const { mockHttpDownload, mockMkdirSync } = vi.hoisted(() => ({
-    mockHttpDownload: vi.fn(),
-    mockMkdirSync: vi.fn(),
-}));
-vi.mock('@sovovs/bycli/download', () => ({
-    formatCookieHeader: vi.fn().mockReturnValue('cookie=value'),
-    httpDownload: mockHttpDownload,
-}));
-vi.mock('node:fs', () => ({
-    mkdirSync: mockMkdirSync,
-}));
-// Now import the adapter (after mocks are set up)
-await import('./download.js');
-let cmd;
-beforeAll(() => {
-    cmd = getRegistry().get('pixiv/download');
-    expect(cmd?.func).toBeTypeOf('function');
-});
-describe('pixiv download', () => {
-    beforeEach(() => {
-        mockHttpDownload.mockReset();
-        mockMkdirSync.mockReset();
-    });
-    it('throws CommandExecutionError on invalid illust ID', async () => {
-        const page = createPageMock([]);
-        await expect(cmd.func(page, { 'illust-id': 'abc', output: '/tmp/test' })).rejects.toThrow(CommandExecutionError);
-    });
-    it('throws AuthRequiredError on 403', async () => {
-        const page = createPageMock([{ __httpError: 403 }]);
-        await expect(cmd.func(page, { 'illust-id': '12345', output: '/tmp/test' })).rejects.toThrow(AuthRequiredError);
-    });
-    it('throws CommandExecutionError on 404', async () => {
-        const page = createPageMock([{ __httpError: 404 }]);
-        await expect(cmd.func(page, { 'illust-id': '12345', output: '/tmp/test' })).rejects.toThrow(CommandExecutionError);
-    });
-    it('throws CommandExecutionError on non-auth HTTP failure', async () => {
-        const page = createPageMock([{ __httpError: 500 }]);
-        await expect(cmd.func(page, { 'illust-id': '12345', output: '/tmp/test' })).rejects.toThrow(CommandExecutionError);
-    });
-    it('returns failure when no images found', async () => {
-        const page = createPageMock([{ body: [] }]);
-        const result = (await cmd.func(page, { 'illust-id': '12345', output: '/tmp/test' }));
-        expect(result).toEqual([{ index: 0, type: '-', status: 'failed', size: 'No images found' }]);
-    });
-    it('downloads images with Referer header', async () => {
-        mockHttpDownload.mockResolvedValue({ success: true, size: 1024000 });
-        const page = createPageMock([
-            {
-                body: [
-                    { urls: { original: 'https://i.pximg.net/img-original/img/2025/01/01/00/00/00/12345_p0.png' } },
-                    { urls: { original: 'https://i.pximg.net/img-original/img/2025/01/01/00/00/00/12345_p1.jpg' } },
-                ],
-            },
-        ]);
-        const result = (await cmd.func(page, { 'illust-id': '12345', output: '/tmp/test' }));
-        expect(result).toHaveLength(2);
-        expect(result[0]).toMatchObject({ index: 1, type: 'image', status: 'success' });
-        expect(result[1]).toMatchObject({ index: 2, type: 'image', status: 'success' });
-        // Verify Referer header was passed
-        expect(mockHttpDownload).toHaveBeenCalledTimes(2);
-        const firstCallOpts = mockHttpDownload.mock.calls[0][2];
-        expect(firstCallOpts.headers).toEqual({ Referer: 'https://www.pixiv.net/' });
-    });
-    it('handles individual download failures gracefully', async () => {
-        mockHttpDownload
-            .mockResolvedValueOnce({ success: true, size: 512000 })
-            .mockRejectedValueOnce(new Error('Connection timeout'));
-        const page = createPageMock([
-            {
-                body: [
-                    { urls: { original: 'https://i.pximg.net/img/12345_p0.png' } },
-                    { urls: { original: 'https://i.pximg.net/img/12345_p1.png' } },
-                ],
-            },
-        ]);
-        const result = (await cmd.func(page, { 'illust-id': '12345', output: '/tmp/test' }));
-        expect(result).toHaveLength(2);
-        expect(result[0].status).toBe('success');
-        expect(result[1].status).toBe('failed');
-        expect(result[1].size).toBe('Connection timeout');
-    });
-});

package/clis/pixiv/illusts.test.js

@@ -1,99 +0,0 @@
-import { beforeAll, describe, expect, it } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import { AuthRequiredError, CommandExecutionError } from '@sovovs/bycli/errors';
-import { createPageMock } from '../test-utils.js';
-import './illusts.js';
-let cmd;
-beforeAll(() => {
-    cmd = getRegistry().get('pixiv/illusts');
-    expect(cmd?.func).toBeTypeOf('function');
-});
-describe('pixiv illusts', () => {
-    it('throws CommandExecutionError on invalid user ID', async () => {
-        const page = createPageMock([]);
-        await expect(cmd.func(page, { 'user-id': 'abc', limit: 5 })).rejects.toThrow(CommandExecutionError);
-    });
-    it('throws AuthRequiredError on 401', async () => {
-        const page = createPageMock([{ __httpError: 401 }]);
-        await expect(cmd.func(page, { 'user-id': '11', limit: 5 })).rejects.toThrow(AuthRequiredError);
-    });
-    it('throws generic error on non-auth HTTP failure', async () => {
-        const page = createPageMock([{ __httpError: 500 }]);
-        await expect(cmd.func(page, { 'user-id': '11', limit: 5 })).rejects.toThrow(CommandExecutionError);
-    });
-    it('returns empty array when user has no illusts', async () => {
-        const page = createPageMock([
-            { body: { illusts: {} } },
-        ]);
-        const result = await cmd.func(page, { 'user-id': '11', limit: 5 });
-        expect(result).toEqual([]);
-    });
-    it('fetches illust IDs then batch-fetches details', async () => {
-        const page = createPageMock([
-            // Step 1: profile/all returns illust IDs
-            {
-                body: {
-                    illusts: { '99999': null, '88888': null, '77777': null },
-                },
-            },
-            // Step 2: batch detail response
-            {
-                body: {
-                    works: {
-                        '99999': {
-                            id: '99999',
-                            title: 'Latest Work',
-                            pageCount: 2,
-                            bookmarkCount: 300,
-                            tags: ['original', 'fantasy'],
-                            createDate: '2025-01-15T12:00:00+09:00',
-                        },
-                        '88888': {
-                            id: '88888',
-                            title: 'Older Work',
-                            pageCount: 1,
-                            bookmarkCount: 150,
-                            tags: ['landscape'],
-                            createDate: '2024-12-01T10:00:00+09:00',
-                        },
-                    },
-                },
-            },
-        ]);
-        const result = (await cmd.func(page, { 'user-id': '11', limit: 3 }));
-        // Should be sorted newest first (99999 > 88888 > 77777)
-        expect(result).toHaveLength(2); // 77777 has no detail data, filtered out
-        expect(result[0]).toMatchObject({
-            rank: 1,
-            title: 'Latest Work',
-            illust_id: '99999',
-            pages: 2,
-            bookmarks: 300,
-            created: '2025-01-15',
-        });
-        expect(result[1]).toMatchObject({
-            rank: 2,
-            title: 'Older Work',
-            illust_id: '88888',
-        });
-    });
-    it('respects the limit on illust IDs fetched', async () => {
-        const page = createPageMock([
-            {
-                body: {
-                    illusts: { '100': null, '200': null, '300': null, '400': null, '500': null },
-                },
-            },
-            {
-                body: {
-                    works: {
-                        '500': { id: '500', title: 'W5', pageCount: 1, bookmarkCount: 0, tags: [], createDate: '' },
-                        '400': { id: '400', title: 'W4', pageCount: 1, bookmarkCount: 0, tags: [], createDate: '' },
-                    },
-                },
-            },
-        ]);
-        const result = (await cmd.func(page, { 'user-id': '11', limit: 2 }));
-        expect(result).toHaveLength(2);
-    });
-});

package/clis/pixiv/search.test.js

@@ -1,83 +0,0 @@
-import { beforeAll, describe, expect, it } from 'vitest';
-import { getRegistry } from '@sovovs/bycli/registry';
-import { AuthRequiredError, CommandExecutionError } from '@sovovs/bycli/errors';
-import { createPageMock } from '../test-utils.js';
-import './search.js';
-let cmd;
-beforeAll(() => {
-    cmd = getRegistry().get('pixiv/search');
-    expect(cmd?.func).toBeTypeOf('function');
-});
-describe('pixiv search', () => {
-    it('throws AuthRequiredError on 401', async () => {
-        const page = createPageMock([{ __httpError: 401 }]);
-        await expect(cmd.func(page, { query: '初音ミク', limit: 5 })).rejects.toThrow(AuthRequiredError);
-    });
-    it('throws generic error on non-auth HTTP failure', async () => {
-        const page = createPageMock([{ __httpError: 500 }]);
-        await expect(cmd.func(page, { query: 'test', limit: 5 })).rejects.toThrow(CommandExecutionError);
-    });
-    it('returns ranked results with correct fields', async () => {
-        const page = createPageMock([
-            {
-                body: {
-                    illust: {
-                        data: [
-                            {
-                                id: '12345',
-                                title: 'Miku Illustration',
-                                userName: 'artist1',
-                                userId: '100',
-                                pageCount: 3,
-                                bookmarkCount: 500,
-                                tags: ['初音ミク', 'VOCALOID', 'ミク'],
-                            },
-                            {
-                                id: '67890',
-                                title: 'Another Art',
-                                userName: 'artist2',
-                                userId: '200',
-                                pageCount: 1,
-                                bookmarkCount: 100,
-                                tags: ['オリジナル'],
-                            },
-                        ],
-                    },
-                },
-            },
-        ]);
-        const result = (await cmd.func(page, { query: '初音ミク', limit: 10 }));
-        expect(result).toHaveLength(2);
-        expect(result[0]).toMatchObject({
-            rank: 1,
-            title: 'Miku Illustration',
-            author: 'artist1',
-            illust_id: '12345',
-            pages: 3,
-            bookmarks: 500,
-        });
-        expect(result[1]).toMatchObject({ rank: 2, illust_id: '67890' });
-    });
-    it('respects the limit parameter', async () => {
-        const page = createPageMock([
-            {
-                body: {
-                    illust: {
-                        data: [
-                            { id: '1', title: 'A', userName: 'u1', userId: '1', pageCount: 1, bookmarkCount: 0, tags: [] },
-                            { id: '2', title: 'B', userName: 'u2', userId: '2', pageCount: 1, bookmarkCount: 0, tags: [] },
-                            { id: '3', title: 'C', userName: 'u3', userId: '3', pageCount: 1, bookmarkCount: 0, tags: [] },
-                        ],
-                    },
-                },
-            },
-        ]);
-        const result = (await cmd.func(page, { query: 'test', limit: 2 }));
-        expect(result).toHaveLength(2);
-    });
-    it('returns empty array when no results', async () => {
-        const page = createPageMock([{ body: { illust: { data: [] } } }]);
-        const result = await cmd.func(page, { query: 'nonexistent', limit: 10 });
-        expect(result).toEqual([]);
-    });
-});