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

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

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

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

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