Something went wrong. Try again.
TypeScript client for accessing TLE Community.
Something went wrong. Try again.
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118import Lacuna from '../lacuna';import Responses, { isBlockingError } from './responses';import type { ResponseEvent } from './responses';import type { ServerError, ServerRequest, ServerResponse } from './server';
const request: ServerRequest = { module: 'empire', method: 'get_status', params: {}, addSession: true,};
const eventFor = (response: ServerResponse<any>): ResponseEvent => ({ request, response, attempt: 0, retry: jest.fn() }) as unknown as ResponseEvent;
const slowDown: ServerError = { code: 1010, message: 'Slow down', data: {} };
let responses: Responses;
beforeEach(() => { responses = new Responses(new Lacuna());});
test('isBlockingError only matches the recoverable codes', () => { expect(isBlockingError(undefined)).toBe(false); expect(isBlockingError({ code: 1002, message: 'nope', data: {} })).toBe(false); expect(isBlockingError(slowDown)).toBe(true); expect(isBlockingError({ code: 1016, message: 'captcha', data: {} })).toBe(true);});
test('subscribe returns a working unsubscribe', async () => { const handler = jest.fn(); const unsubscribe = responses.subscribe(handler);
await responses.dispatchBlocking(eventFor({ error: slowDown })); expect(handler).toHaveBeenCalledTimes(1);
unsubscribe();
await responses.dispatchBlocking(eventFor({ error: slowDown })); expect(handler).toHaveBeenCalledTimes(1);});
test('dispatchBlocking awaits handlers in registration order', async () => { const order: string[] = [];
responses.subscribe(async () => { await new Promise((resolve) => setTimeout(resolve, 10)); order.push('first'); }); responses.subscribe(() => { order.push('second'); });
await responses.dispatchBlocking(eventFor({ error: slowDown }));
expect(order).toEqual(['first', 'second']);});
test('dispatchBlocking adopts a response returned by a handler', async () => { responses.subscribe(() => ({ result: { recovered: true } }));
const response = await responses.dispatchBlocking(eventFor({ error: slowDown }));
expect(response.result).toEqual({ recovered: true }); expect(response.error).toBeUndefined();});
test('dispatchBlocking still reaches later handlers once the error is resolved', async () => { const later = jest.fn();
responses.subscribe(() => ({ result: { recovered: true } })); responses.subscribe(later);
await responses.dispatchBlocking(eventFor({ error: slowDown }));
// Subscribers are promised every response, so resolving the error must not // cut the dispatch short - but later handlers see the *resolved* response, // which is what stops a second recovery handler retrying redundantly. expect(later).toHaveBeenCalledTimes(1); expect(later.mock.calls[0][0].response).toEqual({ result: { recovered: true } });});
test('dispatchBlocking keeps going when a handler throws', async () => { console.warn = jest.fn(); const after = jest.fn();
responses.subscribe(() => { throw new Error('handler blew up'); }); responses.subscribe(after);
const response = await responses.dispatchBlocking(eventFor({ error: slowDown }));
expect(after).toHaveBeenCalled(); expect(response.error).toBe(slowDown);});
test('dispatch publishes without waiting and survives a rejecting handler', async () => { // The failing handler below is reported via log.warn; silence it so the // expected warning isn't mistaken for a broken test. console.warn = jest.fn(); const seen: ResponseEvent[] = [];
responses.subscribe(() => Promise.reject(new Error('nope'))); responses.subscribe((event) => { seen.push(event); });
responses.dispatch(eventFor({ result: { ok: 1 } }));
expect(seen).toHaveLength(1); expect(seen[0].request.method).toBe('get_status');
// Let the rejected handler settle so it can't leak into another test. await Promise.resolve();});