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

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

@@ -0,0 +1,93 @@
+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 { Schema } from '../Schema.js';
+import { TestBrowserRouter } from '../../../testProviders.js';
+const options = normalizeOptions({});
+vi.mock('jotai', async () => ({
+    ...(await vi.importActual('jotai')),
+    useAtomValue: vi.fn(),
+}));
+describe('ArraySchema', () => {
+    it("should render Schema with Array 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.User,
+            pointer: '',
+            options,
+            deps: {
+                operation: {
+                    pointer: 'schemasExpansionLevel',
+                },
+            },
+        });
+        const { getByText } = render(_jsx(Schema, { schema: schema }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Dumb Property 3')).toBeInTheDocument();
+    });
+    it("should render Schema with Array 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.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')).toBeInTheDocument();
+    });
+    it('should automatically expand nested array when parent element is expanded', async () => {
+        vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(normalizeOptions({ schemasExpansionLevel: '4' }));
+        const parser = new OpenAPIParser(schemasExpansionLevel, undefined, options);
+        const schema = getSchema({
+            parser,
+            schemaOrRef: schemasExpansionLevel.components.schemas.User,
+            pointer: '',
+            options,
+            deps: {
+                operation: {
+                    pointer: 'schemasExpansionLevel',
+                },
+            },
+        });
+        const { getByText } = render(_jsx(Schema, { schema: schema }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Dumb Property 1 in nested array')).toBeInTheDocument();
+    });
+    it("should not render inner Schema with Array 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.User,
+            pointer: '',
+            options,
+            deps: {
+                operation: {
+                    pointer: 'schemasExpansionLevel',
+                },
+            },
+        });
+        const { queryByText } = render(_jsx(Schema, { schema: schema }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(queryByText('Dumb Property')).toBeNull();
+    });
+});
+//# sourceMappingURL=ArraySchema.test.js.map

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

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

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

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

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

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

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

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

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

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

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

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

@@ -0,0 +1,22 @@
+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/Schema/useOneOfLocationIdx.js

@@ -1 +1 @@
-import{useLocation as s}from"react-router-dom";import{useMemo as r}from"react";const i=/(?=oneof=)/g;function m(o,n){const t=s();return r(()=>o.findIndex((c,e)=>t.hash.split(i)[n]?.includes(`oneof=${e}`)),[n,t.hash,o])}export{m as useOneOfLocationIdx};
+import{useLocation as s}from"react-router";import{useMemo as r}from"react";const i=/(?=oneof=)/g;function m(o,n){const t=s();return r(()=>o.findIndex((c,e)=>t.hash.split(i)[n]?.includes(`oneof=${e}`)),[n,t.hash,o])}export{m as useOneOfLocationIdx};

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

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

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

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

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

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

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

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

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

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

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