yuta/bird
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Use twitter safe relay
CI / test (pull_request) Has been cancelled
Details

Browse Source
This commit is contained in:
yuta
2026-06-24 03:39:34 +09:00
parent b771e827aa
commit 1f6e228272
66 changed files with 597 additions and 1720 deletions
Download Patch File Download Diff File Expand all files Collapse all files
tests/commands.bookmarks.test.ts
+1 -4
View File
@@ -8,10 +8,7 @@ describe('bookmarks command', () => {
const program = new Command();
const ctx = {
resolveTimeoutFromOptions: () => undefined,
resolveCredentialsFromOptions: async () => ({
cookies: { authToken: 'auth', ct0: 'ct0', cookieHeader: 'auth=auth; ct0=ct0' },
warnings: [],
}),
resolveRelayBaseUrlFromOptions: () => 'https://relay.example',
p: () => '',
printTweets: () => undefined,
} as unknown as CliContext;
tests/commands.news.test.ts
+1 -33
View File
@@ -13,14 +13,7 @@ describe('news command', () => {
mockContext = {
resolveTimeoutFromOptions: () => 30000,
resolveQuoteDepthFromOptions: () => undefined,
resolveCredentialsFromOptions: async () => ({
cookies: {
authToken: 'auth',
ct0: 'ct0',
cookieHeader: 'auth=auth; ct0=ct0',
},
warnings: [],
}),
resolveRelayBaseUrlFromOptions: () => 'https://relay.example',
p: (type: string) => `[${type}] `,
colors: {
accent: (text: string) => text,
@@ -128,31 +121,6 @@ describe('news command', () => {
}
});
it('requires both authToken and ct0 credentials', async () => {
mockContext.resolveCredentialsFromOptions = async () => ({
cookies: {
authToken: '',
ct0: '',
cookieHeader: '',
},
warnings: [],
});
registerNewsCommand(program, mockContext as CliContext);
const exitSpy = vi.spyOn(process, 'exit').mockImplementation(((code?: number) => {
throw new Error(`exit ${code}`);
}) as never);
const errorSpy = vi.spyOn(console, 'error').mockImplementation(() => undefined);
try {
await expect(program.parseAsync(['node', 'bird', 'news'])).rejects.toThrow('exit 1');
expect(errorSpy).toHaveBeenCalledWith(expect.stringContaining('Missing required credentials'));
} finally {
exitSpy.mockRestore();
errorSpy.mockRestore();
}
});
it('limits related tweets to tweets-per-item in CLI output', async () => {
registerNewsCommand(program, mockContext as CliContext);
const getNewsSpy = vi.spyOn(TwitterClient.prototype, 'getNews').mockResolvedValue({
tests/commands.read.test.ts
+2 -8
View File
@@ -10,10 +10,7 @@ describe('replies command', () => {
resolveTimeoutFromOptions: () => undefined,
resolveQuoteDepthFromOptions: () => 1,
extractTweetId: (input: string) => input,
resolveCredentialsFromOptions: async () => ({
cookies: { authToken: 'auth', ct0: 'ct0', cookieHeader: 'auth=auth; ct0=ct0' },
warnings: [],
}),
resolveRelayBaseUrlFromOptions: () => 'https://relay.example',
p: () => '',
printTweets: () => undefined,
printTweetsResult: () => undefined,
@@ -85,10 +82,7 @@ describe('thread command', () => {
resolveTimeoutFromOptions: () => undefined,
resolveQuoteDepthFromOptions: () => 1,
extractTweetId: (input: string) => input,
resolveCredentialsFromOptions: async () => ({
cookies: { authToken: 'auth', ct0: 'ct0', cookieHeader: 'auth=auth; ct0=ct0' },
warnings: [],
}),
resolveRelayBaseUrlFromOptions: () => 'https://relay.example',
p: () => '',
printTweets: () => undefined,
printTweetsResult: () => undefined,
tests/commands.search.test.ts
+1 -4
View File
@@ -13,10 +13,7 @@ describe('search command', () => {
mockContext = {
resolveTimeoutFromOptions: () => undefined,
resolveQuoteDepthFromOptions: () => undefined,
resolveCredentialsFromOptions: async () => ({
cookies: { authToken: 'auth', ct0: 'ct0', cookieHeader: 'auth=auth; ct0=ct0' },
warnings: [],
}),
resolveRelayBaseUrlFromOptions: () => 'https://relay.example',
p: () => '',
printTweetsResult: vi.fn(),
};
tests/commands.users.test.ts
+1 -4
View File
@@ -6,10 +6,7 @@ import { TwitterClient } from '../src/lib/twitter-client.js';
const baseCtx = {
resolveTimeoutFromOptions: () => undefined,
resolveCredentialsFromOptions: async () => ({
cookies: { authToken: 'auth', ct0: 'ct0', cookieHeader: 'auth=auth; ct0=ct0' },
warnings: [],
}),
resolveRelayBaseUrlFromOptions: () => 'https://relay.example',
p: () => '',
printTweets: () => undefined,
} as unknown as CliContext;
tests/cookies.test.ts
-381
View File
@@ -1,381 +0,0 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
type SweetCookieResult = { cookies: Array<{ name: string; value: string; domain?: string }>; warnings: string[] };
const sweet = vi.hoisted(() => ({
results: new Map<string, SweetCookieResult>(),
options: new Map<string, { timeoutMs?: number }>(),
}));
vi.mock('@steipete/sweet-cookie', () => ({
getCookies: vi.fn(async (options: { browsers?: string[]; timeoutMs?: number }) => {
const browser = options.browsers?.[0] ?? 'unknown';
sweet.options.set(browser, options);
return (
sweet.results.get(browser) ?? {
cookies: [],
warnings: [],
}
);
}),
}));
describe('cookies', () => {
const originalEnv = process.env;
beforeEach(() => {
vi.resetModules();
sweet.results.clear();
sweet.options.clear();
process.env = { ...originalEnv };
process.env.AUTH_TOKEN = undefined;
process.env.TWITTER_AUTH_TOKEN = undefined;
process.env.CT0 = undefined;
process.env.TWITTER_CT0 = undefined;
});
afterEach(() => {
process.env = originalEnv;
vi.restoreAllMocks();
});
describe('resolveCredentials', () => {
it('honors cookieSource=firefox even when Safari has cookies', async () => {
sweet.results.set('safari', {
cookies: [
{ name: 'auth_token', value: 'safari_auth', domain: 'x.com' },
{ name: 'ct0', value: 'safari_ct0', domain: 'x.com' },
],
warnings: [],
});
sweet.results.set('firefox', {
cookies: [
{ name: 'auth_token', value: 'firefox_auth', domain: 'x.com' },
{ name: 'ct0', value: 'firefox_ct0', domain: 'x.com' },
],
warnings: [],
});
const { resolveCredentials } = await import('../src/lib/cookies.js');
const result = await resolveCredentials({ cookieSource: 'firefox' });
expect(result.cookies.authToken).toBe('firefox_auth');
expect(result.cookies.ct0).toBe('firefox_ct0');
expect(result.cookies.source).toContain('Firefox');
});
it('honors cookieSource=safari', async () => {
if (process.platform !== 'darwin') {
return;
}
sweet.results.set('safari', {
cookies: [
{ name: 'auth_token', value: 'safari_auth', domain: 'x.com' },
{ name: 'ct0', value: 'safari_ct0', domain: 'x.com' },
],
warnings: [],
});
const { resolveCredentials } = await import('../src/lib/cookies.js');
const result = await resolveCredentials({ cookieSource: 'safari' });
expect(result.cookies.authToken).toBe('safari_auth');
expect(result.cookies.ct0).toBe('safari_ct0');
expect(result.cookies.cookieHeader).toContain('auth_token=safari_auth');
expect(result.cookies.cookieHeader).toContain('ct0=safari_ct0');
expect(result.cookies.source).toBe('Safari');
});
it('uses firefox when enabled and returns cookies', async () => {
sweet.results.set('firefox', {
cookies: [
{ name: 'auth_token', value: 'firefox_auth', domain: 'x.com' },
{ name: 'ct0', value: 'firefox_ct0', domain: 'x.com' },
],
warnings: [],
});
const { resolveCredentials } = await import('../src/lib/cookies.js');
const result = await resolveCredentials({ cookieSource: 'firefox', firefoxProfile: 'abc.default-release' });
expect(result.cookies.authToken).toBe('firefox_auth');
expect(result.cookies.ct0).toBe('firefox_ct0');
expect(result.cookies.cookieHeader).toContain('auth_token=firefox_auth');
expect(result.cookies.cookieHeader).toContain('ct0=firefox_ct0');
expect(result.cookies.source).toContain('Firefox');
});
it('should prioritize CLI arguments over env vars', async () => {
process.env.AUTH_TOKEN = 'env_auth';
process.env.CT0 = 'env_ct0';
const { resolveCredentials } = await import('../src/lib/cookies.js');
const result = await resolveCredentials({
authToken: 'cli_auth',
ct0: 'cli_ct0',
});
expect(result.cookies.authToken).toBe('cli_auth');
expect(result.cookies.ct0).toBe('cli_ct0');
expect(result.cookies.cookieHeader).toBe('auth_token=cli_auth; ct0=cli_ct0');
expect(result.cookies.source).toBe('CLI argument');
});
it('should use AUTH_TOKEN env var', async () => {
process.env.AUTH_TOKEN = 'test_auth_token';
process.env.CT0 = 'test_ct0';
const { resolveCredentials } = await import('../src/lib/cookies.js');
const result = await resolveCredentials({ cookieSource: 'safari' });
expect(result.cookies.authToken).toBe('test_auth_token');
expect(result.cookies.ct0).toBe('test_ct0');
expect(result.cookies.source).toBe('env AUTH_TOKEN');
});
it('should use TWITTER_AUTH_TOKEN env var as fallback', async () => {
process.env.TWITTER_AUTH_TOKEN = 'twitter_auth';
process.env.TWITTER_CT0 = 'twitter_ct0';
const { resolveCredentials } = await import('../src/lib/cookies.js');
const result = await resolveCredentials({ cookieSource: 'safari' });
expect(result.cookies.authToken).toBe('twitter_auth');
expect(result.cookies.ct0).toBe('twitter_ct0');
});
it('should trim whitespace from values', async () => {
process.env.AUTH_TOKEN = ' trimmed_auth ';
process.env.CT0 = ' trimmed_ct0 ';
const { resolveCredentials } = await import('../src/lib/cookies.js');
const result = await resolveCredentials({});
expect(result.cookies.authToken).toBe('trimmed_auth');
expect(result.cookies.ct0).toBe('trimmed_ct0');
});
it('should treat empty strings as null', async () => {
process.env.AUTH_TOKEN = ' ';
process.env.CT0 = '';
const { resolveCredentials } = await import('../src/lib/cookies.js');
const result = await resolveCredentials({ cookieSource: 'safari' });
expect(result.cookies.authToken).toBeNull();
expect(result.cookies.ct0).toBeNull();
expect(result.warnings.length).toBeGreaterThan(0);
});
it('should warn when credentials are missing', async () => {
const { resolveCredentials } = await import('../src/lib/cookies.js');
const result = await resolveCredentials({ cookieSource: 'safari' });
expect(result.warnings).toContain(
'Missing auth_token - provide via --auth-token, AUTH_TOKEN env var, or login to x.com in Safari/Chrome/Firefox',
);
expect(result.warnings).toContain(
'Missing ct0 - provide via --ct0, CT0 env var, or login to x.com in Safari/Chrome/Firefox',
);
});
it('falls back to Chrome when enabled and Firefox disabled', async () => {
sweet.results.set('chrome', {
cookies: [
{ name: 'auth_token', value: 'test_auth', domain: 'x.com' },
{ name: 'ct0', value: 'test_ct0', domain: 'x.com' },
],
warnings: [],
});
const { resolveCredentials } = await import('../src/lib/cookies.js');
const result = await resolveCredentials({
cookieSource: 'chrome',
chromeProfile: 'Default',
cookieTimeoutMs: 15000,
});
expect(result.cookies.authToken).toBe('test_auth');
expect(result.cookies.ct0).toBe('test_ct0');
expect(result.cookies.source).toContain('Chrome');
expect(sweet.options.get('chrome')?.timeoutMs).toBe(15000);
});
it('defaults to a 30s cookie timeout on macOS', async () => {
if (process.platform !== 'darwin') {
return;
}
sweet.results.set('chrome', {
cookies: [
{ name: 'auth_token', value: 'test_auth', domain: 'x.com' },
{ name: 'ct0', value: 'test_ct0', domain: 'x.com' },
],
warnings: [],
});
const { resolveCredentials } = await import('../src/lib/cookies.js');
const result = await resolveCredentials({ cookieSource: 'chrome' });
expect(result.cookies.authToken).toBe('test_auth');
expect(result.cookies.ct0).toBe('test_ct0');
expect(sweet.options.get('chrome')?.timeoutMs).toBe(30000);
});
it('uses default browser order when cookieSource is omitted', async () => {
sweet.results.set('safari', { cookies: [], warnings: [] });
sweet.results.set('chrome', { cookies: [], warnings: [] });
sweet.results.set('firefox', {
cookies: [
{ name: 'auth_token', value: 'firefox_auth', domain: 'x.com' },
{ name: 'ct0', value: 'firefox_ct0', domain: 'x.com' },
],
warnings: [],
});
const { resolveCredentials } = await import('../src/lib/cookies.js');
const result = await resolveCredentials({});
expect(result.cookies.authToken).toBe('firefox_auth');
expect(result.cookies.ct0).toBe('firefox_ct0');
expect(result.cookies.source).toContain('Firefox');
});
it('prefers twitter.com cookies when x.com is missing', async () => {
sweet.results.set('chrome', {
cookies: [
{ name: 'auth_token', value: 'twitter_auth', domain: 'twitter.com' },
{ name: 'ct0', value: 'twitter_ct0', domain: 'twitter.com' },
],
warnings: [],
});
const { resolveCredentials } = await import('../src/lib/cookies.js');
const result = await resolveCredentials({ cookieSource: 'chrome' });
expect(result.cookies.authToken).toBe('twitter_auth');
expect(result.cookies.ct0).toBe('twitter_ct0');
});
it('falls back to the first cookie when no domain matches', async () => {
sweet.results.set('firefox', {
cookies: [
{ name: 'auth_token', value: 'first_auth', domain: 'example.com' },
{ name: 'ct0', value: 'first_ct0', domain: 'example.com' },
],
warnings: [],
});
const { resolveCredentials } = await import('../src/lib/cookies.js');
const result = await resolveCredentials({ cookieSource: 'firefox' });
expect(result.cookies.authToken).toBe('first_auth');
expect(result.cookies.ct0).toBe('first_ct0');
});
});
describe('extractCookiesFromSafari', () => {
it('returns cookies from Safari', async () => {
if (process.platform !== 'darwin') {
return;
}
sweet.results.set('safari', {
cookies: [
{ name: 'auth_token', value: 'safari_auth', domain: 'x.com' },
{ name: 'ct0', value: 'safari_ct0', domain: 'x.com' },
],
warnings: [],
});
const { extractCookiesFromSafari } = await import('../src/lib/cookies.js');
const result = await extractCookiesFromSafari();
expect(result.cookies.authToken).toBe('safari_auth');
expect(result.cookies.ct0).toBe('safari_ct0');
expect(result.cookies.source).toBe('Safari');
});
it('prefers Safari over Chrome when both are available', async () => {
if (process.platform !== 'darwin') {
return;
}
sweet.results.set('safari', {
cookies: [
{ name: 'auth_token', value: 'safari_auth', domain: 'x.com' },
{ name: 'ct0', value: 'safari_ct0', domain: 'x.com' },
],
warnings: [],
});
sweet.results.set('chrome', {
cookies: [
{ name: 'auth_token', value: 'chrome_auth', domain: 'x.com' },
{ name: 'ct0', value: 'chrome_ct0', domain: 'x.com' },
],
warnings: [],
});
const { resolveCredentials } = await import('../src/lib/cookies.js');
const result = await resolveCredentials({ cookieSource: ['safari', 'chrome'] });
expect(result.cookies.authToken).toBe('safari_auth');
expect(result.cookies.ct0).toBe('safari_ct0');
});
});
describe('extractCookiesFromChrome', () => {
it('returns cookies when Chrome yields values', async () => {
sweet.results.set('chrome', {
cookies: [
{ name: 'auth_token', value: 'test_auth', domain: 'x.com' },
{ name: 'ct0', value: 'test_ct0', domain: 'x.com' },
],
warnings: [],
});
const { extractCookiesFromChrome } = await import('../src/lib/cookies.js');
const result = await extractCookiesFromChrome('Default');
expect(result.cookies.authToken).toBe('test_auth');
expect(result.cookies.ct0).toBe('test_ct0');
expect(result.cookies.source).toContain('Chrome');
expect(result.warnings).toHaveLength(0);
});
it('warns when Chrome returns no cookies', async () => {
sweet.results.set('chrome', { cookies: [], warnings: [] });
const { extractCookiesFromChrome } = await import('../src/lib/cookies.js');
const result = await extractCookiesFromChrome('Default');
expect(result.cookies.authToken).toBeNull();
expect(result.cookies.ct0).toBeNull();
expect(result.warnings.some((w) => w.includes('No Twitter cookies found in Chrome'))).toBe(true);
});
});
describe('extractCookiesFromFirefox', () => {
it('warns when Firefox cookies database is missing', async () => {
sweet.results.set('firefox', {
cookies: [],
warnings: ['Firefox cookies database not found.'],
});
const { extractCookiesFromFirefox } = await import('../src/lib/cookies.js');
const result = await extractCookiesFromFirefox('missing-profile');
expect(result.cookies.authToken).toBeNull();
expect(result.cookies.ct0).toBeNull();
expect(result.warnings).toContain('Firefox cookies database not found.');
});
it('warns when Firefox returns no cookies', async () => {
sweet.results.set('firefox', { cookies: [], warnings: [] });
const { extractCookiesFromFirefox } = await import('../src/lib/cookies.js');
const result = await extractCookiesFromFirefox('abc.default-release');
expect(result.cookies.authToken).toBeNull();
expect(result.cookies.ct0).toBeNull();
expect(result.warnings.some((w) => w.includes('No Twitter cookies found in Firefox'))).toBe(true);
});
});
});
tests/help-output.test.ts
+3 -2
View File
@@ -45,8 +45,9 @@ describe('root help output', () => {
cmd.outputHelp();
expect(help).toContain('--auth-token');
expect(help).toContain('--ct0');
expect(help).toContain('--relay-base-url');
expect(help).not.toContain('--auth-token');
expect(help).not.toContain('--ct0');
expect(help).toContain('--timeout');
expect(help).toContain('--quote-depth');
});
tests/library-exports.test.ts
+1 -2
View File
@@ -1,9 +1,8 @@
import { describe, expect, it } from 'vitest';
import { resolveCredentials, TwitterClient } from '../src/index.js';
import { TwitterClient } from '../src/index.js';
describe('library exports', () => {
it('exposes primary library surface', () => {
expect(typeof TwitterClient).toBe('function');
expect(typeof resolveCredentials).toBe('function');
});
});
tests/live/live-all.test.ts
+51 -110
View File
@@ -7,8 +7,7 @@ type RunResult = { exitCode: number; stdout: string; stderr: string; signal: Nod
const LIVE = process.env.BIRD_LIVE === '1';
const authToken = (process.env.AUTH_TOKEN ?? process.env.TWITTER_AUTH_TOKEN ?? '').trim();
const ct0 = (process.env.CT0 ?? process.env.TWITTER_CT0 ?? '').trim();
const relayBaseUrl = (process.env.TWITTER_RELAY_BASE_URL ?? '').trim();
const CLI_PATH = path.resolve(process.cwd(), 'dist', 'cli.js');
@@ -27,8 +26,6 @@ function runBird(args: string[], options: { timeoutMs?: number } = {}): Promise<
stdio: ['ignore', 'pipe', 'pipe'],
env: {
...process.env,
AUTH_TOKEN: authToken,
CT0: ct0,
NODE_ENV: LIVE_NODE_ENV,
},
});
@@ -76,7 +73,6 @@ const d = LIVE ? describe : describe.skip;
d('live CLI (Twitter/X) all commands', () => {
const timeoutArg = (process.env.BIRD_LIVE_TIMEOUT_MS ?? '20000').trim();
const cookieTimeoutArg = (process.env.BIRD_LIVE_COOKIE_TIMEOUT_MS ?? '30000').trim();
const baseArgs = ['--plain', '--timeout', timeoutArg, '--quote-depth', '0'];
let whoamiStdout = '';
@@ -92,19 +88,16 @@ d('live CLI (Twitter/X) all commands', () => {
throw new Error(`Missing ${CLI_PATH}. Run: pnpm run build:dist`);
}
if (!authToken || !ct0) {
const check = await runBird([...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'check'], { timeoutMs: 45_000 });
if (check.exitCode !== 0) {
throw new Error(
'Missing live credentials.\n' +
'- Option A: set AUTH_TOKEN + CT0 (or TWITTER_AUTH_TOKEN/TWITTER_CT0)\n' +
'- Option B: login to x.com in Safari/Chrome/Firefox for cookie extraction\n\n' +
`bird check output:\n${check.stdout}\n${check.stderr}`,
);
}
if (!relayBaseUrl) {
throw new Error('Missing TWITTER_RELAY_BASE_URL for live tests.');
}
const who = await runBird([...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'whoami'], { timeoutMs: 45_000 });
const check = await runBird([...baseArgs, 'check'], { timeoutMs: 45_000 });
if (check.exitCode !== 0) {
throw new Error(`bird check failed:\n${check.stdout}\n${check.stderr}`);
}
const who = await runBird([...baseArgs, 'whoami'], { timeoutMs: 45_000 });
if (who.exitCode !== 0) {
throw new Error(`whoami failed (exit ${who.exitCode}, signal ${who.signal ?? 'none'}):\n${who.stderr}`);
}
@@ -132,12 +125,9 @@ d('live CLI (Twitter/X) all commands', () => {
const searchQuery = (
process.env.BIRD_LIVE_SEARCH_QUERY ?? `from:${handle} -filter:replies -filter:retweets`
).trim();
const search = await runBird(
[...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'search', searchQuery, '-n', '25', '--json'],
{
timeoutMs: 45_000,
},
);
const search = await runBird([...baseArgs, 'search', searchQuery, '-n', '25', '--json'], {
timeoutMs: 45_000,
});
if (search.exitCode !== 0) {
throw new Error(
`search failed (exit ${search.exitCode}, signal ${search.signal ?? 'none'}):\n${search.stderr}`,
@@ -157,7 +147,7 @@ d('live CLI (Twitter/X) all commands', () => {
listId = (process.env.BIRD_LIVE_LIST_ID ?? '').trim();
if (!listId) {
const lists = await runBird([...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'lists', '-n', '1', '--json'], {
const lists = await runBird([...baseArgs, 'lists', '-n', '1', '--json'], {
timeoutMs: 45_000,
});
if (lists.exitCode === 0) {
@@ -166,12 +156,9 @@ d('live CLI (Twitter/X) all commands', () => {
}
}
if (!listId) {
const lists = await runBird(
[...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'lists', '--member-of', '-n', '1', '--json'],
{
timeoutMs: 45_000,
},
);
const lists = await runBird([...baseArgs, 'lists', '--member-of', '-n', '1', '--json'], {
timeoutMs: 45_000,
});
if (lists.exitCode === 0) {
const parsed = parseJson<Array<{ id?: string }>>(lists.stdout);
listId = String(parsed[0]?.id ?? '').trim();
@@ -186,7 +173,7 @@ d('live CLI (Twitter/X) all commands', () => {
});
it('check works', async () => {
const check = await runBird([...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'check'], { timeoutMs: 45_000 });
const check = await runBird([...baseArgs, 'check'], { timeoutMs: 45_000 });
expect(check.exitCode).toBe(0);
expect(check.stdout.length).toBeGreaterThan(0);
});
@@ -199,17 +186,14 @@ d('live CLI (Twitter/X) all commands', () => {
it('search returns JSON array', async () => {
const search = searchStdout
? { exitCode: 0, stdout: searchStdout }
: await runBird(
[...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'search', `from:${handle}`, '-n', '10', '--json'],
{ timeoutMs: 45_000 },
);
: await runBird([...baseArgs, 'search', `from:${handle}`, '-n', '10', '--json'], { timeoutMs: 45_000 });
expect(search.exitCode).toBe(0);
const tweets = parseJson<Array<{ id?: string }>>(search.stdout);
expect(Array.isArray(tweets)).toBe(true);
});
it('read returns tweet JSON', async () => {
const read = await runBird([...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'read', tweetId, '--json'], {
const read = await runBird([...baseArgs, 'read', tweetId, '--json'], {
timeoutMs: 45_000,
});
expect(read.exitCode).toBe(0);
@@ -219,7 +203,7 @@ d('live CLI (Twitter/X) all commands', () => {
});
it('tweet-id shorthand returns tweet JSON', async () => {
const shorthand = await runBird([...baseArgs, '--cookie-timeout', cookieTimeoutArg, tweetId, '--json'], {
const shorthand = await runBird([...baseArgs, tweetId, '--json'], {
timeoutMs: 45_000,
});
expect(shorthand.exitCode).toBe(0);
@@ -228,7 +212,7 @@ d('live CLI (Twitter/X) all commands', () => {
});
it('replies returns JSON array', async () => {
const replies = await runBird([...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'replies', tweetId, '--json'], {
const replies = await runBird([...baseArgs, 'replies', tweetId, '--json'], {
timeoutMs: 45_000,
});
expect(replies.exitCode).toBe(0);
@@ -237,7 +221,7 @@ d('live CLI (Twitter/X) all commands', () => {
});
it('thread returns JSON array', async () => {
const thread = await runBird([...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'thread', tweetId, '--json'], {
const thread = await runBird([...baseArgs, 'thread', tweetId, '--json'], {
timeoutMs: 45_000,
});
expect(thread.exitCode).toBe(0);
@@ -246,31 +230,25 @@ d('live CLI (Twitter/X) all commands', () => {
});
it('mentions returns JSON array', async () => {
const mentions = await runBird(
[...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'mentions', '-n', '10', '--json'],
{
timeoutMs: 45_000,
},
);
const mentions = await runBird([...baseArgs, 'mentions', '-n', '10', '--json'], {
timeoutMs: 45_000,
});
expect(mentions.exitCode).toBe(0);
const mentionTweets = parseJson<Array<{ id?: string }>>(mentions.stdout);
expect(Array.isArray(mentionTweets)).toBe(true);
});
it('bookmarks returns JSON array', async () => {
const bookmarks = await runBird(
[...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'bookmarks', '-n', '10', '--json'],
{
timeoutMs: 45_000,
},
);
const bookmarks = await runBird([...baseArgs, 'bookmarks', '-n', '10', '--json'], {
timeoutMs: 45_000,
});
expect(bookmarks.exitCode).toBe(0);
const bookmarkTweets = parseJson<Array<{ id?: string }>>(bookmarks.stdout);
expect(Array.isArray(bookmarkTweets)).toBe(true);
});
it('likes returns JSON array', async () => {
const likes = await runBird([...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'likes', '-n', '10', '--json'], {
const likes = await runBird([...baseArgs, 'likes', '-n', '10', '--json'], {
timeoutMs: 45_000,
});
expect(likes.exitCode).toBe(0);
@@ -279,24 +257,18 @@ d('live CLI (Twitter/X) all commands', () => {
});
it('following returns JSON array', async () => {
const following = await runBird(
[...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'following', '--user', userId, '-n', '10', '--json'],
{
timeoutMs: 45_000,
},
);
const following = await runBird([...baseArgs, 'following', '--user', userId, '-n', '10', '--json'], {
timeoutMs: 45_000,
});
expect(following.exitCode).toBe(0);
const followingUsers = parseJson<Array<{ id?: string; username?: string }>>(following.stdout);
expect(Array.isArray(followingUsers)).toBe(true);
});
it('followers returns JSON array', async () => {
const followers = await runBird(
[...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'followers', '--user', userId, '-n', '10', '--json'],
{
timeoutMs: 45_000,
},
);
const followers = await runBird([...baseArgs, 'followers', '--user', userId, '-n', '10', '--json'], {
timeoutMs: 45_000,
});
expect(followers.exitCode).toBe(0);
const followerUsers = parseJson<Array<{ id?: string; username?: string }>>(followers.stdout);
expect(Array.isArray(followerUsers)).toBe(true);
@@ -304,12 +276,9 @@ d('live CLI (Twitter/X) all commands', () => {
it('user-tweets returns JSON array', async () => {
const testHandle = process.env.BIRD_LIVE_USER_TWEETS_HANDLE || 'X';
const userTweets = await runBird(
[...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'user-tweets', testHandle, '-n', '5', '--json'],
{
timeoutMs: 45_000,
},
);
const userTweets = await runBird([...baseArgs, 'user-tweets', testHandle, '-n', '5', '--json'], {
timeoutMs: 45_000,
});
expect(userTweets.exitCode).toBe(0);
const tweets = parseJson<Array<{ id?: string; author?: { username?: string } }>>(userTweets.stdout);
expect(Array.isArray(tweets)).toBe(true);
@@ -320,20 +289,7 @@ d('live CLI (Twitter/X) all commands', () => {
const testHandle =
process.env.BIRD_LIVE_USER_TWEETS_PAGED_HANDLE ?? process.env.BIRD_LIVE_USER_TWEETS_HANDLE ?? 'X';
const userTweets = await runBird(
[
...baseArgs,
'--cookie-timeout',
cookieTimeoutArg,
'user-tweets',
testHandle,
'-n',
'50',
'--max-pages',
'3',
'--delay',
'0',
'--json',
],
[...baseArgs, 'user-tweets', testHandle, '-n', '50', '--max-pages', '3', '--delay', '0', '--json'],
{
timeoutMs: 45_000,
},
@@ -344,7 +300,7 @@ d('live CLI (Twitter/X) all commands', () => {
});
it('lists returns JSON array', async () => {
const lists = await runBird([...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'lists', '-n', '10', '--json'], {
const lists = await runBird([...baseArgs, 'lists', '-n', '10', '--json'], {
timeoutMs: 45_000,
});
expect(lists.exitCode).toBe(0);
@@ -356,17 +312,14 @@ d('live CLI (Twitter/X) all commands', () => {
if (!listTimelineAvailable) {
return;
}
const timeline = await runBird(
[...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'list-timeline', listId, '-n', '5', '--json'],
{ timeoutMs: 45_000 },
);
const timeline = await runBird([...baseArgs, 'list-timeline', listId, '-n', '5', '--json'], { timeoutMs: 45_000 });
expect(timeline.exitCode).toBe(0);
const payload = parseJson<Array<{ id?: string }>>(timeline.stdout);
expect(Array.isArray(payload)).toBe(true);
});
it('home for-you returns JSON array', async () => {
const home = await runBird([...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'home', '-n', '5', '--json'], {
const home = await runBird([...baseArgs, 'home', '-n', '5', '--json'], {
timeoutMs: 45_000,
});
expect(home.exitCode).toBe(0);
@@ -375,20 +328,14 @@ d('live CLI (Twitter/X) all commands', () => {
}, 60_000);
it('home following returns JSON array', async () => {
let home = await runBird(
[...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'home', '--following', '-n', '5', '--json'],
{
timeoutMs: 45_000,
},
);
let home = await runBird([...baseArgs, 'home', '--following', '-n', '5', '--json'], {
timeoutMs: 45_000,
});
if (home.exitCode !== 0 && home.stderr.includes('OverCapacity')) {
await sleep(1500);
home = await runBird(
[...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'home', '--following', '-n', '5', '--json'],
{
timeoutMs: 45_000,
},
);
home = await runBird([...baseArgs, 'home', '--following', '-n', '5', '--json'], {
timeoutMs: 45_000,
});
}
expect(home.exitCode).toBe(0);
const payload = parseJson<Array<{ id?: string }>>(home.stdout);
@@ -396,27 +343,21 @@ d('live CLI (Twitter/X) all commands', () => {
}, 60_000);
it('news returns JSON array', async () => {
const news = await runBird(
[...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'news', '-n', '5', '--ai-only', '--json'],
{ timeoutMs: 45_000 },
);
const news = await runBird([...baseArgs, 'news', '-n', '5', '--ai-only', '--json'], { timeoutMs: 45_000 });
expect(news.exitCode).toBe(0);
const payload = parseJson<Array<{ id?: string }>>(news.stdout);
expect(Array.isArray(payload)).toBe(true);
});
it('trending returns JSON array', async () => {
const trending = await runBird(
[...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'trending', '-n', '5', '--json'],
{ timeoutMs: 45_000 },
);
const trending = await runBird([...baseArgs, 'trending', '-n', '5', '--json'], { timeoutMs: 45_000 });
expect(trending.exitCode).toBe(0);
const payload = parseJson<Array<{ id?: string }>>(trending.stdout);
expect(Array.isArray(payload)).toBe(true);
});
it('query-ids returns JSON', async () => {
const queryIds = await runBird([...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'query-ids', '--json'], {
const queryIds = await runBird([...baseArgs, 'query-ids', '--json'], {
timeoutMs: 60_000,
});
expect(queryIds.exitCode).toBe(0);
tests/live/live.test.ts
+38 -77
View File
@@ -7,8 +7,7 @@ type RunResult = { exitCode: number; stdout: string; stderr: string; signal: Nod
const LIVE = process.env.BIRD_LIVE === '1';
const authToken = (process.env.AUTH_TOKEN ?? process.env.TWITTER_AUTH_TOKEN ?? '').trim();
const ct0 = (process.env.CT0 ?? process.env.TWITTER_CT0 ?? '').trim();
const relayBaseUrl = (process.env.TWITTER_RELAY_BASE_URL ?? '').trim();
const CLI_PATH = path.resolve(process.cwd(), 'dist', 'cli.js');
@@ -27,8 +26,6 @@ function runBird(args: string[], options: { timeoutMs?: number } = {}): Promise<
stdio: ['ignore', 'pipe', 'pipe'],
env: {
...process.env,
AUTH_TOKEN: authToken,
CT0: ct0,
NODE_ENV: LIVE_NODE_ENV,
},
});
@@ -72,7 +69,6 @@ const d = LIVE ? describe : describe.skip;
d('live CLI (Twitter/X)', () => {
const timeoutArg = (process.env.BIRD_LIVE_TIMEOUT_MS ?? '20000').trim();
const cookieTimeoutArg = (process.env.BIRD_LIVE_COOKIE_TIMEOUT_MS ?? '30000').trim();
const baseArgs = ['--plain', '--timeout', timeoutArg, '--quote-depth', '0'];
let whoamiStdout = '';
@@ -85,19 +81,16 @@ d('live CLI (Twitter/X)', () => {
throw new Error(`Missing ${CLI_PATH}. Run: pnpm run build:dist`);
}
if (!authToken || !ct0) {
const check = await runBird([...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'check'], { timeoutMs: 45_000 });
if (check.exitCode !== 0) {
throw new Error(
'Missing live credentials.\n' +
'- Option A: set AUTH_TOKEN + CT0 (or TWITTER_AUTH_TOKEN/TWITTER_CT0)\n' +
'- Option B: login to x.com in Safari/Chrome/Firefox for cookie extraction\n\n' +
`bird check output:\n${check.stdout}\n${check.stderr}`,
);
}
if (!relayBaseUrl) {
throw new Error('Missing TWITTER_RELAY_BASE_URL for live tests.');
}
const who = await runBird([...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'whoami'], { timeoutMs: 45_000 });
const check = await runBird([...baseArgs, 'check'], { timeoutMs: 45_000 });
if (check.exitCode !== 0) {
throw new Error(`bird check failed:\n${check.stdout}\n${check.stderr}`);
}
const who = await runBird([...baseArgs, 'whoami'], { timeoutMs: 45_000 });
if (who.exitCode !== 0) {
throw new Error(`whoami failed (exit ${who.exitCode}, signal ${who.signal ?? 'none'}):\n${who.stderr}`);
}
@@ -127,12 +120,9 @@ d('live CLI (Twitter/X)', () => {
const searchQuery = (
process.env.BIRD_LIVE_SEARCH_QUERY ?? `from:${handle} -filter:replies -filter:retweets`
).trim();
const search = await runBird(
[...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'search', searchQuery, '-n', '25', '--json'],
{
timeoutMs: 45_000,
},
);
const search = await runBird([...baseArgs, 'search', searchQuery, '-n', '25', '--json'], {
timeoutMs: 45_000,
});
if (search.exitCode !== 0) {
throw new Error(`search failed (exit ${search.exitCode}, signal ${search.signal ?? 'none'}):\n${search.stderr}`);
}
@@ -160,7 +150,7 @@ d('live CLI (Twitter/X)', () => {
});
it('read returns tweet JSON', async () => {
const read = await runBird([...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'read', tweetId, '--json'], {
const read = await runBird([...baseArgs, 'read', tweetId, '--json'], {
timeoutMs: 45_000,
});
expect(read.exitCode).toBe(0);
@@ -170,7 +160,7 @@ d('live CLI (Twitter/X)', () => {
});
it('tweet-id shorthand returns tweet JSON', async () => {
const shorthand = await runBird([...baseArgs, '--cookie-timeout', cookieTimeoutArg, tweetId, '--json'], {
const shorthand = await runBird([...baseArgs, tweetId, '--json'], {
timeoutMs: 45_000,
});
expect(shorthand.exitCode).toBe(0);
@@ -179,7 +169,7 @@ d('live CLI (Twitter/X)', () => {
});
it('replies returns JSON array', async () => {
const replies = await runBird([...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'replies', tweetId, '--json'], {
const replies = await runBird([...baseArgs, 'replies', tweetId, '--json'], {
timeoutMs: 45_000,
});
expect(replies.exitCode).toBe(0);
@@ -188,7 +178,7 @@ d('live CLI (Twitter/X)', () => {
});
it('thread returns JSON array', async () => {
const thread = await runBird([...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'thread', tweetId, '--json'], {
const thread = await runBird([...baseArgs, 'thread', tweetId, '--json'], {
timeoutMs: 45_000,
});
expect(thread.exitCode).toBe(0);
@@ -198,24 +188,18 @@ d('live CLI (Twitter/X)', () => {
});
it('mentions returns JSON array', async () => {
const mentions = await runBird(
[...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'mentions', '-n', '10', '--json'],
{
timeoutMs: 45_000,
},
);
const mentions = await runBird([...baseArgs, 'mentions', '-n', '10', '--json'], {
timeoutMs: 45_000,
});
expect(mentions.exitCode).toBe(0);
const mentionTweets = parseJson<Array<{ id?: string }>>(mentions.stdout);
expect(Array.isArray(mentionTweets)).toBe(true);
});
it('bookmarks returns JSON array', async () => {
const bookmarks = await runBird(
[...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'bookmarks', '-n', '10', '--json'],
{
timeoutMs: 45_000,
},
);
const bookmarks = await runBird([...baseArgs, 'bookmarks', '-n', '10', '--json'], {
timeoutMs: 45_000,
});
expect(bookmarks.exitCode).toBe(0);
const bookmarkTweets = parseJson<Array<{ id?: string }>>(bookmarks.stdout);
expect(Array.isArray(bookmarkTweets)).toBe(true);
@@ -226,17 +210,16 @@ d('live CLI (Twitter/X)', () => {
if (!folderId) {
return;
}
const bookmarks = await runBird(
[...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'bookmarks', '--folder-id', folderId, '-n', '10', '--json'],
{ timeoutMs: 45_000 },
);
const bookmarks = await runBird([...baseArgs, 'bookmarks', '--folder-id', folderId, '-n', '10', '--json'], {
timeoutMs: 45_000,
});
expect(bookmarks.exitCode).toBe(0);
const bookmarkTweets = parseJson<Array<{ id?: string }>>(bookmarks.stdout);
expect(Array.isArray(bookmarkTweets)).toBe(true);
});
it('likes returns JSON array', async () => {
const likes = await runBird([...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'likes', '-n', '10', '--json'], {
const likes = await runBird([...baseArgs, 'likes', '-n', '10', '--json'], {
timeoutMs: 45_000,
});
expect(likes.exitCode).toBe(0);
@@ -245,24 +228,18 @@ d('live CLI (Twitter/X)', () => {
});
it('following returns JSON array', async () => {
const following = await runBird(
[...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'following', '--user', userId, '-n', '10', '--json'],
{
timeoutMs: 45_000,
},
);
const following = await runBird([...baseArgs, 'following', '--user', userId, '-n', '10', '--json'], {
timeoutMs: 45_000,
});
expect(following.exitCode).toBe(0);
const followingUsers = parseJson<Array<{ id?: string; username?: string }>>(following.stdout);
expect(Array.isArray(followingUsers)).toBe(true);
});
it('followers returns JSON array', async () => {
const followers = await runBird(
[...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'followers', '--user', userId, '-n', '10', '--json'],
{
timeoutMs: 45_000,
},
);
const followers = await runBird([...baseArgs, 'followers', '--user', userId, '-n', '10', '--json'], {
timeoutMs: 45_000,
});
expect(followers.exitCode).toBe(0);
const followerUsers = parseJson<Array<{ id?: string; username?: string }>>(followers.stdout);
expect(Array.isArray(followerUsers)).toBe(true);
@@ -271,12 +248,9 @@ d('live CLI (Twitter/X)', () => {
it('user-tweets returns JSON array', async () => {
// Use a known active account for reliable testing (authenticated user may have no tweets)
const testHandle = process.env.BIRD_LIVE_USER_TWEETS_HANDLE || 'X';
const userTweets = await runBird(
[...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'user-tweets', testHandle, '-n', '5', '--json'],
{
timeoutMs: 45_000,
},
);
const userTweets = await runBird([...baseArgs, 'user-tweets', testHandle, '-n', '5', '--json'], {
timeoutMs: 45_000,
});
expect(userTweets.exitCode).toBe(0);
const tweets = parseJson<Array<{ id?: string; author?: { username?: string } }>>(userTweets.stdout);
expect(Array.isArray(tweets)).toBe(true);
@@ -289,20 +263,7 @@ d('live CLI (Twitter/X)', () => {
const testHandle =
process.env.BIRD_LIVE_USER_TWEETS_PAGED_HANDLE ?? process.env.BIRD_LIVE_USER_TWEETS_HANDLE ?? 'X';
const userTweets = await runBird(
[
...baseArgs,
'--cookie-timeout',
cookieTimeoutArg,
'user-tweets',
testHandle,
'-n',
'50',
'--max-pages',
'3',
'--delay',
'0',
'--json',
],
[...baseArgs, 'user-tweets', testHandle, '-n', '50', '--max-pages', '3', '--delay', '0', '--json'],
{
timeoutMs: 45_000,
},
@@ -315,7 +276,7 @@ d('live CLI (Twitter/X)', () => {
});
it('query-ids returns JSON', async () => {
const queryIds = await runBird([...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'query-ids', '--json'], {
const queryIds = await runBird([...baseArgs, 'query-ids', '--json'], {
timeoutMs: 60_000,
});
expect(queryIds.exitCode).toBe(0);
@@ -340,7 +301,7 @@ d('live CLI (Twitter/X)', () => {
// Skip unless explicitly provided - long-form tweets may be deleted/unavailable
return;
}
const read = await runBird([...baseArgs, '--cookie-timeout', cookieTimeoutArg, 'read', longformTweetId, '--json'], {
const read = await runBird([...baseArgs, 'read', longformTweetId, '--json'], {
timeoutMs: 45_000,
});
expect(read.exitCode).toBe(0);
tests/twitter-client-coverage.api.test.ts
+27 -32
View File
@@ -1,12 +1,7 @@
import { afterEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
const validCookies = {
authToken: 'test_auth_token',
ct0: 'test_ct0_token',
cookieHeader: 'auth_token=test_auth_token; ct0=test_ct0_token',
source: 'test',
};
const testRelayBaseUrl = 'https://relay.example';
type ResponseLike = {
ok: boolean;
@@ -53,7 +48,7 @@ describe('TwitterClient API coverage', () => {
.mockResolvedValueOnce(makeResponse({ ok: false, status: 500, text: async () => 'boom' }));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.tweet('hi');
expect(result.success).toBe(false);
@@ -72,7 +67,7 @@ describe('TwitterClient API coverage', () => {
);
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.tweet('hi');
expect(result.success).toBe(false);
@@ -91,7 +86,7 @@ describe('TwitterClient API coverage', () => {
);
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.tweet('hi');
expect(result.success).toBe(false);
@@ -106,7 +101,7 @@ describe('TwitterClient API coverage', () => {
.mockResolvedValueOnce(makeResponse({ ok: false, status: 500, text: async () => 'down' }));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.search('test');
expect(result.success).toBe(false);
@@ -121,7 +116,7 @@ describe('TwitterClient API coverage', () => {
);
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.search('test');
expect(result.success).toBe(false);
@@ -132,7 +127,7 @@ describe('TwitterClient API coverage', () => {
const mockFetch = vi.fn().mockRejectedValue(new Error('boom'));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.search('test');
expect(result.success).toBe(false);
@@ -143,7 +138,7 @@ describe('TwitterClient API coverage', () => {
const mockFetch = vi.fn().mockResolvedValue(makeResponse({ ok: false, status: 404, text: async () => 'nope' }));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.search('test');
expect(result.success).toBe(false);
@@ -160,7 +155,7 @@ describe('TwitterClient API coverage', () => {
.mockResolvedValueOnce(makeResponse({ ok: false, status: 500, text: async () => 'down' }));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientApiPrivate;
clientPrivate.getBookmarksQueryIds = async () => ['test'];
const result = await client.getBookmarks(1);
@@ -177,7 +172,7 @@ describe('TwitterClient API coverage', () => {
);
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientApiPrivate;
clientPrivate.getBookmarksQueryIds = async () => ['test'];
const result = await client.getBookmarks(1);
@@ -190,7 +185,7 @@ describe('TwitterClient API coverage', () => {
const mockFetch = vi.fn().mockRejectedValue(new Error('boom'));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientApiPrivate;
clientPrivate.getBookmarksQueryIds = async () => ['test'];
const result = await client.getBookmarks(1);
@@ -200,7 +195,7 @@ describe('TwitterClient API coverage', () => {
});
it('returns unknown error when no query ids are available', async () => {
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientApiPrivate;
clientPrivate.getBookmarksQueryIds = async () => [];
@@ -214,7 +209,7 @@ describe('TwitterClient API coverage', () => {
const mockFetch = vi.fn().mockResolvedValue(makeResponse({ ok: false, status: 404, text: async () => 'nope' }));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getBookmarks(1);
expect(result.success).toBe(false);
@@ -229,7 +224,7 @@ describe('TwitterClient API coverage', () => {
.mockResolvedValueOnce(makeResponse({ ok: false, status: 500, text: async () => 'down' }));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientApiPrivate;
clientPrivate.getFollowingQueryIds = async () => ['test'];
@@ -247,7 +242,7 @@ describe('TwitterClient API coverage', () => {
);
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientApiPrivate;
clientPrivate.getFollowersQueryIds = async () => ['test'];
@@ -258,7 +253,7 @@ describe('TwitterClient API coverage', () => {
});
it('returns unknown error when no query ids are available', async () => {
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientApiPrivate;
clientPrivate.getFollowingQueryIds = async () => [];
@@ -272,7 +267,7 @@ describe('TwitterClient API coverage', () => {
const mockFetch = vi.fn().mockResolvedValue(makeResponse({ ok: false, status: 404, text: async () => 'nope' }));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientApiPrivate;
clientPrivate.getFollowersQueryIds = async () => ['test'];
@@ -294,7 +289,7 @@ describe('TwitterClient API coverage', () => {
.mockResolvedValueOnce(makeResponse({ ok: false, status: 500, text: async () => 'down' }));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientApiPrivate;
clientPrivate.getCurrentUser = stubCurrentUser;
clientPrivate.getLikesQueryIds = async () => ['test'];
@@ -313,7 +308,7 @@ describe('TwitterClient API coverage', () => {
);
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientApiPrivate;
clientPrivate.getCurrentUser = stubCurrentUser;
clientPrivate.getLikesQueryIds = async () => ['test'];
@@ -328,7 +323,7 @@ describe('TwitterClient API coverage', () => {
const mockFetch = vi.fn().mockRejectedValue(new Error('boom'));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientApiPrivate;
clientPrivate.getCurrentUser = stubCurrentUser;
clientPrivate.getLikesQueryIds = async () => ['test'];
@@ -340,7 +335,7 @@ describe('TwitterClient API coverage', () => {
});
it('returns unknown error when no query ids are available', async () => {
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientApiPrivate;
clientPrivate.getCurrentUser = stubCurrentUser;
clientPrivate.getLikesQueryIds = async () => [];
@@ -355,7 +350,7 @@ describe('TwitterClient API coverage', () => {
const mockFetch = vi.fn().mockResolvedValue(makeResponse({ ok: false, status: 404, text: async () => 'nope' }));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientApiPrivate;
clientPrivate.getCurrentUser = stubCurrentUser;
clientPrivate.getLikesQueryIds = async () => ['test'];
@@ -375,7 +370,7 @@ describe('TwitterClient API coverage', () => {
.mockResolvedValueOnce(makeResponse({ ok: false, status: 500, text: async () => 'down' }));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientApiPrivate;
clientPrivate.getBookmarkFolderQueryIds = async () => ['test'];
const result = await client.getBookmarkFolderTimeline('123', 1);
@@ -392,7 +387,7 @@ describe('TwitterClient API coverage', () => {
);
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientApiPrivate;
clientPrivate.getBookmarkFolderQueryIds = async () => ['test'];
const result = await client.getBookmarkFolderTimeline('123', 1);
@@ -405,7 +400,7 @@ describe('TwitterClient API coverage', () => {
const mockFetch = vi.fn().mockRejectedValue(new Error('boom'));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientApiPrivate;
clientPrivate.getBookmarkFolderQueryIds = async () => ['test'];
const result = await client.getBookmarkFolderTimeline('123', 1);
@@ -415,7 +410,7 @@ describe('TwitterClient API coverage', () => {
});
it('returns unknown error when no query ids are available', async () => {
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientApiPrivate;
clientPrivate.getBookmarkFolderQueryIds = async () => [];
@@ -429,7 +424,7 @@ describe('TwitterClient API coverage', () => {
const mockFetch = vi.fn().mockResolvedValue(makeResponse({ ok: false, status: 404, text: async () => 'nope' }));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getBookmarkFolderTimeline('123', 1);
expect(result.success).toBe(false);
tests/twitter-client-coverage.core.test.ts
+19 -20
View File
@@ -2,12 +2,7 @@ import { afterEach, describe, expect, it, vi } from 'vitest';
import { runtimeQueryIds } from '../src/lib/runtime-query-ids.js';
import { TwitterClient } from '../src/lib/twitter-client.js';
const validCookies = {
authToken: 'test_auth_token',
ct0: 'test_ct0_token',
cookieHeader: 'auth_token=test_auth_token; ct0=test_ct0_token',
source: 'test',
};
const testRelayBaseUrl = 'https://relay.example';
type ResponseLike = {
ok: boolean;
@@ -46,7 +41,7 @@ describe('TwitterClient core coverage', () => {
});
it('refreshQueryIds calls runtime refresh outside test env', async () => {
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const refreshSpy = vi.spyOn(runtimeQueryIds, 'refresh').mockResolvedValue(null);
process.env.NODE_ENV = 'production';
@@ -63,11 +58,15 @@ describe('TwitterClient core coverage', () => {
});
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies, timeoutMs: 5 });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl, timeoutMs: 5 });
const clientPrivate = client as unknown as TwitterClientPrivate;
await clientPrivate.fetchWithTimeout('https://example.com', { method: 'GET' });
await clientPrivate.fetchWithTimeout('https://x.com/i/api/test', { method: 'GET' });
expect(mockFetch).toHaveBeenCalledTimes(1);
expect(mockFetch).toHaveBeenCalledWith(
'https://relay.example/i/api/test',
expect.objectContaining({ method: 'GET' }),
);
});
it('returns a not found error when tweet data is missing', async () => {
@@ -102,7 +101,7 @@ describe('TwitterClient core coverage', () => {
);
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getTweet('123');
expect(result.success).toBe(false);
@@ -110,7 +109,7 @@ describe('TwitterClient core coverage', () => {
});
it('adds client user id header after ensureClientUserId', async () => {
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
process.env.NODE_ENV = 'production';
vi.spyOn(client, 'getCurrentUser').mockResolvedValue({
@@ -130,7 +129,7 @@ describe('TwitterClient core coverage', () => {
const mockFetch = vi.fn().mockResolvedValueOnce(makeResponse({ ok: false, status: 500 }));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
const result = await clientPrivate.fetchUserArticlePlainText('user', 'tweet');
@@ -141,7 +140,7 @@ describe('TwitterClient core coverage', () => {
const mockFetch = vi.fn().mockRejectedValueOnce(new Error('boom'));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
const result = await clientPrivate.fetchUserArticlePlainText('user', 'tweet');
@@ -160,7 +159,7 @@ describe('TwitterClient core coverage', () => {
);
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
const result = await clientPrivate.fetchUserArticlePlainText('user', 'tweet');
@@ -177,7 +176,7 @@ describe('TwitterClient core coverage', () => {
);
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
const result = await clientPrivate.fetchTweetDetail('1');
@@ -210,7 +209,7 @@ describe('TwitterClient core coverage', () => {
);
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
const result = await clientPrivate.fetchTweetDetail('1');
@@ -260,7 +259,7 @@ describe('TwitterClient core coverage', () => {
);
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
const result = await clientPrivate.fetchTweetDetail('2');
@@ -295,7 +294,7 @@ describe('TwitterClient core coverage', () => {
);
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
const result = await clientPrivate.fetchTweetDetail('1');
@@ -306,7 +305,7 @@ describe('TwitterClient core coverage', () => {
const mockFetch = vi.fn().mockRejectedValueOnce(new Error('boom'));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
const result = await clientPrivate.fetchTweetDetail('1');
@@ -320,7 +319,7 @@ describe('TwitterClient core coverage', () => {
const mockFetch = vi.fn().mockRejectedValueOnce(new Error('boom'));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
const result = await clientPrivate.postStatusUpdate({ text: 'hello' });
tests/twitter-client-coverage.news.test.ts
+13 -18
View File
@@ -1,12 +1,7 @@
import { afterEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
const validCookies = {
authToken: 'test_auth_token',
ct0: 'test_ct0_token',
cookieHeader: 'auth_token=test_auth_token; ct0=test_ct0_token',
source: 'test',
};
const testRelayBaseUrl = 'https://relay.example';
type ResponseLike = {
ok: boolean;
@@ -99,7 +94,7 @@ describe('TwitterClient news API coverage', () => {
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getNews(1);
expect(result.success).toBe(true);
@@ -125,7 +120,7 @@ describe('TwitterClient news API coverage', () => {
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getNews(1, { includeRaw: true });
expect(result.success).toBe(true);
@@ -154,7 +149,7 @@ describe('TwitterClient news API coverage', () => {
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getNews(10, { aiOnly: true });
expect(result.success).toBe(true);
@@ -180,7 +175,7 @@ describe('TwitterClient news API coverage', () => {
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getNews(1, { tabs: ['news'] });
expect(result.success).toBe(true);
@@ -195,7 +190,7 @@ describe('TwitterClient news API coverage', () => {
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getNews(10);
expect(result.success).toBe(false);
@@ -214,7 +209,7 @@ describe('TwitterClient news API coverage', () => {
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getNews(10);
expect(result.success).toBe(false);
@@ -226,7 +221,7 @@ describe('TwitterClient news API coverage', () => {
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getNews(10);
expect(result.success).toBe(false);
@@ -262,7 +257,7 @@ describe('TwitterClient news API coverage', () => {
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getNews(10);
expect(result.success).toBe(true);
@@ -296,7 +291,7 @@ describe('TwitterClient news API coverage', () => {
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getNews(2);
expect(result.success).toBe(true);
@@ -326,7 +321,7 @@ describe('TwitterClient news API coverage', () => {
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getNews(1);
expect(result.success).toBe(true);
@@ -360,7 +355,7 @@ describe('TwitterClient news API coverage', () => {
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getNews(2);
expect(result.success).toBe(true);
@@ -387,7 +382,7 @@ describe('TwitterClient news API coverage', () => {
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getNews(1);
expect(result.success).toBe(true);
tests/twitter-client-coverage.upload.test.ts
+10 -15
View File
@@ -2,12 +2,7 @@ import { afterEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
import { extractArticleText } from '../src/lib/twitter-client-utils.js';
const validCookies = {
authToken: 'test_auth_token',
ct0: 'test_ct0_token',
cookieHeader: 'auth_token=test_auth_token; ct0=test_ct0_token',
source: 'test',
};
const testRelayBaseUrl = 'https://relay.example';
type ResponseLike = {
ok: boolean;
@@ -40,7 +35,7 @@ describe('TwitterClient upload coverage', () => {
describe('uploadMedia error paths', () => {
it('rejects unsupported media types', async () => {
global.fetch = vi.fn() as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.uploadMedia({ data: new Uint8Array([1, 2, 3]), mimeType: 'application/pdf' });
expect(result.success).toBe(false);
@@ -53,7 +48,7 @@ describe('TwitterClient upload coverage', () => {
.mockResolvedValueOnce(makeResponse({ ok: false, status: 500, text: async () => 'nope' }));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.uploadMedia({ data: new Uint8Array([1]), mimeType: 'image/png' });
expect(result.success).toBe(false);
@@ -67,7 +62,7 @@ describe('TwitterClient upload coverage', () => {
.mockResolvedValueOnce(makeResponse({ ok: false, status: 500, text: async () => 'nope' }));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.uploadMedia({ data: new Uint8Array([1]), mimeType: 'image/png' });
expect(result.success).toBe(false);
@@ -82,7 +77,7 @@ describe('TwitterClient upload coverage', () => {
.mockResolvedValueOnce(makeResponse({ ok: false, status: 500, text: async () => 'nope' }));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.uploadMedia({ data: new Uint8Array([1]), mimeType: 'image/png' });
expect(result.success).toBe(false);
@@ -101,7 +96,7 @@ describe('TwitterClient upload coverage', () => {
);
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.uploadMedia({ data: new Uint8Array([1]), mimeType: 'video/mp4' });
expect(result.success).toBe(false);
@@ -121,7 +116,7 @@ describe('TwitterClient upload coverage', () => {
.mockResolvedValueOnce(makeResponse({ ok: false, status: 503, text: async () => 'down' }));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientUploadPrivate;
clientPrivate.sleep = vi.fn().mockResolvedValue(undefined);
@@ -149,7 +144,7 @@ describe('TwitterClient upload coverage', () => {
.mockResolvedValueOnce(makeResponse({ json: async () => ({ processing_info: { state: 'succeeded' } }) }));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientUploadPrivate;
clientPrivate.sleep = vi.fn().mockResolvedValue(undefined);
@@ -167,7 +162,7 @@ describe('TwitterClient upload coverage', () => {
.mockResolvedValueOnce(makeResponse({ ok: false, status: 400, text: async () => 'bad' }));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.uploadMedia({ data: new Uint8Array([1]), mimeType: 'image/png', alt: 'alt' });
expect(result.success).toBe(false);
@@ -178,7 +173,7 @@ describe('TwitterClient upload coverage', () => {
const mockFetch = vi.fn().mockRejectedValueOnce(new Error('boom'));
global.fetch = mockFetch as unknown as typeof fetch;
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.uploadMedia({ data: new Uint8Array([1]), mimeType: 'image/png' });
expect(result.success).toBe(false);
tests/twitter-client-fixtures.ts
+1 -6
View File
@@ -1,11 +1,6 @@
import type { TwitterClient } from '../src/lib/twitter-client.js';
export const validCookies = {
authToken: 'test_auth_token',
ct0: 'test_ct0_token',
cookieHeader: 'auth_token=test_auth_token; ct0=test_ct0_token',
source: 'test',
};
export const testRelayBaseUrl = 'https://relay.example';
export type TwitterClientPrivate = TwitterClient & {
getCurrentUser: () => Promise<{
tests/twitter-client.constructor-tweet-reply.test.ts
+34 -34
View File
@@ -1,6 +1,6 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
import { validCookies } from './twitter-client-fixtures.js';
import { testRelayBaseUrl } from './twitter-client-fixtures.js';
const originalFetch = global.fetch;
@@ -10,26 +10,22 @@ afterEach(() => {
});
describe('TwitterClient constructor', () => {
it('should throw if authToken is missing', () => {
expect(
() =>
new TwitterClient({
cookies: { authToken: null, ct0: 'test', cookieHeader: null, source: null },
}),
).toThrow('Both authToken and ct0 cookies are required');
it('throws if relay base URL is missing', () => {
const originalRelayBaseUrl = process.env.TWITTER_RELAY_BASE_URL;
delete process.env.TWITTER_RELAY_BASE_URL;
try {
expect(() => new TwitterClient({})).toThrow('TWITTER_RELAY_BASE_URL is required');
} finally {
if (originalRelayBaseUrl === undefined) {
delete process.env.TWITTER_RELAY_BASE_URL;
} else {
process.env.TWITTER_RELAY_BASE_URL = originalRelayBaseUrl;
}
}
});
it('should throw if ct0 is missing', () => {
expect(
() =>
new TwitterClient({
cookies: { authToken: 'test', ct0: null, cookieHeader: null, source: null },
}),
).toThrow('Both authToken and ct0 cookies are required');
});
it('should create client with valid cookies', () => {
const client = new TwitterClient({ cookies: validCookies });
it('creates client with relay base URL', () => {
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
expect(client).toBeInstanceOf(TwitterClient);
});
});
@@ -61,7 +57,7 @@ describe('TwitterClient tweet', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.tweet('Hello world!');
expect(result.success).toBe(true);
@@ -69,8 +65,12 @@ describe('TwitterClient tweet', () => {
expect(mockFetch).toHaveBeenCalledTimes(1);
const [url, options] = mockFetch.mock.calls[0];
expect(url).toContain('CreateTweet');
expect(String(url)).toContain(`${testRelayBaseUrl}/i/api/graphql/`);
expect(String(url)).toContain('CreateTweet');
expect(options.method).toBe('POST');
expect(options.headers).not.toHaveProperty('cookie');
expect(options.headers).not.toHaveProperty('authorization');
expect(options.headers).not.toHaveProperty('x-csrf-token');
const body = JSON.parse(options.body);
expect(body.variables.tweet_text).toBe('Hello world!');
@@ -94,7 +94,7 @@ describe('TwitterClient tweet', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.tweet('Hello world!', ['111', '222']);
expect(result.success).toBe(true);
@@ -136,7 +136,7 @@ describe('TwitterClient tweet', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.tweet('Hello world!');
expect(result.success).toBe(true);
@@ -146,7 +146,7 @@ describe('TwitterClient tweet', () => {
const [firstUrl] = mockFetch.mock.calls[0];
const [thirdUrl] = mockFetch.mock.calls[2];
expect(String(firstUrl)).toContain('/CreateTweet');
expect(String(thirdUrl)).toBe('https://x.com/i/api/graphql');
expect(String(thirdUrl)).toBe(`${testRelayBaseUrl}/i/api/graphql`);
});
it('should handle API errors', async () => {
@@ -157,7 +157,7 @@ describe('TwitterClient tweet', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.tweet('Test');
expect(result.success).toBe(false);
@@ -184,7 +184,7 @@ describe('TwitterClient tweet', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.tweet('Hello world!');
expect(result.success).toBe(true);
@@ -212,7 +212,7 @@ describe('TwitterClient tweet', () => {
text: async () => 'Forbidden',
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.tweet('Hello world!');
expect(result.success).toBe(false);
@@ -242,7 +242,7 @@ describe('TwitterClient tweet', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.tweet('Hello world!');
expect(result.success).toBe(false);
@@ -268,7 +268,7 @@ describe('TwitterClient tweet', () => {
json: async () => ({}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.tweet('Hello world!');
expect(result.success).toBe(false);
@@ -283,7 +283,7 @@ describe('TwitterClient tweet', () => {
text: async () => 'Forbidden',
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.tweet('Test');
expect(result.success).toBe(false);
@@ -293,7 +293,7 @@ describe('TwitterClient tweet', () => {
it('should handle network errors', async () => {
mockFetch.mockRejectedValueOnce(new Error('Network error'));
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.tweet('Test');
expect(result.success).toBe(false);
@@ -316,7 +316,7 @@ describe('TwitterClient tweet', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.tweet('Hello world!');
expect(result.success).toBe(false);
@@ -348,7 +348,7 @@ describe('TwitterClient reply', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.reply('This is a reply', '1234567890');
expect(result.success).toBe(true);
@@ -382,7 +382,7 @@ describe('TwitterClient reply', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.reply('This is a reply', '1234567890', ['111', '222']);
expect(result.success).toBe(true);
tests/twitter-client.conversations.test.ts
+5 -5
View File
@@ -1,6 +1,6 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
import { validCookies } from './twitter-client-fixtures.js';
import { testRelayBaseUrl } from './twitter-client-fixtures.js';
const originalFetch = global.fetch;
@@ -78,7 +78,7 @@ describe('TwitterClient conversation helpers', () => {
json: async () => makeConversationPayload(),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getReplies('1');
expect(result.success).toBe(true);
@@ -102,7 +102,7 @@ describe('TwitterClient conversation helpers', () => {
json: async () => payload,
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getThread('2');
expect(result.success).toBe(true);
@@ -147,7 +147,7 @@ describe('TwitterClient conversation helpers', () => {
json: async () => payload,
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getThread('1');
expect(result.success).toBe(true);
@@ -161,7 +161,7 @@ describe('TwitterClient conversation helpers', () => {
text: async () => 'oops',
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getThread('1');
expect(result.success).toBe(false);
tests/twitter-client.current-user.test.ts
+19 -23
View File
@@ -1,6 +1,6 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
import { validCookies } from './twitter-client-fixtures.js';
import { testRelayBaseUrl } from './twitter-client-fixtures.js';
const originalFetch = global.fetch;
@@ -28,7 +28,7 @@ describe('TwitterClient getCurrentUser', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getCurrentUser();
expect(result.success).toBe(true);
@@ -44,7 +44,7 @@ describe('TwitterClient getCurrentUser', () => {
text: async () => '{"language":"en"}',
}));
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getCurrentUser();
expect(result.success).toBe(false);
@@ -58,32 +58,26 @@ describe('TwitterClient getCurrentUser', () => {
text: async () => 'Unauthorized',
}));
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getCurrentUser();
expect(result.success).toBe(false);
expect(result.error).toContain('HTTP 401');
});
it('uses HTML fallback when API endpoints 404', async () => {
it('returns error when API endpoints 404', async () => {
mockFetch
.mockResolvedValueOnce({ ok: false, status: 404, text: async () => 'not found' })
.mockResolvedValueOnce({ ok: false, status: 404, text: async () => 'not found' })
.mockResolvedValueOnce({ ok: false, status: 404, text: async () => 'not found' })
.mockResolvedValueOnce({ ok: false, status: 404, text: async () => 'not found' })
.mockResolvedValueOnce({
ok: true,
status: 200,
text: async () => '<html>"screen_name":"fallback","user_id":"999"</html>',
});
.mockResolvedValueOnce({ ok: false, status: 404, text: async () => 'not found' });
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getCurrentUser();
expect(result.success).toBe(true);
expect(result.user?.username).toBe('fallback');
expect(result.user?.id).toBe('999');
expect(mockFetch).toHaveBeenCalledTimes(5);
expect(result.success).toBe(false);
expect(result.error).toContain('HTTP 404');
expect(mockFetch).toHaveBeenCalledTimes(4);
});
it('skips an endpoint when JSON parsing fails', async () => {
@@ -105,7 +99,7 @@ describe('TwitterClient getCurrentUser', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getCurrentUser();
expect(result.success).toBe(true);
@@ -113,24 +107,26 @@ describe('TwitterClient getCurrentUser', () => {
expect(mockFetch).toHaveBeenCalledTimes(2);
});
it('continues on fetch errors and still succeeds via HTML fallback', async () => {
it('continues on fetch errors and still succeeds via later API endpoint', async () => {
mockFetch
.mockRejectedValueOnce(new Error('boom'))
.mockResolvedValueOnce({ ok: false, status: 404, text: async () => 'not found' })
.mockResolvedValueOnce({ ok: false, status: 404, text: async () => 'not found' })
.mockResolvedValueOnce({ ok: false, status: 404, text: async () => 'not found' })
.mockRejectedValueOnce(new Error('settings boom'))
.mockResolvedValueOnce({
ok: true,
status: 200,
text: async () => '<html>"screen_name":"fallback","user_id":"999"</html>',
json: async () => ({
user_id: '999',
screen_name: 'fallback',
name: 'Fallback User',
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getCurrentUser();
expect(result.success).toBe(true);
expect(result.user?.username).toBe('fallback');
expect(result.user?.id).toBe('999');
expect(mockFetch).toHaveBeenCalledTimes(3);
});
});
tests/twitter-client.following-pagination.test.ts
+5 -5
View File
@@ -1,7 +1,7 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
import type { TwitterClientPrivate } from './twitter-client-fixtures.js';
import { validCookies } from './twitter-client-fixtures.js';
import { testRelayBaseUrl } from './twitter-client-fixtures.js';
const originalFetch = global.fetch;
@@ -69,7 +69,7 @@ describe('TwitterClient following pagination', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getFollowingQueryIds = async () => ['q1'];
clientPrivate.getFollowingViaRest = vi.fn();
@@ -109,7 +109,7 @@ describe('TwitterClient following pagination', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getFollowingQueryIds = async () => ['q1'];
clientPrivate.getFollowingViaRest = vi.fn();
@@ -147,7 +147,7 @@ describe('TwitterClient following pagination', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getFollowingQueryIds = async () => ['q1'];
clientPrivate.getFollowingViaRest = vi.fn();
@@ -165,7 +165,7 @@ describe('TwitterClient following pagination', () => {
text: async () => 'boom',
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getFollowingQueryIds = async () => ['q1'];
clientPrivate.getFollowingViaRest = vi.fn().mockResolvedValue({ success: false, error: 'rest fail' });
tests/twitter-client.following.test.ts
+8 -8
View File
@@ -1,6 +1,6 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
import { validCookies } from './twitter-client-fixtures.js';
import { testRelayBaseUrl } from './twitter-client-fixtures.js';
const originalFetch = global.fetch;
@@ -84,7 +84,7 @@ describe('TwitterClient following/followers', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClient & { getFollowingQueryIds: () => Promise<string[]> };
clientPrivate.getFollowingQueryIds = async () => ['test'];
@@ -138,7 +138,7 @@ describe('TwitterClient following/followers', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClient & { getFollowersQueryIds: () => Promise<string[]> };
clientPrivate.getFollowersQueryIds = async () => ['test'];
@@ -183,7 +183,7 @@ describe('TwitterClient following/followers', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClient & {
getFollowingQueryIds: () => Promise<string[]>;
refreshQueryIds: () => Promise<void>;
@@ -225,7 +225,7 @@ describe('TwitterClient following/followers', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClient & { getFollowingQueryIds: () => Promise<string[]> };
clientPrivate.getFollowingQueryIds = async () => ['test'];
@@ -265,7 +265,7 @@ describe('TwitterClient following/followers', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClient & { getFollowersQueryIds: () => Promise<string[]> };
clientPrivate.getFollowersQueryIds = async () => ['test'];
@@ -320,7 +320,7 @@ describe('TwitterClient following/followers', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClient & { getFollowersQueryIds: () => Promise<string[]> };
clientPrivate.getFollowersQueryIds = async () => ['test'];
@@ -368,7 +368,7 @@ describe('TwitterClient following/followers', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClient & { getFollowersQueryIds: () => Promise<string[]> };
clientPrivate.getFollowersQueryIds = async () => ['test'];
tests/twitter-client.get-tweet.test.ts
+12 -12
View File
@@ -1,7 +1,7 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
import { mapTweetResult } from '../src/lib/twitter-client-utils.js';
import { validCookies } from './twitter-client-fixtures.js';
import { testRelayBaseUrl } from './twitter-client-fixtures.js';
const originalFetch = global.fetch;
@@ -49,7 +49,7 @@ describe('TwitterClient getTweet', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getTweet('12345');
expect(result.success).toBe(true);
@@ -103,7 +103,7 @@ describe('TwitterClient getTweet', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getTweet('6789');
expect(result.success).toBe(true);
@@ -118,7 +118,7 @@ describe('TwitterClient getTweet', () => {
text: async () => 'Not Found',
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getTweet('missing');
expect(result.success).toBe(false);
@@ -168,7 +168,7 @@ describe('TwitterClient getTweet', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getTweet('article123');
expect(result.success).toBe(true);
@@ -252,7 +252,7 @@ describe('TwitterClient getTweet', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getTweet('article123');
expect(result.success).toBe(true);
@@ -295,7 +295,7 @@ describe('TwitterClient getTweet', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getTweet('note123');
expect(result.success).toBe(true);
@@ -326,7 +326,7 @@ describe('TwitterClient getTweet', () => {
.mockResolvedValueOnce({ ok: false, status: 404, text: async () => '' })
.mockResolvedValueOnce({ ok: true, status: 200, json: async () => payload });
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getTweet('1');
expect(result.success).toBe(true);
@@ -366,7 +366,7 @@ describe('TwitterClient quoted tweets', () => {
const root = makeTweetResult('1', 'root');
root.quoted_status_result = { result: quoted };
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const mapped = mapTweetResult(root, (client as { quoteDepth: number }).quoteDepth);
expect(mapped?.quotedTweet?.id).toBe('2');
@@ -378,7 +378,7 @@ describe('TwitterClient quoted tweets', () => {
const root = makeTweetResult('1', 'root');
root.quoted_status_result = { result: quoted };
const client = new TwitterClient({ cookies: validCookies, quoteDepth: 0 });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl, quoteDepth: 0 });
const mapped = mapTweetResult(root, (client as { quoteDepth: number }).quoteDepth);
expect(mapped?.quotedTweet).toBeUndefined();
@@ -391,7 +391,7 @@ describe('TwitterClient quoted tweets', () => {
const root = makeTweetResult('1', 'root');
root.quoted_status_result = { result: quoted1 };
const client = new TwitterClient({ cookies: validCookies, quoteDepth: 2 });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl, quoteDepth: 2 });
const mapped = mapTweetResult(root, (client as { quoteDepth: number }).quoteDepth);
expect(mapped?.quotedTweet?.id).toBe('2');
@@ -409,7 +409,7 @@ describe('TwitterClient quoted tweets', () => {
},
};
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const mapped = mapTweetResult(root, (client as { quoteDepth: number }).quoteDepth);
expect(mapped?.quotedTweet?.id).toBe('2');
tests/twitter-client.home-timeline.test.ts
+8 -8
View File
@@ -1,6 +1,6 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
import { validCookies } from './twitter-client-fixtures.js';
import { testRelayBaseUrl } from './twitter-client-fixtures.js';
const originalFetch = global.fetch;
@@ -72,7 +72,7 @@ describe('TwitterClient home timeline', () => {
json: async () => makeHomeTimelineResponse('123456', 'Hello from For You feed!', 'testuser'),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getHomeTimeline(1);
expect(result.success).toBe(true);
@@ -89,7 +89,7 @@ describe('TwitterClient home timeline', () => {
text: async () => 'Unauthorized',
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getHomeTimeline(1);
expect(result.success).toBe(false);
@@ -104,7 +104,7 @@ describe('TwitterClient home timeline', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getHomeTimeline(1);
expect(result.success).toBe(false);
@@ -119,7 +119,7 @@ describe('TwitterClient home timeline', () => {
json: async () => makeHomeTimelineResponse('789012', 'Hello from Following feed!', 'chronouser'),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getHomeLatestTimeline(1);
expect(result.success).toBe(true);
@@ -136,7 +136,7 @@ describe('TwitterClient home timeline', () => {
text: async () => 'Forbidden',
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getHomeLatestTimeline(1);
expect(result.success).toBe(false);
@@ -241,7 +241,7 @@ describe('TwitterClient home timeline', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getHomeTimeline(2);
expect(result.success).toBe(true);
@@ -333,7 +333,7 @@ describe('TwitterClient home timeline', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getHomeTimeline(5);
expect(result.success).toBe(true);
tests/twitter-client.json-full.test.ts
+8 -8
View File
@@ -1,7 +1,7 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
import { mapTweetResult, parseTweetsFromInstructions } from '../src/lib/twitter-client-utils.js';
import { validCookies } from './twitter-client-fixtures.js';
import { testRelayBaseUrl } from './twitter-client-fixtures.js';
const originalFetch = global.fetch;
@@ -207,7 +207,7 @@ describe('TwitterClient getTweet with includeRaw option', () => {
json: async () => mockTweetResponse,
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getTweet('12345');
expect(result.success).toBe(true);
@@ -220,7 +220,7 @@ describe('TwitterClient getTweet with includeRaw option', () => {
json: async () => mockTweetResponse,
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getTweet('12345', { includeRaw: true });
expect(result.success).toBe(true);
@@ -280,7 +280,7 @@ describe('TwitterClient getReplies with includeRaw option', () => {
json: async () => mockRepliesResponse,
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getReplies('12345', { includeRaw: true });
expect(result.success).toBe(true);
@@ -340,7 +340,7 @@ describe('TwitterClient getThread with includeRaw option', () => {
json: async () => mockThreadResponse,
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getThread('12345', { includeRaw: true });
expect(result.success).toBe(true);
@@ -402,7 +402,7 @@ describe('TwitterClient search with includeRaw option', () => {
json: async () => mockSearchResponse,
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.search('test query', 10, { includeRaw: true });
expect(result.success).toBe(true);
@@ -417,7 +417,7 @@ describe('TwitterClient search with includeRaw option', () => {
json: async () => mockSearchResponse,
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.search('test query', 10);
expect(result.success).toBe(true);
@@ -462,7 +462,7 @@ describe('--json-full flag behavior (without --json)', () => {
json: async () => mockTweetResponse,
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
// Only passing includeRaw: true, simulating --json-full without --json
const result = await client.getTweet('12345', { includeRaw: true });
tests/twitter-client.json-full.timelines.test.ts
+5 -5
View File
@@ -1,6 +1,6 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
import { type TwitterClientPrivate, validCookies } from './twitter-client-fixtures.js';
import { type TwitterClientPrivate, testRelayBaseUrl } from './twitter-client-fixtures.js';
const originalFetch = global.fetch;
@@ -60,7 +60,7 @@ describe('TwitterClient timelines includeRaw', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getBookmarks(1, { includeRaw: true });
expect(result.success).toBe(true);
@@ -112,7 +112,7 @@ describe('TwitterClient timelines includeRaw', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getBookmarkFolderTimeline('123', 1, { includeRaw: true });
expect(result.success).toBe(true);
@@ -168,7 +168,7 @@ describe('TwitterClient timelines includeRaw', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getCurrentUser = async () => ({
success: true,
@@ -229,7 +229,7 @@ describe('TwitterClient timelines includeRaw', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getListTimelineQueryIds = async () => ['test'];
tests/twitter-client.likes.test.ts
+5 -5
View File
@@ -1,6 +1,6 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
import { type TwitterClientPrivate, validCookies } from './twitter-client-fixtures.js';
import { type TwitterClientPrivate, testRelayBaseUrl } from './twitter-client-fixtures.js';
const originalFetch = global.fetch;
@@ -67,7 +67,7 @@ describe('TwitterClient likes', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getCurrentUser = async () => ({
success: true,
@@ -198,7 +198,7 @@ describe('TwitterClient likes', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getCurrentUser = async () => ({
success: true,
@@ -275,7 +275,7 @@ describe('TwitterClient likes', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getCurrentUser = async () => ({
success: true,
@@ -292,7 +292,7 @@ describe('TwitterClient likes', () => {
});
it('returns an error when current user is unavailable', async () => {
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getCurrentUser = async () => ({ success: false, error: 'no user' });
tests/twitter-client.lists.memberships.test.ts
+3 -3
View File
@@ -2,7 +2,7 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
import { type TwitterClientPrivate, validCookies } from './twitter-client-fixtures.js';
import { type TwitterClientPrivate, testRelayBaseUrl } from './twitter-client-fixtures.js';
const originalFetch = global.fetch;
@@ -61,7 +61,7 @@ describe('TwitterClient lists memberships', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getCurrentUser = async () => ({
success: true,
@@ -118,7 +118,7 @@ describe('TwitterClient lists memberships', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getCurrentUser = async () => ({
success: true,
tests/twitter-client.lists.owned.errors.test.ts
+8 -8
View File
@@ -2,7 +2,7 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
import { type TwitterClientPrivate, validCookies } from './twitter-client-fixtures.js';
import { type TwitterClientPrivate, testRelayBaseUrl } from './twitter-client-fixtures.js';
const originalFetch = global.fetch;
@@ -27,7 +27,7 @@ describe('TwitterClient lists owned errors', () => {
text: async () => 'Internal Server Error',
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getCurrentUser = async () => ({
success: true,
@@ -42,7 +42,7 @@ describe('TwitterClient lists owned errors', () => {
});
it('returns error when getCurrentUser fails', async () => {
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getCurrentUser = async () => ({
success: false,
@@ -65,7 +65,7 @@ describe('TwitterClient lists owned errors', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getCurrentUser = async () => ({
success: true,
@@ -88,7 +88,7 @@ describe('TwitterClient lists owned errors', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getCurrentUser = async () => ({
success: true,
@@ -143,7 +143,7 @@ describe('TwitterClient lists owned errors', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getCurrentUser = async () => ({
success: true,
@@ -223,7 +223,7 @@ describe('TwitterClient lists owned errors', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getCurrentUser = async () => ({
success: true,
@@ -274,7 +274,7 @@ describe('TwitterClient lists owned errors', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getCurrentUser = async () => ({
success: true,
tests/twitter-client.lists.owned.test.ts
+7 -7
View File
@@ -2,7 +2,7 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
import { type TwitterClientPrivate, validCookies } from './twitter-client-fixtures.js';
import { type TwitterClientPrivate, testRelayBaseUrl } from './twitter-client-fixtures.js';
const originalFetch = global.fetch;
@@ -65,7 +65,7 @@ describe('TwitterClient lists owned', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getCurrentUser = async () => ({
success: true,
@@ -105,7 +105,7 @@ describe('TwitterClient lists owned', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getCurrentUser = async () => ({
success: true,
@@ -160,7 +160,7 @@ describe('TwitterClient lists owned', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getCurrentUser = async () => ({
success: true,
@@ -209,7 +209,7 @@ describe('TwitterClient lists owned', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getCurrentUser = async () => ({
success: true,
@@ -258,7 +258,7 @@ describe('TwitterClient lists owned', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getCurrentUser = async () => ({
success: true,
@@ -291,7 +291,7 @@ describe('TwitterClient lists owned', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getCurrentUser = async () => ({
success: true,
tests/twitter-client.lists.pagination.edges.test.ts
+5 -5
View File
@@ -2,7 +2,7 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
import { type TwitterClientPrivate, validCookies } from './twitter-client-fixtures.js';
import { type TwitterClientPrivate, testRelayBaseUrl } from './twitter-client-fixtures.js';
const originalFetch = global.fetch;
@@ -68,7 +68,7 @@ describe('TwitterClient lists pagination (continued)', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getListTimelineQueryIds = async () => ['test'];
@@ -213,7 +213,7 @@ describe('TwitterClient lists pagination (continued)', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getListTimelineQueryIds = async () => ['test'];
@@ -334,7 +334,7 @@ describe('TwitterClient lists pagination (continued)', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getListTimelineQueryIds = async () => ['test'];
@@ -449,7 +449,7 @@ describe('TwitterClient lists pagination (continued)', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getListTimelineQueryIds = async () => ['test'];
tests/twitter-client.lists.pagination.test.ts
+3 -3
View File
@@ -2,7 +2,7 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
import { type TwitterClientPrivate, validCookies } from './twitter-client-fixtures.js';
import { type TwitterClientPrivate, testRelayBaseUrl } from './twitter-client-fixtures.js';
const originalFetch = global.fetch;
@@ -123,7 +123,7 @@ describe('TwitterClient lists pagination', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getListTimelineQueryIds = async () => ['test'];
@@ -250,7 +250,7 @@ describe('TwitterClient lists pagination', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getListTimelineQueryIds = async () => ['test'];
tests/twitter-client.lists.timeline.test.ts
+6 -6
View File
@@ -2,7 +2,7 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
import { type TwitterClientPrivate, validCookies } from './twitter-client-fixtures.js';
import { type TwitterClientPrivate, testRelayBaseUrl } from './twitter-client-fixtures.js';
const originalFetch = global.fetch;
@@ -69,7 +69,7 @@ describe('TwitterClient lists timeline', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getListTimelineQueryIds = async () => ['test'];
@@ -98,7 +98,7 @@ describe('TwitterClient lists timeline', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getListTimelineQueryIds = async () => ['test'];
@@ -115,7 +115,7 @@ describe('TwitterClient lists timeline', () => {
text: async () => 'Forbidden',
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getListTimelineQueryIds = async () => ['test'];
@@ -134,7 +134,7 @@ describe('TwitterClient lists timeline', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getListTimelineQueryIds = async () => ['test'];
@@ -199,7 +199,7 @@ describe('TwitterClient lists timeline', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as unknown as TwitterClientPrivate;
clientPrivate.getListTimelineQueryIds = async () => ['test'];
clientPrivate.refreshQueryIds = async () => {};
tests/twitter-client.media.test.ts
+4 -4
View File
@@ -1,6 +1,6 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
import { validCookies } from './twitter-client-fixtures.js';
import { testRelayBaseUrl } from './twitter-client-fixtures.js';
const originalFetch = global.fetch;
@@ -34,7 +34,7 @@ describe('TwitterClient uploadMedia', () => {
ok: true,
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const data = new Uint8Array([1, 2, 3, 4]);
const result = await client.uploadMedia({ data, mimeType: 'image/png', alt: 'alt text' });
@@ -43,7 +43,7 @@ describe('TwitterClient uploadMedia', () => {
expect(mockFetch).toHaveBeenCalledTimes(4);
const [initUrl, initOptions] = mockFetch.mock.calls[0];
expect(String(initUrl)).toContain('upload.twitter.com');
expect(String(initUrl)).toBe(`${testRelayBaseUrl}/i/media/upload.json`);
expect(initOptions.method).toBe('POST');
expect(initOptions.body).toBeInstanceOf(URLSearchParams);
expect((initOptions.body as URLSearchParams).get('command')).toBe('INIT');
@@ -87,7 +87,7 @@ describe('TwitterClient uploadMedia', () => {
json: async () => ({ processing_info: { state: 'succeeded' } }),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const data = new Uint8Array([1, 2, 3, 4, 5]);
const result = await client.uploadMedia({ data, mimeType: 'video/mp4', alt: 'ignored' });
tests/twitter-client.pagination.test.ts
+13 -13
View File
@@ -1,6 +1,6 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
import { validCookies } from './twitter-client-fixtures.js';
import { testRelayBaseUrl } from './twitter-client-fixtures.js';
const originalFetch = global.fetch;
@@ -75,7 +75,7 @@ describe('TwitterClient pagination for thread and replies', () => {
json: async () => makeConversationPayload(['2', '3'], undefined, '1'),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getRepliesPaged('1');
expect(result.success).toBe(true);
@@ -98,7 +98,7 @@ describe('TwitterClient pagination for thread and replies', () => {
json: async () => makeConversationPayload(['4', '5'], undefined, '1'),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getRepliesPaged('1', { pageDelayMs: 0 });
expect(result.success).toBe(true);
@@ -121,7 +121,7 @@ describe('TwitterClient pagination for thread and replies', () => {
json: async () => makeConversationPayload(['4', '5'], 'cursor-page-3', '1'),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getRepliesPaged('1', { maxPages: 2, pageDelayMs: 0 });
expect(result.success).toBe(true);
@@ -137,7 +137,7 @@ describe('TwitterClient pagination for thread and replies', () => {
json: async () => makeConversationPayload(['4', '5'], undefined, '1'),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getRepliesPaged('1', { cursor: 'resume-cursor', pageDelayMs: 0 });
expect(result.success).toBe(true);
@@ -161,7 +161,7 @@ describe('TwitterClient pagination for thread and replies', () => {
json: async () => makeConversationPayload(['3', '4'], undefined, '1'), // '3' is duplicate
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getRepliesPaged('1', { pageDelayMs: 0 });
expect(result.success).toBe(true);
@@ -182,7 +182,7 @@ describe('TwitterClient pagination for thread and replies', () => {
text: async () => 'Internal Server Error',
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getRepliesPaged('1', { pageDelayMs: 0 });
expect(result.success).toBe(false);
@@ -209,7 +209,7 @@ describe('TwitterClient pagination for thread and replies', () => {
json: async () => makeConversationPayload(['3'], undefined, '1'),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getRepliesPaged('1', { pageDelayMs: 0 });
expect(result.success).toBe(true);
@@ -227,7 +227,7 @@ describe('TwitterClient pagination for thread and replies', () => {
json: async () => makeConversationPayload(['1', '2', '3'], undefined, undefined, '1'),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getThreadPaged('1');
expect(result.success).toBe(true);
@@ -248,7 +248,7 @@ describe('TwitterClient pagination for thread and replies', () => {
json: async () => makeConversationPayload(['3', '4'], undefined, undefined, '1'),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getThreadPaged('1', { pageDelayMs: 0 });
expect(result.success).toBe(true);
@@ -320,7 +320,7 @@ describe('TwitterClient pagination for thread and replies', () => {
json: async () => payload,
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getThreadPaged('1');
expect(result.success).toBe(true);
@@ -391,7 +391,7 @@ describe('TwitterClient pagination for thread and replies', () => {
json: async () => payload,
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getThreadPaged('1');
expect(result.success).toBe(true);
@@ -412,7 +412,7 @@ describe('TwitterClient pagination for thread and replies', () => {
json: async () => makeConversationPayload(['3', '4'], 'cursor-page-3', undefined, '1'),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getThreadPaged('1', { maxPages: 2, pageDelayMs: 0 });
expect(result.success).toBe(true);
tests/twitter-client.search-bookmarks.test.ts
+17 -17
View File
@@ -1,6 +1,6 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
import { validCookies } from './twitter-client-fixtures.js';
import { testRelayBaseUrl } from './twitter-client-fixtures.js';
const originalFetch = global.fetch;
@@ -69,7 +69,7 @@ describe('TwitterClient search', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.search('needle', 1);
expect(result.success).toBe(true);
@@ -109,7 +109,7 @@ describe('TwitterClient search', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.search('hello', 5);
expect(result.success).toBe(true);
@@ -117,7 +117,7 @@ describe('TwitterClient search', () => {
});
it('returns an unknown error when no query IDs are available', async () => {
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
(client as unknown as { getSearchTimelineQueryIds: () => Promise<string[]> }).getSearchTimelineQueryIds =
async () => [];
@@ -185,7 +185,7 @@ describe('TwitterClient search', () => {
json: async () => makeResponse(['2', '3']),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.search('needle', 3);
expect(result.success).toBe(true);
@@ -260,7 +260,7 @@ describe('TwitterClient search', () => {
json: async () => makeResponse(['3'], 'same-cursor'),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.search('needle', 4);
expect(result.success).toBe(true);
@@ -334,7 +334,7 @@ describe('TwitterClient search', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.search('needle', 3);
expect(result.success).toBe(true);
@@ -411,7 +411,7 @@ describe('TwitterClient search', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getAllSearchResults('query', { maxPages: 1 });
expect(result.success).toBe(true);
@@ -466,7 +466,7 @@ describe('TwitterClient search', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getAllSearchResults('query', { cursor: 'old-cursor' });
expect(result.success).toBe(true);
@@ -533,7 +533,7 @@ describe('TwitterClient bookmarks', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getBookmarks(2);
expect(result.success).toBe(true);
@@ -648,7 +648,7 @@ describe('TwitterClient bookmarks', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getAllBookmarks();
expect(result.success).toBe(true);
@@ -760,7 +760,7 @@ describe('TwitterClient bookmarks', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getAllBookmarks({ maxPages: 1 });
expect(result.success).toBe(true);
@@ -816,7 +816,7 @@ describe('TwitterClient bookmarks', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getAllBookmarks({ cursor: 'cursor-1' });
expect(result.success).toBe(true);
@@ -931,7 +931,7 @@ describe('TwitterClient bookmarks', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getAllBookmarks();
expect(result.success).toBe(true);
@@ -988,7 +988,7 @@ describe('TwitterClient bookmarks', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getAllBookmarks({ maxPages: 1 });
expect(result.success).toBe(true);
@@ -1051,7 +1051,7 @@ describe('TwitterClient bookmark folders', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getBookmarkFolderTimeline('123', 2);
expect(result.success).toBe(true);
@@ -1123,7 +1123,7 @@ describe('TwitterClient bookmark folders', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const clientPrivate = client as TwitterClient & { getBookmarkFolderQueryIds: () => Promise<string[]> };
clientPrivate.getBookmarkFolderQueryIds = async () => ['test'];
tests/twitter-client.user-lookup.test.ts
+8 -8
View File
@@ -1,6 +1,6 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
import { validCookies } from './twitter-client-fixtures.js';
import { testRelayBaseUrl } from './twitter-client-fixtures.js';
const originalFetch = global.fetch;
@@ -37,7 +37,7 @@ describe('TwitterClient getUserIdByUsername', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getUserIdByUsername('@testuser');
expect(result.success).toBe(true);
@@ -66,7 +66,7 @@ describe('TwitterClient getUserIdByUsername', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getUserIdByUsername('anotheruser');
expect(result.success).toBe(true);
@@ -74,7 +74,7 @@ describe('TwitterClient getUserIdByUsername', () => {
});
it('returns error for invalid username format', async () => {
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getUserIdByUsername('invalid handle with spaces');
@@ -84,7 +84,7 @@ describe('TwitterClient getUserIdByUsername', () => {
});
it('returns error for empty username', async () => {
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getUserIdByUsername('');
@@ -94,7 +94,7 @@ describe('TwitterClient getUserIdByUsername', () => {
});
it('returns error for username exceeding 15 characters', async () => {
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getUserIdByUsername('thisusernameiswaytoolong');
@@ -118,7 +118,7 @@ describe('TwitterClient getUserIdByUsername', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getUserIdByUsername('suspended');
expect(result.success).toBe(false);
@@ -156,7 +156,7 @@ describe('TwitterClient getUserIdByUsername', () => {
}),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getUserIdByUsername('founduser');
expect(result.success).toBe(true);
tests/twitter-client.user-tweets.test.ts
+14 -14
View File
@@ -1,6 +1,6 @@
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { TwitterClient } from '../src/lib/twitter-client.js';
import { validCookies } from './twitter-client-fixtures.js';
import { testRelayBaseUrl } from './twitter-client-fixtures.js';
const originalFetch = global.fetch;
@@ -91,7 +91,7 @@ describe('TwitterClient getUserTweets', () => {
makeTimelineResponse([makeTweetResult('1', 'First tweet'), makeTweetResult('2', 'Second tweet')]),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getUserTweets('12345', 10);
expect(result.success).toBe(true);
@@ -114,7 +114,7 @@ describe('TwitterClient getUserTweets', () => {
]),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getUserTweets('12345', 2);
expect(result.success).toBe(true);
@@ -128,7 +128,7 @@ describe('TwitterClient getUserTweets', () => {
json: async () => makeTimelineResponse([]),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getUserTweets('12345', 10);
expect(result.success).toBe(true);
@@ -142,7 +142,7 @@ describe('TwitterClient getUserTweets', () => {
json: async () => makeTimelineResponse([makeTweetResult('1', 'Tweet')], 'next-cursor-abc'),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getUserTweetsPaged('12345', 20, { maxPages: 1 });
expect(result.success).toBe(true);
@@ -156,7 +156,7 @@ describe('TwitterClient getUserTweets', () => {
text: async () => 'Internal Server Error',
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getUserTweets('12345', 10);
expect(result.success).toBe(false);
@@ -249,7 +249,7 @@ describe('TwitterClient getUserTweetsPaged', () => {
),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getUserTweetsPaged('12345', 5, { pageDelayMs: 0 });
expect(result.success).toBe(true);
@@ -275,7 +275,7 @@ describe('TwitterClient getUserTweetsPaged', () => {
});
}
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getUserTweetsPaged('12345', 9999, { pageDelayMs: 0 });
expect(result.success).toBe(true);
@@ -285,7 +285,7 @@ describe('TwitterClient getUserTweetsPaged', () => {
});
it('returns error for invalid limit', async () => {
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getUserTweetsPaged('12345', 0);
expect(result.success).toBe(false);
@@ -306,7 +306,7 @@ describe('TwitterClient getUserTweetsPaged', () => {
json: async () => makeTimelineResponse([makeTweetResult('2', 'Page 2 Tweet')], 'cursor-page-3'),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getUserTweetsPaged('12345', 40, {
maxPages: 2,
pageDelayMs: 0, // No delay for tests
@@ -333,7 +333,7 @@ describe('TwitterClient getUserTweetsPaged', () => {
json: async () => makeTimelineResponse([makeTweetResult('2', 'Tweet 2')], 'cursor-3'),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getUserTweetsPaged('12345', 40, {
maxPages: 2,
pageDelayMs: 0,
@@ -357,7 +357,7 @@ describe('TwitterClient getUserTweetsPaged', () => {
json: async () => makeTimelineResponse([makeTweetResult('2', 'Tweet 2')]), // No cursor = end
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getUserTweetsPaged('12345', 100, {
maxPages: 5,
pageDelayMs: 0,
@@ -386,7 +386,7 @@ describe('TwitterClient getUserTweetsPaged', () => {
]),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getUserTweetsPaged('12345', 40, {
maxPages: 2,
pageDelayMs: 0,
@@ -404,7 +404,7 @@ describe('TwitterClient getUserTweetsPaged', () => {
json: async () => makeTimelineResponse([makeTweetResult('5', 'Resumed Tweet')]),
});
const client = new TwitterClient({ cookies: validCookies });
const client = new TwitterClient({ relayBaseUrl: testRelayBaseUrl });
const result = await client.getUserTweetsPaged('12345', 20, {
maxPages: 1,
cursor: 'resume-cursor-xyz',