@bleedingdev/modern-js-runtime-extensions 3.9.0-ultramodern.9 → 3.9.3-ultramodern.10

package/tests/routeHydration.test.ts

@@ -1,180 +0,0 @@
-import {
-  createRouteHydrationScriptTags,
-  getMatchedRouteChunks,
-  injectBeforeHydrationEntryScript,
-  orderHydrationScriptChunks,
-  replaceChunkJsPlaceholder,
-} from '../src/routeHydration';
-
-const manifest = {
-  routeAssets: {
-    layout: { assets: ['/shared.js', '/layout.css'] },
-    page: { assets: ['/page.js', '/shared.js'] },
-    empty: {},
-    missing: undefined,
-    'async-main': { assets: ['/shared.js', '/async-main.hash.js'] },
-  },
-};
-
-const tag = (src: string) => `<script src="${src}"></script>`;
-
-describe('route hydration policy', () => {
-  it('maps matched assets in route order without deduplicating or filtering', () => {
-    const mapped = getMatchedRouteChunks(
-      manifest,
-      ['layout', 'unknown', 'empty', 'missing', 'page'],
-      asset => ({ url: asset, marker: 'preserved' }),
-    );
-    expect(mapped).toEqual(
-      ['/shared.js', '/layout.css', '/page.js', '/shared.js'].map(url => ({
-        url,
-        marker: 'preserved',
-      })),
-    );
-  });
-
-  it('returns no chunks for an explicit missing manifest or empty matches', () => {
-    const toChunk = rstest.fn((url: string) => ({ url }));
-    expect(getMatchedRouteChunks(undefined, ['page'], toChunk)).toEqual([]);
-    expect(getMatchedRouteChunks({}, ['page'], toChunk)).toEqual([]);
-    expect(getMatchedRouteChunks(manifest, [], toChunk)).toEqual([]);
-    expect(toChunk).not.toHaveBeenCalled();
-    expect(createRouteHydrationScriptTags(undefined, ['page'], 'main')).toBe(
-      '',
-    );
-    expect(createRouteHydrationScriptTags({}, ['page'], 'main')).toBe('');
-  });
-
-  it('keeps dependencies, collected chunks and route chunks before async entry', () => {
-    const dependency = { url: '/dependency.js', marker: 'dependency' };
-    const collected = { url: '/collected.js', marker: 'collected' };
-    const route = { url: '/route.js', marker: 'route' };
-    const entry = { url: '/async-main.hash.js', marker: 'entry' };
-    const asyncEntryChunks = [entry, dependency];
-    const result = orderHydrationScriptChunks({
-      asyncEntryChunks,
-      collectedChunks: [collected, { ...dependency, marker: 'duplicate' }],
-      matchedRouteChunks: [route, { url: '' }, {}, { ...collected }],
-      entryName: 'main',
-    });
-    expect(result).toEqual([dependency, collected, route, entry]);
-    expect(result[0]).toBe(dependency);
-    expect(result[1]).toBe(collected);
-    expect(asyncEntryChunks).toEqual([entry, dependency]);
-  });
-
-  it('classifies async entries using filename while retaining the JS URL rule', () => {
-    const entry = { url: '/opaque.js', filename: 'nested/async-main-hash.js' };
-    const queried = { url: '/async-main.js?hash=1' };
-    const otherEntry = { url: '/async-other.js' };
-    const asset = { url: '/async-main.css' };
-    const route = { url: '/route.js' };
-    expect(
-      orderHydrationScriptChunks({
-        asyncEntryChunks: [entry, queried, otherEntry, asset],
-        collectedChunks: [],
-        matchedRouteChunks: [route],
-        entryName: 'main',
-      }),
-    ).toEqual([queried, otherEntry, asset, route, entry]);
-  });
-
-  it('serializes unique JS route assets then async assets and matches exact src', () => {
-    expect(
-      createRouteHydrationScriptTags(manifest, ['layout', 'page'], 'main', {
-        template: `${tag('/page.js.map')}${tag('/shared.js')}`,
-      }),
-    ).toBe(`${tag('/page.js')} ${tag('/async-main.hash.js')}`);
-    expect(createRouteHydrationScriptTags(manifest, [], 'main')).toBe(
-      `${tag('/shared.js')} ${tag('/async-main.hash.js')}`,
-    );
-  });
-
-  it('escapes asset and nonce attributes and omits empty nonce', () => {
-    const unsafeManifest = {
-      routeAssets: {
-        page: { assets: ['/route" onload="alert(1)&x=<tag>.js'] },
-      },
-    };
-    expect(
-      createRouteHydrationScriptTags(unsafeManifest, ['page'], 'main', {
-        nonce: 'nonce"&<value>',
-      }),
-    ).toBe(
-      '<script src="/route&quot; onload=&quot;alert(1)&amp;x=&lt;tag&gt;.js" nonce="nonce&quot;&amp;&lt;value&gt;"></script>',
-    );
-    expect(
-      createRouteHydrationScriptTags(manifest, ['page'], 'other', {
-        nonce: '',
-      }),
-    ).toBe(`${tag('/page.js')} ${tag('/shared.js')}`);
-  });
-
-  it('prefers the main entry even when an async entry appears earlier', () => {
-    const asyncEntry = tag('/async-main.hash.js');
-    const entry =
-      "<script defer src='/nested/main-hash.js?build=1#hash'></script>";
-    const template = `${asyncEntry}${entry}`;
-    expect(injectBeforeHydrationEntryScript(template, 'ROUTE', 'main')).toBe(
-      `${asyncEntry}ROUTE${entry}`,
-    );
-  });
-
-  it('falls back to async entry and preserves templates with no entry', () => {
-    const asyncEntry = tag('/nested/async-main.js');
-    expect(injectBeforeHydrationEntryScript(asyncEntry, 'ROUTE', 'main')).toBe(
-      `ROUTE${asyncEntry}`,
-    );
-    expect(injectBeforeHydrationEntryScript(tag('/index.js'), 'ROUTE')).toBe(
-      `ROUTE${tag('/index.js')}`,
-    );
-    const other = tag('/other-main.js');
-    expect(injectBeforeHydrationEntryScript(other, 'ROUTE', 'main')).toBe(
-      other,
-    );
-    expect(injectBeforeHydrationEntryScript(asyncEntry, '', 'main')).toBe(
-      asyncEntry,
-    );
-  });
-
-  it('moves placeholder scripts before hydration and replaces literal text safely', () => {
-    const placeholder = '<!-- chunks -->';
-    const scripts = '<script src="/$&-$`-$\'.js"></script>';
-    const entry = tag('/main.js');
-    expect(
-      replaceChunkJsPlaceholder(
-        `${entry}${placeholder}`,
-        scripts,
-        'main',
-        placeholder,
-      ),
-    ).toBe(`${scripts}${entry}`);
-    expect(
-      replaceChunkJsPlaceholder(
-        `before${placeholder}after`,
-        scripts,
-        'main',
-        placeholder,
-      ),
-    ).toBe(`before${scripts}after`);
-    expect(replaceChunkJsPlaceholder(entry, scripts, 'main', placeholder)).toBe(
-      entry,
-    );
-    expect(
-      replaceChunkJsPlaceholder(
-        `${entry}${placeholder}`,
-        '',
-        'main',
-        placeholder,
-      ),
-    ).toBe(entry);
-    expect(
-      replaceChunkJsPlaceholder(
-        `${placeholder}${placeholder}`,
-        '',
-        undefined,
-        placeholder,
-      ),
-    ).toBe(placeholder);
-  });
-});

package/tests/routerPrefetchPolicy.test.ts

@@ -1,102 +0,0 @@
-import { createRouterPrefetchPolicy } from '../src/routerPrefetchPolicy';
-
-const settle = async () => {
-  for (let turn = 0; turn < 10; turn += 1) await Promise.resolve();
-};
-
-afterEach(() => rstest.useRealTimers());
-
-test('implements render defaults and cancels delayed intent before dispatch', async () => {
-  rstest.useFakeTimers();
-  const policy = createRouterPrefetchPolicy();
-  const notify = rstest.fn();
-  const render = policy.observe({ element: null, notify });
-  expect(notify).toHaveBeenLastCalledWith({ code: true, data: true });
-  render.dispose();
-  const intent = policy.observe({
-    element: null,
-    prefetch: 'none',
-    preload: 'intent',
-    notify,
-  });
-  intent.onIntent();
-  intent.onCancel();
-  await rstest.advanceTimersByTimeAsync(100);
-  expect(notify).toHaveBeenLastCalledWith({ code: false, data: false });
-  intent.onIntent();
-  await rstest.advanceTimersByTimeAsync(100);
-  expect(notify).toHaveBeenLastCalledWith({ code: true, data: false });
-  intent.dispose();
-});
-
-test('limits concurrent loads, removes cancelled queued keys, and retries rejected loads', async () => {
-  const policy = createRouterPrefetchPolicy();
-  const context = {};
-  const loader = {};
-  const started: number[] = [];
-  const releases: (() => void)[] = [];
-  const schedule = (id: number) =>
-    policy.schedule({
-      runtimeContext: context,
-      chunkLoader: loader,
-      publicPath: '/',
-      key: String(id),
-      run: () => {
-        started.push(id);
-        return new Promise<void>(resolve => releases.push(resolve));
-      },
-    });
-  const cancellations = Array.from({ length: 6 }, (_, id) => schedule(id));
-  await settle();
-  expect(started).toEqual([0, 1, 2, 3]);
-  cancellations[4]();
-  releases[0]();
-  await settle();
-  expect(started).toEqual([0, 1, 2, 3, 5]);
-  schedule(4);
-  releases[1]();
-  await settle();
-  expect(started).toEqual([0, 1, 2, 3, 5, 4]);
-  for (const release of releases) release();
-  await settle();
-  const fail = rstest.fn(() => Promise.reject(new Error('retry')));
-  const options = {
-    runtimeContext: context,
-    chunkLoader: loader,
-    publicPath: '/',
-    key: 'failed',
-    run: fail,
-  };
-  policy.schedule(options);
-  await settle();
-  policy.schedule(options);
-  await settle();
-  expect(fail).toHaveBeenCalledTimes(2);
-});
-
-test('deduplicates only within matching context, loader, public path and live TTL', async () => {
-  let now = 0;
-  rstest.spyOn(performance, 'now').mockImplementation(() => now);
-  const policy = createRouterPrefetchPolicy();
-  const run = rstest.fn(() => Promise.resolve());
-  const options = {
-    runtimeContext: {},
-    chunkLoader: {},
-    publicPath: '/',
-    key: 'route',
-    run,
-  };
-  policy.schedule(options);
-  policy.schedule(options);
-  await settle();
-  expect(run).toHaveBeenCalledTimes(1);
-  policy.schedule({ ...options, runtimeContext: {} });
-  policy.schedule({ ...options, chunkLoader: {} });
-  policy.schedule({ ...options, publicPath: '/other/' });
-  await settle();
-  expect(run).toHaveBeenCalledTimes(4);
-  now = 30_001;
-  policy.schedule(options);
-  await settle();
-  expect(run).toHaveBeenCalledTimes(5);
-});

package/tests/routerProvider.test.ts

@@ -1,29 +0,0 @@
-import { createRouterPlugin } from '../src/routerProvider';
-
-test('selects the injected app-local factory from runtime config and preserves native hook objects', () => {
-  const registryHooks = { afterCreate: { call() {} } };
-  const defaultFactory = rstest.fn(() => ({ setup: rstest.fn() }));
-  const setup = rstest.fn();
-  const localFactory = rstest.fn(() => ({ registryHooks, setup }));
-  const plugin = createRouterPlugin({
-    defaultProvider: { name: 'native', factory: defaultFactory },
-    registryHooks,
-    localProviders: [{ name: 'custom', factory: localFactory }],
-  })();
-  const api = { getRuntimeConfig: () => ({ router: { framework: 'custom' } }) };
-  expect(plugin.registryHooks).toBe(registryHooks);
-  plugin.setup(api);
-  expect(localFactory).toHaveBeenCalledWith({});
-  expect(setup).toHaveBeenCalledWith(api);
-  expect(defaultFactory).not.toHaveBeenCalled();
-});
-
-test('rejects missing local providers', () => {
-  const factory = createRouterPlugin({
-    defaultProvider: { name: 'native', factory: () => ({}) },
-    registryHooks: {},
-  });
-  expect(() =>
-    factory({ framework: 'foreign' }).setup({ getRuntimeConfig: () => ({}) }),
-  ).toThrow(/app-owned router provider realm/);
-});

package/tests/routerState.test.ts

@@ -1,78 +0,0 @@
-import {
-  applyRouterRuntimeState,
-  applyRouterServerPrepareResult,
-  cleanupRouterRuntimeState,
-  getRouterHydrationScripts,
-  getRouterMatchedRouteIds,
-  getRouterRuntimeState,
-  getRouterServerSnapshot,
-} from '../src/routerState';
-
-describe('router state primitives', () => {
-  it('preserves snapshot precedence and a captured snapshot across client state updates', () => {
-    const context = { requestId: 'one' };
-    expect(
-      applyRouterRuntimeState(context, {
-        framework: 'custom',
-        basename: '/client',
-        hydrationScripts: ['client'],
-        matchedRouteIds: ['client-route'],
-        serverSnapshot: {
-          basename: '/server',
-          hydrationScripts: ['server'],
-          matchedRouteIds: ['server-route'],
-        },
-      }),
-    ).toBe(context);
-    const snapshot = getRouterServerSnapshot(context);
-    expect(snapshot).toMatchObject({
-      framework: 'custom',
-      basename: '/server',
-      hydrationScripts: ['server'],
-      matchedRouteIds: ['server-route'],
-    });
-    expect(getRouterHydrationScripts(context)).toEqual(['server']);
-    expect(getRouterMatchedRouteIds(context)).toEqual(['server-route']);
-
-    applyRouterRuntimeState(context, {
-      framework: 'custom',
-      instance: { client: true },
-    });
-    expect(getRouterRuntimeState(context)?.serverSnapshot).toBeUndefined();
-    expect(getRouterServerSnapshot(context)).toBe(snapshot);
-    expect(getRouterHydrationScripts(context)).toEqual(['server']);
-    expect(getRouterMatchedRouteIds(context)).toEqual(['server-route']);
-  });
-
-  it('applies server prepare overrides and awaits cleanup without propagating failures', async () => {
-    const context = {};
-    const stateCleanup = rstest.fn();
-    const cleanup = rstest.fn(async () => {
-      await Promise.resolve();
-    });
-    expect(
-      applyRouterServerPrepareResult(context, {
-        state: {
-          framework: 'custom',
-          cleanup: stateCleanup,
-          serverSnapshot: { statusCode: 200 },
-        },
-        snapshot: { statusCode: 299 },
-        cleanup,
-      }),
-    ).toBe(context);
-    expect(getRouterServerSnapshot(context)?.statusCode).toBe(299);
-    await cleanupRouterRuntimeState(context);
-    expect(cleanup).toHaveBeenCalledTimes(1);
-    expect(stateCleanup).not.toHaveBeenCalled();
-
-    applyRouterRuntimeState(context, {
-      framework: 'custom',
-      cleanup: async () => {
-        throw new Error('cleanup failed');
-      },
-    });
-    await expect(cleanupRouterRuntimeState(context)).resolves.toBeUndefined();
-    await expect(cleanupRouterRuntimeState({})).resolves.toBeUndefined();
-  });
-});

package/tests/routerStatePlugin.test.ts

@@ -1,63 +0,0 @@
-import {
-  getRouterRuntimeState,
-  getRouterServerSnapshot,
-} from '../src/routerState';
-import { createRouterStatePlugin } from '../src/routerStatePlugin';
-
-function install() {
-  const registryHooks = { onAfterCreateRouter: { call() {} } };
-  const plugin = createRouterStatePlugin({ registryHooks });
-  let beforeRender!: (context: object) => void;
-  let afterCreate!: Parameters<
-    Parameters<typeof plugin.setup>[0]['onAfterCreateRouter']
-  >[0];
-  plugin.setup({
-    onBeforeRender: callback => {
-      beforeRender = callback;
-    },
-    onAfterCreateRouter: callback => {
-      afterCreate = callback;
-    },
-  });
-  return { plugin, registryHooks, beforeRender, afterCreate };
-}
-
-test('keeps injected hooks and per-context policies stable without sharing app values', () => {
-  const { beforeRender } = install();
-  const first: any = {};
-  const second: any = {};
-  beforeRender(first);
-  const policy = first.linkPrefetchPolicy;
-  beforeRender(first);
-  beforeRender(second);
-  expect(first.linkPrefetchPolicy).toBe(policy);
-  expect(second.linkPrefetchPolicy).not.toBe(policy);
-});
-
-test('projects loader data, errors and valid route ids from injected SSR input', () => {
-  const { afterCreate } = install();
-  const errors = { route: new Error('route error') };
-  const context = {
-    routerContext: {
-      statusCode: 503,
-      errors,
-      loaderData: { root: { ok: true } },
-      matches: [{ route: { id: 'root' } }, { route: {} }],
-    },
-  };
-  afterCreate({
-    framework: 'react-router',
-    phase: 'ssr-prepare',
-    runtimeContext: context,
-    router: context.routerContext,
-    basename: '/nested',
-  });
-  expect(getRouterRuntimeState(context)?.instance).toBe(context.routerContext);
-  expect(getRouterServerSnapshot(context)).toMatchObject({
-    framework: 'react-router',
-    basename: '/nested',
-    statusCode: 503,
-    matchedRouteIds: ['root'],
-    routerData: { loaderData: context.routerContext.loaderData, errors },
-  });
-});

package/tests/runtimeContextProjection.test.ts

@@ -1,83 +0,0 @@
-import { createRuntimeContextExtension } from '../src/contextExtensions';
-import { projectRuntimeContext } from '../src/runtimeContextProjection';
-
-describe('fork runtime context projection', () => {
-  it('removes copied enumerable extension state only from the public projection', () => {
-    const context = { isBrowser: false, requestId: 'original' };
-    const extension = createRuntimeContextExtension<object>('test:projection');
-    const state = { router: 'private' };
-    extension.set(context, state);
-    const publicInput = { ...context };
-
-    const result = projectRuntimeContext(
-      { internalContext: context, publicContext: publicInput },
-      { context, isRsc: false },
-    );
-
-    expect(result.internalContext).toBe(context);
-    expect(result.publicContext).not.toBe(publicInput);
-    expect(extension.get(result.internalContext)).toBe(state);
-    expect(extension.get(publicInput)).toBe(state);
-    expect(extension.get(result.publicContext)).toBeUndefined();
-    expect(Object.getOwnPropertySymbols(result.publicContext)).not.toContain(
-      Symbol.for('@modern-js/runtime:context-extensions'),
-    );
-  });
-
-  it('projects RSC request fields and locals without mutating the original response', () => {
-    const response = {
-      setHeader: rstest.fn(),
-      status: rstest.fn(),
-      locals: { tenant: 'tractor-store' },
-    };
-    const request = {
-      params: { category: 'compact' },
-      pathname: '/tractors',
-      query: { sort: 'price' },
-      headers: { accept: 'text/html' },
-      host: 'example.test',
-      url: 'https://example.test/tractors?sort=price',
-      raw: new Request('https://example.test/tractors'),
-    };
-    const context = { isBrowser: false, ssrContext: { request, response } };
-    const extension = createRuntimeContextExtension<object>('test:rsc');
-    const state = { original: true };
-    extension.set(context, state);
-    const publicContext = { isBrowser: false };
-    const result = projectRuntimeContext(
-      { internalContext: context, publicContext },
-      { context, isRsc: true },
-    );
-    const internal = result.internalContext as typeof result.internalContext & {
-      context: { request: object; response: typeof response };
-      requestContext: { request: object; response: typeof response };
-    };
-    const publicValue = result.publicContext as typeof internal;
-
-    expect(internal).not.toBe(context);
-    expect(internal.ssrContext).toBeUndefined();
-    expect(internal.requestContext).toBe(publicValue.requestContext);
-    expect(internal.context).toBe(internal.requestContext);
-    expect(publicValue.context).toBe(internal.requestContext);
-    expect(internal.requestContext.response.locals).toBe(response.locals);
-    expect(context.ssrContext.response).toBe(response);
-    expect(extension.get(context)).toBe(state);
-    // Internal RSC copy behavior is retained pending separate Flight proof.
-    expect(extension.get(internal)).toBe(state);
-    expect(extension.get(publicValue)).toBeUndefined();
-  });
-
-  it('does not apply server request projection to an RSC browser context', () => {
-    const context = {
-      isBrowser: true,
-      ssrContext: { request: {}, response: { locals: { browser: true } } },
-    };
-    const result = projectRuntimeContext(
-      { internalContext: context, publicContext: { ...context } },
-      { context, isRsc: true },
-    );
-    expect(result.internalContext).toBe(context);
-    expect(result.internalContext.ssrContext).toBe(context.ssrContext);
-    expect(result.publicContext).not.toHaveProperty('requestContext');
-  });
-});

package/tests/safeFailure.test.ts

@@ -1,136 +0,0 @@
-import {
-  createSafeFailureHttpResult,
-  createSafeFailureResponse,
-  createSafeJsonFailureResponse,
-  getSafeFailureStatus,
-} from '../src/safeFailure';
-
-const readBody = async (response: Response) =>
-  (await response.json()) as Record<string, unknown>;
-
-describe('safe failure responses', () => {
-  it.each([
-    [500, 'INTERNAL_SERVER_ERROR', 'Internal Server Error'],
-  ])('redacts a %i failure through every response surface', async (status, code, message) => {
-    const error = Object.assign(new Error('database-password'), {
-      status,
-      code: 'SECRET_CODE',
-      cause: 'root-cause',
-      details: 'internal-details',
-      stack: 'hidden-stack',
-    });
-    const expectedBody = {
-      success: false,
-      error: { code, message, status },
-    };
-
-    expect(createSafeFailureHttpResult(error)).toMatchObject({
-      status,
-      body: expectedBody,
-    });
-    for (const createResponse of [
-      createSafeFailureResponse,
-      createSafeJsonFailureResponse,
-    ]) {
-      const response = createResponse(error);
-      expect(response.status).toBe(status);
-      expect(response.headers.get('content-type')).toBe(
-        'application/json; charset=utf-8',
-      );
-      const body = await readBody(response);
-      expect(body).toEqual(expectedBody);
-      expect(JSON.stringify(body)).not.toMatch(
-        /database-password|SECRET_CODE|root-cause|internal-details|hidden-stack/u,
-      );
-    }
-
-    // Response construction must not destroy the raw error retained for
-    // internal structured diagnostics.
-    expect(error.cause).toBe('root-cause');
-    expect(error.details).toBe('internal-details');
-  });
-
-  it.each([
-    ['delay seconds text', ' 120 ', '120'],
-    [
-      'valid Date object',
-      new Date(Date.UTC(2026, 7, 30, 20, 0, 0)),
-      'Sun, 30 Aug 2026 20:00:00 GMT',
-    ],
-  ])('canonicalizes %s for Retry-After', (_, retryAfter, expected) => {
-    const result = createSafeFailureHttpResult({ status: 503, retryAfter });
-    expect(result.headers['Retry-After']).toBe(expected);
-  });
-
-  it('derives Retry-After from a retryAfterSeconds error property', () => {
-    const error = Object.assign(new Error('maintenance'), {
-      status: 503,
-      retryAfterSeconds: 120,
-    });
-    expect(createSafeFailureHttpResult(error).headers['Retry-After']).toBe(
-      '120',
-    );
-  });
-
-  it('converts Retry-After milliseconds to canonical delay seconds', () => {
-    expect(
-      createSafeFailureHttpResult({ status: 503, retryAfterMs: 2500 }).headers[
-        'Retry-After'
-      ],
-    ).toBe('3');
-  });
-
-  it.each([
-    ['a header injection payload', '120\r\nX-Injected: true'],
-    ['an invalid Date object', new Date(Number.NaN)],
-  ])('rejects %s as Retry-After', (_, retryAfter) => {
-    const result = createSafeFailureHttpResult({ status: 503, retryAfter });
-    expect(result.headers['Retry-After']).toBeUndefined();
-    expect(() =>
-      createSafeFailureResponse({ status: 503, retryAfter }),
-    ).not.toThrow();
-  });
-
-  it('never emits Retry-After for a non-503 response', () => {
-    expect(
-      createSafeFailureHttpResult({ status: 500, retryAfter: '120' }).headers[
-        'Retry-After'
-      ],
-    ).toBeUndefined();
-  });
-
-  it('fails closed without throwing when error property access is hostile', () => {
-    const hostile = new Proxy(
-      {},
-      {
-        has() {
-          throw new Error('proxy trap secret');
-        },
-        get() {
-          throw new Error('getter secret');
-        },
-      },
-    );
-
-    expect(getSafeFailureStatus(hostile)).toBe(500);
-    expect(createSafeFailureHttpResult(hostile)).toEqual({
-      status: 500,
-      body: {
-        success: false,
-        error: {
-          code: 'INTERNAL_SERVER_ERROR',
-          message: 'Internal Server Error',
-          status: 500,
-        },
-      },
-      headers: {
-        'content-type': 'application/json; charset=utf-8',
-      },
-    });
-  });
-
-  it('uses statusCode only when it is a valid failure status', () => {
-    expect(getSafeFailureStatus({ status: 200, statusCode: 503 })).toBe(503);
-    expect(getSafeFailureStatus({ status: 503.5, statusCode: 799 })).toBe(500);
-  });
-});