wehub-resource-sync
9b395f5cc3
E2E Headed Chrome / e2e-headed (macos-15) (push) Has been cancelled
E2E Headed Chrome / e2e-headed (ubuntu-latest) (push) Has been cancelled
E2E Headed Chrome / e2e-headed (windows-latest) (push) Has been cancelled
CI / build (macos-latest) (push) Has been cancelled
CI / build (ubuntu-latest) (push) Has been cancelled
CI / build (windows-latest) (push) Has been cancelled
CI / unit-test (push) Has been cancelled
CI / bun-test (push) Has been cancelled
CI / adapter-test (push) Has been cancelled
CI / smoke-test (macos-latest) (push) Has been cancelled
CI / smoke-test (ubuntu-latest) (push) Has been cancelled
Security Audit / audit (push) Has been cancelled
Build Chrome Extension / build (push) Has been cancelled
Trigger Website Rebuild (Docs Updated) / dispatch (push) Has been cancelled
371 lines
18 KiB
JavaScript
371 lines
18 KiB
JavaScript
// Contract tests for the Phase-3 P0.5 refactor that retired the legacy
|
|
// pipeline-based silent-failure pattern across comment / follow / unfollow.
|
|
//
|
|
// Each adapter is now `func + Strategy.COOKIE + browser:true` with a
|
|
// shared button-walker helper bundle from utils.js. These tests pin
|
|
// down (a) registration metadata, (b) typed-error boundary, including
|
|
// the retryable-hint contract that distinguishes server-fan-out
|
|
// (comment) from idempotent client-safe (follow / unfollow) failures,
|
|
// (c) build-script invariants — sentinels, login + rate-limit guards,
|
|
// expected button labels and selectors.
|
|
|
|
import { describe, expect, it, vi } from 'vitest';
|
|
import {
|
|
ArgumentError,
|
|
AuthRequiredError,
|
|
CommandExecutionError,
|
|
} from '@jackwener/opencli/errors';
|
|
import { commentCommand, __test__ as commentTest } from './comment.js';
|
|
import { followCommand, __test__ as followTest } from './follow.js';
|
|
import { unfollowCommand, __test__ as unfollowTest } from './unfollow.js';
|
|
import {
|
|
BUTTON_WALKER_HELPERS,
|
|
BUTTON_WALKER_SENTINELS,
|
|
COMMENT_TEXT_MAX,
|
|
RETRYABLE_HINTS,
|
|
parseTikTokVideoUrl,
|
|
requireCommentText,
|
|
throwButtonWalkerError,
|
|
} from './utils.js';
|
|
|
|
function makePage(rows) {
|
|
return {
|
|
goto: vi.fn().mockResolvedValue(undefined),
|
|
wait: vi.fn().mockResolvedValue(undefined),
|
|
evaluate: vi.fn().mockResolvedValue(rows),
|
|
};
|
|
}
|
|
|
|
function makeFailingPage(error) {
|
|
return {
|
|
goto: vi.fn().mockResolvedValue(undefined),
|
|
wait: vi.fn().mockResolvedValue(undefined),
|
|
evaluate: vi.fn().mockRejectedValue(error),
|
|
};
|
|
}
|
|
|
|
function makeGotoFailingPage(error) {
|
|
return {
|
|
goto: vi.fn().mockRejectedValue(error),
|
|
wait: vi.fn().mockResolvedValue(undefined),
|
|
evaluate: vi.fn(),
|
|
};
|
|
}
|
|
|
|
const VIDEO_URL = 'https://www.tiktok.com/@creator/video/7350000000000000000';
|
|
|
|
const sampleCommentRow = { url: VIDEO_URL, text: 'great clip', result: 'posted' };
|
|
const sampleFollowRow = { username: 'creator', url: 'https://www.tiktok.com/@creator', result: 'followed' };
|
|
const sampleUnfollowRow = { username: 'creator', url: 'https://www.tiktok.com/@creator', result: 'unfollowed' };
|
|
|
|
describe('tiktok/utils (P0.5 button-walker additions)', () => {
|
|
it('requireCommentText rejects empty / whitespace / overlong with ArgumentError', () => {
|
|
expect(() => requireCommentText('')).toThrow(ArgumentError);
|
|
expect(() => requireCommentText(' ')).toThrow(ArgumentError);
|
|
expect(() => requireCommentText(undefined)).toThrow(ArgumentError);
|
|
expect(() => requireCommentText('x'.repeat(COMMENT_TEXT_MAX + 1))).toThrow(ArgumentError);
|
|
expect(requireCommentText(' hello ')).toBe('hello');
|
|
expect(requireCommentText('x'.repeat(COMMENT_TEXT_MAX))).toHaveLength(COMMENT_TEXT_MAX);
|
|
});
|
|
|
|
it('parseTikTokVideoUrl rejects non-tiktok / bad shape and accepts canonical URL', () => {
|
|
expect(() => parseTikTokVideoUrl('')).toThrow(ArgumentError);
|
|
expect(() => parseTikTokVideoUrl('not a url')).toThrow(ArgumentError);
|
|
expect(() => parseTikTokVideoUrl('https://example.com/@u/video/123')).toThrow(ArgumentError);
|
|
expect(() => parseTikTokVideoUrl('https://www.tiktok.com/@user/photo/123')).toThrow(ArgumentError);
|
|
expect(() => parseTikTokVideoUrl('https://www.tiktok.com/@user/video/123abc')).toThrow(ArgumentError);
|
|
expect(() => parseTikTokVideoUrl('https://www.tiktok.com/@user/video/123/extra')).toThrow(ArgumentError);
|
|
expect(() => parseTikTokVideoUrl('https://vm.tiktok.com/abc')).toThrow(ArgumentError);
|
|
const parsed = parseTikTokVideoUrl(VIDEO_URL);
|
|
expect(parsed.username).toBe('creator');
|
|
expect(parsed.videoId).toBe('7350000000000000000');
|
|
expect(parsed.url).toBe(VIDEO_URL);
|
|
// accepts a trailing slash plus query string, but not extra path segments
|
|
expect(parseTikTokVideoUrl(`${VIDEO_URL}/?lang=en`).videoId).toBe('7350000000000000000');
|
|
});
|
|
|
|
it('BUTTON_WALKER_SENTINELS exposes the 4 sentinel strings used by IIFEs', () => {
|
|
expect(BUTTON_WALKER_SENTINELS.AUTH_REQUIRED).toBe('AUTH_REQUIRED');
|
|
expect(BUTTON_WALKER_SENTINELS.BUTTON_NOT_FOUND).toBe('BUTTON_NOT_FOUND');
|
|
expect(BUTTON_WALKER_SENTINELS.STATE_VERIFY_FAIL).toBe('STATE_VERIFY_FAIL');
|
|
expect(BUTTON_WALKER_SENTINELS.RATE_LIMITED).toBe('RATE_LIMITED');
|
|
});
|
|
|
|
it('RETRYABLE_HINTS encodes retryable=true|false plus reason in human-readable form', () => {
|
|
expect(RETRYABLE_HINTS.commentFailure).toMatch(/retryable=false/);
|
|
expect(RETRYABLE_HINTS.commentFailure).toMatch(/server-fan-out/);
|
|
expect(RETRYABLE_HINTS.relationFailure).toMatch(/retryable=true/);
|
|
expect(RETRYABLE_HINTS.relationFailure).toMatch(/idempotent/);
|
|
});
|
|
|
|
it('BUTTON_WALKER_HELPERS string template exposes the expected helper names', () => {
|
|
expect(typeof BUTTON_WALKER_HELPERS).toBe('string');
|
|
for (const name of [
|
|
'checkLoggedIn',
|
|
'findButtonByText',
|
|
'buttonExists',
|
|
'detectRateLimitPopup',
|
|
'waitFor',
|
|
'ensureLoggedInOrThrow',
|
|
'ensureNoRateLimitOrThrow',
|
|
]) {
|
|
expect(BUTTON_WALKER_HELPERS).toContain('function ' + name + '(');
|
|
}
|
|
});
|
|
|
|
it('throwButtonWalkerError maps AUTH_REQUIRED-shaped messages to AuthRequiredError', () => {
|
|
expect(() => throwButtonWalkerError(new Error('AUTH_REQUIRED: login required'), {
|
|
authMessage: 'login pls',
|
|
failureMessage: 'op failed',
|
|
retryableHint: RETRYABLE_HINTS.relationFailure,
|
|
})).toThrow(AuthRequiredError);
|
|
});
|
|
|
|
it('throwButtonWalkerError keeps captcha / rate-limit as retryable CommandExecutionError, not AuthRequiredError', () => {
|
|
for (const message of [
|
|
'RATE_LIMITED: TikTok rate limit / captcha detected',
|
|
'captcha verification needed',
|
|
'Too many requests, try again later',
|
|
]) {
|
|
try {
|
|
throwButtonWalkerError(new Error(message), {
|
|
authMessage: 'login pls',
|
|
failureMessage: 'op failed',
|
|
retryableHint: RETRYABLE_HINTS.relationFailure,
|
|
});
|
|
throw new Error('should have thrown');
|
|
} catch (err) {
|
|
expect(err).toBeInstanceOf(CommandExecutionError);
|
|
expect(err.hint).toMatch(/retryable=true/);
|
|
}
|
|
}
|
|
});
|
|
|
|
it('throwButtonWalkerError maps everything else to CommandExecutionError with retryable hint', () => {
|
|
try {
|
|
throwButtonWalkerError(new Error('BUTTON_NOT_FOUND: missing'), {
|
|
authMessage: 'a',
|
|
failureMessage: 'op failed',
|
|
retryableHint: RETRYABLE_HINTS.commentFailure,
|
|
});
|
|
throw new Error('should have thrown');
|
|
} catch (err) {
|
|
expect(err).toBeInstanceOf(CommandExecutionError);
|
|
expect(err.message).toMatch(/op failed: BUTTON_NOT_FOUND/);
|
|
expect(err.hint).toMatch(/retryable=false/);
|
|
}
|
|
try {
|
|
throwButtonWalkerError(new Error('STATE_VERIFY_FAIL: did not flip'), {
|
|
authMessage: 'login pls',
|
|
failureMessage: 'op failed',
|
|
retryableHint: RETRYABLE_HINTS.relationFailure,
|
|
});
|
|
throw new Error('should have thrown');
|
|
} catch (err) {
|
|
expect(err).toBeInstanceOf(CommandExecutionError);
|
|
expect(err.hint).toMatch(/retryable=true/);
|
|
}
|
|
});
|
|
});
|
|
|
|
describe('tiktok/comment (Route 1 button-walker refactor)', () => {
|
|
it('registers as write-access COOKIE browser adapter with url/text/result columns', () => {
|
|
expect(commentCommand.access).toBe('write');
|
|
expect(commentCommand.browser).toBe(true);
|
|
expect(commentCommand.strategy).toBe('cookie');
|
|
expect(commentCommand.columns).toEqual(['url', 'text', 'result']);
|
|
});
|
|
|
|
it('validates --url and --text upfront before navigating', async () => {
|
|
const page = makePage([sampleCommentRow]);
|
|
await expect(commentCommand.func(page, { url: '', text: 'hi' })).rejects.toBeInstanceOf(ArgumentError);
|
|
await expect(commentCommand.func(page, { url: VIDEO_URL, text: '' })).rejects.toBeInstanceOf(ArgumentError);
|
|
await expect(commentCommand.func(page, { url: 'https://example.com/x', text: 'hi' })).rejects.toBeInstanceOf(ArgumentError);
|
|
await expect(commentCommand.func(page, { url: VIDEO_URL, text: 'x'.repeat(COMMENT_TEXT_MAX + 1) })).rejects.toBeInstanceOf(ArgumentError);
|
|
expect(page.goto).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('navigates to the canonical video URL and returns the row from evaluate', async () => {
|
|
const page = makePage([sampleCommentRow]);
|
|
const rows = await commentCommand.func(page, { url: VIDEO_URL, text: 'great clip' });
|
|
expect(page.goto).toHaveBeenCalledWith(VIDEO_URL, { waitUntil: 'load', settleMs: 6000 });
|
|
expect(rows).toEqual([sampleCommentRow]);
|
|
});
|
|
|
|
it('maps page-evaluate errors to typed errors with comment retryable=false hint', async () => {
|
|
await expect(commentCommand.func(
|
|
makeFailingPage(new Error('AUTH_REQUIRED: TikTok login required')),
|
|
{ url: VIDEO_URL, text: 'hi' },
|
|
)).rejects.toBeInstanceOf(AuthRequiredError);
|
|
try {
|
|
await commentCommand.func(
|
|
makeFailingPage(new Error('STATE_VERIFY_FAIL: comment count did not increase')),
|
|
{ url: VIDEO_URL, text: 'hi' },
|
|
);
|
|
throw new Error('should have thrown');
|
|
} catch (err) {
|
|
expect(err).toBeInstanceOf(CommandExecutionError);
|
|
expect(err.message).toMatch(/Failed to post comment/);
|
|
expect(err.hint).toMatch(/retryable=false/);
|
|
expect(err.hint).toMatch(/server-fan-out/);
|
|
}
|
|
});
|
|
|
|
it('maps navigation failures and empty evaluate rows to CommandExecutionError', async () => {
|
|
await expect(commentCommand.func(
|
|
makeGotoFailingPage(new Error('net::ERR_ABORTED')),
|
|
{ url: VIDEO_URL, text: 'hi' },
|
|
)).rejects.toBeInstanceOf(CommandExecutionError);
|
|
await expect(commentCommand.func(
|
|
makePage([]),
|
|
{ url: VIDEO_URL, text: 'hi' },
|
|
)).rejects.toBeInstanceOf(CommandExecutionError);
|
|
});
|
|
|
|
it('build script embeds text via JSON.stringify and calls login + rate-limit guards', () => {
|
|
const script = commentTest.buildCommentScript('he said "hi"\nbye');
|
|
expect(script).toContain('const commentText = "he said \\"hi\\"\\nbye";');
|
|
expect(script).toContain('ensureLoggedInOrThrow()');
|
|
expect(script).toContain('ensureNoRateLimitOrThrow()');
|
|
expect(script).toContain('STATE_VERIFY_FAIL');
|
|
expect(script).toContain('BUTTON_NOT_FOUND');
|
|
expect(script).toContain('[data-e2e="comment-input"]');
|
|
expect(script).toContain('[data-e2e="comment-level-1"]');
|
|
expect(script).toContain("['Post', '发布', '发送']");
|
|
});
|
|
});
|
|
|
|
describe('tiktok/follow (Route 1 button-walker refactor)', () => {
|
|
it('registers as write-access COOKIE browser adapter with username/url/result columns', () => {
|
|
expect(followCommand.access).toBe('write');
|
|
expect(followCommand.browser).toBe(true);
|
|
expect(followCommand.strategy).toBe('cookie');
|
|
expect(followCommand.columns).toEqual(['username', 'url', 'result']);
|
|
});
|
|
|
|
it('validates username upfront before navigating', async () => {
|
|
const page = makePage([sampleFollowRow]);
|
|
await expect(followCommand.func(page, { username: '' })).rejects.toBeInstanceOf(ArgumentError);
|
|
await expect(followCommand.func(page, { username: 'bad name' })).rejects.toBeInstanceOf(ArgumentError);
|
|
expect(page.goto).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('navigates to /@username (with @ stripped) and returns the row from evaluate', async () => {
|
|
const page = makePage([sampleFollowRow]);
|
|
const rows = await followCommand.func(page, { username: '@creator' });
|
|
expect(page.goto).toHaveBeenCalledWith('https://www.tiktok.com/@creator', { waitUntil: 'load', settleMs: 5000 });
|
|
expect(rows).toEqual([sampleFollowRow]);
|
|
});
|
|
|
|
it('maps AUTH_REQUIRED to AuthRequiredError; other failures get retryable=true hint', async () => {
|
|
await expect(followCommand.func(
|
|
makeFailingPage(new Error('AUTH_REQUIRED: TikTok login required')),
|
|
{ username: 'creator' },
|
|
)).rejects.toBeInstanceOf(AuthRequiredError);
|
|
try {
|
|
await followCommand.func(
|
|
makeFailingPage(new Error('STATE_VERIFY_FAIL: follow button did not flip')),
|
|
{ username: 'creator' },
|
|
);
|
|
throw new Error('should have thrown');
|
|
} catch (err) {
|
|
expect(err).toBeInstanceOf(CommandExecutionError);
|
|
expect(err.message).toMatch(/Failed to follow @creator/);
|
|
expect(err.hint).toMatch(/retryable=true/);
|
|
expect(err.hint).toMatch(/idempotent/);
|
|
}
|
|
});
|
|
|
|
it('maps navigation failures and empty evaluate rows to retryable CommandExecutionError', async () => {
|
|
await expect(followCommand.func(
|
|
makeGotoFailingPage(new Error('Execution context was destroyed')),
|
|
{ username: 'creator' },
|
|
)).rejects.toBeInstanceOf(CommandExecutionError);
|
|
await expect(followCommand.func(
|
|
makePage([]),
|
|
{ username: 'creator' },
|
|
)).rejects.toMatchObject({ hint: expect.stringMatching(/retryable=true/) });
|
|
});
|
|
|
|
it('build script embeds username via JSON.stringify and pins all relation labels', () => {
|
|
const script = followTest.buildFollowScript('creator');
|
|
expect(script).toContain('const username = "creator";');
|
|
expect(script).toContain('ensureLoggedInOrThrow()');
|
|
expect(script).toContain('ensureNoRateLimitOrThrow()');
|
|
expect(script).toContain("'Follow', '关注'");
|
|
expect(script).toContain("'Following', '已关注'");
|
|
expect(script).toContain("'Friends', '互关'");
|
|
expect(script).toContain("'already-following'");
|
|
expect(script).toContain("'already-friends'");
|
|
expect(script).toContain("result: 'followed'");
|
|
expect(script).not.toContain('becameFriends ?');
|
|
expect(script).toContain('STATE_VERIFY_FAIL');
|
|
expect(script).toContain('BUTTON_NOT_FOUND');
|
|
});
|
|
});
|
|
|
|
describe('tiktok/unfollow (Route 1 button-walker refactor)', () => {
|
|
it('registers as write-access COOKIE browser adapter with username/url/result columns', () => {
|
|
expect(unfollowCommand.access).toBe('write');
|
|
expect(unfollowCommand.browser).toBe(true);
|
|
expect(unfollowCommand.strategy).toBe('cookie');
|
|
expect(unfollowCommand.columns).toEqual(['username', 'url', 'result']);
|
|
});
|
|
|
|
it('validates username upfront before navigating', async () => {
|
|
const page = makePage([sampleUnfollowRow]);
|
|
await expect(unfollowCommand.func(page, { username: '' })).rejects.toBeInstanceOf(ArgumentError);
|
|
await expect(unfollowCommand.func(page, { username: 'bad/name' })).rejects.toBeInstanceOf(ArgumentError);
|
|
expect(page.goto).not.toHaveBeenCalled();
|
|
});
|
|
|
|
it('navigates to /@username and returns the row from evaluate', async () => {
|
|
const page = makePage([sampleUnfollowRow]);
|
|
const rows = await unfollowCommand.func(page, { username: 'creator' });
|
|
expect(page.goto).toHaveBeenCalledWith('https://www.tiktok.com/@creator', { waitUntil: 'load', settleMs: 5000 });
|
|
expect(rows).toEqual([sampleUnfollowRow]);
|
|
});
|
|
|
|
it('maps AUTH_REQUIRED to AuthRequiredError; other failures get retryable=true hint', async () => {
|
|
await expect(unfollowCommand.func(
|
|
makeFailingPage(new Error('AUTH_REQUIRED: login required')),
|
|
{ username: 'creator' },
|
|
)).rejects.toBeInstanceOf(AuthRequiredError);
|
|
try {
|
|
await unfollowCommand.func(
|
|
makeFailingPage(new Error('STATE_VERIFY_FAIL: relation did not flip back')),
|
|
{ username: 'creator' },
|
|
);
|
|
throw new Error('should have thrown');
|
|
} catch (err) {
|
|
expect(err).toBeInstanceOf(CommandExecutionError);
|
|
expect(err.message).toMatch(/Failed to unfollow @creator/);
|
|
expect(err.hint).toMatch(/retryable=true/);
|
|
expect(err.hint).toMatch(/idempotent/);
|
|
}
|
|
});
|
|
|
|
it('maps navigation failures and empty evaluate rows to retryable CommandExecutionError', async () => {
|
|
await expect(unfollowCommand.func(
|
|
makeGotoFailingPage(new Error('Execution context was destroyed')),
|
|
{ username: 'creator' },
|
|
)).rejects.toBeInstanceOf(CommandExecutionError);
|
|
await expect(unfollowCommand.func(
|
|
makePage([]),
|
|
{ username: 'creator' },
|
|
)).rejects.toMatchObject({ hint: expect.stringMatching(/retryable=true/) });
|
|
});
|
|
|
|
it('build script handles confirm-dialog flow + flips back to Follow', () => {
|
|
const script = unfollowTest.buildUnfollowScript('creator');
|
|
expect(script).toContain('const username = "creator";');
|
|
expect(script).toContain('ensureLoggedInOrThrow()');
|
|
expect(script).toContain('ensureNoRateLimitOrThrow()');
|
|
expect(script).toContain("'Unfollow', '取消关注'");
|
|
expect(script).toContain("'already-not-following'");
|
|
expect(script).toContain("'unfollowed'");
|
|
expect(script).toContain('STATE_VERIFY_FAIL');
|
|
expect(script).toContain('BUTTON_NOT_FOUND');
|
|
});
|
|
});
|