@stoplight/elements-core 9.0.25-beta-0.2 → 9.0.25-beta-0.4

package/src/utils/exampleGeneration/exampleGeneration.spec.tsx

@@ -1,664 +0,0 @@
-import * as Sampler from '@stoplight/json-schema-sampler';
-import { JSONSchema7 } from 'json-schema';
-
-import {
-  generateExampleFromMediaTypeContent,
-  generateExamplesFromJsonSchema,
-  stringifyExampleWithResolvedSchema,
-} from './exampleGeneration';
-
-const modelWithNoExamples: JSONSchema7 = require('../../__fixtures__/models/model-with-no-examples.json');
-
-describe('generateExamplesFromJsonSchema', () => {
-  it('returns error message when example generation fails ', () => {
-    const errorMessage = 'This is a mocked Error message';
-    jest.spyOn(Sampler, 'sample').mockImplementationOnce(() => {
-      throw Error(errorMessage);
-    });
-
-    const example = generateExamplesFromJsonSchema(modelWithNoExamples);
-    expect(example).toEqual([{ label: '', data: `Example cannot be created for this schema\nError: ${errorMessage}` }]);
-  });
-
-  it('generates examples for schemas with oneOf', () => {
-    const schemaWithOneOf: JSONSchema7 = {
-      oneOf: [
-        {
-          type: 'object',
-          properties: {
-            name: { type: 'string' },
-            age: { type: 'number' },
-          },
-        },
-        {
-          type: 'object',
-          properties: {
-            title: { type: 'string' },
-            description: { type: 'string' },
-          },
-        },
-      ],
-    };
-
-    const examples = generateExamplesFromJsonSchema(schemaWithOneOf);
-    expect(examples.length).toBeGreaterThan(0);
-    expect(examples[0].data).not.toContain('Example cannot be created');
-
-    const parsed = JSON.parse(examples[0].data);
-    expect(parsed).toHaveProperty('name');
-    expect(parsed).toHaveProperty('age');
-  });
-
-  it('generates examples for schemas with anyOf', () => {
-    const schemaWithAnyOf: JSONSchema7 = {
-      anyOf: [
-        {
-          type: 'object',
-          properties: {
-            username: { type: 'string' },
-            password: { type: 'string' },
-          },
-        },
-        {
-          type: 'object',
-          properties: {
-            token: { type: 'string' },
-          },
-        },
-      ],
-    };
-
-    const examples = generateExamplesFromJsonSchema(schemaWithAnyOf);
-    expect(examples.length).toBeGreaterThan(0);
-    expect(examples[0].data).not.toContain('Example cannot be created');
-
-    const parsed = JSON.parse(examples[0].data);
-    expect(parsed).toHaveProperty('username');
-    expect(parsed).toHaveProperty('password');
-  });
-});
-
-describe('generateExampleFromMediaTypeContent', () => {
-  it('generates examples for media type content with oneOf in schema', () => {
-    const mediaTypeContent = {
-      mediaType: 'application/json',
-      schema: {
-        oneOf: [
-          {
-            type: 'object',
-            properties: {
-              id: { type: 'number' },
-              name: { type: 'string' },
-            },
-          },
-          {
-            type: 'object',
-            properties: {
-              code: { type: 'string' },
-              message: { type: 'string' },
-            },
-          },
-        ],
-      },
-    };
-
-    const example = generateExampleFromMediaTypeContent(mediaTypeContent as any, {});
-    expect(example).not.toContain('Example cannot be created');
-
-    const parsed = JSON.parse(example);
-    expect(parsed).toHaveProperty('id');
-    expect(parsed).toHaveProperty('name');
-  });
-
-  it('does not use format-injected int32 minimum as generated value (double-processed internal model)', () => {
-    const mediaTypeContent = {
-      mediaType: 'application/json',
-      schema: {
-        type: 'integer',
-        format: 'int32',
-        minimum: 0 - 2 ** 31,
-        maximum: 2 ** 31 - 1,
-        'x-stoplight': { explicitProperties: ['type', 'format', 'minimum', 'maximum'] },
-      },
-    };
-
-    const example = generateExampleFromMediaTypeContent(mediaTypeContent as any, {});
-    const parsed = JSON.parse(example);
-    expect(parsed).not.toBe(0 - 2 ** 31);
-  });
-
-  it('does not use format-injected int64 minimum as generated value', () => {
-    const mediaTypeContent = {
-      mediaType: 'application/json',
-      schema: {
-        type: 'integer',
-        format: 'int64',
-        minimum: Number.MIN_SAFE_INTEGER,
-        maximum: Number.MAX_SAFE_INTEGER,
-        'x-stoplight': { explicitProperties: ['type', 'format', 'minimum', 'maximum'] },
-      },
-    };
-
-    const example = generateExampleFromMediaTypeContent(mediaTypeContent as any, {});
-    const parsed = JSON.parse(example);
-    expect(parsed).not.toBe(Number.MIN_SAFE_INTEGER);
-  });
-
-  it('preserves user-set minimum in request body schema that differs from format default', () => {
-    const mediaTypeContent = {
-      mediaType: 'application/json',
-      schema: {
-        type: 'integer',
-        format: 'int32',
-        minimum: 0, // user-authored, different from int32 default (-2147483648)
-        'x-stoplight': { explicitProperties: ['type', 'format', 'minimum'] },
-      },
-    };
-
-    const example = generateExampleFromMediaTypeContent(mediaTypeContent as any, {});
-    const parsed = JSON.parse(example);
-    expect(parsed).toBeGreaterThanOrEqual(0);
-  });
-
-  it('strips format-injected bounds from nested object properties in request body', () => {
-    const mediaTypeContent = {
-      mediaType: 'application/json',
-      schema: {
-        type: 'object',
-        properties: {
-          count: {
-            type: 'integer',
-            format: 'int32',
-            minimum: 0 - 2 ** 31,
-            maximum: 2 ** 31 - 1,
-            'x-stoplight': { explicitProperties: ['type', 'format', 'minimum', 'maximum'] },
-          },
-        },
-      },
-    };
-
-    const example = generateExampleFromMediaTypeContent(mediaTypeContent as any, {});
-    const parsed = JSON.parse(example);
-    expect(parsed.count).not.toBe(0 - 2 ** 31);
-  });
-
-  it('does not use format-injected float minimum as generated value', () => {
-    const mediaTypeContent = {
-      mediaType: 'application/json',
-      schema: {
-        type: 'number',
-        format: 'float',
-        minimum: 0 - 2 ** 128,
-        maximum: 2 ** 128 - 1,
-        'x-stoplight': { explicitProperties: ['type', 'format', 'minimum', 'maximum'] },
-      },
-    };
-
-    const example = generateExampleFromMediaTypeContent(mediaTypeContent as any, {});
-    const parsed = JSON.parse(example);
-    expect(parsed).not.toBe(0 - 2 ** 128);
-    expect(typeof parsed).toBe('number');
-  });
-
-  it('does not use format-injected double minimum as generated value', () => {
-    const mediaTypeContent = {
-      mediaType: 'application/json',
-      schema: {
-        type: 'number',
-        format: 'double',
-        minimum: 0 - Number.MAX_VALUE,
-        maximum: Number.MAX_VALUE,
-        'x-stoplight': { explicitProperties: ['type', 'format', 'minimum', 'maximum'] },
-      },
-    };
-
-    const example = generateExampleFromMediaTypeContent(mediaTypeContent as any, {});
-    const parsed = JSON.parse(example);
-    expect(parsed).not.toBe(0 - Number.MAX_VALUE);
-    expect(typeof parsed).toBe('number');
-  });
-
-  it('strips format-injected bounds from component model schema (no x-stoplight metadata)', () => {
-    const mediaTypeContent = {
-      mediaType: 'application/json',
-      schema: {
-        type: 'integer',
-        format: 'int32',
-        // no x-stoplight — raw OpenAPI component model, minimum injected by convertToJsonSchema
-        minimum: 0 - 2 ** 31,
-        maximum: 2 ** 31 - 1,
-      },
-    };
-
-    const example = generateExampleFromMediaTypeContent(mediaTypeContent as any, {});
-    const parsed = JSON.parse(example);
-    expect(parsed).not.toBe(0 - 2 ** 31);
-    expect(typeof parsed).toBe('number');
-  });
-
-  it('strips format-injected bounds from allOf members in request body', () => {
-    const mediaTypeContent = {
-      mediaType: 'application/json',
-      schema: {
-        allOf: [
-          {
-            type: 'integer',
-            format: 'int32',
-            minimum: 0 - 2 ** 31,
-            maximum: 2 ** 31 - 1,
-            'x-stoplight': { explicitProperties: ['type', 'format', 'minimum', 'maximum'] },
-          },
-        ],
-      },
-    };
-
-    const example = generateExampleFromMediaTypeContent(mediaTypeContent as any, {});
-    const parsed = JSON.parse(example);
-    expect(parsed).not.toBe(0 - 2 ** 31);
-    expect(typeof parsed).toBe('number');
-  });
-
-  it('strips format-injected bounds from oneOf members in request body', () => {
-    const mediaTypeContent = {
-      mediaType: 'application/json',
-      schema: {
-        oneOf: [
-          {
-            type: 'integer',
-            format: 'int32',
-            minimum: 0 - 2 ** 31,
-            maximum: 2 ** 31 - 1,
-            'x-stoplight': { explicitProperties: ['type', 'format', 'minimum', 'maximum'] },
-          },
-        ],
-      },
-    };
-
-    const example = generateExampleFromMediaTypeContent(mediaTypeContent as any, {});
-    const parsed = JSON.parse(example);
-    expect(parsed).not.toBe(0 - 2 ** 31);
-    expect(typeof parsed).toBe('number');
-  });
-
-  it('renders float field with no default as "0.0" not "0"', () => {
-    const mediaTypeContent = {
-      mediaType: 'application/json',
-      schema: { type: 'number', format: 'float' },
-    };
-
-    expect(generateExampleFromMediaTypeContent(mediaTypeContent as any, {}).trim()).toBe('0.0');
-  });
-
-  it('renders double field with no default as "0.0" not "0"', () => {
-    const mediaTypeContent = {
-      mediaType: 'application/json',
-      schema: { type: 'number', format: 'double' },
-    };
-
-    expect(generateExampleFromMediaTypeContent(mediaTypeContent as any, {}).trim()).toBe('0.0');
-  });
-
-  it('renders float property inside object as 0.0 in the output string', () => {
-    const mediaTypeContent = {
-      mediaType: 'application/json',
-      schema: {
-        type: 'object',
-        properties: {
-          price: { type: 'number', format: 'float' },
-          qty: { type: 'integer' },
-        },
-      },
-    };
-
-    const raw = generateExampleFromMediaTypeContent(mediaTypeContent as any, {});
-    expect(raw).toContain('"price": 0.0');
-    expect(raw).toContain('"qty": 0');
-  });
-
-  it('does not render plain number (no format) as 0.0', () => {
-    const mediaTypeContent = {
-      mediaType: 'application/json',
-      schema: { type: 'number' },
-    };
-
-    expect(generateExampleFromMediaTypeContent(mediaTypeContent as any, {}).trim()).toBe('0');
-  });
-});
-
-describe('stripInferredNumericBounds - Format-injected min/max handling', () => {
-  it('strips format-injected minimum/maximum from int32 (internal model case - double-processed)', () => {
-    const internalModelSchema: JSONSchema7 = {
-      type: 'integer',
-      format: 'int32',
-      minimum: 0 - 2 ** 31, // -2147483648
-      maximum: 2 ** 31 - 1, // 2147483647
-      ['x-stoplight']: {
-        explicitProperties: ['type', 'format', 'minimum', 'maximum'], // incorrectly includes min/max due to double-processing
-      },
-    } as any;
-
-    const examples = generateExamplesFromJsonSchema(internalModelSchema);
-    const parsed = JSON.parse(examples[0].data);
-    // After stripping, sampler should generate a normal value like 0, not -2147483648
-    expect(parsed).not.toBe(-2147483648);
-    expect(parsed).not.toBe(2147483647);
-    expect(typeof parsed).toBe('number');
-  });
-
-  it('strips format-injected bounds from int64', () => {
-    const schema: JSONSchema7 = {
-      type: 'integer',
-      format: 'int64',
-      minimum: Number.MIN_SAFE_INTEGER,
-      maximum: Number.MAX_SAFE_INTEGER,
-      ['x-stoplight']: {
-        explicitProperties: ['type', 'format', 'minimum', 'maximum'],
-      },
-    } as any;
-
-    const examples = generateExamplesFromJsonSchema(schema);
-    const parsed = JSON.parse(examples[0].data);
-    expect(parsed).not.toBe(Number.MIN_SAFE_INTEGER);
-    expect(parsed).not.toBe(Number.MAX_SAFE_INTEGER);
-    expect(typeof parsed).toBe('number');
-  });
-
-  it('strips format-injected bounds from float', () => {
-    const schema: JSONSchema7 = {
-      type: 'number',
-      format: 'float',
-      minimum: 0 - 2 ** 128,
-      maximum: 2 ** 128 - 1,
-      ['x-stoplight']: {
-        explicitProperties: ['type', 'format', 'minimum', 'maximum'],
-      },
-    } as any;
-
-    const examples = generateExamplesFromJsonSchema(schema);
-    const parsed = JSON.parse(examples[0].data);
-    expect(typeof parsed).toBe('number');
-    expect(parsed).not.toBe(0 - 2 ** 128);
-  });
-
-  it('keeps user-set minimum/maximum that differ from format default', () => {
-    const schema: JSONSchema7 = {
-      type: 'integer',
-      format: 'int32',
-      minimum: 0, // User explicitly set to 0, not the format default -2147483648
-      maximum: 100,
-      ['x-stoplight']: {
-        explicitProperties: ['type', 'format', 'minimum', 'maximum'],
-      },
-    } as any;
-
-    const examples = generateExamplesFromJsonSchema(schema);
-    const parsed = JSON.parse(examples[0].data);
-    // Sampler should respect user's constraints
-    expect(parsed).toBeGreaterThanOrEqual(0);
-    expect(parsed).toBeLessThanOrEqual(100);
-  });
-
-  it('does not affect component model schemas (no x-stoplight)', () => {
-    const componentModelSchema: JSONSchema7 = {
-      type: 'integer',
-      format: 'int32',
-      // No minimum/maximum, no x-stoplight
-    };
-
-    const examples = generateExamplesFromJsonSchema(componentModelSchema);
-    const parsed = JSON.parse(examples[0].data);
-    expect(typeof parsed).toBe('number');
-    expect(parsed).not.toBe(0 - 2 ** 31); // Should not be format boundary
-  });
-
-  it('handles nested properties with format-injected bounds', () => {
-    const schema: JSONSchema7 = {
-      type: 'object',
-      properties: {
-        count: {
-          type: 'integer',
-          format: 'int32',
-          minimum: 0 - 2 ** 31,
-          maximum: 2 ** 31 - 1,
-          ['x-stoplight']: {
-            explicitProperties: ['type', 'format', 'minimum', 'maximum'],
-          },
-        },
-        total: {
-          type: 'number',
-          format: 'float',
-          minimum: 0 - 2 ** 128,
-          maximum: 2 ** 128 - 1,
-          ['x-stoplight']: {
-            explicitProperties: ['type', 'format', 'minimum', 'maximum'],
-          },
-        },
-      },
-    } as any;
-
-    const examples = generateExamplesFromJsonSchema(schema);
-    const parsed = JSON.parse(examples[0].data);
-    expect(parsed).toHaveProperty('count');
-    expect(parsed).toHaveProperty('total');
-    expect(typeof parsed.count).toBe('number');
-    expect(typeof parsed.total).toBe('number');
-    // Neither should be format boundary values
-    expect(parsed.count).not.toBe(0 - 2 ** 31);
-    expect(parsed.total).not.toBe(0 - 2 ** 128);
-  });
-
-  it('handles allOf with format-injected bounds', () => {
-    const schema: JSONSchema7 = {
-      allOf: [
-        {
-          type: 'object',
-          properties: {
-            value: {
-              type: 'integer',
-              format: 'int32',
-              minimum: 0 - 2 ** 31,
-              maximum: 2 ** 31 - 1,
-              ['x-stoplight']: {
-                explicitProperties: ['type', 'format', 'minimum', 'maximum'],
-              },
-            },
-          },
-        },
-      ],
-    } as any;
-
-    const examples = generateExamplesFromJsonSchema(schema);
-    const parsed = JSON.parse(examples[0].data);
-    expect(parsed).toHaveProperty('value');
-    expect(typeof parsed.value).toBe('number');
-    expect(parsed.value).not.toBe(0 - 2 ** 31);
-  });
-
-  it('handles oneOf with format-injected bounds in options', () => {
-    const schema: JSONSchema7 = {
-      oneOf: [
-        {
-          type: 'integer',
-          format: 'int32',
-          minimum: 0 - 2 ** 31,
-          maximum: 2 ** 31 - 1,
-          ['x-stoplight']: {
-            explicitProperties: ['type', 'format', 'minimum', 'maximum'],
-          },
-        },
-        {
-          type: 'string',
-        },
-      ],
-    } as any;
-
-    const examples = generateExamplesFromJsonSchema(schema);
-    const parsed = JSON.parse(examples[0].data);
-    // Should be either string or a reasonable integer, not format boundary
-    expect(parsed === 0 - 2 ** 31 ? false : true).toBe(true);
-  });
-
-  it('keeps minimum only without maximum when only minimum is user-set', () => {
-    const schema: JSONSchema7 = {
-      type: 'integer',
-      format: 'int32',
-      minimum: 10, // User-set, differs from format default
-      ['x-stoplight']: {
-        explicitProperties: ['type', 'format', 'minimum'],
-      },
-    } as any;
-
-    const examples = generateExamplesFromJsonSchema(schema);
-    const parsed = JSON.parse(examples[0].data);
-    expect(parsed).toBeGreaterThanOrEqual(10);
-  });
-
-  it('handles double-processed schema correctly - does not throw error', () => {
-    const doubleProcessedSchema: JSONSchema7 = {
-      type: 'integer',
-      format: 'int32',
-      minimum: 0 - 2 ** 31,
-      maximum: 2 ** 31 - 1,
-      ['x-stoplight']: {
-        explicitProperties: ['type', 'format', 'minimum', 'maximum'],
-      },
-      description: 'This was processed twice',
-    } as any;
-
-    expect(() => {
-      generateExamplesFromJsonSchema(doubleProcessedSchema);
-    }).not.toThrow();
-
-    const examples = generateExamplesFromJsonSchema(doubleProcessedSchema);
-    expect(examples.length).toBeGreaterThan(0);
-    expect(examples[0].data).not.toContain('Example cannot be created');
-  });
-
-  it('renders float field in Example section as "0.0" not "0"', () => {
-    const schema: JSONSchema7 = { type: 'number', format: 'float' };
-    expect(generateExamplesFromJsonSchema(schema)[0].data.trim()).toBe('0.0');
-  });
-
-  it('renders double field in Example section as "0.0" not "0"', () => {
-    const schema: JSONSchema7 = { type: 'number', format: 'double' };
-    expect(generateExamplesFromJsonSchema(schema)[0].data.trim()).toBe('0.0');
-  });
-
-  it('renders float property inside object as 0.0 in Example section', () => {
-    const schema: JSONSchema7 = {
-      type: 'object',
-      properties: {
-        rate: { type: 'number', format: 'float' } as any,
-        code: { type: 'integer' },
-      },
-    };
-
-    const data = generateExamplesFromJsonSchema(schema)[0].data;
-    expect(data).toContain('"rate": 0.0');
-    expect(data).toContain('"code": 0');
-  });
-});
-
-describe('stringifyExampleWithResolvedSchema', () => {
-  it('normalizes inferred numeric bounds inside array items', () => {
-    const schema: JSONSchema7 = {
-      type: 'array',
-      items: {
-        type: 'object',
-        properties: {
-          age: {
-            type: 'integer',
-            format: 'int32',
-            minimum: 0 - 2 ** 31,
-            maximum: 2 ** 31 - 1,
-            ['x-stoplight']: { explicitProperties: ['type', 'format'] },
-          },
-          price: {
-            type: 'number',
-            format: 'float',
-            minimum: 0 - 2 ** 128,
-            maximum: 2 ** 128 - 1,
-            ['x-stoplight']: { explicitProperties: ['type', 'format'] },
-          },
-        },
-      },
-    } as any;
-
-    const data = stringifyExampleWithResolvedSchema([{ age: 0 - 2 ** 31, price: 0 - 2 ** 128 }], schema);
-    expect(data).toContain('"age": 0');
-    expect(data).toContain('"price": 0.0');
-  });
-
-  it('normalizes inferred numeric bounds inside allOf response schemas', () => {
-    const schema: JSONSchema7 = {
-      allOf: [
-        {
-          type: 'object',
-          properties: {
-            age: {
-              type: 'integer',
-              format: 'int32',
-              minimum: 0 - 2 ** 31,
-              maximum: 2 ** 31 - 1,
-              ['x-stoplight']: { explicitProperties: ['type', 'format'] },
-            },
-          },
-        },
-        {
-          type: 'object',
-          properties: {
-            price: {
-              type: 'number',
-              format: 'float',
-              minimum: 0 - 2 ** 128,
-              maximum: 2 ** 128 - 1,
-              ['x-stoplight']: { explicitProperties: ['type', 'format'] },
-            },
-          },
-        },
-      ],
-    } as any;
-
-    const data = stringifyExampleWithResolvedSchema({ age: 0 - 2 ** 31, price: 0 - 2 ** 128 }, schema);
-    expect(data).toContain('"age": 0');
-    expect(data).toContain('"price": 0.0');
-  });
-
-  it('normalizes inferred numeric bounds inside oneOf and anyOf response schemas', () => {
-    const oneOfSchema: JSONSchema7 = {
-      oneOf: [
-        {
-          type: 'object',
-          properties: {
-            age: {
-              type: 'integer',
-              format: 'int32',
-              minimum: 0 - 2 ** 31,
-              maximum: 2 ** 31 - 1,
-              ['x-stoplight']: { explicitProperties: ['type', 'format'] },
-            },
-          },
-        },
-      ],
-    } as any;
-    const anyOfSchema: JSONSchema7 = {
-      anyOf: [
-        {
-          type: 'object',
-          properties: {
-            price: {
-              type: 'number',
-              format: 'float',
-              minimum: 0 - 2 ** 128,
-              maximum: 2 ** 128 - 1,
-              ['x-stoplight']: { explicitProperties: ['type', 'format'] },
-            },
-          },
-        },
-      ],
-    } as any;
-
-    expect(stringifyExampleWithResolvedSchema({ age: 0 - 2 ** 31 }, oneOfSchema)).toContain('"age": 0');
-    expect(stringifyExampleWithResolvedSchema({ price: 0 - 2 ** 128 }, anyOfSchema)).toContain('"price": 0.0');
-  });
-});