@redocly/openapi-docs 3.24.0 → 3.24.1

package/lib/components/ContentItems/__tests__/Items.test.js

@@ -0,0 +1,66 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { render, screen } from '@testing-library/react';
+import { Items } from '../Items.js';
+import { TestMemoryRouter } from '../../../testProviders.js';
+vi.mock('../../ContentItem', () => ({
+    ContentItem: ({ children, item }) => (_jsxs("div", { "data-testid": `content-item-${item.id}`, children: [item.title, children] })),
+}));
+vi.mock('../VirtualList', () => ({
+    VirtualList: ({ items }) => (_jsx("div", { "data-testid": "virtual-list", children: items.map((item) => (_jsx("div", { children: item.title }, item.id))) })),
+}));
+const mockItems = [
+    { id: '1', title: 'Item 1', type: 'group', items: [] },
+    { id: '2', title: 'Item 2', type: 'group', items: [] },
+];
+const mockMixedTypeItems = Array.from({ length: 16 }, (_, i) => ({
+    id: `mixed-${i}`,
+    title: `Item ${i}`,
+    type: i % 2 === 0 ? 'operation' : 'schema',
+    items: [],
+}));
+const mockOperationItems = Array.from({ length: 16 }, (_, i) => ({
+    id: `op-${i}`,
+    title: `Operation ${i}`,
+    type: 'operation',
+    items: [],
+}));
+describe('Items', () => {
+    const renderWithRouter = (component) => {
+        return render(_jsx(TestMemoryRouter, { children: component }));
+    };
+    it('renders null when items array is empty', () => {
+        const { container } = renderWithRouter(_jsx(Items, { items: [], routingBasePath: "/docs" }));
+        expect(container.firstChild).toBeNull();
+    });
+    it('renders regular list for less than 10 items', () => {
+        renderWithRouter(_jsx(Items, { items: mockItems, routingBasePath: "/docs" }));
+        expect(screen.getByTestId('content-item-1')).toBeInTheDocument();
+        expect(screen.getByTestId('content-item-2')).toBeInTheDocument();
+        expect(screen.queryByTestId('virtual-list')).not.toBeInTheDocument();
+    });
+    it('renders VirtualList for more than 15 operation items', () => {
+        renderWithRouter(_jsx(Items, { items: mockOperationItems, routingBasePath: "/docs" }));
+        expect(screen.getByTestId('virtual-list')).toBeInTheDocument();
+        expect(screen.queryByTestId('content-item-1')).not.toBeInTheDocument();
+    });
+    it('renders VirtualList for more than 15 mixed operation and schema items', () => {
+        renderWithRouter(_jsx(Items, { items: mockMixedTypeItems, routingBasePath: "/docs" }));
+        expect(screen.getByTestId('virtual-list')).toBeInTheDocument();
+        expect(screen.queryByTestId('content-item-mixed-0')).not.toBeInTheDocument();
+    });
+    it('renders nested items correctly', () => {
+        const nestedItems = [
+            {
+                id: '1',
+                title: 'Parent',
+                type: 'group',
+                items: [{ id: '1-1', title: 'Child', type: 'group', items: [] }],
+            },
+        ];
+        renderWithRouter(_jsx(Items, { items: nestedItems, routingBasePath: "/docs" }));
+        expect(screen.getByTestId('content-item-1')).toBeInTheDocument();
+        expect(screen.getByText('Parent')).toBeInTheDocument();
+        expect(screen.getByText('Child')).toBeInTheDocument();
+    });
+});
+//# sourceMappingURL=Items.test.js.map

package/lib/components/ContentItems/__tests__/VirtualList.test.d.ts

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

package/lib/components/ContentItems/__tests__/VirtualList.test.js

@@ -0,0 +1,135 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, screen } from '@testing-library/react';
+import { Routes, Route } from 'react-router';
+import { act } from 'react';
+import { VirtualList } from '../VirtualList.js';
+import { TestMemoryRouter } from '../../../testProviders.js';
+const mockItems = [
+    { href: '/item1', title: 'Item 1' },
+    { href: '/item2', title: 'Item 2' },
+    { href: '/item3', title: 'Item 3' },
+    { href: '/item4', title: 'Item 4' },
+    { href: '/item5', title: 'Item 5' },
+];
+const renderItem = (item) => (_jsx("div", { "data-testid": item.href.replace('/', ''), children: typeof item.title === 'string'
+        ? String(item.title)
+        : String(item.name) }, item.href));
+const renderWithRouter = (initialPath, props) => {
+    return render(_jsx(TestMemoryRouter, { initialEntries: [initialPath], children: _jsx(Routes, { children: _jsx(Route, { path: "*", element: _jsx(VirtualList, { ...props }) }) }) }));
+};
+describe('VirtualList', () => {
+    beforeEach(() => {
+        vi.useFakeTimers();
+    });
+    afterEach(() => {
+        vi.clearAllTimers();
+        vi.useRealTimers();
+    });
+    it('should render empty list when no items provided', () => {
+        renderWithRouter('/', {
+            items: [],
+            renderItem,
+            routingBasePath: '/',
+        });
+        expect(screen.queryByTestId(/item/)).not.toBeInTheDocument();
+    });
+    it('should initially render first three items when no active item', () => {
+        renderWithRouter('/non-existing', {
+            items: mockItems,
+            renderItem,
+            routingBasePath: '/',
+        });
+        expect(screen.getByTestId('item1')).toBeInTheDocument();
+        expect(screen.getByTestId('item2')).toBeInTheDocument();
+        expect(screen.getByTestId('item3')).toBeInTheDocument();
+        expect(screen.queryByTestId('item4')).not.toBeInTheDocument();
+        expect(screen.queryByTestId('item5')).not.toBeInTheDocument();
+    });
+    it('should render items around active item', () => {
+        renderWithRouter('/item3', {
+            items: mockItems,
+            renderItem,
+            routingBasePath: '/',
+        });
+        expect(screen.getByTestId('item2')).toBeInTheDocument();
+        expect(screen.getByTestId('item3')).toBeInTheDocument();
+        expect(screen.getByTestId('item4')).toBeInTheDocument();
+    });
+    it('should handle first item selection', () => {
+        renderWithRouter('/item1', {
+            items: mockItems,
+            renderItem,
+            routingBasePath: '/',
+        });
+        expect(screen.getByTestId('item1')).toBeInTheDocument();
+        expect(screen.getByTestId('item2')).toBeInTheDocument();
+        expect(screen.queryByTestId('item3')).toBeInTheDocument();
+    });
+    it('should handle last item selection', () => {
+        renderWithRouter('/item5', {
+            items: mockItems,
+            renderItem,
+            routingBasePath: '/',
+        });
+        expect(screen.queryByTestId('item1')).not.toBeInTheDocument();
+        expect(screen.queryByTestId('item2')).not.toBeInTheDocument();
+        expect(screen.queryByTestId('item3')).not.toBeInTheDocument();
+        expect(screen.getByTestId('item4')).toBeInTheDocument();
+        expect(screen.getByTestId('item5')).toBeInTheDocument();
+    });
+    it('should eventually render all items after timeout', () => {
+        renderWithRouter('/item3', {
+            items: mockItems,
+            renderItem,
+            routingBasePath: '/',
+        });
+        expect(screen.getByTestId('item2')).toBeInTheDocument();
+        expect(screen.getByTestId('item3')).toBeInTheDocument();
+        expect(screen.getByTestId('item4')).toBeInTheDocument();
+        act(() => {
+            vi.advanceTimersByTime(1000);
+        });
+        expect(screen.getByTestId('item1')).toBeInTheDocument();
+        expect(screen.getByTestId('item2')).toBeInTheDocument();
+        expect(screen.getByTestId('item3')).toBeInTheDocument();
+        expect(screen.getByTestId('item4')).toBeInTheDocument();
+        expect(screen.getByTestId('item5')).toBeInTheDocument();
+    });
+    it('should handle custom routing base path', () => {
+        renderWithRouter('/docs/item1', {
+            items: mockItems,
+            renderItem,
+            routingBasePath: '/docs',
+        });
+        expect(screen.getByTestId('item1')).toBeInTheDocument();
+        expect(screen.getByTestId('item2')).toBeInTheDocument();
+        expect(screen.queryByTestId('item3')).toBeInTheDocument();
+    });
+    it('should not re-render if all items are already visible', () => {
+        const { rerender } = renderWithRouter('/item1', {
+            items: mockItems,
+            renderItem,
+            routingBasePath: '/',
+        });
+        act(() => {
+            vi.advanceTimersByTime(1000);
+        });
+        const initialRenderCount = screen.getAllByTestId(/item/).length;
+        rerender(_jsx(TestMemoryRouter, { initialEntries: ['/item3'], children: _jsx(Routes, { children: _jsx(Route, { path: "*", element: _jsx(VirtualList, { items: mockItems, renderItem: renderItem, routingBasePath: "/" }) }) }) }));
+        expect(screen.getAllByTestId(/item/).length).toBe(initialRenderCount);
+    });
+    it('should cleanup on unmount', () => {
+        const { unmount } = renderWithRouter('/item1', {
+            items: mockItems,
+            renderItem,
+            routingBasePath: '/',
+        });
+        unmount();
+        expect(() => {
+            act(() => {
+                vi.runAllTimers();
+            });
+        }).not.toThrow();
+    });
+});
+//# sourceMappingURL=VirtualList.test.js.map

package/lib/components/Discriminator/__tests__/DiscriminatorDropdown.test.d.ts

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

package/lib/components/Discriminator/__tests__/DiscriminatorDropdown.test.js

@@ -0,0 +1,63 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+import * as Jotai from 'jotai';
+import { normalizeOptions, OpenAPIParser } from '../../../services/index.js';
+import { getSchema } from '../../../models/index.js';
+import { Schema } from '../../Schema/index.js';
+import * as simpleDiscriminatorFixture from './fixtures/simple-discriminator.json';
+import * as discriminatorWithDefaultFixture from '../../../models/__tests__/fixtures/discriminator-with-default-mapping.json';
+import { TestBrowserRouter } from '../../../testProviders.js';
+const options = normalizeOptions({});
+vi.mock('jotai', async () => ({
+    ...(await vi.importActual('jotai')),
+    useAtomValue: vi.fn(),
+}));
+describe('DiscriminatorDropdown', () => {
+    vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(options);
+    const parser = new OpenAPIParser(simpleDiscriminatorFixture, undefined, options);
+    const schema = getSchema({
+        parser,
+        schemaOrRef: { $ref: '#/components/schemas/Pet' },
+        pointer: '#/components/schemas/Pet',
+        options,
+        deps: { operation: { pointer: 'defaultPointer' } },
+    });
+    describe('discriminator', () => {
+        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue({
+            activeOneOf: {
+                '#/components/schemas/Pet': 0,
+            },
+        });
+        it('should correctly render SchemaView', () => {
+            const { getByText } = render(_jsx(Schema, { schema: schema }), {
+                wrapper: TestBrowserRouter,
+            });
+            expect(getByText('type')).toBeInTheDocument();
+            expect(getByText('C̵a̵t̵ (deprecated)')).toBeInTheDocument();
+        });
+    });
+    describe('discriminator with defaultMapping', () => {
+        const parserWithDefault = new OpenAPIParser(discriminatorWithDefaultFixture, undefined, options);
+        const schemaWithDefault = getSchema({
+            parser: parserWithDefault,
+            schemaOrRef: { $ref: '#/components/schemas/Pet' },
+            pointer: '#/components/schemas/Pet',
+            options,
+            deps: { operation: { pointer: 'defaultPointer' } },
+        });
+        it('schema has correct oneOf structure with defaultMapping', () => {
+            expect(schemaWithDefault.oneOf).toHaveLength(3);
+            expect(schemaWithDefault.oneOf?.[0].title).toBe('cat');
+            expect(schemaWithDefault.oneOf?.[0].isDefaultMapping).toBe(false);
+            expect(schemaWithDefault.oneOf?.[1].title).toBe('dog');
+            expect(schemaWithDefault.oneOf?.[1].isDefaultMapping).toBe(false);
+            expect(schemaWithDefault.oneOf?.[2].title).toBe('Default mapping');
+            expect(schemaWithDefault.oneOf?.[2].isDefaultMapping).toBe(true);
+        });
+        it('finds correct defaultMappingIdx', () => {
+            const defaultMappingIdx = schemaWithDefault.oneOf?.findIndex((subSchema) => subSchema.isDefaultMapping);
+            expect(defaultMappingIdx).toBe(2);
+        });
+    });
+});
+//# sourceMappingURL=DiscriminatorDropdown.test.js.map

package/lib/components/Download/__tests__/DownloadSpecification.test.d.ts

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

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