mirror of
https://github.com/GitbookIO/gitbook.git
synced 2026-09-16 23:55:20 +00:00
Nolann B.
1127 lines
32 KiB
TypeScript
1127 lines
32 KiB
TypeScript
import { describe, expect, it } from 'bun:test';
|
||
|
||
import type { OpenAPIV3 } from '@gitbook/openapi-parser';
|
||
import { generateSchemaExample } from './generateSchemaExample';
|
||
|
||
describe('generateSchemaExample', () => {
|
||
it('sets example values', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
example: 10,
|
||
})
|
||
).toBe(10);
|
||
});
|
||
|
||
it('uses first example, if multiple are configured', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
examples: [10],
|
||
})
|
||
).toBe(10);
|
||
});
|
||
|
||
it('takes the first enum as example', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
enum: ['available', 'pending', 'sold'],
|
||
})
|
||
).toBe('available');
|
||
});
|
||
|
||
it('uses "text" as a fallback for strings', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'string',
|
||
})
|
||
).toBe('text');
|
||
});
|
||
|
||
it('only includes required attributes and attributes with example values', () => {
|
||
expect(
|
||
generateSchemaExample(
|
||
{
|
||
type: 'object',
|
||
required: ['first_name'],
|
||
properties: {
|
||
first_name: {
|
||
type: 'string',
|
||
},
|
||
last_name: {
|
||
type: 'string',
|
||
required: true,
|
||
},
|
||
position: {
|
||
type: 'string',
|
||
examples: ['Developer'],
|
||
},
|
||
description: {
|
||
type: 'string',
|
||
example: 'A developer',
|
||
},
|
||
age: {
|
||
type: 'number',
|
||
},
|
||
},
|
||
},
|
||
{
|
||
omitEmptyAndOptionalProperties: true,
|
||
}
|
||
)
|
||
).toStrictEqual({
|
||
first_name: 'text',
|
||
last_name: 'text',
|
||
position: 'Developer',
|
||
description: 'A developer',
|
||
});
|
||
});
|
||
|
||
it('includes every available attributes', () => {
|
||
expect(
|
||
generateSchemaExample(
|
||
{
|
||
type: 'object',
|
||
required: ['first_name'],
|
||
properties: {
|
||
first_name: {
|
||
type: 'string',
|
||
},
|
||
last_name: {
|
||
type: 'string',
|
||
required: true,
|
||
},
|
||
position: {
|
||
type: 'string',
|
||
examples: ['Developer'],
|
||
},
|
||
description: {
|
||
type: 'string',
|
||
example: 'A developer',
|
||
},
|
||
age: {
|
||
type: 'number',
|
||
},
|
||
},
|
||
},
|
||
{
|
||
omitEmptyAndOptionalProperties: false,
|
||
}
|
||
)
|
||
).toStrictEqual({
|
||
first_name: 'text',
|
||
last_name: 'text',
|
||
position: 'Developer',
|
||
description: 'A developer',
|
||
age: 1,
|
||
});
|
||
});
|
||
|
||
it('uses example value for first type in non-null union types', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: ['string', 'number'],
|
||
} as OpenAPIV3.BaseSchemaObject)
|
||
).toBe('text');
|
||
});
|
||
|
||
it('uses null for nullable union types', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: ['string', 'null'],
|
||
} as OpenAPIV3.BaseSchemaObject)
|
||
).toBeNull();
|
||
});
|
||
|
||
it('sets example values', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
example: 10,
|
||
})
|
||
).toBe(10);
|
||
});
|
||
|
||
it('goes through properties recursively with objects', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'object',
|
||
properties: {
|
||
category: {
|
||
type: 'object',
|
||
properties: {
|
||
id: {
|
||
example: 1,
|
||
},
|
||
name: {
|
||
example: 'Dogs',
|
||
},
|
||
attributes: {
|
||
type: 'object',
|
||
properties: {
|
||
size: {
|
||
enum: ['small', 'medium', 'large'],
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
})
|
||
).toMatchObject({
|
||
category: {
|
||
id: 1,
|
||
name: 'Dogs',
|
||
attributes: {
|
||
size: 'small',
|
||
},
|
||
},
|
||
});
|
||
});
|
||
|
||
it('goes through properties recursively with arrays', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'object',
|
||
properties: {
|
||
tags: {
|
||
type: 'array',
|
||
items: {
|
||
type: 'object',
|
||
properties: {
|
||
id: {
|
||
example: 1,
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
})
|
||
).toMatchObject({
|
||
tags: [
|
||
{
|
||
id: 1,
|
||
},
|
||
],
|
||
});
|
||
});
|
||
|
||
it('uses empty [] as a fallback for arrays', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'object',
|
||
properties: {
|
||
title: {
|
||
type: 'array',
|
||
},
|
||
},
|
||
})
|
||
).toMatchObject({
|
||
title: [],
|
||
});
|
||
});
|
||
|
||
// it('returns emails as an example value', () => {
|
||
// const result = generateSchemaExample({
|
||
// type: 'string',
|
||
// format: 'email',
|
||
// });
|
||
|
||
// function isEmail(text: string) {
|
||
// return !!text.match(/^.+@.+\..+$/);
|
||
// }
|
||
|
||
// expect(isEmail(result)).toBe(true);
|
||
// });
|
||
|
||
it('uses true as a fallback for booleans', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'boolean',
|
||
})
|
||
).toBe(true);
|
||
});
|
||
|
||
it('uses 1 as a fallback for integers', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'integer',
|
||
})
|
||
).toBe(1);
|
||
});
|
||
|
||
it('returns an array if the schema type is array', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'array',
|
||
})
|
||
).toMatchObject([]);
|
||
});
|
||
|
||
it('uses array example values', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'array',
|
||
example: ['foobar'],
|
||
items: {
|
||
type: 'string',
|
||
},
|
||
})
|
||
).toMatchObject(['foobar']);
|
||
});
|
||
|
||
it('uses specified object as array default', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'array',
|
||
items: {
|
||
type: 'object',
|
||
properties: {
|
||
foo: {
|
||
type: 'number',
|
||
},
|
||
bar: {
|
||
type: 'string',
|
||
},
|
||
},
|
||
},
|
||
})
|
||
).toMatchObject([
|
||
{
|
||
foo: 1,
|
||
bar: 'text',
|
||
},
|
||
]);
|
||
});
|
||
|
||
it('uses the first example in object anyOf', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'object',
|
||
anyOf: [
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
foo: { type: 'number' },
|
||
},
|
||
},
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
bar: { type: 'string' },
|
||
},
|
||
},
|
||
],
|
||
})
|
||
).toMatchObject({ foo: 1 });
|
||
});
|
||
|
||
it('uses the first example in object oneOf', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'object',
|
||
oneOf: [
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
foo: { type: 'number' },
|
||
},
|
||
},
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
bar: { type: 'string' },
|
||
},
|
||
},
|
||
],
|
||
})
|
||
).toMatchObject({ foo: 1 });
|
||
});
|
||
|
||
it('uses the first example in object anyOf when type is not defined', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
anyOf: [
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
foo: { type: 'number' },
|
||
},
|
||
},
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
bar: { type: 'string' },
|
||
},
|
||
},
|
||
],
|
||
})
|
||
).toMatchObject({ foo: 1 });
|
||
});
|
||
|
||
it('uses the first example in object oneOf when type is not defined', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
oneOf: [
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
foo: { type: 'number' },
|
||
},
|
||
},
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
bar: { type: 'string' },
|
||
},
|
||
},
|
||
],
|
||
})
|
||
).toMatchObject({ foo: 1 });
|
||
});
|
||
|
||
it('uses all examples in object allOf', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
allOf: [
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
foo: { type: 'number' },
|
||
},
|
||
},
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
bar: { type: 'string' },
|
||
},
|
||
},
|
||
],
|
||
})
|
||
).toMatchObject({ foo: 1, bar: 'text' });
|
||
});
|
||
|
||
it('merges allOf items in arrays', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'array',
|
||
items: {
|
||
allOf: [
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
foobar: { type: 'string' },
|
||
foo: { type: 'number' },
|
||
},
|
||
},
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
bar: { type: 'string' },
|
||
},
|
||
},
|
||
],
|
||
},
|
||
})
|
||
).toMatchObject([{ foobar: 'text', foo: 1, bar: 'text' }]);
|
||
});
|
||
|
||
it('handles array items with allOf containing objects', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'array',
|
||
items: {
|
||
allOf: [
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
id: { type: 'number', example: 1 },
|
||
},
|
||
},
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
name: { type: 'string', example: 'test' },
|
||
},
|
||
},
|
||
],
|
||
},
|
||
})
|
||
).toMatchObject([
|
||
{
|
||
id: 1,
|
||
name: 'test',
|
||
},
|
||
]);
|
||
});
|
||
|
||
it('uses the first example in array anyOf', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'array',
|
||
items: {
|
||
anyOf: [
|
||
{
|
||
type: 'string',
|
||
example: 'foobar',
|
||
},
|
||
{
|
||
type: 'string',
|
||
example: 'barfoo',
|
||
},
|
||
],
|
||
},
|
||
})
|
||
).toMatchObject(['foobar']);
|
||
});
|
||
|
||
it('uses one example in array oneOf', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'array',
|
||
items: {
|
||
oneOf: [
|
||
{
|
||
type: 'string',
|
||
example: 'foobar',
|
||
},
|
||
{
|
||
type: 'string',
|
||
example: 'barfoo',
|
||
},
|
||
],
|
||
},
|
||
})
|
||
).toMatchObject(['foobar']);
|
||
});
|
||
|
||
it('uses all examples in array allOf', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'array',
|
||
items: {
|
||
allOf: [
|
||
{
|
||
type: 'string',
|
||
example: 'foobar',
|
||
},
|
||
{
|
||
type: 'string',
|
||
example: 'barfoo',
|
||
},
|
||
],
|
||
},
|
||
})
|
||
).toMatchObject(['foobar', 'barfoo']);
|
||
});
|
||
|
||
it('uses 1 as the default for a number', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'number',
|
||
})
|
||
).toBe(1);
|
||
});
|
||
|
||
it('uses min as the default for a number', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'number',
|
||
min: 200,
|
||
})
|
||
).toBe(200);
|
||
});
|
||
|
||
it('returns plaintext', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'string',
|
||
example: 'foobar',
|
||
})
|
||
).toEqual('foobar');
|
||
});
|
||
|
||
it('converts a whole schema to an example response', () => {
|
||
const schema: OpenAPIV3.SchemaObject = {
|
||
required: ['name', 'photoUrls'],
|
||
type: 'object',
|
||
properties: {
|
||
id: {
|
||
type: 'integer',
|
||
format: 'int64',
|
||
example: 10,
|
||
},
|
||
name: {
|
||
type: 'string',
|
||
example: 'doggie',
|
||
},
|
||
category: {
|
||
type: 'object',
|
||
properties: {
|
||
id: {
|
||
type: 'integer',
|
||
format: 'int64',
|
||
example: 1,
|
||
},
|
||
name: {
|
||
type: 'string',
|
||
example: 'Dogs',
|
||
},
|
||
},
|
||
xml: {
|
||
name: 'category',
|
||
},
|
||
},
|
||
photoUrls: {
|
||
type: 'array',
|
||
xml: {
|
||
wrapped: true,
|
||
},
|
||
items: {
|
||
type: 'string',
|
||
xml: {
|
||
name: 'photoUrl',
|
||
},
|
||
},
|
||
},
|
||
tags: {
|
||
type: 'array',
|
||
xml: {
|
||
wrapped: true,
|
||
},
|
||
items: {
|
||
type: 'object',
|
||
properties: {
|
||
id: {
|
||
type: 'integer',
|
||
format: 'int64',
|
||
},
|
||
name: {
|
||
type: 'string',
|
||
},
|
||
},
|
||
xml: {
|
||
name: 'tag',
|
||
},
|
||
},
|
||
},
|
||
status: {
|
||
type: 'string',
|
||
description: 'pet status in the store',
|
||
enum: ['available', 'pending', 'sold'],
|
||
},
|
||
},
|
||
xml: {
|
||
name: 'pet',
|
||
},
|
||
};
|
||
|
||
expect(generateSchemaExample(schema)).toMatchObject({
|
||
id: 10,
|
||
name: 'doggie',
|
||
category: {
|
||
id: 1,
|
||
name: 'Dogs',
|
||
},
|
||
photoUrls: ['text'],
|
||
tags: [
|
||
{
|
||
id: 1,
|
||
name: 'text',
|
||
},
|
||
],
|
||
status: 'available',
|
||
});
|
||
});
|
||
|
||
it('outputs XML', () => {
|
||
expect(
|
||
generateSchemaExample(
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
id: {
|
||
example: 1,
|
||
xml: {
|
||
name: 'foo',
|
||
},
|
||
},
|
||
},
|
||
},
|
||
{ xml: true }
|
||
)
|
||
).toMatchObject({
|
||
foo: 1,
|
||
});
|
||
});
|
||
|
||
it('add XML wrappers where needed', () => {
|
||
expect(
|
||
generateSchemaExample(
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
photoUrls: {
|
||
type: 'array',
|
||
xml: {
|
||
wrapped: true,
|
||
},
|
||
items: {
|
||
type: 'string',
|
||
example: 'https://example.com',
|
||
xml: {
|
||
name: 'photoUrl',
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
{ xml: true }
|
||
)
|
||
).toMatchObject({
|
||
photoUrls: [{ photoUrl: 'https://example.com' }],
|
||
});
|
||
});
|
||
|
||
it('doesn’t wrap items when not needed', () => {
|
||
expect(
|
||
generateSchemaExample(
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
photoUrls: {
|
||
type: 'array',
|
||
items: {
|
||
type: 'string',
|
||
example: 'https://example.com',
|
||
xml: {
|
||
name: 'photoUrl',
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
{ xml: true }
|
||
)
|
||
).toMatchObject({
|
||
photoUrls: ['https://example.com'],
|
||
});
|
||
});
|
||
|
||
it('use the first item of oneOf', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
oneOf: [
|
||
{
|
||
maxLength: 255,
|
||
type: 'string',
|
||
},
|
||
{
|
||
type: 'null',
|
||
},
|
||
],
|
||
})
|
||
).toBe('text');
|
||
});
|
||
|
||
it('works with allOf', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
allOf: [
|
||
{
|
||
type: 'string',
|
||
},
|
||
],
|
||
})
|
||
).toBe('text');
|
||
});
|
||
|
||
it('uses all schemas in allOf', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
allOf: [
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
id: {
|
||
example: 10,
|
||
},
|
||
},
|
||
},
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
title: {
|
||
example: 'Foobar',
|
||
},
|
||
},
|
||
},
|
||
],
|
||
})
|
||
).toMatchObject({
|
||
id: 10,
|
||
title: 'Foobar',
|
||
});
|
||
});
|
||
|
||
it('returns null for unknown types', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'fantasy',
|
||
} as OpenAPIV3.BaseSchemaObject)
|
||
).toBe(null);
|
||
});
|
||
|
||
it('returns readOnly attributes by default', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
example: 'foobar',
|
||
readOnly: true,
|
||
})
|
||
).toBe('foobar');
|
||
});
|
||
|
||
it('returns readOnly attributes in read mode', () => {
|
||
expect(
|
||
generateSchemaExample(
|
||
{
|
||
example: 'foobar',
|
||
readOnly: true,
|
||
},
|
||
{
|
||
mode: 'read',
|
||
}
|
||
)
|
||
).toBe('foobar');
|
||
});
|
||
|
||
it('doesn’t return readOnly attributes in write mode', () => {
|
||
expect(
|
||
generateSchemaExample(
|
||
{
|
||
example: 'foobar',
|
||
readOnly: true,
|
||
},
|
||
{
|
||
mode: 'write',
|
||
}
|
||
)
|
||
).toBeUndefined();
|
||
});
|
||
|
||
it('returns writeOnly attributes by default', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
example: 'foobar',
|
||
writeOnly: true,
|
||
})
|
||
).toBe('foobar');
|
||
});
|
||
|
||
it('returns writeOnly attributes in write mode', () => {
|
||
expect(
|
||
generateSchemaExample(
|
||
{
|
||
example: 'foobar',
|
||
writeOnly: true,
|
||
},
|
||
{
|
||
mode: 'write',
|
||
}
|
||
)
|
||
).toBe('foobar');
|
||
});
|
||
|
||
it('doesn’t return writeOnly attributes in read mode', () => {
|
||
expect(
|
||
generateSchemaExample(
|
||
{
|
||
example: 'foobar',
|
||
writeOnly: true,
|
||
},
|
||
{
|
||
mode: 'read',
|
||
}
|
||
)
|
||
).toBeUndefined();
|
||
});
|
||
|
||
it('allows any additonalProperty', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'object',
|
||
additionalProperties: {},
|
||
})
|
||
).toMatchObject({
|
||
ANY_ADDITIONAL_PROPERTY: 'anything',
|
||
});
|
||
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'object',
|
||
additionalProperties: true,
|
||
})
|
||
).toMatchObject({
|
||
ANY_ADDITIONAL_PROPERTY: 'anything',
|
||
});
|
||
});
|
||
|
||
it('adds an additionalProperty with specific types', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'object',
|
||
additionalProperties: {
|
||
type: 'integer',
|
||
},
|
||
})
|
||
).toMatchObject({
|
||
ANY_ADDITIONAL_PROPERTY: 1,
|
||
});
|
||
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'object',
|
||
additionalProperties: {
|
||
type: 'boolean',
|
||
},
|
||
})
|
||
).toMatchObject({
|
||
ANY_ADDITIONAL_PROPERTY: true,
|
||
});
|
||
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'object',
|
||
additionalProperties: {
|
||
type: 'string',
|
||
},
|
||
})
|
||
).toMatchObject({
|
||
ANY_ADDITIONAL_PROPERTY: 'text',
|
||
});
|
||
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'object',
|
||
additionalProperties: {
|
||
type: 'object',
|
||
properties: {
|
||
foo: {
|
||
type: 'string',
|
||
},
|
||
},
|
||
},
|
||
})
|
||
).toMatchObject({
|
||
ANY_ADDITIONAL_PROPERTY: {
|
||
foo: 'text',
|
||
},
|
||
});
|
||
});
|
||
|
||
it('works with anyOf', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
title: 'Foo',
|
||
type: 'object',
|
||
anyOf: [
|
||
{
|
||
type: 'object',
|
||
required: ['a'],
|
||
properties: {
|
||
a: {
|
||
type: 'integer',
|
||
format: 'int32',
|
||
},
|
||
},
|
||
},
|
||
{
|
||
type: 'object',
|
||
required: ['b'],
|
||
properties: {
|
||
b: {
|
||
type: 'string',
|
||
},
|
||
},
|
||
},
|
||
],
|
||
required: ['c'],
|
||
properties: {
|
||
c: {
|
||
type: 'boolean',
|
||
},
|
||
},
|
||
})
|
||
).toStrictEqual({
|
||
a: 1,
|
||
c: true,
|
||
});
|
||
});
|
||
|
||
it('deals with circular references', () => {
|
||
const schema = {
|
||
type: 'object',
|
||
properties: {
|
||
foobar: {},
|
||
},
|
||
} satisfies OpenAPIV3.SchemaObject;
|
||
|
||
// Create a circular reference
|
||
schema.properties.foobar = schema;
|
||
|
||
// 10 levels deep, that’s enough. It should return null then.
|
||
expect(generateSchemaExample(schema)).toStrictEqual({
|
||
foobar: {
|
||
foobar: {
|
||
foobar: {
|
||
foobar: {
|
||
foobar: {
|
||
foobar: '[Circular Reference]',
|
||
},
|
||
},
|
||
},
|
||
},
|
||
},
|
||
});
|
||
});
|
||
|
||
it('handles patternProperties', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'object',
|
||
patternProperties: {
|
||
'^(.*)$': {
|
||
type: 'object',
|
||
properties: {
|
||
dataId: {
|
||
type: 'string',
|
||
},
|
||
link: {
|
||
anyOf: [
|
||
{
|
||
format: 'uri',
|
||
type: 'string',
|
||
example: 'https://example.com',
|
||
},
|
||
{
|
||
type: 'null',
|
||
},
|
||
],
|
||
},
|
||
},
|
||
required: ['dataId', 'link'],
|
||
},
|
||
},
|
||
})
|
||
).toStrictEqual({
|
||
'^(.*)$': {
|
||
dataId: 'text',
|
||
link: 'https://example.com',
|
||
},
|
||
});
|
||
});
|
||
|
||
it('handles deprecated properties', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'object',
|
||
deprecated: true,
|
||
})
|
||
).toBeUndefined();
|
||
});
|
||
|
||
it('handle nested deprecated properties', () => {
|
||
expect(
|
||
generateSchemaExample({
|
||
type: 'array',
|
||
items: {
|
||
deprecated: true,
|
||
},
|
||
})
|
||
).toBeUndefined();
|
||
});
|
||
|
||
it('merges object properties from oneOf -> allOf', () => {
|
||
const schema = {
|
||
type: 'object',
|
||
properties: {
|
||
discriminator: {
|
||
type: 'string',
|
||
},
|
||
},
|
||
oneOf: [
|
||
{
|
||
allOf: [
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
bar: {
|
||
type: 'string',
|
||
},
|
||
},
|
||
},
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
baz: {
|
||
type: 'number',
|
||
},
|
||
},
|
||
},
|
||
{
|
||
type: 'string', // This will return a string, but should be ignored
|
||
},
|
||
],
|
||
},
|
||
],
|
||
} satisfies OpenAPIV3.SchemaObject;
|
||
|
||
const result = generateSchemaExample(schema);
|
||
|
||
expect(result).toBeDefined();
|
||
expect(result).toHaveProperty('discriminator');
|
||
expect(result).toHaveProperty('bar');
|
||
expect(result).toHaveProperty('baz');
|
||
});
|
||
|
||
it('merges object properties from anyOf -> allOf', () => {
|
||
const schema = {
|
||
type: 'object',
|
||
properties: {
|
||
discriminator: {
|
||
type: 'string',
|
||
},
|
||
},
|
||
anyOf: [
|
||
{
|
||
allOf: [
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
bar: {
|
||
type: 'string',
|
||
},
|
||
},
|
||
},
|
||
{
|
||
type: 'object',
|
||
properties: {
|
||
baz: {
|
||
type: 'number',
|
||
},
|
||
},
|
||
},
|
||
{
|
||
type: 'string', // This will return a string, but should be ignored
|
||
},
|
||
],
|
||
},
|
||
],
|
||
} satisfies OpenAPIV3.SchemaObject;
|
||
|
||
const result = generateSchemaExample(schema);
|
||
|
||
expect(result).toBeDefined();
|
||
expect(result).toHaveProperty('discriminator');
|
||
expect(result).toHaveProperty('bar');
|
||
expect(result).toHaveProperty('baz');
|
||
});
|
||
});
|