@scality/data-browser-library 1.0.0-preview.11 → 1.0.0-preview.15

package/dist/components/DataBrowserUI.d.ts

@@ -0,0 +1,27 @@
+import React from 'react';
+import type { DataBrowserUIProps } from '../config/types';
+/**
+ * DataBrowserUI component - Main UI component for data browser.
+ * Must be wrapped with DataBrowserProvider for S3 client and theme context,
+ * and a BrowserRouter for routing.
+ *
+ * Uses relative routing for route definitions, but absolute paths for navigation.
+ * Pass basePath to DataBrowserUI to specify where the UI is mounted.
+ *
+ * @example
+ * ```tsx
+ * <BrowserRouter>
+ *   <DataBrowserProvider
+ *     getS3Config={getS3Config}
+ *     theme={theme}
+ *   >
+ *     <Routes>
+ *       <Route path="/accounts/:accountName/buckets/*" element={
+ *         <DataBrowserUI basePath="/accounts/my-account" />
+ *       } />
+ *     </Routes>
+ *   </DataBrowserProvider>
+ * </BrowserRouter>
+ * ```
+ */
+export declare const DataBrowserUI: React.FC<DataBrowserUIProps>;

package/dist/components/DataBrowserUI.js

@@ -0,0 +1,88 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import "react";
+import { Route, Routes } from "react-router";
+import styled_components from "styled-components";
+import { DataBrowserUICustomizationProvider } from "../contexts/DataBrowserUICustomizationContext.js";
+import { BucketCreate, BucketLifecycleFormPage, BucketNotificationCreatePage, BucketPage, BucketPolicyPage, BucketReplicationFormPage, ObjectLockSettings, ObjectPage } from "./index.js";
+import { useS3ConfigSwitch } from "../hooks/useS3ConfigSwitch.js";
+import { AppContainer } from "@scality/core-ui";
+const RoutesContainer = styled_components.div`
+  flex: 1;
+  display: flex;
+  flex-direction: column;
+  width: 100%;
+  overflow: hidden;
+`;
+const DataBrowserUIContent = ({ header })=>{
+    useS3ConfigSwitch();
+    return /*#__PURE__*/ jsx(AppContainer, {
+        children: [
+            ...header ? [
+                /*#__PURE__*/ jsx(AppContainer.ContextContainer, {
+                    children: /*#__PURE__*/ jsx("div", {
+                        children: header
+                    })
+                }, "header")
+            ] : [],
+            /*#__PURE__*/ jsx(AppContainer.MainContent, {
+                children: /*#__PURE__*/ jsx(RoutesContainer, {
+                    children: /*#__PURE__*/ jsxs(Routes, {
+                        children: [
+                            /*#__PURE__*/ jsx(Route, {
+                                index: true,
+                                element: /*#__PURE__*/ jsx(BucketPage, {})
+                            }),
+                            /*#__PURE__*/ jsx(Route, {
+                                path: "-/create",
+                                element: /*#__PURE__*/ jsx(BucketCreate, {})
+                            }),
+                            /*#__PURE__*/ jsx(Route, {
+                                path: ":bucketName/objects/object-lock-settings",
+                                element: /*#__PURE__*/ jsx(ObjectLockSettings, {})
+                            }),
+                            /*#__PURE__*/ jsx(Route, {
+                                path: ":bucketName/lifecycle/edit/:ruleId",
+                                element: /*#__PURE__*/ jsx(BucketLifecycleFormPage, {})
+                            }),
+                            /*#__PURE__*/ jsx(Route, {
+                                path: ":bucketName/lifecycle/create",
+                                element: /*#__PURE__*/ jsx(BucketLifecycleFormPage, {})
+                            }),
+                            /*#__PURE__*/ jsx(Route, {
+                                path: ":bucketName/replication/edit/:ruleId",
+                                element: /*#__PURE__*/ jsx(BucketReplicationFormPage, {})
+                            }),
+                            /*#__PURE__*/ jsx(Route, {
+                                path: ":bucketName/replication/create",
+                                element: /*#__PURE__*/ jsx(BucketReplicationFormPage, {})
+                            }),
+                            /*#__PURE__*/ jsx(Route, {
+                                path: ":bucketName/notifications/create",
+                                element: /*#__PURE__*/ jsx(BucketNotificationCreatePage, {})
+                            }),
+                            /*#__PURE__*/ jsx(Route, {
+                                path: ":bucketName/objects",
+                                element: /*#__PURE__*/ jsx(ObjectPage, {})
+                            }),
+                            /*#__PURE__*/ jsx(Route, {
+                                path: ":bucketName/policy",
+                                element: /*#__PURE__*/ jsx(BucketPolicyPage, {})
+                            }),
+                            /*#__PURE__*/ jsx(Route, {
+                                path: ":bucketName/*",
+                                element: /*#__PURE__*/ jsx(BucketPage, {})
+                            })
+                        ]
+                    })
+                })
+            }, "main")
+        ]
+    });
+};
+const DataBrowserUI = (props)=>/*#__PURE__*/ jsx(DataBrowserUICustomizationProvider, {
+        config: props,
+        children: /*#__PURE__*/ jsx(DataBrowserUIContent, {
+            header: props.header
+        })
+    });
+export { DataBrowserUI };

package/dist/components/Editor.d.ts

@@ -1,4 +1,4 @@
-import { EditorProps, BeforeMount } from "@monaco-editor/react";
+import { EditorProps, BeforeMount } from '@monaco-editor/react';
 interface EditorComponentProps {
     value: string;
     onChange: (value: string | undefined) => void;

package/dist/components/Editor.js

@@ -1,7 +1,7 @@
 import { jsx } from "react/jsx-runtime";
 import react from "@monaco-editor/react";
-const Editor = ({ value, onChange, readOnly = false, language = "json", height = "400px", width = "100%", beforeMount, ...rest })=>{
-    const editorTheme = "vs-dark";
+const Editor = ({ value, onChange, readOnly = false, language = 'json', height = '400px', width = '100%', beforeMount, ...rest })=>{
+    const editorTheme = 'vs-dark';
     return /*#__PURE__*/ jsx(react, {
         height: height,
         width: width,
@@ -16,7 +16,7 @@ const Editor = ({ value, onChange, readOnly = false, language = "json", height =
                 enabled: false
             },
             fontSize: 12,
-            lineNumbers: "on",
+            lineNumbers: 'on',
             automaticLayout: true,
             formatOnPaste: true,
             formatOnType: true

package/dist/components/__tests__/BucketCreate.test.js

@@ -1,11 +1,11 @@
 import { jsx } from "react/jsx-runtime";
 import { fireEvent, render, screen, waitFor } from "@testing-library/react";
 import user_event from "@testing-library/user-event";
-import { MemoryRouter } from "react-router-dom";
+import { MemoryRouter } from "react-router";
 import { createMockMutationResult, createTestWrapper } from "../../test/testUtils.js";
 import { BucketCreate } from "../buckets/BucketCreate.js";
 import { useCreateBucket, useSetBucketObjectLockConfiguration, useSetBucketVersioning } from "../../hooks/index.js";
-jest.mock("../../hooks", ()=>({
+jest.mock('../../hooks', ()=>({
         useCreateBucket: jest.fn(),
         useSetBucketVersioning: jest.fn(),
         useSetBucketObjectLockConfiguration: jest.fn()
@@ -15,12 +15,12 @@ const mockUseSetBucketVersioning = jest.mocked(useSetBucketVersioning);
 const mockUseSetBucketObjectLockConfiguration = jest.mocked(useSetBucketObjectLockConfiguration);
 const mockNavigate = jest.fn();
 const mockShowToast = jest.fn();
-jest.mock("react-router", ()=>({
-        ...jest.requireActual("react-router"),
+jest.mock('react-router', ()=>({
+        ...jest.requireActual('react-router'),
         useNavigate: ()=>mockNavigate
     }));
-jest.mock("@scality/core-ui", ()=>({
-        ...jest.requireActual("@scality/core-ui"),
+jest.mock('@scality/core-ui', ()=>({
+        ...jest.requireActual('@scality/core-ui'),
         useToast: ()=>({
                 showToast: mockShowToast
             })
@@ -51,108 +51,108 @@ const fillBucketName = async (name)=>{
 };
 const submitForm = async ()=>{
     await waitFor(()=>{
-        const createButton = screen.getByRole("button", {
+        const createButton = screen.getByRole('button', {
             name: /^create$/i
         });
         expect(createButton).not.toBeDisabled();
     }, {
         timeout: 3000
     });
-    const createButton = screen.getByRole("button", {
+    const createButton = screen.getByRole('button', {
         name: /^create$/i
     });
     await user_event.click(createButton);
 };
-describe("BucketCreate", ()=>{
+describe('BucketCreate', ()=>{
     beforeEach(()=>{
         jest.clearAllMocks();
         setupMocks();
     });
-    it("renders form with required fields", ()=>{
+    it('renders form with required fields', ()=>{
         renderBucketCreate();
-        expect(screen.getByText("Create a New Bucket")).toBeInTheDocument();
+        expect(screen.getByText('Create a New Bucket')).toBeInTheDocument();
         expect(screen.getByLabelText(/bucket name/i)).toBeInTheDocument();
-        expect(screen.getByText("Versioning")).toBeInTheDocument();
-        expect(screen.getByText("Object-lock")).toBeInTheDocument();
+        expect(screen.getByText('Versioning')).toBeInTheDocument();
+        expect(screen.getByText('Object-lock')).toBeInTheDocument();
     });
-    it("shows validation error for invalid bucket name with uppercase", async ()=>{
+    it('shows validation error for invalid bucket name with uppercase', async ()=>{
         renderBucketCreate();
-        await user_event.type(screen.getByLabelText(/bucket name/i), "INVALID");
+        await user_event.type(screen.getByLabelText(/bucket name/i), 'INVALID');
         await user_event.tab();
         await waitFor(()=>{
             expect(screen.getByText(/bucket names can include only lowercase/i)).toBeInTheDocument();
         });
     });
-    it("shows validation error for bucket name starting with hyphen", async ()=>{
+    it('shows validation error for bucket name starting with hyphen', async ()=>{
         renderBucketCreate();
-        await user_event.type(screen.getByLabelText(/bucket name/i), "-invalid");
+        await user_event.type(screen.getByLabelText(/bucket name/i), '-invalid');
         await user_event.tab();
         await waitFor(()=>{
             expect(screen.getByText(/bucket names can include only lowercase/i)).toBeInTheDocument();
         });
     });
-    it("shows validation error for bucket name ending with hyphen", async ()=>{
+    it('shows validation error for bucket name ending with hyphen', async ()=>{
         renderBucketCreate();
-        await user_event.type(screen.getByLabelText(/bucket name/i), "invalid-");
+        await user_event.type(screen.getByLabelText(/bucket name/i), 'invalid-');
         await user_event.tab();
         await waitFor(()=>{
             expect(screen.getByText(/bucket names can include only lowercase/i)).toBeInTheDocument();
         });
     });
-    it("shows validation error for bucket name with adjacent periods", async ()=>{
+    it('shows validation error for bucket name with adjacent periods', async ()=>{
         renderBucketCreate();
-        await user_event.type(screen.getByLabelText(/bucket name/i), "test..bucket");
+        await user_event.type(screen.getByLabelText(/bucket name/i), 'test..bucket');
         await user_event.tab();
         await waitFor(()=>{
             expect(screen.getByText(/bucket names cannot contain two adjacent periods/i)).toBeInTheDocument();
         });
     });
-    it("shows validation error for bucket name formatted as IP address", async ()=>{
+    it('shows validation error for bucket name formatted as IP address', async ()=>{
         renderBucketCreate();
-        await user_event.type(screen.getByLabelText(/bucket name/i), "192.168.1.1");
+        await user_event.type(screen.getByLabelText(/bucket name/i), '192.168.1.1');
         await user_event.tab();
         await waitFor(()=>{
             expect(screen.getByText(/bucket names must not be formatted as an ip address/i)).toBeInTheDocument();
         });
     });
-    it("shows validation error for bucket name with forbidden prefix", async ()=>{
+    it('shows validation error for bucket name with forbidden prefix', async ()=>{
         renderBucketCreate();
-        await user_event.type(screen.getByLabelText(/bucket name/i), "xn--test");
+        await user_event.type(screen.getByLabelText(/bucket name/i), 'xn--test');
         await user_event.tab();
         await waitFor(()=>{
             expect(screen.getByText(/bucket names must not start with/i)).toBeInTheDocument();
         });
     });
-    it("shows validation error for bucket name with forbidden suffix", async ()=>{
+    it('shows validation error for bucket name with forbidden suffix', async ()=>{
         renderBucketCreate();
-        await user_event.type(screen.getByLabelText(/bucket name/i), "test-s3alias");
+        await user_event.type(screen.getByLabelText(/bucket name/i), 'test-s3alias');
         await user_event.tab();
         await waitFor(()=>{
             expect(screen.getByText(/bucket names must not end with/i)).toBeInTheDocument();
         });
     });
-    it("shows validation error for duplicate bucket name when context provided", async ()=>{
+    it('shows validation error for duplicate bucket name when context provided', async ()=>{
         renderBucketCreate({
             validationContext: {
                 existingBuckets: [
-                    "existing-bucket",
-                    "another-bucket"
+                    'existing-bucket',
+                    'another-bucket'
                 ]
             }
         });
-        await user_event.type(screen.getByLabelText(/bucket name/i), "existing-bucket");
+        await user_event.type(screen.getByLabelText(/bucket name/i), 'existing-bucket');
         await user_event.tab();
         await waitFor(()=>{
             expect(screen.getByText(/a bucket with this name already exists/i)).toBeInTheDocument();
         });
     });
-    it("accepts valid bucket names with dots and hyphens", async ()=>{
+    it('accepts valid bucket names with dots and hyphens', async ()=>{
         renderBucketCreate();
         const validNames = [
-            "my-bucket-123",
-            "my.bucket.name",
-            "test-bucket.example",
-            "123-bucket-456"
+            'my-bucket-123',
+            'my.bucket.name',
+            'test-bucket.example',
+            '123-bucket-456'
         ];
         for (const name of validNames){
             const input = screen.getByLabelText(/bucket name/i);
@@ -166,79 +166,79 @@ describe("BucketCreate", ()=>{
             });
         }
     });
-    it("allows bucket creation when name is unique", async ()=>{
+    it('allows bucket creation when name is unique', async ()=>{
         renderBucketCreate({
             validationContext: {
                 existingBuckets: [
-                    "existing-bucket",
-                    "another-bucket"
+                    'existing-bucket',
+                    'another-bucket'
                 ]
             }
         });
-        await fillBucketName("new-unique-bucket");
+        await fillBucketName('new-unique-bucket');
         await waitFor(()=>{
-            expect(screen.getByRole("button", {
+            expect(screen.getByRole('button', {
                 name: /^create$/i
             })).not.toBeDisabled();
         });
     });
-    it("disables create button when form is invalid", ()=>{
+    it('disables create button when form is invalid', ()=>{
         renderBucketCreate();
-        expect(screen.getByRole("button", {
+        expect(screen.getByRole('button', {
             name: /^create$/i
         })).toBeDisabled();
     });
-    it("enables create button when bucket name is valid", async ()=>{
+    it('enables create button when bucket name is valid', async ()=>{
         renderBucketCreate();
-        await fillBucketName("test-bucket");
+        await fillBucketName('test-bucket');
         await waitFor(()=>{
-            expect(screen.getByRole("button", {
+            expect(screen.getByRole('button', {
                 name: /^create$/i
             })).not.toBeDisabled();
         });
     });
-    it("creates bucket with basic configuration", async ()=>{
+    it('creates bucket with basic configuration', async ()=>{
         renderBucketCreate();
-        await fillBucketName("test-bucket");
+        await fillBucketName('test-bucket');
         await submitForm();
         expect(mockMutations.createBucket).toHaveBeenCalledWith({
-            Bucket: "test-bucket",
+            Bucket: 'test-bucket',
             ObjectLockEnabledForBucket: void 0
         }, expect.objectContaining({
             onSuccess: expect.any(Function),
             onError: expect.any(Function)
         }));
     });
-    it("shows success toast and navigates after bucket creation", async ()=>{
+    it('shows success toast and navigates after bucket creation', async ()=>{
         renderBucketCreate();
-        await fillBucketName("my-bucket");
+        await fillBucketName('my-bucket');
         await submitForm();
         const successCallback = mockMutations.createBucket.mock.calls[0][1].onSuccess;
         successCallback();
         expect(mockShowToast).toHaveBeenCalledWith({
             open: true,
             message: 'Bucket "my-bucket" created successfully',
-            status: "success"
+            status: 'success'
         });
-        expect(mockNavigate).toHaveBeenCalledWith("/buckets/my-bucket");
+        expect(mockNavigate).toHaveBeenCalledWith('/buckets/my-bucket');
     });
-    it("shows error toast when bucket creation fails", async ()=>{
+    it('shows error toast when bucket creation fails', async ()=>{
         renderBucketCreate();
-        await fillBucketName("test-bucket");
+        await fillBucketName('test-bucket');
         await submitForm();
         const errorCallback = mockMutations.createBucket.mock.calls[0][1].onError;
-        const error = new Error("Bucket already exists");
+        const error = new Error('Bucket already exists');
         errorCallback(error);
         expect(mockShowToast).toHaveBeenCalledWith({
             open: true,
-            message: "Bucket already exists",
-            status: "error"
+            message: 'Bucket already exists',
+            status: 'error'
         });
     });
-    it("enables versioning when requested", async ()=>{
+    it('enables versioning when requested', async ()=>{
         renderBucketCreate();
-        await fillBucketName("test-bucket");
-        const versioningCheckbox = screen.getByRole("checkbox", {
+        await fillBucketName('test-bucket');
+        const versioningCheckbox = screen.getByRole('checkbox', {
             name: /versioning/i
         });
         await user_event.click(versioningCheckbox);
@@ -246,32 +246,32 @@ describe("BucketCreate", ()=>{
         const successCallback = mockMutations.createBucket.mock.calls[0][1].onSuccess;
         successCallback();
         expect(mockMutations.setVersioning).toHaveBeenCalledWith({
-            Bucket: "test-bucket",
+            Bucket: 'test-bucket',
             VersioningConfiguration: {
-                Status: "Enabled"
+                Status: 'Enabled'
             }
         }, expect.objectContaining({
             onSuccess: expect.any(Function),
             onError: expect.any(Function)
         }));
     });
-    it("disables versioning checkbox when object lock is enabled", async ()=>{
+    it('disables versioning checkbox when object lock is enabled', async ()=>{
         renderBucketCreate();
-        await fillBucketName("test-bucket");
-        const objectLockCheckbox = screen.getByRole("checkbox", {
+        await fillBucketName('test-bucket');
+        const objectLockCheckbox = screen.getByRole('checkbox', {
             name: /object-lock/i
         });
         await user_event.click(objectLockCheckbox);
-        const versioningCheckbox = screen.getByRole("checkbox", {
+        const versioningCheckbox = screen.getByRole('checkbox', {
             name: /versioning/i
         });
         expect(versioningCheckbox).toBeDisabled();
         expect(screen.getByText(/automatically activated when object-lock is enabled/i)).toBeInTheDocument();
     });
-    it("enables versioning automatically when object lock is enabled", async ()=>{
+    it('enables versioning automatically when object lock is enabled', async ()=>{
         renderBucketCreate();
-        await fillBucketName("test-bucket");
-        const objectLockCheckbox = screen.getByRole("checkbox", {
+        await fillBucketName('test-bucket');
+        const objectLockCheckbox = screen.getByRole('checkbox', {
             name: /object-lock/i
         });
         await user_event.click(objectLockCheckbox);
@@ -283,13 +283,13 @@ describe("BucketCreate", ()=>{
         successCallback();
         expect(mockMutations.setVersioning).not.toHaveBeenCalled();
     });
-    it("configures object lock retention when enabled", async ()=>{
+    it('configures object lock retention when enabled', async ()=>{
         renderBucketCreate();
-        await fillBucketName("test-bucket");
-        await user_event.click(screen.getByRole("checkbox", {
+        await fillBucketName('test-bucket');
+        await user_event.click(screen.getByRole('checkbox', {
             name: /object-lock/i
         }));
-        await user_event.click(screen.getByRole("checkbox", {
+        await user_event.click(screen.getByRole('checkbox', {
             name: /default retention/i
         }));
         await submitForm();
@@ -297,12 +297,12 @@ describe("BucketCreate", ()=>{
         createSuccessCallback();
         expect(mockMutations.setVersioning).not.toHaveBeenCalled();
         expect(mockMutations.setObjectLock).toHaveBeenCalledWith({
-            Bucket: "test-bucket",
+            Bucket: 'test-bucket',
             ObjectLockConfiguration: {
-                ObjectLockEnabled: "Enabled",
+                ObjectLockEnabled: 'Enabled',
                 Rule: {
                     DefaultRetention: {
-                        Mode: "GOVERNANCE",
+                        Mode: 'GOVERNANCE',
                         Days: 1,
                         Years: void 0
                     }
@@ -313,83 +313,83 @@ describe("BucketCreate", ()=>{
             onError: expect.any(Function)
         }));
     });
-    it("calls custom onSubmit when provided", async ()=>{
+    it('calls custom onSubmit when provided', async ()=>{
         const customSubmit = jest.fn();
         renderBucketCreate({
             onSubmit: customSubmit
         });
-        await fillBucketName("test-bucket");
+        await fillBucketName('test-bucket');
         await submitForm();
         expect(customSubmit).toHaveBeenCalledWith(expect.objectContaining({
-            name: "test-bucket",
+            name: 'test-bucket',
             isVersioning: false,
             isObjectLockEnabled: false
         }));
         expect(mockMutations.createBucket).not.toHaveBeenCalled();
     });
-    it("calls custom onCancel when provided", ()=>{
+    it('calls custom onCancel when provided', ()=>{
         const customCancel = jest.fn();
         renderBucketCreate({
             onCancel: customCancel
         });
-        const cancelButton = screen.getByRole("button", {
+        const cancelButton = screen.getByRole('button', {
             name: /cancel/i
         });
         fireEvent.click(cancelButton);
         expect(customCancel).toHaveBeenCalled();
         expect(mockNavigate).not.toHaveBeenCalled();
     });
-    it("navigates to buckets list when cancel is clicked without custom handler", ()=>{
+    it('navigates to buckets list when cancel is clicked without custom handler', ()=>{
         renderBucketCreate();
-        const cancelButton = screen.getByRole("button", {
+        const cancelButton = screen.getByRole('button', {
             name: /cancel/i
         });
         fireEvent.click(cancelButton);
-        expect(mockNavigate).toHaveBeenCalledWith("/buckets");
+        expect(mockNavigate).toHaveBeenCalledWith('/buckets');
     });
-    it("renders injected children", ()=>{
+    it('renders injected children', ()=>{
         renderBucketCreate({
             children: /*#__PURE__*/ jsx("div", {
                 "data-testid": "custom-field",
                 children: "Custom Field"
             })
         });
-        expect(screen.getByTestId("custom-field")).toBeInTheDocument();
+        expect(screen.getByTestId('custom-field')).toBeInTheDocument();
     });
-    it("shows loading state during bucket creation", async ()=>{
+    it('shows loading state during bucket creation', async ()=>{
         renderBucketCreate();
-        await fillBucketName("test-bucket");
+        await fillBucketName('test-bucket');
         await submitForm();
         setupMocks({
             isPending: true
         });
         expect(mockMutations.createBucket).toHaveBeenCalled();
     });
-    it("shows error toast when versioning configuration fails", async ()=>{
+    it('shows error toast when versioning configuration fails', async ()=>{
         renderBucketCreate();
-        await fillBucketName("test-bucket");
-        await user_event.click(screen.getByRole("checkbox", {
+        await fillBucketName('test-bucket');
+        await user_event.click(screen.getByRole('checkbox', {
             name: /versioning/i
         }));
         await submitForm();
         const createSuccessCallback = mockMutations.createBucket.mock.calls[0][1].onSuccess;
         createSuccessCallback();
         const versioningErrorCallback = mockMutations.setVersioning.mock.calls[0][1].onError;
-        const error = new Error("Failed to enable versioning");
+        const error = new Error('Failed to enable versioning');
         versioningErrorCallback(error);
         expect(mockShowToast).toHaveBeenCalledWith({
             open: true,
-            message: "Failed to enable versioning",
-            status: "error"
+            message: 'Failed to enable versioning',
+            status: 'error'
         });
     });
-    it("shows error toast when object lock configuration fails", async ()=>{
+    it('shows error toast when object lock configuration fails', async ()=>{
         renderBucketCreate();
-        await fillBucketName("test-bucket");
-        await user_event.click(screen.getByRole("checkbox", {
+        await fillBucketName('test-bucket');
+        await user_event.click(screen.getByRole('checkbox', {
             name: /object-lock/i
         }));
-        await user_event.click(screen.getByRole("checkbox", {
+        await user_event.click(screen.getByRole('checkbox', {
             name: /default retention/i
         }));
         await submitForm();
@@ -397,12 +397,12 @@ describe("BucketCreate", ()=>{
         createSuccessCallback();
         expect(mockMutations.setVersioning).not.toHaveBeenCalled();
         const objectLockErrorCallback = mockMutations.setObjectLock.mock.calls[0][1].onError;
-        const error = new Error("Failed to configure retention");
+        const error = new Error('Failed to configure retention');
         objectLockErrorCallback(error);
         expect(mockShowToast).toHaveBeenCalledWith({
             open: true,
-            message: "Failed to configure retention",
-            status: "error"
+            message: 'Failed to configure retention',
+            status: 'error'
         });
     });
 });

package/dist/components/__tests__/BucketDetails.test.d.ts

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