@sovovs/bycli 1.8.0 → 2.0.0

package/clis/douyin/_shared/timing.test.js

@@ -1,28 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { validateTiming, toUnixSeconds } from './timing.js';
-describe('validateTiming', () => {
-    const now = () => Math.floor(Date.now() / 1000);
-    it('accepts a time 3 hours from now', () => {
-        expect(() => validateTiming(now() + 3 * 3600)).not.toThrow();
-    });
-    it('rejects a time less than 2 hours from now', () => {
-        expect(() => validateTiming(now() + 3600)).toThrow('至少 2 小时后');
-    });
-    it('rejects a time more than 14 days from now', () => {
-        expect(() => validateTiming(now() + 15 * 86400)).toThrow('不能超过 14 天');
-    });
-});
-describe('toUnixSeconds', () => {
-    it('passes through a numeric unix timestamp', () => {
-        expect(toUnixSeconds(1744070400)).toBe(1744070400);
-    });
-    it('parses a numeric unix timestamp string', () => {
-        expect(toUnixSeconds('1744070400')).toBe(1744070400);
-    });
-    it('parses ISO8601 string', () => {
-        expect(toUnixSeconds('2026-04-08T12:00:00Z')).toBe(Math.floor(new Date('2026-04-08T12:00:00Z').getTime() / 1000));
-    });
-    it('throws on invalid input', () => {
-        expect(() => toUnixSeconds('not-a-date')).toThrow();
-    });
-});

package/clis/douyin/_shared/tos-upload-short-read.test.js

@@ -1,83 +0,0 @@
-/**
- * Tests for the fs.readSync short-read guard in tosUpload.
- *
- * This file is separate from tos-upload.test.ts because vi.mock is hoisted and
- * would interfere with the real-fs tests there.
- *
- * Strategy:
- * - Use setReadSyncOverride (exported testing seam) to force readSync to return 0
- * - Mock global fetch to satisfy initMultipartUpload so the code path reaches readSync
- */
-import * as actualFs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { CommandExecutionError } from '@sovovs/bycli/errors';
-import { setReadSyncOverride, tosUpload } from './tos-upload.js';
-/** Build a minimal fetch mock that satisfies initMultipartUpload (POST ?uploads → 200 + UploadId XML). */
-function makeFetchMock() {
-    return vi.fn().mockResolvedValue({
-        status: 200,
-        text: async () => '<InitiateMultipartUploadResult><UploadId>mock-upload-id</UploadId></InitiateMultipartUploadResult>',
-        headers: { forEach: (_cb) => { } },
-    });
-}
-describe('tosUpload short-read guard', () => {
-    let tmpDir;
-    let tmpFile;
-    let originalFetch;
-    beforeEach(() => {
-        originalFetch = globalThis.fetch;
-        tmpDir = actualFs.mkdtempSync(path.join(os.tmpdir(), 'tos-upload-shortread-'));
-        tmpFile = path.join(tmpDir, 'video.mp4');
-        // 100-byte file — fits in a single part
-        actualFs.writeFileSync(tmpFile, Buffer.alloc(100, 0xff));
-    });
-    afterEach(() => {
-        setReadSyncOverride(null);
-        globalThis.fetch = originalFetch;
-        actualFs.rmSync(tmpDir, { recursive: true, force: true });
-    });
-    it('throws CommandExecutionError on short read', async () => {
-        // Mock fetch so initMultipartUpload succeeds and code reaches readSync
-        globalThis.fetch = makeFetchMock();
-        // Override readSync to return 0 (fewer bytes than requested)
-        setReadSyncOverride(() => 0);
-        const mockCredentials = {
-            access_key_id: 'AKIAIOSFODNN7EXAMPLE',
-            secret_access_key: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
-            session_token: 'test-session-token',
-            expired_time: Date.now() / 1000 + 3600,
-        };
-        const uploadInfo = {
-            tos_upload_url: 'https://tos-cn-i-alisg.volces.com/bucket/key',
-            auth: 'AWS4-HMAC-SHA256 Credential=test',
-            video_id: 'test-video-id',
-        };
-        await expect(tosUpload({
-            filePath: tmpFile,
-            uploadInfo,
-            credentials: mockCredentials,
-        })).rejects.toThrow(CommandExecutionError);
-    });
-    it('error message identifies the part number and byte counts', async () => {
-        globalThis.fetch = makeFetchMock();
-        setReadSyncOverride(() => 0);
-        const mockCredentials = {
-            access_key_id: 'AKIAIOSFODNN7EXAMPLE',
-            secret_access_key: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
-            session_token: 'test-session-token',
-            expired_time: Date.now() / 1000 + 3600,
-        };
-        const uploadInfo = {
-            tos_upload_url: 'https://tos-cn-i-alisg.volces.com/bucket/key',
-            auth: 'AWS4-HMAC-SHA256 Credential=test',
-            video_id: 'test-video-id',
-        };
-        await expect(tosUpload({
-            filePath: tmpFile,
-            uploadInfo,
-            credentials: mockCredentials,
-        })).rejects.toThrow(/Short read on part 1: expected 100 bytes, got 0/);
-    });
-});

package/clis/douyin/_shared/tos-upload.test.js

@@ -1,229 +0,0 @@
-import * as fs from 'node:fs';
-import * as os from 'node:os';
-import * as path from 'node:path';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { PART_SIZE, computeAws4Headers, deleteResumeState, extractRegionFromHost, getResumeFilePath, loadResumeState, saveResumeState, } from './tos-upload.js';
-// ── extractRegionFromHost ────────────────────────────────────────────────────
-describe('extractRegionFromHost', () => {
-    it('extracts region from standard TOS host', () => {
-        expect(extractRegionFromHost('tos-cn-i-alisg.volces.com')).toBe('cn-i-alisg');
-    });
-    it('extracts region from beijing TOS host', () => {
-        expect(extractRegionFromHost('tos-cn-beijing.ivolces.com')).toBe('cn-beijing');
-    });
-    it('falls back to cn-north-1 for unknown host', () => {
-        expect(extractRegionFromHost('unknown.example.com')).toBe('cn-north-1');
-    });
-});
-// ── Part chunking ────────────────────────────────────────────────────────────
-describe('PART_SIZE and part chunking logic', () => {
-    it('PART_SIZE is exactly 5 MB', () => {
-        expect(PART_SIZE).toBe(5 * 1024 * 1024);
-    });
-    it('single file smaller than PART_SIZE fits in 1 part', () => {
-        const fileSize = 1 * 1024 * 1024; // 1 MB
-        const totalParts = Math.ceil(fileSize / PART_SIZE);
-        expect(totalParts).toBe(1);
-        const lastPartSize = fileSize - (totalParts - 1) * PART_SIZE;
-        expect(lastPartSize).toBe(fileSize);
-    });
-    it('exactly 5 MB file produces 1 part', () => {
-        const fileSize = PART_SIZE;
-        expect(Math.ceil(fileSize / PART_SIZE)).toBe(1);
-    });
-    it('5 MB + 1 byte produces 2 parts', () => {
-        const fileSize = PART_SIZE + 1;
-        expect(Math.ceil(fileSize / PART_SIZE)).toBe(2);
-    });
-    it('100 MB file produces 20 parts of 5 MB each', () => {
-        const fileSize = 100 * 1024 * 1024;
-        const totalParts = Math.ceil(fileSize / PART_SIZE);
-        expect(totalParts).toBe(20);
-        // Each part is exactly PART_SIZE
-        for (let i = 1; i <= totalParts; i++) {
-            const offset = (i - 1) * PART_SIZE;
-            const chunkSize = Math.min(PART_SIZE, fileSize - offset);
-            expect(chunkSize).toBe(PART_SIZE);
-        }
-    });
-    it('101 MB file produces 21 parts, last part is 1 MB', () => {
-        const fileSize = 101 * 1024 * 1024;
-        const totalParts = Math.ceil(fileSize / PART_SIZE);
-        expect(totalParts).toBe(21);
-        const lastOffset = (totalParts - 1) * PART_SIZE;
-        const lastPartSize = fileSize - lastOffset;
-        expect(lastPartSize).toBe(1 * 1024 * 1024);
-    });
-});
-// ── Resume file serialization/deserialization ─────────────────────────────────
-describe('resume state read/write', () => {
-    let tmpDir;
-    let resumePath;
-    beforeEach(() => {
-        tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), 'tos-upload-test-'));
-        resumePath = path.join(tmpDir, 'resume.json');
-    });
-    afterEach(() => {
-        fs.rmSync(tmpDir, { recursive: true, force: true });
-    });
-    it('saves and loads resume state correctly', () => {
-        const state = {
-            uploadId: 'test-upload-id-123',
-            fileSize: 12345678,
-            parts: [
-                { partNumber: 1, etag: '"abc123"' },
-                { partNumber: 2, etag: '"def456"' },
-            ],
-        };
-        saveResumeState(resumePath, state);
-        const loaded = loadResumeState(resumePath, 12345678);
-        expect(loaded).not.toBeNull();
-        expect(loaded.uploadId).toBe('test-upload-id-123');
-        expect(loaded.fileSize).toBe(12345678);
-        expect(loaded.parts).toHaveLength(2);
-        expect(loaded.parts[0]).toEqual({ partNumber: 1, etag: '"abc123"' });
-        expect(loaded.parts[1]).toEqual({ partNumber: 2, etag: '"def456"' });
-    });
-    it('returns null when file does not exist', () => {
-        const result = loadResumeState('/nonexistent/path/resume.json', 12345678);
-        expect(result).toBeNull();
-    });
-    it('returns null when fileSize does not match', () => {
-        const state = {
-            uploadId: 'upload-id',
-            fileSize: 100,
-            parts: [],
-        };
-        saveResumeState(resumePath, state);
-        // Different file size — should not resume
-        const result = loadResumeState(resumePath, 999);
-        expect(result).toBeNull();
-    });
-    it('returns null when JSON is malformed', () => {
-        fs.writeFileSync(resumePath, 'not-valid-json', 'utf8');
-        const result = loadResumeState(resumePath, 100);
-        expect(result).toBeNull();
-    });
-    it('returns null when uploadId is missing', () => {
-        const broken = { fileSize: 100, parts: [] };
-        fs.writeFileSync(resumePath, JSON.stringify(broken), 'utf8');
-        const result = loadResumeState(resumePath, 100);
-        expect(result).toBeNull();
-    });
-    it('deletes resume file without throwing when file exists', () => {
-        fs.writeFileSync(resumePath, '{}', 'utf8');
-        expect(() => deleteResumeState(resumePath)).not.toThrow();
-        expect(fs.existsSync(resumePath)).toBe(false);
-    });
-    it('deleteResumeState does not throw when file does not exist', () => {
-        expect(() => deleteResumeState('/nonexistent/path/resume.json')).not.toThrow();
-    });
-    it('saveResumeState creates parent directories if missing', () => {
-        const nestedPath = path.join(tmpDir, 'nested', 'deep', 'resume.json');
-        const state = { uploadId: 'x', fileSize: 0, parts: [] };
-        expect(() => saveResumeState(nestedPath, state)).not.toThrow();
-        expect(fs.existsSync(nestedPath)).toBe(true);
-    });
-});
-// ── getResumeFilePath ────────────────────────────────────────────────────────
-describe('getResumeFilePath', () => {
-    it('returns a path inside ~/.bycli/douyin-resume/', () => {
-        const result = getResumeFilePath('/some/video/file.mp4');
-        expect(result).toContain('douyin-resume');
-        expect(result).toMatch(/\.json$/);
-    });
-    it('produces same path for same input', () => {
-        const a = getResumeFilePath('/video.mp4');
-        const b = getResumeFilePath('/video.mp4');
-        expect(a).toBe(b);
-    });
-    it('produces different paths for different inputs', () => {
-        const a = getResumeFilePath('/video1.mp4');
-        const b = getResumeFilePath('/video2.mp4');
-        expect(a).not.toBe(b);
-    });
-});
-// ── computeAws4Headers ───────────────────────────────────────────────────────
-describe('computeAws4Headers', () => {
-    const mockCredentials = {
-        access_key_id: 'AKIAIOSFODNN7EXAMPLE',
-        secret_access_key: 'wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY',
-        session_token: 'FQoGZXIvYXdzEJr//////////test-session-token',
-        expired_time: Date.now() / 1000 + 3600,
-    };
-    it('returns Authorization header', () => {
-        const headers = computeAws4Headers({
-            method: 'PUT',
-            url: 'https://tos-cn-i-alisg.volces.com/bucket/object?partNumber=1&uploadId=abc',
-            headers: { 'content-type': 'application/octet-stream' },
-            body: Buffer.from('hello'),
-            credentials: mockCredentials,
-            service: 'tos',
-            region: 'cn-i-alisg',
-            datetime: '20260325T120000Z',
-        });
-        expect(headers['Authorization']).toMatch(/^AWS4-HMAC-SHA256 Credential=/);
-        expect(headers['Authorization']).toContain('AKIAIOSFODNN7EXAMPLE/20260325/cn-i-alisg/tos/aws4_request');
-        expect(headers['Authorization']).toContain('SignedHeaders=');
-        expect(headers['Authorization']).toContain('Signature=');
-    });
-    it('includes x-amz-date header', () => {
-        const headers = computeAws4Headers({
-            method: 'PUT',
-            url: 'https://tos-cn-i-alisg.volces.com/bucket/object?partNumber=1&uploadId=abc',
-            headers: {},
-            body: Buffer.alloc(0),
-            credentials: mockCredentials,
-            service: 'tos',
-            region: 'cn-i-alisg',
-            datetime: '20260325T120000Z',
-        });
-        expect(headers['x-amz-date']).toBe('20260325T120000Z');
-    });
-    it('includes x-amz-security-token with session token', () => {
-        const headers = computeAws4Headers({
-            method: 'PUT',
-            url: 'https://tos-cn-i-alisg.volces.com/bucket/object',
-            headers: {},
-            body: '',
-            credentials: mockCredentials,
-            service: 'tos',
-            region: 'cn-i-alisg',
-            datetime: '20260325T120000Z',
-        });
-        expect(headers['x-amz-security-token']).toBe(mockCredentials.session_token);
-    });
-    it('signed headers list is sorted', () => {
-        const headers = computeAws4Headers({
-            method: 'POST',
-            url: 'https://tos-cn-i-alisg.volces.com/bucket/object?uploadId=abc',
-            headers: { 'content-type': 'application/xml' },
-            body: '<xml/>',
-            credentials: mockCredentials,
-            service: 'tos',
-            region: 'cn-i-alisg',
-            datetime: '20260325T120000Z',
-        });
-        const authHeader = headers['Authorization'];
-        const signedHeadersMatch = authHeader.match(/SignedHeaders=([^,]+)/);
-        expect(signedHeadersMatch).not.toBeNull();
-        const signedHeadersList = signedHeadersMatch[1].split(';');
-        const sorted = [...signedHeadersList].sort((a, b) => a.localeCompare(b));
-        expect(signedHeadersList).toEqual(sorted);
-    });
-    it('produces deterministic signature for same inputs', () => {
-        const opts = {
-            method: 'PUT',
-            url: 'https://tos-cn-i-alisg.volces.com/bucket/key?partNumber=1&uploadId=xyz',
-            headers: { 'content-type': 'application/octet-stream' },
-            body: Buffer.from('test-data'),
-            credentials: mockCredentials,
-            service: 'tos',
-            region: 'cn-i-alisg',
-            datetime: '20260325T120000Z',
-        };
-        const h1 = computeAws4Headers(opts);
-        const h2 = computeAws4Headers(opts);
-        expect(h1['Authorization']).toBe(h2['Authorization']);
-    });
-});

package/clis/douyin/_shared/transcode.test.js

@@ -1,91 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { TimeoutError } from '@sovovs/bycli/errors';
-import { pollTranscodeWithFetch } from './transcode.js';
-// ── Helpers ──────────────────────────────────────────────────────────────────
-function makePage() {
-    return {
-        goto: vi.fn(),
-        evaluate: vi.fn(),
-        getCookies: vi.fn(),
-        snapshot: vi.fn(),
-        click: vi.fn(),
-        typeText: vi.fn(),
-        pressKey: vi.fn(),
-        scrollTo: vi.fn(),
-        getFormState: vi.fn(),
-        wait: vi.fn(),
-        tabs: vi.fn(),
-        selectTab: vi.fn(),
-        networkRequests: vi.fn(),
-        consoleMessages: vi.fn(),
-        scroll: vi.fn(),
-        autoScroll: vi.fn(),
-        installInterceptor: vi.fn(),
-        getInterceptedRequests: vi.fn(),
-        screenshot: vi.fn(),
-    };
-}
-const COMPLETE_RESULT = {
-    encode: 2,
-    duration: 30,
-    fps: 30,
-    height: 1920,
-    width: 1080,
-    poster_uri: 'tos-cn-i-alisg.volces.com/poster/abc',
-    poster_url: 'https://p3-creator.douyinpic.com/poster/abc',
-};
-// ── Tests ─────────────────────────────────────────────────────────────────────
-describe('pollTranscodeWithFetch', () => {
-    it('returns TranscodeResult immediately when first response has encode=2', async () => {
-        const fetchFn = vi.fn().mockResolvedValue(COMPLETE_RESULT);
-        const page = makePage();
-        const result = await pollTranscodeWithFetch(fetchFn, page, 'vid_123');
-        expect(result).toEqual(COMPLETE_RESULT);
-        expect(fetchFn).toHaveBeenCalledOnce();
-        const [, method, url] = fetchFn.mock.calls[0];
-        expect(method).toBe('GET');
-        expect(url).toContain('video_id=vid_123');
-        expect(url).toContain('aid=1128');
-    });
-    it('polls multiple times until encode=2 is received', async () => {
-        const pending = { encode: 1, duration: 0, fps: 0, height: 0, width: 0, poster_uri: '', poster_url: '' };
-        const fetchFn = vi
-            .fn()
-            .mockResolvedValueOnce(pending)
-            .mockResolvedValueOnce(pending)
-            .mockResolvedValueOnce(COMPLETE_RESULT);
-        const page = makePage();
-        // Use a large timeoutMs so it doesn't expire, but override POLL_INTERVAL via
-        // a short timeout knowing we'll get 3 calls quickly with mocked promises.
-        // Since pollTranscodeWithFetch uses setTimeout for 3s between polls, we need
-        // to mock timers to keep tests fast.
-        vi.useFakeTimers();
-        const resultPromise = pollTranscodeWithFetch(fetchFn, page, 'vid_456', 60_000);
-        // Advance timers for each pending poll cycle
-        await vi.runAllTimersAsync();
-        const result = await resultPromise;
-        expect(result).toEqual(COMPLETE_RESULT);
-        expect(fetchFn).toHaveBeenCalledTimes(3);
-        vi.useRealTimers();
-    });
-    it('throws TimeoutError when encode never becomes 2 within timeoutMs', async () => {
-        const pending = { encode: 1, duration: 0, fps: 0, height: 0, width: 0, poster_uri: '', poster_url: '' };
-        const fetchFn = vi.fn().mockResolvedValue(pending);
-        const page = makePage();
-        vi.useFakeTimers();
-        const resultPromise = pollTranscodeWithFetch(fetchFn, page, 'vid_789', 5_000);
-        // Suppress unhandled-rejection so vitest doesn't flag it
-        resultPromise.catch(() => undefined);
-        // Advance time past the 5s timeout
-        await vi.runAllTimersAsync();
-        await expect(resultPromise).rejects.toBeInstanceOf(TimeoutError);
-        vi.useRealTimers();
-    });
-    it('URL encodes video_id in the request URL', async () => {
-        const fetchFn = vi.fn().mockResolvedValue(COMPLETE_RESULT);
-        const page = makePage();
-        await pollTranscodeWithFetch(fetchFn, page, 'vid with spaces');
-        const [, , url] = fetchFn.mock.calls[0];
-        expect(url).toContain('video_id=vid%20with%20spaces');
-    });
-});

package/clis/douyin/_shared/vod-upload.test.js

@@ -1,38 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { AuthRequiredError, CommandExecutionError } from '@sovovs/bycli/errors';
-import { getUploadAuthV5Credentials, applyVideoUploadInner } from './vod-upload.js';
-
-describe('douyin vod upload helpers', () => {
-  it('parses creator upload auth v5 credentials', async () => {
-    const page = { evaluate: async () => ({ status_code: 0, auth: JSON.stringify({ AccessKeyID: 'ak', SecretAccessKey: 'sk', SessionToken: 'token', ExpiredTime: 123, CurrentTime: 100 }) }) };
-    await expect(getUploadAuthV5Credentials(page)).resolves.toEqual({ access_key_id: 'ak', secret_access_key: 'sk', session_token: 'token', user_id: '', expired_time: 123, current_time: 100 });
-  });
-
-  it('unwraps browser bridge envelopes around upload auth payloads', async () => {
-    const payload = { status_code: 0, auth: JSON.stringify({ AccessKeyID: 'ak', SecretAccessKey: 'sk', SessionToken: 'token' }) };
-    const page = { evaluate: async () => ({ session: 'site:douyin:test', data: payload }) };
-    await expect(getUploadAuthV5Credentials(page)).resolves.toMatchObject({ access_key_id: 'ak', secret_access_key: 'sk', session_token: 'token' });
-  });
-
-  it('maps upload auth permission errors to AuthRequiredError', async () => {
-    const page = { evaluate: async () => ({ status_code: 401, status_msg: 'login required' }) };
-    await expect(getUploadAuthV5Credentials(page)).rejects.toBeInstanceOf(AuthRequiredError);
-  });
-
-  it('maps ApplyUploadInner response to TOS upload info', async () => {
-    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue({ ok: true, status: 200, text: async () => JSON.stringify({ ResponseMetadata: { RequestId: 'req' }, Result: { InnerUploadAddress: { UploadNodes: [{ Vid: 'video-id', SessionKey: 'session-key', UploadHost: 'tos.example.com', StoreInfos: [{ StoreUri: 'obj/key.mp4', Auth: 'space-auth' }] }] } } }) });
-    await expect(applyVideoUploadInner(1234, { access_key_id: 'ak', secret_access_key: 'sk', session_token: 'token' })).resolves.toEqual({ video_id: 'video-id', tos_upload_url: 'https://tos.example.com/obj/key.mp4', auth: 'space-auth', session_key: 'session-key', upload_header: {}, user_id: '' });
-    const [url, init] = fetchSpy.mock.calls[0];
-    expect(String(url)).toContain('Action=ApplyUploadInner');
-    expect(String(url)).toContain('Version=2020-11-19');
-    expect(init.headers.Authorization).toContain('AWS4-HMAC-SHA256 Credential=ak/');
-    expect(init.headers['x-amz-security-token']).toBe('token');
-    fetchSpy.mockRestore();
-  });
-
-  it('surfaces VOD API errors with context', async () => {
-    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockResolvedValue({ ok: true, status: 200, text: async () => JSON.stringify({ ResponseMetadata: { Error: { Code: 'AccessDenied', Message: 'denied' } } }) });
-    await expect(applyVideoUploadInner(1234, { access_key_id: 'ak', secret_access_key: 'sk', session_token: 'token' })).rejects.toBeInstanceOf(CommandExecutionError);
-    fetchSpy.mockRestore();
-  });
-});

package/clis/douyin/activities.test.js

@@ -1,55 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const { browserFetchMock } = vi.hoisted(() => ({
-    browserFetchMock: vi.fn(),
-}));
-vi.mock('./_shared/browser-fetch.js', () => ({
-    browserFetch: browserFetchMock,
-}));
-import { getRegistry } from '@sovovs/bycli/registry';
-import './activities.js';
-describe('douyin activities registration', () => {
-    beforeEach(() => {
-        browserFetchMock.mockReset();
-    });
-    it('registers the activities command', () => {
-        const registry = getRegistry();
-        const cmd = [...registry.values()].find(c => c.site === 'douyin' && c.name === 'activities');
-        expect(cmd).toBeDefined();
-    });
-    it('has expected columns', () => {
-        const registry = getRegistry();
-        const cmd = [...registry.values()].find(c => c.site === 'douyin' && c.name === 'activities');
-        expect(cmd?.columns).toContain('activity_id');
-        expect(cmd?.columns).toContain('title');
-        expect(cmd?.columns).toContain('end_time');
-    });
-    it('uses COOKIE strategy', () => {
-        const registry = getRegistry();
-        const cmd = [...registry.values()].find(c => c.site === 'douyin' && c.name === 'activities');
-        expect(cmd?.strategy).toBe('cookie');
-    });
-    it('maps the current activity payload shape returned by creator center', async () => {
-        const registry = getRegistry();
-        const cmd = [...registry.values()].find(c => c.site === 'douyin' && c.name === 'activities');
-        expect(cmd?.func).toBeDefined();
-        if (!cmd?.func)
-            throw new Error('douyin activities command not registered');
-        browserFetchMock.mockResolvedValueOnce({
-            activity_list: [
-                {
-                    activity_id: '200',
-                    activity_name: '超会玩派对',
-                    show_end_time: '2026.05.31',
-                },
-            ],
-        });
-        const rows = await cmd.func({}, {});
-        expect(rows).toEqual([
-            {
-                activity_id: '200',
-                title: '超会玩派对',
-                end_time: '2026.05.31',
-            },
-        ]);
-    });
-});

package/clis/douyin/collections.test.js

@@ -1,45 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
-const { browserFetchMock } = vi.hoisted(() => ({
-    browserFetchMock: vi.fn(),
-}));
-vi.mock('./_shared/browser-fetch.js', () => ({
-    browserFetch: browserFetchMock,
-}));
-import { getRegistry } from '@sovovs/bycli/registry';
-import './collections.js';
-describe('douyin collections', () => {
-    beforeEach(() => {
-        browserFetchMock.mockReset();
-    });
-    it('registers the collections command', () => {
-        const registry = getRegistry();
-        const cmd = [...registry.values()].find(c => c.site === 'douyin' && c.name === 'collections');
-        expect(cmd).toBeDefined();
-        expect(cmd?.args.some(a => a.name === 'limit')).toBe(true);
-    });
-    it('has expected columns', () => {
-        const registry = getRegistry();
-        const cmd = [...registry.values()].find(c => c.site === 'douyin' && c.name === 'collections');
-        expect(cmd?.columns).toContain('mix_id');
-        expect(cmd?.columns).toContain('name');
-        expect(cmd?.columns).toContain('item_count');
-    });
-    it('uses COOKIE strategy', () => {
-        const registry = getRegistry();
-        const cmd = [...registry.values()].find(c => c.site === 'douyin' && c.name === 'collections');
-        expect(cmd?.strategy).toBe('cookie');
-    });
-    it('uses the current mix list request shape', async () => {
-        const registry = getRegistry();
-        const command = [...registry.values()].find((cmd) => cmd.site === 'douyin' && cmd.name === 'collections');
-        expect(command?.func).toBeDefined();
-        if (!command?.func)
-            throw new Error('douyin collections command not registered');
-        browserFetchMock.mockResolvedValueOnce({
-            mix_list: [],
-        });
-        const rows = await command.func({}, { limit: 12 });
-        expect(browserFetchMock).toHaveBeenCalledWith({}, 'GET', 'https://creator.douyin.com/web/api/mix/list/?status=0,1,2,3,6&count=12&cursor=0&should_query_new_mix=1&device_platform=web&aid=1128');
-        expect(rows).toEqual([]);
-    });
-});