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

package/lib/components/Download/__tests__/DownloadSpecification.test.js

@@ -0,0 +1,52 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, renderHook } from '@testing-library/react';
+import util from 'util';
+import { DownloadSpecification } from '../DownloadSpecification.js';
+import { useDownloadInfo } from '../useDownloadInfo.js';
+Object.defineProperty(global, 'TextEncoder', {
+    value: util.TextEncoder,
+});
+describe('DownloadSpecification', () => {
+    it('DownloadButton renders correctly without title', () => {
+        const downloadUrls = [
+            {
+                url: 'downloadDefinitionUrlValue.json',
+            },
+            {
+                url: 'downloadDefinitionUrlValue.yaml',
+            },
+            {
+                url: 'downloadDefinitionUrlValue.txt',
+            },
+        ];
+        const { result } = renderHook(() => useDownloadInfo({
+            downloadUrls,
+        }));
+        const downloadObjects = result?.current ?? [];
+        const { container } = render(_jsx(DownloadSpecification, { downloadObjects: downloadObjects }));
+        expect(container).toMatchSnapshot();
+    });
+    it('DownloadButton renders correctly with title', () => {
+        const downloadUrls = [
+            {
+                title: 'OpenAPI Description json format',
+                url: 'downloadDefinitionUrlValue.json',
+            },
+            {
+                title: 'OpenAPI Description yaml format',
+                url: 'downloadDefinitionUrlValue.yaml',
+            },
+            {
+                title: 'OpenAPI Description text format',
+                url: 'downloadDefinitionUrlValue.txt',
+            },
+        ];
+        const { result } = renderHook(() => useDownloadInfo({
+            downloadUrls,
+        }));
+        const downloadObjects = result?.current ?? [];
+        const { container } = render(_jsx(DownloadSpecification, { downloadObjects: downloadObjects }));
+        expect(container).toMatchSnapshot();
+    });
+});
+//# sourceMappingURL=DownloadSpecification.test.js.map

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

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

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

@@ -0,0 +1,60 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useAtom } from 'jotai/index';
+import { render, screen, fireEvent } from '@testing-library/react';
+import { ExpandAllButton } from '../ExpandAllButton.js';
+import { useTranslate, useTelemetry } from '../../../hooks/index.js';
+// Mock the dependencies
+vi.mock('jotai/index', () => ({
+    useAtom: vi.fn(),
+    useAtomValue: vi.fn(),
+    atom: vi.fn(),
+}));
+vi.mock('../../../hooks', () => ({
+    useTranslate: vi.fn(),
+    useTelemetry: vi.fn(), // Add mock for useTelemetry
+}));
+vi.mock('@redocly/theme', () => ({
+    Button: ({ children, ...props }) => _jsx("button", { ...props, children: children }),
+    MaximizeIcon: () => _jsx("span", { "data-testid": "maximize-icon" }),
+}));
+describe('ExpandAllButton', () => {
+    const mockSetOperationState = vi.fn();
+    const mockTranslate = vi.fn((_key, defaultValue) => defaultValue);
+    const mockTelemetrySend = vi.fn();
+    beforeEach(() => {
+        vi.clearAllMocks();
+        useAtom.mockReturnValue([
+            { request: { expandedAll: false }, response: { expandedAll: false } },
+            mockSetOperationState,
+        ]);
+        useTranslate.mockReturnValue(mockTranslate);
+        useTelemetry.mockReturnValue({
+            sendExpandCollapseAllClickedMessage: mockTelemetrySend,
+        });
+    });
+    it('renders correctly with initial state', () => {
+        render(_jsx(ExpandAllButton, { operationPointer: "test", type: "request" }));
+        expect(screen.getByRole('button')).toHaveTextContent('Expand all');
+    });
+    it('toggles state when clicked', () => {
+        render(_jsx(ExpandAllButton, { operationPointer: "test", type: "request" }));
+        fireEvent.click(screen.getByRole('button'));
+        expect(mockSetOperationState).toHaveBeenCalledTimes(1);
+        expect(mockSetOperationState).toHaveBeenCalledWith(expect.any(Object));
+        const updateObject = mockSetOperationState.mock.calls[0][0];
+        expect(updateObject).toEqual({ request: { expandedAll: true } });
+    });
+    it('displays correct text based on expanded state', () => {
+        useAtom.mockReturnValue([
+            { request: { expandedAll: true }, response: { expandedAll: false } },
+            mockSetOperationState,
+        ]);
+        render(_jsx(ExpandAllButton, { operationPointer: "test", type: "request" }));
+        expect(screen.getByRole('button')).toHaveTextContent('Collapse all');
+    });
+    it('uses translate function for button text', () => {
+        render(_jsx(ExpandAllButton, { operationPointer: "test", type: "request" }));
+        expect(mockTranslate).toHaveBeenCalledWith('openapi.expandAll', 'Expand all');
+    });
+});
+//# sourceMappingURL=ExpandAllButton.test.js.map

package/lib/components/ExpandAllButton/__tests__/helpers.test.d.ts

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

package/lib/components/ExpandAllButton/__tests__/helpers.test.js

@@ -0,0 +1,133 @@
+import { parseYaml } from '@redocly/openapi-core';
+import { outdent } from 'outdent';
+import { normalizeOptions, OpenAPIParser } from '../../../services/index.js';
+import { computeExpandAllDepth, MAX_EXPAND_ALL_DEPTH } from '../helpers.js';
+const options = normalizeOptions({});
+function makeParser(spec) {
+    return new OpenAPIParser(spec, undefined, options);
+}
+function asModel(rawSchema) {
+    return { schema: rawSchema, rawSchema };
+}
+describe('computeExpandAllDepth', () => {
+    test('returns the ceiling for small schemas', () => {
+        const spec = parseYaml(outdent `
+      openapi: 3.0.0
+      components:
+        schemas:
+          User:
+            type: object
+            properties:
+              name:
+                type: string
+              address:
+                type: object
+                properties:
+                  city:
+                    type: string
+    `);
+        const parser = makeParser(spec);
+        expect(computeExpandAllDepth(parser, [asModel(spec.components.schemas.User)])).toBe(MAX_EXPAND_ALL_DEPTH);
+    });
+    test('clamps the depth for schemas that unfold exponentially', () => {
+        // Each level references the same node 5 times -> 5^level rows.
+        const spec = parseYaml(outdent `
+      openapi: 3.0.0
+      components:
+        schemas:
+          Node:
+            type: object
+            properties:
+              a:
+                $ref: '#/components/schemas/Node'
+              b:
+                $ref: '#/components/schemas/Node'
+              c:
+                $ref: '#/components/schemas/Node'
+              d:
+                $ref: '#/components/schemas/Node'
+              e:
+                $ref: '#/components/schemas/Node'
+    `);
+        const parser = makeParser(spec);
+        const depth = computeExpandAllDepth(parser, [asModel(spec.components.schemas.Node)], 100);
+        // 5 + 25 + 125 = 155 > 100 -> depth 2
+        expect(depth).toBe(2);
+    });
+    test('expands at least one level even when the first level exceeds the budget', () => {
+        const properties = Object.fromEntries(Array.from({ length: 50 }, (_, i) => [`p${i}`, { type: 'object' }]));
+        const parser = makeParser({ openapi: '3.0.0', components: {} });
+        expect(computeExpandAllDepth(parser, [asModel({ type: 'object', properties })], 10)).toBe(1);
+    });
+    test('counts rows through allOf, oneOf active variant, and array items', () => {
+        const spec = parseYaml(outdent `
+      openapi: 3.0.0
+      components:
+        schemas:
+          Wrapped:
+            type: object
+            properties:
+              list:
+                type: array
+                items:
+                  allOf:
+                    - type: object
+                      properties:
+                        first:
+                          type: string
+                    - type: object
+                      properties:
+                        second:
+                          oneOf:
+                            - type: object
+                              properties:
+                                variantField:
+                                  type: string
+                            - type: object
+                              properties:
+                                otherA:
+                                  type: string
+                                otherB:
+                                  type: string
+    `);
+        const parser = makeParser(spec);
+        const root = asModel(spec.components.schemas.Wrapped);
+        // level 1: list (1 row); level 2: first + second (cum 3); level 3: variantField (oneOf[0] only, cum 4)
+        expect(computeExpandAllDepth(parser, [root], 4)).toBe(MAX_EXPAND_ALL_DEPTH);
+        expect(computeExpandAllDepth(parser, [root], 3)).toBe(2);
+        expect(computeExpandAllDepth(parser, [root], 2)).toBe(1);
+    });
+    test('counts additionalProperties and unevaluatedProperties as rows (mirrors buildFields)', () => {
+        const parser = makeParser({ openapi: '3.0.0', components: {} });
+        // 9 named properties + 1 `additionalProperties: true` row = 10 rows > budget 9
+        const properties = Object.fromEntries(Array.from({ length: 9 }, (_, i) => [`p${i}`, { type: 'string' }]));
+        expect(computeExpandAllDepth(parser, [asModel({ type: 'object', properties, additionalProperties: true })], 9)).toBe(1);
+        expect(computeExpandAllDepth(parser, [asModel({ type: 'object', properties, unevaluatedProperties: { type: 'string' } })], 9)).toBe(1);
+        // Without them the 9 properties fit the budget.
+        expect(computeExpandAllDepth(parser, [asModel({ type: 'object', properties })], 9)).toBe(MAX_EXPAND_ALL_DEPTH);
+    });
+    test('is resilient to missing parser or schemas', () => {
+        expect(computeExpandAllDepth(undefined, [])).toBe(MAX_EXPAND_ALL_DEPTH);
+        expect(computeExpandAllDepth({}, [])).toBe(MAX_EXPAND_ALL_DEPTH);
+        expect(computeExpandAllDepth(makeParser({ openapi: '3.0.0' }), [undefined])).toBe(MAX_EXPAND_ALL_DEPTH);
+    });
+    test('does not hang on self-referencing (cyclic) schemas', () => {
+        const spec = parseYaml(outdent `
+      openapi: 3.0.0
+      components:
+        schemas:
+          Cyclic:
+            type: object
+            properties:
+              self:
+                $ref: '#/components/schemas/Cyclic'
+              name:
+                type: string
+    `);
+        const parser = makeParser(spec);
+        const depth = computeExpandAllDepth(parser, [asModel(spec.components.schemas.Cyclic)]);
+        expect(depth).toBeGreaterThanOrEqual(1);
+        expect(depth).toBeLessThanOrEqual(MAX_EXPAND_ALL_DEPTH);
+    });
+});
+//# sourceMappingURL=helpers.test.js.map

package/lib/components/Language/__tests__/LanguageDropdown.test.d.ts

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

package/lib/components/Language/__tests__/LanguageDropdown.test.js

@@ -0,0 +1,23 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, fireEvent, screen } from '@testing-library/react';
+import { LanguageDropdown } from '../LanguageDropdown.js';
+const mockSamples = [
+    { key: 'js', title: 'JS', lang: 'js' },
+    { key: 'node.js', title: 'Node.JS', lang: 'nodejs' },
+];
+const mockActiveTab = mockSamples[0].key;
+const mockOnChange = vi.fn();
+describe('LanguageDropdown', () => {
+    test('LanguageDropdown renders correctly', () => {
+        const { getAllByText } = render(_jsx(LanguageDropdown, { samples: mockSamples, activeTab: mockActiveTab, onChange: mockOnChange }));
+        expect(getAllByText(mockSamples[0].title)[0]).toBeInTheDocument();
+    });
+    test('LanguageDropdown handles onChange correctly', () => {
+        const { getAllByText } = render(_jsx(LanguageDropdown, { samples: mockSamples, activeTab: mockActiveTab, onChange: mockOnChange }));
+        fireEvent.click(screen.getAllByText(mockSamples[0].title)[0]);
+        const otherLanguage = mockSamples[1];
+        fireEvent.click(getAllByText(otherLanguage.title)[0]);
+        expect(mockOnChange).toHaveBeenCalledWith(otherLanguage.key);
+    });
+});
+//# sourceMappingURL=LanguageDropdown.test.js.map

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

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

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

@@ -0,0 +1,34 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+import * as Jotai from 'jotai/index';
+import { normalizeOptions } from '../../../services/index.js';
+import { Markdown } from '../Markdown.js';
+import { withTestProviders } from '../../../testProviders.js';
+vi.mock('jotai', async () => ({
+    ...(await vi.importActual('jotai')),
+    useAtomValue: vi.fn(),
+}));
+describe('Components', () => {
+    describe('Markdown', () => {
+        beforeEach(() => {
+            vi.clearAllMocks();
+        });
+        test('Markdown renders correctly', () => {
+            const { getByText } = render(withTestProviders(_jsx(Markdown, { source: `# Heading 1\n\n[link](https://google.com)` })));
+            expect(getByText('Heading 1')).toBeInTheDocument();
+            expect(getByText('link')).toBeInTheDocument();
+            expect(getByText('link').closest('a')).toHaveAttribute('href', 'https://google.com');
+        });
+        test('Markdown custom sanitize works', () => {
+            const options = normalizeOptions({
+                unstable_hooks: { sanitize: (str) => str.replace('bad word', '**') },
+            });
+            vi.spyOn(Jotai, 'useAtomValue').mockImplementation(() => {
+                return options;
+            });
+            const { getByText } = render(withTestProviders(_jsx(Markdown, { source: `# Heading 1\n\n[link](https://google.com)\nbad word` })));
+            expect(getByText(/\*\*/)).toBeInTheDocument();
+        });
+    });
+});
+//# sourceMappingURL=Markdown.test.js.map

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

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

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

@@ -0,0 +1,66 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { act, fireEvent, render, screen } from '@testing-library/react';
+import { vi } from 'vitest';
+import { McpOverview } from '../McpOverview.js';
+import { withTestProviders, TestMemoryRouter } from '../../../testProviders.js';
+import mcpInfo from './fixtures/mcp-info.json';
+describe('McpOverview', () => {
+    it('should render mcp overview', () => {
+        render(withTestProviders(_jsx(TestMemoryRouter, { children: _jsx(McpOverview, { mcpInfo: mcpInfo, mcpServers: [{ url: 'https://api.example.com/mcp' }] }) })));
+        expect(screen.getByText('Protocol version')).toBeInTheDocument();
+        expect(screen.getByText('1.0.0')).toBeInTheDocument();
+        expect(screen.getByText('Capabilities')).toBeInTheDocument();
+        expect(screen.queryByText('tool_code_interpreter')).not.toBeInTheDocument();
+        expect(screen.queryByText('tool_image_generation')).not.toBeInTheDocument();
+        expect(screen.getByText('Endpoint')).toBeInTheDocument();
+        expect(screen.getByText('https://api.example.com/mcp')).toBeInTheDocument();
+    });
+    it('should render experimental capabilities', () => {
+        render(withTestProviders(_jsx(TestMemoryRouter, { children: _jsx(McpOverview, { mcpInfo: mcpInfo, mcpServers: [{ url: 'https://api.example.com/mcp' }] }) })));
+        expect(screen.getByText('Experimental capabilities')).toBeInTheDocument();
+        expect(screen.getByText('a:')).toBeInTheDocument();
+        expect(screen.getByText('true')).toBeInTheDocument();
+    });
+    it('should keep endpoint variables visible while resolving the Cursor deeplink url', async () => {
+        const openSpy = vi.spyOn(window, 'open').mockImplementation(() => null);
+        render(withTestProviders(_jsx(TestMemoryRouter, { children: _jsx(McpOverview, { mcpInfo: mcpInfo, mcpServers: [
+                    {
+                        url: 'https://{projectHost}/mcp',
+                        variables: {
+                            projectHost: {
+                                default: 'redocly.com',
+                            },
+                        },
+                    },
+                ] }) })));
+        expect(screen.getByText('https://{projectHost}/mcp')).toBeInTheDocument();
+        await act(async () => {
+            fireEvent.click(screen.getByRole('button', { name: 'Connect to Cursor' }));
+        });
+        expect(openSpy).toHaveBeenCalledWith(expect.any(String), '_blank');
+        const deeplink = String(openSpy.mock.calls[0][0]);
+        const cursorUrl = new URL(deeplink);
+        const encodedConfig = cursorUrl.searchParams.get('config');
+        const decodedConfig = JSON.parse(Buffer.from(encodedConfig || '', 'base64').toString('utf-8'));
+        expect(decodedConfig).toEqual({
+            url: 'https://redocly.com/mcp',
+            description: 'MCP Server',
+        });
+        openSpy.mockRestore();
+    });
+    it('should render capabilities with listChanged and subscribe', () => {
+        const mcpInfoWithExtras = {
+            ...mcpInfo,
+            capabilities: {
+                ...mcpInfo.capabilities,
+                tools: {
+                    listChanged: true,
+                    subscribe: true,
+                },
+            },
+        };
+        render(withTestProviders(_jsx(TestMemoryRouter, { children: _jsx(McpOverview, { mcpInfo: mcpInfoWithExtras, mcpServers: [{ url: 'https://api.example.com/mcp' }] }) })));
+        expect(screen.getByText(/tools \(list changed\) \(subscribe\)/)).toBeInTheDocument();
+    });
+});
+//# sourceMappingURL=McpOverview.test.js.map

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