@equinor/fusion-framework-module-http 8.1.0 → 8.1.1

package/tests/HttpClient.test.ts

@@ -1,173 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { lastValueFrom } from 'rxjs';
-
-import { Errors, HttpClientProvider } from '../src';
-import { HttpClientConfigurator } from '../src/configurator';
-import { HttpClient, HttpClientMsal } from '../src/lib';
-import { HttpResponseHandler } from '../src/lib/operators';
-
-let provider: HttpClientProvider;
-
-describe('HttpClient', () => {
-  beforeEach(() => {
-    const config = new HttpClientConfigurator(HttpClient);
-    config.configureClient('foo', 'http://localhost:3000');
-    provider = new HttpClientProvider(config);
-  });
-
-  afterEach(() => {
-    vi.restoreAllMocks();
-  });
-
-  it('should create instance', () => {
-    const client = provider.createClient('foo');
-    expect(client).toBeDefined();
-    expect(client.uri).toBe('http://localhost:3000');
-  });
-
-  it('should allow providing headers in request', async () => {
-    const client = provider.createClient('foo');
-    client.requestHandler.setHeader('x-foo', 'bar');
-
-    const request = await lastValueFrom(
-      client.requestHandler.process({
-        path: '/api',
-        uri: client.uri,
-        headers: { 'x-bar': 'baz' },
-      }),
-    );
-
-    const headers = request.headers as Headers;
-    expect(headers.get('x-foo')).toBe('bar');
-    expect(headers.get('x-bar')).toBe('baz');
-  });
-
-  it('should not modify configured headers', async () => {
-    const fooClient = provider.createClient('foo');
-    fooClient.requestHandler.setHeader('x-foo', 'bar');
-
-    const fooRequest = await lastValueFrom(
-      fooClient.requestHandler.process({ path: '/api', uri: fooClient.uri }),
-    );
-
-    expect((fooRequest.headers as Headers)?.get('x-foo')).toBe('bar');
-
-    const barClient = provider.createClient('foo');
-    const barRequest = await lastValueFrom(
-      barClient.requestHandler.process({ path: '/api', uri: barClient.uri }),
-    );
-
-    expect((barRequest.headers as Headers)?.get('x-foo')).toBeUndefined();
-  });
-
-  it('should execute configured response handlers from client options', async () => {
-    const responseSpy = vi.fn();
-    const config = new HttpClientConfigurator(HttpClient);
-
-    config.configureClient('bar', {
-      baseUri: 'http://localhost:3000',
-      responseHandler: new HttpResponseHandler({
-        'response-spy': responseSpy,
-      }),
-    });
-
-    const localProvider = new HttpClientProvider(config);
-    vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response(null, { status: 200 }));
-
-    await localProvider.createClient('bar').fetch('/api');
-
-    expect(responseSpy).toHaveBeenCalledTimes(1);
-  });
-
-  it('should emit the original path on the request stream', async () => {
-    const requestSpy = vi.fn();
-    vi.spyOn(globalThis, 'fetch').mockResolvedValue(new Response(null, { status: 200 }));
-
-    const client = provider.createClient('foo');
-    const subscription = client.request$.subscribe(requestSpy);
-
-    await client.fetch('/api');
-    subscription.unsubscribe();
-
-    expect(requestSpy).toHaveBeenCalledWith(
-      expect.objectContaining({
-        path: '/api',
-        uri: 'http://localhost:3000/api',
-      }),
-    );
-  });
-
-  it('should throw when a configured client cannot be found', () => {
-    expect(() => provider.createClient('missing-client')).toThrowError(
-      new Errors.ClientNotFoundException('No registered http client for key [missing-client]'),
-    );
-  });
-
-  it('should treat a bare hostname as https:// URL with a warning', () => {
-    const warnSpy = vi.spyOn(console, 'warn').mockImplementation(() => {});
-    const client = provider.createClient('api.example.com');
-    expect(client.uri).toBe('https://api.example.com');
-    expect(warnSpy).toHaveBeenCalledWith(
-      expect.stringContaining('missing the http:// or https:// protocol'),
-    );
-  });
-
-  it('runs middleware registered through the configurator around every created client', async () => {
-    const config = new HttpClientConfigurator(HttpClient);
-    config.configureClient('foo', 'http://localhost:3000');
-    config.addMiddleware(() => Response.json('from-middleware'));
-
-    const client = new HttpClientProvider(config).createClient('foo');
-
-    await expect(client.json('/api')).resolves.toBe('from-middleware');
-  });
-
-  it('lets middleware call next through to the real network call', async () => {
-    vi.spyOn(globalThis, 'fetch').mockResolvedValue(Response.json('from-network'));
-
-    const config = new HttpClientConfigurator(HttpClient);
-    config.configureClient('foo', 'http://localhost:3000');
-    config.addMiddleware((uri, init, next) => next(uri, init));
-
-    const client = new HttpClientProvider(config).createClient('foo');
-
-    await expect(client.json('/api')).resolves.toBe('from-network');
-  });
-
-  it('aborts the underlying fetch on abort(), even behind a pass-through middleware', async () => {
-    // `next(...)` resolves through a Promise (`HttpMiddlewareHandler`'s `toPromise`), so this
-    // asserts the fix doesn't rely on RxJS unsubscription reaching `_performFetch` through it.
-    const fetchSpy = vi.spyOn(globalThis, 'fetch').mockImplementation(
-      (_input, init) =>
-        new Promise((_resolve, reject) => {
-          init?.signal?.addEventListener('abort', () => reject(init.signal?.reason));
-        }),
-    );
-
-    const config = new HttpClientConfigurator(HttpClient);
-    config.configureClient('foo', 'http://localhost:3000');
-    config.addMiddleware((uri, init, next) => next(uri, init));
-
-    const client = new HttpClientProvider(config).createClient('foo');
-    const request = client.json('/api');
-    // let the request reach `_performFetch` (and register the abort listener) before aborting
-    await vi.waitFor(() => expect(fetchSpy).toHaveBeenCalledTimes(1));
-    client.abort();
-
-    await expect(request).rejects.toBeDefined();
-    expect(fetchSpy.mock.calls[0][1]?.signal?.aborted).toBe(true);
-  });
-});
-
-describe('HttpClientMsal', () => {
-  it('should not mutate the provided request init object', () => {
-    const client = new HttpClientMsal('http://localhost:3000');
-    client.defaultScopes = ['scope.default'];
-
-    const init = { scopes: ['scope.request'] };
-
-    client.fetch$('/api', init);
-
-    expect(init).toStrictEqual({ scopes: ['scope.request'] });
-  });
-});

package/tests/HttpMiddlewareHandler.test.ts

@@ -1,58 +0,0 @@
-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

@@ -1,62 +0,0 @@
-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

@@ -1,135 +0,0 @@
-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/tests/operators.test.ts

@@ -1,137 +0,0 @@
-/* eslint-disable @typescript-eslint/ban-ts-comment */
-import { describe, it, expect, vi } from 'vitest';
-import { lastValueFrom, of } from 'rxjs';
-import { toArray } from 'rxjs/operators';
-import {
-  capitalizeRequestMethodOperator,
-  type ProcessOperator,
-  requestValidationOperator,
-  sseMap,
-} from '../src/lib/operators';
-import type { FetchRequest } from '../src/lib';
-
-const executeOperator = <R, O extends ProcessOperator<FetchRequest, R>>(
-  operator: O,
-  request: Parameters<O>[0],
-): Promise<ReturnType<O>> => {
-  return new Promise((resolve, rejects) => {
-    try {
-      resolve(operator(request) as ReturnType<O>);
-    } catch (error) {
-      rejects(error);
-    }
-  });
-};
-
-describe('capitalizeRequestMethodOperator', () => {
-  it('should capitalize request method', async () => {
-    const consoleWarn = vi.spyOn(console, 'warn').mockImplementationOnce((msg) => {
-      expect(msg).toMatch(/RFC 7231/);
-    });
-
-    const operator = capitalizeRequestMethodOperator();
-
-    const result = executeOperator(operator, { method: 'get' });
-
-    await expect(result).resolves.toMatchObject({ method: 'GET' });
-    expect(consoleWarn).toHaveBeenCalled();
-  });
-
-  it('should handle undefined request method', async () => {
-    const operator = capitalizeRequestMethodOperator();
-
-    const result = executeOperator(operator, { method: undefined });
-
-    await expect(result).resolves.toMatchObject({ method: undefined });
-  });
-});
-
-describe('requestValidationOperator', () => {
-  /**
-   * A mock FetchRequest object used for testing purposes.
-   */
-  const mockRequest: FetchRequest = Object.freeze({
-    method: 'GET',
-    uri: 'https://foo.bar',
-    path: 'api',
-  });
-
-  it('should pass validation for valid request parameters', async () => {
-    const operator = requestValidationOperator();
-
-    const result = executeOperator(operator, mockRequest);
-
-    await expect(result).resolves.toBeUndefined();
-  });
-
-  it('should parse valid request parameters', async () => {
-    const operator = requestValidationOperator({ parse: true });
-
-    const result = executeOperator(operator, mockRequest);
-
-    await expect(result).resolves.toStrictEqual(mockRequest);
-  });
-
-  it('should allow additional properties when strict validation is disabled', async () => {
-    const operator = requestValidationOperator({ parse: true });
-
-    const result = executeOperator(operator, {
-      ...mockRequest,
-      // @ts-expect-error
-      additionalProperty: 'some-value',
-    });
-
-    await expect(result).resolves.toMatchObject(mockRequest);
-    await expect(result).resolves.toHaveProperty('additionalProperty', 'some-value');
-  });
-
-  it('should remove additional properties when strict validation is enabled', async () => {
-    const operator = requestValidationOperator({ parse: true, strict: true });
-
-    const result = executeOperator(operator, {
-      ...mockRequest,
-      // @ts-expect-error
-      additionalProperty: 'some-value',
-      method: 'GET',
-    });
-
-    await expect(result).resolves.toStrictEqual(mockRequest);
-    await expect(result).resolves.not.toHaveProperty('additionalProperty');
-  });
-
-  it('should throw an error for invalid request parameters', async () => {
-    const operator = requestValidationOperator({ parse: true });
-
-    const result = executeOperator(operator, {
-      ...mockRequest,
-      method: 'GETS', // invalid method
-    });
-
-    await expect(result).rejects.toThrowError('RFC 2615');
-  });
-});
-
-describe('sseMap', () => {
-  it('should map SSE responses through the operators index export', async () => {
-    const response = new Response(
-      new ReadableStream({
-        start(controller) {
-          controller.enqueue(new TextEncoder().encode('data: {"key": "value"}\n\n'));
-          controller.close();
-        },
-      }),
-      {
-        headers: { 'Content-Type': 'text/event-stream' },
-        status: 200,
-      },
-    );
-
-    const events = await lastValueFrom(
-      of(response)
-        // parse the SSE stream and collect every emitted event into a single array
-        .pipe(sseMap<{ key: string }>(), toArray()),
-    );
-
-    expect(events).toEqual([{ data: { key: 'value' } }]);
-  });
-});