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

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 {};

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

@@ -1,459 +0,0 @@
-import { normalizeOptions, OpenAPIParser } from '../../services/index.js';
-import { getOperation } from '../operation.js';
-import { getRequestBody } from '../request.js';
-import specFixture from './fixtures/operation/petstore.json';
-import definitionFixture from './fixtures/operation/operationDefinition.json';
-import noRequestDefinitionFixture from './fixtures/operation/noRequestOperationDefinition.json';
-import { replaceCircularJson } from './helpers.js';
-const options = normalizeOptions({});
-import { configure as originalConfigure } from '@redocly/theme/ext/configure';
-vi.mock('@redocly/theme/ext/configure', async (importOriginal) => {
-    const actual = await importOriginal();
-    return {
-        ...actual,
-        configure: vi.fn(() => ({
-            requestValues: {},
-        })),
-    };
-});
-const mockConfigure = vi.mocked(originalConfigure);
-const spec = specFixture;
-const definition = definitionFixture;
-const noRequestDefinition = noRequestDefinitionFixture;
-describe('Models', () => {
-    describe('Operation', () => {
-        const parser = new OpenAPIParser(spec, undefined, options);
-        let operation;
-        let requestBody;
-        let payload;
-        describe('Operation with request body', () => {
-            beforeEach(() => {
-                operation = getOperation(parser, definition, undefined, options, 'test');
-                requestBody = getRequestBody({
-                    parser,
-                    infoOrRef: definition?.requestBody,
-                    options,
-                    operation,
-                    isEvent: false,
-                });
-                payload = {
-                    lang: 'payload',
-                    label: 'Payload',
-                    source: '',
-                    requestBodyContent: requestBody.content,
-                };
-            });
-            test('should create Operation Model', () => {
-                expect(operation).toBeDefined();
-                expect(operation.operationId).toBe(definition.operationId);
-            });
-            test('should return request body', () => {
-                expect(operation.requestBody?.description).toEqual(requestBody.description);
-                expect(operation.requestBody?.required).toEqual(requestBody.required);
-                expect(JSON.stringify(operation.requestBody?.content, replaceCircularJson)).toEqual(JSON.stringify(requestBody.content, replaceCircularJson));
-            });
-            test('should return payload', () => {
-                expect(JSON.stringify(operation.payload, replaceCircularJson)).toEqual(JSON.stringify(payload, replaceCircularJson));
-            });
-            test('should return hasSamples: true', () => {
-                expect(operation.hasSamples).toBe(true);
-            });
-            test('should return definitionSamples', () => {
-                expect(operation.definitionSamples).toEqual(definition['x-codeSamples']);
-            });
-        });
-        describe('Operation without request body', () => {
-            beforeEach(() => {
-                operation = getOperation(parser, noRequestDefinition, undefined, options, '');
-            });
-            test('should return requestBody undefined', () => {
-                expect(operation.requestBody).toBe(undefined);
-            });
-            test('should return payload undefined', () => {
-                expect(operation.payload).toEqual({
-                    lang: 'Payload',
-                    source: '',
-                    requestBodyContent: undefined,
-                });
-            });
-            test('should return hasSamples: false', () => {
-                expect(operation.hasSamples).toBe(false);
-            });
-        });
-        describe('Operation with mock server options', () => {
-            const specWithServers = {
-                ...spec,
-                servers: [
-                    {
-                        url: 'https://default-server-url.com',
-                        description: 'default server',
-                    },
-                ],
-            };
-            const parser = new OpenAPIParser(specWithServers, undefined, options);
-            test('Should handle mock server position "first"', () => {
-                const options = {
-                    ...normalizeOptions({}),
-                    mockServer: { url: 'http://mock-server-url.com', position: 'first' },
-                };
-                const operation = getOperation(parser, definition, undefined, options, '');
-                expect(operation.servers).toEqual([
-                    {
-                        description: '',
-                        url: 'http://mock-server-url.com',
-                    },
-                    ...specWithServers.servers,
-                ]);
-            });
-            test('Should handle mock server position "last"', () => {
-                const options = {
-                    ...normalizeOptions({}),
-                    mockServer: { url: 'http://mock-server-url.com', position: 'last' },
-                };
-                const operation = getOperation(parser, definition, undefined, options, '');
-                expect(operation.servers).toEqual([
-                    ...specWithServers.servers,
-                    {
-                        description: '',
-                        url: 'http://mock-server-url.com',
-                    },
-                ]);
-            });
-            test('Should handle mock server position "replace"', () => {
-                const options = {
-                    ...normalizeOptions({}),
-                    mockServer: { url: 'http://mock-server-url.com', position: 'replace' },
-                };
-                const operation = getOperation(parser, definition, undefined, options, '');
-                expect(operation.servers).toEqual([
-                    {
-                        description: '',
-                        url: 'http://mock-server-url.com',
-                    },
-                ]);
-            });
-        });
-        describe('Operation with configured request values', () => {
-            beforeEach(() => {
-                // Reset the mock before each test
-                mockConfigure.mockReturnValue({ requestValues: {} });
-            });
-            test('should update request body with configured values', () => {
-                mockConfigure.mockReturnValue({
-                    requestValues: {
-                        body: {
-                            name: 'test-pet',
-                            status: 'available-test',
-                        },
-                    },
-                });
-                operation = getOperation(parser, definition, undefined, options, 'test');
-                const content = operation.requestBody?.content?.mediaTypes[0];
-                expect(content?.examples?.cat?.value).toEqual(expect.objectContaining({
-                    name: 'test-pet',
-                    status: 'available-test',
-                }));
-            });
-            test('should update security with configured values', () => {
-                mockConfigure.mockReturnValue({
-                    requestValues: {
-                        security: {
-                            default: {
-                                token: {
-                                    access_token: 'test-token',
-                                    token_type: 'test token type',
-                                },
-                            },
-                        },
-                    },
-                });
-                operation = getOperation(parser, definition, undefined, options, 'test');
-                operation.security.forEach((security) => {
-                    security.schemes.forEach((scheme) => {
-                        expect(scheme['x-defaultAccessToken']).toBe('test-token');
-                        expect(scheme['x-defaultTokenType']).toBe('test token type');
-                    });
-                });
-            });
-        });
-        describe('Operation with server-specific request values', () => {
-            const servers = [
-                {
-                    url: 'https://prod-server-url.com',
-                    description: 'prod server',
-                },
-                {
-                    url: 'https://dev-server-url.com',
-                    description: 'dev server',
-                },
-            ];
-            const specWithServers = {
-                ...spec,
-                servers: servers,
-            };
-            const definitionWithServers = {
-                ...definition,
-                servers: specWithServers.servers,
-            };
-            const parser = new OpenAPIParser(specWithServers, undefined, options);
-            beforeEach(() => {
-                // Reset the mock before each test
-                mockConfigure.mockReturnValue({ requestValues: {} });
-            });
-            test('should apply server-specific body values from configure function', () => {
-                mockConfigure.mockReturnValue({
-                    requestValues: {
-                        'https://prod-server-url.com': {
-                            body: {
-                                name: 'prod-pet',
-                                status: 'available-prod',
-                            },
-                        },
-                        'https://dev-server-url.com': {
-                            body: {
-                                name: 'dev-pet',
-                                status: 'available-dev',
-                            },
-                        },
-                    },
-                });
-                operation = getOperation(parser, definitionWithServers, undefined, options, 'test');
-                const content = operation.requestBody?.content?.mediaTypes[0];
-                expect(content?.examples?.cat?.serverValues?.['https://prod-server-url.com']?.value).toEqual(expect.objectContaining({
-                    name: 'prod-pet',
-                    status: 'available-prod',
-                }));
-                expect(content?.examples?.cat?.serverValues?.['https://dev-server-url.com']?.value).toEqual(expect.objectContaining({
-                    name: 'dev-pet',
-                    status: 'available-dev',
-                }));
-            });
-            test('should handle security settings in server-specific request values', () => {
-                mockConfigure.mockReturnValue({
-                    requestValues: {
-                        'https://prod-server-url.com': {
-                            security: {
-                                default: {
-                                    token: {
-                                        access_token: 'prod-token',
-                                        token_type: 'prod token type',
-                                    },
-                                },
-                            },
-                        },
-                        'https://dev-server-url.com': {
-                            security: {
-                                default: {
-                                    token: {
-                                        access_token: 'dev-token',
-                                        token_type: 'dev token type',
-                                    },
-                                },
-                            },
-                        },
-                    },
-                });
-                operation = getOperation(parser, definitionWithServers, undefined, options, 'test');
-                operation.security.forEach((security) => {
-                    security.schemes.forEach((scheme) => {
-                        // Check server-specific credentials
-                        expect(scheme.serverValues?.['https://prod-server-url.com']?.['x-defaultAccessToken']).toEqual('prod-token');
-                        expect(scheme.serverValues?.['https://dev-server-url.com']?.['x-defaultAccessToken']).toEqual('dev-token');
-                    });
-                });
-            });
-            test('should handle empty serverValues object', () => {
-                mockConfigure.mockReturnValue({
-                    requestValues: {},
-                });
-                operation = getOperation(parser, definitionWithServers, undefined, options, 'test');
-                const content = operation.requestBody?.content?.mediaTypes[0];
-                // Verify default example values remain unchanged
-                expect(content?.examples?.cat?.serverValues).toBeUndefined();
-            });
-            test('should handle request values with only some servers defined', () => {
-                mockConfigure.mockReturnValue({
-                    requestValues: {
-                        'https://prod-server-url.com': {
-                            body: {
-                                name: 'prod-only-pet',
-                            },
-                        },
-                        // dev server not defined
-                    },
-                });
-                operation = getOperation(parser, definitionWithServers, undefined, options, 'test');
-                const content = operation.requestBody?.content?.mediaTypes[0];
-                // Prod server should have values
-                expect(content?.examples?.cat?.serverValues?.['https://prod-server-url.com']?.value).toEqual(expect.objectContaining({
-                    name: 'prod-only-pet',
-                }));
-                // Dev server should not have values
-                expect(content?.examples?.cat?.serverValues?.['https://dev-server-url.com']).toBeUndefined();
-            });
-        });
-        describe('Operation with dynamic request values', () => {
-            beforeEach(() => {
-                mockConfigure.mockReturnValue({ requestValues: {} });
-            });
-            test('should prioritize dynamicRequestValues over configured values', () => {
-                mockConfigure.mockReturnValue({
-                    requestValues: {
-                        body: {
-                            name: 'configured-pet',
-                            status: 'configured-status',
-                        },
-                        security: {
-                            default: {
-                                token: {
-                                    access_token: 'configured-token',
-                                    token_type: 'configured token type',
-                                },
-                            },
-                        },
-                    },
-                });
-                const dynamicRequestValues = {
-                    body: {
-                        name: 'dynamic-pet',
-                        status: 'dynamic-status',
-                    },
-                    security: {
-                        default: {
-                            token: {
-                                access_token: 'dynamic-token',
-                                token_type: 'dynamic token type',
-                            },
-                        },
-                    },
-                };
-                operation = getOperation(parser, definition, undefined, options, 'test', undefined, undefined, dynamicRequestValues);
-                const content = operation.requestBody?.content?.mediaTypes[0];
-                expect(content?.examples?.cat?.value).toEqual(expect.objectContaining({
-                    name: 'dynamic-pet',
-                    status: 'dynamic-status',
-                }));
-                operation.security.forEach((security) => {
-                    security.schemes.forEach((scheme) => {
-                        expect(scheme['x-defaultAccessToken']).toBe('dynamic-token');
-                        expect(scheme['x-defaultTokenType']).toBe('dynamic token type');
-                    });
-                });
-            });
-        });
-        describe('Operation badges', () => {
-            beforeEach(() => {
-                mockConfigure.mockReturnValue({ requestValues: {} });
-            });
-            test('should include badges from x-badges extension with default values', () => {
-                const operationDefinitionWithBadges = {
-                    ...definition,
-                    'x-badges': [
-                        {
-                            name: 'Beta',
-                            color: 'blue',
-                            position: 'before',
-                        },
-                        {
-                            name: 'New',
-                        },
-                    ],
-                };
-                operation = getOperation(parser, operationDefinitionWithBadges, undefined, options, 'test');
-                expect(operation.badges).toEqual([
-                    {
-                        name: 'Beta',
-                        color: 'blue',
-                        position: 'before',
-                    },
-                    {
-                        name: 'New',
-                        color: 'blue',
-                        position: 'after',
-                    },
-                ]);
-            });
-            test('should add badges from tags matching badge or audience kind tags in spec', () => {
-                const specWithBadgeTags = {
-                    ...spec,
-                    tags: [
-                        {
-                            name: 'beta',
-                            kind: 'badge',
-                            summary: 'Beta Feature',
-                        },
-                        {
-                            name: 'developers',
-                            kind: 'audience',
-                        },
-                        {
-                            name: 'pet',
-                            description: 'Pet operations',
-                        },
-                    ],
-                };
-                const operationDefinitionWithTag = {
-                    ...definition,
-                    tags: ['beta', 'developers', 'pet'],
-                };
-                const parserWithBadgeTags = new OpenAPIParser(specWithBadgeTags, undefined, options);
-                operation = getOperation(parserWithBadgeTags, operationDefinitionWithTag, undefined, options, 'test');
-                expect(operation.badges).toEqual([
-                    {
-                        name: 'Beta Feature',
-                        color: 'blue',
-                        position: 'after',
-                        icon: undefined,
-                        description: undefined,
-                    },
-                    {
-                        name: 'developers',
-                        color: 'grey',
-                        position: 'after',
-                        icon: 'user-group',
-                        description: undefined,
-                    },
-                ]);
-            });
-            test('should combine x-badges and tag-based badges', () => {
-                const specWithBadgeTags = {
-                    ...spec,
-                    tags: [
-                        {
-                            name: 'beta',
-                            kind: 'badge',
-                            summary: 'Beta Feature',
-                        },
-                    ],
-                };
-                const operationDefinitionWithBoth = {
-                    ...definition,
-                    tags: ['beta'],
-                    'x-badges': [
-                        {
-                            name: 'New',
-                            color: 'green',
-                        },
-                    ],
-                };
-                const parserWithBadgeTags = new OpenAPIParser(specWithBadgeTags, undefined, options);
-                operation = getOperation(parserWithBadgeTags, operationDefinitionWithBoth, undefined, options, 'test');
-                expect(operation.badges).toEqual([
-                    {
-                        name: 'New',
-                        color: 'green',
-                        position: 'after',
-                    },
-                    {
-                        name: 'Beta Feature',
-                        color: 'blue',
-                        position: 'after',
-                        icon: undefined,
-                        description: undefined,
-                    },
-                ]);
-            });
-        });
-    });
-});
-//# sourceMappingURL=Operation.test.js.map

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

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