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

package/lib/components/Replay/__tests__/utils.test.js

@@ -1,526 +0,0 @@
-import { convertOperationToReplayValue, convertOperationToReplayValueForRedoc, convertRequestSecurity, } from '../utils.js';
-import { getOperation } from '../../../models/index.js';
-vi.mock('../../../services', () => {
-    return {
-        OpenAPIParser: class MockOpenAPIParser {
-            definition;
-            constructor(definition) {
-                this.definition = definition;
-            }
-        },
-        normalizeOptions: vi.fn(() => ({})),
-    };
-});
-vi.mock('../../../models', () => ({
-    getOperation: vi.fn(),
-}));
-const mockGetOperation = vi.mocked(getOperation);
-const createMockField = (name, example) => ({
-    name,
-    example,
-    schema: {
-        type: 'string',
-        format: undefined,
-        enum: [],
-    },
-});
-describe('Replay utils', () => {
-    describe('convertOperationToReplayValue', () => {
-        it('returns undefined when openAPI is not provided', () => {
-            const result = convertOperationToReplayValue('/path', 'get', undefined);
-            expect(result).toBeUndefined();
-        });
-        it('returns undefined when operation is not found', () => {
-            const mockOpenAPI = {
-                paths: {
-                    '/path': {
-                        get: {},
-                    },
-                },
-            };
-            mockGetOperation.mockReturnValue(null);
-            const result = convertOperationToReplayValue('/path', 'get', mockOpenAPI);
-            expect(result).toBeUndefined();
-        });
-        it('forwards docs options to getOperation (e.g. mock server for embedded replay)', () => {
-            const mockOpenAPI = {
-                paths: {
-                    '/test': {
-                        get: {},
-                        parameters: [],
-                    },
-                },
-            };
-            mockGetOperation.mockClear();
-            mockGetOperation.mockReturnValue({
-                id: 'op1',
-                name: 'Test Operation',
-                httpVerb: 'get',
-                operationId: 'testOp',
-                parameters: [],
-                path: '/test',
-                href: '/test',
-                servers: [],
-                security: [],
-                responses: [],
-            });
-            const docsOptions = {
-                mockServer: {
-                    url: 'http://localhost:9999/_mock/slug',
-                    description: 'Mock server',
-                    position: 'first',
-                },
-            };
-            convertOperationToReplayValue('/test', 'get', mockOpenAPI, undefined, undefined, undefined, undefined, docsOptions);
-            expect(mockGetOperation).toHaveBeenCalled();
-            const lastCall = mockGetOperation.mock.calls[mockGetOperation.mock.calls.length - 1];
-            expect(lastCall[3]).toEqual(docsOptions);
-        });
-        it('converts operation to replay value correctly', () => {
-            const mockOperation = {
-                id: 'op1',
-                name: 'Test Operation',
-                httpVerb: 'get',
-                operationId: 'testOp',
-                parameters: [],
-                path: '/test',
-                href: '/test',
-                servers: [],
-                security: [],
-                responses: [
-                    {
-                        code: '200',
-                        description: 'Success',
-                        content: {
-                            mediaTypes: [
-                                {
-                                    name: 'application/json',
-                                    schema: {
-                                        rawSchema: { type: 'object' },
-                                    },
-                                },
-                            ],
-                        },
-                    },
-                ],
-            };
-            const mockOpenAPI = {
-                paths: {
-                    '/test': {
-                        get: {},
-                        parameters: [],
-                    },
-                },
-            };
-            mockGetOperation.mockReturnValue(mockOperation);
-            const result = convertOperationToReplayValue('/test', 'get', mockOpenAPI);
-            expect(result).toEqual({
-                id: 'op1',
-                name: 'Test Operation',
-                method: 'get',
-                operationId: 'testOp',
-                parameters: [],
-                body: undefined,
-                path: '/test',
-                href: '/test',
-                servers: [],
-                security: [],
-                responses: {
-                    '200': {
-                        code: '200',
-                        description: 'Success',
-                        mediaTypes: {
-                            'application/json': {
-                                name: 'application/json',
-                                schema: {
-                                    type: 'object',
-                                    components: {},
-                                },
-                            },
-                        },
-                    },
-                },
-            });
-        });
-        it('should set allowReserved on parameters when operation params have allowReserved', () => {
-            const mockOperation = {
-                id: 'op1',
-                name: 'Test',
-                httpVerb: 'get',
-                operationId: 'testOp',
-                parameters: [
-                    {
-                        name: 'filter',
-                        in: 'query',
-                        required: false,
-                        allowReserved: true,
-                        schema: { type: 'string' },
-                    },
-                ],
-                path: '/test',
-                href: '/test',
-                servers: [],
-                security: [],
-                responses: [],
-            };
-            const mockOpenAPI = {
-                paths: { '/test': { get: {} } },
-            };
-            mockGetOperation.mockReturnValue(mockOperation);
-            const result = convertOperationToReplayValue('/test', 'get', mockOpenAPI);
-            expect(result?.parameters).toHaveLength(1);
-            expect(result?.parameters?.[0].allowReserved).toBe(true);
-        });
-        it('finds operation in additionalOperations when not in standard methods', () => {
-            const mockOpenAPI = {
-                paths: {
-                    '/resource': {
-                        get: { summary: 'Get resource' },
-                        additionalOperations: {
-                            test: {
-                                summary: 'Custom TEST method',
-                                operationId: 'testOp',
-                                responses: {},
-                            },
-                        },
-                    },
-                },
-            };
-            let receivedOperationDef = null;
-            mockGetOperation.mockImplementation((_parser, operationDef) => {
-                receivedOperationDef = operationDef;
-                return {
-                    id: 'custom-op',
-                    method: 'test',
-                    operationId: 'testOp',
-                    parameters: [],
-                    responses: [],
-                    servers: [],
-                    security: [],
-                };
-            });
-            const result = convertOperationToReplayValue('/resource', 'test', mockOpenAPI);
-            expect(receivedOperationDef).toBeDefined();
-            expect(receivedOperationDef.summary).toBe('Custom TEST method');
-            expect(receivedOperationDef.operationId).toBe('testOp');
-            expect(receivedOperationDef.httpVerb).toBe('test');
-            expect(receivedOperationDef.pathName).toBe('/resource');
-            expect(result).toBeDefined();
-        });
-        it('returns undefined when method not found and additionalOperations does not contain it', () => {
-            const mockOpenAPI = {
-                paths: {
-                    '/resource': {
-                        get: { summary: 'Get resource' },
-                        additionalOperations: {
-                            test: { summary: 'Custom TEST method' },
-                        },
-                    },
-                },
-            };
-            mockGetOperation.mockReturnValue(null);
-            const result = convertOperationToReplayValue('/resource', 'greet', mockOpenAPI);
-            expect(result).toBeUndefined();
-            expect(mockGetOperation).toHaveBeenCalled();
-            const callArgs = mockGetOperation.mock.calls[0];
-            expect(callArgs[1]?.summary).toBeUndefined();
-        });
-    });
-    describe('convertOperationToReplayValueForRedoc', () => {
-        it('returns undefined when base conversion returns undefined', () => {
-            const result = convertOperationToReplayValueForRedoc()('/path', 'get', undefined);
-            expect(result).toBeUndefined();
-        });
-        it('adds generated operationId when none exists', () => {
-            const mockOpenAPI = {
-                paths: {
-                    '/test': {
-                        get: {},
-                    },
-                },
-            };
-            const mockOperation = {
-                path: '/test',
-                method: 'get',
-                httpVerb: 'get',
-                operationId: undefined,
-                parameters: [],
-                security: [],
-                responses: [],
-                servers: [],
-            };
-            mockGetOperation.mockReturnValue(mockOperation);
-            const result = convertOperationToReplayValueForRedoc()('/test', 'get', mockOpenAPI);
-            expect(result?.operationId).toBe('/paths/~1test/get');
-        });
-        it('uses stored operation state for active request body example', () => {
-            const mockOpenAPI = {
-                paths: {
-                    '/test': {
-                        get: {},
-                    },
-                },
-            };
-            const mockOperation = {
-                id: 'op1',
-                name: 'Test operation',
-                path: '/test',
-                href: '/test',
-                method: 'get',
-                httpVerb: 'get',
-                operationId: undefined,
-                parameters: [],
-                servers: [],
-                security: [],
-                responses: [],
-                requestBody: {
-                    required: false,
-                    content: {
-                        mediaTypes: [
-                            {
-                                name: 'application/json',
-                                schema: {
-                                    rawSchema: { type: 'object' },
-                                },
-                                examples: {
-                                    default: {
-                                        value: { id: 1 },
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                },
-            };
-            mockGetOperation.mockReturnValue(mockOperation);
-            const result = convertOperationToReplayValueForRedoc(undefined, undefined, undefined, {
-                '/paths/~1test/get': {
-                    activeExampleName: 'event_entry',
-                    activeOneOf: {},
-                    activeSecuritySchemeIds: [],
-                    requestValues: {},
-                    request: {},
-                    response: {},
-                },
-            })('/test', 'get', mockOpenAPI);
-            expect(result?.body?.activeExampleName).toBe('event_entry');
-        });
-    });
-    describe('convertRequestSecurity', () => {
-        it('returns undefined when security is not provided', () => {
-            const result = convertRequestSecurity(undefined);
-            expect(result).toBeUndefined();
-        });
-        it('converts security requirements correctly', () => {
-            const mockSecurity = [
-                {
-                    schemes: [
-                        {
-                            id: 'auth1',
-                            type: 'oauth2',
-                            in: 'header',
-                            scopes: ['read'],
-                            scheme: 'bearer',
-                            name: 'Authorization',
-                            flows: { implicit: {} },
-                            'x-defaultAccessToken': 'token123',
-                            'x-defaultTokenType': 'Bearer',
-                        },
-                    ],
-                },
-            ];
-            const result = convertRequestSecurity(mockSecurity);
-            expect(result).toEqual([
-                [
-                    {
-                        id: 'auth1',
-                        type: 'oauth2',
-                        in: 'header',
-                        scopes: ['read'],
-                        scheme: 'bearer',
-                        name: 'Authorization',
-                        flows: { implicit: {} },
-                        'x-defaultAccessToken': 'token123',
-                        'x-defaultTokenType': 'Bearer',
-                    },
-                ],
-            ]);
-        });
-        it('removes undefined properties from security scheme', () => {
-            const mockSecurity = [
-                {
-                    schemes: [
-                        {
-                            id: 'auth1',
-                            type: 'apiKey',
-                            in: 'header',
-                            name: 'X-API-Key',
-                            flows: undefined,
-                            'x-defaultAccessToken': undefined,
-                        },
-                    ],
-                },
-            ];
-            const result = convertRequestSecurity(mockSecurity);
-            expect(result?.[0][0]).toEqual({
-                id: 'auth1',
-                type: 'apiKey',
-                in: 'header',
-                name: 'X-API-Key',
-            });
-            expect(result?.[0][0].flows).toBeUndefined();
-            expect(result?.[0][0]['x-defaultAccessToken']).toBeUndefined();
-        });
-    });
-    describe('convertOperationToReplayValue with form-urlencoded body', () => {
-        it('extracts parameters from oneOf schema for application/x-www-form-urlencoded', () => {
-            const mockFields = [
-                createMockField('client_id', 'YOUR_CLIENT_ID'),
-                createMockField('client_secret', 'YOUR_CLIENT_SECRET'),
-                createMockField('grant_type', 'client_credentials'),
-            ];
-            const mockOperation = {
-                id: 'op1',
-                name: 'Get Token',
-                httpVerb: 'post',
-                operationId: 'getToken',
-                parameters: [],
-                path: '/oauth/token',
-                href: '/oauth/token',
-                servers: [],
-                security: [],
-                responses: [],
-                requestBody: {
-                    required: true,
-                    content: {
-                        mediaTypes: [
-                            {
-                                name: 'application/x-www-form-urlencoded',
-                                schema: {
-                                    fields: undefined,
-                                    oneOf: [
-                                        {
-                                            fields: mockFields,
-                                        },
-                                    ],
-                                },
-                                examples: {
-                                    default: {
-                                        value: {
-                                            client_id: 'YOUR_CLIENT_ID',
-                                            client_secret: 'YOUR_CLIENT_SECRET',
-                                            grant_type: 'client_credentials',
-                                        },
-                                    },
-                                },
-                            },
-                        ],
-                    },
-                },
-            };
-            const mockOpenAPI = {
-                paths: {
-                    '/oauth/token': {
-                        post: {},
-                        parameters: [],
-                    },
-                },
-            };
-            mockGetOperation.mockReturnValue(mockOperation);
-            const result = convertOperationToReplayValue('/oauth/token', 'post', mockOpenAPI);
-            expect(result?.body).toBeDefined();
-            expect(result?.body?.mediaTypes?.['application/x-www-form-urlencoded']).toBeDefined();
-            const formUrlEncodedMediaType = result?.body?.mediaTypes?.['application/x-www-form-urlencoded'];
-            expect(formUrlEncodedMediaType?.parameters).toBeDefined();
-            expect(formUrlEncodedMediaType?.parameters).toHaveLength(3);
-            expect(formUrlEncodedMediaType?.parameters?.[0]?.name).toBe('client_id');
-            expect(formUrlEncodedMediaType?.parameters?.[1]?.name).toBe('client_secret');
-            expect(formUrlEncodedMediaType?.parameters?.[2]?.name).toBe('grant_type');
-        });
-        it('extracts parameters from direct schema fields when available', () => {
-            const mockFields = [
-                createMockField('username', 'testuser'),
-                createMockField('password', 'testpass'),
-            ];
-            const mockOperation = {
-                id: 'op1',
-                name: 'Login',
-                httpVerb: 'post',
-                operationId: 'login',
-                parameters: [],
-                path: '/login',
-                href: '/login',
-                servers: [],
-                security: [],
-                responses: [],
-                requestBody: {
-                    required: true,
-                    content: {
-                        mediaTypes: [
-                            {
-                                name: 'application/x-www-form-urlencoded',
-                                schema: {
-                                    fields: mockFields,
-                                },
-                                examples: {},
-                            },
-                        ],
-                    },
-                },
-            };
-            const mockOpenAPI = {
-                paths: {
-                    '/login': {
-                        post: {},
-                        parameters: [],
-                    },
-                },
-            };
-            mockGetOperation.mockReturnValue(mockOperation);
-            const result = convertOperationToReplayValue('/login', 'post', mockOpenAPI);
-            const formUrlEncodedMediaType = result?.body?.mediaTypes?.['application/x-www-form-urlencoded'];
-            expect(formUrlEncodedMediaType?.parameters).toHaveLength(2);
-            expect(formUrlEncodedMediaType?.parameters?.[0]?.name).toBe('username');
-            expect(formUrlEncodedMediaType?.parameters?.[1]?.name).toBe('password');
-        });
-        it('returns undefined parameters when schema has no fields and no oneOf', () => {
-            const mockOperation = {
-                id: 'op1',
-                name: 'Test',
-                httpVerb: 'post',
-                operationId: 'test',
-                parameters: [],
-                path: '/test',
-                href: '/test',
-                servers: [],
-                security: [],
-                responses: [],
-                requestBody: {
-                    required: true,
-                    content: {
-                        mediaTypes: [
-                            {
-                                name: 'application/x-www-form-urlencoded',
-                                schema: {},
-                                examples: {},
-                            },
-                        ],
-                    },
-                },
-            };
-            const mockOpenAPI = {
-                paths: {
-                    '/test': {
-                        post: {},
-                        parameters: [],
-                    },
-                },
-            };
-            mockGetOperation.mockReturnValue(mockOperation);
-            const result = convertOperationToReplayValue('/test', 'post', mockOpenAPI);
-            const formUrlEncodedMediaType = result?.body?.mediaTypes?.['application/x-www-form-urlencoded'];
-            expect(formUrlEncodedMediaType?.parameters).toBeUndefined();
-        });
-    });
-});
-//# sourceMappingURL=utils.test.js.map

package/lib/components/Request/__tests__/RequestDetails.test.d.ts

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

package/lib/components/Request/__tests__/RequestDetails.test.js

@@ -1,98 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { render, screen, fireEvent } from '@testing-library/react';
-import { RequestDetails } from '../RequestDetails.js';
-import { getField, getMediaContent } from '../../../models/index.js';
-import { normalizeOptions, OpenAPIParser } from '../../../services/index.js';
-import { withTestProviders, TestMemoryRouter } from '../../../testProviders.js';
-const OPERATION_POINTER = '#/paths/~1pets/get';
-// Wide enough that 45 * 45 = 2025 rows blow the 2000-row budget one level after
-// the schema's own properties.
-const WIDTH = 45;
-const SMALL_WIDTH = 44;
-function makeWideProperties(prefix, value, width = WIDTH) {
-    return Object.fromEntries(Array.from({ length: width }, (_, i) => [`${prefix}_${i}`, { ...value }]));
-}
-const definition = {
-    openapi: '3.0.0',
-    info: { title: 'test', version: '0' },
-    paths: {},
-    components: {
-        schemas: {
-            Small: {
-                type: 'object',
-                properties: makeWideProperties('small', { $ref: '#/components/schemas/SmallLeaf' }, SMALL_WIDTH),
-            },
-            SmallLeaf: {
-                type: 'object',
-                properties: makeWideProperties('small_leaf', { type: 'string' }, SMALL_WIDTH),
-            },
-            Big: {
-                type: 'object',
-                properties: makeWideProperties('big', { $ref: '#/components/schemas/BigLeaf' }),
-            },
-            BigLeaf: {
-                type: 'object',
-                properties: makeWideProperties('leaf', { type: 'string' }),
-            },
-        },
-    },
-};
-// The probe replaces the parameters/body tree: it renders a real SubSchema at the
-// level nested parameter nodes actually mount at (PropertyDetails defaults level
-// to 1 and passes level + 1), so the test observes whether "Expand all" reaches
-// parameter nesting.
-vi.mock('../../RequestParameters/index.js', async () => {
-    const { SubSchema } = await import('../../Schema/SubSchema.js');
-    return {
-        RequestParameters: () => (_jsx(SubSchema, { expandByDefault: false, expandable: true, level: 2, propertyLength: WIDTH, deepLink: `${OPERATION_POINTER}/t=request`, operationPointer: OPERATION_POINTER, children: _jsx("div", { "data-testid": "nested-content" }) })),
-    };
-});
-const options = normalizeOptions({});
-const parser = new OpenAPIParser(definition, undefined, options);
-const operationDeps = { operation: { pointer: OPERATION_POINTER } };
-function makeOperation(overrides) {
-    return {
-        id: 'getPets',
-        pointer: OPERATION_POINTER,
-        description: undefined,
-        externalDocs: undefined,
-        extensions: {},
-        security: [],
-        parameters: [],
-        requestBody: undefined,
-        callbackId: '',
-        ...overrides,
-    };
-}
-function renderRequestDetails(operation) {
-    return render(withTestProviders(_jsx(TestMemoryRouter, { children: _jsx(RequestDetails, { operation: operation, translate: (_key, value) => value || _key }) }), { definition }));
-}
-describe('RequestDetails expand-all depth', () => {
-    it('expands parameter nesting one level when the parameter schema fits the budget', () => {
-        const parameter = getField(parser, { name: 'filter', in: 'query', schema: { $ref: '#/components/schemas/Small' } }, '', options, operationDeps);
-        renderRequestDetails(makeOperation({ parameters: [parameter] }));
-        expect(screen.queryByTestId('nested-content')).not.toBeInTheDocument();
-        // A parameter's own property rows render behind a level-2 node (the parameter
-        // row itself is level 1). Showing the 45 properties fits the budget, so
-        // "Expand all" must open the parameter node — not skip parameters entirely.
-        fireEvent.click(screen.getByRole('button', { name: /expand all/i }));
-        expect(screen.getByTestId('nested-content')).toBeInTheDocument();
-    });
-    it('keeps nested body nodes collapsed when their rows exceed the budget', () => {
-        const requestBody = {
-            content: getMediaContent({
-                parser,
-                info: { 'application/json': { schema: { $ref: '#/components/schemas/Big' } } },
-                isRequestType: true,
-                options,
-                data: operationDeps,
-            }),
-        };
-        renderRequestDetails(makeOperation({ requestBody }));
-        // The body root's 45 property rows are always visible; expanding their nested
-        // level-2 nodes would add 2025 rows and blow the budget, so depth stays 1.
-        fireEvent.click(screen.getByRole('button', { name: /expand all/i }));
-        expect(screen.queryByTestId('nested-content')).not.toBeInTheDocument();
-    });
-});
-//# sourceMappingURL=RequestDetails.test.js.map

package/lib/components/RequestSamples/__tests__/Example.test.d.ts

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