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

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'
         });
     });
 });