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

package/lib/components/RedoclyOpenAPIDocs/__tests__/RedoclyOpenAPIDocs.test.js

@@ -0,0 +1,104 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { parseYaml } from '@redocly/openapi-core';
+import { readFileSync } from 'fs';
+import { render, waitFor } from '@testing-library/react';
+import { vi } from 'vitest';
+import { createElement } from 'react';
+import { MemoryRouter } from 'react-router';
+import { useTelemetry } from '../../../hooks/index.js';
+import { useSetAtom } from 'jotai';
+vi.mock('../../../hooks/useTelemetry');
+vi.mock('../../../hooks/useRouter', () => ({
+    useRouter: () => ({
+        Router: ({ children }) => createElement(MemoryRouter, {}, children),
+        routerProps: {},
+    }),
+}));
+vi.mock('@redocly/theme/core/openapi', async () => {
+    const actual = await vi.importActual('@redocly/theme/core/openapi');
+    return {
+        ...actual,
+        getOperationColor: vi.fn(() => '#007bff'),
+        SearchSessionProvider: ({ children }) => {
+            const mockContextValue = {
+                searchSessionId: 'test-session-id',
+                refreshSearchSessionId: vi.fn(),
+            };
+            const Provider = actual.SearchSessionContext.Provider;
+            return createElement(Provider, { value: mockContextValue, children });
+        },
+    };
+});
+vi.mock('jotai', async () => {
+    const originalJotai = await vi.importActual('jotai');
+    return {
+        ...originalJotai,
+        useSetAtom: vi.fn(),
+    };
+});
+import { RedoclyOpenAPIDocs } from '../RedoclyOpenAPIDocs.js';
+const contents = readFileSync('./playground/openapi/petstore.yaml', 'utf8');
+const definition = parseYaml(contents);
+vi.mock('../../../hooks/useLicense', () => {
+    return {
+        useLicense: () => {
+            return {
+                licenseInfo: { valid: true, allowed: true },
+                isValid: true,
+            };
+        },
+    };
+});
+describe('RedoclyOpenAPIDocs', () => {
+    const options = {};
+    const store = { definition, options };
+    window.scrollTo = vi.fn();
+    const mockTelemetrySend = vi.fn();
+    beforeEach(() => {
+        vi.clearAllMocks();
+        useTelemetry.mockImplementation(() => ({
+            sendViewedMessage: mockTelemetrySend,
+        }));
+        useSetAtom.mockReturnValue(vi.fn());
+    });
+    describe('onLoaded callback', () => {
+        it('should call callback on mount', async () => {
+            const onLoaded = vi.fn();
+            render(_jsx(RedoclyOpenAPIDocs, { store: store, onLoaded: onLoaded }));
+            await waitFor(() => {
+                expect(onLoaded).toHaveBeenCalledTimes(1);
+            }, { timeout: 10_000 });
+        }, 15_000);
+        it('should return null if store is not provided', () => {
+            const { container } = render(_jsx(RedoclyOpenAPIDocs, {}));
+            expect(container.firstChild).toBeNull();
+        });
+        it('should not render sidebar if options.hideSidebar is true', () => {
+            const { queryByRole } = render(_jsx(RedoclyOpenAPIDocs, { store: { ...store, options: { ...options, hideSidebar: true } } }));
+            expect(queryByRole('complementary')).not.toBeInTheDocument();
+        });
+        it('should pass correct props to SidebarLogo when x-logo is defined', () => {
+            const xLogo = {
+                url: 'https://example.com/logo.png',
+                href: 'https://example.com',
+                altText: 'example logo',
+                backgroundColor: '#FFFFFF',
+            };
+            const definitionWithLogo = {
+                ...definition,
+                info: { ...definition.info, 'x-logo': xLogo },
+            };
+            const { getByAltText } = render(_jsx(RedoclyOpenAPIDocs, { store: { ...store, definition: definitionWithLogo } }));
+            const logoImg = getByAltText(xLogo.altText);
+            expect(logoImg.src).toBe(xLogo.url);
+            expect(logoImg.parentElement?.getAttribute('href')).toBe(xLogo.href);
+        });
+        it('should not set operations when hideReplay is true', () => {
+            const setAllOperations = vi.fn();
+            useSetAtom.mockReturnValue(setAllOperations);
+            render(_jsx(RedoclyOpenAPIDocs, { store: { ...store, options: { ...options, hideReplay: true } } }));
+            expect(setAllOperations).not.toHaveBeenCalled();
+        });
+    });
+});
+//# sourceMappingURL=RedoclyOpenAPIDocs.test.js.map

package/lib/components/RenderHook/__tests__/RenderHook.test.d.ts

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

package/lib/components/RenderHook/__tests__/RenderHook.test.js

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/* tslint:disable:no-implicit-dependencies */
+import { render } from '@testing-library/react';
+import { RenderHook } from '../RenderHook.js';
+describe('RenderHook', () => {
+    it('should render correctly', () => {
+        const { container } = render(_jsx(RenderHook, { Hook: ({ someProp }) => ({ html: `<a href='#'>${someProp}</a>` }), props: { someProp: 'text' } }));
+        expect(container.innerHTML).toEqual('<span><a href="#">text</a></span>');
+    });
+    it("should return null if Hook prop isn't defined", () => {
+        const { container } = render(_jsx(RenderHook, { props: { someProp: 'text' } }));
+        expect(container.innerHTML).toEqual('');
+    });
+});
+//# sourceMappingURL=RenderHook.test.js.map

package/lib/components/Replay/__tests__/utils.test.d.ts

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

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

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

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