@redocly/openapi-docs 3.24.1 → 3.25.0-next.1

package/lib/utils/__tests__/openapi.test.js

@@ -1,1378 +0,0 @@
-import { detectType, getOperationName, getStatusCodeType, humanizeConstraints, isOperationName, isPrimitiveType, mergeParams, normalizeServers, pluralizeType, serializeParameterValue, sortByRequired, humanizeNumberRange, getDefinitionName, serializeQueryParameter, isSequentialMediaType, langFromMime, getContent, } from '../index.js';
-import { getField } from '../../models/index.js';
-import { OpenAPIParser } from '../../services/OpenAPIParser.js';
-import { getContentWithLegacyExamples } from '../openapi.js';
-import { normalizeOptions } from '../../services/index.js';
-describe('Utils', () => {
-    describe('openapi getStatusCode', () => {
-        it('Should return info for status codes within 100 and 200', () => {
-            expect(getStatusCodeType(100)).toEqual('info');
-            expect(getStatusCodeType(150)).toEqual('info');
-            expect(getStatusCodeType(199)).toEqual('info');
-        });
-        it('Should return success for status codes within 200 and 300', () => {
-            expect(getStatusCodeType(200)).toEqual('success');
-            expect(getStatusCodeType(250)).toEqual('success');
-            expect(getStatusCodeType(299)).toEqual('success');
-        });
-        it('Should return redirect for status codes within 300 and 400', () => {
-            expect(getStatusCodeType(300)).toEqual('redirect');
-            expect(getStatusCodeType(399)).toEqual('redirect');
-        });
-        it('Should return error for status codes above 400', () => {
-            expect(getStatusCodeType(400)).toEqual('error');
-            expect(getStatusCodeType(500)).toEqual('error');
-            expect(getStatusCodeType(599)).toEqual('error');
-        });
-        it('Should throw for incorrect HTTP code', () => {
-            expect(() => getStatusCodeType(99)).toThrow('invalid HTTP code');
-            expect(() => getStatusCodeType(600)).toThrow('invalid HTTP code');
-        });
-    });
-    describe('openapi isOperationName', () => {
-        it('Should return `true` for correct HTTP verbs', () => {
-            expect(isOperationName('get')).toEqual(true);
-            expect(isOperationName('post')).toEqual(true);
-            expect(isOperationName('put')).toEqual(true);
-            expect(isOperationName('head')).toEqual(true);
-            expect(isOperationName('patch')).toEqual(true);
-            expect(isOperationName('delete')).toEqual(true);
-            expect(isOperationName('options')).toEqual(true);
-            expect(isOperationName('x-query')).toEqual(true);
-            expect(isOperationName('query')).toEqual(true);
-        });
-        it('Should return `false` for incorrect HTTP verbs', () => {
-            expect(isOperationName('properties')).toEqual(false);
-            expect(isOperationName('x-name')).toEqual(false);
-            expect(isOperationName('fix')).toEqual(false);
-        });
-    });
-    describe('openapi serializeQueryParameter', () => {
-        it('should join elements of the array with a "&"', () => {
-            expect(serializeQueryParameter('arrayOfObjects', 'form', true, [
-                { sub1: 'foo', enumTest: 'available' },
-                { sub1: 'test', enumTest: 'sold' },
-            ])).toEqual('arrayOfObjects=sub1%3Dfoo%26enumTest%3Davailable&arrayOfObjects=sub1%3Dtest%26enumTest%3Dsold');
-        });
-    });
-    let sixtyLetterStr = '';
-    for (let i = 0; i < 60; i++) {
-        sixtyLetterStr += 'a';
-    }
-    describe('openapi getOperationName', () => {
-        it('Should return operation self summary if exists', () => {
-            const operation = {
-                summary: 'test',
-                operationId: 'fail',
-                description: 'fail',
-            };
-            expect(getOperationName(operation)).toEqual('test');
-        });
-        it('Should return operationId if no summary', () => {
-            const operation = {
-                operationId: 'test',
-                description: 'fail',
-            };
-            expect(getOperationName(operation)).toEqual('test');
-        });
-        it('Should return description if no summary and operationId', () => {
-            const operation = {
-                description: 'test',
-            };
-            expect(getOperationName(operation)).toEqual('test');
-        });
-        it('Should return only first 50 description letter if no summary and operationId', () => {
-            const operation = {
-                description: sixtyLetterStr,
-            };
-            expect(sixtyLetterStr.length).toBeGreaterThan(50);
-            expect(getOperationName(operation).length).toBe(50);
-        });
-        it('Should return pathName if no summary, operationId, description', () => {
-            const operation = {
-                pathName: '/sandbox/test',
-            };
-            expect(getOperationName(operation)).toBe('/sandbox/test');
-        });
-        it('Should return <no summary> if no info', () => {
-            const operation = {
-                description: undefined,
-            };
-            expect(getOperationName(operation)).toBe('<no summary>');
-        });
-    });
-    describe('openapi detectType', () => {
-        it('Should detect object.type if it is specified', () => {
-            expect(detectType({
-                type: 'object',
-            })).toBe('object');
-            expect(detectType({
-                type: 'object',
-                minimum: 1,
-            })).toBe('object');
-        });
-        const tests = {
-            number: ['multipleOf', 'maximum', 'exclusiveMaximum', 'minimum', 'exclusiveMinimum'],
-            string: ['pattern', 'minLength', 'maxLength'],
-            array: ['items', 'maxItems', 'minItems', 'uniqueItems'],
-            object: [
-                'maxProperties',
-                'minProperties',
-                'required',
-                'additionalProperties',
-                'unevaluatedProperties',
-                'properties',
-            ],
-        };
-        Object.keys(tests).forEach((name) => {
-            it(`Should detect ${name} if ${name} properties are present`, () => {
-                tests[name].forEach((propName) => {
-                    expect(detectType({
-                        [propName]: 0,
-                    })).toBe(name);
-                });
-            });
-        });
-    });
-    describe('openapi isPrimitiveType', () => {
-        it('Should return true for empty object', () => {
-            const schema = {
-                type: 'object',
-            };
-            expect(isPrimitiveType(schema)).toEqual(true);
-        });
-        it('Should return false for object with props', () => {
-            const schema = {
-                type: 'object',
-                properties: {
-                    a: {
-                        type: 'string',
-                    },
-                },
-            };
-            expect(isPrimitiveType(schema)).toEqual(false);
-        });
-        it("should return true for array contains object and schema hasn't properties", () => {
-            const schema = {
-                type: ['object', 'string'],
-            };
-            expect(isPrimitiveType(schema)).toEqual(true);
-        });
-        it('should return false for array contains object and schema has properties', () => {
-            const schema = {
-                type: ['object', 'string'],
-                properties: {
-                    a: {
-                        type: 'string',
-                    },
-                },
-            };
-            expect(isPrimitiveType(schema)).toEqual(false);
-        });
-        it('should return false for array contains array type and schema has items', () => {
-            const schema = {
-                type: ['array'],
-                items: {
-                    type: 'object',
-                    additionalProperties: true,
-                },
-            };
-            expect(isPrimitiveType(schema)).toEqual(false);
-        });
-        it('should return false for array contains array type and schema has items(unevaluatedProperties)', () => {
-            const schema = {
-                type: ['array'],
-                items: {
-                    type: 'object',
-                    unevaluatedProperties: true,
-                },
-            };
-            expect(isPrimitiveType(schema)).toEqual(false);
-        });
-        it('should return false for array contains object and array types and schema has items', () => {
-            const schema = {
-                type: ['array', 'object'],
-                items: {
-                    type: 'object',
-                    additionalProperties: true,
-                },
-            };
-            expect(isPrimitiveType(schema)).toEqual(false);
-        });
-        it('should return false for array contains object and array types and schema has properties', () => {
-            const schema = {
-                type: ['array', 'object'],
-                properties: {
-                    a: {
-                        type: 'string',
-                    },
-                },
-            };
-            expect(isPrimitiveType(schema)).toEqual(false);
-        });
-        it('should return true for array contains array of strings', () => {
-            const schema = {
-                type: 'array',
-                items: {
-                    type: 'array',
-                    items: {
-                        type: 'string',
-                    },
-                },
-            };
-            expect(isPrimitiveType(schema)).toEqual(true);
-        });
-        it('Should return true for array of string which include the null value', () => {
-            const schema = {
-                type: ['object', 'string', 'null'],
-            };
-            expect(isPrimitiveType(schema)).toEqual(true);
-        });
-        it('Should return false for array with non-empty objects', () => {
-            const schema = {
-                type: 'array',
-                items: {
-                    type: 'object',
-                    properties: {
-                        a: {
-                            type: 'string',
-                        },
-                    },
-                },
-            };
-            expect(isPrimitiveType(schema)).toEqual(false);
-        });
-        it('should return false for object with additionalProperties', () => {
-            const schema = {
-                type: 'array',
-                items: {
-                    type: 'object',
-                    additionalProperties: true,
-                },
-            };
-            expect(isPrimitiveType(schema)).toEqual(false);
-        });
-        it('should return false for object with unevaluatedProperties', () => {
-            const schema = {
-                type: 'array',
-                items: {
-                    type: 'object',
-                    unevaluatedProperties: true,
-                },
-            };
-            expect(isPrimitiveType(schema)).toEqual(false);
-        });
-        it('should work with externally provided type', () => {
-            const schema = {
-                properties: {
-                    a: {
-                        type: 'string',
-                    },
-                },
-            };
-            expect(isPrimitiveType(schema, 'object')).toEqual(false);
-        });
-    });
-    describe('openapi mergeParams', () => {
-        it('Should deduplicate params with same "name" and "in"', () => {
-            const pathParams = [
-                {
-                    name: 'param1',
-                    in: 'path',
-                    description: 'path',
-                },
-                {
-                    name: 'param2',
-                    in: 'path',
-                },
-            ];
-            const operationParams = [
-                {
-                    name: 'param1',
-                    in: 'path',
-                    description: 'oper',
-                },
-                {
-                    name: 'param2',
-                    in: 'query',
-                },
-            ];
-            const parser = new OpenAPIParser({ openapi: '3.0' });
-            const res = mergeParams(parser, pathParams, operationParams, {
-                pathPointer: '',
-                operationPointer: '/post',
-            });
-            expect(res).toHaveLength(3);
-            expect(res[0]).toEqual({
-                paramOrRef: pathParams[1],
-                pointer: '/parameters/1',
-            });
-            expect(res[1]).toEqual({
-                paramOrRef: operationParams[0],
-                pointer: '/post/parameters/0',
-            });
-            expect(res[2]).toEqual({
-                paramOrRef: operationParams[1],
-                pointer: '/post/parameters/1',
-            });
-        });
-    });
-    describe('normalize servers', () => {
-        it('should make url absolute and strip spec name', () => {
-            const res = normalizeServers('http://base.com/spec.yaml', [
-                {
-                    url: '/sandbox/test',
-                },
-            ]);
-            expect(res).toEqual([{ url: 'http://base.com/sandbox/test', description: '' }]);
-        });
-        it('should correctly resolve url with server relative path', () => {
-            const res = normalizeServers('http://base.com/subpath/spec.yaml', [
-                {
-                    url: '/sandbox/test',
-                },
-            ]);
-            expect(res).toEqual([{ url: 'http://base.com/sandbox/test', description: '' }]);
-        });
-        it('should correctly resolve url with relative path', () => {
-            const res = normalizeServers('http://base.com/subpath/spec.yaml', [
-                {
-                    url: 'sandbox/test',
-                },
-            ]);
-            expect(res).toEqual([{ url: 'http://base.com/subpath/sandbox/test', description: '' }]);
-        });
-        it('should prefer server host over spec`s one', () => {
-            const res = normalizeServers('http://base.com/spec.yaml', [
-                {
-                    url: 'https://otherbase.com/sandbox/test',
-                },
-            ]);
-            expect(res).toEqual([{ url: 'https://otherbase.com/sandbox/test', description: '' }]);
-        });
-        it('should strip trailing slash', () => {
-            const res = normalizeServers('', [
-                {
-                    url: 'https://otherbase.com/sandbox/test/',
-                },
-            ]);
-            expect(res).toEqual([{ url: 'https://otherbase.com/sandbox/test', description: '' }]);
-        });
-        it('should remove query string and hash from url', () => {
-            const originalWindow = { ...window };
-            const windowSpy = vi.spyOn(global, 'window', 'get');
-            windowSpy.mockImplementation(() => ({
-                ...originalWindow,
-                location: {
-                    ...originalWindow.location,
-                    href: 'https://base.com/subpath/?param=value#tag',
-                },
-            }));
-            const res = normalizeServers(undefined, [
-                {
-                    url: 'sandbox/test',
-                },
-            ]);
-            expect(res).toEqual([{ url: 'https://base.com/subpath/sandbox/test', description: '' }]);
-            windowSpy.mockRestore();
-        });
-        it('should set correct protocol', () => {
-            const res = normalizeServers('https://base.com', [
-                {
-                    url: '//base.com/sandbox/test',
-                    description: 'test',
-                },
-            ]);
-            expect(res).toEqual([{ url: 'https://base.com/sandbox/test', description: 'test' }]);
-        });
-    });
-    describe('openapi humanizeNumberRange', () => {
-        it('should return `>=` when only minimum value present or exclusiveMinimum = false', () => {
-            const expected = '>= 0';
-            expect(humanizeNumberRange({ minimum: 0 })).toEqual(expected);
-            expect(humanizeNumberRange({ minimum: 0, exclusiveMinimum: false })).toEqual(expected);
-        });
-        it('should return `>` when minimum value present and exclusiveMinimum set to true', () => {
-            expect(humanizeNumberRange({ minimum: 0, exclusiveMinimum: true })).toEqual('> 0');
-        });
-        it('should return `<=` when only maximum value present or exclusiveMinimum = false', () => {
-            const expected = '<= 10';
-            expect(humanizeNumberRange({ maximum: 10 })).toEqual(expected);
-            expect(humanizeNumberRange({ maximum: 10, exclusiveMaximum: false })).toEqual(expected);
-        });
-        it('should return `<` when maximum value present and exclusiveMaximum set to true', () => {
-            expect(humanizeNumberRange({ maximum: 10, exclusiveMaximum: true })).toEqual('< 10');
-        });
-        it('should return correct range for minimum and maximum values and with different exclusive set', () => {
-            expect(humanizeNumberRange({ minimum: 0, maximum: 10 })).toEqual('[ 0 .. 10 ]');
-            expect(humanizeNumberRange({
-                minimum: 0,
-                exclusiveMinimum: true,
-                maximum: 10,
-                exclusiveMaximum: true,
-            })).toEqual('( 0 .. 10 )');
-            expect(humanizeNumberRange({
-                minimum: 0,
-                maximum: 10,
-                exclusiveMaximum: true,
-            })).toEqual('[ 0 .. 10 )');
-            expect(humanizeNumberRange({
-                minimum: 0,
-                exclusiveMinimum: true,
-                maximum: 10,
-            })).toEqual('( 0 .. 10 ]');
-        });
-        it('should return correct range exclusive values only', () => {
-            expect(humanizeNumberRange({ exclusiveMinimum: 0 })).toEqual('> 0');
-            expect(humanizeNumberRange({ exclusiveMaximum: 10 })).toEqual('< 10');
-            expect(humanizeNumberRange({ exclusiveMinimum: 0, exclusiveMaximum: 10 })).toEqual('( 0 .. 10 )');
-        });
-        it('should return correct min value', () => {
-            expect(humanizeNumberRange({ minimum: 5, exclusiveMinimum: 10 })).toEqual('> 5');
-            expect(humanizeNumberRange({ minimum: -5, exclusiveMinimum: -10 })).toEqual('> -10');
-        });
-        it('should return correct max value', () => {
-            expect(humanizeNumberRange({ maximum: 10, exclusiveMaximum: 15 })).toEqual('< 15');
-            expect(humanizeNumberRange({ maximum: -10, exclusiveMaximum: -15 })).toEqual('< -10');
-        });
-        it('should return undefined', () => {
-            expect(humanizeNumberRange({})).toEqual(undefined);
-        });
-    });
-    describe('openapi humanizeConstraints', () => {
-        const itemConstraintSchema = (min, max, multipleOf, uniqueItems) => ({ type: 'array', minItems: min, maxItems: max, multipleOf, uniqueItems });
-        it('should not have a humanized constraint without schema constraints', () => {
-            expect(humanizeConstraints(itemConstraintSchema())).toHaveLength(0);
-        });
-        it('should have a humanized constraint when minItems is set', () => {
-            expect(humanizeConstraints(itemConstraintSchema(2))).toContain('>= 2 items');
-        });
-        it('should have a humanized constraint when maxItems is set', () => {
-            expect(humanizeConstraints(itemConstraintSchema(undefined, 8))).toContain('<= 8 items');
-        });
-        it('should have a humanized constraint when minItems and maxItems are both set', () => {
-            expect(humanizeConstraints(itemConstraintSchema(2, 8))).toContain('[ 2 .. 8 ] items');
-        });
-        it('should have a humanized constraint when minItems and maxItems are the same', () => {
-            expect(humanizeConstraints(itemConstraintSchema(7, 7))).toContain('= 7 items');
-        });
-        it('should have a humanized constraint when justMinItems is set, and it is equal to 1', () => {
-            expect(humanizeConstraints(itemConstraintSchema(1))).toContain('non-empty');
-        });
-        it('should have a humanized constraint when multipleOf is set, and it is in format of /^0\\.0*1$/', () => {
-            expect(humanizeConstraints(itemConstraintSchema(undefined, undefined, 0.01))).toContain('decimal places <= 2');
-        });
-        it('should have a humanized constraint when multipleOf is set, and it is in format other than /^0\\.0*1$/', () => {
-            expect(humanizeConstraints(itemConstraintSchema(undefined, undefined, 0.5))).toContain('multiple of 0.5');
-        });
-        it('should have a humanized constraint when uniqueItems is set', () => {
-            expect(humanizeConstraints(itemConstraintSchema(undefined, undefined, undefined, true))).toContain('unique');
-        });
-    });
-    describe('OpenAPI pluralizeType', () => {
-        it('should pluralize all simple types', () => {
-            expect(pluralizeType('string')).toEqual('strings');
-            expect(pluralizeType('number')).toEqual('numbers');
-            expect(pluralizeType('object')).toEqual('objects');
-            expect(pluralizeType('integer')).toEqual('integers');
-            expect(pluralizeType('boolean')).toEqual('booleans');
-            expect(pluralizeType('array')).toEqual('arrays');
-        });
-        it('should pluralize complex display types', () => {
-            expect(pluralizeType('object (Pet)')).toEqual('objects (Pet)');
-            expect(pluralizeType('string <email>')).toEqual('strings <email>');
-        });
-        it('should pluralize oneOf-ed display types', () => {
-            expect(pluralizeType('object or string')).toEqual('objects or strings');
-            expect(pluralizeType('object (Pet) or number <int64>')).toEqual('objects (Pet) or numbers <int64>');
-        });
-        it('should not pluralize display types that are already pluralized', () => {
-            expect(pluralizeType('strings')).toEqual('strings');
-            expect(pluralizeType('objects (Pet)')).toEqual('objects (Pet)');
-            expect(pluralizeType('strings <email>')).toEqual('strings <email>');
-            expect(pluralizeType('objects or strings')).toEqual('objects or strings');
-            expect(pluralizeType('objects (Pet) or numbers <int64>')).toEqual('objects (Pet) or numbers <int64>');
-        });
-    });
-    describe('openapi serializeParameter', () => {
-        const testCases = [
-            {
-                location: 'path',
-                name: 'id',
-                description: 'path parameters',
-                cases: [
-                    {
-                        value: 5,
-                        description: 'primitive values',
-                        cases: [
-                            { style: 'simple', explode: false, expected: '5' },
-                            { style: 'simple', explode: true, expected: '5' },
-                            { style: 'label', explode: false, expected: '.5' },
-                            { style: 'label', explode: true, expected: '.5' },
-                            { style: 'matrix', explode: false, expected: ';id=5' },
-                            { style: 'matrix', explode: true, expected: ';id=5' },
-                        ],
-                    },
-                    {
-                        value: [3, 4, 5],
-                        description: 'array values',
-                        cases: [
-                            { style: 'simple', explode: false, expected: '3,4,5' },
-                            { style: 'simple', explode: true, expected: '3,4,5' },
-                            { style: 'label', explode: false, expected: '.3,4,5' },
-                            { style: 'label', explode: true, expected: '.3.4.5' },
-                            { style: 'matrix', explode: false, expected: ';id=3,4,5' },
-                            { style: 'matrix', explode: true, expected: ';id=3;id=4;id=5' },
-                        ],
-                    },
-                    {
-                        value: { role: 'admin', firstName: 'Alex' },
-                        description: 'object values',
-                        cases: [
-                            { style: 'simple', explode: false, expected: 'role,admin,firstName,Alex' },
-                            { style: 'simple', explode: true, expected: 'role=admin,firstName=Alex' },
-                            { style: 'label', explode: false, expected: '.role,admin,firstName,Alex' },
-                            { style: 'label', explode: true, expected: '.role=admin.firstName=Alex' },
-                            { style: 'matrix', explode: false, expected: ';id=role,admin,firstName,Alex' },
-                            { style: 'matrix', explode: true, expected: ';role=admin;firstName=Alex' },
-                        ],
-                    },
-                ],
-            },
-            {
-                location: 'query',
-                name: 'id',
-                description: 'query parameters',
-                cases: [
-                    {
-                        value: 5,
-                        description: 'primitive values',
-                        cases: [
-                            { style: 'form', explode: true, expected: 'id=5' },
-                            { style: 'form', explode: false, expected: 'id=5' },
-                        ],
-                    },
-                    {
-                        value: [3, 4, 5],
-                        description: 'array values',
-                        cases: [
-                            { style: 'form', explode: true, expected: 'id=3&id=4&id=5' },
-                            { style: 'form', explode: false, expected: 'id=3,4,5' },
-                            { style: 'spaceDelimited', explode: true, expected: 'id=3&id=4&id=5' },
-                            { style: 'spaceDelimited', explode: false, expected: '3%204%205' },
-                            { style: 'pipeDelimited', explode: true, expected: 'id=3&id=4&id=5' },
-                            { style: 'pipeDelimited', explode: false, expected: '3|4|5' },
-                        ],
-                    },
-                    {
-                        value: { role: 'admin', firstName: 'Alex' },
-                        description: 'object values',
-                        cases: [
-                            { style: 'form', explode: true, expected: 'role=admin&firstName=Alex' },
-                            { style: 'form', explode: false, expected: 'id=role,admin,firstName,Alex' },
-                            { style: 'deepObject', explode: true, expected: 'id[role]=admin&id[firstName]=Alex' },
-                            {
-                                style: 'spaceDelimited',
-                                explode: false,
-                                expected: 'role%20admin%20firstName%20Alex',
-                            },
-                            { style: 'pipeDelimited', explode: false, expected: 'role|admin|firstName|Alex' },
-                        ],
-                    },
-                ],
-            },
-            {
-                location: 'cookie',
-                name: 'id',
-                description: 'cookie parameters',
-                cases: [
-                    {
-                        value: 5,
-                        description: 'primitive values',
-                        cases: [
-                            { style: 'form', explode: true, expected: 'id=5' },
-                            { style: 'form', explode: false, expected: 'id=5' },
-                        ],
-                    },
-                    {
-                        value: [3, 4, 5],
-                        description: 'array values',
-                        cases: [
-                            { style: 'form', explode: true, expected: 'id=3&id=4&id=5' },
-                            { style: 'form', explode: false, expected: 'id=3,4,5' },
-                        ],
-                    },
-                    {
-                        value: { role: 'admin', firstName: 'Alex' },
-                        description: 'object values',
-                        cases: [
-                            { style: 'form', explode: true, expected: 'role=admin&firstName=Alex' },
-                            { style: 'form', explode: false, expected: 'id=role,admin,firstName,Alex' },
-                        ],
-                    },
-                ],
-            },
-            {
-                location: 'header',
-                name: 'x-id',
-                description: 'header parameters',
-                cases: [
-                    {
-                        value: 5,
-                        description: 'primitive values',
-                        cases: [
-                            { style: 'simple', explode: false, expected: '5' },
-                            { style: 'simple', explode: true, expected: '5' },
-                        ],
-                    },
-                    {
-                        value: [3, 4, 5],
-                        description: 'array values',
-                        cases: [
-                            { style: 'simple', explode: false, expected: '3,4,5' },
-                            { style: 'simple', explode: true, expected: '3,4,5' },
-                        ],
-                    },
-                    {
-                        value: { role: 'admin', firstName: 'Alex' },
-                        description: 'object values',
-                        cases: [
-                            { style: 'simple', explode: false, expected: 'role,admin,firstName,Alex' },
-                            { style: 'simple', explode: true, expected: 'role=admin,firstName=Alex' },
-                        ],
-                    },
-                ],
-            },
-        ];
-        testCases.forEach((locationTestGroup) => {
-            describe(`${locationTestGroup.description}`, () => {
-                locationTestGroup.cases.forEach((valueTypeTestGroup) => {
-                    describe(`${valueTypeTestGroup.description}`, () => {
-                        valueTypeTestGroup.cases.forEach((testCase) => {
-                            it(`should serialize correctly when style is ${testCase.style} and explode is ${testCase.explode}`, () => {
-                                const parameter = {
-                                    name: locationTestGroup.name,
-                                    in: locationTestGroup.location,
-                                    style: testCase.style,
-                                    explode: testCase.explode,
-                                };
-                                const serialized = serializeParameterValue(parameter, valueTypeTestGroup.value);
-                                expect(serialized).toEqual(testCase.expected);
-                            });
-                        });
-                    });
-                });
-            });
-        });
-        describe('advanced serialization', () => {
-            it('should serialize correctly query parameter with content with application/json', () => {
-                const parameter = {
-                    name: 'id',
-                    in: 'query',
-                    content: {
-                        'application/json': {
-                            schema: {
-                                type: 'string',
-                            },
-                        },
-                    },
-                };
-                const parser = new OpenAPIParser({ openapi: '3.0' });
-                const opts = normalizeOptions({});
-                const field = getField(parser, parameter, '', opts, { operation: {} });
-                expect(serializeParameterValue(field, { name: 'test', age: 23 })).toEqual('id={"name":"test","age":23}');
-            });
-            it('should serialize correctly header parameter with content with application/json', () => {
-                const parameter = {
-                    name: 'x-header',
-                    in: 'header',
-                    content: {
-                        'application/json': {
-                            schema: {
-                                type: 'string',
-                            },
-                        },
-                    },
-                };
-                const parser = new OpenAPIParser({ openapi: '3.0' });
-                const opts = normalizeOptions({});
-                const field = getField(parser, parameter, '', opts, { operation: {} });
-                expect(serializeParameterValue(field, { name: 'test', age: 23 })).toEqual('{"name":"test","age":23}');
-            });
-        });
-        describe('querystring parameters', () => {
-            it('should serialize complex nested object with arrays using form-urlencoded querystring', () => {
-                const parameter = {
-                    name: 'filter',
-                    in: 'querystring',
-                    content: {
-                        'application/x-www-form-urlencoded': {
-                            schema: {
-                                type: 'object',
-                                properties: {
-                                    name: { type: 'string' },
-                                    age: { type: 'number' },
-                                    tags: {
-                                        type: 'array',
-                                        items: { type: 'string' },
-                                    },
-                                    address: {
-                                        type: 'object',
-                                        properties: {
-                                            city: { type: 'string' },
-                                            zip: { type: 'string' },
-                                        },
-                                    },
-                                    preferences: {
-                                        type: 'object',
-                                        properties: {
-                                            notifications: { type: 'boolean' },
-                                            categories: {
-                                                type: 'array',
-                                                items: { type: 'string' },
-                                            },
-                                        },
-                                    },
-                                },
-                            },
-                        },
-                    },
-                };
-                const parser = new OpenAPIParser({ openapi: '3.2' });
-                const opts = normalizeOptions({});
-                const field = getField(parser, parameter, '', opts, { operation: {} });
-                const value = {
-                    name: 'test',
-                    age: 23,
-                    tags: ['admin', 'editor'],
-                    address: {
-                        city: 'Test',
-                        zip: '80-001',
-                    },
-                    preferences: {
-                        notifications: true,
-                        categories: ['tech', 'science'],
-                    },
-                };
-                expect(serializeParameterValue(field, value)).toEqual('name=test&age=23&tags=admin&tags=editor&address%5Bcity%5D=Test&address%5Bzip%5D=80-001&preferences%5Bnotifications%5D=true&preferences%5Bcategories%5D=tech&preferences%5Bcategories%5D=science');
-            });
-            it('should serialize querystring parameter with json content and primitive value', () => {
-                const parameter = {
-                    name: 'filter',
-                    in: 'querystring',
-                    content: {
-                        'application/json': {
-                            schema: {
-                                type: 'string',
-                            },
-                        },
-                    },
-                };
-                const parser = new OpenAPIParser({ openapi: '3.2' });
-                const opts = normalizeOptions({});
-                const field = getField(parser, parameter, '', opts, { operation: {} });
-                expect(serializeParameterValue(field, 'test-value')).toEqual('filter="test-value"');
-            });
-            it('should serialize querystring parameter with schema and style (no content)', () => {
-                const parameter = {
-                    name: 'filter',
-                    in: 'querystring',
-                    style: 'form',
-                    explode: true,
-                    schema: {
-                        type: 'object',
-                        properties: {
-                            name: { type: 'string' },
-                            age: { type: 'number' },
-                        },
-                    },
-                };
-                const parser = new OpenAPIParser({ openapi: '3.2' });
-                const opts = normalizeOptions({});
-                const field = getField(parser, parameter, '', opts, { operation: {} });
-                expect(serializeParameterValue(field, { name: 'test', age: 23 })).toEqual('name=test&age=23');
-            });
-        });
-    });
-    describe('OpenAPI sortByRequired', () => {
-        it('should equal to the old data when all items have no required props', () => {
-            const fields = [
-                {
-                    name: 'loginName',
-                    required: false,
-                },
-                {
-                    name: 'displayName',
-                    required: false,
-                },
-                {
-                    name: 'email',
-                    required: false,
-                },
-                {
-                    name: 'space',
-                    required: false,
-                },
-                {
-                    name: 'type',
-                    required: false,
-                },
-                {
-                    name: 'depIds',
-                    required: false,
-                },
-                {
-                    name: 'depNames',
-                    required: false,
-                },
-                {
-                    name: 'password',
-                    required: false,
-                },
-                {
-                    name: 'pwdControl',
-                    required: false,
-                },
-                {
-                    name: 'csfLevel',
-                    required: false,
-                },
-                {
-                    name: 'priority',
-                    required: false,
-                },
-                {
-                    name: 'siteId',
-                    required: false,
-                },
-            ];
-            expect(sortByRequired(fields)).toEqual(fields);
-        });
-        it('other item should be the same order when some of items are required', () => {
-            const fields = [
-                {
-                    name: 'loginName',
-                    required: true,
-                },
-                {
-                    name: 'displayName',
-                    required: false,
-                },
-                {
-                    name: 'email',
-                    required: true,
-                },
-                {
-                    name: 'space',
-                    required: false,
-                },
-                {
-                    name: 'type',
-                    required: false,
-                },
-                {
-                    name: 'depIds',
-                    required: false,
-                },
-                {
-                    name: 'depNames',
-                    required: false,
-                },
-                {
-                    name: 'password',
-                    required: false,
-                },
-                {
-                    name: 'pwdControl',
-                    required: false,
-                },
-                {
-                    name: 'csfLevel',
-                    required: false,
-                },
-                {
-                    name: 'priority',
-                    required: false,
-                },
-                {
-                    name: 'siteId',
-                    required: false,
-                },
-            ];
-            const sortedFields = [
-                {
-                    name: 'loginName',
-                    required: true,
-                },
-                {
-                    name: 'email',
-                    required: true,
-                },
-                {
-                    name: 'displayName',
-                    required: false,
-                },
-                {
-                    name: 'space',
-                    required: false,
-                },
-                {
-                    name: 'type',
-                    required: false,
-                },
-                {
-                    name: 'depIds',
-                    required: false,
-                },
-                {
-                    name: 'depNames',
-                    required: false,
-                },
-                {
-                    name: 'password',
-                    required: false,
-                },
-                {
-                    name: 'pwdControl',
-                    required: false,
-                },
-                {
-                    name: 'csfLevel',
-                    required: false,
-                },
-                {
-                    name: 'priority',
-                    required: false,
-                },
-                {
-                    name: 'siteId',
-                    required: false,
-                },
-            ];
-            expect(sortByRequired(fields)).toEqual(sortedFields);
-        });
-        it('should the order of required items is as same as the order parameter', () => {
-            const fields = [
-                {
-                    name: 'loginName',
-                    required: true,
-                },
-                {
-                    name: 'displayName',
-                    required: true,
-                },
-                {
-                    name: 'email',
-                    required: true,
-                },
-                {
-                    name: 'space',
-                    required: false,
-                },
-                {
-                    name: 'type',
-                    required: false,
-                },
-                {
-                    name: 'depIds',
-                    required: false,
-                },
-                {
-                    name: 'depNames',
-                    required: false,
-                },
-                {
-                    name: 'password',
-                    required: false,
-                },
-                {
-                    name: 'pwdControl',
-                    required: false,
-                },
-                {
-                    name: 'csfLevel',
-                    required: false,
-                },
-                {
-                    name: 'priority',
-                    required: false,
-                },
-                {
-                    name: 'siteId',
-                    required: false,
-                },
-            ];
-            expect(sortByRequired(fields, ['siteId', 'displayName', 'loginName', 'email'])).toEqual([
-                {
-                    name: 'displayName',
-                    required: true,
-                },
-                {
-                    name: 'loginName',
-                    required: true,
-                },
-                {
-                    name: 'email',
-                    required: true,
-                },
-                {
-                    name: 'space',
-                    required: false,
-                },
-                {
-                    name: 'type',
-                    required: false,
-                },
-                {
-                    name: 'depIds',
-                    required: false,
-                },
-                {
-                    name: 'depNames',
-                    required: false,
-                },
-                {
-                    name: 'password',
-                    required: false,
-                },
-                {
-                    name: 'pwdControl',
-                    required: false,
-                },
-                {
-                    name: 'csfLevel',
-                    required: false,
-                },
-                {
-                    name: 'priority',
-                    required: false,
-                },
-                {
-                    name: 'siteId',
-                    required: false,
-                },
-            ]);
-            expect(sortByRequired(fields, ['email', 'displayName'])).toEqual([
-                {
-                    name: 'email',
-                    required: true,
-                },
-                {
-                    name: 'displayName',
-                    required: true,
-                },
-                {
-                    name: 'loginName',
-                    required: true,
-                },
-                {
-                    name: 'space',
-                    required: false,
-                },
-                {
-                    name: 'type',
-                    required: false,
-                },
-                {
-                    name: 'depIds',
-                    required: false,
-                },
-                {
-                    name: 'depNames',
-                    required: false,
-                },
-                {
-                    name: 'password',
-                    required: false,
-                },
-                {
-                    name: 'pwdControl',
-                    required: false,
-                },
-                {
-                    name: 'csfLevel',
-                    required: false,
-                },
-                {
-                    name: 'priority',
-                    required: false,
-                },
-                {
-                    name: 'siteId',
-                    required: false,
-                },
-            ]);
-            expect(sortByRequired(fields, ['displayName'])).toEqual([
-                {
-                    name: 'displayName',
-                    required: true,
-                },
-                {
-                    name: 'loginName',
-                    required: true,
-                },
-                {
-                    name: 'email',
-                    required: true,
-                },
-                {
-                    name: 'space',
-                    required: false,
-                },
-                {
-                    name: 'type',
-                    required: false,
-                },
-                {
-                    name: 'depIds',
-                    required: false,
-                },
-                {
-                    name: 'depNames',
-                    required: false,
-                },
-                {
-                    name: 'password',
-                    required: false,
-                },
-                {
-                    name: 'pwdControl',
-                    required: false,
-                },
-                {
-                    name: 'csfLevel',
-                    required: false,
-                },
-                {
-                    name: 'priority',
-                    required: false,
-                },
-                {
-                    name: 'siteId',
-                    required: false,
-                },
-            ]);
-        });
-    });
-    describe('OpenAPI getContentWithLegacyExamles', () => {
-        it('should return undefined if no x-examples/x-example and no content', () => {
-            expect(getContentWithLegacyExamples({})).toBeUndefined();
-        });
-        it('should return unmodified object if no x-examples or x-example', () => {
-            const info = {
-                content: {
-                    'application/json': {},
-                },
-            };
-            const content = getContentWithLegacyExamples(info);
-            expect(content).toStrictEqual(info.content);
-        });
-        it('should create a new content object if no content and x-examples', () => {
-            const info = {
-                'x-examples': {
-                    'application/json': {
-                        name: {
-                            value: 'test',
-                        },
-                    },
-                },
-            };
-            const content = getContentWithLegacyExamples(info);
-            expect(content).toEqual({
-                'application/json': {
-                    examples: {
-                        name: {
-                            value: 'test',
-                        },
-                    },
-                },
-            });
-        });
-        it('should create a new content object if no content and x-example', () => {
-            const info = {
-                'x-example': {
-                    'application/json': 'test',
-                },
-            };
-            const content = getContentWithLegacyExamples(info);
-            expect(content).toEqual({
-                'application/json': { example: 'test' },
-            });
-        });
-        it('should return copy of content with injected x-example', () => {
-            const info = {
-                'x-example': {
-                    'application/json': 'test',
-                },
-                content: {
-                    'application/json': {
-                        schema: { type: 'string' },
-                    },
-                    'text/plain': { schema: { type: 'string' } },
-                },
-            };
-            const content = getContentWithLegacyExamples(info);
-            expect(content).toEqual({
-                'application/json': { schema: { type: 'string' }, example: 'test' },
-                'text/plain': { schema: { type: 'string' } },
-            });
-            expect(content).not.toStrictEqual(info.content);
-            expect(content['application/json']).not.toStrictEqual(info.content['application/json']);
-            expect(content['text/plain']).toStrictEqual(info.content['text/plain']);
-        });
-        it('should prefer x-examples over x-example', () => {
-            const info = {
-                'x-example': {
-                    'application/json': 'test',
-                },
-                'x-examples': {
-                    'application/json': { name: { value: 'test' } },
-                },
-                content: {
-                    'application/json': {
-                        schema: { type: 'string' },
-                    },
-                    'text/plain': { schema: { type: 'string' } },
-                },
-            };
-            const content = getContentWithLegacyExamples(info);
-            expect(content).toEqual({
-                'application/json': { schema: { type: 'string' }, examples: { name: { value: 'test' } } },
-                'text/plain': { schema: { type: 'string' } },
-            });
-            expect(content).not.toStrictEqual(info.content);
-            expect(content['application/json']).not.toStrictEqual(info.content['application/json']);
-            expect(content['text/plain']).toStrictEqual(info.content['text/plain']);
-        });
-    });
-    describe('getDefinitionName', () => {
-        test('should return the name if pointer match regex', () => {
-            expect(getDefinitionName('#/components/schemas/Call')).toEqual('Call');
-        });
-        test("should return the `undefined` if pointer not match regex or it's absent", () => {
-            expect(getDefinitionName('#/test/path/Call')).toBeUndefined();
-            expect(getDefinitionName()).toBeUndefined();
-        });
-    });
-    describe('isSequentialMediaType', () => {
-        it('should return true for streaming media types', () => {
-            expect(isSequentialMediaType('application/jsonl')).toBe(true);
-            expect(isSequentialMediaType('application/x-ndjson')).toBe(true);
-            expect(isSequentialMediaType('application/json-seq')).toBe(true);
-            expect(isSequentialMediaType('text/event-stream')).toBe(true);
-            expect(isSequentialMediaType('multipart/mixed')).toBe(true);
-        });
-        it('should return false for non-streaming media types', () => {
-            expect(isSequentialMediaType('application/json')).toBe(false);
-            expect(isSequentialMediaType('text/plain')).toBe(false);
-            expect(isSequentialMediaType('application/xml')).toBe(false);
-            expect(isSequentialMediaType('application/octet-stream')).toBe(false);
-        });
-    });
-    describe('langFromMime', () => {
-        it('should return correct language for streaming media types', () => {
-            expect(langFromMime('application/jsonl')).toBe('jsonl');
-            expect(langFromMime('text/event-stream')).toBe('yaml');
-            expect(langFromMime('multipart/mixed')).toBe('multipart-mixed');
-        });
-        it('should return correct language for other media types', () => {
-            expect(langFromMime('application/xml')).toBe('xml');
-            expect(langFromMime('application/json')).toBe('json');
-            expect(langFromMime('text/plain')).toBe('clike');
-        });
-    });
-    describe('OpenAPI 3.2 components/mediaTypes', () => {
-        it('should dereference $ref in content to components/mediaTypes', () => {
-            const definition = {
-                openapi: '3.2.0',
-                info: { title: 'Test', version: '1.0.0' },
-                paths: {},
-                components: {
-                    mediaTypes: {
-                        PatchResponse: {
-                            'application/json': {
-                                schema: { type: 'object', properties: { id: { type: 'string' } } },
-                                examples: {
-                                    default_example: { value: { id: '123' } },
-                                },
-                            },
-                        },
-                    },
-                },
-            };
-            const parser = new OpenAPIParser(definition, undefined, normalizeOptions({}));
-            const info = {
-                content: {
-                    $ref: '#/components/mediaTypes/PatchResponse',
-                },
-            };
-            const content = getContent(parser, info);
-            expect(content).toEqual({
-                'application/json': {
-                    schema: { type: 'object', properties: { id: { type: 'string' } } },
-                    examples: {
-                        default_example: { value: { id: '123' } },
-                    },
-                },
-            });
-        });
-        it('should return $ref unchanged if content is not a ref', () => {
-            const definition = {
-                openapi: '3.2.0',
-                info: { title: 'Test', version: '1.0.0' },
-                paths: {},
-            };
-            const parser = new OpenAPIParser(definition, undefined, normalizeOptions({}));
-            const info = {
-                content: {
-                    'application/json': {
-                        schema: { type: 'string' },
-                    },
-                },
-            };
-            const content = getContent(parser, info);
-            expect(content).toEqual({
-                'application/json': {
-                    schema: { type: 'string' },
-                },
-            });
-        });
-        it('should handle $ref in content with x-examples', () => {
-            const definition = {
-                openapi: '3.2.0',
-                info: { title: 'Test', version: '1.0.0' },
-                paths: {},
-                components: {
-                    mediaTypes: {
-                        PatchResponse: {
-                            'application/json': {
-                                schema: { type: 'object' },
-                            },
-                        },
-                    },
-                },
-            };
-            const parser = new OpenAPIParser(definition, undefined, normalizeOptions({}));
-            const info = {
-                content: {
-                    $ref: '#/components/mediaTypes/PatchResponse',
-                },
-                'x-examples': {
-                    'application/json': {
-                        test: { value: { id: 'test' } },
-                    },
-                },
-            };
-            const content = getContent(parser, info);
-            expect(content).toEqual({
-                'application/json': {
-                    schema: { type: 'object' },
-                    examples: {
-                        test: { value: { id: 'test' } },
-                    },
-                },
-            });
-        });
-    });
-});
-//# sourceMappingURL=openapi.test.js.map