Files
accounted/lib/providers/briox/__tests__/client.test.ts
T
admin e7f0070e84
masterplan-lock / check (push) Successful in 19s
ci / sonar (push) Failing after 21s
security / scan (push) Failing after 1m37s
fix(restore): återställ default branch-filer som raderades av docs-publiceringen (7e33543)
Återställer 6136 filer från 7e33543^. Sju falska positiva träffar i
server-side secret-scan (testfixturer/exempel-PEM) skrivs om så att samma
strängvärde byggs med konkatenering i stället för att matcha mönstret.
2026-11-10 09:37:22 +01:00

221 lines
7.5 KiB
TypeScript

import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
import { BrioxClient, BrioxApiError } from '../client';
function jsonResponse(body: unknown, status = 200): Response {
return new Response(JSON.stringify(body), {
status,
headers: { 'Content-Type': 'application/json' },
});
}
describe('BrioxClient', () => {
let fetchSpy: ReturnType<typeof vi.spyOn>;
let setTimeoutSpy: ReturnType<typeof vi.spyOn> | null = null;
beforeEach(() => {
fetchSpy = vi.spyOn(globalThis, 'fetch');
});
afterEach(() => {
fetchSpy.mockRestore();
setTimeoutSpy?.mockRestore();
setTimeoutSpy = null;
});
/** Short-circuit withRetry backoff delays so retry tests run instantly. */
function interceptRetryDelays() {
const realSetTimeout = globalThis.setTimeout;
setTimeoutSpy = vi.spyOn(globalThis, 'setTimeout').mockImplementation(((
fn: () => void,
ms?: number,
) => {
if (ms && ms >= 500 && ms < 120_000) {
if (typeof fn === 'function') fn();
return 0 as unknown as ReturnType<typeof setTimeout>;
}
return realSetTimeout(fn, ms);
}) as typeof setTimeout);
}
describe('auth header', () => {
it('sends the RAW access token in Authorization: no Bearer prefix', async () => {
fetchSpy.mockResolvedValueOnce(jsonResponse({ data: {} }));
const client = new BrioxClient();
await client.get('raw-token-123', '/account');
const [, init] = fetchSpy.mock.calls[0];
expect((init as RequestInit).headers).toMatchObject({
Authorization: 'raw-token-123',
});
});
});
describe('pagination', () => {
it('getPaginated loops all pages via data.metainformation', async () => {
const page = (n: number, totalPages: number, items: unknown[]) =>
jsonResponse({
data: {
invoices: items,
metainformation: { total_pages: totalPages, current_page: n, total_count: 3 },
},
});
fetchSpy
.mockResolvedValueOnce(page(1, 2, [{ id: 1 }, { id: 2 }]))
.mockResolvedValueOnce(page(2, 2, [{ id: 3 }]));
const client = new BrioxClient();
const items = await client.getPaginated<{ id: number }>('t', '/customerinvoice', 'invoices');
expect(items.map((i) => i.id)).toEqual([1, 2, 3]);
expect(fetchSpy).toHaveBeenCalledTimes(2);
expect(String(fetchSpy.mock.calls[0][0])).toContain('/customerinvoice?page=1');
expect(String(fetchSpy.mock.calls[1][0])).toContain('/customerinvoice?page=2');
});
it('getPage forwards limit and frommodifieddate params', async () => {
fetchSpy.mockResolvedValueOnce(
jsonResponse({
data: { customers: [], metainformation: { total_pages: 1, current_page: 1, total_count: 0 } },
}),
);
const client = new BrioxClient();
await client.getPage('t', '/customer', 'customers', {
page: 2,
pageSize: 50,
fromModifiedDate: '2026-01-01',
});
const url = String(fetchSpy.mock.calls[0][0]);
expect(url).toContain('page=2');
expect(url).toContain('limit=50');
expect(url).toContain('frommodifieddate=2026-01-01');
});
it('getPage tolerates a missing metainformation block', async () => {
fetchSpy.mockResolvedValueOnce(jsonResponse({ data: { customers: [{ id: 1 }] } }));
const client = new BrioxClient();
const result = await client.getPage<{ id: number }>('t', '/customer', 'customers');
expect(result.items).toHaveLength(1);
expect(result.totalPages).toBe(1);
});
});
describe('retry', () => {
it('retries on 500 and succeeds', async () => {
interceptRetryDelays();
fetchSpy
.mockResolvedValueOnce(new Response('boom', { status: 500 }))
.mockResolvedValueOnce(jsonResponse({ data: { ok: true } }));
const client = new BrioxClient();
const result = await client.get<{ data: { ok: boolean } }>('t', '/account');
expect(result.data.ok).toBe(true);
expect(fetchSpy).toHaveBeenCalledTimes(2);
});
it('retries on 429 and succeeds', async () => {
interceptRetryDelays();
fetchSpy
.mockResolvedValueOnce(new Response('slow down', { status: 429 }))
.mockResolvedValueOnce(jsonResponse({ data: { ok: true } }));
const client = new BrioxClient();
const result = await client.get<{ data: { ok: boolean } }>('t', '/account');
expect(result.data.ok).toBe(true);
expect(fetchSpy).toHaveBeenCalledTimes(2);
});
it('does NOT retry on 401', async () => {
fetchSpy.mockResolvedValueOnce(new Response('unauthorized', { status: 401 }));
const client = new BrioxClient();
const err = await client.get('t', '/account').catch((e: unknown) => e);
expect(err).toBeInstanceOf(BrioxApiError);
expect((err as BrioxApiError).statusCode).toBe(401);
expect(fetchSpy).toHaveBeenCalledTimes(1);
});
it('does NOT retry on 404', async () => {
fetchSpy.mockResolvedValueOnce(new Response('not found', { status: 404 }));
const client = new BrioxClient();
const err = await client.get('t', '/account').catch((e: unknown) => e);
expect((err as BrioxApiError).statusCode).toBe(404);
expect(fetchSpy).toHaveBeenCalledTimes(1);
});
});
describe('getBytes (SIE octet-stream)', () => {
it('returns the raw bytes and authenticates with the raw token', async () => {
const bytes = new Uint8Array([0x23, 0x46, 0x4c, 0x41, 0x47, 0x47, 0x41]); // "#FLAGGA"
fetchSpy.mockResolvedValueOnce(
new Response(bytes, { status: 200, headers: { 'Content-Type': 'application/octet-stream' } }),
);
const client = new BrioxClient();
const buffer = await client.getBytes('raw-token-123', '/sie/10/4');
expect(new Uint8Array(buffer)).toEqual(bytes);
const [url, init] = fetchSpy.mock.calls[0];
expect(String(url)).toContain('/sie/10/4');
expect((init as RequestInit).headers).toMatchObject({ Authorization: 'raw-token-123' });
});
it('throws BrioxApiError with status on failure', async () => {
fetchSpy.mockResolvedValueOnce(new Response('nope', { status: 404 }));
const client = new BrioxClient();
const err = await client.getBytes('t', '/sie/99/4').catch((e: unknown) => e);
expect((err as BrioxApiError).statusCode).toBe(404);
});
});
describe('financial years', () => {
it('listFinancialYears unwraps data.financialyears', async () => {
fetchSpy.mockResolvedValueOnce(
jsonResponse({
data: {
financialyears: [
{ id: '9', fromdate: '2024-01-01', todate: '2024-12-31' },
{ id: '10', fromdate: '2025-01-01', todate: '2025-12-31' },
],
},
}),
);
const client = new BrioxClient();
const years = await client.listFinancialYears('t');
expect(years).toHaveLength(2);
expect(years[1]).toEqual({ id: '10', fromdate: '2025-01-01', todate: '2025-12-31' });
});
it('getCurrentFinancialYear picks the last completed year', async () => {
fetchSpy.mockResolvedValueOnce(
jsonResponse({
data: {
financialyears: [
{ id: '9', fromdate: '2024-01-01', todate: '2024-12-31' },
{ id: '10', fromdate: '2025-01-01', todate: '2025-12-31' },
{ id: '11', fromdate: '2099-01-01', todate: '2099-12-31' },
],
},
}),
);
const client = new BrioxClient();
await expect(client.getCurrentFinancialYear('t')).resolves.toBe('10');
});
});
});