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

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

@@ -1,16 +1,16 @@
 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 { createTestWrapper, findToggleByLabel, mockErrorSubmit, mockOffsetSize, mockSuccessSubmit, submitForm } from "../../test/testUtils.js";
-import { BucketReplicationFormPage } from "../buckets/BucketReplicationFormPage.js";
+import { MemoryRouter, Route, Routes } from "react-router";
 import { useGetBucketReplication, useSetBucketReplication } from "../../hooks/bucketConfiguration.js";
 import { useBuckets } from "../../hooks/bucketOperations.js";
-jest.mock("../../hooks/bucketConfiguration", ()=>({
+import { createTestWrapper, findToggleByLabel, mockErrorSubmit, mockOffsetSize, mockSuccessSubmit, submitForm } from "../../test/testUtils.js";
+import { BucketReplicationFormPage } from "../buckets/BucketReplicationFormPage.js";
+jest.mock('../../hooks/bucketConfiguration', ()=>({
         useGetBucketReplication: jest.fn(),
         useSetBucketReplication: jest.fn()
     }));
-jest.mock("../../hooks/bucketOperations", ()=>({
+jest.mock('../../hooks/bucketOperations', ()=>({
         useBuckets: jest.fn()
     }));
 const mockUseGetBucketReplication = jest.mocked(useGetBucketReplication);
@@ -18,17 +18,17 @@ const mockUseSetBucketReplication = jest.mocked(useSetBucketReplication);
 const mockUseBuckets = jest.mocked(useBuckets);
 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 renderBucketReplicationFormPage = (bucketName = "test-bucket", ruleId)=>{
+const renderBucketReplicationFormPage = (bucketName = 'test-bucket', ruleId)=>{
     const Wrapper = createTestWrapper();
     const path = ruleId ? `/buckets/${bucketName}/replication/${ruleId}/edit` : `/buckets/${bucketName}/replication/create`;
     return render(/*#__PURE__*/ jsx(MemoryRouter, {
@@ -51,15 +51,15 @@ const renderBucketReplicationFormPage = (bucketName = "test-bucket", ruleId)=>{
         })
     }));
 };
-describe("BucketReplicationFormPage", ()=>{
+describe('BucketReplicationFormPage', ()=>{
     const mockMutate = jest.fn();
     const fillRequiredFields = async (options)=>{
-        const { roleArn = "arn:aws:iam::123456789012:role/replication-role", ruleId, targetBucket = "destination-bucket" } = options;
+        const { roleArn = 'arn:aws:iam::123456789012:role/replication-role', ruleId, targetBucket = 'destination-bucket' } = options;
         await user_event.type(screen.getByLabelText(/role arn/i), roleArn);
         await user_event.type(screen.getByLabelText(/rule id/i), ruleId);
         const targetBucketSelect = screen.getByLabelText(/target bucket/i);
         await user_event.click(targetBucketSelect);
-        await user_event.click(screen.getByRole("option", {
+        await user_event.click(screen.getByRole('option', {
             name: targetBucket
         }));
     };
@@ -70,7 +70,7 @@ describe("BucketReplicationFormPage", ()=>{
         mockOffsetSize(800, 600);
         mockUseGetBucketReplication.mockReturnValue({
             data: void 0,
-            status: "success"
+            status: 'success'
         });
         mockUseSetBucketReplication.mockReturnValue({
             mutate: mockMutate,
@@ -80,153 +80,153 @@ describe("BucketReplicationFormPage", ()=>{
             data: {
                 Buckets: [
                     {
-                        Name: "test-bucket"
+                        Name: 'test-bucket'
                     },
                     {
-                        Name: "destination-bucket"
+                        Name: 'destination-bucket'
                     },
                     {
-                        Name: "backup-bucket"
+                        Name: 'backup-bucket'
                     }
                 ]
             },
-            status: "success"
+            status: 'success'
         });
     });
-    describe("Page Rendering", ()=>{
-        it("renders create mode with correct title", ()=>{
+    describe('Page Rendering', ()=>{
+        it('renders create mode with correct title', ()=>{
             renderBucketReplicationFormPage();
-            expect(screen.getByText("Create Replication Rule")).toBeInTheDocument();
+            expect(screen.getByText('Create Replication 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',
                 Priority: 1,
                 Destination: {
-                    Bucket: "arn:aws:s3:::destination-bucket"
+                    Bucket: 'arn:aws:s3:::destination-bucket'
                 }
             };
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/replication-role",
+                        Role: 'arn:aws:iam::123456789012:role/replication-role',
                         Rules: [
                             existingRule
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "test-rule");
+            renderBucketReplicationFormPage('test-bucket', 'test-rule');
             await waitFor(()=>{
-                expect(screen.getByText("Edit Replication Rule")).toBeInTheDocument();
+                expect(screen.getByText('Edit Replication Rule')).toBeInTheDocument();
             });
         });
-        it("shows loading state when fetching replication data", ()=>{
+        it('shows loading state when fetching replication data', ()=>{
             mockUseGetBucketReplication.mockReturnValue({
                 data: void 0,
-                status: "pending"
+                status: 'pending'
             });
             renderBucketReplicationFormPage();
-            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', ()=>{
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/replication-role",
+                        Role: 'arn:aws:iam::123456789012:role/replication-role',
                         Rules: []
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "non-existent");
-            expect(screen.getByText("Rule not found")).toBeInTheDocument();
+            renderBucketReplicationFormPage('test-bucket', 'non-existent');
+            expect(screen.getByText('Rule not found')).toBeInTheDocument();
         });
-        it("displays all form sections", async ()=>{
+        it('displays all form sections', async ()=>{
             renderBucketReplicationFormPage();
             await waitFor(()=>{
                 expect(screen.getByLabelText(/role arn/i)).toBeInTheDocument();
                 expect(screen.getByLabelText(/rule id/i)).toBeInTheDocument();
-                expect(screen.getByText("Replicate encrypted objects")).toBeInTheDocument();
-                expect(screen.getByText("Delete marker replication")).toBeInTheDocument();
+                expect(screen.getByText('Replicate encrypted objects')).toBeInTheDocument();
+                expect(screen.getByText('Delete marker replication')).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', ()=>{
             renderBucketReplicationFormPage();
             expect(screen.getByLabelText(/role arn/i)).toBeInTheDocument();
             expect(screen.getByLabelText(/rule id/i)).toBeInTheDocument();
             expect(screen.getByLabelText(/status/i)).toBeInTheDocument();
             expect(screen.getByLabelText(/target bucket/i)).toBeInTheDocument();
         });
-        it("shows Role ARN input when no existing rules", ()=>{
+        it('shows Role ARN input when no existing rules', ()=>{
             renderBucketReplicationFormPage();
             const roleInput = screen.getByLabelText(/role arn/i);
             expect(roleInput).toBeInTheDocument();
-            expect(roleInput.tagName).toBe("INPUT");
+            expect(roleInput.tagName).toBe('INPUT');
         });
-        it("displays existing Role as read-only text when rules exist", ()=>{
+        it('displays existing Role as read-only text when rules exist', ()=>{
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/existing-role",
+                        Role: 'arn:aws:iam::123456789012:role/existing-role',
                         Rules: [
                             {
-                                ID: "existing-rule",
-                                Status: "Enabled",
+                                ID: 'existing-rule',
+                                Status: 'Enabled',
                                 Priority: 1,
                                 Destination: {
-                                    Bucket: "arn:aws:s3:::bucket"
+                                    Bucket: 'arn:aws:s3:::bucket'
                                 }
                             }
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
             renderBucketReplicationFormPage();
-            expect(screen.getByText("arn:aws:iam::123456789012:role/existing-role")).toBeInTheDocument();
+            expect(screen.getByText('arn:aws:iam::123456789012:role/existing-role')).toBeInTheDocument();
             expect(screen.getByText(/to change the role, edit it through bucket/i)).toBeInTheDocument();
             expect(screen.queryByPlaceholderText(/arn:aws:iam/)).not.toBeInTheDocument();
         });
-        it("shows Rule ID input in create mode", ()=>{
+        it('shows Rule ID input in create mode', ()=>{
             renderBucketReplicationFormPage();
             const ruleIdInput = screen.getByLabelText(/rule id/i);
             expect(ruleIdInput).toBeInTheDocument();
-            expect(ruleIdInput.tagName).toBe("INPUT");
+            expect(ruleIdInput.tagName).toBe('INPUT');
         });
-        it("displays Rule ID as read-only text in edit mode", async ()=>{
+        it('displays Rule ID as read-only text in edit mode', async ()=>{
             const existingRule = {
-                ID: "readonly-rule-id",
-                Status: "Enabled",
+                ID: 'readonly-rule-id',
+                Status: 'Enabled',
                 Priority: 1,
                 Destination: {
-                    Bucket: "arn:aws:s3:::bucket"
+                    Bucket: 'arn:aws:s3:::bucket'
                 }
             };
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             existingRule
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "readonly-rule-id");
+            renderBucketReplicationFormPage('test-bucket', 'readonly-rule-id');
             await waitFor(()=>{
-                expect(screen.getByText("readonly-rule-id")).toBeInTheDocument();
+                expect(screen.getByText('readonly-rule-id')).toBeInTheDocument();
             });
-            expect(screen.queryByRole("textbox", {
+            expect(screen.queryByRole('textbox', {
                 name: /rule id/i
             })).not.toBeInTheDocument();
         });
-        it("renders Status select field", async ()=>{
+        it('renders Status select field', async ()=>{
             renderBucketReplicationFormPage();
             await waitFor(()=>{
                 expect(screen.getByLabelText(/rule id/i)).toBeInTheDocument();
@@ -234,189 +234,189 @@ describe("BucketReplicationFormPage", ()=>{
             const statusElement = document.querySelector('[id="status"]');
             expect(statusElement).toBeInTheDocument();
         });
-        it("renders Priority number input with auto-assigned placeholder", ()=>{
+        it('renders Priority number input with auto-assigned placeholder', ()=>{
             renderBucketReplicationFormPage();
             const priorityInput = screen.getByLabelText(/rule priority/i);
             expect(priorityInput).toBeInTheDocument();
-            expect(priorityInput).toHaveAttribute("placeholder", "Example: Auto-assigned: 0");
+            expect(priorityInput).toHaveAttribute('placeholder', 'Example: Auto-assigned: 0');
         });
-        it("renders all toggle fields", ()=>{
+        it('renders all toggle fields', ()=>{
             renderBucketReplicationFormPage();
-            expect(screen.getByText("Replicate encrypted objects")).toBeInTheDocument();
-            expect(screen.getByText("Encrypt replicated objects")).toBeInTheDocument();
-            expect(screen.getByText("Replication Time Control (RTC)")).toBeInTheDocument();
-            expect(screen.getByText("RTC metrics and notifications")).toBeInTheDocument();
-            expect(screen.getByText("Replica modification sync")).toBeInTheDocument();
-            expect(screen.getByText("Delete marker replication")).toBeInTheDocument();
-        });
-        it("renders target bucket as Select for same account", ()=>{
+            expect(screen.getByText('Replicate encrypted objects')).toBeInTheDocument();
+            expect(screen.getByText('Encrypt replicated objects')).toBeInTheDocument();
+            expect(screen.getByText('Replication Time Control (RTC)')).toBeInTheDocument();
+            expect(screen.getByText('RTC metrics and notifications')).toBeInTheDocument();
+            expect(screen.getByText('Replica modification sync')).toBeInTheDocument();
+            expect(screen.getByText('Delete marker replication')).toBeInTheDocument();
+        });
+        it('renders target bucket as Select for same account', ()=>{
             renderBucketReplicationFormPage();
             expect(screen.getAllByText(/target bucket/i)[0]).toBeInTheDocument();
         });
-        it("renders storage class select with all options", async ()=>{
+        it('renders storage class select with all options', async ()=>{
             renderBucketReplicationFormPage();
             const storageClassSelect = screen.getByLabelText(/storage class/i);
             await user_event.click(storageClassSelect);
-            expect(screen.getByRole("option", {
-                name: "Same as source"
+            expect(screen.getByRole('option', {
+                name: 'Same as source'
             })).toBeInTheDocument();
-            expect(screen.getByRole("option", {
-                name: "Glacier"
+            expect(screen.getByRole('option', {
+                name: 'Glacier'
             })).toBeInTheDocument();
-            expect(screen.getByRole("option", {
-                name: "Glacier Deep Archive"
+            expect(screen.getByRole('option', {
+                name: 'Glacier Deep Archive'
             })).toBeInTheDocument();
-            expect(screen.getByRole("option", {
-                name: "Standard-IA"
+            expect(screen.getByRole('option', {
+                name: 'Standard-IA'
             })).toBeInTheDocument();
-            expect(screen.getByRole("option", {
-                name: "One Zone-IA"
+            expect(screen.getByRole('option', {
+                name: 'One Zone-IA'
             })).toBeInTheDocument();
-            expect(screen.getByRole("option", {
-                name: "Intelligent-Tiering"
+            expect(screen.getByRole('option', {
+                name: 'Intelligent-Tiering'
             })).toBeInTheDocument();
-            expect(screen.getByRole("option", {
-                name: "Glacier Instant Retrieval"
+            expect(screen.getByRole('option', {
+                name: 'Glacier Instant Retrieval'
             })).toBeInTheDocument();
         });
     });
-    describe("Form Validation", ()=>{
-        it("validates Role ARN is required for first replication rule", async ()=>{
+    describe('Form Validation', ()=>{
+        it('validates Role ARN is required for first replication rule', async ()=>{
             renderBucketReplicationFormPage();
             const roleInput = screen.getByLabelText(/role arn/i);
-            await user_event.type(roleInput, "test");
+            await user_event.type(roleInput, 'test');
             await user_event.clear(roleInput);
             await waitFor(()=>{
                 expect(screen.getByText(/role arn is required for first replication rule/i)).toBeInTheDocument();
             });
         });
-        it("validates Role ARN is optional when existing rules present", async ()=>{
+        it('validates Role ARN is optional when existing rules present', async ()=>{
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/existing-role",
+                        Role: 'arn:aws:iam::123456789012:role/existing-role',
                         Rules: [
                             {
-                                ID: "existing-rule",
-                                Status: "Enabled",
+                                ID: 'existing-rule',
+                                Status: 'Enabled',
                                 Priority: 1,
                                 Destination: {
-                                    Bucket: "arn:aws:s3:::bucket"
+                                    Bucket: 'arn:aws:s3:::bucket'
                                 }
                             }
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
             renderBucketReplicationFormPage();
-            await user_event.type(screen.getByLabelText(/rule id/i), "new-rule");
+            await user_event.type(screen.getByLabelText(/rule id/i), 'new-rule');
             const targetBucketSelect = screen.getByLabelText(/target bucket/i);
             await user_event.click(targetBucketSelect);
-            await user_event.click(screen.getByRole("option", {
-                name: "destination-bucket"
+            await user_event.click(screen.getByRole('option', {
+                name: 'destination-bucket'
             }));
             await waitFor(()=>{
-                const createButton = screen.getByRole("button", {
+                const createButton = screen.getByRole('button', {
                     name: /create/i
                 });
                 expect(createButton).toBeEnabled();
             });
         });
-        it("validates Rule ID is required", async ()=>{
+        it('validates Rule ID is required', async ()=>{
             renderBucketReplicationFormPage();
             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 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 ()=>{
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             {
-                                ID: "existing-rule",
-                                Status: "Enabled",
+                                ID: 'existing-rule',
+                                Status: 'Enabled',
                                 Priority: 1,
                                 Destination: {
-                                    Bucket: "arn:aws:s3:::bucket"
+                                    Bucket: 'arn:aws:s3:::bucket'
                                 }
                             }
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
             renderBucketReplicationFormPage();
             const ruleIdInput = screen.getByLabelText(/rule id/i);
-            await user_event.type(ruleIdInput, "existing-rule");
+            await user_event.type(ruleIdInput, 'existing-rule');
             await waitFor(()=>{
                 expect(screen.getByText(/a rule with this id already exists/i)).toBeInTheDocument();
             });
         });
-        it("validates Priority must be >= 0", async ()=>{
+        it('validates Priority must be >= 0', async ()=>{
             renderBucketReplicationFormPage();
-            await user_event.type(screen.getByLabelText(/rule id/i), "test-rule");
+            await user_event.type(screen.getByLabelText(/rule id/i), 'test-rule');
             const priorityInput = screen.getByLabelText(/rule priority/i);
             await user_event.clear(priorityInput);
-            await user_event.type(priorityInput, "-1");
+            await user_event.type(priorityInput, '-1');
             await user_event.tab();
             await waitFor(()=>{
                 expect(screen.getByText(/priority must be at least 0/i)).toBeInTheDocument();
             });
         });
-        it("disables submit button when Target Bucket is not selected", async ()=>{
+        it('disables submit button when Target Bucket is not selected', async ()=>{
             renderBucketReplicationFormPage();
-            await user_event.type(screen.getByLabelText(/role arn/i), "arn:aws:iam::123456789012:role/role");
-            await user_event.type(screen.getByLabelText(/rule id/i), "test-rule");
+            await user_event.type(screen.getByLabelText(/role arn/i), 'arn:aws:iam::123456789012:role/role');
+            await user_event.type(screen.getByLabelText(/rule id/i), 'test-rule');
             await waitFor(()=>{
-                const createButton = screen.getByRole("button", {
+                const createButton = screen.getByRole('button', {
                     name: /create/i
                 });
                 expect(createButton).toBeDisabled();
             });
         });
-        it("shows Target Account ID field when sameAccount is false", async ()=>{
+        it('shows Target Account ID field when sameAccount is false', async ()=>{
             renderBucketReplicationFormPage();
-            const sameAccountToggle = findToggleByLabel("Same account destination");
+            const sameAccountToggle = findToggleByLabel('Same account destination');
             await user_event.click(sameAccountToggle);
             await waitFor(()=>{
                 expect(screen.getByLabelText(/target account id/i)).toBeInTheDocument();
             });
         });
-        it("shows Replica KMS Key ID field when encryptReplicatedObjects is true", async ()=>{
+        it('shows Replica KMS Key ID field when encryptReplicatedObjects is true', async ()=>{
             renderBucketReplicationFormPage();
-            const encryptToggle = findToggleByLabel("Encrypt replicated objects");
+            const encryptToggle = findToggleByLabel('Encrypt replicated objects');
             await user_event.click(encryptToggle);
             await waitFor(()=>{
                 expect(screen.getByLabelText(/replica kms key id/i)).toBeInTheDocument();
             });
         });
-        it("shows prefix field when filterType is prefix", async ()=>{
+        it('shows prefix field when filterType is prefix', async ()=>{
             renderBucketReplicationFormPage();
             const filterSelect = document.querySelector('[id="filterType"]');
             await user_event.click(filterSelect);
             await waitFor(()=>{
-                expect(screen.getByRole("option", {
-                    name: "Prefix filter"
+                expect(screen.getByRole('option', {
+                    name: 'Prefix filter'
                 })).toBeInTheDocument();
             });
-            await user_event.click(screen.getByRole("option", {
-                name: "Prefix filter"
+            await user_event.click(screen.getByRole('option', {
+                name: 'Prefix filter'
             }));
             await waitFor(()=>{
                 expect(screen.getByLabelText(/prefix/i)).toBeInTheDocument();
             });
         });
     });
-    describe("Automatic Field Behaviors - Encryption", ()=>{
-        it("shows encryption requirement when includeEncryptedObjects is enabled", async ()=>{
+    describe('Automatic Field Behaviors - Encryption', ()=>{
+        it('shows encryption requirement when includeEncryptedObjects is enabled', async ()=>{
             renderBucketReplicationFormPage();
-            const includeEncryptedToggle = findToggleByLabel("Replicate encrypted objects");
+            const includeEncryptedToggle = findToggleByLabel('Replicate encrypted objects');
             expect(includeEncryptedToggle).toBeInTheDocument();
             await user_event.click(includeEncryptedToggle);
             await waitFor(()=>{
@@ -424,129 +424,129 @@ describe("BucketReplicationFormPage", ()=>{
             });
         });
     });
-    describe("Automatic Field Behaviors - RTC", ()=>{
-        it("shows metrics requirement when enforceRTC is enabled", async ()=>{
+    describe('Automatic Field Behaviors - RTC', ()=>{
+        it('shows metrics requirement when enforceRTC is enabled', async ()=>{
             renderBucketReplicationFormPage();
-            const enforceRTCToggle = findToggleByLabel("Replication Time Control (RTC)");
+            const enforceRTCToggle = findToggleByLabel('Replication Time Control (RTC)');
             await user_event.click(enforceRTCToggle);
             await waitFor(()=>{
                 expect(screen.getByText(/metrics must be enabled when rtc is enabled/i)).toBeInTheDocument();
             });
         });
     });
-    describe("Automatic Field Behaviors - Delete Marker", ()=>{
-        it("disables deleteMarkerReplication when filterType is tags", async ()=>{
+    describe('Automatic Field Behaviors - Delete Marker', ()=>{
+        it('disables deleteMarkerReplication when filterType is tags', async ()=>{
             renderBucketReplicationFormPage();
             const filterSelect = screen.getByLabelText(/^filter$/i);
             await user_event.click(filterSelect);
-            await user_event.click(screen.getByRole("option", {
-                name: "Tags filter"
+            await user_event.click(screen.getByRole('option', {
+                name: 'Tags filter'
             }));
             await waitFor(()=>{
-                const deleteMarkerToggle = findToggleByLabel("Delete marker replication");
+                const deleteMarkerToggle = findToggleByLabel('Delete marker replication');
                 expect(deleteMarkerToggle).toBeDisabled();
             });
         });
-        it("disables deleteMarkerReplication when filterType is and", async ()=>{
+        it('disables deleteMarkerReplication when filterType is and', async ()=>{
             renderBucketReplicationFormPage();
             const filterSelect = screen.getByLabelText(/^filter$/i);
             await user_event.click(filterSelect);
-            await user_event.click(screen.getByRole("option", {
-                name: "Prefix and tags filter"
+            await user_event.click(screen.getByRole('option', {
+                name: 'Prefix and tags filter'
             }));
             await waitFor(()=>{
-                const deleteMarkerToggle = findToggleByLabel("Delete marker replication");
+                const deleteMarkerToggle = findToggleByLabel('Delete marker replication');
                 expect(deleteMarkerToggle).toBeDisabled();
             });
         });
-        it("auto-disables deleteMarkerReplication when switching to tag-based filters", async ()=>{
+        it('auto-disables deleteMarkerReplication when switching to tag-based filters', async ()=>{
             renderBucketReplicationFormPage();
-            const deleteMarkerToggle = findToggleByLabel("Delete marker replication");
+            const deleteMarkerToggle = findToggleByLabel('Delete marker replication');
             await user_event.click(deleteMarkerToggle);
             await waitFor(()=>{
                 expect(deleteMarkerToggle).toBeChecked();
             });
             const filterSelect = screen.getByLabelText(/^filter$/i);
             await user_event.click(filterSelect);
-            await user_event.click(screen.getByRole("option", {
-                name: "Tags filter"
+            await user_event.click(screen.getByRole('option', {
+                name: 'Tags filter'
             }));
             await waitFor(()=>{
-                const updatedToggle = findToggleByLabel("Delete marker replication");
+                const updatedToggle = findToggleByLabel('Delete marker replication');
                 expect(updatedToggle).not.toBeChecked();
                 expect(updatedToggle).toBeDisabled();
             });
         });
-        it("shows helper text explaining tag filter restriction", async ()=>{
+        it('shows helper text explaining tag filter restriction', async ()=>{
             renderBucketReplicationFormPage();
             const filterSelect = screen.getByLabelText(/^filter$/i);
             await user_event.click(filterSelect);
-            await user_event.click(screen.getByRole("option", {
-                name: "Tags filter"
+            await user_event.click(screen.getByRole('option', {
+                name: 'Tags filter'
             }));
             await waitFor(()=>{
                 expect(screen.getByText(/delete marker replication is not supported for tag-based filters/i)).toBeInTheDocument();
             });
         });
     });
-    describe("Automatic Field Behaviors - Conditional Fields", ()=>{
-        it("shows switchObjectOwnership toggle only when sameAccount is false", async ()=>{
+    describe('Automatic Field Behaviors - Conditional Fields', ()=>{
+        it('shows switchObjectOwnership toggle only when sameAccount is false', async ()=>{
             renderBucketReplicationFormPage();
-            expect(screen.queryByText("Switch Object ownership")).not.toBeInTheDocument();
-            const sameAccountToggle = findToggleByLabel("Same account destination");
+            expect(screen.queryByText('Switch Object ownership')).not.toBeInTheDocument();
+            const sameAccountToggle = findToggleByLabel('Same account destination');
             await user_event.click(sameAccountToggle);
             await waitFor(()=>{
-                expect(screen.getByText("Switch Object ownership")).toBeInTheDocument();
+                expect(screen.getByText('Switch Object ownership')).toBeInTheDocument();
             });
         });
-        it("shows Target Account ID input when sameAccount is false", async ()=>{
+        it('shows Target Account ID input when sameAccount is false', async ()=>{
             renderBucketReplicationFormPage();
             expect(screen.queryByLabelText(/target account id/i)).not.toBeInTheDocument();
-            const sameAccountToggle = findToggleByLabel("Same account destination");
+            const sameAccountToggle = findToggleByLabel('Same account destination');
             await user_event.click(sameAccountToggle);
             await waitFor(()=>{
                 expect(screen.getByLabelText(/target account id/i)).toBeInTheDocument();
             });
         });
-        it("renders target bucket as Input for cross-account replication", async ()=>{
+        it('renders target bucket as Input for cross-account replication', async ()=>{
             renderBucketReplicationFormPage();
-            const sameAccountToggle = findToggleByLabel("Same account destination");
+            const sameAccountToggle = findToggleByLabel('Same account destination');
             await user_event.click(sameAccountToggle);
             await waitFor(()=>{
                 const targetBucketInput = screen.getByLabelText(/target bucket/i);
-                expect(targetBucketInput.tagName).toBe("INPUT");
+                expect(targetBucketInput.tagName).toBe('INPUT');
             });
         });
-        it("shows Replica KMS Key ID input when encryptReplicatedObjects is true", async ()=>{
+        it('shows Replica KMS Key ID input when encryptReplicatedObjects is true', async ()=>{
             renderBucketReplicationFormPage();
             expect(screen.queryByLabelText(/replica kms key id/i)).not.toBeInTheDocument();
-            const encryptToggle = findToggleByLabel("Encrypt replicated objects");
+            const encryptToggle = findToggleByLabel('Encrypt replicated objects');
             await user_event.click(encryptToggle);
             await waitFor(()=>{
                 expect(screen.getByLabelText(/replica kms key id/i)).toBeInTheDocument();
             });
         });
     });
-    describe("Form Submission - Create Mode", ()=>{
-        it("submits minimal replication rule with required fields only", async ()=>{
+    describe('Form Submission - Create Mode', ()=>{
+        it('submits minimal replication rule with required fields only', async ()=>{
             renderBucketReplicationFormPage();
             await fillRequiredFields({
-                ruleId: "minimal-rule"
+                ruleId: 'minimal-rule'
             });
             mockSuccessSubmit(mockMutate);
-            await submitForm("create");
+            await submitForm('create');
             await waitFor(()=>{
                 expect(mockMutate).toHaveBeenCalledWith(expect.objectContaining({
-                    Bucket: "test-bucket",
+                    Bucket: 'test-bucket',
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/replication-role",
+                        Role: 'arn:aws:iam::123456789012:role/replication-role',
                         Rules: expect.arrayContaining([
                             expect.objectContaining({
-                                ID: "minimal-rule",
-                                Status: "Enabled",
+                                ID: 'minimal-rule',
+                                Status: 'Enabled',
                                 Priority: 0,
                                 Destination: expect.objectContaining({
-                                    Bucket: "arn:aws:s3:::destination-bucket"
+                                    Bucket: 'arn:aws:s3:::destination-bucket'
                                 })
                             })
                         ])
@@ -554,643 +554,643 @@ describe("BucketReplicationFormPage", ()=>{
                 }), expect.any(Object));
             });
         });
-        it("submits complete replication rule with all optional fields", async ()=>{
+        it('submits complete replication rule with all optional fields', async ()=>{
             renderBucketReplicationFormPage();
-            await user_event.type(screen.getByLabelText(/role arn/i), "arn:aws:iam::123456789012:role/replication-role");
-            await user_event.type(screen.getByLabelText(/rule id/i), "complete-rule");
-            await user_event.type(screen.getByLabelText(/rule priority/i), "5");
+            await user_event.type(screen.getByLabelText(/role arn/i), 'arn:aws:iam::123456789012:role/replication-role');
+            await user_event.type(screen.getByLabelText(/rule id/i), 'complete-rule');
+            await user_event.type(screen.getByLabelText(/rule priority/i), '5');
             const filterSelect = document.querySelector('[id="filterType"]');
             await user_event.click(filterSelect);
             await waitFor(()=>{
-                expect(screen.getByRole("option", {
-                    name: "Prefix filter"
+                expect(screen.getByRole('option', {
+                    name: 'Prefix filter'
                 })).toBeInTheDocument();
             });
-            await user_event.click(screen.getByRole("option", {
-                name: "Prefix filter"
+            await user_event.click(screen.getByRole('option', {
+                name: 'Prefix filter'
             }));
             await waitFor(()=>{
                 expect(screen.getByLabelText(/prefix/i)).toBeInTheDocument();
             });
-            await user_event.type(screen.getByLabelText(/prefix/i), "logs/");
-            const sameAccountToggle = findToggleByLabel("Same account destination");
+            await user_event.type(screen.getByLabelText(/prefix/i), 'logs/');
+            const sameAccountToggle = findToggleByLabel('Same account destination');
             await user_event.click(sameAccountToggle);
             await waitFor(()=>{
                 expect(screen.getByLabelText(/target account id/i)).toBeInTheDocument();
             });
-            await user_event.type(screen.getByLabelText(/target account id/i), "987654321098");
-            await user_event.type(screen.getByLabelText(/target bucket/i), "cross-account-bucket");
+            await user_event.type(screen.getByLabelText(/target account id/i), '987654321098');
+            await user_event.type(screen.getByLabelText(/target bucket/i), 'cross-account-bucket');
             const storageClassSelect = document.querySelector('[id="storageClass"]');
             await user_event.click(storageClassSelect);
             await waitFor(()=>{
-                expect(screen.getByRole("option", {
-                    name: "Glacier"
+                expect(screen.getByRole('option', {
+                    name: 'Glacier'
                 })).toBeInTheDocument();
             });
-            await user_event.click(screen.getByRole("option", {
-                name: "Glacier"
+            await user_event.click(screen.getByRole('option', {
+                name: 'Glacier'
             }));
-            const switchOwnershipToggle = findToggleByLabel("Switch Object ownership");
+            const switchOwnershipToggle = findToggleByLabel('Switch Object ownership');
             await user_event.click(switchOwnershipToggle);
-            const includeEncryptedToggle = findToggleByLabel("Replicate encrypted objects");
+            const includeEncryptedToggle = findToggleByLabel('Replicate encrypted objects');
             await user_event.click(includeEncryptedToggle);
             await waitFor(()=>{
                 expect(screen.getByLabelText(/replica kms key id/i)).toBeInTheDocument();
             });
-            await user_event.type(screen.getByLabelText(/replica kms key id/i), "arn:aws:kms:us-east-1:987654321098:key/12345678-1234-1234-1234-123456789012");
-            const enforceRTCToggle = findToggleByLabel("Replication Time Control (RTC)");
+            await user_event.type(screen.getByLabelText(/replica kms key id/i), 'arn:aws:kms:us-east-1:987654321098:key/12345678-1234-1234-1234-123456789012');
+            const enforceRTCToggle = findToggleByLabel('Replication Time Control (RTC)');
             await user_event.click(enforceRTCToggle);
-            const replicaModToggle = findToggleByLabel("Replica modification sync");
+            const replicaModToggle = findToggleByLabel('Replica modification sync');
             await user_event.click(replicaModToggle);
             mockMutate.mockImplementation((_, options)=>{
                 options?.onSuccess?.();
             });
             await waitFor(()=>{
-                const createButton = screen.getByRole("button", {
+                const createButton = screen.getByRole('button', {
                     name: /create/i
                 });
                 expect(createButton).toBeEnabled();
             });
-            fireEvent.click(screen.getByRole("button", {
+            fireEvent.click(screen.getByRole('button', {
                 name: /create/i
             }));
             await waitFor(()=>{
                 const call = mockMutate.mock.calls[0][0];
                 expect(call.ReplicationConfiguration.Rules[0]).toMatchObject({
-                    ID: "complete-rule",
-                    Status: "Enabled",
+                    ID: 'complete-rule',
+                    Status: 'Enabled',
                     Priority: 5,
                     Filter: {
-                        Prefix: "logs/"
+                        Prefix: 'logs/'
                     },
                     Destination: expect.objectContaining({
-                        Bucket: "arn:aws:s3:::cross-account-bucket",
-                        Account: "987654321098",
-                        StorageClass: "GLACIER",
+                        Bucket: 'arn:aws:s3:::cross-account-bucket',
+                        Account: '987654321098',
+                        StorageClass: 'GLACIER',
                         AccessControlTranslation: {
-                            Owner: "Destination"
+                            Owner: 'Destination'
                         },
                         EncryptionConfiguration: {
-                            ReplicaKmsKeyID: "arn:aws:kms:us-east-1:987654321098:key/12345678-1234-1234-1234-123456789012"
+                            ReplicaKmsKeyID: 'arn:aws:kms:us-east-1:987654321098:key/12345678-1234-1234-1234-123456789012'
                         },
                         ReplicationTime: {
-                            Status: "Enabled",
+                            Status: 'Enabled',
                             Time: {
                                 Minutes: 15
                             }
                         },
                         Metrics: expect.objectContaining({
-                            Status: "Enabled"
+                            Status: 'Enabled'
                         })
                     }),
                     SourceSelectionCriteria: expect.objectContaining({
                         SseKmsEncryptedObjects: {
-                            Status: "Enabled"
+                            Status: 'Enabled'
                         },
                         ReplicaModifications: {
-                            Status: "Enabled"
+                            Status: 'Enabled'
                         }
                     })
                 });
             });
         });
-        it("appends new rule to existing rules array", async ()=>{
+        it('appends new rule to existing rules array', async ()=>{
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             {
-                                ID: "existing-rule",
-                                Status: "Enabled",
+                                ID: 'existing-rule',
+                                Status: 'Enabled',
                                 Priority: 1,
                                 Destination: {
-                                    Bucket: "arn:aws:s3:::existing-bucket"
+                                    Bucket: 'arn:aws:s3:::existing-bucket'
                                 }
                             }
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
             renderBucketReplicationFormPage();
-            await user_event.type(screen.getByLabelText(/rule id/i), "new-rule");
+            await user_event.type(screen.getByLabelText(/rule id/i), 'new-rule');
             const targetBucketSelect = screen.getByLabelText(/target bucket/i);
             await user_event.click(targetBucketSelect);
-            await user_event.click(screen.getByRole("option", {
-                name: "destination-bucket"
+            await user_event.click(screen.getByRole('option', {
+                name: 'destination-bucket'
             }));
             mockMutate.mockImplementation((_, options)=>{
                 options?.onSuccess?.();
             });
             await waitFor(()=>{
-                const createButton = screen.getByRole("button", {
+                const createButton = screen.getByRole('button', {
                     name: /create/i
                 });
                 expect(createButton).toBeEnabled();
             });
-            fireEvent.click(screen.getByRole("button", {
+            fireEvent.click(screen.getByRole('button', {
                 name: /create/i
             }));
             await waitFor(()=>{
                 const call = mockMutate.mock.calls[0][0];
                 expect(call.ReplicationConfiguration.Rules).toHaveLength(2);
-                expect(call.ReplicationConfiguration.Rules[0].ID).toBe("existing-rule");
-                expect(call.ReplicationConfiguration.Rules[1].ID).toBe("new-rule");
+                expect(call.ReplicationConfiguration.Rules[0].ID).toBe('existing-rule');
+                expect(call.ReplicationConfiguration.Rules[1].ID).toBe('new-rule');
             });
         });
-        it("navigates to bucket replication tab on success", async ()=>{
+        it('navigates to bucket replication tab on success', async ()=>{
             renderBucketReplicationFormPage();
             await fillRequiredFields({
-                roleArn: "arn:aws:iam::123456789012:role/role",
-                ruleId: "success-rule"
+                roleArn: 'arn:aws:iam::123456789012:role/role',
+                ruleId: 'success-rule'
             });
             mockSuccessSubmit(mockMutate);
-            await submitForm("create");
+            await submitForm('create');
             await waitFor(()=>{
-                expect(mockNavigate).toHaveBeenCalledWith("/buckets/test-bucket?tab=replication");
+                expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket?tab=replication');
             });
         });
-        it("displays success toast after rule creation", async ()=>{
+        it('displays success toast after rule creation', async ()=>{
             renderBucketReplicationFormPage();
             await fillRequiredFields({
-                roleArn: "arn:aws:iam::123456789012:role/role",
-                ruleId: "toast-rule"
+                roleArn: 'arn:aws:iam::123456789012:role/role',
+                ruleId: 'toast-rule'
             });
             mockSuccessSubmit(mockMutate);
-            await submitForm("create");
+            await submitForm('create');
             await waitFor(()=>{
                 expect(mockShowToast).toHaveBeenCalledWith({
                     open: true,
-                    message: "Replication rule created successfully",
-                    status: "success"
+                    message: 'Replication rule created successfully',
+                    status: 'success'
                 });
             });
         });
-        it("displays error toast when creation fails", async ()=>{
+        it('displays error toast when creation fails', async ()=>{
             renderBucketReplicationFormPage();
             await fillRequiredFields({
-                roleArn: "arn:aws:iam::123456789012:role/role",
-                ruleId: "error-rule"
+                roleArn: 'arn:aws:iam::123456789012:role/role',
+                ruleId: 'error-rule'
             });
-            mockErrorSubmit(mockMutate, "Access Denied");
-            await submitForm("create");
+            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("disables submit button when form is pristine", ()=>{
+        it('disables submit button when form is pristine', ()=>{
             renderBucketReplicationFormPage();
-            const createButton = screen.getByRole("button", {
+            const createButton = screen.getByRole('button', {
                 name: /create/i
             });
             expect(createButton).toBeDisabled();
         });
-        it("disables submit button when form is invalid", async ()=>{
+        it('disables submit button when form is invalid', async ()=>{
             renderBucketReplicationFormPage();
-            await user_event.type(screen.getByLabelText(/rule id/i), "test");
+            await user_event.type(screen.getByLabelText(/rule id/i), 'test');
             await waitFor(()=>{
-                const createButton = screen.getByRole("button", {
+                const createButton = screen.getByRole('button', {
                     name: /create/i
                 });
                 expect(createButton).toBeDisabled();
             });
         });
-        it("enables submit button when form is valid and dirty", async ()=>{
+        it('enables submit button when form is valid and dirty', async ()=>{
             renderBucketReplicationFormPage();
             await fillRequiredFields({
-                roleArn: "arn:aws:iam::123456789012:role/role",
-                ruleId: "valid-rule"
+                roleArn: 'arn:aws:iam::123456789012:role/role',
+                ruleId: 'valid-rule'
             });
             await waitFor(()=>{
-                const createButton = screen.getByRole("button", {
+                const createButton = screen.getByRole('button', {
                     name: /create/i
                 });
                 expect(createButton).toBeEnabled();
             });
         });
     });
-    describe("Form Submission - Edit Mode", ()=>{
-        it("updates existing rule while preserving other rules", async ()=>{
+    describe('Form Submission - Edit Mode', ()=>{
+        it('updates existing rule while preserving other rules', async ()=>{
             const existingRules = [
                 {
-                    ID: "rule-1",
-                    Status: "Enabled",
+                    ID: 'rule-1',
+                    Status: 'Enabled',
                     Priority: 1,
                     Destination: {
-                        Bucket: "arn:aws:s3:::bucket-1"
+                        Bucket: 'arn:aws:s3:::bucket-1'
                     }
                 },
                 {
-                    ID: "rule-2",
-                    Status: "Enabled",
+                    ID: 'rule-2',
+                    Status: 'Enabled',
                     Priority: 2,
                     Destination: {
-                        Bucket: "arn:aws:s3:::bucket-2"
+                        Bucket: 'arn:aws:s3:::bucket-2'
                     }
                 }
             ];
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: existingRules
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "rule-1");
+            renderBucketReplicationFormPage('test-bucket', 'rule-1');
             await waitFor(()=>{
-                expect(screen.getByText("Edit Replication Rule")).toBeInTheDocument();
+                expect(screen.getByText('Edit Replication 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'
             }));
             mockMutate.mockImplementation((_, options)=>{
                 options?.onSuccess?.();
             });
             await waitFor(()=>{
-                const saveButton = screen.getByRole("button", {
+                const saveButton = screen.getByRole('button', {
                     name: /save/i
                 });
                 expect(saveButton).toBeEnabled();
             });
-            fireEvent.click(screen.getByRole("button", {
+            fireEvent.click(screen.getByRole('button', {
                 name: /save/i
             }));
             await waitFor(()=>{
                 const call = mockMutate.mock.calls[0][0];
                 expect(call.ReplicationConfiguration.Rules).toHaveLength(2);
-                expect(call.ReplicationConfiguration.Rules[0].ID).toBe("rule-1");
-                expect(call.ReplicationConfiguration.Rules[0].Status).toBe("Disabled");
-                expect(call.ReplicationConfiguration.Rules[1].ID).toBe("rule-2");
-                expect(call.ReplicationConfiguration.Rules[1].Status).toBe("Enabled");
+                expect(call.ReplicationConfiguration.Rules[0].ID).toBe('rule-1');
+                expect(call.ReplicationConfiguration.Rules[0].Status).toBe('Disabled');
+                expect(call.ReplicationConfiguration.Rules[1].ID).toBe('rule-2');
+                expect(call.ReplicationConfiguration.Rules[1].Status).toBe('Enabled');
             });
         });
-        it("navigates to bucket replication tab on success", async ()=>{
+        it('navigates to bucket replication tab on success', async ()=>{
             const existingRule = {
-                ID: "edit-rule",
-                Status: "Enabled",
+                ID: 'edit-rule',
+                Status: 'Enabled',
                 Priority: 1,
                 Destination: {
-                    Bucket: "arn:aws:s3:::bucket"
+                    Bucket: 'arn:aws:s3:::bucket'
                 }
             };
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             existingRule
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "edit-rule");
+            renderBucketReplicationFormPage('test-bucket', 'edit-rule');
             await waitFor(()=>{
-                expect(screen.getByText("Edit Replication Rule")).toBeInTheDocument();
+                expect(screen.getByText('Edit Replication 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'
             }));
             mockMutate.mockImplementation((_, options)=>{
                 options?.onSuccess?.();
             });
             await waitFor(()=>{
-                const saveButton = screen.getByRole("button", {
+                const saveButton = screen.getByRole('button', {
                     name: /save/i
                 });
                 expect(saveButton).toBeEnabled();
             });
-            fireEvent.click(screen.getByRole("button", {
+            fireEvent.click(screen.getByRole('button', {
                 name: /save/i
             }));
             await waitFor(()=>{
-                expect(mockNavigate).toHaveBeenCalledWith("/buckets/test-bucket?tab=replication");
+                expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket?tab=replication');
             });
         });
-        it("displays update success toast in edit mode", async ()=>{
+        it('displays update success toast in edit mode', async ()=>{
             const existingRule = {
-                ID: "toast-rule",
-                Status: "Enabled",
+                ID: 'toast-rule',
+                Status: 'Enabled',
                 Priority: 1,
                 Destination: {
-                    Bucket: "arn:aws:s3:::bucket"
+                    Bucket: 'arn:aws:s3:::bucket'
                 }
             };
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             existingRule
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "toast-rule");
+            renderBucketReplicationFormPage('test-bucket', 'toast-rule');
             await waitFor(()=>{
-                expect(screen.getByText("Edit Replication Rule")).toBeInTheDocument();
+                expect(screen.getByText('Edit Replication 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'
             }));
             mockMutate.mockImplementation((_, options)=>{
                 options?.onSuccess?.();
             });
             await waitFor(()=>{
-                const saveButton = screen.getByRole("button", {
+                const saveButton = screen.getByRole('button', {
                     name: /save/i
                 });
                 expect(saveButton).toBeEnabled();
             });
-            fireEvent.click(screen.getByRole("button", {
+            fireEvent.click(screen.getByRole('button', {
                 name: /save/i
             }));
             await waitFor(()=>{
                 expect(mockShowToast).toHaveBeenCalledWith({
                     open: true,
-                    message: "Replication rule updated successfully",
-                    status: "success"
+                    message: 'Replication rule updated successfully',
+                    status: 'success'
                 });
             });
         });
-        it("displays error toast with error message on failure", async ()=>{
+        it('displays error toast with error message on failure', async ()=>{
             const existingRule = {
-                ID: "error-rule",
-                Status: "Enabled",
+                ID: 'error-rule',
+                Status: 'Enabled',
                 Priority: 1,
                 Destination: {
-                    Bucket: "arn:aws:s3:::bucket"
+                    Bucket: 'arn:aws:s3:::bucket'
                 }
             };
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             existingRule
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "error-rule");
+            renderBucketReplicationFormPage('test-bucket', 'error-rule');
             await waitFor(()=>{
-                expect(screen.getByText("Edit Replication Rule")).toBeInTheDocument();
+                expect(screen.getByText('Edit Replication 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'
             }));
-            const error = new Error("Network Error");
+            const error = new Error('Network Error');
             mockMutate.mockImplementation((_, options)=>{
                 options?.onError?.(error);
             });
             await waitFor(()=>{
-                const saveButton = screen.getByRole("button", {
+                const saveButton = screen.getByRole('button', {
                     name: /save/i
                 });
                 expect(saveButton).toBeEnabled();
             });
-            fireEvent.click(screen.getByRole("button", {
+            fireEvent.click(screen.getByRole('button', {
                 name: /save/i
             }));
             await waitFor(()=>{
                 expect(mockShowToast).toHaveBeenCalledWith({
                     open: true,
-                    message: "Network Error",
-                    status: "error"
+                    message: 'Network Error',
+                    status: 'error'
                 });
                 expect(mockNavigate).not.toHaveBeenCalled();
             });
         });
     });
-    describe("Rule Data Loading in Edit Mode", ()=>{
-        it("loads rule with no filter correctly", async ()=>{
+    describe('Rule Data Loading in Edit Mode', ()=>{
+        it('loads rule with no filter correctly', async ()=>{
             const rule = {
-                ID: "no-filter-rule",
-                Status: "Enabled",
+                ID: 'no-filter-rule',
+                Status: 'Enabled',
                 Priority: 1,
                 Destination: {
-                    Bucket: "arn:aws:s3:::bucket"
+                    Bucket: 'arn:aws:s3:::bucket'
                 }
             };
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             rule
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "no-filter-rule");
+            renderBucketReplicationFormPage('test-bucket', 'no-filter-rule');
             await waitFor(()=>{
                 const filterSelect = screen.getByLabelText(/^filter$/i);
                 expect(filterSelect).toBeInTheDocument();
                 expect(screen.queryByLabelText(/prefix/i)).not.toBeInTheDocument();
             });
         });
-        it("loads rule with prefix filter correctly", async ()=>{
+        it('loads rule with prefix filter correctly', async ()=>{
             const rule = {
-                ID: "prefix-rule",
-                Status: "Enabled",
+                ID: 'prefix-rule',
+                Status: 'Enabled',
                 Priority: 1,
                 Filter: {
-                    Prefix: "documents/"
+                    Prefix: 'documents/'
                 },
                 Destination: {
-                    Bucket: "arn:aws:s3:::bucket"
+                    Bucket: 'arn:aws:s3:::bucket'
                 }
             };
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             rule
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "prefix-rule");
+            renderBucketReplicationFormPage('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',
                 Priority: 1,
                 Filter: {
                     Tag: {
-                        Key: "env",
-                        Value: "prod"
+                        Key: 'env',
+                        Value: 'prod'
                     }
                 },
                 Destination: {
-                    Bucket: "arn:aws:s3:::bucket"
+                    Bucket: 'arn:aws:s3:::bucket'
                 }
             };
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             rule
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "tag-rule");
+            renderBucketReplicationFormPage('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 prefix and tags filter correctly", async ()=>{
+        it('loads rule with prefix and tags filter correctly', async ()=>{
             const rule = {
-                ID: "and-rule",
-                Status: "Enabled",
+                ID: 'and-rule',
+                Status: 'Enabled',
                 Priority: 1,
                 Filter: {
                     And: {
-                        Prefix: "logs/",
+                        Prefix: 'logs/',
                         Tags: [
                             {
-                                Key: "type",
-                                Value: "audit"
+                                Key: 'type',
+                                Value: 'audit'
                             },
                             {
-                                Key: "year",
-                                Value: "2024"
+                                Key: 'year',
+                                Value: '2024'
                             }
                         ]
                     }
                 },
                 Destination: {
-                    Bucket: "arn:aws:s3:::bucket"
+                    Bucket: 'arn:aws:s3:::bucket'
                 }
             };
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             rule
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "and-rule");
+            renderBucketReplicationFormPage('test-bucket', 'and-rule');
             await waitFor(()=>{
                 const prefixInput = screen.getByLabelText(/prefix/i);
-                expect(prefixInput).toHaveValue("logs/");
-                expect(screen.getByDisplayValue("type")).toBeInTheDocument();
-                expect(screen.getByDisplayValue("audit")).toBeInTheDocument();
-                expect(screen.getByDisplayValue("year")).toBeInTheDocument();
-                expect(screen.getByDisplayValue("2024")).toBeInTheDocument();
+                expect(prefixInput).toHaveValue('logs/');
+                expect(screen.getByDisplayValue('type')).toBeInTheDocument();
+                expect(screen.getByDisplayValue('audit')).toBeInTheDocument();
+                expect(screen.getByDisplayValue('year')).toBeInTheDocument();
+                expect(screen.getByDisplayValue('2024')).toBeInTheDocument();
             });
         });
-        it("loads rule with includeEncryptedObjects enabled", async ()=>{
+        it('loads rule with includeEncryptedObjects enabled', async ()=>{
             const rule = {
-                ID: "encrypted-rule",
-                Status: "Enabled",
+                ID: 'encrypted-rule',
+                Status: 'Enabled',
                 Priority: 1,
                 Destination: {
-                    Bucket: "arn:aws:s3:::bucket"
+                    Bucket: 'arn:aws:s3:::bucket'
                 },
                 SourceSelectionCriteria: {
                     SseKmsEncryptedObjects: {
-                        Status: "Enabled"
+                        Status: 'Enabled'
                     }
                 }
             };
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             rule
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "encrypted-rule");
+            renderBucketReplicationFormPage('test-bucket', 'encrypted-rule');
             await waitFor(()=>{
-                const includeEncryptedToggle = findToggleByLabel("Replicate encrypted objects");
+                const includeEncryptedToggle = findToggleByLabel('Replicate encrypted objects');
                 expect(includeEncryptedToggle).toBeChecked();
             });
         });
-        it("loads rule with encryptReplicatedObjects and KMS Key ID", async ()=>{
+        it('loads rule with encryptReplicatedObjects and KMS Key ID', async ()=>{
             const rule = {
-                ID: "encrypt-replica-rule",
-                Status: "Enabled",
+                ID: 'encrypt-replica-rule',
+                Status: 'Enabled',
                 Priority: 1,
                 Destination: {
-                    Bucket: "arn:aws:s3:::bucket",
+                    Bucket: 'arn:aws:s3:::bucket',
                     EncryptionConfiguration: {
-                        ReplicaKmsKeyID: "arn:aws:kms:us-east-1:123456789012:key/12345"
+                        ReplicaKmsKeyID: 'arn:aws:kms:us-east-1:123456789012:key/12345'
                     }
                 }
             };
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             rule
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "encrypt-replica-rule");
+            renderBucketReplicationFormPage('test-bucket', 'encrypt-replica-rule');
             await waitFor(()=>{
-                const encryptReplicatedToggle = findToggleByLabel("Encrypt replicated objects");
+                const encryptReplicatedToggle = findToggleByLabel('Encrypt replicated objects');
                 expect(encryptReplicatedToggle).toBeChecked();
                 const kmsKeyInput = screen.getByLabelText(/replica kms key id/i);
-                expect(kmsKeyInput).toHaveValue("arn:aws:kms:us-east-1:123456789012:key/12345");
+                expect(kmsKeyInput).toHaveValue('arn:aws:kms:us-east-1:123456789012:key/12345');
             });
         });
-        it("loads rule with enforceRTC and enableRTCNotification", async ()=>{
+        it('loads rule with enforceRTC and enableRTCNotification', async ()=>{
             const rule = {
-                ID: "rtc-rule",
-                Status: "Enabled",
+                ID: 'rtc-rule',
+                Status: 'Enabled',
                 Priority: 1,
                 Destination: {
-                    Bucket: "arn:aws:s3:::bucket",
+                    Bucket: 'arn:aws:s3:::bucket',
                     ReplicationTime: {
-                        Status: "Enabled",
+                        Status: 'Enabled',
                         Time: {
                             Minutes: 15
                         }
                     },
                     Metrics: {
-                        Status: "Enabled",
+                        Status: 'Enabled',
                         EventThreshold: {
                             Minutes: 15
                         }
@@ -1200,258 +1200,258 @@ describe("BucketReplicationFormPage", ()=>{
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             rule
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "rtc-rule");
+            renderBucketReplicationFormPage('test-bucket', 'rtc-rule');
             await waitFor(()=>{
-                expect(screen.getByText("Replication Time Control (RTC)")).toBeInTheDocument();
+                expect(screen.getByText('Replication Time Control (RTC)')).toBeInTheDocument();
             });
-            const enforceRTCToggle = findToggleByLabel("Replication Time Control (RTC)");
+            const enforceRTCToggle = findToggleByLabel('Replication Time Control (RTC)');
             expect(enforceRTCToggle).toBeChecked();
         });
-        it("loads rule with replicaModifications enabled", async ()=>{
+        it('loads rule with replicaModifications enabled', async ()=>{
             const rule = {
-                ID: "replica-mod-rule",
-                Status: "Enabled",
+                ID: 'replica-mod-rule',
+                Status: 'Enabled',
                 Priority: 1,
                 Destination: {
-                    Bucket: "arn:aws:s3:::bucket"
+                    Bucket: 'arn:aws:s3:::bucket'
                 },
                 SourceSelectionCriteria: {
                     ReplicaModifications: {
-                        Status: "Enabled"
+                        Status: 'Enabled'
                     }
                 }
             };
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             rule
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "replica-mod-rule");
+            renderBucketReplicationFormPage('test-bucket', 'replica-mod-rule');
             await waitFor(()=>{
-                const replicaModToggle = findToggleByLabel("Replica modification sync");
+                const replicaModToggle = findToggleByLabel('Replica modification sync');
                 expect(replicaModToggle).toBeChecked();
             });
         });
-        it("loads rule with deleteMarkerReplication enabled", async ()=>{
+        it('loads rule with deleteMarkerReplication enabled', async ()=>{
             const rule = {
-                ID: "delete-marker-rule",
-                Status: "Enabled",
+                ID: 'delete-marker-rule',
+                Status: 'Enabled',
                 Priority: 1,
                 Destination: {
-                    Bucket: "arn:aws:s3:::bucket"
+                    Bucket: 'arn:aws:s3:::bucket'
                 },
                 DeleteMarkerReplication: {
-                    Status: "Enabled"
+                    Status: 'Enabled'
                 }
             };
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             rule
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "delete-marker-rule");
+            renderBucketReplicationFormPage('test-bucket', 'delete-marker-rule');
             await waitFor(()=>{
-                const deleteMarkerToggle = findToggleByLabel("Delete marker replication");
+                const deleteMarkerToggle = findToggleByLabel('Delete marker replication');
                 expect(deleteMarkerToggle).toBeChecked();
             });
         });
-        it("loads rule with cross-account destination", async ()=>{
+        it('loads rule with cross-account destination', async ()=>{
             const rule = {
-                ID: "cross-account-rule",
-                Status: "Enabled",
+                ID: 'cross-account-rule',
+                Status: 'Enabled',
                 Priority: 1,
                 Destination: {
-                    Bucket: "arn:aws:s3:::cross-account-bucket",
-                    Account: "987654321098"
+                    Bucket: 'arn:aws:s3:::cross-account-bucket',
+                    Account: '987654321098'
                 }
             };
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             rule
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "cross-account-rule");
+            renderBucketReplicationFormPage('test-bucket', 'cross-account-rule');
             await waitFor(()=>{
                 const sameAccountToggle = screen.getByText(/not same account destination/i);
                 expect(sameAccountToggle).toBeInTheDocument();
                 const accountIdInput = screen.getByLabelText(/target account id/i);
-                expect(accountIdInput).toHaveValue("987654321098");
+                expect(accountIdInput).toHaveValue('987654321098');
                 const targetBucketInput = screen.getByLabelText(/target bucket/i);
-                expect(targetBucketInput).toHaveValue("cross-account-bucket");
+                expect(targetBucketInput).toHaveValue('cross-account-bucket');
             });
         });
-        it("loads rule with switchObjectOwnership enabled", async ()=>{
+        it('loads rule with switchObjectOwnership enabled', async ()=>{
             const rule = {
-                ID: "ownership-rule",
-                Status: "Enabled",
+                ID: 'ownership-rule',
+                Status: 'Enabled',
                 Priority: 1,
                 Destination: {
-                    Bucket: "arn:aws:s3:::bucket",
-                    Account: "987654321098",
+                    Bucket: 'arn:aws:s3:::bucket',
+                    Account: '987654321098',
                     AccessControlTranslation: {
-                        Owner: "Destination"
+                        Owner: 'Destination'
                     }
                 }
             };
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             rule
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "ownership-rule");
+            renderBucketReplicationFormPage('test-bucket', 'ownership-rule');
             await waitFor(()=>{
-                const ownershipToggle = findToggleByLabel("Switch Object ownership");
+                const ownershipToggle = findToggleByLabel('Switch Object ownership');
                 expect(ownershipToggle).toBeChecked();
             });
         });
-        it("loads rule with custom StorageClass", async ()=>{
+        it('loads rule with custom StorageClass', async ()=>{
             const rule = {
-                ID: "storage-class-rule",
-                Status: "Enabled",
+                ID: 'storage-class-rule',
+                Status: 'Enabled',
                 Priority: 1,
                 Destination: {
-                    Bucket: "arn:aws:s3:::bucket",
-                    StorageClass: "GLACIER"
+                    Bucket: 'arn:aws:s3:::bucket',
+                    StorageClass: 'GLACIER'
                 }
             };
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             rule
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "storage-class-rule");
+            renderBucketReplicationFormPage('test-bucket', 'storage-class-rule');
             await waitFor(()=>{
                 const storageClassSelect = screen.getByLabelText(/storage class/i);
                 expect(storageClassSelect).toBeInTheDocument();
             });
         });
-        it("loads rule with custom Priority", async ()=>{
+        it('loads rule with custom Priority', async ()=>{
             const rule = {
-                ID: "priority-rule",
-                Status: "Enabled",
+                ID: 'priority-rule',
+                Status: 'Enabled',
                 Priority: 99,
                 Destination: {
-                    Bucket: "arn:aws:s3:::bucket"
+                    Bucket: 'arn:aws:s3:::bucket'
                 }
             };
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             rule
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "priority-rule");
+            renderBucketReplicationFormPage('test-bucket', 'priority-rule');
             await waitFor(()=>{
                 const priorityInput = screen.getByLabelText(/rule priority/i);
                 expect(priorityInput).toHaveValue(99);
             });
         });
     });
-    describe("Priority Auto-assignment", ()=>{
-        it("auto-assigns priority 0 when no existing rules", ()=>{
+    describe('Priority Auto-assignment', ()=>{
+        it('auto-assigns priority 0 when no existing rules', ()=>{
             renderBucketReplicationFormPage();
             const priorityInput = screen.getByLabelText(/rule priority/i);
-            expect(priorityInput).toHaveAttribute("placeholder", "Example: Auto-assigned: 0");
+            expect(priorityInput).toHaveAttribute('placeholder', 'Example: Auto-assigned: 0');
         });
-        it("auto-assigns next available priority when rules exist", ()=>{
+        it('auto-assigns next available priority when rules exist', ()=>{
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             {
-                                ID: "rule-1",
-                                Status: "Enabled",
+                                ID: 'rule-1',
+                                Status: 'Enabled',
                                 Priority: 5,
                                 Destination: {
-                                    Bucket: "arn:aws:s3:::bucket"
+                                    Bucket: 'arn:aws:s3:::bucket'
                                 }
                             },
                             {
-                                ID: "rule-2",
-                                Status: "Enabled",
+                                ID: 'rule-2',
+                                Status: 'Enabled',
                                 Priority: 10,
                                 Destination: {
-                                    Bucket: "arn:aws:s3:::bucket"
+                                    Bucket: 'arn:aws:s3:::bucket'
                                 }
                             }
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
             renderBucketReplicationFormPage();
             const priorityInput = screen.getByLabelText(/rule priority/i);
-            expect(priorityInput).toHaveAttribute("placeholder", "Example: Auto-assigned: 11");
+            expect(priorityInput).toHaveAttribute('placeholder', 'Example: Auto-assigned: 11');
         });
-        it("allows manual priority override", async ()=>{
+        it('allows manual priority override', async ()=>{
             renderBucketReplicationFormPage();
             const priorityInput = screen.getByLabelText(/rule priority/i);
-            await user_event.type(priorityInput, "25");
+            await user_event.type(priorityInput, '25');
             expect(priorityInput).toHaveValue(25);
         });
-        it("accepts empty priority and defaults to 0 on submit", async ()=>{
+        it('accepts empty priority and defaults to 0 on submit', async ()=>{
             renderBucketReplicationFormPage();
-            await user_event.type(screen.getByLabelText(/role arn/i), "arn:aws:iam::123456789012:role/role");
-            await user_event.type(screen.getByLabelText(/rule id/i), "no-priority-rule");
+            await user_event.type(screen.getByLabelText(/role arn/i), 'arn:aws:iam::123456789012:role/role');
+            await user_event.type(screen.getByLabelText(/rule id/i), 'no-priority-rule');
             const targetBucketSelect = screen.getByLabelText(/target bucket/i);
             await user_event.click(targetBucketSelect);
-            await user_event.click(screen.getByRole("option", {
-                name: "destination-bucket"
+            await user_event.click(screen.getByRole('option', {
+                name: 'destination-bucket'
             }));
             mockMutate.mockImplementation((_, options)=>{
                 options?.onSuccess?.();
             });
             await waitFor(()=>{
-                const createButton = screen.getByRole("button", {
+                const createButton = screen.getByRole('button', {
                     name: /create/i
                 });
                 expect(createButton).toBeEnabled();
             });
-            fireEvent.click(screen.getByRole("button", {
+            fireEvent.click(screen.getByRole('button', {
                 name: /create/i
             }));
             await waitFor(()=>{
@@ -1460,209 +1460,209 @@ describe("BucketReplicationFormPage", ()=>{
             });
         });
     });
-    describe("Target Bucket Selection", ()=>{
-        it("renders target bucket field for same-account replication", ()=>{
+    describe('Target Bucket Selection', ()=>{
+        it('renders target bucket field for same-account replication', ()=>{
             renderBucketReplicationFormPage();
             const targetBucketSelect = screen.getByLabelText(/target bucket/i);
             expect(targetBucketSelect).toBeInTheDocument();
         });
-        it("filters out current bucket from bucket list", async ()=>{
+        it('filters out current bucket from bucket list', async ()=>{
             renderBucketReplicationFormPage();
             const targetBucketSelect = screen.getByLabelText(/target bucket/i);
             await user_event.click(targetBucketSelect);
-            expect(screen.getByRole("option", {
-                name: "destination-bucket"
+            expect(screen.getByRole('option', {
+                name: 'destination-bucket'
             })).toBeInTheDocument();
-            expect(screen.getByRole("option", {
-                name: "backup-bucket"
+            expect(screen.getByRole('option', {
+                name: 'backup-bucket'
             })).toBeInTheDocument();
-            expect(screen.queryByRole("option", {
-                name: "test-bucket"
+            expect(screen.queryByRole('option', {
+                name: 'test-bucket'
             })).not.toBeInTheDocument();
         });
-        it("shows text Input for cross-account replication", async ()=>{
+        it('shows text Input for cross-account replication', async ()=>{
             renderBucketReplicationFormPage();
             const sameAccountToggle = screen.getByText(/same account destination/i);
             await user_event.click(sameAccountToggle);
             await waitFor(()=>{
                 const targetBucketInput = screen.getByLabelText(/target bucket/i);
-                expect(targetBucketInput.tagName).toBe("INPUT");
+                expect(targetBucketInput.tagName).toBe('INPUT');
             });
         });
-        it("loads available buckets using useBuckets hook", ()=>{
+        it('loads available buckets using useBuckets hook', ()=>{
             renderBucketReplicationFormPage();
             expect(mockUseBuckets).toHaveBeenCalled();
         });
     });
-    describe("Navigation & Button States", ()=>{
-        it("navigates back to bucket replication tab on Cancel", ()=>{
+    describe('Navigation & Button States', ()=>{
+        it('navigates back to bucket replication tab on Cancel', ()=>{
             renderBucketReplicationFormPage();
-            const cancelButton = screen.getByRole("button", {
+            const cancelButton = screen.getByRole('button', {
                 name: /cancel/i
             });
             fireEvent.click(cancelButton);
-            expect(mockNavigate).toHaveBeenCalledWith("/buckets/test-bucket?tab=replication");
+            expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket?tab=replication');
         });
-        it("disables Cancel button when mutation is pending", ()=>{
+        it('disables Cancel button when mutation is pending', ()=>{
             mockUseSetBucketReplication.mockReturnValue({
                 mutate: mockMutate,
                 isPending: true
             });
             renderBucketReplicationFormPage();
-            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 ()=>{
             mockUseSetBucketReplication.mockReturnValue({
                 mutate: mockMutate,
                 isPending: true
             });
             renderBucketReplicationFormPage();
-            await user_event.type(screen.getByLabelText(/role arn/i), "arn:aws:iam::123456789012:role/role");
-            await user_event.type(screen.getByLabelText(/rule id/i), "test-rule");
+            await user_event.type(screen.getByLabelText(/role arn/i), 'arn:aws:iam::123456789012:role/role');
+            await user_event.type(screen.getByLabelText(/rule id/i), 'test-rule');
             const targetBucketSelect = screen.getByLabelText(/target bucket/i);
             await user_event.click(targetBucketSelect);
-            await user_event.click(screen.getByRole("option", {
-                name: "destination-bucket"
+            await user_event.click(screen.getByRole('option', {
+                name: 'destination-bucket'
             }));
             await waitFor(()=>{
-                const createButton = screen.getByRole("button", {
+                const createButton = screen.getByRole('button', {
                     name: /create/i
                 });
                 expect(createButton).toBeDisabled();
             });
         });
-        it("shows Create button with no icon in create mode", ()=>{
+        it('shows Create button with no icon in create mode', ()=>{
             renderBucketReplicationFormPage();
-            const createButton = screen.getByRole("button", {
+            const createButton = screen.getByRole('button', {
                 name: /create/i
             });
             expect(createButton).toBeInTheDocument();
-            expect(createButton.querySelector("svg")).not.toBeInTheDocument();
+            expect(createButton.querySelector('svg')).not.toBeInTheDocument();
         });
-        it("shows Save button with Save icon in edit mode", async ()=>{
+        it('shows Save button with Save icon in edit mode', async ()=>{
             const existingRule = {
-                ID: "edit-rule",
-                Status: "Enabled",
+                ID: 'edit-rule',
+                Status: 'Enabled',
                 Priority: 1,
                 Destination: {
-                    Bucket: "arn:aws:s3:::bucket"
+                    Bucket: 'arn:aws:s3:::bucket'
                 }
             };
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             existingRule
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "edit-rule");
+            renderBucketReplicationFormPage('test-bucket', 'edit-rule');
             await waitFor(()=>{
-                const saveButton = screen.getByRole("button", {
+                const saveButton = screen.getByRole('button', {
                     name: /save/i
                 });
                 expect(saveButton).toBeInTheDocument();
-                expect(saveButton.querySelector("svg")).toBeInTheDocument();
+                expect(saveButton.querySelector('svg')).toBeInTheDocument();
             });
         });
     });
-    describe("Edge Cases", ()=>{
-        it("handles URL-encoded rule ID in edit mode", async ()=>{
+    describe('Edge Cases', ()=>{
+        it('handles URL-encoded rule ID in edit mode', async ()=>{
             const existingRule = {
-                ID: "rule with spaces",
-                Status: "Enabled",
+                ID: 'rule with spaces',
+                Status: 'Enabled',
                 Priority: 1,
                 Destination: {
-                    Bucket: "arn:aws:s3:::bucket"
+                    Bucket: 'arn:aws:s3:::bucket'
                 }
             };
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             existingRule
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", encodeURIComponent("rule with spaces"));
+            renderBucketReplicationFormPage('test-bucket', encodeURIComponent('rule with spaces'));
             await waitFor(()=>{
-                expect(screen.getByText("rule with spaces")).toBeInTheDocument();
+                expect(screen.getByText('rule with spaces')).toBeInTheDocument();
             });
         });
-        it("handles rules without Priority field", async ()=>{
+        it('handles rules without Priority field', async ()=>{
             const rule = {
-                ID: "no-priority",
-                Status: "Enabled",
+                ID: 'no-priority',
+                Status: 'Enabled',
                 Destination: {
-                    Bucket: "arn:aws:s3:::bucket"
+                    Bucket: 'arn:aws:s3:::bucket'
                 }
             };
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             rule
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "no-priority");
+            renderBucketReplicationFormPage('test-bucket', 'no-priority');
             await waitFor(()=>{
                 const priorityInput = screen.getByLabelText(/rule priority/i);
                 expect(priorityInput).toHaveValue(null);
             });
         });
-        it("handles rules without StorageClass", async ()=>{
+        it('handles rules without StorageClass', async ()=>{
             const rule = {
-                ID: "no-storage-class",
-                Status: "Enabled",
+                ID: 'no-storage-class',
+                Status: 'Enabled',
                 Priority: 1,
                 Destination: {
-                    Bucket: "arn:aws:s3:::bucket"
+                    Bucket: 'arn:aws:s3:::bucket'
                 }
             };
             mockUseGetBucketReplication.mockReturnValue({
                 data: {
                     ReplicationConfiguration: {
-                        Role: "arn:aws:iam::123456789012:role/role",
+                        Role: 'arn:aws:iam::123456789012:role/role',
                         Rules: [
                             rule
                         ]
                     }
                 },
-                status: "success"
+                status: 'success'
             });
-            renderBucketReplicationFormPage("test-bucket", "no-storage-class");
+            renderBucketReplicationFormPage('test-bucket', 'no-storage-class');
             await waitFor(()=>{
                 const storageClassSelect = screen.getByLabelText(/storage class/i);
                 expect(storageClassSelect).toBeInTheDocument();
             });
         });
     });
-    describe("Boundary Conditions", ()=>{
-        it("accepts Rule ID with reasonable length", async ()=>{
+    describe('Boundary Conditions', ()=>{
+        it('accepts Rule ID with reasonable length', async ()=>{
             renderBucketReplicationFormPage();
-            const longRuleId = "rule-name-with-many-segments-" + "segment-".repeat(10);
+            const longRuleId = 'rule-name-with-many-segments-' + 'segment-'.repeat(10);
             const ruleIdInput = screen.getByLabelText(/rule id/i);
             await user_event.type(ruleIdInput, longRuleId);
             await waitFor(()=>{
                 expect(ruleIdInput).toHaveValue(longRuleId);
             });
         });
-        it("handles special characters in Rule ID", async ()=>{
+        it('handles special characters in Rule ID', async ()=>{
             renderBucketReplicationFormPage();
-            const validSpecialChars = "rule-name_with.special-chars_123";
+            const validSpecialChars = 'rule-name_with.special-chars_123';
             const ruleIdInput = screen.getByLabelText(/rule id/i);
             await user_event.type(ruleIdInput, validSpecialChars);
             await user_event.tab();
@@ -1670,84 +1670,84 @@ describe("BucketReplicationFormPage", ()=>{
                 expect(ruleIdInput).toHaveValue(validSpecialChars);
             });
         });
-        it("validates Priority with boundary values", async ()=>{
+        it('validates Priority with boundary values', async ()=>{
             renderBucketReplicationFormPage();
-            await user_event.type(screen.getByLabelText(/rule id/i), "boundary-test");
+            await user_event.type(screen.getByLabelText(/rule id/i), 'boundary-test');
             const priorityInput = screen.getByLabelText(/rule priority/i);
             await user_event.clear(priorityInput);
-            await user_event.type(priorityInput, "0");
+            await user_event.type(priorityInput, '0');
             await user_event.tab();
             await waitFor(()=>{
                 expect(screen.queryByText(/priority must be at least 0/i)).not.toBeInTheDocument();
             });
             await user_event.clear(priorityInput);
-            await user_event.type(priorityInput, "2147483647");
+            await user_event.type(priorityInput, '2147483647');
             await user_event.tab();
             await waitFor(()=>{
                 expect(priorityInput).toHaveValue(2147483647);
             });
         });
-        it("handles very long prefix values", async ()=>{
+        it('handles very long prefix values', async ()=>{
             renderBucketReplicationFormPage();
             const filterSelect = document.querySelector('[id="filterType"]');
             await user_event.click(filterSelect);
             await waitFor(()=>{
-                expect(screen.getByRole("option", {
-                    name: "Prefix filter"
+                expect(screen.getByRole('option', {
+                    name: 'Prefix filter'
                 })).toBeInTheDocument();
             });
-            await user_event.click(screen.getByRole("option", {
-                name: "Prefix filter"
+            await user_event.click(screen.getByRole('option', {
+                name: 'Prefix filter'
             }));
             await waitFor(()=>{
                 expect(screen.getByLabelText(/prefix/i)).toBeInTheDocument();
             });
-            const longPrefix = "logs/" + "a".repeat(100);
+            const longPrefix = 'logs/' + 'a'.repeat(100);
             const prefixInput = screen.getByLabelText(/prefix/i);
             await user_event.type(prefixInput, longPrefix);
             await waitFor(()=>{
                 expect(prefixInput).toHaveValue(longPrefix);
             });
         });
-        it("accepts valid Role ARN format", async ()=>{
+        it('accepts valid Role ARN format', async ()=>{
             renderBucketReplicationFormPage();
             const roleArnInput = screen.getByLabelText(/role arn/i);
-            await user_event.type(roleArnInput, "arn:aws:iam::123456789012:role/replication-role");
+            await user_event.type(roleArnInput, 'arn:aws:iam::123456789012:role/replication-role');
             await user_event.tab();
             await waitFor(()=>{
-                expect(roleArnInput).toHaveValue("arn:aws:iam::123456789012:role/replication-role");
+                expect(roleArnInput).toHaveValue('arn:aws:iam::123456789012:role/replication-role');
             });
         });
-        it("accepts valid Target Account ID", async ()=>{
+        it('accepts valid Target Account ID', async ()=>{
             renderBucketReplicationFormPage();
-            const sameAccountToggle = findToggleByLabel("Same account destination");
+            const sameAccountToggle = findToggleByLabel('Same account destination');
             await user_event.click(sameAccountToggle);
             await waitFor(()=>{
                 expect(screen.getByLabelText(/target account id/i)).toBeInTheDocument();
             });
             const accountIdInput = screen.getByLabelText(/target account id/i);
-            await user_event.type(accountIdInput, "123456789012");
+            await user_event.type(accountIdInput, '123456789012');
             await user_event.tab();
             await waitFor(()=>{
-                expect(accountIdInput).toHaveValue("123456789012");
+                expect(accountIdInput).toHaveValue('123456789012');
             });
         });
-        it("handles empty form submission attempt", async ()=>{
+        it('handles empty form submission attempt', async ()=>{
             renderBucketReplicationFormPage();
-            const createButton = screen.getByRole("button", {
+            const createButton = screen.getByRole('button', {
                 name: /create/i
             });
             expect(createButton).toBeDisabled();
         });
-        it("validates KMS Key ID format", async ()=>{
+        it('validates KMS Key ID format', async ()=>{
             renderBucketReplicationFormPage();
-            const encryptToggle = findToggleByLabel("Encrypt replicated objects");
+            const encryptToggle = findToggleByLabel('Encrypt replicated objects');
             await user_event.click(encryptToggle);
             await waitFor(()=>{
                 expect(screen.getByLabelText(/replica kms key id/i)).toBeInTheDocument();
             });
             const kmsKeyInput = screen.getByLabelText(/replica kms key id/i);
-            const validKmsArn = "arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012";
+            const validKmsArn = 'arn:aws:kms:us-east-1:123456789012:key/12345678-1234-1234-1234-123456789012';
             await user_event.type(kmsKeyInput, validKmsArn);
             await waitFor(()=>{
                 expect(kmsKeyInput).toHaveValue(validKmsArn);