@sovovs/bycli 1.8.0 → 2.0.0

package/clis/powerchina/search.test.js

@@ -1,93 +0,0 @@
-import { afterEach, describe, expect, it, vi } from 'vitest';
-import { EmptyResultError } from '@sovovs/bycli/errors';
-import { getRegistry } from '@sovovs/bycli/registry';
-import { __test__ } from './search.js';
-import './search.js';
-
-afterEach(() => {
-  vi.unstubAllGlobals();
-});
-
-describe('powerchina search helpers', () => {
-  it('builds candidate URLs with keyword variants', () => {
-    const candidates = __test__.buildSearchCandidates('procurement');
-    expect(candidates[0]).toContain('keyword=procurement');
-    expect(candidates.some((item) => item.includes('/search?keywords='))).toBe(true);
-    expect(candidates.some((item) => item === 'https://bid.powerchina.cn/search')).toBe(true);
-  });
-
-  it('normalizes date text', () => {
-    expect(__test__.normalizeDate('2026-4-7')).toBe('2026-04-07');
-    expect(__test__.normalizeDate('公告时间：2026年04月07日')).toBe('2026-04-07');
-  });
-
-  it('deduplicates title/url pairs', () => {
-    const deduped = __test__.dedupeCandidates([
-      { title: 'A', url: 'https://a.com/1', date: '2026-04-07' },
-      { title: 'A', url: 'https://a.com/1', date: '2026-04-07' },
-      { title: 'B', url: 'https://a.com/1', date: '2026-04-07' },
-    ]);
-    expect(deduped).toHaveLength(2);
-  });
-
-  it('filters obvious navigation rows before quality gate', () => {
-    const filtered = __test__.filterNavigationRows([
-      { title: '搜索', url: 'https://bid.powerchina.cn/search', date: '2026-04-07' },
-      { title: '首页', url: 'https://bid.powerchina.cn/', date: '2026-04-07' },
-      { title: 'English', url: 'https://bid.powerchina.cn/old/en', date: '' },
-      { title: '某项目电梯采购公告', url: 'https://bid.powerchina.cn/notice/detail?id=123', date: '2026-04-07' },
-    ]);
-    expect(filtered).toHaveLength(1);
-    expect(filtered[0].title).toContain('电梯采购公告');
-  });
-
-  it('treats old/en language switch urls as navigation', () => {
-    expect(__test__.isLikelyNavigationUrl('https://bid.powerchina.cn/old/en')).toBe(true);
-  });
-
-  it('treats language-toggle labels as navigation titles', () => {
-    expect(__test__.isLikelyNavigationTitle('English')).toBe(true);
-    expect(__test__.isLikelyNavigationTitle('EN')).toBe(true);
-  });
-
-  it('builds api detail urls with stable id', () => {
-    const url = __test__.buildApiDetailUrl('2409419657');
-    expect(url).toBe('https://bid.powerchina.cn/newcbs/recpro-newmember/BidAnnouncementSummary/getInfo/2409419657');
-  });
-
-  it('maps api rows into normalized search candidates', () => {
-    const mapped = __test__.toApiCandidate({
-      id: '2409419657',
-      title: '某项目电梯采购公告',
-      announcementType: '招采公告',
-      companyType: '3',
-      titleTypeName: '货物类',
-      source: '设备物资集中采购电子平台',
-      publishTime: '2026-04-07 17:05:02',
-      submissionDeadline: '2026-04-14',
-    });
-    expect(mapped).not.toBeNull();
-    expect(mapped?.title).toContain('电梯采购公告');
-    expect(mapped?.date).toBe('2026-04-07');
-    expect(mapped?.url).toBe('https://bid.powerchina.cn/newcbs/recpro-newmember/BidAnnouncementSummary/getInfo/2409419657');
-  });
-
-  it('throws EmptyResultError when extraction only finds navigation rows', async () => {
-    vi.stubGlobal('fetch', vi.fn().mockRejectedValue(new Error('network down')));
-    const cmd = getRegistry().get('powerchina/search');
-    const page = {
-      goto: vi.fn().mockResolvedValue(undefined),
-      wait: vi.fn().mockResolvedValue(undefined),
-      evaluate: vi.fn().mockResolvedValue([
-        {
-          title: '首页',
-          url: 'https://bid.powerchina.cn/',
-          date: '',
-          contextText: '首页',
-        },
-      ]),
-    };
-
-    await expect(cmd.func(page, { query: '电梯', limit: 1 })).rejects.toBeInstanceOf(EmptyResultError);
-  });
-});

package/clis/producthunt/utils.test.js

@@ -1,64 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { parseFeed, pickVoteCount, PRODUCTHUNT_CATEGORY_SLUGS } from './utils.js';
-const SAMPLE_ATOM = `<?xml version="1.0" encoding="UTF-8"?>
-<feed xmlns="http://www.w3.org/2005/Atom">
-  <title>Product Hunt</title>
-  <entry>
-    <id>tag:www.producthunt.com,2005:Post/1001</id>
-    <published>2026-03-26T10:00:00-07:00</published>
-    <title>Awesome AI Tool</title>
-    <content type="html">&lt;p&gt;The best AI tool ever made&lt;/p&gt;&lt;p&gt;&lt;a href="..."&gt;Discussion&lt;/a&gt;&lt;/p&gt;</content>
-    <author><name>Jane Doe</name></author>
-    <link rel="alternate" type="text/html" href="https://www.producthunt.com/products/awesome-ai-tool"/>
-  </entry>
-  <entry>
-    <id>tag:www.producthunt.com,2005:Post/1002</id>
-    <published>2026-03-25T08:00:00-07:00</published>
-    <title>Dev Helper</title>
-    <content type="html">&lt;p&gt;Speeds up your workflow&lt;/p&gt;</content>
-    <author><name>John Smith</name></author>
-    <link rel="alternate" type="text/html" href="https://www.producthunt.com/products/dev-helper"/>
-  </entry>
-</feed>`;
-describe('parseFeed', () => {
-    it('parses entries into ranked posts', () => {
-        const posts = parseFeed(SAMPLE_ATOM);
-        expect(posts).toHaveLength(2);
-        expect(posts[0].rank).toBe(1);
-        expect(posts[0].name).toBe('Awesome AI Tool');
-        expect(posts[0].author).toBe('Jane Doe');
-        expect(posts[0].date).toBe('2026-03-26');
-        expect(posts[0].url).toBe('https://www.producthunt.com/products/awesome-ai-tool');
-        expect(posts[0].tagline).toContain('best AI tool');
-    });
-    it('strips HTML and Discussion link from tagline', () => {
-        const posts = parseFeed(SAMPLE_ATOM);
-        expect(posts[0].tagline).not.toContain('<p>');
-        expect(posts[0].tagline).not.toContain('Discussion');
-    });
-    it('returns empty array for empty feed', () => {
-        expect(parseFeed('<feed></feed>')).toHaveLength(0);
-    });
-    it('assigns sequential ranks', () => {
-        const posts = parseFeed(SAMPLE_ATOM);
-        expect(posts.map(p => p.rank)).toEqual([1, 2]);
-    });
-    it('prefers vote-like candidates over unrelated numeric badges', () => {
-        const votes = pickVoteCount([
-            { text: '12', className: 'font-semibold', inButton: false, inReviewLink: false },
-            { text: '98', className: 'vote-button', inButton: true, inReviewLink: false },
-        ]);
-        expect(votes).toBe('98');
-    });
-    it('ignores numbers inside review links', () => {
-        const votes = pickVoteCount([
-            { text: '120', className: 'text-secondary', inButton: false, inReviewLink: true },
-            { text: '45', className: 'vote-button', inButton: true, inReviewLink: false },
-        ]);
-        expect(votes).toBe('45');
-    });
-    it('shares category slugs across commands', () => {
-        expect(PRODUCTHUNT_CATEGORY_SLUGS).toContain('developer-tools');
-        expect(PRODUCTHUNT_CATEGORY_SLUGS).toContain('ai-agents');
-    });
-});

package/clis/pubmed/pubmed.test.js

@@ -1,276 +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 {
-    LINK_COLUMNS,
-    RELATED_COLUMNS,
-    SEARCH_COLUMNS,
-    buildEutilsUrl,
-    buildSearchQuery,
-    parseArticleXml,
-    requireBoundedInt,
-    requirePmid,
-} from './utils.js';
-import './search.js';
-import './article.js';
-import './author.js';
-import './citations.js';
-import './related.js';
-
-const SUMMARY_RESULT = {
-    result: {
-        uids: ['123', '456'],
-        123: {
-            uid: '123',
-            title: 'Cancer machine learning.',
-            authors: [{ name: 'Alice A' }, { name: 'Bob B' }, { name: 'Carol C' }, { name: 'Dan D' }],
-            fulljournalname: 'Journal of Tests',
-            pubdate: '2024 Jan',
-            pubtype: ['Journal Article', 'Review'],
-            articleids: [{ idtype: 'doi', value: '10.1000/test' }],
-        },
-        456: {
-            uid: '456',
-            title: 'Second article.',
-            authors: [{ name: 'Eve E' }],
-            source: 'Test Source',
-            pubdate: '2023',
-            pubtype: ['Journal Article'],
-            articleids: [],
-        },
-    },
-};
-
-const ARTICLE_XML = `<?xml version="1.0"?>
-<PubmedArticle>
-  <MedlineCitation>
-    <Article>
-      <Journal>
-        <Title>Journal of Tests</Title>
-        <JournalIssue><PubDate><Year>2024</Year><Month>Jan</Month><Day>02</Day></PubDate></JournalIssue>
-      </Journal>
-      <ArticleTitle>Detailed PubMed article &amp; title.</ArticleTitle>
-      <Abstract><AbstractText>Background text.</AbstractText><AbstractText>Conclusion text.</AbstractText></Abstract>
-      <AuthorList>
-        <Author><LastName>Alice</LastName><ForeName>Example</ForeName></Author>
-        <Author><LastName>Bob</LastName><Initials>B</Initials></Author>
-      </AuthorList>
-      <Language>eng</Language>
-      <PublicationTypeList><PublicationType>Review</PublicationType></PublicationTypeList>
-    </Article>
-    <MeshHeadingList><MeshHeading><DescriptorName>Neoplasms</DescriptorName></MeshHeading></MeshHeadingList>
-    <KeywordList><Keyword>machine learning</Keyword></KeywordList>
-  </MedlineCitation>
-  <PubmedData><ArticleIdList><ArticleId IdType="doi">10.1000/detail</ArticleId><ArticleId IdType="pmc">PMC123</ArticleId></ArticleIdList></PubmedData>
-</PubmedArticle>`;
-
-function jsonResponse(body, ok = true, status = 200) {
-    return {
-        ok,
-        status,
-        json: vi.fn().mockResolvedValue(body),
-        text: vi.fn().mockResolvedValue(typeof body === 'string' ? body : JSON.stringify(body)),
-    };
-}
-
-function xmlResponse(body, ok = true, status = 200) {
-    return {
-        ok,
-        status,
-        json: vi.fn().mockRejectedValue(new Error('not json')),
-        text: vi.fn().mockResolvedValue(body),
-    };
-}
-
-afterEach(() => {
-    vi.unstubAllGlobals();
-});
-
-describe('pubmed adapter registration', () => {
-    it('registers five public read commands with expected listing columns', () => {
-        const registry = getRegistry();
-        for (const name of ['search', 'article', 'author', 'citations', 'related']) {
-            const command = registry.get(`pubmed/${name}`);
-            expect(command).toBeDefined();
-            expect(command.strategy).toBe('public');
-            expect(command.browser).toBe(false);
-            expect(command.access).toBe('read');
-        }
-        expect(registry.get('pubmed/search').columns).toEqual(SEARCH_COLUMNS);
-        expect(registry.get('pubmed/author').columns).toEqual(LINK_COLUMNS);
-        expect(registry.get('pubmed/citations').columns).toEqual(LINK_COLUMNS);
-        expect(registry.get('pubmed/related').columns).toEqual(RELATED_COLUMNS);
-    });
-});
-
-describe('pubmed utility contracts', () => {
-    it('rejects invalid PMIDs and silently-clamped limits', () => {
-        expect(requirePmid('37780221')).toBe('37780221');
-        expect(() => requirePmid('PMID:37780221')).toThrow(ArgumentError);
-        expect(requireBoundedInt(undefined, 20, 100)).toBe(20);
-        expect(requireBoundedInt('100', 20, 100)).toBe(100);
-        expect(() => requireBoundedInt('2abc', 20, 100)).toThrow(ArgumentError);
-        expect(() => requireBoundedInt(101, 20, 100)).toThrow(/<= 100/);
-        expect(() => requireBoundedInt(0, 20, 100)).toThrow(ArgumentError);
-    });
-
-    it('builds E-utilities URLs with optional NCBI metadata', () => {
-        vi.stubEnv('NCBI_API_KEY', 'key-1');
-        vi.stubEnv('NCBI_EMAIL', 'dev@example.com');
-        const url = buildEutilsUrl('esearch', { term: 'cancer', retmax: 5 });
-        expect(url).toContain('/esearch.fcgi?');
-        expect(url).toContain('db=pubmed');
-        expect(url).toContain('api_key=key-1');
-        expect(url).toContain('email=dev%40example.com');
-        expect(url).toContain('term=cancer');
-    });
-
-    it('composes search filters without dropping date boundaries', () => {
-        expect(buildSearchQuery('cancer', {
-            author: 'Smith J',
-            journal: 'Nature',
-            yearFrom: 2020,
-            yearTo: 2024,
-            articleType: 'Review',
-            hasAbstract: true,
-            hasFullText: true,
-            humanOnly: true,
-            englishOnly: true,
-        })).toBe('cancer AND Smith J[Author] AND Nature[Journal] AND 2020:2024[PDAT] AND Review[PT] AND hasabstract[text] AND free full text[sb] AND humans[mesh] AND english[lang]');
-        expect(() => buildSearchQuery('cancer', { yearFrom: 2025, yearTo: 2020 })).toThrow(ArgumentError);
-    });
-
-    it('parses EFetch XML into article details', () => {
-        const article = parseArticleXml(ARTICLE_XML, '123');
-        expect(article.title).toBe('Detailed PubMed article & title.');
-        expect(article.abstract).toBe('Background text. Conclusion text.');
-        expect(article.authors).toEqual(['Alice Example', 'Bob B']);
-        expect(article.journal).toBe('Journal of Tests');
-        expect(article.doi).toBe('10.1000/detail');
-        expect(article.mesh_terms).toBe('Neoplasms');
-    });
-});
-
-describe('pubmed search command', () => {
-    it('returns summary rows for ESearch ids', async () => {
-        vi.stubGlobal('fetch', vi.fn()
-            .mockResolvedValueOnce(jsonResponse({ esearchresult: { idlist: ['123', '456'] } }))
-            .mockResolvedValueOnce(jsonResponse(SUMMARY_RESULT)));
-        const rows = await getRegistry().get('pubmed/search').func({ query: 'cancer', limit: 2, sort: 'date' });
-        expect(rows).toHaveLength(2);
-        expect(rows[0]).toMatchObject({ rank: 1, pmid: '123', title: 'Cancer machine learning', article_type: 'Review', doi: '10.1000/test' });
-        expect(rows[0].url).toBe('https://pubmed.ncbi.nlm.nih.gov/123/');
-    });
-
-    it('rejects bad query, limit, sort, and year args before fetch', async () => {
-        const fetchMock = vi.fn();
-        vi.stubGlobal('fetch', fetchMock);
-        const command = getRegistry().get('pubmed/search');
-        await expect(command.func({ query: ' ', limit: 2 })).rejects.toBeInstanceOf(ArgumentError);
-        await expect(command.func({ query: 'cancer', limit: 101 })).rejects.toBeInstanceOf(ArgumentError);
-        await expect(command.func({ query: 'cancer', sort: 'bad' })).rejects.toBeInstanceOf(ArgumentError);
-        await expect(command.func({ query: 'cancer', 'year-from': 2025, 'year-to': 2020 })).rejects.toBeInstanceOf(ArgumentError);
-        expect(fetchMock).not.toHaveBeenCalled();
-    });
-
-    it('maps empty and API error envelopes to typed errors', async () => {
-        const command = getRegistry().get('pubmed/search');
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValueOnce(jsonResponse({ esearchresult: { idlist: [] } })));
-        await expect(command.func({ query: 'nothing' })).rejects.toBeInstanceOf(EmptyResultError);
-
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValueOnce(jsonResponse({ esearchresult: { errorlist: { phrasesnotfound: ['bad field'] } } })));
-        await expect(command.func({ query: 'bad' })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-
-    it('maps HTTP, fetch, JSON, and partial summary failures to CommandExecutionError', async () => {
-        const command = getRegistry().get('pubmed/search');
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValueOnce(jsonResponse({}, false, 500)));
-        await expect(command.func({ query: 'cancer' })).rejects.toBeInstanceOf(CommandExecutionError);
-
-        vi.stubGlobal('fetch', vi.fn().mockRejectedValueOnce(new Error('network down')));
-        await expect(command.func({ query: 'cancer' })).rejects.toBeInstanceOf(CommandExecutionError);
-
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValueOnce({ ok: true, status: 200, json: vi.fn().mockRejectedValue(new Error('bad json')) }));
-        await expect(command.func({ query: 'cancer' })).rejects.toBeInstanceOf(CommandExecutionError);
-
-        vi.stubGlobal('fetch', vi.fn()
-            .mockResolvedValueOnce(jsonResponse({ esearchresult: { idlist: ['123', '456'] } }))
-            .mockResolvedValueOnce(jsonResponse({ result: { 123: SUMMARY_RESULT.result[123] } })));
-        await expect(command.func({ query: 'cancer' })).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-});
-
-describe('pubmed article command', () => {
-    it('returns field/value rows for a valid article', async () => {
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValueOnce(xmlResponse(ARTICLE_XML)));
-        const rows = await getRegistry().get('pubmed/article').func({ pmid: '123' });
-        expect(rows).toContainEqual({ field: 'PMID', value: '123' });
-        expect(rows).toContainEqual({ field: 'DOI', value: '10.1000/detail' });
-        expect(rows.find(row => row.field === 'Abstract').value).toContain('Background text');
-    });
-
-    it('rejects invalid or missing articles with typed errors', async () => {
-        const command = getRegistry().get('pubmed/article');
-        await expect(command.func({ pmid: 'abc' })).rejects.toBeInstanceOf(ArgumentError);
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValueOnce(xmlResponse('<ERROR>not found</ERROR>')));
-        await expect(command.func({ pmid: '123' })).rejects.toBeInstanceOf(EmptyResultError);
-    });
-});
-
-describe('pubmed author command', () => {
-    it('searches author position and affiliation filters', async () => {
-        const fetchMock = vi.fn()
-            .mockResolvedValueOnce(jsonResponse({ esearchresult: { idlist: ['123'] } }))
-            .mockResolvedValueOnce(jsonResponse({ result: { 123: SUMMARY_RESULT.result[123] } }));
-        vi.stubGlobal('fetch', fetchMock);
-        const rows = await getRegistry().get('pubmed/author').func({ name: 'Smith J', position: 'first', affiliation: 'Harvard', limit: 1 });
-        expect(rows[0].pmid).toBe('123');
-        const url = fetchMock.mock.calls[0][0];
-        expect(url).toContain('Smith+J%5B1au%5D');
-        expect(url).toContain('Harvard%5Bad%5D');
-    });
-
-    it('rejects invalid author filters and empty results', async () => {
-        const command = getRegistry().get('pubmed/author');
-        await expect(command.func({ name: '', position: 'any' })).rejects.toBeInstanceOf(ArgumentError);
-        await expect(command.func({ name: 'Smith', position: 'middle' })).rejects.toBeInstanceOf(ArgumentError);
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValueOnce(jsonResponse({ esearchresult: { idlist: [] } })));
-        await expect(command.func({ name: 'Smith' })).rejects.toBeInstanceOf(EmptyResultError);
-    });
-});
-
-describe('pubmed citations and related commands', () => {
-    it('returns cited-by summary rows with PMID round-trip ids', async () => {
-        vi.stubGlobal('fetch', vi.fn()
-            .mockResolvedValueOnce(jsonResponse({ linksets: [{ linksetdbs: [{ links: ['123'] }] }] }))
-            .mockResolvedValueOnce(jsonResponse({ result: { 123: SUMMARY_RESULT.result[123] } })));
-        const rows = await getRegistry().get('pubmed/citations').func({ pmid: '999', direction: 'citedby', limit: 1 });
-        expect(rows).toHaveLength(1);
-        expect(rows[0].pmid).toBe('123');
-    });
-
-    it('rejects invalid citation args and empty relationships', async () => {
-        const command = getRegistry().get('pubmed/citations');
-        await expect(command.func({ pmid: 'bad' })).rejects.toBeInstanceOf(ArgumentError);
-        await expect(command.func({ pmid: '999', direction: 'sideways' })).rejects.toBeInstanceOf(ArgumentError);
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValueOnce(jsonResponse({ linksets: [{ linksetdbs: [] }] })));
-        await expect(command.func({ pmid: '999', direction: 'citedby' })).rejects.toBeInstanceOf(EmptyResultError);
-    });
-
-    it('returns related rows with optional score', async () => {
-        vi.stubGlobal('fetch', vi.fn()
-            .mockResolvedValueOnce(jsonResponse({ linksets: [{ linksetdbs: [{ links: [{ id: '999', score: 999 }, { id: '123', score: 42 }] }] }] }))
-            .mockResolvedValueOnce(jsonResponse({ result: { 123: SUMMARY_RESULT.result[123] } })));
-        const rows = await getRegistry().get('pubmed/related').func({ pmid: '999', score: true, limit: 1 });
-        expect(rows).toHaveLength(1);
-        expect(rows[0]).toMatchObject({ pmid: '123', score: 42 });
-    });
-
-    it('rejects invalid related args and empty related links', async () => {
-        const command = getRegistry().get('pubmed/related');
-        await expect(command.func({ pmid: 'bad' })).rejects.toBeInstanceOf(ArgumentError);
-        await expect(command.func({ pmid: '999', limit: 101 })).rejects.toBeInstanceOf(ArgumentError);
-        vi.stubGlobal('fetch', vi.fn().mockResolvedValueOnce(jsonResponse({ linksets: [{ linksetdbs: [{ links: [{ id: '999' }] }] }] })));
-        await expect(command.func({ pmid: '999' })).rejects.toBeInstanceOf(EmptyResultError);
-    });
-});

package/clis/quark/utils.test.js

@@ -1,58 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { AuthRequiredError, CommandExecutionError } from '@sovovs/bycli/errors';
-import { apiGet, apiPost, extractPwdId, getShareList, getToken } from './utils.js';
-function makePage(evaluateImpl) {
-    return {
-        evaluate: vi.fn(evaluateImpl),
-    };
-}
-describe('quark utils', () => {
-    it('extractPwdId accepts share URLs and raw ids', () => {
-        expect(extractPwdId('https://pan.quark.cn/s/abc123')).toBe('abc123');
-        expect(extractPwdId('abc123')).toBe('abc123');
-    });
-    it('maps JSON auth failures to AuthRequiredError', async () => {
-        const page = makePage(async () => ({
-            status: 401,
-            code: 401,
-            message: '未登录',
-            data: null,
-        }));
-        await expect(apiGet(page, 'https://drive-pc.quark.cn/test')).rejects.toBeInstanceOf(AuthRequiredError);
-    });
-    it('maps non-JSON auth pages to AuthRequiredError', async () => {
-        const page = makePage(async () => {
-            const error = Object.assign(new Error('Non-JSON response: <html><title>登录</title></html>'), { status: 401 });
-            throw error;
-        });
-        await expect(apiPost(page, 'https://drive-pc.quark.cn/test', {})).rejects.toBeInstanceOf(AuthRequiredError);
-    });
-    it('keeps generic API failures as CommandExecutionError', async () => {
-        const page = makePage(async () => ({
-            status: 500,
-            code: 500,
-            message: 'server busy',
-            data: null,
-        }));
-        await expect(apiGet(page, 'https://drive-pc.quark.cn/test')).rejects.toBeInstanceOf(CommandExecutionError);
-    });
-    it('unwraps successful token responses', async () => {
-        const page = makePage(async () => ({
-            status: 200,
-            code: 0,
-            message: 'ok',
-            data: { stoken: 'token123' },
-        }));
-        await expect(getToken(page, 'abc123')).resolves.toBe('token123');
-    });
-    it('maps share-tree detail auth failures to AuthRequiredError', async () => {
-        const page = makePage(async () => ({
-            status: 401,
-            code: 401,
-            message: '请先登录',
-            data: null,
-            metadata: { _total: 0 },
-        }));
-        await expect(getShareList(page, 'abc123', 'token123')).rejects.toBeInstanceOf(AuthRequiredError);
-    });
-});

package/clis/qwen/utils.test.js

@@ -1,45 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { ArgumentError } from '@sovovs/bycli/errors';
-import { parseQianwenSessionId } from './utils.js';
-
-describe('qwen parseQianwenSessionId', () => {
-    const id = 'abcd1234ef567890abcd1234ef567890';
-
-    it('returns a bare 32-char hex ID unchanged', () => {
-        expect(parseQianwenSessionId(id)).toBe(id);
-    });
-
-    it('lowercases an upper-case ID', () => {
-        expect(parseQianwenSessionId(id.toUpperCase())).toBe(id);
-    });
-
-    it('extracts the session ID from a full qianwen.com chat URL', () => {
-        expect(parseQianwenSessionId(`https://www.qianwen.com/chat/${id}`)).toBe(id);
-        expect(parseQianwenSessionId(`https://www.qianwen.com/chat/${id}?from=share`)).toBe(id);
-        expect(parseQianwenSessionId(`http://qianwen.com/chat/${id}`)).toBe(id);
-    });
-
-    it('throws ArgumentError on empty input', () => {
-        expect(() => parseQianwenSessionId('')).toThrow(ArgumentError);
-        expect(() => parseQianwenSessionId(null)).toThrow(ArgumentError);
-        expect(() => parseQianwenSessionId(undefined)).toThrow(ArgumentError);
-        expect(() => parseQianwenSessionId('   ')).toThrow(ArgumentError);
-    });
-
-    it('throws ArgumentError on non-hex input', () => {
-        expect(() => parseQianwenSessionId('not-an-id')).toThrow(ArgumentError);
-        expect(() => parseQianwenSessionId('123')).toThrow(ArgumentError);
-        // 32 chars but not all hex
-        expect(() => parseQianwenSessionId('zbcd1234ef567890abcd1234ef567890')).toThrow(ArgumentError);
-        // 31 hex chars — too short
-        expect(() => parseQianwenSessionId('abcd1234ef567890abcd1234ef56789')).toThrow(ArgumentError);
-        // 33 hex chars — too long
-        expect(() => parseQianwenSessionId('abcd1234ef567890abcd1234ef5678900')).toThrow(ArgumentError);
-        // URL with the wrong path shape must not silently fall through.
-        expect(() => parseQianwenSessionId('https://www.qianwen.com/somewhere/else')).toThrow(ArgumentError);
-        // URL embedding a 33+ hex tail must not silently truncate to 32 chars
-        // and open the wrong conversation.
-        expect(() => parseQianwenSessionId(`https://www.qianwen.com/chat/${id}0`)).toThrow(ArgumentError);
-        expect(() => parseQianwenSessionId(`https://www.qianwen.com/chat/${id}abc`)).toThrow(ArgumentError);
-    });
-});