@redocly/openapi-docs 3.24.0-next.9 → 3.24.1

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

@@ -0,0 +1,1378 @@
+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