alice.pds.demo.boltless.dev
This repository has no description
1import { describe, expect, it, vi } from 'vitest';
2import { ClientResponseError } from './client';
3import { createRequestCache, httpStatusFor, parallel, toHttpError } from './load';
4
5const cre = (status: number, error: string, message?: string): ClientResponseError =>
6 new ClientResponseError({ status, data: { error, message } });
7
8describe('httpStatusFor', () => {
9 it('passes through an in-band XRPC status', () => {
10 expect(httpStatusFor(cre(404, 'RecordNotFound'))).toBe(404);
11 });
12
13 it('prefers an in-band status over the error-name mapping', () => {
14 // status 503 is in [400,599] so it wins even though the name maps to 404.
15 expect(httpStatusFor(cre(503, 'RecordNotFound'))).toBe(503);
16 });
17
18 it('maps the error name when the status is out of the 400-599 band', () => {
19 expect(httpStatusFor(cre(200, 'RecordNotFound'))).toBe(404);
20 expect(httpStatusFor(cre(200, 'InvalidRequest'))).toBe(400);
21 expect(httpStatusFor(cre(200, 'UpstreamFailed'))).toBe(502);
22 expect(httpStatusFor(cre(200, 'UpstreamGone'))).toBe(502);
23 expect(httpStatusFor(cre(200, 'InvalidRecord'))).toBe(502);
24 expect(httpStatusFor(cre(200, 'Overloaded'))).toBe(503);
25 expect(httpStatusFor(cre(200, 'SomethingElse'))).toBe(500);
26 });
27
28 it('maps any non-XRPC cause to 500', () => {
29 expect(httpStatusFor(new Error('boom'))).toBe(500);
30 expect(httpStatusFor('a string')).toBe(500);
31 expect(httpStatusFor(undefined)).toBe(500);
32 expect(httpStatusFor({ status: 404 })).toBe(500);
33 });
34});
35
36describe('toHttpError', () => {
37 it('throws a SvelteKit error with the mapped status and the XRPC description', () => {
38 let thrown: unknown;
39 try {
40 toHttpError(cre(404, 'RecordNotFound', 'no such repo'));
41 } catch (e) {
42 thrown = e;
43 }
44 expect(thrown).toMatchObject({ status: 404, body: { message: 'no such repo' } });
45 });
46
47 it('falls back to the error name when the description is absent', () => {
48 let thrown: unknown;
49 try {
50 toHttpError(cre(200, 'Overloaded'));
51 } catch (e) {
52 thrown = e;
53 }
54 expect(thrown).toMatchObject({ status: 503, body: { message: 'Overloaded' } });
55 });
56
57 it('uses the fallback message + 500 for a non-XRPC cause', () => {
58 let thrown: unknown;
59 try {
60 toHttpError(new Error('boom'), 'could not load');
61 } catch (e) {
62 thrown = e;
63 }
64 expect(thrown).toMatchObject({ status: 500, body: { message: 'could not load' } });
65 });
66});
67
68describe('parallel', () => {
69 it('preserves key/value pairing regardless of settle order', async () => {
70 // deferred across a few microtasks (no real timer) so it settles after `fast`.
71 const slow = Promise.resolve()
72 .then(() => Promise.resolve())
73 .then(() => 'slow');
74 const result = await parallel({ fast: Promise.resolve('fast'), slow });
75 expect(result).toEqual({ fast: 'fast', slow: 'slow' });
76 });
77
78 it('resolves to an empty object for no tasks', async () => {
79 await expect(parallel({})).resolves.toEqual({});
80 });
81
82 it('rejects if any input promise rejects', async () => {
83 await expect(
84 parallel({ a: Promise.resolve(1), b: Promise.reject(new Error('boom')) })
85 ).rejects.toThrow('boom');
86 });
87});
88
89describe('createRequestCache', () => {
90 it('invokes the loader once per key and shares the value', async () => {
91 const cache = createRequestCache();
92 const load = vi.fn(async () => 42);
93
94 const first = await cache.run('k', load);
95 const second = await cache.run('k', load);
96
97 expect(first).toBe(42);
98 expect(second).toBe(42);
99 expect(load).toHaveBeenCalledTimes(1);
100 });
101
102 it('shares one in-flight promise for concurrent same-key calls', () => {
103 const cache = createRequestCache();
104 const load = vi.fn(async () => 'v');
105
106 const a = cache.run('k', load);
107 const b = cache.run('k', load);
108
109 expect(a).toBe(b);
110 expect(load).toHaveBeenCalledTimes(1);
111 });
112
113 it('runs distinct keys independently', async () => {
114 const cache = createRequestCache();
115 const load = vi.fn(async (key: string) => key.toUpperCase());
116
117 await cache.run('a', () => load('a'));
118 await cache.run('b', () => load('b'));
119
120 expect(load).toHaveBeenCalledTimes(2);
121 });
122});