index.test.ts

import type {
  GeneratorOptions,
  GeneratorVerbOptions,
  NormalizedOverrideOutput,
} from '@orval/core';
import { OutputMockType } from '@orval/core';
import { describe, expect, it } from 'vitest';

import { generateMSW } from './index';

describe('generateMSW', () => {
  const mockVerbOptions = {
    operationId: 'getUser',
    operationName: 'getUser',
    verb: 'get',
    tags: [],
    response: {
      imports: [],
      definition: { success: 'User' },
      types: { success: [{ key: '200', value: 'User' }] },
      contentTypes: ['application/json'],
    },
  } as unknown as GeneratorVerbOptions;

  const baseOptions = {
    route: '/users/{id}',
    pathRoute: '/users/{id}',
    output: 'test',
    override: { operations: {}, tags: {} } as NormalizedOverrideOutput,
    context: {
      target: 'test',
      workspace: '',
      spec: {
        openapi: '3.0.0',
        info: { title: 'Test', version: '1.0.0' },
        paths: {},
      },
      output: {
        target: 'test',
        namingConvention: 'camelCase',
        fileExtension: '.ts',
        mode: 'single',
        override: { operations: {}, tags: {} } as NormalizedOverrideOutput,
        client: 'axios-functions',
        httpClient: 'fetch',
        clean: false,
        docs: false,
        formatter: undefined,
        headers: false,
        indexFiles: true,
        allParamsOptional: false,
        urlEncodeParameters: false,
        unionAddMissingProperties: false,
        optionsParamRequired: false,
        propertySortOrder: 'specification',
      },
    },
  } as unknown as GeneratorOptions;

  const generate = (overrides: Partial<GeneratorOptions> = {}) =>
    generateMSW(mockVerbOptions, { ...baseOptions, ...overrides });

  describe('delay functionality', () => {
    it('should not include delay call when no delay is provided', () => {
      const result = generate();
      expect(result.implementation.handler).not.toContain('await delay');
    });

    it('should include delay call when delay is a number', () => {
      const result = generate({
        mock: { type: OutputMockType.MSW, delay: 100 },
      });
      expect(result.implementation.handler).toContain('await delay(100);');
    });

    it('should not include delay call when delay is false', () => {
      const result = generate({
        mock: { type: OutputMockType.MSW, delay: false },
      });
      expect(result.implementation.handler).not.toContain('await delay');
    });

    it('should execute delay function immediately when delayFunctionLazyExecute is false', () => {
      const result = generate({
        mock: {
          type: OutputMockType.MSW,
          delay: () => 200,
          delayFunctionLazyExecute: false,
        },
      });
      expect(result.implementation.handler).toContain('await delay(200);');
    });

    it('should preserve delay function when delayFunctionLazyExecute is true', () => {
      const result = generate({
        mock: {
          type: OutputMockType.MSW,
          delay: () => 10,
          delayFunctionLazyExecute: true,
        },
      });
      expect(result.implementation.handler).toContain(
        'await delay((() => 10)());',
      );
    });

    it('should handle delay function in override.mock', () => {
      const result = generate({
        override: {
          ...baseOptions.override,
          mock: { delay: () => 300, delayFunctionLazyExecute: true },
        },
      });
      expect(result.implementation.handler).toContain(
        'await delay((() => 300)());',
      );
    });

    it('should prioritize override.mock.delay over options.mock.delay', () => {
      const result = generate({
        mock: { type: OutputMockType.MSW, delay: 100 },
        override: { ...baseOptions.override, mock: { delay: 500 } },
      });
      expect(result.implementation.handler).toContain('await delay(500);');
      expect(result.implementation.handler).not.toContain('await delay(100);');
    });

    it('should prioritize override.mock.delayFunctionLazyExecute', () => {
      const result = generate({
        mock: {
          type: OutputMockType.MSW,
          delay: () => 100,
          delayFunctionLazyExecute: false,
        },
        override: {
          ...baseOptions.override,
          mock: { delay: () => 200, delayFunctionLazyExecute: true },
        },
      });
      expect(result.implementation.handler).toContain(
        'await delay((() => 200)());',
      );
    });
  });

  describe('handler generation', () => {
    it('should generate a valid MSW handler', () => {
      const result = generate({
        mock: { type: OutputMockType.MSW, delay: 100 },
      });

      expect(result.implementation.handlerName).toBe('getGetUserMockHandler');
      expect(result.implementation.handler).toContain(
        'export const getGetUserMockHandler',
      );
      expect(result.implementation.handler).toContain('return http.get');
    });

    it('should not include JSON.stringify in handler (uses HttpResponse.json or null body)', () => {
      const result = generate();

      // When there is no mock data, handler returns HttpResponse with null body
      // When there IS mock data, handler should use HttpResponse.json (not JSON.stringify)
      expect(result.implementation.handler).not.toContain('JSON.stringify');
    });

    it('should handle binary/Blob response types without JSON.stringify', () => {
      const blobVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'Blob' },
          types: {
            success: [{ key: '200', value: 'Blob' }],
          },
          contentTypes: ['application/octet-stream'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(blobVerbOptions, baseOptions);

      expect(result.implementation.handler).not.toContain('JSON.stringify');
      expect(result.implementation.handler).toContain(
        'application/octet-stream',
      );
      // Mock function signature should use ArrayBuffer instead of Blob
      expect(result.implementation.handler).not.toContain(
        'overrideResponse?: Blob',
      );
      expect(result.implementation.handler).toContain(
        'HttpResponse.arrayBuffer',
      );
      // The mock function should return an ArrayBuffer
      expect(result.implementation.function).toContain('ArrayBuffer');
      expect(result.implementation.function).not.toContain('Blob');
    });

    it('should handle image content types as binary', () => {
      const imageVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'Blob' },
          types: {
            success: [{ key: '200', value: 'Blob' }],
          },
          contentTypes: ['image/png'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(imageVerbOptions, baseOptions);

      expect(result.implementation.handler).not.toContain('JSON.stringify');
      expect(result.implementation.handler).toContain('image/png');
    });

    it('should handle font content types as binary', () => {
      const fontVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'Blob' },
          types: {
            success: [{ key: '200', value: 'Blob' }],
          },
          contentTypes: ['font/woff2'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(fontVerbOptions, baseOptions);

      expect(result.implementation.handler).not.toContain('JSON.stringify');
      expect(result.implementation.handler).toContain('font/woff2');
      expect(result.implementation.handler).toContain(
        'HttpResponse.arrayBuffer',
      );
    });

    // Regression: issue #3065
    // When the OpenAPI upgrader converts `format: binary` to
    // `contentMediaType: application/octet-stream` (OAS 3.0 → 3.1), the mock
    // generator must still emit an ArrayBuffer — not `faker.string.alpha(...)` —
    // even when the declared content type is JSON-like (e.g. application/json).
    it('should generate ArrayBuffer mock for binary schema under JSON content types', () => {
      const binaryJsonVerbOptions = {
        ...mockVerbOptions,
        response: {
          imports: [],
          definition: { success: 'Blob' },
          types: {
            success: [
              {
                key: '200',
                value: 'Blob',
                contentType: 'application/json',
                originalSchema: {
                  type: 'string',
                  contentMediaType: 'application/octet-stream',
                },
                imports: [],
                schemas: [],
                type: 'string',
                isEnum: false,
                isRef: false,
                hasReadonlyProps: false,
              },
              {
                key: '200',
                value: 'Blob',
                contentType: 'text/json',
                originalSchema: {
                  type: 'string',
                  contentMediaType: 'application/octet-stream',
                },
                imports: [],
                schemas: [],
                type: 'string',
                isEnum: false,
                isRef: false,
                hasReadonlyProps: false,
              },
            ],
          },
          contentTypes: ['application/json', 'text/json'],
        },
      } as unknown as GeneratorVerbOptions;

      const result = generateMSW(binaryJsonVerbOptions, baseOptions);

      expect(result.implementation.function).toContain('ArrayBuffer');
      expect(result.implementation.function).not.toContain(
        'faker.string.alpha',
      );
      expect(result.implementation.function).not.toContain(': Blob =>');
      expect(result.implementation.handler).toContain(
        'HttpResponse.arrayBuffer',
      );
    });

    it('should handle application/pdf as binary', () => {
      const pdfVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'Blob' },
          types: {
            success: [{ key: '200', value: 'Blob' }],
          },
          contentTypes: ['application/pdf'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(pdfVerbOptions, baseOptions);

      expect(result.implementation.handler).not.toContain('JSON.stringify');
      expect(result.implementation.handler).toContain('application/pdf');
      expect(result.implementation.handler).toContain(
        'HttpResponse.arrayBuffer',
      );
    });

    it('should generate ArrayBuffer mock for $ref to a format: binary schema', () => {
      const refBinaryVerbOptions = {
        ...mockVerbOptions,
        response: {
          imports: [],
          definition: { success: 'TestPdfFile' },
          types: {
            success: [
              {
                key: '200',
                value: 'TestPdfFile',
                contentType: '*/*',
                originalSchema: { type: 'string', format: 'binary' },
                imports: [{ name: 'TestPdfFile' }],
                schemas: [],
                type: 'string',
                isEnum: false,
                isRef: true,
                hasReadonlyProps: false,
              },
            ],
          },
          contentTypes: ['*/*'],
        },
      } as unknown as GeneratorVerbOptions;

      const result = generateMSW(refBinaryVerbOptions, baseOptions);

      expect(result.implementation.handler).toContain(
        'HttpResponse.arrayBuffer',
      );
      expect(result.implementation.handler).not.toContain('JSON.stringify');
      // The ref alias return type must be rewritten to ArrayBuffer to stay consistent with the arrayBuffer body.
      expect(result.implementation.function).toContain(': ArrayBuffer');
      expect(result.implementation.function).not.toContain(': TestPdfFile');
    });

    it('should rewrite aliased ref imports for $ref binary schemas', () => {
      const aliasedVerbOptions = {
        ...mockVerbOptions,
        response: {
          imports: [],
          definition: { success: '__TestPdfFile' },
          types: {
            success: [
              {
                key: '200',
                value: '__TestPdfFile',
                contentType: '*/*',
                originalSchema: { type: 'string', format: 'binary' },
                imports: [{ name: 'TestPdfFile', alias: '__TestPdfFile' }],
                schemas: [],
                type: 'string',
                isEnum: false,
                isRef: true,
                hasReadonlyProps: false,
              },
            ],
          },
          contentTypes: ['*/*'],
        },
      } as unknown as GeneratorVerbOptions;

      const result = generateMSW(aliasedVerbOptions, baseOptions);

      expect(result.implementation.function).toContain(': ArrayBuffer');
      expect(result.implementation.function).not.toContain(': __TestPdfFile');
    });

    it('should not force binary path when preferredContentType narrows to a non-binary success variant', () => {
      const mixedVerbOptions = {
        ...mockVerbOptions,
        response: {
          imports: [],
          definition: { success: 'Pet | Blob' },
          types: {
            success: [
              {
                key: '200',
                value: 'Pet',
                contentType: 'application/json',
                originalSchema: {
                  type: 'object',
                  properties: { name: { type: 'string' } },
                },
                imports: [],
                schemas: [],
                type: 'object',
                isEnum: false,
                isRef: true,
                hasReadonlyProps: false,
              },
              {
                key: '200',
                value: 'Blob',
                contentType: 'application/octet-stream',
                originalSchema: { type: 'string', format: 'binary' },
                imports: [],
                schemas: [],
                type: 'string',
                isEnum: false,
                isRef: false,
                hasReadonlyProps: false,
              },
            ],
          },
          contentTypes: ['application/json', 'application/octet-stream'],
        },
      } as unknown as GeneratorVerbOptions;

      const result = generateMSW(mixedVerbOptions, {
        ...baseOptions,
        mock: { preferredContentType: 'application/json' },
      } as unknown as GeneratorOptions);

      expect(result.implementation.handler).not.toContain(
        'HttpResponse.arrayBuffer',
      );
      expect(result.implementation.handler).toContain('HttpResponse.json');
    });

    it('should type the info parameter in the handler callback', () => {
      const result = generate({
        mock: { type: OutputMockType.MSW, delay: 100 },
      });

      // The handler callback's info param should be explicitly typed
      expect(result.implementation.handler).toContain(
        'async (info: Parameters<Parameters<typeof http.get>[1]>[0])',
      );
    });

    it('should use HttpResponse.text for text/plain responses', () => {
      const textVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'string' },
          types: { success: [{ key: '200', value: 'string' }] },
          contentTypes: ['text/plain'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(textVerbOptions, baseOptions);

      expect(result.implementation.handler).toContain('HttpResponse.text');
      expect(result.implementation.handler).toContain('textBody');
      expect(result.implementation.handler).toContain('JSON.stringify');
      expect(result.implementation.handler).not.toContain('HttpResponse.json');
    });

    it('should use HttpResponse.html for text/html responses', () => {
      const htmlVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'string' },
          types: { success: [{ key: '200', value: 'string' }] },
          contentTypes: ['text/html'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(htmlVerbOptions, baseOptions);

      expect(result.implementation.handler).toContain('HttpResponse.html');
      expect(result.implementation.handler).not.toContain('HttpResponse.json');
      expect(result.implementation.handler).not.toContain('HttpResponse.text(');
    });

    it('should use HttpResponse.xml for application/xml responses', () => {
      const xmlVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'string' },
          types: { success: [{ key: '200', value: 'string' }] },
          contentTypes: ['application/xml'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(xmlVerbOptions, baseOptions);

      expect(result.implementation.handler).toContain('HttpResponse.xml');
      expect(result.implementation.handler).not.toContain('HttpResponse.json');
      expect(result.implementation.handler).not.toContain('HttpResponse.text(');
    });

    // Regression test for https://github.com/orval-labs/orval/issues/3270.
    // When the response definition resolves to `unknown` (as with a 302
    // redirect returning text/html that is not treated as a success body),
    // no `*ResponseMock` helper is generated. The handler must not emit a
    // `resolvedBody`/`textBody` prelude that references the missing helper.
    it('should not reference a missing *ResponseMock for unknown text responses', () => {
      const unknownHtmlVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'unknown' },
          types: { success: [{ key: '302', value: 'unknown' }] },
          contentTypes: ['text/html'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(unknownHtmlVerbOptions, baseOptions);

      expect(result.implementation.function).toBe('');
      expect(result.implementation.handler).not.toContain('ResponseMock()');
      expect(result.implementation.handler).not.toContain('resolvedBody');
      expect(result.implementation.handler).not.toContain('textBody');
      expect(result.implementation.handler).toContain('new HttpResponse(null,');
    });

    it('should use HttpResponse.xml for vendor +xml responses', () => {
      const vendorXmlVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'string' },
          types: { success: [{ key: '200', value: 'string' }] },
          contentTypes: ['application/vnd.api+xml'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(vendorXmlVerbOptions, baseOptions);

      expect(result.implementation.handler).toContain('HttpResponse.xml');
      expect(result.implementation.handler).not.toContain('HttpResponse.json');
      expect(result.implementation.handler).not.toContain('HttpResponse.text(');
    });

    it('should avoid undefined array min/max in general JS types', () => {
      const numberArrayVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'number[]' },
          types: { success: [{ key: '200', value: 'number[]' }] },
          contentTypes: ['application/json'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(numberArrayVerbOptions, baseOptions);

      expect(result.implementation.function).toContain(
        'Array.from({length: faker.number.int()}',
      );
      expect(result.implementation.function).not.toContain('undefined');
    });

    it('should include array min/max when provided for general JS types', () => {
      const numberArrayVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'number[]' },
          types: { success: [{ key: '200', value: 'number[]' }] },
          contentTypes: ['application/json'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(numberArrayVerbOptions, {
        ...baseOptions,
        override: {
          ...baseOptions.override,
          mock: { arrayMin: 1, arrayMax: 3 },
        },
      });

      expect(result.implementation.function).toContain(
        'faker.number.int({min: 1, max: 3})',
      );
    });

    it('should evaluate text response override expression once via temp variable', () => {
      const textVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'string' },
          types: { success: [{ key: '200', value: 'string' }] },
          contentTypes: ['text/plain'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(textVerbOptions, baseOptions);

      // The handler should assign the resolved response to a temp var
      // and then use it, rather than inlining the await expression multiple times
      expect(result.implementation.handler).toContain('const resolvedBody =');
      expect(result.implementation.handler).toContain(
        "typeof resolvedBody === 'string'",
      );
    });

    it('should handle binary responses with ArrayBuffer fallback', () => {
      const blobVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'Blob' },
          types: { success: [{ key: '200', value: 'Blob' }] },
          contentTypes: ['application/octet-stream'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(blobVerbOptions, baseOptions);

      // Should use the mock function and fall back to empty ArrayBuffer
      expect(result.implementation.handler).toContain(
        'binaryBody instanceof ArrayBuffer',
      );
      expect(result.implementation.handler).toContain('new ArrayBuffer(0)');
      // The binary handler should call the mock function as fallback
      expect(result.implementation.handler).toContain(
        'getGetUserResponseMock()',
      );
    });

    it('should honor preferredContentType for binary content headers', () => {
      const blobVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'Blob' },
          types: {
            success: [
              {
                key: '200',
                value: 'Blob',
                contentType: 'application/octet-stream',
              },
              { key: '200', value: 'Blob', contentType: 'image/png' },
            ],
          },
          contentTypes: ['application/octet-stream', 'image/png'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(blobVerbOptions, {
        ...baseOptions,
        mock: {
          type: OutputMockType.MSW,
          preferredContentType: 'image/png',
        },
      });

      expect(result.implementation.handler).toContain(
        "headers: { 'Content-Type': 'image/png' }",
      );
    });

    it('should use HttpResponse.text when text/plain comes before application/xml in mixed content types', () => {
      const mixedVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'string' },
          types: { success: [{ key: '200', value: 'string' }] },
          contentTypes: ['text/plain', 'application/xml', 'application/json'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(mixedVerbOptions, {
        ...baseOptions,
        override: {
          ...baseOptions.override,
          operations: {
            ...baseOptions.override.operations,
            getUser: {
              mock: {
                data: { id: 1, name: 'Milo' },
              },
            },
          },
        },
      });

      // text/plain is the first text-like content type, so HttpResponse.text should be used
      expect(result.implementation.handler).toContain('HttpResponse.text(');
      expect(result.implementation.handler).not.toContain('HttpResponse.xml(');
      expect(result.implementation.handler).not.toContain('HttpResponse.json(');
    });

    it('should use HttpResponse.xml when application/xml comes first in mixed content types', () => {
      const mixedVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'string' },
          types: { success: [{ key: '200', value: 'string' }] },
          contentTypes: ['application/xml', 'application/json'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(mixedVerbOptions, {
        ...baseOptions,
        override: {
          ...baseOptions.override,
          operations: {
            ...baseOptions.override.operations,
            getUser: {
              mock: {
                data: { id: 1, name: 'Milo' },
              },
            },
          },
        },
      });

      // application/xml is the first text-like content type
      expect(result.implementation.handler).toContain('HttpResponse.xml(');
      expect(result.implementation.handler).not.toContain('HttpResponse.text(');
      expect(result.implementation.handler).not.toContain('HttpResponse.json(');
    });

    it('should keep text helper for exact string return types even when preferredContentType is application/json', () => {
      const mixedVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'string' },
          types: {
            success: [
              { key: '200', value: 'string', contentType: 'application/xml' },
              { key: '200', value: 'string', contentType: 'application/json' },
            ],
          },
          contentTypes: ['application/xml', 'application/json'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(mixedVerbOptions, {
        ...baseOptions,
        mock: {
          type: OutputMockType.MSW,
          preferredContentType: 'application/json',
        },
      });

      expect(result.implementation.handler).toContain('HttpResponse.xml(');
      expect(result.implementation.handler).not.toContain('HttpResponse.json(');
      expect(result.implementation.handler).not.toContain('HttpResponse.text(');
    });

    it('should prefer HttpResponse.json for structured return types when json and xml are both available', () => {
      const mixedVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'Pet' },
          types: { success: [{ key: '200', value: 'Pet' }] },
          contentTypes: ['application/xml', 'application/json'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(mixedVerbOptions, {
        ...baseOptions,
        override: {
          ...baseOptions.override,
          operations: {
            ...baseOptions.override.operations,
            getUser: {
              mock: {
                data: { id: 1, name: 'Milo' },
              },
            },
          },
        },
      });

      expect(result.implementation.handler).toContain('HttpResponse.json(');
      expect(result.implementation.handler).not.toContain('HttpResponse.xml(');
      expect(result.implementation.handler).not.toContain('JSON.stringify');
    });

    it('should honor preferredContentType for text helpers when multiple text types exist', () => {
      const mixedVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'string' },
          types: {
            success: [
              { key: '200', value: 'string', contentType: 'text/plain' },
              { key: '200', value: 'string', contentType: 'text/html' },
            ],
          },
          contentTypes: ['text/plain', 'text/html'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(mixedVerbOptions, {
        ...baseOptions,
        mock: {
          type: OutputMockType.MSW,
          preferredContentType: 'text/html',
        },
      });

      expect(result.implementation.handler).toContain('HttpResponse.html(');
      expect(result.implementation.handler).not.toContain('HttpResponse.text(');
    });

    it('should use HttpResponse.json when application/json is the only content type (no text-like)', () => {
      const result = generate();

      // Default mockVerbOptions has application/json only
      expect(result.implementation.handler).not.toContain('HttpResponse.text(');
      expect(result.implementation.handler).not.toContain('HttpResponse.xml(');
      expect(result.implementation.handler).not.toContain('HttpResponse.html(');
    });

    it('should use text prelude (resolvedBody → textBody) for xml and html responses', () => {
      const xmlVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'string' },
          types: { success: [{ key: '200', value: 'string' }] },
          contentTypes: ['application/xml'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(xmlVerbOptions, baseOptions);

      // XML responses should still use the text prelude for string conversion
      expect(result.implementation.handler).toContain('const resolvedBody =');
      expect(result.implementation.handler).toContain('textBody');
      expect(result.implementation.handler).toContain(
        'HttpResponse.xml(textBody',
      );
    });

    it('should accept RequestHandlerOptions in all handler types', () => {
      // JSON handler
      const jsonResult = generate();
      expect(jsonResult.implementation.handler).toContain(
        'options?: RequestHandlerOptions',
      );
      expect(jsonResult.implementation.handler).toContain('}, options)');

      // Text handler
      const textVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'string' },
          types: { success: [{ key: '200', value: 'string' }] },
          contentTypes: ['text/plain'],
        },
      } as GeneratorVerbOptions;
      const textResult = generateMSW(textVerbOptions, baseOptions);
      expect(textResult.implementation.handler).toContain(
        'options?: RequestHandlerOptions',
      );
      expect(textResult.implementation.handler).toContain('}, options)');

      // Binary handler
      const blobVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'Blob' },
          types: { success: [{ key: '200', value: 'Blob' }] },
          contentTypes: ['application/octet-stream'],
        },
      } as GeneratorVerbOptions;
      const blobResult = generateMSW(blobVerbOptions, baseOptions);
      expect(blobResult.implementation.handler).toContain(
        'options?: RequestHandlerOptions',
      );
      expect(blobResult.implementation.handler).toContain('}, options)');
    });
  });

  describe('mixed content-type runtime branching (issue #2950)', () => {
    it('Test A: should generate runtime branching for text/plain + xml + json with union return type string | Pet', () => {
      const mixedVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'string | Pet' },
          types: { success: [{ key: '200', value: 'string | Pet' }] },
          contentTypes: ['text/plain', 'application/xml', 'application/json'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(mixedVerbOptions, {
        ...baseOptions,
        override: {
          ...baseOptions.override,
          operations: {
            ...baseOptions.override.operations,
            getUser: { mock: { data: { id: 1, name: 'Milo' } } },
          },
        },
      });

      // Should generate runtime typeof check to branch on resolved value
      expect(result.implementation.handler).toContain(
        "typeof resolvedBody === 'string'",
      );
      // String values should use HttpResponse.text (first text-like content type)
      expect(result.implementation.handler).toContain('HttpResponse.text(');
      // Object values should use HttpResponse.json
      expect(result.implementation.handler).toContain('HttpResponse.json(');
      // Should NOT use JSON.stringify — objects go to .json(), strings go to .text()
      expect(result.implementation.handler).not.toContain('JSON.stringify');
      // Should resolve the body once into a temp variable
      expect(result.implementation.handler).toContain('const resolvedBody =');
      // Should NOT have the textBody prelude (that's only for static text branch)
      expect(result.implementation.handler).not.toContain('const textBody =');
    });

    it('Test B: should generate runtime branching for xml + json with union return type string | Pet', () => {
      const mixedVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'string | Pet' },
          types: { success: [{ key: '200', value: 'string | Pet' }] },
          contentTypes: ['application/xml', 'application/json'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(mixedVerbOptions, {
        ...baseOptions,
        override: {
          ...baseOptions.override,
          operations: {
            ...baseOptions.override.operations,
            getUser: { mock: { data: { id: 1, name: 'Milo' } } },
          },
        },
      });

      // Should generate runtime typeof check
      expect(result.implementation.handler).toContain(
        "typeof resolvedBody === 'string'",
      );
      // String values should use HttpResponse.xml (first text-like = application/xml)
      expect(result.implementation.handler).toContain('HttpResponse.xml(');
      // Object values should use HttpResponse.json
      expect(result.implementation.handler).toContain('HttpResponse.json(');
      // Should NOT use JSON.stringify
      expect(result.implementation.handler).not.toContain('JSON.stringify');
    });

    it('Test C: should NOT use runtime branching for xml + json with non-union return type Pet', () => {
      const mixedVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'Pet' },
          types: { success: [{ key: '200', value: 'Pet' }] },
          contentTypes: ['application/xml', 'application/json'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(mixedVerbOptions, {
        ...baseOptions,
        override: {
          ...baseOptions.override,
          operations: {
            ...baseOptions.override.operations,
            getUser: { mock: { data: { id: 1, name: 'Milo' } } },
          },
        },
      });

      // shouldPreferJsonResponse is true (non-string return type + json available)
      // so it should use HttpResponse.json directly — no runtime branching needed
      expect(result.implementation.handler).toContain('HttpResponse.json(');
      expect(result.implementation.handler).not.toContain('HttpResponse.xml(');
      expect(result.implementation.handler).not.toContain('HttpResponse.text(');
      expect(result.implementation.handler).not.toContain('JSON.stringify');
      // No runtime typeof check
      expect(result.implementation.handler).not.toContain(
        "typeof resolvedBody === 'string'",
      );
    });

    it('Test D: should NOT use runtime branching for text/plain only with return type string', () => {
      const textVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'string' },
          types: { success: [{ key: '200', value: 'string' }] },
          contentTypes: ['text/plain'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(textVerbOptions, baseOptions);

      // Pure string return type with text/plain only → static text branch, no runtime branching
      expect(result.implementation.handler).toContain('HttpResponse.text(');
      expect(result.implementation.handler).toContain('textBody');
      expect(result.implementation.handler).not.toContain('HttpResponse.json(');
      // No runtime content-type switch branch is used; static text prelude computes textBody
      expect(result.implementation.handler).toContain('const resolvedBody =');
      expect(result.implementation.handler).toContain('const textBody =');
    });

    it('Test E: should NOT use runtime branching for text/plain + json with return type string (not union)', () => {
      const mixedVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'string' },
          types: { success: [{ key: '200', value: 'string' }] },
          contentTypes: ['text/plain', 'application/json'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(mixedVerbOptions, baseOptions);

      // mockReturnType === 'string' → needsRuntimeContentTypeSwitch is false
      // hasStringReturnType is true, shouldPreferJsonResponse is false
      // Falls into static text branch
      expect(result.implementation.handler).toContain('HttpResponse.text(');
      expect(result.implementation.handler).toContain('textBody');
      expect(result.implementation.handler).not.toContain('HttpResponse.json(');
      // Uses static textBody prelude, not runtime branching
      expect(result.implementation.handler).toContain('const textBody =');
    });

    it('Test E2: should keep text/plain helper when preferredContentType is json and return type is string', () => {
      const mixedVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'string' },
          types: {
            success: [
              { key: '200', value: 'string', contentType: 'text/plain' },
              { key: '200', value: 'string', contentType: 'application/json' },
            ],
          },
          contentTypes: ['text/plain', 'application/json'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(mixedVerbOptions, {
        ...baseOptions,
        mock: {
          type: OutputMockType.MSW,
          preferredContentType: 'application/json',
        },
      });

      expect(result.implementation.handler).toContain('HttpResponse.text(');
      expect(result.implementation.handler).not.toContain('HttpResponse.json(');
      expect(result.implementation.handler).toContain('const textBody =');
    });

    it('Test F: should NOT use runtime branching when preferredContentType is json with union return type', () => {
      const mixedVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'string | Pet' },
          types: {
            success: [
              { key: '200', value: 'string | Pet', contentType: 'text/plain' },
              {
                key: '200',
                value: 'string | Pet',
                contentType: 'application/xml',
              },
              {
                key: '200',
                value: 'string | Pet',
                contentType: 'application/json',
              },
            ],
          },
          contentTypes: ['text/plain', 'application/xml', 'application/json'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(mixedVerbOptions, {
        ...baseOptions,
        mock: {
          type: OutputMockType.MSW,
          preferredContentType: 'application/json',
        },
        override: {
          ...baseOptions.override,
          operations: {
            ...baseOptions.override.operations,
            getUser: { mock: { data: { id: 1, name: 'Milo' } } },
          },
        },
      });

      // preferredContentType narrows contentTypesByPreference to ['application/json']
      // isTextResponse becomes false, so falls into the json-only branch
      expect(result.implementation.handler).toContain('HttpResponse.json(');
      expect(result.implementation.handler).not.toContain('HttpResponse.text(');
      expect(result.implementation.handler).not.toContain('HttpResponse.xml(');
      expect(result.implementation.handler).not.toContain('JSON.stringify');
      // No runtime typeof check needed
      expect(result.implementation.handler).not.toContain(
        "typeof resolvedBody === 'string'",
      );
    });

    it('Test G: should generate runtime branching for text/html + json with union return type string | Pet', () => {
      const mixedVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'string | Pet' },
          types: { success: [{ key: '200', value: 'string | Pet' }] },
          contentTypes: ['text/html', 'application/json'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(mixedVerbOptions, {
        ...baseOptions,
        override: {
          ...baseOptions.override,
          operations: {
            ...baseOptions.override.operations,
            getUser: { mock: { data: { id: 1, name: 'Milo' } } },
          },
        },
      });

      expect(result.implementation.handler).toContain(
        "typeof resolvedBody === 'string'",
      );
      expect(result.implementation.handler).toContain('HttpResponse.html(');
      expect(result.implementation.handler).toContain('HttpResponse.json(');
      expect(result.implementation.handler).not.toContain('JSON.stringify');
    });

    it('Test H: should generate runtime branching for vendor +xml + json with union return type string | Pet', () => {
      const mixedVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'string | Pet' },
          types: { success: [{ key: '200', value: 'string | Pet' }] },
          contentTypes: ['application/vnd.orval+xml', 'application/json'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(mixedVerbOptions, {
        ...baseOptions,
        override: {
          ...baseOptions.override,
          operations: {
            ...baseOptions.override.operations,
            getUser: { mock: { data: { id: 1, name: 'Milo' } } },
          },
        },
      });

      expect(result.implementation.handler).toContain(
        "typeof resolvedBody === 'string'",
      );
      expect(result.implementation.handler).toContain('HttpResponse.xml(');
      expect(result.implementation.handler).toContain('HttpResponse.json(');
      expect(result.implementation.handler).not.toContain('JSON.stringify');
    });

    it('Test I: should still select first text-like helper even when json appears first in content types', () => {
      const mixedVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'string | Pet' },
          types: { success: [{ key: '200', value: 'string | Pet' }] },
          contentTypes: ['application/json', 'application/xml'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(mixedVerbOptions, {
        ...baseOptions,
        override: {
          ...baseOptions.override,
          operations: {
            ...baseOptions.override.operations,
            getUser: { mock: { data: { id: 1, name: 'Milo' } } },
          },
        },
      });

      expect(result.implementation.handler).toContain(
        "typeof resolvedBody === 'string'",
      );
      expect(result.implementation.handler).toContain('HttpResponse.xml(');
      expect(result.implementation.handler).toContain('HttpResponse.json(');
      expect(result.implementation.handler).not.toContain('JSON.stringify');
    });

    it('Test J: should use static text path when preferredContentType is text/plain for union return type', () => {
      const mixedVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'string | Pet' },
          types: {
            success: [
              { key: '200', value: 'string | Pet', contentType: 'text/plain' },
              {
                key: '200',
                value: 'string | Pet',
                contentType: 'application/json',
              },
            ],
          },
          contentTypes: ['text/plain', 'application/json'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(mixedVerbOptions, {
        ...baseOptions,
        mock: {
          type: OutputMockType.MSW,
          preferredContentType: 'text/plain',
        },
        override: {
          ...baseOptions.override,
          operations: {
            ...baseOptions.override.operations,
            getUser: { mock: { data: { id: 1, name: 'Milo' } } },
          },
        },
      });

      expect(result.implementation.handler).toContain('HttpResponse.text(');
      expect(result.implementation.handler).toContain('const textBody =');
      expect(result.implementation.handler).not.toContain('HttpResponse.json(');
      expect(result.implementation.handler).not.toContain(
        "typeof resolvedBody === 'string'\n      ? HttpResponse",
      );
    });

    it('Test K: should generate runtime branching for vendor +xml + vendor +json with union return type string | Pet', () => {
      const mixedVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'string | Pet' },
          types: { success: [{ key: '200', value: 'string | Pet' }] },
          contentTypes: [
            'application/vnd.orval+xml',
            'application/vnd.orval+json',
          ],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(mixedVerbOptions, {
        ...baseOptions,
        override: {
          ...baseOptions.override,
          operations: {
            ...baseOptions.override.operations,
            getUser: { mock: { data: { id: 1, name: 'Milo' } } },
          },
        },
      });

      expect(result.implementation.handler).toContain(
        "typeof resolvedBody === 'string'",
      );
      expect(result.implementation.handler).toContain('HttpResponse.xml(');
      expect(result.implementation.handler).toContain('HttpResponse.json(');
      expect(result.implementation.handler).not.toContain('JSON.stringify');
    });

    it('Test L: should not treat type names containing "string" as string return types', () => {
      const mixedVerbOptions = {
        ...mockVerbOptions,
        response: {
          ...mockVerbOptions.response,
          definition: { success: 'StringPayload | Pet' },
          types: { success: [{ key: '200', value: 'StringPayload | Pet' }] },
          contentTypes: ['application/xml', 'application/json'],
        },
      } as GeneratorVerbOptions;

      const result = generateMSW(mixedVerbOptions, {
        ...baseOptions,
        override: {
          ...baseOptions.override,
          operations: {
            ...baseOptions.override.operations,
            getUser: { mock: { data: { id: 1, name: 'Milo' } } },
          },
        },
      });

      // Since StringPayload is not the primitive `string`, this should prefer JSON for structured data
      expect(result.implementation.handler).toContain('HttpResponse.json(');
      expect(result.implementation.handler).not.toContain('HttpResponse.xml(');
      expect(result.implementation.handler).not.toContain(
        "typeof resolvedBody === 'string'\n      ? HttpResponse",
      );
    });
  });

  // Regression: issue #3269
  // When a response import is aliased (e.g. `Widget as __Widget`, produced by
  // split mode when the function param name collides with the schema name),
  // the generated mock code references the alias (`__Widget`) rather than the
  // bare name. The import filter must match against the alias, otherwise the
  // import is dropped and the mock file references an undeclared identifier
  // (TS2304).
  describe('aliased import filter (issue #3269)', () => {
    it('should include an aliased import that is referenced only by its alias', () => {
      const aliasedVerbOptions = {
        ...mockVerbOptions,
        response: {
          imports: [{ name: 'Widget', alias: '__Widget' }],
          definition: { success: '__Widget | null' },
          types: {
            success: [{ key: '200', value: '__Widget | null' }],
          },
          contentTypes: ['application/json'],
        },
      } as unknown as GeneratorVerbOptions;

      const result = generateMSW(aliasedVerbOptions, baseOptions);

      expect(result.imports).toContainEqual(
        expect.objectContaining({ name: 'Widget', alias: '__Widget' }),
      );
    });

    it('should drop an aliased import that is not referenced anywhere', () => {
      const unusedAliasVerbOptions = {
        ...mockVerbOptions,
        response: {
          imports: [{ name: 'User' }, { name: 'Unused', alias: '__Unused' }],
          definition: { success: 'User' },
          types: { success: [{ key: '200', value: 'User' }] },
          contentTypes: ['application/json'],
        },
      } as unknown as GeneratorVerbOptions;

      const result = generateMSW(unusedAliasVerbOptions, baseOptions);

      // Positive control: the bare-name import that IS referenced is kept.
      expect(result.imports).toContainEqual(
        expect.objectContaining({ name: 'User' }),
      );
      // The unused aliased import is filtered out.
      expect(result.imports).not.toContainEqual(
        expect.objectContaining({ name: 'Unused' }),
      );
    });

    it('should keep both entries when bare and aliased forms appear in the code', () => {
      // Defensive: if a future change reintroduces dual entries (one bare,
      // one aliased) for the same schema in a single verb's imports, both
      // must survive the filter when the code references each form.
      const dualVerbOptions = {
        ...mockVerbOptions,
        response: {
          imports: [{ name: 'Pet' }, { name: 'Pet', alias: '__Pet' }],
          definition: { success: 'Pet | __Pet' },
          types: { success: [{ key: '200', value: 'Pet | __Pet' }] },
          contentTypes: ['application/json'],
        },
      } as unknown as GeneratorVerbOptions;

      const result = generateMSW(dualVerbOptions, baseOptions);

      const petEntries = result.imports.filter((i) => i.name === 'Pet');
      expect(petEntries).toHaveLength(2);
      expect(petEntries.some((i) => !i.alias)).toBe(true);
      expect(petEntries.some((i) => i.alias === '__Pet')).toBe(true);
    });
  });
});

describe('strict mock types (#3525)', () => {
  const petResponseType = {
    key: '200',
    value: 'Pet',
    contentType: 'application/json',
    originalSchema: {
      type: 'object',
      required: ['id', 'name'],
      properties: {
        id: { type: 'integer' },
        name: { type: 'string' },
        tag: { type: 'string', nullable: true },
      },
    },
    imports: [{ name: 'Pet', values: false }],
    schemas: [],
    type: 'object',
    isEnum: false,
    isRef: true,
    hasReadonlyProps: false,
  };

  const petVerbOptions = {
    operationId: 'getPet',
    operationName: 'getPet',
    verb: 'get',
    tags: [],
    response: {
      imports: [{ name: 'Pet', values: false }],
      definition: { success: 'Pet' },
      types: { success: [petResponseType] },
      contentTypes: ['application/json'],
    },
  } as unknown as GeneratorVerbOptions;

  const strictOverride = {
    operations: {},
    tags: {},
    mock: {
      required: true,
      nonNullable: true,
    },
  } as NormalizedOverrideOutput;

  const baseOptions = {
    route: '/pet',
    pathRoute: '/pet',
    output: 'test',
    override: strictOverride,
    context: {
      target: 'test',
      workspace: '',
      spec: {
        openapi: '3.0.0',
        info: { title: 'Test', version: '1.0.0' },
        paths: {},
      },
      output: {
        target: 'test',
        namingConvention: 'camelCase',
        fileExtension: '.ts',
        mode: 'single',
        override: strictOverride,
        client: 'axios-functions',
        httpClient: 'fetch',
        clean: false,
        docs: false,
        formatter: undefined,
        headers: false,
        indexFiles: true,
        allParamsOptional: false,
        urlEncodeParameters: false,
        unionAddMissingProperties: false,
        optionsParamRequired: false,
        propertySortOrder: 'specification',
      },
    },
  } as unknown as GeneratorOptions;

  it('emits PetMock return type for response mocks without per-operation type blocks', () => {
    const result = generateMSW(petVerbOptions, {
      ...baseOptions,
      mock: { type: OutputMockType.MSW },
    });

    expect(result.implementation.function).not.toContain('export type PetMock');
    expect(result.implementation.function).not.toContain(
      'export type KeysWithNull<O>',
    );
    expect(result.implementation.function).toContain(
      'export const getGetPetResponseMock = <O extends Partial<Extract<Pet, object>> = {}>(overrideResponse?: O): MockWithNullableOverrides<Pet, O, PetMock> =>',
    );
    expect(result.implementation.function).toContain(
      ') as MockWithNullableOverrides<Pet, O, PetMock>;',
    );
    expect(result.implementation.function).not.toContain(', null]');
  });

  it('derives responseMock and handler names from operationName (splitByContentType)', () => {
    // splitByContentType keeps one operationId across variants but suffixes
    // operationName (e.g. *WithJson / *WithFormData). The MSW responseMock and
    // handler names must follow operationName, otherwise sibling variants emit
    // duplicate declarations and tsc fails with TS2451. See #3342.
    const result = generateMSW(
      {
        ...petVerbOptions,
        operationId: 'getPet',
        operationName: 'getPetWithFormData',
      } as unknown as GeneratorVerbOptions,
      { ...baseOptions, mock: { type: OutputMockType.MSW } },
    );

    expect(result.implementation.handlerName).toBe(
      'getGetPetWithFormDataMockHandler',
    );
    expect(result.implementation.function).toContain(
      'export const getGetPetWithFormDataResponseMock',
    );
    expect(result.implementation.handler).toContain(
      'export const getGetPetWithFormDataMockHandler',
    );
    expect(result.implementation.function).not.toContain(
      'getGetPetResponseMock',
    );
  });

  it('keeps the loose return type when strict flags are unset', () => {
    const looseOverride = {
      operations: {},
      tags: {},
      mock: {},
    } as NormalizedOverrideOutput;

    const result = generateMSW(petVerbOptions, {
      ...baseOptions,
      override: looseOverride,
      context: {
        ...baseOptions.context,
        output: {
          ...baseOptions.context.output,
          override: looseOverride,
        },
      },
      mock: { type: OutputMockType.MSW },
    });

    expect(result.implementation.function).not.toContain('export type PetMock');
    expect(result.implementation.function).toContain(
      'export const getGetPetResponseMock = (overrideResponse: Partial<Extract<Pet, object>> = {}): Pet =>',
    );
  });
});

describe('recursion guards for cyclic allOf schemas', () => {
  const override = {
    operations: {},
    tags: {},
    mock: {},
  } as NormalizedOverrideOutput;

  // Drive generateMSW end-to-end with a response body that resolves to `root`,
  // with `schemas` available on the spec for $ref resolution. This exercises
  // the same expansion path that overflowed the stack on specs containing
  // allOf inheritance cycles between named component schemas — e.g. the
  // serialized System.Xml.Linq.* XML DOM types, where XElement → XContainer →
  // XNode → XObject and the base references its subtypes back. The earlier
  // `!item.isRef` allOf guard could not break such cycles because every hop is
  // a top-level $ref; the allOf-ancestor chain (existingReferencedAllOfRefs) now
  // does. A regression here throws `RangeError: Maximum call stack size exceeded`.
  const run = (schemas: Record<string, unknown>, root: string) => {
    const verbOptions = {
      operationId: 'getRoot',
      operationName: 'getRoot',
      verb: 'get',
      tags: [],
      response: {
        imports: [{ name: root, values: false }],
        definition: { success: root },
        types: {
          success: [
            {
              key: '200',
              value: root,
              contentType: 'application/json',
              originalSchema: { $ref: `#/components/schemas/${root}` },
              imports: [{ name: root, values: false }],
              schemas: [],
              isRef: true,
            },
          ],
          errors: [],
        },
        contentTypes: ['application/json'],
      },
    } as unknown as GeneratorVerbOptions;

    const options = {
      route: '/root',
      pathRoute: '/root',
      output: 'test',
      override,
      mock: { type: OutputMockType.MSW, delay: false },
      context: {
        target: 'test',
        workspace: '',
        spec: {
          openapi: '3.0.0',
          info: { title: 'Test', version: '1.0.0' },
          paths: {},
          components: { schemas },
        },
        output: {
          target: 'test',
          namingConvention: 'camelCase',
          fileExtension: '.ts',
          mode: 'single',
          override,
          client: 'axios-functions',
          httpClient: 'fetch',
          clean: false,
          docs: false,
          formatter: undefined,
          headers: false,
          indexFiles: true,
          allParamsOptional: false,
          urlEncodeParameters: false,
          unionAddMissingProperties: false,
          optionsParamRequired: false,
          propertySortOrder: 'specification',
        },
      },
    } as unknown as GeneratorOptions;

    return generateMSW(verbOptions, options);
  };

  it('does not overflow on a mutual allOf cycle (A allOf B, B allOf A)', () => {
    const schemas = {
      A: { allOf: [{ $ref: '#/components/schemas/B' }] },
      B: { allOf: [{ $ref: '#/components/schemas/A' }] },
    };
    expect(() => run(schemas, 'A')).not.toThrow();
  });

  it('does not overflow on a multi-hop allOf inheritance cycle', () => {
    const schemas = {
      A: { allOf: [{ $ref: '#/components/schemas/B' }] },
      B: { allOf: [{ $ref: '#/components/schemas/C' }] },
      C: { allOf: [{ $ref: '#/components/schemas/A' }] },
    };
    expect(() => run(schemas, 'A')).not.toThrow();
  });

  // A discriminated base whose subtypes extend it via allOf while the base
  // carries a property typed as one of those subtypes. This shape resembles the
  // real System.Xml.Linq.* family but is already handled by the existing guards
  // (it does NOT overflow pre-fix). It is kept as a guard in the other
  // direction: the new allOf-ancestor chain must not *over*-cut a legitimate
  // polymorphic hierarchy — it must keep generating successfully.
  it('still generates a discriminated allOf inheritance hierarchy', () => {
    const schemas = {
      XObject: {
        type: 'object',
        required: ['kind'],
        discriminator: {
          propertyName: 'kind',
          mapping: {
            node: '#/components/schemas/XNode',
            container: '#/components/schemas/XContainer',
            element: '#/components/schemas/XElement',
          },
        },
        properties: {
          kind: { type: 'string' },
          parent: {
            allOf: [{ $ref: '#/components/schemas/XElement' }],
            nullable: true,
          },
        },
      },
      XNode: { allOf: [{ $ref: '#/components/schemas/XObject' }] },
      XContainer: { allOf: [{ $ref: '#/components/schemas/XNode' }] },
      XElement: {
        allOf: [{ $ref: '#/components/schemas/XContainer' }],
        properties: { name: { type: 'string' } },
      },
    };
    expect(() => run(schemas, 'XElement')).not.toThrow();
  });
});