Every analytics tool wants a subscription. And your data. I built Twiligent instead. YouTube stats. Instagram stats. One dashboard. Runs locally on your machine.
import { test } from 'node:test';
import assert from 'node:assert/strict';
import { createCircuitBreaker, isOutage, isSubrequestLimit } from '../../lib/circuitBreaker.ts';
import { NotFoundError, UpstreamError, UpstreamTimeoutError } from '../../lib/errors.ts';
function clock(start = 0) {
let time = start;
return { now: () => time, advance: (ms: number) => { time += ms; } };
}
const down = () => Promise.reject(new UpstreamError('YouTube could not be reached (fetch failed)', { reason: 'unreachable' }));
const up = () => Promise.resolve('ok');
async function failTimes(breaker: ReturnType<typeof createCircuitBreaker>, times: number) {
for (let i = 0; i < times; i++) await assert.rejects(breaker.run(down));
}
test('four outage failures in a row still let the next call through', async () => {
const breaker = createCircuitBreaker('YouTube', { now: clock().now });
await failTimes(breaker, 4);
assert.equal(await breaker.run(up), 'ok');
});
test('the fifth failure in a row pauses calls, which then fail at once with a temporary error that says to wait', async () => {
const breaker = createCircuitBreaker('YouTube', { now: clock().now });
await failTimes(breaker, 5);
let called = false;
await assert.rejects(breaker.run(() => { called = true; return up(); }), (err: UpstreamError) => {
assert.equal(err.reason, 'unreachable');
assert.equal(err.message, 'YouTube is not answering, so calls to it are paused for a moment. Try again in a minute.');
return true;
});
assert.equal(called, false);
});
test('after 30 seconds one trial call goes through, and an answer closes the breaker', async () => {
const time = clock();
const breaker = createCircuitBreaker('YouTube', { now: time.now });
await failTimes(breaker, 5);
time.advance(29_999);
await assert.rejects(breaker.run(up), /paused/);
time.advance(1);
assert.equal(await breaker.run(up), 'ok');
assert.equal(await breaker.run(up), 'ok');
});
test('a failed trial pauses calls for another 30 seconds', async () => {
const time = clock();
const breaker = createCircuitBreaker('YouTube', { now: time.now });
await failTimes(breaker, 5);
time.advance(30_000);
await assert.rejects(breaker.run(down), /could not be reached/);
time.advance(29_000);
await assert.rejects(breaker.run(up), /paused/);
});
test('while the trial call runs, other calls keep failing at once', async () => {
const time = clock();
const breaker = createCircuitBreaker('YouTube', { now: time.now });
await failTimes(breaker, 5);
time.advance(30_000);
let answer: (value: string) => void = () => {};
const trial = breaker.run(() => new Promise<string>(resolve => { answer = resolve; }));
await assert.rejects(breaker.run(up), /paused/);
answer('ok');
assert.equal(await trial, 'ok');
assert.equal(await breaker.run(up), 'ok');
});
test('errors about the request, such as a missing channel or a bad token, never open the breaker and reset the count', async () => {
const breaker = createCircuitBreaker('YouTube', { now: clock().now });
await failTimes(breaker, 4);
await assert.rejects(breaker.run(() => Promise.reject(new UpstreamError('Invalid token', { status: 401 }))));
await failTimes(breaker, 4);
assert.equal(await breaker.run(up), 'ok');
});
test('a call the caller cancelled says nothing about the platform', async () => {
const breaker = createCircuitBreaker('YouTube', { now: clock().now });
const cancelled = AbortSignal.abort();
for (let i = 0; i < 6; i++) {
await assert.rejects(breaker.run(() => Promise.reject(new UpstreamTimeoutError('YouTube')), cancelled));
}
assert.equal(await breaker.run(up), 'ok');
});
test('timeouts, unreachable hosts and server errors are outages; client errors and other failures are not', () => {
assert.equal(isOutage(new UpstreamTimeoutError('Instagram')), true);
assert.equal(isOutage(new UpstreamError('down', { reason: 'unreachable' })), true);
assert.equal(isOutage(new UpstreamError('Instagram API 503: Service Unavailable', { status: 503 })), true);
assert.equal(isOutage(new UpstreamError('Instagram rate limit hit', { status: 429 })), false);
assert.equal(isOutage(new UpstreamError('Invalid OAuth access token', { status: 190 })), false);
assert.equal(isOutage(new NotFoundError('Instagram user not found')), false);
assert.equal(isOutage(new UpstreamTimeoutError('Instagram'), AbortSignal.abort()), false);
});
test('for Instagram a Graph error code above 500, such as 506 for a duplicate post, is not mistaken for a server error', async () => {
assert.equal(isOutage(new UpstreamError('Duplicate posting', { status: 506 }), undefined, false), false);
const breaker = createCircuitBreaker('Instagram', { httpStatus: false, now: clock().now });
for (let i = 0; i < 6; i++) await assert.rejects(breaker.run(() => Promise.reject(new UpstreamError('Duplicate posting', { status: 506 }))));
assert.equal(await breaker.run(up), 'ok');
});
test('running out of this invocation\'s subrequests never pauses the platform for everyone, nor clears a real outage count', async () => {
const breaker = createCircuitBreaker('YouTube', { now: clock().now });
const spent = () => Promise.reject(new UpstreamError('YouTube could not be reached (Too many subrequests.)', { reason: 'unreachable', cause: new Error('Too many subrequests.') }));
for (let i = 0; i < 10; i++) await assert.rejects(breaker.run(spent));
assert.equal(await breaker.run(up), 'ok');
await failTimes(breaker, 4);
await assert.rejects(breaker.run(spent));
await failTimes(breaker, 1);
await assert.rejects(breaker.run(up), /paused for a moment/);
assert.equal(isSubrequestLimit(new Error('fetch failed')), false);
assert.equal(isOutage(new UpstreamError('x (Too many subrequests.)', { reason: 'unreachable' })), false);
});