@redocly/openapi-docs 3.24.0 → 3.24.1

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

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

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

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

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

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