@redocly/openapi-docs 3.24.1 → 3.24.2

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

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

@@ -1,221 +0,0 @@
-import { parseYaml } from '@redocly/openapi-core';
-import { outdent } from 'outdent';
-import { getResponse } from '../response.js';
-import { normalizeOptions, OpenAPIParser } from '../../services/index.js';
-const opts = normalizeOptions({});
-describe('Models', () => {
-    describe('ResponseModel', () => {
-        let parser, props;
-        beforeEach(() => {
-            parser = new OpenAPIParser({ openapi: '3.0.0' }, undefined, opts);
-            props = {
-                parser,
-                defaultAsError: false,
-                infoOrRef: {},
-                options: opts,
-                isEvent: false,
-                code: 'default',
-            };
-        });
-        test('should calculate response type based on code', () => {
-            let resp = getResponse({ ...props, code: '200' });
-            expect(resp.type).toEqual('success');
-            resp = getResponse({ ...props, code: '120' });
-            expect(resp.type).toEqual('info');
-            resp = getResponse({ ...props, code: '301' });
-            expect(resp.type).toEqual('redirect');
-            resp = getResponse({ ...props, code: '400' });
-            expect(resp.type).toEqual('error');
-        });
-        test('default should be successful by default', () => {
-            const resp = getResponse({ ...props, code: 'default' });
-            expect(resp.type).toEqual('success');
-        });
-        test('default should be error if defaultAsError is true', () => {
-            const resp = getResponse({ ...props, code: 'default', defaultAsError: true });
-            expect(resp.type).toEqual('error');
-        });
-        test('should use x-summary for summary and description for description', () => {
-            const resp = getResponse({
-                ...props,
-                infoOrRef: {
-                    'x-summary': 'test summary',
-                    description: 'test description',
-                },
-            });
-            expect(resp.summary).toEqual('test summary');
-            expect(resp.description).toEqual('test description');
-        });
-        test('should have empty summary and description if not provided', () => {
-            const resp = getResponse({
-                ...props,
-                infoOrRef: {},
-            });
-            expect(resp.summary).toEqual('');
-            expect(resp.description).toEqual('');
-        });
-        test('should parse headers', () => {
-            const resp = getResponse({
-                ...props,
-                operation: { pointer: '#/paths/~1test/get' },
-                infoOrRef: {
-                    headers: {
-                        'X-Rate-Limit': {
-                            description: 'Calls per hour allowed by the user',
-                            schema: {
-                                type: 'integer',
-                                format: 'int32',
-                            },
-                        },
-                    },
-                },
-            });
-            expect(resp.headers).toHaveLength(1);
-            expect(resp.headers[0].name).toEqual('X-Rate-Limit');
-            expect(resp.headers[0].description).toEqual('Calls per hour allowed by the user');
-        });
-        test('should parse content', () => {
-            const resp = getResponse({
-                ...props,
-                operation: { pointer: '#/paths/~1test/get' },
-                infoOrRef: {
-                    content: {
-                        'application/json': {
-                            schema: {
-                                type: 'string',
-                            },
-                        },
-                    },
-                },
-            });
-            expect(resp.content).toBeDefined();
-            expect(resp.content?.mediaTypes).toHaveLength(1);
-            expect(resp.content?.mediaTypes[0].name).toEqual('application/json');
-        });
-        test('should dereference $ref in response content to components/mediaTypes (OpenAPI 3.2)', () => {
-            const spec = parseYaml(outdent `
-        openapi: 3.2.0
-        info:
-          title: Test
-          version: 1.0.0
-        paths:
-          /test:
-            get:
-              operationId: test
-              responses:
-                '200':
-                  description: ok
-                  content:
-                    $ref: '#/components/mediaTypes/PatchResponse'
-        components:
-          mediaTypes:
-            PatchResponse:
-              application/json:
-                schema:
-                  type: string
-      `);
-            parser = new OpenAPIParser(spec, undefined, opts);
-            const resp = getResponse({
-                parser,
-                code: '200',
-                defaultAsError: false,
-                infoOrRef: spec.paths['/test'].get.responses['200'],
-                options: opts,
-                operation: { pointer: '#/paths/~1test/get' },
-            });
-            expect(resp.content).toBeDefined();
-            expect(resp.content?.mediaTypes).toHaveLength(1);
-            expect(resp.content?.mediaTypes[0].name).toBe('application/json');
-            expect(resp.content?.mediaTypes[0].schema?.type).toBe('string');
-        });
-        test('should set isRequestType when isEvent is true', () => {
-            const resp = getResponse({
-                ...props,
-                isEvent: true,
-                operation: { pointer: '#/paths/~1test/get' },
-                infoOrRef: {
-                    content: {
-                        'application/json': {
-                            schema: {
-                                type: 'string',
-                            },
-                        },
-                    },
-                },
-            });
-            expect(resp.content).toBeDefined();
-            expect(resp.content?.isRequestType).toBe(true);
-        });
-        test('should get correct sibling in responses for openapi 3.1', () => {
-            const spec = parseYaml(outdent `
-        openapi: 3.1.0
-        paths:
-          /test:
-            get:
-              operationId: test
-              responses:
-                '200':
-                  description: Overridden description
-                  $ref: "#/components/responses/Successful"
-        components:
-          responses:
-            Successful:
-              description: successful operation
-              content:
-                application/json:
-                  schema:
-                    type: object
-                    properties:
-                      successful:
-                        type: boolean
-      `);
-            parser = new OpenAPIParser(spec, undefined, opts);
-            const code = '200';
-            const responseModel = getResponse({
-                parser: parser,
-                code: code,
-                defaultAsError: false,
-                infoOrRef: spec.paths['/test'].get.responses[code],
-                options: opts,
-                operation: {},
-            });
-            expect(responseModel.summary).toBe('Overridden description');
-        });
-        test('should not override description in responses for openapi 3.0', () => {
-            const spec = parseYaml(outdent `
-        openapi: 3.0.0
-        paths:
-          /test:
-            get:
-              operationId: test
-              responses:
-                '200':
-                  description: Overridden description
-                  $ref: "#/components/responses/Successful"
-        components:
-          responses:
-            Successful:
-              description: successful operation
-              content:
-                application/json:
-                  schema:
-                    type: object
-                    properties:
-                      successful:
-                        type: boolean
-      `);
-            parser = new OpenAPIParser(spec, undefined, opts);
-            const code = '200';
-            const responseModel = getResponse({
-                parser: parser,
-                code: code,
-                defaultAsError: false,
-                infoOrRef: spec.paths['/test'].get.responses[code],
-                options: opts,
-                operation: {},
-            });
-            expect(responseModel.summary).toBe('successful operation');
-        });
-    });
-});
-//# sourceMappingURL=Response.test.js.map

package/lib/models/__tests__/Schema.circular.test.d.ts

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