@redocly/openapi-docs 3.24.1 → 3.24.2

package/lib/jotai/__tests__/app.test.js

@@ -1,53 +0,0 @@
-import { act, renderHook } from '@testing-library/react';
-import { useAtomValue, useSetAtom } from 'jotai';
-import { 
-// @community-ignore
-environmentAtom, 
-// @community-ignore-end
-appStore, appStoreOverrideAtom, } from '../app.js';
-describe('jotai atoms', () => {
-    describe('environmentAtom', () => {
-        test('should return default values with empty state', () => {
-            const { result: { current: [env, envName], }, } = renderHook(() => useAtomValue(environmentAtom));
-            expect(envName).toEqual('');
-            expect(env).toEqual({});
-        });
-        test('should return first environment if non-existing is selected', () => {
-            const { result: { current: setApp }, } = renderHook(() => useSetAtom(appStore));
-            act(() => {
-                setApp({
-                    environments: {
-                        Default: { foo: 'bar', baz: 'qux' },
-                    },
-                    environment: 'non-existing',
-                });
-            });
-            const { result: { current: [env, envName], }, } = renderHook(() => useAtomValue(environmentAtom));
-            expect(envName).toEqual('Default');
-            expect(env).toEqual({ foo: 'bar', baz: 'qux' });
-        });
-        test('should work with override data', () => {
-            const { result: { current: setApp }, } = renderHook(() => useSetAtom(appStore));
-            const { result: { current: setOverride }, } = renderHook(() => useSetAtom(appStoreOverrideAtom));
-            act(() => {
-                setApp({
-                    environments: {
-                        Mock: {},
-                        Default: { foo: 'bar', baz: 'qux' },
-                    },
-                    environment: 'non-existing',
-                });
-                setOverride({
-                    environments: {
-                        Default: { foo: '123', secret: 'password' },
-                    },
-                    environment: 'Default',
-                });
-            });
-            const { result: { current: [env, envName], }, } = renderHook(() => useAtomValue(environmentAtom));
-            expect(envName).toEqual('Default');
-            expect(env).toEqual({ foo: '123', baz: 'qux', secret: 'password' });
-        });
-    });
-});
-//# sourceMappingURL=app.test.js.map

package/lib/models/__tests__/Callback.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/models/__tests__/Callback.test.js

@@ -1,15 +0,0 @@
-import { getCallback } from '../callback.js';
-import { normalizeOptions, OpenAPIParser } from '../../services/index.js';
-import spec from './fixtures/callback.json';
-const opts = normalizeOptions({});
-describe('Models', () => {
-    describe('CallbackModel', () => {
-        const parser = new OpenAPIParser(spec, undefined, opts);
-        test('basic callback details', () => {
-            const callback = getCallback(parser, 'Test.Callback', { $ref: '#/components/callbacks/Test' }, '', opts, '');
-            expect(callback.name).toEqual('Test.Callback');
-            expect(callback.operations.length).toEqual(0);
-        });
-    });
-});
-//# sourceMappingURL=Callback.test.js.map

package/lib/models/__tests__/FieldModel.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/models/__tests__/FieldModel.test.js

@@ -1,117 +0,0 @@
-import { getField } from '../field.js';
-import { normalizeOptions, OpenAPIParser } from '../../services/index.js';
-import spec from './fixtures/fields.json';
-const opts = normalizeOptions({});
-const deps = { operation: { pointer: 'testFieldModel' } };
-describe('Models', () => {
-    describe('FieldModel', () => {
-        const parser = new OpenAPIParser(spec, undefined, opts);
-        test('basic field details', () => {
-            const field = getField(parser, {
-                $ref: '#/components/parameters/testParam',
-            }, '#/components/parameters/testParam', opts, deps);
-            expect(field.name).toEqual('test_name');
-            expect(field.in).toEqual('path');
-            expect(field.required).toEqual(false);
-            expect(field.schema.type).toEqual('string');
-        });
-        test('field details relevant for parameter serialization', () => {
-            const field = getField(parser, {
-                $ref: '#/components/parameters/serializationParam',
-            }, '#/components/parameters/serializationParam', opts, deps);
-            expect(field.name).toEqual('serialization_test_name');
-            expect(field.in).toEqual('query');
-            expect(field.schema.type).toEqual('array');
-            expect(field.style).toEqual('form');
-            expect(field.explode).toEqual(true);
-        });
-        test('field details relevant for default path param serialization', () => {
-            const field = getField(parser, {
-                $ref: '#/components/parameters/pathParamWithNoStyle',
-            }, '#/components/parameters/pathParamWithNoStyle', opts, deps);
-            expect(field.name).toEqual('serialization_test_name');
-            expect(field.in).toEqual('path');
-            expect(field.schema.type).toEqual('array');
-            expect(field.style).toEqual('simple');
-            expect(field.explode).toEqual(false);
-        });
-        test('field details relevant for default query parameter serialization', () => {
-            const field = getField(parser, {
-                $ref: '#/components/parameters/queryParamWithNoStyle',
-            }, '#/components/parameters/queryParamWithNoStyle', opts, deps);
-            expect(field.name).toEqual('serialization_test_name');
-            expect(field.in).toEqual('query');
-            expect(field.schema.type).toEqual('array');
-            expect(field.style).toEqual('form');
-            expect(field.explode).toEqual(true);
-        });
-        test('field details relevant for default cookie parameter serialization', () => {
-            const field = getField(parser, {
-                $ref: '#/components/parameters/queryParamWithNoStyle',
-            }, '#/components/parameters/queryParamWithNoStyle', opts, deps);
-            expect(field.name).toEqual('serialization_test_name');
-            expect(field.in).toEqual('query');
-            expect(field.schema.type).toEqual('array');
-            expect(field.style).toEqual('form');
-            expect(field.explode).toEqual(true);
-        });
-        test('field name should populated from name even if $ref (headers)', () => {
-            const field = getField(parser, {
-                $ref: '#/components/headers/testHeader',
-                name: 'Test-Header',
-            }, '#/components/headers/testHeader', opts, deps);
-            expect(field.name).toEqual('Test-Header');
-        });
-        test('param example should be override the example provided by the schema', () => {
-            const field = getField(parser, {
-                $ref: '#/components/parameters/queryParamExample',
-            }, '', opts, deps);
-            expect(field.example).toEqual({ id: 'main example' });
-            expect(field.schema.example).toEqual({ id: 'main example' });
-            expect(field.schema.schema.example).toEqual({ id: 'main example' });
-        });
-        test('content example should be override the example provided by the schema', () => {
-            const field = getField(parser, {
-                $ref: '#/components/parameters/queryParamWithContentExample',
-            }, '', opts, deps);
-            expect(field.example).toEqual({ id: 'content example' });
-            expect(field.schema.example).toEqual({ id: 'content example' });
-            expect(field.schema.schema.example).toEqual({ id: 'content example' });
-        });
-        test('field includes allowReserved when parameter has allowReserved', () => {
-            const field = getField(parser, {
-                $ref: '#/components/parameters/allowReservedParam',
-            }, '#/components/parameters/allowReservedParam', opts, deps);
-            expect(field.name).toEqual('filter');
-            expect(field.in).toEqual('query');
-            expect(field.allowReserved).toEqual(true);
-        });
-        test('should include badges from x-badges on parameter', () => {
-            const field = getField(parser, { $ref: '#/components/parameters/paramWithBadges' }, '#/components/parameters/paramWithBadges', opts, deps);
-            expect(field.name).toEqual('experimentalFlag');
-            expect(field.badges).toEqual([
-                { name: 'Experimental', position: 'after' },
-                { name: 'Beta', position: 'before', color: 'blue' },
-            ]);
-        });
-        test('should include badges from x-badges on schema property', () => {
-            const field = getField(parser, {
-                name: 'quantityFilled',
-                required: false,
-                schema: {
-                    type: 'integer',
-                    description: 'Filled quantity (experimental).',
-                    'x-badges': [{ name: 'Experimental' }],
-                },
-            }, '#/components/schemas/schemaWithBadgeProperty/properties/quantityFilled', opts, deps);
-            expect(field.name).toEqual('quantityFilled');
-            expect(field.badges).toEqual([{ name: 'Experimental' }]);
-        });
-        test('should include badges from x-badges on schema when parameter schema is a $ref', () => {
-            const field = getField(parser, { $ref: '#/components/parameters/paramWithSchemaRefBadges' }, '#/components/parameters/paramWithSchemaRefBadges', opts, deps);
-            expect(field.name).toEqual('statusFilter');
-            expect(field.badges).toEqual([{ name: 'From ref schema', position: 'after' }]);
-        });
-    });
-});
-//# sourceMappingURL=FieldModel.test.js.map

package/lib/models/__tests__/MediaContent.test.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/models/__tests__/MediaContent.test.js

@@ -1,105 +0,0 @@
-import { getMediaContent } from '../mediaContent.js';
-import { normalizeOptions, OpenAPIParser } from '../../services/index.js';
-import { MediaTypes } from '../../constants.js';
-const options = normalizeOptions({});
-const data = { operation: { pointer: 'testMediaContent' } };
-describe('Models', () => {
-    describe('mediaContent', () => {
-        let parser;
-        const info = {
-            [MediaTypes.JSON]: {
-                schema: {
-                    additionalProperties: {
-                        format: 'int32',
-                    },
-                },
-            },
-        };
-        beforeEach(() => {
-            parser = new OpenAPIParser({ openapi: '3.0.0' }, undefined, options);
-        });
-        test('should work with default arguments', () => {
-            const consoleError = vi.spyOn(global.console, 'error');
-            const mediaContentModel = getMediaContent({
-                parser,
-                info: {},
-                isRequestType: true,
-                options,
-                data,
-            });
-            expect(consoleError).not.toHaveBeenCalled();
-            expect(mediaContentModel).toEqual({
-                hasSample: false,
-                isRequestType: true,
-                mediaTypes: [],
-                ...data,
-            });
-        });
-        test('should handle isRequestType argument', () => {
-            const mediaContentModelWithRequestTypeTrue = getMediaContent({
-                parser,
-                info: {},
-                isRequestType: true,
-                options,
-                data,
-            });
-            const mediaContentModelWithRequestTypeFalse = getMediaContent({
-                parser,
-                info: {},
-                isRequestType: false,
-                options,
-                data,
-            });
-            expect(mediaContentModelWithRequestTypeTrue.isRequestType).toEqual(true);
-            expect(mediaContentModelWithRequestTypeFalse.isRequestType).toEqual(false);
-        });
-        test('should return mediaType', () => {
-            const mediaContentModel = getMediaContent({
-                parser,
-                info,
-                isRequestType: true,
-                options,
-                data,
-            });
-            const firstMediaType = mediaContentModel.mediaTypes[0];
-            expect(mediaContentModel.mediaTypes.length).toEqual(1);
-            expect(firstMediaType.name).toEqual(MediaTypes.JSON);
-        });
-        test('should preserve summary for each example when media type uses examples object', () => {
-            const infoWithExamples = {
-                [MediaTypes.JSON]: {
-                    schema: {
-                        type: 'object',
-                        properties: { publisherId: { type: 'string' } },
-                    },
-                    examples: {
-                        'example-0': {
-                            summary: 'First Example',
-                            value: { publisherId: '1' },
-                        },
-                        'example-1': {
-                            summary: 'Second Example',
-                            value: { publisherId: '2' },
-                        },
-                    },
-                },
-            };
-            const mediaContentModel = getMediaContent({
-                parser,
-                info: infoWithExamples,
-                isRequestType: true,
-                options,
-                data,
-            });
-            const examples = mediaContentModel.mediaTypes[0]?.examples;
-            expect(examples).toBeDefined();
-            expect(examples?.['example-0']).toBeDefined();
-            expect(examples?.['example-0']?.summary).toBe('First Example');
-            expect(examples?.['example-0']?.value).toEqual({ publisherId: '1' });
-            expect(examples?.['example-1']).toBeDefined();
-            expect(examples?.['example-1']?.summary).toBe('Second Example');
-            expect(examples?.['example-1']?.value).toEqual({ publisherId: '2' });
-        });
-    });
-});
-//# sourceMappingURL=MediaContent.test.js.map

package/lib/models/__tests__/Operation.test.d.ts

@@ -1 +0,0 @@
-export {};