@redocly/openapi-docs 3.24.1 → 3.24.2

package/lib/components/Schema/__tests__/ObjectSchema.test.js

@@ -1,115 +0,0 @@
-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 schemasExpansionLevel from './fixtures/schemaExpansionLevel.json';
-import requiredField from './fixtures/requiredField.json';
-import { Schema } from '../Schema.js';
-import { TestBrowserRouter } from '../../../testProviders.js';
-const options = normalizeOptions({});
-vi.mock('jotai', async () => ({
-    ...(await vi.importActual('jotai')),
-    useAtomValue: vi.fn(),
-}));
-describe('ObjectSchema', () => {
-    it("should render Schema when schemasExpansionLevel is 'all'", async () => {
-        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(normalizeOptions({ schemasExpansionLevel: 'all' }));
-        const parser = new OpenAPIParser(schemasExpansionLevel, undefined, options);
-        const schema = getSchema({
-            parser,
-            schemaOrRef: schemasExpansionLevel.components.schemas.Pet,
-            pointer: '',
-            options,
-            deps: {
-                operation: {
-                    pointer: 'schemasExpansionLevel',
-                },
-            },
-        });
-        const { getByText } = render(_jsx(Schema, { schema: schema }), {
-            wrapper: TestBrowserRouter,
-        });
-        expect(getByText('Dumb Property 6')).toBeInTheDocument();
-    });
-    it("should render Schema when schemasExpansionLevel is '3'", async () => {
-        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(normalizeOptions({ schemasExpansionLevel: '3' }));
-        const parser = new OpenAPIParser(schemasExpansionLevel, undefined, options);
-        const schema = getSchema({
-            parser,
-            schemaOrRef: schemasExpansionLevel.components.schemas.Pet,
-            pointer: '',
-            options,
-            deps: {
-                operation: {
-                    pointer: 'schemasExpansionLevel',
-                },
-            },
-        });
-        const { getByText, queryByText } = render(_jsx(Schema, { schema: schema }), {
-            wrapper: TestBrowserRouter,
-        });
-        expect(getByText('Dumb Property 3')).toBeInTheDocument();
-        expect(queryByText('Dumb Property 4')).toBeNull();
-    });
-    it("should not render inner Schema when schemasExpansionLevel is '0'", async () => {
-        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(normalizeOptions({ schemasExpansionLevel: '0' }));
-        const parser = new OpenAPIParser(schemasExpansionLevel, undefined, options);
-        const schema = getSchema({
-            parser,
-            schemaOrRef: schemasExpansionLevel.components.schemas.Pet,
-            pointer: '',
-            options,
-            deps: {
-                operation: {
-                    pointer: 'schemasExpansionLevel',
-                },
-            },
-        });
-        const { queryByText } = render(_jsx(Schema, { schema: schema }), {
-            wrapper: TestBrowserRouter,
-        });
-        expect(queryByText('Test Sub Category')).toBeNull();
-    });
-    it("should render Schema when required is 'category' -> 'sub'", async () => {
-        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(normalizeOptions({}));
-        const parser = new OpenAPIParser(requiredField, undefined, options);
-        const schema = getSchema({
-            parser,
-            schemaOrRef: requiredField.components.schemas.Pet,
-            pointer: '',
-            options,
-            deps: {
-                operation: {
-                    pointer: 'schemasExpansionLevel',
-                },
-            },
-        });
-        const { getByText, queryByText } = render(_jsx(Schema, { schema: schema }), {
-            wrapper: TestBrowserRouter,
-        });
-        expect(getByText('Dumb Property 2')).toBeInTheDocument();
-        expect(queryByText('Dumb Property 3')).toBeNull();
-    });
-    it("should render Schema when required is 'tags' -> 'sub' at Array schema", async () => {
-        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(normalizeOptions({}));
-        const parser = new OpenAPIParser(requiredField, undefined, options);
-        const schema = getSchema({
-            parser,
-            schemaOrRef: requiredField.components.schemas.User,
-            pointer: '',
-            options,
-            deps: {
-                operation: {
-                    pointer: 'schemasExpansionLevel',
-                },
-            },
-        });
-        const { getByText, queryByText } = render(_jsx(Schema, { schema: schema }), {
-            wrapper: TestBrowserRouter,
-        });
-        expect(getByText('Dumb Property 1')).toBeInTheDocument();
-        expect(queryByText('Dumb Property 2')).toBeNull();
-    });
-});
-//# sourceMappingURL=ObjectSchema.test.js.map

package/lib/components/Schema/__tests__/OneOfSchema.test.d.ts

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

package/lib/components/Schema/__tests__/OneOfSchema.test.js

@@ -1,33 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { render } from '@testing-library/react';
-import { normalizeOptions, OpenAPIParser } from '../../../services/index.js';
-import { getSchema } from '../../../models/index.js';
-import oneOfWithDiscriminator from './fixtures/oneOfWithDiscriminator.json';
-import { Schema } from '../Schema.js';
-import { TestBrowserRouter } from '../../../testProviders.js';
-const options = normalizeOptions({});
-describe('OneOfSchema', () => {
-    it('should render correct oneOf and discriminator based on deep link', () => {
-        const parser = new OpenAPIParser(oneOfWithDiscriminator, undefined, options);
-        const schema = getSchema({
-            parser,
-            schemaOrRef: { $ref: '#/components/schemas/OneOfSchema' },
-            pointer: '',
-            options,
-            deps: {
-                operation: {
-                    pointer: '/paths/schema',
-                },
-            },
-            absolutePointer: '/paths/schema',
-        });
-        history.pushState({}, '', 'user/createuser#user/createuser/t=request&path=pet&oneof=1&d=1&oneof=0');
-        const { getByText } = render(_jsx(Schema, { schema: schema }), {
-            wrapper: TestBrowserRouter,
-        });
-        expect(getByText('Type of the shape - Shape')).toBeInTheDocument();
-        expect(getByText('Whether or not the triangle is equilateral')).toBeInTheDocument();
-        expect(getByText('Perimeter of the Equilateral')).toBeInTheDocument();
-    });
-});
-//# sourceMappingURL=OneOfSchema.test.js.map

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

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

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

@@ -1,67 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { act, fireEvent, render } from '@testing-library/react';
-import { normalizeOptions, OpenAPIParser } from '../../../services/index.js';
-import { getSchema } from '../../../models/index.js';
-import oneOfWithDiscriminator from './fixtures/oneOfWithDiscriminator.json';
-import singleOneOf from './fixtures/singleOneOf.json';
-import { Schema } from '../Schema.js';
-import { TestBrowserRouter } from '../../../testProviders.js';
-const options = normalizeOptions({});
-describe('SchemaView', () => {
-    describe('OneOf', () => {
-        it('should render oneOf with a single item and display its schema fields', () => {
-            const parser = new OpenAPIParser(singleOneOf, undefined, options);
-            const schema = getSchema({
-                parser,
-                schemaOrRef: singleOneOf.paths['/example'].get.responses['200'].content['application/json'].schema,
-                pointer: '',
-                options,
-                deps: {
-                    operation: {
-                        pointer: '/paths/example',
-                    },
-                },
-                absolutePointer: '/paths/example',
-            });
-            const { getByText } = render(_jsx(Schema, { schema: schema }), {
-                wrapper: TestBrowserRouter,
-            });
-            expect(getByText('One of:')).toBeInTheDocument();
-            expect(getByText('UserResponse')).toBeInTheDocument();
-            expect(getByText('type')).toBeInTheDocument();
-            expect(getByText('data')).toBeInTheDocument();
-        });
-        it('should render oneOf with a discriminator without affecting each other', () => {
-            const parser = new OpenAPIParser(oneOfWithDiscriminator, undefined, options);
-            const schema = getSchema({
-                parser,
-                schemaOrRef: { $ref: '#/components/schemas/OneOfSchema' },
-                pointer: '',
-                options,
-                deps: {
-                    operation: {
-                        pointer: '/paths/schema',
-                    },
-                },
-                absolutePointer: '/paths/schema',
-            });
-            const { getByText } = render(_jsx(Schema, { schema: schema }), {
-                wrapper: TestBrowserRouter,
-            });
-            expect(getByText('Shape')).toBeInTheDocument();
-            act(() => {
-                fireEvent.click(getByText('Shape'));
-            });
-            expect(getByText('Discriminator')).toBeInTheDocument();
-            expect(getByText('square')).toBeInTheDocument();
-            expect(getByText('triangle')).toBeInTheDocument();
-            expect(getByText('sideLength')).toBeInTheDocument();
-            act(() => {
-                fireEvent.click(getByText('triangle'));
-            });
-            expect(getByText('equilateral')).toBeInTheDocument();
-            expect(getByText('Whether or not the triangle is equilateral')).toBeInTheDocument();
-        });
-    });
-});
-//# sourceMappingURL=Schema.test.js.map

package/lib/components/Schema/__tests__/useOneOfLocationIdx.test.d.ts

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

package/lib/components/Schema/__tests__/useOneOfLocationIdx.test.js

@@ -1,22 +0,0 @@
-import { renderHook } from '@testing-library/react';
-import { useOneOfLocationIdx } from '../useOneOfLocationIdx.js';
-vi.mock('react-router', () => ({
-    useLocation: vi.fn().mockReturnValue({
-        hash: '#plans/postplan/t=request&path=&oneof=1/trial&oneof=0/period',
-    }),
-}));
-describe('useOneOfLocationIdx', () => {
-    it('should return the index of the oneOf item in the hash', () => {
-        const oneOf = [{}, {}, {}];
-        const level = 1;
-        const { result } = renderHook(() => useOneOfLocationIdx(oneOf, level));
-        expect(result.current).toBe(1);
-    });
-    it('should return -1 if the oneOf item is not found in the hash', () => {
-        const oneOf = [{}, {}, {}];
-        const level = 3;
-        const { result } = renderHook(() => useOneOfLocationIdx(oneOf, level));
-        expect(result.current).toBe(-1);
-    });
-});
-//# sourceMappingURL=useOneOfLocationIdx.test.js.map

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

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

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

@@ -1,95 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { render, fireEvent } from '@testing-library/react';
-import * as Jotai from 'jotai';
-import { ClipboardService } from '@redocly/theme/core/openapi';
-import { SchemaCatalogLink } from '../SchemaCatalogLink.js';
-vi.mock('jotai', async () => ({
-    ...(await vi.importActual('jotai')),
-    useAtomValue: vi.fn(),
-}));
-vi.mock('../../../utils/dom', async () => ({
-    ...(await vi.importActual('../../../utils/dom')),
-    IS_BROWSER: true,
-}));
-vi.mock('@redocly/theme/core/openapi', async () => {
-    const actual = await vi.importActual('@redocly/theme/core/openapi');
-    const actualClipboard = actual.ClipboardService;
-    return {
-        ...actual,
-        ClipboardService: {
-            ...actualClipboard,
-            copyCustom: vi.fn(),
-        },
-    };
-});
-describe('SchemaCatalogLink', () => {
-    beforeEach(() => {
-        vi.clearAllMocks();
-        vi.useFakeTimers();
-        Object.defineProperty(global, 'navigator', {
-            value: {
-                clipboard: {
-                    writeText: vi.fn(),
-                },
-            },
-            writable: true,
-        });
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-    it('should render correctly', () => {
-        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue({
-            parser: {
-                definition: {
-                    'x-schema-catalog-link': '/_bundle/test.yaml',
-                },
-            },
-        });
-        const result = render(_jsx(SchemaCatalogLink, { schemaRef: "#/components/schemas/test" }));
-        expect(result.baseElement).toMatchSnapshot();
-    });
-    it('should not render if x-schema-catalog-link is not defined', () => {
-        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue({
-            parser: {
-                definition: {},
-            },
-        });
-        const result = render(_jsx(SchemaCatalogLink, { schemaRef: "#/components/schemas/test" }));
-        expect(result.baseElement).toMatchSnapshot();
-    });
-    it('should render correctly on server', async () => {
-        vi.doMock('../../../utils/dom', async () => ({
-            ...(await vi.importActual('../../../utils/dom')),
-            IS_BROWSER: vi.fn().mockReturnValue(false),
-        }));
-        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue({
-            parser: {
-                definition: {
-                    'x-schema-catalog-link': '/_bundle/test.yaml',
-                },
-            },
-        });
-        const result = render(_jsx(SchemaCatalogLink, { schemaRef: "#/components/schemas/test" }));
-        expect(result.baseElement).toMatchSnapshot();
-    });
-    it('should copy link to clipboard when copy button is clicked', async () => {
-        vi.doMock('../../../utils/dom', async () => ({
-            ...(await vi.importActual('../../../utils/dom')),
-            IS_BROWSER: vi.fn().mockReturnValue(true),
-        }));
-        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue({
-            parser: {
-                definition: {
-                    'x-schema-catalog-link': '/_bundle/test.yaml',
-                },
-            },
-        });
-        const result = render(_jsx(SchemaCatalogLink, { schemaRef: "#/components/schemas/test" }));
-        // Find the copy button by role
-        const copyButton = result.getByRole('button');
-        fireEvent.click(copyButton);
-        expect(ClipboardService.copyCustom).toHaveBeenCalled();
-    });
-});
-//# sourceMappingURL=SchemaCatalogLink.test.js.map

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

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

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

@@ -1,38 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { act, fireEvent, render } from '@testing-library/react';
-import { Security } from '../Security.js';
-vi.mock('jotai', async () => ({
-    ...(await vi.importActual('jotai')),
-    useAtomValue: vi.fn(() => ({ options: { hideSecuritySection: false } })),
-}));
-vi.mock('../SecurityModal', async () => ({
-    SecurityModal: vi.fn(() => _jsx("div", { children: "Mocked SecurityModal" })),
-}));
-describe('Security Component', () => {
-    it('should not renders SecurityButton initially when securities is empty', () => {
-        const { queryByText } = render(_jsx(Security, { securities: [] }));
-        expect(queryByText('Security')).not.toBeInTheDocument();
-    });
-    it('renders SecurityModal when SecurityButton is clicked', async () => {
-        const securities = [
-            {
-                schemes: [
-                    {
-                        description: 'For this sample, you can use the api key `special-key` to test the authorization filters.\n',
-                        type: 'apiKey',
-                        name: 'api_key',
-                        in: 'header',
-                        id: 'api_key',
-                        sectionId: 'api_key',
-                        scopes: ['write:pets', 'read:pets'],
-                    },
-                ],
-            },
-        ];
-        const { getByRole, getByText } = render(_jsx(Security, { securities: securities }));
-        fireEvent.click(getByRole('button', { name: 'View details' }));
-        await act(async () => { });
-        expect(getByText('Mocked SecurityModal')).toBeInTheDocument();
-    });
-});
-//# sourceMappingURL=Security.test.js.map

package/lib/components/Security/__tests__/SecurityButton.test.d.ts

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

package/lib/components/Security/__tests__/SecurityButton.test.js

@@ -1,92 +0,0 @@
-import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { fireEvent, render } from '@testing-library/react';
-import { SecurityButton } from '../SecurityButton.js';
-describe('SecurityButton Component', () => {
-    const securities = [
-        { schemes: [{ id: 'scheme1' }] },
-        { schemes: [{ id: 'scheme2' }, { id: 'scheme3' }] },
-    ];
-    it('should render the button with `View details` text', () => {
-        const { getByRole } = render(_jsx(SecurityButton, { securities: [securities[0]], onClick: () => { } }));
-        expect(getByRole('button', { name: 'View details' })).toBeInTheDocument();
-    });
-    it('should render the panel with correct text for a single security scheme', () => {
-        const { getByTestId } = render(_jsx(SecurityButton, { securities: [securities[0]], onClick: () => { } }));
-        expect(getByTestId('panel-body')).toHaveTextContent('scheme1');
-    });
-    it('should render the panel with correct text for multiple Authentication Types', () => {
-        const schemas = [
-            [{ schemes: [{ id: 'A' }] }, { schemes: [{ id: 'B' }] }], // Should render "A or B"
-            [{ schemes: [{ id: 'A' }, { id: 'B' }] }], // Should render "A and B"
-            [{ schemes: [{ id: 'A' }, { id: 'B' }] }, { schemes: [{ id: 'C' }, { id: 'D' }] }], // Should render "(A and B) or (C and D)"
-        ];
-        const { getAllByTestId } = render(_jsxs(_Fragment, { children: [_jsx(SecurityButton, { securities: schemas[0], onClick: () => { } }), _jsx(SecurityButton, { securities: schemas[1], onClick: () => { } }), _jsx(SecurityButton, { securities: schemas[2], onClick: () => { } })] }));
-        const panelBodies = getAllByTestId('panel-body');
-        expect(panelBodies[0]).toHaveTextContent('A or B');
-        expect(panelBodies[1]).toHaveTextContent('A and B');
-        expect(panelBodies[2]).toHaveTextContent('(A and B) or (C and D)');
-    });
-    it('shows required scopes for oauth2 schemes (truncated with +N)', () => {
-        const securities = [
-            {
-                schemes: [
-                    {
-                        id: 'OAuth2',
-                        type: 'oauth2',
-                        scopes: ['read:users', 'write:users', 'admin:users', 'delete:users', 'sudo:users'],
-                    },
-                ],
-            },
-        ];
-        const { getByTestId } = render(_jsx(SecurityButton, { securities: securities, onClick: () => { } }));
-        const body = getByTestId('panel-body');
-        expect(body).toHaveTextContent('OAuth2');
-        expect(body).toHaveTextContent('Required scopes');
-        expect(body).toHaveTextContent('read:users');
-        expect(body).toHaveTextContent('write:users');
-        expect(body).toHaveTextContent('admin:users');
-        expect(body).toHaveTextContent('delete:users');
-        expect(body).toHaveTextContent('+1');
-    });
-    it('allows focusing the +N scope tag with keyboard', () => {
-        const securities = [
-            {
-                schemes: [
-                    {
-                        id: 'OAuth2',
-                        type: 'oauth2',
-                        scopes: ['read:users', 'write:users', 'admin:users', 'delete:users', 'sudo:users'],
-                    },
-                ],
-            },
-        ];
-        const { getByText } = render(_jsx(SecurityButton, { securities: securities, onClick: () => { } }));
-        const plusOne = getByText('+1');
-        const focusable = plusOne.closest('[role="button"]');
-        expect(focusable).not.toBeNull();
-        expect(focusable).toHaveAttribute('tabindex', '0');
-    });
-    it('show truncated scope names for oauth2 schemes', () => {
-        const securities = [
-            {
-                schemes: [
-                    {
-                        id: 'OAuth2',
-                        type: 'oauth2',
-                        scopes: ['scope:verylongscopenameforoauthsecurityscheme'],
-                    },
-                ],
-            },
-        ];
-        const { getByTestId } = render(_jsx(SecurityButton, { securities: securities, onClick: () => { } }));
-        const body = getByTestId('panel-body');
-        expect(body).toHaveTextContent('scope:verylongscopenameforoauths..');
-    });
-    it('calls the onClick callback when the button is clicked', () => {
-        const onClickMock = vi.fn();
-        const { getByRole } = render(_jsx(SecurityButton, { securities: securities, onClick: onClickMock }));
-        fireEvent.click(getByRole('button', { name: 'View details' }));
-        expect(onClickMock).toHaveBeenCalled();
-    });
-});
-//# sourceMappingURL=SecurityButton.test.js.map

package/lib/components/Security/__tests__/SecurityModal.test.d.ts

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

package/lib/components/Security/__tests__/SecurityModal.test.js

@@ -1,172 +0,0 @@
-import { jsx as _jsx } from "react/jsx-runtime";
-import { render, fireEvent, act } from '@testing-library/react';
-import { SecurityModal } from '../SecurityModal.js';
-describe('SecurityModal Component', () => {
-    const securities = [
-        {
-            schemes: [
-                {
-                    id: 'B',
-                    description: 'Test description scheme B',
-                    type: 'http',
-                    bearerFormat: 'password',
-                    scopes: [],
-                },
-                {
-                    id: 'C',
-                    description: 'Test description scheme C',
-                    type: 'http',
-                    bearerFormat: 'password',
-                    scopes: [],
-                },
-            ],
-        },
-        {
-            schemes: [
-                {
-                    id: 'A',
-                    description: 'Test description scheme A',
-                    type: 'apiKey',
-                    in: 'header',
-                    name: 'api_key',
-                    scopes: [],
-                },
-            ],
-        },
-        {
-            schemes: [
-                {
-                    id: 'D',
-                    description: 'Test description scheme D',
-                    type: 'oauth2',
-                    flows: {
-                        authorizationCode: {
-                            authorizationUrl: 'https://example.com/authorization',
-                            tokenUrl: 'https://example.com/token',
-                            scopes: {
-                                'read:pets': 'read your pets',
-                                'write:pets': 'modify pets in your account',
-                            },
-                        },
-                    },
-                    scopes: ['read:pets'],
-                },
-            ],
-        },
-    ];
-    it('renders the SecurityModal with the correct number of SegmentedItems', () => {
-        const { getByText } = render(_jsx(SecurityModal, { securities: securities, onClose: () => { } }));
-        expect(getByText('A')).toBeInTheDocument();
-        expect(getByText('B and C')).toBeInTheDocument();
-    });
-    it('renders the SecurityModal with the correct number of SecurityFlows and Dividers', () => {
-        const { getByText, getAllByText } = render(_jsx(SecurityModal, { securities: securities, onClose: () => { } }));
-        expect(getByText('Test description scheme B')).toBeInTheDocument();
-        expect(getByText('Test description scheme C')).toBeInTheDocument();
-        expect(getByText('and')).toBeInTheDocument();
-        expect(getAllByText('HTTP Authorization Scheme').length).toEqual(2);
-        expect(getAllByText('http').length).toEqual(2);
-    });
-    it('should update active security scheme on click and display relevant information', async () => {
-        const { getByText } = render(_jsx(SecurityModal, { securities: securities, onClose: () => { } }));
-        fireEvent.click(getByText('A'));
-        await act(async () => { });
-        expect(getByText('Test description scheme A')).toBeInTheDocument();
-        expect(getByText('Header parameter name:')).toBeInTheDocument();
-        expect(getByText('api_key')).toBeInTheDocument();
-    });
-    it('should display details for OAuth2 scheme D including initial optional scopes toggle', async () => {
-        const { getByText, getAllByText } = render(_jsx(SecurityModal, { securities: securities, onClose: () => { } }));
-        fireEvent.click(getByText('D'));
-        await act(async () => { });
-        expect(getByText('Test description scheme D')).toBeInTheDocument();
-        expect(getByText('Required scopes')).toBeInTheDocument();
-        expect(getByText('Show optional scopes')).toBeInTheDocument();
-        const readPetsScopes = getAllByText('read:pets');
-        expect(readPetsScopes.length).toBe(1);
-        const writePetsScopes = getAllByText('write:pets');
-        expect(writePetsScopes.length).toBe(1);
-    });
-    it('should toggle optional scopes visibility for OAuth2 scheme D', async () => {
-        const { getByText, queryByText } = render(_jsx(SecurityModal, { securities: securities, onClose: () => { } }));
-        fireEvent.click(getByText('D'));
-        await act(async () => { });
-        fireEvent.click(getByText('Show optional scopes'));
-        await act(async () => { });
-        expect(getByText('Hide optional scopes')).toBeInTheDocument();
-        expect(queryByText('Show optional scopes')).toBeNull();
-    });
-    it('calls onClose callback when the Close button is clicked', () => {
-        const onCloseMock = vi.fn();
-        const { getByTestId } = render(_jsx(SecurityModal, { securities: securities, onClose: onCloseMock }));
-        fireEvent.click(getByTestId('close'));
-        expect(onCloseMock).toHaveBeenCalled();
-    });
-    it('should display required scopes from scopes array if there are no flows', () => {
-        const securities = [
-            {
-                schemes: [
-                    {
-                        id: 'D',
-                        description: 'Test description scheme D',
-                        type: 'oauth2',
-                        flows: {},
-                        scopes: ['read:pets'],
-                    },
-                ],
-            },
-        ];
-        const { getByText } = render(_jsx(SecurityModal, { securities: securities, onClose: () => { } }));
-        expect(getByText('read:pets')).toBeInTheDocument();
-    });
-    it('should exlcude required scopes from optional scopes', async () => {
-        const { getByText, getAllByText } = render(_jsx(SecurityModal, { securities: securities, onClose: () => { } }));
-        fireEvent.click(getByText('D'));
-        await act(async () => { });
-        fireEvent.click(getByText('Show optional scopes'));
-        await act(async () => { });
-        expect(getAllByText('read:pets').length).toBe(1);
-        expect(getAllByText('write:pets').length).toBe(1);
-    });
-    it('should render required scopes once per scheme and optional scopes per flow when there are multiple flows', async () => {
-        const securities = [
-            {
-                schemes: [
-                    {
-                        id: 'D',
-                        description: 'Test description scheme D',
-                        type: 'oauth2',
-                        flows: {
-                            authorizationCode: {
-                                authorizationUrl: 'https://example.com/authorization',
-                                tokenUrl: 'https://example.com/token',
-                                scopes: {
-                                    'read:pets': 'read your pets',
-                                    'write:pets': 'modify pets in your account',
-                                },
-                            },
-                            clientCredentials: {
-                                tokenUrl: 'https://example.com/token',
-                                scopes: {
-                                    'read:pets': 'read your pets',
-                                    'write:pets': 'modify pets in your account',
-                                },
-                            },
-                        },
-                        scopes: ['read:pets'],
-                    },
-                ],
-            },
-        ];
-        const { getByText, getAllByText } = render(_jsx(SecurityModal, { securities: securities, onClose: () => { } }));
-        // Required is per scheme
-        expect(getAllByText('Required scopes').length).toBe(1);
-        expect(getAllByText('read:pets').length).toBe(1);
-        // Each flow gets its own optional scopes block
-        expect(getByText('authorizationCode')).toBeInTheDocument();
-        expect(getByText('clientCredentials')).toBeInTheDocument();
-        expect(getAllByText('Show optional scopes').length).toBe(2);
-        expect(getAllByText('write:pets').length).toBe(2);
-    });
-});
-//# sourceMappingURL=SecurityModal.test.js.map

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

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