@equinor/fusion-framework-module-http 8.0.5 → 8.1.0-next.0

package/tests/HttpMiddlewareHandler.test.ts

@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'vitest';
+import { firstValueFrom } from 'rxjs';
+
+import { HttpMiddlewareHandler } from '../src/lib/operators';
+import type { HttpMiddleware } from '../src/lib/operators';
+
+const terminal = (): Promise<Response> => Promise.resolve(Response.json('from-network'));
+
+describe('HttpMiddlewareHandler', () => {
+  it('calls the terminal step when no middleware is registered', async () => {
+    const handler = new HttpMiddlewareHandler();
+
+    const response = await firstValueFrom(handler.process('https://api.example.com', {}, terminal));
+
+    await expect(response.json()).resolves.toBe('from-network');
+  });
+
+  it('runs registered middleware outermost-first, wrapping the terminal step', async () => {
+    const handler = new HttpMiddlewareHandler();
+    const order: string[] = [];
+
+    const trace =
+      (name: string): HttpMiddleware =>
+      async (uri, init, next) => {
+        order.push(`${name}-before`);
+        const response = await next(uri, init);
+        order.push(`${name}-after`);
+        return response;
+      };
+
+    handler.use(trace('outer'));
+    handler.use(trace('inner'));
+
+    await firstValueFrom(handler.process('https://api.example.com', {}, terminal));
+
+    expect(order).toEqual(['outer-before', 'inner-before', 'inner-after', 'outer-after']);
+  });
+
+  it('short-circuits when a middleware never calls next', async () => {
+    const handler = new HttpMiddlewareHandler();
+    handler.use(() => Response.json('from-middleware'));
+
+    const response = await firstValueFrom(handler.process('https://api.example.com', {}, terminal));
+
+    await expect(response.json()).resolves.toBe('from-middleware');
+  });
+
+  it('clones registered middleware from another handler without sharing mutations', () => {
+    const source = new HttpMiddlewareHandler();
+    source.use(() => Response.json('a'));
+
+    const clone = new HttpMiddlewareHandler(source);
+    clone.use(() => Response.json('b'));
+
+    expect(source.middleware).toHaveLength(1);
+    expect(clone.middleware).toHaveLength(2);
+  });
+});

package/tests/mock/adapters.test.ts

@@ -0,0 +1,62 @@
+import { describe, expect, it, vi } from 'vitest';
+
+import { createOpenApiMockMiddleware } from '../../src/mock/create-open-api-mock-middleware';
+
+describe('createOpenApiMockMiddleware', () => {
+  it('answers a matching request without calling next', async () => {
+    const middleware = createOpenApiMockMiddleware({
+      resolve: async ({ method, path }) =>
+        method === 'GET' && path === '/pets/1'
+          ? { status: 200, mock: { id: '1', name: 'Rex' } }
+          : undefined,
+    });
+    const next = vi.fn();
+
+    const response = await middleware('http://localhost/pets/1', { method: 'GET' }, next);
+
+    expect(response instanceof Response ? response.status : undefined).toBe(200);
+    expect(response instanceof Response ? await response.json() : undefined).toEqual({
+      id: '1',
+      name: 'Rex',
+    });
+    expect(next).not.toHaveBeenCalled();
+  });
+
+  it('falls through to next when the OpenApiMock has no matching operation', async () => {
+    const middleware = createOpenApiMockMiddleware({ resolve: async () => undefined });
+    const fallback = Response.json({ ok: true });
+    const next = vi.fn(async () => fallback);
+
+    const response = await middleware('http://localhost/unknown', { method: 'GET' }, next);
+
+    expect(next).toHaveBeenCalledWith('http://localhost/unknown', { method: 'GET' });
+    expect(response).toBe(fallback);
+  });
+
+  it('defaults to GET when init has no method', async () => {
+    const resolve = vi.fn(async () => undefined);
+    const middleware = createOpenApiMockMiddleware({ resolve });
+
+    await middleware(
+      'http://localhost/pets/1',
+      {},
+      vi.fn(async () => Response.json(null)),
+    );
+
+    expect(resolve).toHaveBeenCalledWith(
+      expect.objectContaining({ method: 'GET', path: '/pets/1' }),
+    );
+  });
+
+  it('forwards query parameters to resolve()', async () => {
+    const middleware = createOpenApiMockMiddleware({
+      resolve: async ({ query }) => ({ status: 200, mock: query }),
+    });
+
+    const response = await middleware('http://localhost/items?page=2', { method: 'GET' }, vi.fn());
+
+    expect(response instanceof Response ? await response.json() : undefined).toEqual({
+      page: '2',
+    });
+  });
+});

package/tests/mock/router-middleware.test.ts

@@ -0,0 +1,135 @@
+import { firstValueFrom, from } from 'rxjs';
+import type { ObservableInput } from 'rxjs';
+import { describe, expect, it } from 'vitest';
+
+import { createRouterMiddleware } from '../../src/mock/create-router-middleware';
+
+const next = async (): Promise<Response> => new Response(null, { status: 599 });
+
+// HttpMiddleware may return an ObservableInput, so tests can't assume the result is a Response.
+const toResponse = (result: Response | ObservableInput<Response>): Promise<Response> =>
+  result instanceof Response ? Promise.resolve(result) : firstValueFrom(from(result));
+
+describe('createRouterMiddleware', () => {
+  it('answers a matching route without calling next', async () => {
+    const middleware = createRouterMiddleware('https://api.example.com', (router) => {
+      router.get('/items', () => Response.json([{ id: 1 }]));
+    });
+
+    const response = await toResponse(
+      middleware('https://api.example.com/items', { method: 'GET' }, next),
+    );
+
+    await expect(response.json()).resolves.toEqual([{ id: 1 }]);
+  });
+
+  it('extracts path parameters from a `:param` segment', async () => {
+    const middleware = createRouterMiddleware('https://api.example.com', (router) => {
+      router.get('/items/:id', ({ params }) => Response.json({ id: params.id }));
+    });
+
+    const response = await toResponse(
+      middleware('https://api.example.com/items/42', { method: 'GET' }, next),
+    );
+
+    await expect(response.json()).resolves.toEqual({ id: '42' });
+  });
+
+  it('falls through to next when no route matches', async () => {
+    const middleware = createRouterMiddleware('https://api.example.com', (router) => {
+      router.get('/items', () => Response.json([]));
+    });
+
+    const response = await toResponse(
+      middleware('https://api.example.com/unknown', { method: 'GET' }, next),
+    );
+
+    expect(response.status).toBe(599);
+  });
+
+  it('falls through to next when the method does not match', async () => {
+    const middleware = createRouterMiddleware('https://api.example.com', (router) => {
+      router.get('/items', () => Response.json([]));
+    });
+
+    const response = await toResponse(
+      middleware('https://api.example.com/items', { method: 'POST' }, next),
+    );
+
+    expect(response.status).toBe(599);
+  });
+
+  it('falls through to next for a request to a different origin', async () => {
+    const middleware = createRouterMiddleware('https://api.example.com', (router) => {
+      router.get('/items', () => Response.json([]));
+    });
+
+    const response = await toResponse(
+      middleware('https://other.example.com/items', { method: 'GET' }, next),
+    );
+
+    expect(response.status).toBe(599);
+  });
+
+  it('matches non-overlapping routes independently of registration order', async () => {
+    const middleware = createRouterMiddleware('https://api.example.com', (router) => {
+      router.get('/items/:id/relations', () => Response.json({ from: 'relations' }));
+      router.get('/items/:id', () => Response.json({ from: 'single' }));
+    });
+
+    const response = await toResponse(
+      middleware('https://api.example.com/items/1/relations', { method: 'GET' }, next),
+    );
+
+    await expect(response.json()).resolves.toEqual({ from: 'relations' });
+  });
+
+  it('the first registered route wins when two patterns both match', async () => {
+    const middleware = createRouterMiddleware('https://api.example.com', (router) => {
+      router.get('/items/:id', () => Response.json({ from: 'first' }));
+      router.get('/items/:id', () => Response.json({ from: 'second' }));
+    });
+
+    const response = await toResponse(
+      middleware('https://api.example.com/items/1', { method: 'GET' }, next),
+    );
+
+    await expect(response.json()).resolves.toEqual({ from: 'first' });
+  });
+
+  it('`.on` matches any method when none is given', async () => {
+    const middleware = createRouterMiddleware('https://api.example.com', (router) => {
+      router.on(undefined, '/items', () => Response.json({ ok: true }));
+    });
+
+    const response = await toResponse(
+      middleware('https://api.example.com/items', { method: 'DELETE' }, next),
+    );
+
+    await expect(response.json()).resolves.toEqual({ ok: true });
+  });
+
+  it('exposes query parameters through `url.searchParams`', async () => {
+    const middleware = createRouterMiddleware('https://api.example.com', (router) => {
+      router.get('/items', ({ url }) => Response.json({ search: url.searchParams.get('q') }));
+    });
+
+    const response = await toResponse(
+      middleware('https://api.example.com/items?q=needle', { method: 'GET' }, next),
+    );
+
+    await expect(response.json()).resolves.toEqual({ search: 'needle' });
+  });
+
+  it('strips a non-root base path before matching the route template', async () => {
+    const middleware = createRouterMiddleware('https://api.example.com/v1', (router) => {
+      router.get('/items', () => Response.json({ ok: true }));
+    });
+
+    const response = await toResponse(
+      middleware('https://api.example.com/v1/items', { method: 'GET' }, next),
+    );
+
+    await expect(response.json()).resolves.toEqual({ ok: true });
+  });
+});

package/vitest.config.ts

@@ -1,6 +1,6 @@
 import { defineProject } from 'vitest/config';
 
-import { name, version } from './package.json';
+import { name, version } from './package.json' with { type: 'json' };
 
 export default defineProject({
   test: {