@scality/data-browser-library 1.0.0-preview.9 → 1.0.1

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

@@ -1,11 +1,11 @@
 import { jsx, jsxs } from "react/jsx-runtime";
 import { fireEvent, render, screen, waitFor } from "@testing-library/react";
 import user_event from "@testing-library/user-event";
-import { MemoryRouter, Route, Routes } from "react-router-dom";
+import { MemoryRouter, Route, Routes } from "react-router";
+import { useGetBucketLifecycle, useSetBucketLifecycle } from "../../hooks/bucketConfiguration.js";
 import { createTestWrapper, findToggleByLabel, mockErrorSubmit, mockOffsetSize, mockSuccessSubmit, submitForm } from "../../test/testUtils.js";
 import { BucketLifecycleFormPage } from "../buckets/BucketLifecycleFormPage.js";
-import { useGetBucketLifecycle, useSetBucketLifecycle } from "../../hooks/bucketConfiguration.js";
-jest.mock("../../hooks/bucketConfiguration", ()=>({
+jest.mock('../../hooks/bucketConfiguration', ()=>({
         useGetBucketLifecycle: jest.fn(),
         useSetBucketLifecycle: jest.fn()
     }));
@@ -13,17 +13,17 @@ const mockUseGetBucketLifecycle = jest.mocked(useGetBucketLifecycle);
 const mockUseSetBucketLifecycle = jest.mocked(useSetBucketLifecycle);
 const mockNavigate = jest.fn();
 const mockShowToast = jest.fn();
-jest.mock("react-router-dom", ()=>({
-        ...jest.requireActual("react-router-dom"),
+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
             })
     }));
-const renderBucketLifecycleFormPage = (bucketName = "test-bucket", ruleId)=>{
+const renderBucketLifecycleFormPage = (bucketName = 'test-bucket', ruleId)=>{
     const Wrapper = createTestWrapper();
     const path = ruleId ? `/buckets/${bucketName}/lifecycle/${ruleId}/edit` : `/buckets/${bucketName}/lifecycle/create`;
     return render(/*#__PURE__*/ jsx(MemoryRouter, {
@@ -46,10 +46,10 @@ const renderBucketLifecycleFormPage = (bucketName = "test-bucket", ruleId)=>{
         })
     }));
 };
-describe("BucketLifecycleFormPage", ()=>{
+describe('BucketLifecycleFormPage', ()=>{
     const mockMutate = jest.fn();
     const enableExpirationAction = async ()=>{
-        const expirationToggle = findToggleByLabel("Expiration current version");
+        const expirationToggle = findToggleByLabel('Expiration current version');
         await user_event.click(expirationToggle);
     };
     const fillRequiredFields = async (ruleId)=>{
@@ -63,22 +63,22 @@ describe("BucketLifecycleFormPage", ()=>{
         mockOffsetSize(800, 600);
         mockUseGetBucketLifecycle.mockReturnValue({
             data: void 0,
-            status: "success"
+            status: 'success'
         });
         mockUseSetBucketLifecycle.mockReturnValue({
             mutate: mockMutate,
             isPending: false
         });
     });
-    describe("Page Rendering", ()=>{
-        it("renders create mode with correct title", ()=>{
+    describe('Page Rendering', ()=>{
+        it('renders create mode with correct title', ()=>{
             renderBucketLifecycleFormPage();
-            expect(screen.getByText("Create Lifecycle Rule")).toBeInTheDocument();
+            expect(screen.getByText('Create Lifecycle Rule')).toBeInTheDocument();
         });
-        it("renders edit mode with correct title when rule exists", async ()=>{
+        it('renders edit mode with correct title when rule exists', async ()=>{
             const existingRule = {
-                ID: "test-rule",
-                Status: "Enabled",
+                ID: 'test-rule',
+                Status: 'Enabled',
                 Filter: {},
                 Expiration: {
                     Days: 30
@@ -90,68 +90,68 @@ describe("BucketLifecycleFormPage", ()=>{
                         existingRule
                     ]
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketLifecycleFormPage("test-bucket", "test-rule");
+            renderBucketLifecycleFormPage('test-bucket', 'test-rule');
             await waitFor(()=>{
-                expect(screen.getByText("Edit Lifecycle Rule")).toBeInTheDocument();
+                expect(screen.getByText('Edit Lifecycle Rule')).toBeInTheDocument();
             });
         });
-        it("shows loading state when fetching lifecycle data", ()=>{
+        it('shows loading state when fetching lifecycle data', ()=>{
             mockUseGetBucketLifecycle.mockReturnValue({
                 data: void 0,
-                status: "pending"
+                status: 'pending'
             });
             renderBucketLifecycleFormPage();
-            expect(screen.getByText("Loading...")).toBeInTheDocument();
+            expect(screen.getByText('Loading...')).toBeInTheDocument();
         });
-        it("shows error when rule not found in edit mode", ()=>{
+        it('shows error when rule not found in edit mode', ()=>{
             mockUseGetBucketLifecycle.mockReturnValue({
                 data: {
                     Rules: []
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketLifecycleFormPage("test-bucket", "non-existent");
-            expect(screen.getByText("Rule not found")).toBeInTheDocument();
+            renderBucketLifecycleFormPage('test-bucket', 'non-existent');
+            expect(screen.getByText('Rule not found')).toBeInTheDocument();
         });
     });
-    describe("Form Fields - Initial State", ()=>{
-        it("renders required form fields in create mode", ()=>{
+    describe('Form Fields - Initial State', ()=>{
+        it('renders required form fields in create mode', ()=>{
             renderBucketLifecycleFormPage();
             expect(screen.getByLabelText(/rule id/i)).toBeInTheDocument();
             expect(screen.getByLabelText(/status/i)).toBeInTheDocument();
             expect(screen.getByLabelText(/filter/i)).toBeInTheDocument();
         });
-        it("renders all lifecycle action toggles", ()=>{
+        it('renders all lifecycle action toggles', ()=>{
             renderBucketLifecycleFormPage();
-            expect(screen.getByText("Transition current version")).toBeInTheDocument();
-            expect(screen.getByText("Expiration current version")).toBeInTheDocument();
-            expect(screen.getByText("Transition noncurrent version")).toBeInTheDocument();
-            expect(screen.getByText("Expiration noncurrent version")).toBeInTheDocument();
-            expect(screen.getByText("Expire incomplete multipart upload")).toBeInTheDocument();
+            expect(screen.getByText('Transition current version')).toBeInTheDocument();
+            expect(screen.getByText('Expiration current version')).toBeInTheDocument();
+            expect(screen.getByText('Transition noncurrent version')).toBeInTheDocument();
+            expect(screen.getByText('Expiration noncurrent version')).toBeInTheDocument();
+            expect(screen.getByText('Expire incomplete multipart upload')).toBeInTheDocument();
         });
-        it("shows all filter type options when filter select is opened", async ()=>{
+        it('shows all filter type options when filter select is opened', async ()=>{
             renderBucketLifecycleFormPage();
             const filterSelect = screen.getByLabelText(/filter/i);
             await user_event.click(filterSelect);
-            expect(screen.getByRole("option", {
-                name: "All objects"
+            expect(screen.getByRole('option', {
+                name: 'All objects'
             })).toBeInTheDocument();
-            expect(screen.getByRole("option", {
-                name: "Prefix filter"
+            expect(screen.getByRole('option', {
+                name: 'Prefix filter'
             })).toBeInTheDocument();
-            expect(screen.getByRole("option", {
-                name: "Tags filter"
+            expect(screen.getByRole('option', {
+                name: 'Tags filter'
             })).toBeInTheDocument();
-            expect(screen.getByRole("option", {
-                name: "Prefix and tags filter"
+            expect(screen.getByRole('option', {
+                name: 'Prefix and tags filter'
             })).toBeInTheDocument();
         });
-        it("disables rule ID input in edit mode", async ()=>{
+        it('disables rule ID input in edit mode', async ()=>{
             const existingRule = {
-                ID: "test-rule",
-                Status: "Enabled",
+                ID: 'test-rule',
+                Status: 'Enabled',
                 Filter: {},
                 Expiration: {
                     Days: 30
@@ -163,91 +163,91 @@ describe("BucketLifecycleFormPage", ()=>{
                         existingRule
                     ]
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketLifecycleFormPage("test-bucket", "test-rule");
+            renderBucketLifecycleFormPage('test-bucket', 'test-rule');
             await waitFor(()=>{
-                expect(screen.getByText("test-rule")).toBeInTheDocument();
+                expect(screen.getByText('test-rule')).toBeInTheDocument();
             });
-            expect(screen.queryByRole("textbox", {
+            expect(screen.queryByRole('textbox', {
                 name: /rule id/i
             })).not.toBeInTheDocument();
         });
     });
-    describe("Form Validation", ()=>{
-        it("validates rule ID is required", async ()=>{
+    describe('Form Validation', ()=>{
+        it('validates rule ID is required', async ()=>{
             renderBucketLifecycleFormPage();
             const ruleIdInput = screen.getByLabelText(/rule id/i);
-            await user_event.type(ruleIdInput, "test");
+            await user_event.type(ruleIdInput, 'test');
             await user_event.clear(ruleIdInput);
             await user_event.tab();
             await waitFor(()=>{
                 expect(screen.getByText(/rule id is required/i)).toBeInTheDocument();
             });
         });
-        it("validates rule ID uniqueness against existing rules", async ()=>{
+        it('validates rule ID uniqueness against existing rules', async ()=>{
             mockUseGetBucketLifecycle.mockReturnValue({
                 data: {
                     Rules: [
                         {
-                            ID: "existing-rule",
-                            Status: "Enabled",
+                            ID: 'existing-rule',
+                            Status: 'Enabled',
                             Expiration: {
                                 Days: 30
                             }
                         }
                     ]
                 },
-                status: "success"
+                status: 'success'
             });
             renderBucketLifecycleFormPage();
             const ruleIdInput = screen.getByLabelText(/rule id/i);
-            await user_event.type(ruleIdInput, "existing-rule");
+            await user_event.type(ruleIdInput, 'existing-rule');
             await user_event.tab();
             await waitFor(()=>{
                 expect(screen.getByText(/a rule with this id already exists/i)).toBeInTheDocument();
             });
         });
-        it("disables create button when form is pristine", ()=>{
+        it('disables create button when form is pristine', ()=>{
             renderBucketLifecycleFormPage();
-            const createButton = screen.getByRole("button", {
+            const createButton = screen.getByRole('button', {
                 name: /create/i
             });
             expect(createButton).toBeDisabled();
         });
-        it("disables create button when no lifecycle action is enabled", async ()=>{
+        it('disables create button when no lifecycle action is enabled', async ()=>{
             renderBucketLifecycleFormPage();
-            await user_event.type(screen.getByLabelText(/rule id/i), "test-rule");
-            const createButton = screen.getByRole("button", {
+            await user_event.type(screen.getByLabelText(/rule id/i), 'test-rule');
+            const createButton = screen.getByRole('button', {
                 name: /create/i
             });
             expect(createButton).toBeDisabled();
         });
-        it("enables create button when form is valid and has at least one action", async ()=>{
+        it('enables create button when form is valid and has at least one action', async ()=>{
             renderBucketLifecycleFormPage();
-            await fillRequiredFields("valid-rule");
+            await fillRequiredFields('valid-rule');
             await waitFor(()=>{
-                const createButton = screen.getByRole("button", {
+                const createButton = screen.getByRole('button', {
                     name: /create/i
                 });
                 expect(createButton).toBeEnabled();
             });
         });
     });
-    describe("Form Submission - Create Mode", ()=>{
-        it("submits minimal lifecycle rule with expiration action", async ()=>{
+    describe('Form Submission - Create Mode', ()=>{
+        it('submits minimal lifecycle rule with expiration action', async ()=>{
             renderBucketLifecycleFormPage();
-            await fillRequiredFields("minimal-rule");
+            await fillRequiredFields('minimal-rule');
             mockSuccessSubmit(mockMutate);
-            await submitForm("create");
+            await submitForm('create');
             await waitFor(()=>{
                 expect(mockMutate).toHaveBeenCalledWith(expect.objectContaining({
-                    Bucket: "test-bucket",
+                    Bucket: 'test-bucket',
                     LifecycleConfiguration: {
                         Rules: expect.arrayContaining([
                             expect.objectContaining({
-                                ID: "minimal-rule",
-                                Status: "Enabled",
+                                ID: 'minimal-rule',
+                                Status: 'Enabled',
                                 Filter: {},
                                 Expiration: {
                                     Days: 30
@@ -258,49 +258,49 @@ describe("BucketLifecycleFormPage", ()=>{
                 }), expect.any(Object));
             });
         });
-        it("navigates to bucket lifecycle tab on successful creation", async ()=>{
+        it('navigates to bucket lifecycle tab on successful creation', async ()=>{
             renderBucketLifecycleFormPage();
-            await fillRequiredFields("success-rule");
+            await fillRequiredFields('success-rule');
             mockSuccessSubmit(mockMutate);
-            await submitForm("create");
+            await submitForm('create');
             await waitFor(()=>{
-                expect(mockNavigate).toHaveBeenCalledWith("/buckets/test-bucket?tab=lifecycle");
+                expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket?tab=lifecycle');
             });
         });
-        it("displays success toast after rule creation", async ()=>{
+        it('displays success toast after rule creation', async ()=>{
             renderBucketLifecycleFormPage();
-            await fillRequiredFields("toast-rule");
+            await fillRequiredFields('toast-rule');
             mockSuccessSubmit(mockMutate);
-            await submitForm("create");
+            await submitForm('create');
             await waitFor(()=>{
                 expect(mockShowToast).toHaveBeenCalledWith({
                     open: true,
-                    message: "Lifecycle rule created successfully",
-                    status: "success"
+                    message: 'Lifecycle rule created successfully',
+                    status: 'success'
                 });
             });
         });
-        it("displays error toast when creation fails", async ()=>{
+        it('displays error toast when creation fails', async ()=>{
             renderBucketLifecycleFormPage();
-            await fillRequiredFields("error-rule");
-            mockErrorSubmit(mockMutate, "Access Denied");
-            await submitForm("create");
+            await fillRequiredFields('error-rule');
+            mockErrorSubmit(mockMutate, 'Access Denied');
+            await submitForm('create');
             await waitFor(()=>{
                 expect(mockShowToast).toHaveBeenCalledWith({
                     open: true,
-                    message: "Access Denied",
-                    status: "error"
+                    message: 'Access Denied',
+                    status: 'error'
                 });
                 expect(mockNavigate).not.toHaveBeenCalled();
             });
         });
-        it("appends new rule to existing rules on creation", async ()=>{
+        it('appends new rule to existing rules on creation', async ()=>{
             mockUseGetBucketLifecycle.mockReturnValue({
                 data: {
                     Rules: [
                         {
-                            ID: "existing-rule",
-                            Status: "Enabled",
+                            ID: 'existing-rule',
+                            Status: 'Enabled',
                             Filter: {},
                             Expiration: {
                                 Days: 90
@@ -308,25 +308,25 @@ describe("BucketLifecycleFormPage", ()=>{
                         }
                     ]
                 },
-                status: "success"
+                status: 'success'
             });
             renderBucketLifecycleFormPage();
-            await fillRequiredFields("new-rule");
+            await fillRequiredFields('new-rule');
             mockSuccessSubmit(mockMutate);
-            await submitForm("create");
+            await submitForm('create');
             await waitFor(()=>{
                 const call = mockMutate.mock.calls[0][0];
                 expect(call.LifecycleConfiguration.Rules).toHaveLength(2);
-                expect(call.LifecycleConfiguration.Rules[0].ID).toBe("existing-rule");
-                expect(call.LifecycleConfiguration.Rules[1].ID).toBe("new-rule");
+                expect(call.LifecycleConfiguration.Rules[0].ID).toBe('existing-rule');
+                expect(call.LifecycleConfiguration.Rules[1].ID).toBe('new-rule');
             });
         });
     });
-    describe("Form Submission - Edit Mode", ()=>{
-        it("updates existing rule in edit mode", async ()=>{
+    describe('Form Submission - Edit Mode', ()=>{
+        it('updates existing rule in edit mode', async ()=>{
             const existingRule = {
-                ID: "update-rule",
-                Status: "Enabled",
+                ID: 'update-rule',
+                Status: 'Enabled',
                 Filter: {},
                 Expiration: {
                     Days: 30
@@ -338,30 +338,30 @@ describe("BucketLifecycleFormPage", ()=>{
                         existingRule
                     ]
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketLifecycleFormPage("test-bucket", "update-rule");
+            renderBucketLifecycleFormPage('test-bucket', 'update-rule');
             await waitFor(()=>{
-                expect(screen.getByText("Edit Lifecycle Rule")).toBeInTheDocument();
+                expect(screen.getByText('Edit Lifecycle Rule')).toBeInTheDocument();
             });
             const statusSelect = screen.getByLabelText(/status/i);
             await user_event.click(statusSelect);
-            await user_event.click(screen.getByRole("option", {
-                name: "Disabled"
+            await user_event.click(screen.getByRole('option', {
+                name: 'Disabled'
             }));
             mockSuccessSubmit(mockMutate);
-            await submitForm("save");
+            await submitForm('save');
             await waitFor(()=>{
                 const call = mockMutate.mock.calls[0][0];
                 expect(call.LifecycleConfiguration.Rules).toHaveLength(1);
-                expect(call.LifecycleConfiguration.Rules[0].ID).toBe("update-rule");
-                expect(call.LifecycleConfiguration.Rules[0].Status).toBe("Disabled");
+                expect(call.LifecycleConfiguration.Rules[0].ID).toBe('update-rule');
+                expect(call.LifecycleConfiguration.Rules[0].Status).toBe('Disabled');
             });
         });
-        it("displays update success toast in edit mode", async ()=>{
+        it('displays update success toast in edit mode', async ()=>{
             const existingRule = {
-                ID: "edit-rule",
-                Status: "Enabled",
+                ID: 'edit-rule',
+                Status: 'Enabled',
                 Filter: {},
                 Expiration: {
                     Days: 30
@@ -373,31 +373,31 @@ describe("BucketLifecycleFormPage", ()=>{
                         existingRule
                     ]
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketLifecycleFormPage("test-bucket", "edit-rule");
+            renderBucketLifecycleFormPage('test-bucket', 'edit-rule');
             await waitFor(()=>{
-                expect(screen.getByText("Edit Lifecycle Rule")).toBeInTheDocument();
+                expect(screen.getByText('Edit Lifecycle Rule')).toBeInTheDocument();
             });
             const statusSelect = screen.getByLabelText(/status/i);
             await user_event.click(statusSelect);
-            await user_event.click(screen.getByRole("option", {
-                name: "Disabled"
+            await user_event.click(screen.getByRole('option', {
+                name: 'Disabled'
             }));
             mockSuccessSubmit(mockMutate);
-            await submitForm("save");
+            await submitForm('save');
             await waitFor(()=>{
                 expect(mockShowToast).toHaveBeenCalledWith({
                     open: true,
-                    message: "Lifecycle rule updated successfully",
-                    status: "success"
+                    message: 'Lifecycle rule updated successfully',
+                    status: 'success'
                 });
             });
         });
-        it("disables save button when form is not dirty", async ()=>{
+        it('disables save button when form is not dirty', async ()=>{
             const existingRule = {
-                ID: "unchanged-rule",
-                Status: "Enabled",
+                ID: 'unchanged-rule',
+                Status: 'Enabled',
                 Filter: {},
                 Expiration: {
                     Days: 30
@@ -409,25 +409,25 @@ describe("BucketLifecycleFormPage", ()=>{
                         existingRule
                     ]
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketLifecycleFormPage("test-bucket", "unchanged-rule");
+            renderBucketLifecycleFormPage('test-bucket', 'unchanged-rule');
             await waitFor(()=>{
-                expect(screen.getByText("Edit Lifecycle Rule")).toBeInTheDocument();
+                expect(screen.getByText('Edit Lifecycle Rule')).toBeInTheDocument();
             });
-            const saveButton = screen.getByRole("button", {
+            const saveButton = screen.getByRole('button', {
                 name: /save/i
             });
             expect(saveButton).toBeDisabled();
         });
     });
-    describe("Rule Data Loading", ()=>{
-        it("loads rule with prefix filter correctly", async ()=>{
+    describe('Rule Data Loading', ()=>{
+        it('loads rule with prefix filter correctly', async ()=>{
             const rule = {
-                ID: "prefix-rule",
-                Status: "Enabled",
+                ID: 'prefix-rule',
+                Status: 'Enabled',
                 Filter: {
-                    Prefix: "documents/"
+                    Prefix: 'documents/'
                 },
                 Expiration: {
                     Days: 90
@@ -439,22 +439,22 @@ describe("BucketLifecycleFormPage", ()=>{
                         rule
                     ]
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketLifecycleFormPage("test-bucket", "prefix-rule");
+            renderBucketLifecycleFormPage('test-bucket', 'prefix-rule');
             await waitFor(()=>{
                 const prefixInput = screen.getByLabelText(/prefix/i);
-                expect(prefixInput).toHaveValue("documents/");
+                expect(prefixInput).toHaveValue('documents/');
             });
         });
-        it("loads rule with single tag filter correctly", async ()=>{
+        it('loads rule with single tag filter correctly', async ()=>{
             const rule = {
-                ID: "tag-rule",
-                Status: "Enabled",
+                ID: 'tag-rule',
+                Status: 'Enabled',
                 Filter: {
                     Tag: {
-                        Key: "env",
-                        Value: "prod"
+                        Key: 'env',
+                        Value: 'prod'
                     }
                 },
                 Expiration: {
@@ -467,18 +467,18 @@ describe("BucketLifecycleFormPage", ()=>{
                         rule
                     ]
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketLifecycleFormPage("test-bucket", "tag-rule");
+            renderBucketLifecycleFormPage('test-bucket', 'tag-rule');
             await waitFor(()=>{
-                expect(screen.getByDisplayValue("env")).toBeInTheDocument();
-                expect(screen.getByDisplayValue("prod")).toBeInTheDocument();
+                expect(screen.getByDisplayValue('env')).toBeInTheDocument();
+                expect(screen.getByDisplayValue('prod')).toBeInTheDocument();
             });
         });
-        it("loads rule with expiration days correctly", async ()=>{
+        it('loads rule with expiration days correctly', async ()=>{
             const rule = {
-                ID: "expiration-rule",
-                Status: "Enabled",
+                ID: 'expiration-rule',
+                Status: 'Enabled',
                 Filter: {},
                 Expiration: {
                     Days: 365
@@ -490,20 +490,20 @@ describe("BucketLifecycleFormPage", ()=>{
                         rule
                     ]
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketLifecycleFormPage("test-bucket", "expiration-rule");
+            renderBucketLifecycleFormPage('test-bucket', 'expiration-rule');
             await waitFor(()=>{
-                const expirationToggle = findToggleByLabel("Expiration current version");
+                const expirationToggle = findToggleByLabel('Expiration current version');
                 expect(expirationToggle).toBeChecked();
                 const daysInput = screen.getByLabelText(/^days$/i);
                 expect(daysInput).toHaveValue(365);
             });
         });
-        it("loads rule with noncurrent version expiration correctly", async ()=>{
+        it('loads rule with noncurrent version expiration correctly', async ()=>{
             const rule = {
-                ID: "noncurrent-rule",
-                Status: "Enabled",
+                ID: 'noncurrent-rule',
+                Status: 'Enabled',
                 Filter: {},
                 NoncurrentVersionExpiration: {
                     NoncurrentDays: 90,
@@ -516,11 +516,11 @@ describe("BucketLifecycleFormPage", ()=>{
                         rule
                     ]
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketLifecycleFormPage("test-bucket", "noncurrent-rule");
+            renderBucketLifecycleFormPage('test-bucket', 'noncurrent-rule');
             await waitFor(()=>{
-                const noncurrentExpirationToggle = findToggleByLabel("Expiration noncurrent version");
+                const noncurrentExpirationToggle = findToggleByLabel('Expiration noncurrent version');
                 expect(noncurrentExpirationToggle).toBeChecked();
                 const noncurrentDaysInput = screen.getByLabelText(/noncurrent days/i);
                 expect(noncurrentDaysInput).toHaveValue(90);
@@ -528,10 +528,10 @@ describe("BucketLifecycleFormPage", ()=>{
                 expect(keepVersionsInput).toHaveValue(3);
             });
         });
-        it("loads rule with abort incomplete multipart upload correctly", async ()=>{
+        it('loads rule with abort incomplete multipart upload correctly', async ()=>{
             const rule = {
-                ID: "mpu-rule",
-                Status: "Enabled",
+                ID: 'mpu-rule',
+                Status: 'Enabled',
                 Filter: {},
                 AbortIncompleteMultipartUpload: {
                     DaysAfterInitiation: 7
@@ -543,25 +543,25 @@ describe("BucketLifecycleFormPage", ()=>{
                         rule
                     ]
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketLifecycleFormPage("test-bucket", "mpu-rule");
+            renderBucketLifecycleFormPage('test-bucket', 'mpu-rule');
             await waitFor(()=>{
-                const mpuToggle = findToggleByLabel("Expire incomplete multipart upload");
+                const mpuToggle = findToggleByLabel('Expire incomplete multipart upload');
                 expect(mpuToggle).toBeChecked();
                 const mpuDaysInput = screen.getByLabelText(/days after initiation/i);
                 expect(mpuDaysInput).toHaveValue(7);
             });
         });
-        it("loads rule with transition correctly", async ()=>{
+        it('loads rule with transition correctly', async ()=>{
             const rule = {
-                ID: "transition-rule",
-                Status: "Enabled",
+                ID: 'transition-rule',
+                Status: 'Enabled',
                 Filter: {},
                 Transitions: [
                     {
                         Days: 30,
-                        StorageClass: "GLACIER"
+                        StorageClass: 'GLACIER'
                     }
                 ]
             };
@@ -571,44 +571,44 @@ describe("BucketLifecycleFormPage", ()=>{
                         rule
                     ]
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketLifecycleFormPage("test-bucket", "transition-rule");
+            renderBucketLifecycleFormPage('test-bucket', 'transition-rule');
             await waitFor(()=>{
-                const transitionToggle = findToggleByLabel("Transition current version");
+                const transitionToggle = findToggleByLabel('Transition current version');
                 expect(transitionToggle).toBeChecked();
             });
         });
     });
-    describe("Navigation", ()=>{
-        it("navigates back to bucket lifecycle tab when cancel is clicked", ()=>{
+    describe('Navigation', ()=>{
+        it('navigates back to bucket lifecycle tab when cancel is clicked', ()=>{
             renderBucketLifecycleFormPage();
-            const cancelButton = screen.getByRole("button", {
+            const cancelButton = screen.getByRole('button', {
                 name: /cancel/i
             });
             fireEvent.click(cancelButton);
-            expect(mockNavigate).toHaveBeenCalledWith("/buckets/test-bucket?tab=lifecycle");
+            expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket?tab=lifecycle');
         });
-        it("disables cancel button when mutation is pending", ()=>{
+        it('disables cancel button when mutation is pending', ()=>{
             mockUseSetBucketLifecycle.mockReturnValue({
                 mutate: mockMutate,
                 isPending: true
             });
             renderBucketLifecycleFormPage();
-            const cancelButton = screen.getByRole("button", {
+            const cancelButton = screen.getByRole('button', {
                 name: /cancel/i
             });
             expect(cancelButton).toBeDisabled();
         });
-        it("disables submit button when mutation is pending", async ()=>{
+        it('disables submit button when mutation is pending', async ()=>{
             mockUseSetBucketLifecycle.mockReturnValue({
                 mutate: mockMutate,
                 isPending: true
             });
             renderBucketLifecycleFormPage();
-            await fillRequiredFields("test-rule");
+            await fillRequiredFields('test-rule');
             await waitFor(()=>{
-                const createButton = screen.getByRole("button", {
+                const createButton = screen.getByRole('button', {
                     name: /create/i
                 });
                 expect(createButton).toBeDisabled();