@redocly/openapi-docs 3.24.0 → 3.24.1

package/lib/components/McpTool/__tests__/McpPrompt.test.d.ts

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

package/lib/components/McpTool/__tests__/McpPrompt.test.js

@@ -0,0 +1,57 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, screen } from '@testing-library/react';
+import { McpPrompt } from '../McpPrompt.js';
+import { withTestProviders, TestMemoryRouter } from '../../../testProviders.js';
+const spec = {
+    openapi: '3.0.0',
+    'x-mcp': {
+        prompts: [
+            {
+                name: 'test-prompt',
+                description: 'A test prompt',
+                arguments: [
+                    {
+                        name: 'arg1',
+                        description: 'First argument',
+                        required: true,
+                        example: 'value1',
+                    },
+                ],
+                security: [
+                    {
+                        apiKey: [],
+                    },
+                ],
+            },
+        ],
+    },
+    components: {
+        securitySchemes: {
+            apiKey: {
+                type: 'apiKey',
+                in: 'header',
+                name: 'X-API-Key',
+            },
+        },
+    },
+};
+describe('McpPrompt', () => {
+    it('should render mcp prompt with arguments', () => {
+        render(withTestProviders(_jsx(TestMemoryRouter, { children: _jsx(McpPrompt, { name: "test-prompt", id: "test-prompt" }) }), {
+            definition: spec,
+            options: {},
+        }));
+        expect(screen.getByText('Arguments')).toBeInTheDocument();
+        expect(screen.getByText('arg1')).toBeInTheDocument();
+        expect(screen.getByText('Security')).toBeInTheDocument();
+        expect(screen.getByText('apiKey')).toBeInTheDocument();
+    });
+    it('should return null if prompt not found', () => {
+        const { container } = render(withTestProviders(_jsx(TestMemoryRouter, { children: _jsx(McpPrompt, { name: "not-found", id: "not-found" }) }), {
+            definition: spec,
+            options: {},
+        }));
+        expect(container.firstChild).toBeNull();
+    });
+});
+//# sourceMappingURL=McpPrompt.test.js.map

package/lib/components/McpTool/__tests__/McpResource.test.d.ts

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

package/lib/components/McpTool/__tests__/McpResource.test.js

@@ -0,0 +1,81 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, screen, fireEvent, waitFor } from '@testing-library/react';
+import { vi } from 'vitest';
+import { McpResource } from '../McpResource.js';
+import { withTestProviders, TestMemoryRouter } from '../../../testProviders.js';
+const spec = {
+    openapi: '3.0.0',
+    'x-mcp': {
+        resources: [
+            {
+                name: 'test-resource',
+                uri: 'mcp://test-resource',
+                mimeType: 'application/json',
+                text: '{"key": "value"}',
+                security: [
+                    {
+                        apiKey: [],
+                    },
+                ],
+            },
+        ],
+    },
+    components: {
+        securitySchemes: {
+            apiKey: {
+                type: 'apiKey',
+                in: 'header',
+                name: 'X-API-Key',
+            },
+        },
+    },
+};
+// Mock navigator.clipboard
+const mockClipboard = {
+    writeText: vi.fn(),
+};
+Object.assign(navigator, {
+    clipboard: mockClipboard,
+});
+describe('McpResource', () => {
+    beforeAll(() => {
+        mockClipboard.writeText.mockImplementation(() => Promise.resolve());
+    });
+    afterEach(() => {
+        vi.clearAllMocks();
+    });
+    it('should render mcp resource with content', () => {
+        render(withTestProviders(_jsx(TestMemoryRouter, { children: _jsx(McpResource, { name: "test-resource", id: "test-resource" }) }), {
+            definition: spec,
+            options: {},
+        }));
+        expect(screen.getByText('Resource URI:')).toBeInTheDocument();
+        expect(screen.getByText('mcp://test-resource')).toBeInTheDocument();
+        expect(screen.getByText('Resource MIME type:')).toBeInTheDocument();
+        expect(screen.getAllByText('application/json').length).toBeGreaterThanOrEqual(1);
+        expect(screen.getByText('Resource content')).toBeInTheDocument();
+        expect(screen.getByText(/"key": "value"/)).toBeInTheDocument();
+        expect(screen.getByText('Security')).toBeInTheDocument();
+        expect(screen.getByText('apiKey')).toBeInTheDocument();
+    });
+    it('should render a message if resource not found', () => {
+        render(withTestProviders(_jsx(TestMemoryRouter, { children: _jsx(McpResource, { name: "not-found", id: "not-found" }) }), {
+            definition: spec,
+            options: {},
+        }));
+        expect(screen.getByText('Resource not found: not-found')).toBeInTheDocument();
+    });
+    it('should copy URI to clipboard when clicked', async () => {
+        render(withTestProviders(_jsx(TestMemoryRouter, { children: _jsx(McpResource, { name: "test-resource", id: "test-resource" }) }), {
+            definition: spec,
+            options: {},
+        }));
+        const uriElement = screen.getByText('mcp://test-resource');
+        fireEvent.click(uriElement);
+        expect(mockClipboard.writeText).toHaveBeenCalledWith('mcp://test-resource');
+        await waitFor(() => {
+            expect(screen.getByText('✓ Copied!')).toBeInTheDocument();
+        });
+    });
+});
+//# sourceMappingURL=McpResource.test.js.map

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

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

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

@@ -0,0 +1,82 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, screen } from '@testing-library/react';
+import { McpTool } from '../McpTool.js';
+import { withTestProviders, TestMemoryRouter } from '../../../testProviders.js';
+import mcpData from './fixtures/mcp-tools.json';
+const spec = {
+    openapi: '3.0.0',
+    'x-mcp': mcpData,
+    components: {
+        securitySchemes: {
+            apiKey: {
+                type: 'apiKey',
+                in: 'header',
+                name: 'X-API-Key',
+            },
+        },
+    },
+};
+describe('McpTool', () => {
+    it('should render mcp tool with input and output schema', () => {
+        render(withTestProviders(_jsx(TestMemoryRouter, { children: _jsx(McpTool, { name: "test-tool", id: "test-tool" }) }), {
+            definition: spec,
+            options: {},
+        }));
+        expect(screen.getByText('Input schema')).toBeInTheDocument();
+        expect(screen.getByText('inputProperty')).toBeInTheDocument();
+        expect(screen.getByText('Output schema')).toBeInTheDocument();
+        expect(screen.getByText('outputProperty')).toBeInTheDocument();
+        expect(screen.getByText('Security')).toBeInTheDocument();
+        expect(screen.getByText('apiKey')).toBeInTheDocument();
+    });
+    it('should render a message if tool not found', () => {
+        render(withTestProviders(_jsx(TestMemoryRouter, { children: _jsx(McpTool, { name: "not-found", id: "not-found" }) }), {
+            definition: spec,
+            options: {},
+        }));
+        expect(screen.getByText('Tool not found: not-found')).toBeInTheDocument();
+    });
+    it('should render without output schema', () => {
+        const specWithoutOutput = {
+            ...spec,
+            'x-mcp': {
+                ...spec['x-mcp'],
+                tools: [
+                    {
+                        name: 'test-tool-no-output',
+                        description: 'A test tool without output schema',
+                        inputSchema: {
+                            type: 'object',
+                            properties: {
+                                inputProperty: {
+                                    type: 'string',
+                                },
+                            },
+                        },
+                    },
+                ],
+            },
+        };
+        render(withTestProviders(_jsx(TestMemoryRouter, { children: _jsx(McpTool, { name: "test-tool-no-output", id: "test-tool-no-output" }) }), {
+            definition: specWithoutOutput,
+            options: {},
+        }));
+        expect(screen.getByText('Input schema')).toBeInTheDocument();
+        expect(screen.queryByText('Output schema')).not.toBeInTheDocument();
+    });
+    it('should apply middle panel horizontal padding overrides', () => {
+        const { container } = render(withTestProviders(_jsx(TestMemoryRouter, { children: _jsx(McpTool, { name: "test-tool", id: "test-tool" }) }), {
+            definition: spec,
+            options: {},
+        }));
+        const middlePanel = container.querySelector('.mcp-tool > div > div');
+        expect(middlePanel).toBeTruthy();
+        expect(middlePanel).toHaveStyle({ paddingLeft: '0px' });
+        const styles = Array.from(document.querySelectorAll('style'))
+            .map((tag) => tag.textContent ?? '')
+            .join('\n');
+        expect(styles).toMatch(/padding-left:\s*0/);
+        expect(styles).toMatch(/padding-right:\s*var\(--panel-gap-horizontal\)/);
+    });
+});
+//# sourceMappingURL=McpTool.test.js.map

package/lib/components/MediaTypeSwitch/__tests__/MediaTypesSwitch.test.d.ts

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

package/lib/components/MediaTypeSwitch/__tests__/MediaTypesSwitch.test.js

@@ -0,0 +1,79 @@
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { act, render } from '@testing-library/react';
+import { MediaTypesSwitch } from '../MediaTypesSwitch.js';
+import { getOperation } from '../../../models/index.js';
+import { normalizeOptions, OpenAPIParser } from '../../../services/index.js';
+import testDefinition from './fixtures/test-definition.json';
+import { withTestProviders } from '../../../testProviders.js';
+describe('Components', () => {
+    describe('MediaTypesSwitch', () => {
+        const options = normalizeOptions({});
+        const parser = new OpenAPIParser(testDefinition, undefined, options);
+        let operation;
+        beforeEach(() => {
+            operation = getOperation(parser, {
+                pointer: '#/paths/~1test/get',
+                pathName: '/test',
+                httpVerb: 'GET',
+                pathParameters: [],
+                pathServers: [],
+                isWebhook: false,
+                isAdditionalOperation: false,
+                ...testDefinition.paths['/test'].get,
+            }, undefined, options, '');
+        });
+        test('renders with default media type by default', () => {
+            const childrenFn = vi.fn((mimeType) => _jsxs(_Fragment, { children: ["children: ", mimeType.name] }));
+            const renderSelectFn = vi.fn(() => null);
+            const { getByText } = render(withTestProviders(_jsx(MediaTypesSwitch, { renderSelect: renderSelectFn, content: operation.requestBody?.content, children: childrenFn }), { definition: parser.definition }));
+            expect(renderSelectFn.mock.calls[0][0].options).toEqual([
+                { idx: 0, value: 'application/json' },
+                { idx: 1, value: 'application/xml' },
+            ]);
+            expect(getByText('children: application/json')).toBeInTheDocument();
+        });
+        test('withLabel renders label', () => {
+            const childrenFn = vi.fn((mimeType) => _jsxs(_Fragment, { children: ["children: ", mimeType.name] }));
+            const renderSelectFn = vi.fn(() => _jsx(_Fragment, { children: "dropdown" }));
+            const { getByText } = render(withTestProviders(_jsx(MediaTypesSwitch, { withLabel: true, renderSelect: renderSelectFn, content: operation.requestBody?.content, children: childrenFn }), { definition: parser.definition }));
+            expect(getByText('Content type')).toBeInTheDocument();
+        });
+        test('should try to restore scroll on switch', async () => {
+            const childrenFn = vi.fn((mimeType) => _jsxs(_Fragment, { children: ["children: ", mimeType.name] }));
+            const renderSelectFn = vi.fn(() => (_jsx(_Fragment, { children: "dropdown" })));
+            const { findByText, container } = render(withTestProviders(_jsx(MediaTypesSwitch, { withLabel: true, renderSelect: renderSelectFn, content: operation.requestBody?.content, children: childrenFn }), { definition: parser.definition }));
+            // Create a mock implementation of window.scrollBy
+            const scrollByMock = vi.fn();
+            Object.defineProperty(window, 'scrollBy', { value: scrollByMock });
+            const rectMock = vi.fn(() => {
+                return (rectMock.mock.calls.length > 1 ? { y: 150 } : { y: 100 });
+            });
+            vi.spyOn(container?.firstElementChild, 'getBoundingClientRect').mockImplementation(rectMock);
+            act(() => {
+                const selectProps = renderSelectFn.mock.calls[0][0];
+                selectProps.onChange(selectProps.options[1]);
+            });
+            await findByText('children: application/xml');
+            await new Promise((resolve) => setTimeout(resolve, 500)); // sleep
+            expect(rectMock).toHaveBeenCalledTimes(2);
+            expect(scrollByMock).toHaveBeenCalledWith(0, 50);
+        });
+        test('should not throw and render null for empty media types', () => {
+            const childrenFn = vi.fn((mimeType) => _jsxs(_Fragment, { children: ["children: ", mimeType.name] }));
+            const renderSelectFn = vi.fn(() => null);
+            const { container } = render(withTestProviders(_jsx(MediaTypesSwitch, { renderSelect: renderSelectFn, 
+                // @ts-ignore invalid content shape
+                content: null, children: childrenFn }), { definition: parser.definition }));
+            expect(container.firstChild).toBeNull();
+            const { container: container2 } = render(withTestProviders(_jsx(MediaTypesSwitch, { renderSelect: renderSelectFn, 
+                // @ts-expect-error invalid content shape
+                content: { mediaTypes: null }, children: childrenFn }), { definition: parser.definition }));
+            expect(container2.firstChild).toBeNull();
+            const { container: container3 } = render(withTestProviders(_jsx(MediaTypesSwitch, { renderSelect: renderSelectFn, 
+                // @ts-expect-error invalid content shape
+                content: { mediaTypes: [] }, children: childrenFn }), { definition: parser.definition }));
+            expect(container3.firstChild).toBeNull();
+        });
+    });
+});
+//# sourceMappingURL=MediaTypesSwitch.test.js.map

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

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

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

@@ -0,0 +1,70 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+import { OperationItem } from '../OperationItem.js';
+import { normalizeOptions } from '../../../services/index.js';
+import spec from './fixtures/petstore.json';
+import definition from './fixtures/operationDefinition.json';
+import { environmentAtom } from '../../../jotai/app.js';
+import { globalStoreAtom } from '../../../jotai/store.js';
+import { allOperationsAtom } from '../../../jotai/replay.js';
+import { MockIntersectionObserver } from './__mocks__/mock-intersection-observer.js';
+import { TestBrowserRouter } from '../../../testProviders.js';
+vi.mock('jotai', async () => ({
+    ...(await vi.importActual('jotai')),
+    useAtomValue: vi.fn((a) => {
+        if (a === globalStoreAtom) {
+            return {
+                parser: {
+                    definition: spec,
+                },
+                options: normalizeOptions({
+                    codeSamples: {
+                        languages: [{ lang: 'curl', label: 'curl' }],
+                    },
+                }),
+            };
+        }
+        if (a === environmentAtom) {
+            return [{}, ''];
+        }
+        if (a === allOperationsAtom) {
+            return [];
+        }
+        return {};
+    }),
+    useAtom: vi.fn((a) => {
+        if (a === environmentAtom) {
+            return [[{ server: {} }], vi.fn()];
+        }
+        return [
+            {
+                activeOneOf: { '/paths/~1pet/post': 0 },
+                requestValues: {},
+                request: { expandedFields: {} },
+                response: { expandedFields: {} },
+                activeLanguage: 'curl',
+            },
+            vi.fn(),
+        ];
+    }),
+}));
+describe('OperationItem', () => {
+    beforeAll(() => {
+        window.IntersectionObserver = MockIntersectionObserver;
+    });
+    it('should render badges with correct position', () => {
+        const { getByTestId } = render(_jsx(OperationItem, { item: {
+                operationDefinition: definition,
+                parent: undefined,
+                href: 'test',
+            } }), {
+            wrapper: TestBrowserRouter,
+        });
+        const parentElement = getByTestId('operation-item-header');
+        const childNodes = parentElement.childNodes;
+        expect(childNodes[1].textContent).toBe('Alpha');
+        expect(childNodes[3].textContent).toBe('Beta');
+        expect(childNodes[4].textContent).toBe('Gamma');
+    });
+});
+//# sourceMappingURL=OperationItem.test.js.map

package/lib/components/OperationItem/__tests__/__mocks__/mock-intersection-observer.d.ts

@@ -0,0 +1,16 @@
+export declare class MockIntersectionObserver {
+    readonly root: Element | Document | null;
+    readonly rootMargin: string;
+    readonly scrollMargin: string;
+    readonly thresholds: ReadonlyArray<number>;
+    private viewPort;
+    private entries;
+    private readonly callback;
+    constructor(callback: IntersectionObserverCallback, options?: IntersectionObserverInit);
+    private intersect;
+    isInViewPort(target: HTMLElement): boolean;
+    observe(target: HTMLElement): void;
+    unobserve(target: HTMLElement): void;
+    disconnect(): void;
+    takeRecords(): any[];
+}

package/lib/components/OperationItem/__tests__/__mocks__/mock-intersection-observer.js

@@ -0,0 +1,42 @@
+export class MockIntersectionObserver {
+    root;
+    rootMargin;
+    scrollMargin;
+    thresholds;
+    viewPort;
+    entries;
+    callback;
+    constructor(callback, options) {
+        this.viewPort = options?.root ? options.root : window;
+        this.entries = [];
+        this.root = null;
+        this.rootMargin = '0px';
+        this.scrollMargin = '';
+        this.thresholds = [1];
+        this.callback = callback;
+        this.viewPort.addEventListener('scroll', this.intersect);
+    }
+    intersect = () => {
+        this.entries.map((entry) => {
+            entry.isIntersecting = this.isInViewPort(entry.target);
+        });
+        this.callback(this.entries, this);
+    };
+    isInViewPort(target) {
+        return target.id !== 'toc-0';
+    }
+    observe(target) {
+        this.entries.push({ isIntersecting: false, target });
+    }
+    unobserve(target) {
+        this.entries = this.entries.filter((ob) => ob.target !== target);
+    }
+    disconnect() {
+        this.viewPort.removeEventListener('scroll', this.intersect);
+        this.entries = [];
+    }
+    takeRecords() {
+        return this.entries;
+    }
+}
+//# sourceMappingURL=mock-intersection-observer.js.map

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

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

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

@@ -0,0 +1,59 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+import { Overview } from '../Overview.js';
+const mockTranslate = (key, defaultValue) => defaultValue || key;
+describe('Overview', () => {
+    it('should render correctly with full data', () => {
+        const info = {
+            title: 'Test API',
+            version: '1.0.0',
+            description: 'Test description',
+            contact: {
+                name: 'Test Contact',
+                url: 'https://example.com',
+                email: 'test@example.com',
+            },
+            license: {
+                name: 'MIT',
+                url: 'https://opensource.org/licenses/MIT',
+                identifier: 'MIT',
+            },
+            termsOfService: 'https://example.com/terms',
+        };
+        const { container } = render(_jsx(Overview, { info: info, translate: mockTranslate }));
+        expect(container).toMatchSnapshot();
+    });
+    it('should render correctly with partial data', () => {
+        const info = {
+            title: 'Test API',
+            version: '1.0.0',
+        };
+        const { container } = render(_jsx(Overview, { info: info, translate: mockTranslate }));
+        expect(container).toMatchSnapshot();
+    });
+    it('should render correctly with contact data but without a name', () => {
+        const info = {
+            title: 'Test API',
+            version: '1.0.0',
+            contact: {
+                url: 'https://example.com',
+                email: 'test@example.com',
+            },
+        };
+        const { container } = render(_jsx(Overview, { info: info, translate: mockTranslate }));
+        expect(container).toMatchSnapshot();
+    });
+    it('should render license with name and url when identifier is not present', () => {
+        const info = {
+            title: 'Test API',
+            version: '1.0.0',
+            license: {
+                name: 'Apache 2.0',
+                url: 'https://www.apache.org/licenses/LICENSE-2.0.html',
+            },
+        };
+        const { container } = render(_jsx(Overview, { info: info, translate: mockTranslate }));
+        expect(container).toMatchSnapshot();
+    });
+});
+//# sourceMappingURL=Overview.test.js.map

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

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

package/lib/components/PayloadSamples/__tests__/Example.test.js

@@ -0,0 +1,36 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+import * as Jotai from 'jotai';
+import { Example } from '../Example.js';
+import { normalizeOptions, OpenAPIParser } from '../../../services/index.js';
+import { getExamples } from '../../../models/index.js';
+import testDefinition from './fixtures/mediaTypeUrlencoded.json';
+describe('Example component', () => {
+    const opts = normalizeOptions({});
+    const parser = new OpenAPIParser(testDefinition, undefined, opts);
+    it('render component without error when `externalValue` is pdf file', () => {
+        const example = getExamples({
+            parser,
+            infoOrRef: {
+                summary: 'A sample file',
+                externalValue: 'https://assets.identi.tech/dummy.pdf',
+            },
+            mime: 'application/pdf',
+        });
+        const { container } = render(_jsx(Jotai.Provider, { children: _jsx(Example, { example: example, mimeType: example.mime, onCopyClick: vi.fn() }) }));
+        expect(container).toMatchSnapshot();
+    });
+    it('render component with `externalValue`', () => {
+        const example = getExamples({
+            parser,
+            infoOrRef: {
+                summary: 'A sample json',
+                externalValue: 'https://jsonplaceholder.typicode.com/todos/1',
+            },
+            mime: 'application/json',
+        });
+        const { container } = render(_jsx(Jotai.Provider, { children: _jsx(Example, { example: example, mimeType: example.mime, onCopyClick: vi.fn() }) }));
+        expect(container).toMatchSnapshot();
+    });
+});
+//# sourceMappingURL=Example.test.js.map

package/lib/components/PayloadSamples/__tests__/ExampleValue.test.d.ts

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