@redocly/openapi-docs 3.24.0 → 3.24.1

package/lib/components/RequestSamples/__tests__/Example.test.js

@@ -0,0 +1,384 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, screen, waitFor } from '@testing-library/react';
+import userEvent from '@testing-library/user-event';
+import { Example } from '../Example.js';
+import { withTestProviders } from '../../../testProviders.js';
+// Mock the dependencies
+vi.mock('../../Samples', () => ({
+    ExampleSwitch: ({ examples, exampleKey, onChange, }) => (_jsx("div", { "data-testid": "example-switch", children: _jsx("select", { "data-testid": "example-selector", value: exampleKey, onChange: (e) => onChange(e.target.value), children: Object.keys(examples).map((key) => (_jsx("option", { value: key, children: key }, key))) }) })),
+    useExampleKey: vi.fn(() => ({ exampleKey: 'bee' })),
+}));
+import { useTelemetry, useActivateExample } from '../../../hooks/index.js';
+import { useExampleKey } from '../../Samples/index.js';
+vi.mock('../../../hooks', async () => ({
+    ...(await vi.importActual('../../../hooks')),
+    useActivateExample: vi.fn(() => vi.fn()),
+    useTelemetry: vi.fn(() => ({
+        sendExamplesSwitcherClickedMessage: vi.fn(),
+    })),
+}));
+vi.mock('../../../jotai/operation', () => ({
+    operationStore: vi.fn(() => ({
+        toString: () => 'operationStore',
+    })),
+}));
+import { useAtom } from 'jotai';
+const mockUseTelemetry = vi.mocked(useTelemetry);
+const mockUseActivateExample = vi.mocked(useActivateExample);
+const mockUseExampleKey = vi.mocked(useExampleKey);
+// Mock jotai at module level
+vi.mock('jotai', async () => {
+    const actual = await vi.importActual('jotai');
+    return {
+        ...actual,
+        useAtom: vi.fn(),
+    };
+});
+const mockUseAtom = vi.mocked(useAtom);
+describe('Example component', () => {
+    const mockMediaType = {
+        name: 'application/json',
+        examples: {
+            bee: {
+                mime: 'application/json',
+                value: {
+                    petType: 'bee',
+                    honeyPerDay: 3.14,
+                },
+                rawValue: {
+                    petType: 'bee',
+                    honeyPerDay: 3.14,
+                },
+            },
+        },
+        schema: undefined,
+        isRequestType: true,
+        onlyRequiredInSamples: false,
+        operation: {
+            pointer: '/paths/~1pet/post',
+        },
+    };
+    const mockMediaContent = {
+        mediaTypes: [mockMediaType],
+    };
+    beforeEach(() => {
+        vi.clearAllMocks();
+        vi.spyOn(console, 'log').mockImplementation(() => { });
+        mockUseAtom.mockReturnValue([
+            {
+                activeExampleName: 'bee',
+                activeOneOf: {},
+                requestValues: { body: null },
+            },
+            vi.fn(),
+        ]);
+    });
+    afterEach(() => {
+        vi.restoreAllMocks();
+    });
+    it('should render component with single example without ExampleSwitch', () => {
+        const renderSample = vi.fn(() => _jsx("div", { "data-testid": "sample", children: "Sample" }));
+        render(withTestProviders(_jsx(Example, { mediaType: mockMediaType, mediaContent: mockMediaContent, renderSample: renderSample })));
+        expect(renderSample).toHaveBeenCalledWith();
+        expect(screen.queryByTestId('example-switch')).not.toBeInTheDocument();
+        expect(screen.getByTestId('sample')).toBeInTheDocument();
+    });
+    it('should render component without examples', () => {
+        const noExamplesMediaType = {
+            ...mockMediaType,
+            examples: undefined,
+            formExamples: undefined,
+        };
+        const renderSample = vi.fn(() => _jsx("div", { "data-testid": "sample", children: "Sample" }));
+        render(withTestProviders(_jsx(Example, { mediaType: noExamplesMediaType, mediaContent: mockMediaContent, renderSample: renderSample })));
+        expect(renderSample).toHaveBeenCalledWith();
+        expect(screen.queryByTestId('example-switch')).not.toBeInTheDocument();
+    });
+    it('should render component with multiple examples and ExampleSwitch', () => {
+        const multipleExamplesMediaType = {
+            ...mockMediaType,
+            examples: {
+                bee: {
+                    mime: 'application/json',
+                    value: { petType: 'bee' },
+                    rawValue: { petType: 'bee' },
+                },
+                cat: {
+                    mime: 'application/json',
+                    value: { petType: 'cat' },
+                    rawValue: { petType: 'cat' },
+                },
+            },
+        };
+        const renderSample = vi.fn(() => _jsx("div", { "data-testid": "sample", children: "Sample" }));
+        render(withTestProviders(_jsx(Example, { mediaType: multipleExamplesMediaType, mediaContent: mockMediaContent, renderSample: renderSample })));
+        expect(screen.getByTestId('example-switch')).toBeInTheDocument();
+        expect(renderSample).toHaveBeenCalledWith('bee');
+    });
+    it('should handle example change correctly', async () => {
+        const user = userEvent.setup();
+        const setOperation = vi.fn();
+        const sendTelemetry = vi.fn();
+        const setActivateExampleName = vi.fn();
+        mockUseAtom.mockReturnValue([
+            {
+                activeExampleName: 'bee',
+                activeOneOf: {},
+                requestValues: { body: null },
+            },
+            setOperation,
+        ]);
+        mockUseTelemetry.mockReturnValue({
+            sendExamplesSwitcherClickedMessage: sendTelemetry,
+        });
+        mockUseActivateExample.mockReturnValue(setActivateExampleName);
+        const multipleExamplesMediaType = {
+            ...mockMediaType,
+            examples: {
+                bee: {
+                    mime: 'application/json',
+                    value: { petType: 'bee' },
+                    rawValue: { petType: 'bee' },
+                },
+                cat: {
+                    mime: 'application/json',
+                    value: { petType: 'cat' },
+                    rawValue: { petType: 'cat' },
+                },
+            },
+        };
+        const renderSample = vi.fn(() => _jsx("div", { "data-testid": "sample", children: "Sample" }));
+        render(withTestProviders(_jsx(Example, { mediaType: multipleExamplesMediaType, mediaContent: mockMediaContent, renderSample: renderSample })));
+        const selector = screen.getByTestId('example-selector');
+        await user.selectOptions(selector, 'cat');
+        await waitFor(() => {
+            expect(sendTelemetry).toHaveBeenCalledWith([
+                {
+                    object: 'button',
+                    exampleNumber: 1,
+                    totalExamples: 2,
+                    id: 'examplesSwitcherButton',
+                    uri: 'urn:redocly:redoc:ui:button:examplesSwitcherButton',
+                },
+            ]);
+            expect(setOperation).toHaveBeenCalledWith(expect.objectContaining({
+                activeExampleName: 'cat',
+                activeOneOf: expect.any(Object),
+                requestValues: { body: null },
+            }));
+            expect(setActivateExampleName).toHaveBeenCalledWith('cat');
+        });
+    });
+    it('should use formExamples when examples is undefined', () => {
+        const formExamplesMediaType = {
+            ...mockMediaType,
+            examples: undefined,
+            formExamples: {
+                example1: {
+                    mime: 'application/x-www-form-urlencoded',
+                    value: { field: 'value1' },
+                    rawValue: { field: 'value1' },
+                },
+                example2: {
+                    mime: 'application/x-www-form-urlencoded',
+                    value: { field: 'value2' },
+                    rawValue: { field: 'value2' },
+                },
+            },
+        };
+        const renderSample = vi.fn(() => _jsx("div", { "data-testid": "sample", children: "Sample" }));
+        render(withTestProviders(_jsx(Example, { mediaType: formExamplesMediaType, mediaContent: mockMediaContent, renderSample: renderSample })));
+        expect(screen.getByTestId('example-switch')).toBeInTheDocument();
+        expect(renderSample).toHaveBeenCalledWith('bee');
+    });
+    it('should memoize the component correctly', () => {
+        const multipleExamplesMediaType = {
+            ...mockMediaType,
+            examples: {
+                bee: {
+                    mime: 'application/json',
+                    value: { petType: 'bee' },
+                    rawValue: { petType: 'bee' },
+                },
+                cat: {
+                    mime: 'application/json',
+                    value: { petType: 'cat' },
+                    rawValue: { petType: 'cat' },
+                },
+            },
+        };
+        const renderSample = vi.fn(() => _jsx("div", { "data-testid": "sample", children: "Sample" }));
+        const { rerender } = render(withTestProviders(_jsx(Example, { mediaType: multipleExamplesMediaType, mediaContent: mockMediaContent, renderSample: renderSample })));
+        const initialCallCount = renderSample.mock.calls.length;
+        // Rerender with the same props
+        rerender(withTestProviders(_jsx(Example, { mediaType: multipleExamplesMediaType, mediaContent: mockMediaContent, renderSample: renderSample })));
+        // The renderSample should not be called again due to memoization
+        expect(renderSample.mock.calls.length).toBe(initialCallCount);
+    });
+    it('should use examplesPointer when provided for activeOneOf', () => {
+        const customPointer = '/paths/~1pet/post/requestBody/content/application~1json';
+        const multipleExamplesMediaType = {
+            ...mockMediaType,
+            examplesPointer: customPointer,
+            examples: {
+                bee: {
+                    mime: 'application/json',
+                    value: { petType: 'bee' },
+                    rawValue: { petType: 'bee' },
+                },
+                cat: {
+                    mime: 'application/json',
+                    value: { petType: 'cat' },
+                    rawValue: { petType: 'cat' },
+                },
+            },
+        };
+        mockUseAtom.mockReturnValue([
+            {
+                activeExampleName: 'cat',
+                activeOneOf: { [customPointer]: 1 },
+                requestValues: { body: null },
+            },
+            vi.fn(),
+        ]);
+        const renderSample = vi.fn(() => _jsx("div", { "data-testid": "sample", children: "Sample" }));
+        render(withTestProviders(_jsx(Example, { mediaType: multipleExamplesMediaType, mediaContent: mockMediaContent, renderSample: renderSample })));
+        expect(screen.getByTestId('example-switch')).toBeInTheDocument();
+        // Should render with 'cat' example since activeOneOf[customPointer] = 1
+        expect(renderSample).toHaveBeenCalledWith('cat');
+    });
+    it('should use examplesPointer in handleExampleChange when it starts with operation pointer', async () => {
+        const user = userEvent.setup();
+        const setOperation = vi.fn();
+        const setActivateExampleName = vi.fn();
+        const sendTelemetry = vi.fn();
+        const operationPointer = '/paths/~1pet/post';
+        const examplesPointer = '/paths/~1pet/post/requestBody/content/application~1json';
+        const multipleExamplesMediaType = {
+            ...mockMediaType,
+            operation: {
+                ...mockMediaType.operation,
+                pointer: operationPointer,
+            },
+            examplesPointer,
+            examples: {
+                bee: {
+                    mime: 'application/json',
+                    value: { petType: 'bee' },
+                    rawValue: { petType: 'bee' },
+                },
+                cat: {
+                    mime: 'application/json',
+                    value: { petType: 'cat' },
+                    rawValue: { petType: 'cat' },
+                },
+            },
+        };
+        mockUseAtom.mockReturnValue([
+            {
+                activeExampleName: 'bee',
+                activeOneOf: {},
+                requestValues: { body: null },
+            },
+            setOperation,
+        ]);
+        mockUseTelemetry.mockReturnValue({
+            sendExamplesSwitcherClickedMessage: sendTelemetry,
+        });
+        mockUseActivateExample.mockReturnValue(setActivateExampleName);
+        const renderSample = vi.fn(() => _jsx("div", { "data-testid": "sample", children: "Sample" }));
+        render(withTestProviders(_jsx(Example, { mediaType: multipleExamplesMediaType, mediaContent: mockMediaContent, renderSample: renderSample })));
+        const selector = screen.getByTestId('example-selector');
+        await user.selectOptions(selector, 'cat');
+        await waitFor(() => {
+            expect(setOperation).toHaveBeenCalledWith(expect.objectContaining({
+                activeExampleName: 'cat',
+                activeOneOf: { [examplesPointer]: 1 },
+                requestValues: { body: null },
+            }));
+        });
+    });
+    it('should use operation pointer in handleExampleChange when examplesPointer does not start with operation pointer', async () => {
+        const user = userEvent.setup();
+        const setOperation = vi.fn();
+        const setActivateExampleName = vi.fn();
+        const sendTelemetry = vi.fn();
+        const operationPointer = '/paths/~1pet/post';
+        const examplesPointer = '/different/pointer';
+        const multipleExamplesMediaType = {
+            ...mockMediaType,
+            operation: {
+                ...mockMediaType.operation,
+                pointer: operationPointer,
+            },
+            examplesPointer,
+            examples: {
+                bee: {
+                    mime: 'application/json',
+                    value: { petType: 'bee' },
+                    rawValue: { petType: 'bee' },
+                },
+                cat: {
+                    mime: 'application/json',
+                    value: { petType: 'cat' },
+                    rawValue: { petType: 'cat' },
+                },
+            },
+        };
+        mockUseAtom.mockReturnValue([
+            {
+                activeExampleName: 'bee',
+                activeOneOf: {},
+                requestValues: { body: null },
+            },
+            setOperation,
+        ]);
+        mockUseTelemetry.mockReturnValue({
+            sendExamplesSwitcherClickedMessage: sendTelemetry,
+        });
+        mockUseActivateExample.mockReturnValue(setActivateExampleName);
+        const renderSample = vi.fn(() => _jsx("div", { "data-testid": "sample", children: "Sample" }));
+        render(withTestProviders(_jsx(Example, { mediaType: multipleExamplesMediaType, mediaContent: mockMediaContent, renderSample: renderSample })));
+        const selector = screen.getByTestId('example-selector');
+        await user.selectOptions(selector, 'cat');
+        await waitFor(() => {
+            // Should use operation pointer instead of examplesPointer
+            expect(setOperation).toHaveBeenCalledWith(expect.objectContaining({
+                activeExampleName: 'cat',
+                activeOneOf: { [operationPointer]: 1 },
+                requestValues: { body: null },
+            }));
+        });
+    });
+    it('should fallback to activeExampleKey from useExampleKey when activeOneOf is empty', () => {
+        mockUseExampleKey.mockReturnValue({ exampleKey: 'cat' });
+        const multipleExamplesMediaType = {
+            ...mockMediaType,
+            examples: {
+                bee: {
+                    mime: 'application/json',
+                    value: { petType: 'bee' },
+                    rawValue: { petType: 'bee' },
+                },
+                cat: {
+                    mime: 'application/json',
+                    value: { petType: 'cat' },
+                    rawValue: { petType: 'cat' },
+                },
+            },
+        };
+        mockUseAtom.mockReturnValue([
+            {
+                activeExampleName: undefined,
+                activeOneOf: {},
+                requestValues: { body: null },
+            },
+            vi.fn(),
+        ]);
+        const renderSample = vi.fn(() => _jsx("div", { "data-testid": "sample", children: "Sample" }));
+        render(withTestProviders(_jsx(Example, { mediaType: multipleExamplesMediaType, mediaContent: mockMediaContent, renderSample: renderSample })));
+        // Should use 'cat' from useExampleKey
+        expect(renderSample).toHaveBeenCalledWith('cat');
+    });
+});
+//# sourceMappingURL=Example.test.js.map

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

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

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

@@ -0,0 +1,226 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render, waitFor, 
+// @community-ignore
+fireEvent,
+// @community-ignore-end
+ } from '@testing-library/react';
+import * as Jotai from 'jotai/index';
+import * as useCodeSamplesModule from '../useCodeSamples.js';
+import { RequestSamples } from '../RequestSamples.js';
+import { normalizeOptions, OpenAPIParser } from '../../../services/index.js';
+import { getMediaContent, getOperation } from '../../../models/index.js';
+import { withTestProviders } from '../../../testProviders.js';
+import petStore from './fixtures/petstore.json';
+import definition from './fixtures/operationDefinition.json';
+import { 
+// @community-ignore
+environmentAtom, 
+// @community-ignore-end
+languageAtom, } from '../../../jotai/app.js';
+import { globalStoreAtom } from '../../../jotai/store.js';
+// @community-ignore
+vi.mock('../../Replay', () => ({
+    Replay: () => _jsx("div", { children: "Replay" }),
+}));
+// @community-ignore-end
+vi.mock('jotai', async () => {
+    const actual = await vi.importActual('jotai');
+    return {
+        ...actual,
+        useAtomValue: vi.fn((atom) => {
+            if (atom === languageAtom) {
+                return {
+                    activeLanguage: 'python',
+                    languages: ['python', 'javascript'],
+                };
+            }
+            return actual.useAtomValue(atom);
+        }),
+        useAtom: vi.fn((atom) => {
+            if (atom === languageAtom) {
+                return [
+                    {
+                        activeLanguage: 'python',
+                        languages: ['python', 'javascript'],
+                    },
+                    vi.fn(),
+                ];
+            }
+            return actual.useAtom(atom);
+        }),
+    };
+});
+vi.mock('@redocly/theme/core/openapi', async () => ({
+    ...(await vi.importActual('@redocly/theme/core/openapi')),
+    getOperationColor: vi.fn(() => 'blue'),
+}));
+describe('Components', () => {
+    describe('RequestSamples', () => {
+        let operation;
+        const options = normalizeOptions({});
+        const parser = new OpenAPIParser(petStore, undefined, options);
+        const info = {
+            'application/json': {
+                schema: {
+                    additionalProperties: {
+                        format: 'int32',
+                    },
+                },
+                examples: {
+                    bee: {
+                        mime: 'application/json',
+                        value: {
+                            category: {
+                                id: 0,
+                                name: 'string',
+                            },
+                            honeyPerDay: 3.14,
+                            id: 0,
+                            petType: 'bee',
+                            status: 'available',
+                        },
+                    },
+                    cat: {
+                        mime: 'application/json',
+                        value: {
+                            category: {
+                                id: 0,
+                                name: 'string',
+                            },
+                            huntingSkill: 'adventurous',
+                            id: 0,
+                            petType: 'cat',
+                            status: 'available',
+                        },
+                    },
+                },
+            },
+            'application/xml': {
+                schema: {
+                    additionalProperties: {
+                        format: 'int32',
+                    },
+                },
+            },
+        };
+        // @community-ignore
+        test('should renders correctly with mimeType and Example Dropdowns', async () => {
+            operation = getOperation(parser, definition, undefined, options, '');
+            const PROPS = {
+                operation,
+                content: getMediaContent({
+                    parser,
+                    info,
+                    isRequestType: true,
+                    options,
+                    data: { operation },
+                }),
+            };
+            const { getAllByTestId, getAllByRole, getAllByText } = render(withTestProviders(_jsx(RequestSamples, { ...PROPS }), {
+                definition: parser.definition,
+            }));
+            await waitFor(() => {
+                const dropdowns = getAllByTestId('dropdown');
+                expect(dropdowns.length).toBeGreaterThanOrEqual(2);
+                expect(getAllByText('cat').length).toBeGreaterThanOrEqual(1);
+                expect(getAllByText('application/json').length).toBeGreaterThanOrEqual(1);
+            });
+            const dropdowns = getAllByTestId('dropdown');
+            for (const dropdown of dropdowns) {
+                const trigger = dropdown.querySelector('button');
+                if (trigger) {
+                    fireEvent.click(trigger);
+                }
+            }
+            await waitFor(() => {
+                const menuItems = getAllByRole('menuitem');
+                expect(menuItems.length).toBeGreaterThanOrEqual(4);
+                expect(getAllByText('bee').length).toBeGreaterThanOrEqual(1);
+                expect(getAllByText('application/xml').length).toBeGreaterThanOrEqual(1);
+            });
+        });
+        // @community-ignore-end
+        test('should renders correctly without mimeType selector', () => {
+            operation = getOperation(parser, definition, undefined, options, '');
+            // @ts-ignore
+            operation.requestBody.content.mediaTypes = operation.requestBody?.content?.mediaTypes.filter((m) => m.name === 'application/json');
+            const PROPS = {
+                onlyDefaultMimeType: true,
+                operation,
+                content: getMediaContent({
+                    parser,
+                    info,
+                    isRequestType: true,
+                    options,
+                    data: { operation },
+                }),
+            };
+            const { queryByText } = render(withTestProviders(_jsx(RequestSamples, { ...PROPS }), {
+                definition: parser.definition,
+            }));
+            expect(queryByText('application/json', { selector: 'label' })).not.toBeInTheDocument();
+        });
+        test('should renders correctly with empty languages', async () => {
+            vi.spyOn(Jotai, 'useAtom').mockImplementation((atom) => {
+                if (atom === languageAtom) {
+                    return [
+                        {
+                            activeLanguage: undefined,
+                            languages: [],
+                        },
+                        vi.fn(),
+                    ];
+                }
+                // @community-ignore
+                // For environmentAtom, return [[environment], setEnvironment] format
+                if (atom === environmentAtom) {
+                    return [[{}], vi.fn()];
+                }
+                // @community-ignore-end
+                return [{}, vi.fn()];
+            });
+            vi.spyOn(Jotai, 'useAtomValue').mockImplementation((atom) => {
+                if (atom === languageAtom) {
+                    return {
+                        activeLanguage: undefined,
+                        languages: [],
+                    };
+                }
+                if (atom === globalStoreAtom)
+                    return { options, parser };
+                // @community-ignore
+                if (atom === environmentAtom)
+                    return [{}];
+                // @community-ignore-end
+                return {};
+            });
+            vi.spyOn(useCodeSamplesModule, 'useCodeSamples').mockReturnValue({
+                samples: [], // Empty samples array
+            });
+            const optionsWithEmptyLanguages = normalizeOptions({
+                codeSamples: {
+                    languages: [],
+                },
+            });
+            operation = getOperation(parser, definition, undefined, optionsWithEmptyLanguages, '');
+            const PROPS = {
+                operation,
+                content: getMediaContent({
+                    parser,
+                    info,
+                    isRequestType: true,
+                    options: optionsWithEmptyLanguages,
+                    data: { operation },
+                }),
+            };
+            const { container } = render(withTestProviders(_jsx(RequestSamples, { ...PROPS }), {
+                definition: parser.definition,
+            }));
+            await waitFor(() => {
+                expect(container.getElementsByClassName('dropdown-wrapper').length).toBe(0);
+                expect(container.getElementsByClassName('dropdown-option').length).toBe(0);
+            });
+        });
+    });
+});
+//# sourceMappingURL=RequestSamples.test.js.map

package/lib/components/RequestSamples/__tests__/useCodeSamples.test.d.ts

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

package/lib/components/RequestSamples/__tests__/useCodeSamples.test.js

@@ -0,0 +1,64 @@
+import { vi } from 'vitest';
+import * as Jotai from 'jotai/index';
+import { getOperation } from '../../../models/index.js';
+import definition from './fixtures/operationDefinition.json';
+import { useCodeSamples } from '../useCodeSamples.js';
+import { replaceCircularJson } from '../../../models/__tests__/helpers.js';
+import { normalizeOptions, OpenAPIParser } from '../../../services/index.js';
+import petStore from './fixtures/petstore.json';
+import { globalStoreAtom } from '../../../jotai/store.js';
+// @community-ignore
+import { environmentAtom } from '../../../jotai/app.js';
+// @community-ignore-end
+vi.mock('jotai', async () => ({
+    ...(await vi.importActual('jotai')),
+    useAtomValue: vi.fn(),
+}));
+vi.mock('../../../hooks/useTranslate', () => ({
+    useTranslate: vi.fn(),
+}));
+vi.mock('@redocly/theme/ext/configure', async (importOriginal) => {
+    const actual = await importOriginal();
+    return {
+        ...actual,
+        configure: vi.fn(),
+    };
+});
+describe('useCodeSamples', () => {
+    const options = normalizeOptions({});
+    const parser = new OpenAPIParser(petStore, undefined, options);
+    test('should return all codeSamples', () => {
+        const operation = getOperation(parser, definition, undefined, options, '');
+        vi.spyOn(Jotai, 'useAtomValue').mockImplementation((atom) => {
+            if (atom === globalStoreAtom)
+                return { options, parser };
+            // @community-ignore
+            if (atom === environmentAtom)
+                return [{}, ''];
+            // @community-ignore-end
+            return {};
+        });
+        const { samples } = useCodeSamples(operation);
+        expect(JSON.stringify([samples], replaceCircularJson)).toEqual(JSON.stringify([operation.payload, ...definition['x-codeSamples']], replaceCircularJson));
+    });
+    test('should return just payload and cURL', () => {
+        const options = normalizeOptions({
+            codeSamples: {
+                languages: [{ lang: 'curl' }, { lang: 'Payload', label: 'customPayloadLabel' }],
+            },
+        });
+        const operation = getOperation(parser, definition, undefined, options, '');
+        vi.spyOn(Jotai, 'useAtomValue').mockImplementation((atom) => {
+            if (atom === globalStoreAtom)
+                return { options, parser };
+            // @community-ignore
+            if (atom === environmentAtom)
+                return [{}, ''];
+            // @community-ignore-end
+            return {};
+        });
+        const { samples } = useCodeSamples(operation);
+        expect(JSON.stringify([samples], replaceCircularJson)).toEqual(JSON.stringify([operation.payload, ...definition['x-codeSamples']], replaceCircularJson));
+    });
+});
+//# sourceMappingURL=useCodeSamples.test.js.map

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

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