@redocly/openapi-docs 3.24.0 → 3.24.1

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

@@ -0,0 +1,365 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, fireEvent, screen, act } from '@testing-library/react';
+import * as Jotai from 'jotai';
+import { PropertyDetails } from '../PropertyDetails.js';
+import { normalizeOptions, OpenAPIParser } from '../../../services/index.js';
+import { getField } from '../../../models/index.js';
+import spec from './fixtures/fields.json';
+import { TestBrowserRouter } from '../../../testProviders.js';
+vi.mock('jotai', async () => ({
+    ...(await vi.importActual('jotai')),
+    useAtomValue: vi.fn(),
+}));
+describe('Components', () => {
+    const options = normalizeOptions({});
+    const parser = new OpenAPIParser(spec, undefined, options);
+    const deps = { operation: { pointer: 'defaultPointer' } };
+    vi.spyOn(Jotai, 'useAtomValue').mockReturnValue(options);
+    it('should render FieldDetails without duplicate content', () => {
+        const field = getField(parser, {
+            $ref: '#/components/schemas/primitiveSchema',
+        }, '', options, deps);
+        render(_jsx(PropertyDetails, { field: field }), {
+            wrapper: TestBrowserRouter,
+        });
+        const occurrences = screen.getAllByText('any');
+        expect(occurrences.length).toBe(1);
+    });
+    it('should render FieldDetails with object schema', () => {
+        const field = getField(parser, {
+            $ref: '#/components/objectSchema',
+        }, '', options, deps);
+        const { getAllByText, queryByText, getByText } = render(_jsx(PropertyDetails, { field: field }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(queryByText('Show 2 properties')).not.toBeNull();
+        act(() => {
+            queryByText('Show 2 properties')?.click();
+        });
+        expect(getByText('status')).toBeInTheDocument();
+        expect(getByText('name')).toBeInTheDocument();
+        expect(getAllByText('string').length).toBe(2);
+        act(() => {
+            fireEvent.click(getByText('-'));
+        });
+        expect(getAllByText('Show 2 properties').length).toBe(1);
+    });
+    it('should render FieldDetails with Array of string schema', () => {
+        const field = getField(parser, {
+            $ref: '#/components/arraySchema',
+            name: 'test',
+        }, '', options, deps);
+        const { getByText } = render(_jsx(PropertyDetails, { field: field }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Array of strings')).toBeInTheDocument();
+    });
+    it('should render FieldDetails with Array of object schema', () => {
+        const field = getField(parser, {
+            $ref: '#/components/arrayOfObjectsSchema',
+            name: 'test',
+        }, '', options, deps);
+        const { getByText, container } = render(_jsx(PropertyDetails, { field: field, level: 2 }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Array of objects')).toBeInTheDocument();
+        expect(getByText('Show 2 array properties')).toBeInTheDocument();
+        act(() => {
+            fireEvent.click(getByText('Show 2 array properties'));
+        });
+        expect(getByText('status')).toBeInTheDocument();
+        expect(getByText('name')).toBeInTheDocument();
+        expect(container.textContent.includes('test[].\u200Bname')).toBe(true);
+        expect(container.textContent.includes('test[].\u200Bstatus')).toBe(true);
+    });
+    it('should render array of primitive items with own documentation as a nested items row', () => {
+        const field = getField(parser, {
+            name: 'owners',
+            schema: {
+                type: 'array',
+                minItems: 1,
+                maxItems: 20,
+                description: 'List of ACL groups.',
+                items: {
+                    type: 'string',
+                    format: 'email',
+                    maxLength: 256,
+                    pattern: '^\\S+@\\S+$',
+                    description: 'ACL group formatted as an email.',
+                    example: 'john@example.com',
+                },
+            },
+        }, '', options, deps);
+        const { getByText, queryByText, container } = render(_jsx(PropertyDetails, { field: field, level: 2 }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Array of strings')).toBeInTheDocument();
+        expect(getByText('[ 1 .. 20 ] items')).toBeInTheDocument();
+        expect(getByText('List of ACL groups.')).toBeInTheDocument();
+        // items info is collapsed into the nested items row, including the items example
+        expect(queryByText('ACL group formatted as an email.')).not.toBeInTheDocument();
+        expect(queryByText('Example:')).not.toBeInTheDocument();
+        expect(getByText('Show array items')).toBeInTheDocument();
+        act(() => {
+            fireEvent.click(getByText('Show array items'));
+        });
+        expect(getByText('ACL group formatted as an email.')).toBeInTheDocument();
+        expect(getByText('<= 256 characters')).toBeInTheDocument();
+        expect(getByText('(email)')).toBeInTheDocument();
+        expect(getByText('"john@example.com"')).toBeInTheDocument();
+        // the items row is labeled `owners.[i]`, not `owners[].[i]`
+        expect(container.textContent.includes('owners.\u200B[i]')).toBe(true);
+        expect(container.textContent.includes('owners[]')).toBe(false);
+    });
+    it('should render a single deprecated badge for a deprecated primitive oneOf variant', () => {
+        const field = getField(parser, {
+            name: 'value',
+            schema: {
+                oneOf: [
+                    { type: 'string', deprecated: true, description: 'Legacy plain text value.' },
+                    { type: 'number' },
+                ],
+            },
+        }, '', options, deps);
+        const { getAllByText } = render(_jsx(PropertyDetails, { field: field, level: 2 }), {
+            wrapper: TestBrowserRouter,
+        });
+        // OneOfSchema renders the badge for the active variant; the fallback row must not repeat it
+        expect(getAllByText('Deprecated')).toHaveLength(1);
+    });
+    it('should keep the items docs on the nested items row inside a oneOf variant', () => {
+        const field = getField(parser, {
+            name: 'value',
+            schema: {
+                oneOf: [
+                    {
+                        type: 'array',
+                        items: {
+                            type: 'string',
+                            maxLength: 256,
+                            description: 'ACL group formatted as an email.',
+                            example: 'john@example.com',
+                        },
+                    },
+                    { type: 'string' },
+                ],
+            },
+        }, '', options, deps);
+        const { getByText } = render(_jsx(PropertyDetails, { field: field, level: 2 }), {
+            wrapper: TestBrowserRouter,
+        });
+        act(() => {
+            fireEvent.click(getByText('Show array items'));
+        });
+        expect(getByText('ACL group formatted as an email.')).toBeInTheDocument();
+        expect(getByText('"john@example.com"')).toBeInTheDocument();
+    });
+    it('should index prefixItems rows without the [] marker on the parent name', () => {
+        const tupleParser = new OpenAPIParser({
+            openapi: '3.1.0',
+            components: {
+                schemas: {
+                    AclGroup: {
+                        type: 'string',
+                        maxLength: 256,
+                        description: 'OSDU Access Control List (ACL) group that controls data access.',
+                    },
+                },
+            },
+        }, undefined, options);
+        const field = getField(tupleParser, {
+            name: 'owners',
+            schema: {
+                type: 'array',
+                minItems: 1,
+                maxItems: 20,
+                description: 'Description for property.',
+                example: ['data.default.owners@opendes.testing.slb.com'],
+                prefixItems: [
+                    {
+                        $ref: '#/components/schemas/AclGroup',
+                        description: 'Sibling description for items 111.',
+                    },
+                    { type: 'number', description: 'Description for second item. 222.' },
+                ],
+                items: {
+                    type: 'array',
+                    description: 'Description for additional items.',
+                    minItems: 2,
+                    prefixItems: [
+                        { type: 'number', description: 'Description for first item. 111.' },
+                        { type: 'string', description: 'Description for second item. 222.' },
+                    ],
+                    items: {
+                        type: 'string',
+                        description: 'Description for first item 333.',
+                        maxLength: 256,
+                    },
+                },
+            },
+        }, '', options, deps);
+        const { getByText, queryByText, container } = render(_jsx(PropertyDetails, { field: field, level: 2 }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Array of items')).toBeInTheDocument();
+        expect(getByText('[ 1 .. 20 ] items')).toBeInTheDocument();
+        expect(getByText('Description for property.')).toBeInTheDocument();
+        // the array example is distributed across the item rows, not repeated on the array row
+        expect(screen.queryByTestId('json-viewer')).toBeNull();
+        act(() => {
+            fireEvent.click(getByText('Show 3 properties'));
+        });
+        expect(getByText('"data.default.owners@opendes.testing.slb.com"')).toBeInTheDocument();
+        // tuple members are indexed on the parent name without the [] marker
+        expect(container.textContent.includes('owners.\u200B[0]')).toBe(true);
+        expect(container.textContent.includes('owners.\u200B[1]')).toBe(true);
+        expect(container.textContent.includes('owners.\u200B[2...]')).toBe(true);
+        expect(container.textContent.includes('owners[]')).toBe(false);
+        // the $ref sibling description wins on the prefix item row
+        expect(getByText('Sibling description for items 111.')).toBeInTheDocument();
+        expect(queryByText('OSDU Access Control List (ACL) group that controls data access.')).not.toBeInTheDocument();
+        expect(getByText('(AclGroup)')).toBeInTheDocument();
+        expect(getByText('<= 256 characters')).toBeInTheDocument();
+        expect(getByText('Description for additional items.')).toBeInTheDocument();
+        // the additional items schema is a tuple itself; its rows are indexed the same way
+        act(() => {
+            fireEvent.click(getByText('Show 3 properties'));
+        });
+        expect(container.textContent.includes('owners.\u200B[2...].\u200B[0]')).toBe(true);
+        expect(container.textContent.includes('owners.\u200B[2...].\u200B[1]')).toBe(true);
+        expect(container.textContent.includes('owners.\u200B[2...].\u200B[2...]')).toBe(true);
+        expect(getByText('Description for first item 333.')).toBeInTheDocument();
+    });
+    it('should render nested tuples with empty and items-less member schemas', () => {
+        // mirrors the OpenAPI 3.2 nested multipart/mixed example
+        const field = getField(parser, {
+            name: 'parts',
+            schema: {
+                type: 'array',
+                prefixItems: [
+                    { type: 'array' },
+                    {
+                        type: 'array',
+                        prefixItems: [{ type: 'object' }, { type: 'string' }, {}],
+                    },
+                ],
+            },
+        }, '', options, deps);
+        const { getByText, container } = render(_jsx(PropertyDetails, { field: field, level: 2 }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Array of items')).toBeInTheDocument();
+        act(() => {
+            fireEvent.click(getByText('Show 2 properties'));
+        });
+        // an items-less array member accepts any items
+        expect(container.textContent.includes('parts.\u200B[0]')).toBe(true);
+        expect(getByText('Array of any')).toBeInTheDocument();
+        expect(container.textContent.includes('parts.\u200B[1]')).toBe(true);
+        act(() => {
+            fireEvent.click(getByText('Show 3 properties'));
+        });
+        expect(container.textContent.includes('parts.\u200B[1].\u200B[0]')).toBe(true);
+        expect(getByText('object')).toBeInTheDocument();
+        expect(container.textContent.includes('parts.\u200B[1].\u200B[1]')).toBe(true);
+        expect(getByText('string')).toBeInTheDocument();
+        // an empty {} member schema accepts anything
+        expect(container.textContent.includes('parts.\u200B[1].\u200B[2]')).toBe(true);
+        expect(getByText('any')).toBeInTheDocument();
+        expect(container.textContent.includes('parts[]')).toBe(false);
+    });
+    it('should render FieldDetails with oneOf schema with object schema', () => {
+        const field = getField(parser, {
+            $ref: '#/components/oneOfSchemaWithObjectSchema',
+            name: 'test',
+        }, '', options, deps);
+        const { getByText, container } = render(_jsx(PropertyDetails, { field: field, level: 2 }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Show 2 properties')).toBeInTheDocument();
+        act(() => {
+            fireEvent.click(getByText('Show 2 properties'));
+        });
+        expect(getByText('status')).toBeInTheDocument();
+        expect(getByText('name')).toBeInTheDocument();
+        expect(container.textContent.includes('test.\u200Bname')).toBe(true);
+        expect(container.textContent.includes('test.\u200Bstatus')).toBe(true);
+    });
+    it('should render FieldDetails with a oneOf schema at the first level without nesting', () => {
+        const field = getField(parser, {
+            $ref: '#/components/oneOfSchemaWithObjectSchema',
+            name: 'test',
+        }, '', options, deps);
+        const { getByText, container } = render(_jsx(PropertyDetails, { field: field, level: 2 }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(getByText('Show 2 properties')).toBeInTheDocument();
+        act(() => {
+            fireEvent.click(getByText('Show 2 properties'));
+        });
+        expect(getByText('status')).toBeInTheDocument();
+        expect(getByText('name')).toBeInTheDocument();
+        expect(container.textContent.includes('test.\u200Bname')).toBe(true);
+        expect(container.textContent.includes('test.\u200Bstatus')).toBe(true);
+    });
+    it('the read-only field should be displayed', () => {
+        const field = getField(parser, {
+            $ref: '#/components/testProperties/readOnlyInSchema',
+        }, '', options, deps);
+        const { container } = render(_jsx(PropertyDetails, { field: field }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(container).toHaveTextContent(/read-only/);
+    });
+    it('the write-only field should be displayed', () => {
+        const field = getField(parser, {
+            $ref: '#/components/testProperties/writeOnlyInSchema',
+        }, '', options, deps);
+        const { container } = render(_jsx(PropertyDetails, { field: field }), {
+            wrapper: TestBrowserRouter,
+        });
+        expect(container).toHaveTextContent(/write-only/);
+    });
+    describe('PropertyDetails', () => {
+        it('PropertyDetails with read-only should renders correctly', () => {
+            options.showAccessMode = true;
+            const field = getField(parser, {
+                $ref: '#/components/testProperties/readOnlyInSchema',
+            }, '', options, deps);
+            const { container } = render(_jsx(PropertyDetails, { field: field }), {
+                wrapper: TestBrowserRouter,
+            });
+            expect(container).toHaveTextContent(/read-only/);
+        });
+        it('Field with write-only should renders correctly', () => {
+            options.showAccessMode = true;
+            const field = getField(parser, {
+                $ref: '#/components/testProperties/writeOnlyInSchema',
+            }, '', options, deps);
+            const { container } = render(_jsx(PropertyDetails, { field: field }), {
+                wrapper: TestBrowserRouter,
+            });
+            expect(container).toHaveTextContent(/write-only/);
+        });
+        it('Fields with read-only and write-only in content should renders correctly', async () => {
+            options.showAccessMode = true;
+            const field = getField(parser, {
+                name: 'test',
+                in: 'path',
+                content: {
+                    'application/json': {
+                        schema: {
+                            $ref: '#/components/testProperties/readOnlyInContent',
+                        },
+                    },
+                },
+            }, '', options, deps);
+            const { container } = render(_jsx(PropertyDetails, { field: field }), {
+                wrapper: TestBrowserRouter,
+            });
+            fireEvent.click(await screen.getByText('Show 2 properties'));
+            expect(container).toHaveTextContent(/read-only/);
+        });
+    });
+});
+//# sourceMappingURL=PropertyDetails.test.js.map

package/lib/components/PropertyDetails/__tests__/cycleColorsByLevel.test.d.ts

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

package/lib/components/PropertyDetails/__tests__/cycleColorsByLevel.test.js

@@ -0,0 +1,23 @@
+import { cycleColorsByLevel } from '../cycleColorsByLevel.js';
+describe('fieldColorByLevel', () => {
+    it('returns the correct color for a given level', () => {
+        const levelColors = [
+            '#9D00FF',
+            '#615CEA',
+            '#147DF5',
+            '#08BFCC',
+            '#08CC7A',
+            '#81CC08',
+            '#E5BE00',
+            '#FF8700',
+            '#FF00B8',
+        ];
+        for (let i = 0; i < levelColors.length; i++) {
+            expect(cycleColorsByLevel(i)).toBe(levelColors[i]);
+        }
+        expect(cycleColorsByLevel(levelColors.length)).toBe(levelColors[0]);
+        expect(cycleColorsByLevel(levelColors.length + 1)).toBe(levelColors[1]);
+        expect(cycleColorsByLevel(levelColors.length * 2)).toBe(levelColors[0]);
+    });
+});
+//# sourceMappingURL=cycleColorsByLevel.test.js.map

package/lib/components/RedoclyOpenAPIDocs/__tests__/AppProvider.test.d.ts

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

package/lib/components/RedoclyOpenAPIDocs/__tests__/AppProvider.test.js

@@ -0,0 +1,16 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from '@testing-library/react';
+import { StoreProvider } from '../Providers.js';
+describe('ProStoreProvider', () => {
+    test('StoreProvider should run onInit hook', async () => {
+        const { findByTestId } = render(_jsx(StoreProvider, { options: {}, definition: {
+                openapi: '3.0.0',
+                info: {
+                    version: '1.0',
+                    title: 'Foo',
+                },
+            }, children: _jsx("div", { "data-testid": "test" }) }));
+        expect(await findByTestId('test')).toBeInTheDocument();
+    });
+});
+//# sourceMappingURL=AppProvider.test.js.map

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

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

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

@@ -0,0 +1,104 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { parseYaml } from '@redocly/openapi-core';
+import { readFileSync } from 'fs';
+import { render, waitFor } from '@testing-library/react';
+import { vi } from 'vitest';
+import { createElement } from 'react';
+import { MemoryRouter } from 'react-router';
+import { useTelemetry } from '../../../hooks/index.js';
+import { useSetAtom } from 'jotai';
+vi.mock('../../../hooks/useTelemetry');
+vi.mock('../../../hooks/useRouter', () => ({
+    useRouter: () => ({
+        Router: ({ children }) => createElement(MemoryRouter, {}, children),
+        routerProps: {},
+    }),
+}));
+vi.mock('@redocly/theme/core/openapi', async () => {
+    const actual = await vi.importActual('@redocly/theme/core/openapi');
+    return {
+        ...actual,
+        getOperationColor: vi.fn(() => '#007bff'),
+        SearchSessionProvider: ({ children }) => {
+            const mockContextValue = {
+                searchSessionId: 'test-session-id',
+                refreshSearchSessionId: vi.fn(),
+            };
+            const Provider = actual.SearchSessionContext.Provider;
+            return createElement(Provider, { value: mockContextValue, children });
+        },
+    };
+});
+vi.mock('jotai', async () => {
+    const originalJotai = await vi.importActual('jotai');
+    return {
+        ...originalJotai,
+        useSetAtom: vi.fn(),
+    };
+});
+import { RedoclyOpenAPIDocs } from '../RedoclyOpenAPIDocs.js';
+const contents = readFileSync('./playground/openapi/petstore.yaml', 'utf8');
+const definition = parseYaml(contents);
+vi.mock('../../../hooks/useLicense', () => {
+    return {
+        useLicense: () => {
+            return {
+                licenseInfo: { valid: true, allowed: true },
+                isValid: true,
+            };
+        },
+    };
+});
+describe('RedoclyOpenAPIDocs', () => {
+    const options = {};
+    const store = { definition, options };
+    window.scrollTo = vi.fn();
+    const mockTelemetrySend = vi.fn();
+    beforeEach(() => {
+        vi.clearAllMocks();
+        useTelemetry.mockImplementation(() => ({
+            sendViewedMessage: mockTelemetrySend,
+        }));
+        useSetAtom.mockReturnValue(vi.fn());
+    });
+    describe('onLoaded callback', () => {
+        it('should call callback on mount', async () => {
+            const onLoaded = vi.fn();
+            render(_jsx(RedoclyOpenAPIDocs, { store: store, onLoaded: onLoaded }));
+            await waitFor(() => {
+                expect(onLoaded).toHaveBeenCalledTimes(1);
+            }, { timeout: 10_000 });
+        }, 15_000);
+        it('should return null if store is not provided', () => {
+            const { container } = render(_jsx(RedoclyOpenAPIDocs, {}));
+            expect(container.firstChild).toBeNull();
+        });
+        it('should not render sidebar if options.hideSidebar is true', () => {
+            const { queryByRole } = render(_jsx(RedoclyOpenAPIDocs, { store: { ...store, options: { ...options, hideSidebar: true } } }));
+            expect(queryByRole('complementary')).not.toBeInTheDocument();
+        });
+        it('should pass correct props to SidebarLogo when x-logo is defined', () => {
+            const xLogo = {
+                url: 'https://example.com/logo.png',
+                href: 'https://example.com',
+                altText: 'example logo',
+                backgroundColor: '#FFFFFF',
+            };
+            const definitionWithLogo = {
+                ...definition,
+                info: { ...definition.info, 'x-logo': xLogo },
+            };
+            const { getByAltText } = render(_jsx(RedoclyOpenAPIDocs, { store: { ...store, definition: definitionWithLogo } }));
+            const logoImg = getByAltText(xLogo.altText);
+            expect(logoImg.src).toBe(xLogo.url);
+            expect(logoImg.parentElement?.getAttribute('href')).toBe(xLogo.href);
+        });
+        it('should not set operations when hideReplay is true', () => {
+            const setAllOperations = vi.fn();
+            useSetAtom.mockReturnValue(setAllOperations);
+            render(_jsx(RedoclyOpenAPIDocs, { store: { ...store, options: { ...options, hideReplay: true } } }));
+            expect(setAllOperations).not.toHaveBeenCalled();
+        });
+    });
+});
+//# sourceMappingURL=RedoclyOpenAPIDocs.test.js.map

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

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

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

@@ -0,0 +1,15 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+/* tslint:disable:no-implicit-dependencies */
+import { render } from '@testing-library/react';
+import { RenderHook } from '../RenderHook.js';
+describe('RenderHook', () => {
+    it('should render correctly', () => {
+        const { container } = render(_jsx(RenderHook, { Hook: ({ someProp }) => ({ html: `<a href='#'>${someProp}</a>` }), props: { someProp: 'text' } }));
+        expect(container.innerHTML).toEqual('<span><a href="#">text</a></span>');
+    });
+    it("should return null if Hook prop isn't defined", () => {
+        const { container } = render(_jsx(RenderHook, { props: { someProp: 'text' } }));
+        expect(container.innerHTML).toEqual('');
+    });
+});
+//# sourceMappingURL=RenderHook.test.js.map

package/lib/components/Replay/__tests__/utils.test.d.ts

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