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

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

@@ -0,0 +1,1757 @@
+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";
+import { useGetBucketReplication, useSetBucketReplication } from "../../hooks/bucketConfiguration.js";
+import { useBuckets } from "../../hooks/bucketOperations.js";
+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', ()=>({
+        useBuckets: jest.fn()
+    }));
+const mockUseGetBucketReplication = jest.mocked(useGetBucketReplication);
+const mockUseSetBucketReplication = jest.mocked(useSetBucketReplication);
+const mockUseBuckets = jest.mocked(useBuckets);
+const mockNavigate = jest.fn();
+const mockShowToast = jest.fn();
+jest.mock('react-router', ()=>({
+        ...jest.requireActual('react-router'),
+        useNavigate: ()=>mockNavigate
+    }));
+jest.mock('@scality/core-ui', ()=>({
+        ...jest.requireActual('@scality/core-ui'),
+        useToast: ()=>({
+                showToast: mockShowToast
+            })
+    }));
+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, {
+        initialEntries: [
+            path
+        ],
+        children: /*#__PURE__*/ jsx(Wrapper, {
+            children: /*#__PURE__*/ jsxs(Routes, {
+                children: [
+                    /*#__PURE__*/ jsx(Route, {
+                        path: "/buckets/:bucketName/replication/create",
+                        element: /*#__PURE__*/ jsx(BucketReplicationFormPage, {})
+                    }),
+                    /*#__PURE__*/ jsx(Route, {
+                        path: "/buckets/:bucketName/replication/:ruleId/edit",
+                        element: /*#__PURE__*/ jsx(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;
+        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', {
+            name: targetBucket
+        }));
+    };
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockNavigate.mockClear();
+        mockShowToast.mockClear();
+        mockOffsetSize(800, 600);
+        mockUseGetBucketReplication.mockReturnValue({
+            data: void 0,
+            status: 'success'
+        });
+        mockUseSetBucketReplication.mockReturnValue({
+            mutate: mockMutate,
+            isPending: false
+        });
+        mockUseBuckets.mockReturnValue({
+            data: {
+                Buckets: [
+                    {
+                        Name: 'test-bucket'
+                    },
+                    {
+                        Name: 'destination-bucket'
+                    },
+                    {
+                        Name: 'backup-bucket'
+                    }
+                ]
+            },
+            status: 'success'
+        });
+    });
+    describe('Page Rendering', ()=>{
+        it('renders create mode with correct title', ()=>{
+            renderBucketReplicationFormPage();
+            expect(screen.getByText('Create Replication Rule')).toBeInTheDocument();
+        });
+        it('renders edit mode with correct title when rule exists', async ()=>{
+            const existingRule = {
+                ID: 'test-rule',
+                Status: 'Enabled',
+                Priority: 1,
+                Destination: {
+                    Bucket: 'arn:aws:s3:::destination-bucket'
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/replication-role',
+                        Rules: [
+                            existingRule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage('test-bucket', 'test-rule');
+            await waitFor(()=>{
+                expect(screen.getByText('Edit Replication Rule')).toBeInTheDocument();
+            });
+        });
+        it('shows loading state when fetching replication data', ()=>{
+            mockUseGetBucketReplication.mockReturnValue({
+                data: void 0,
+                status: 'pending'
+            });
+            renderBucketReplicationFormPage();
+            expect(screen.getByText('Loading...')).toBeInTheDocument();
+        });
+        it('shows error when rule not found in edit mode', ()=>{
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/replication-role',
+                        Rules: []
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage('test-bucket', 'non-existent');
+            expect(screen.getByText('Rule not found')).toBeInTheDocument();
+        });
+        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();
+            });
+        });
+    });
+    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', ()=>{
+            renderBucketReplicationFormPage();
+            const roleInput = screen.getByLabelText(/role arn/i);
+            expect(roleInput).toBeInTheDocument();
+            expect(roleInput.tagName).toBe('INPUT');
+        });
+        it('displays existing Role as read-only text when rules exist', ()=>{
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/existing-role',
+                        Rules: [
+                            {
+                                ID: 'existing-rule',
+                                Status: 'Enabled',
+                                Priority: 1,
+                                Destination: {
+                                    Bucket: 'arn:aws:s3:::bucket'
+                                }
+                            }
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage();
+            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', ()=>{
+            renderBucketReplicationFormPage();
+            const ruleIdInput = screen.getByLabelText(/rule id/i);
+            expect(ruleIdInput).toBeInTheDocument();
+            expect(ruleIdInput.tagName).toBe('INPUT');
+        });
+        it('displays Rule ID as read-only text in edit mode', async ()=>{
+            const existingRule = {
+                ID: 'readonly-rule-id',
+                Status: 'Enabled',
+                Priority: 1,
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket'
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            existingRule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage('test-bucket', 'readonly-rule-id');
+            await waitFor(()=>{
+                expect(screen.getByText('readonly-rule-id')).toBeInTheDocument();
+            });
+            expect(screen.queryByRole('textbox', {
+                name: /rule id/i
+            })).not.toBeInTheDocument();
+        });
+        it('renders Status select field', async ()=>{
+            renderBucketReplicationFormPage();
+            await waitFor(()=>{
+                expect(screen.getByLabelText(/rule id/i)).toBeInTheDocument();
+            });
+            const statusElement = document.querySelector('[id="status"]');
+            expect(statusElement).toBeInTheDocument();
+        });
+        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');
+        });
+        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', ()=>{
+            renderBucketReplicationFormPage();
+            expect(screen.getAllByText(/target bucket/i)[0]).toBeInTheDocument();
+        });
+        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'
+            })).toBeInTheDocument();
+            expect(screen.getByRole('option', {
+                name: 'Glacier'
+            })).toBeInTheDocument();
+            expect(screen.getByRole('option', {
+                name: 'Glacier Deep Archive'
+            })).toBeInTheDocument();
+            expect(screen.getByRole('option', {
+                name: 'Standard-IA'
+            })).toBeInTheDocument();
+            expect(screen.getByRole('option', {
+                name: 'One Zone-IA'
+            })).toBeInTheDocument();
+            expect(screen.getByRole('option', {
+                name: 'Intelligent-Tiering'
+            })).toBeInTheDocument();
+            expect(screen.getByRole('option', {
+                name: 'Glacier Instant Retrieval'
+            })).toBeInTheDocument();
+        });
+    });
+    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.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 ()=>{
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/existing-role',
+                        Rules: [
+                            {
+                                ID: 'existing-rule',
+                                Status: 'Enabled',
+                                Priority: 1,
+                                Destination: {
+                                    Bucket: 'arn:aws:s3:::bucket'
+                                }
+                            }
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage();
+            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 waitFor(()=>{
+                const createButton = screen.getByRole('button', {
+                    name: /create/i
+                });
+                expect(createButton).toBeEnabled();
+            });
+        });
+        it('validates Rule ID is required', async ()=>{
+            renderBucketReplicationFormPage();
+            const ruleIdInput = screen.getByLabelText(/rule id/i);
+            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 ()=>{
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            {
+                                ID: 'existing-rule',
+                                Status: 'Enabled',
+                                Priority: 1,
+                                Destination: {
+                                    Bucket: 'arn:aws:s3:::bucket'
+                                }
+                            }
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage();
+            const ruleIdInput = screen.getByLabelText(/rule id/i);
+            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 ()=>{
+            renderBucketReplicationFormPage();
+            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.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 ()=>{
+            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 waitFor(()=>{
+                const createButton = screen.getByRole('button', {
+                    name: /create/i
+                });
+                expect(createButton).toBeDisabled();
+            });
+        });
+        it('shows Target Account ID field when sameAccount is false', async ()=>{
+            renderBucketReplicationFormPage();
+            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 ()=>{
+            renderBucketReplicationFormPage();
+            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 ()=>{
+            renderBucketReplicationFormPage();
+            const filterSelect = document.querySelector('[id="filterType"]');
+            await user_event.click(filterSelect);
+            await waitFor(()=>{
+                expect(screen.getByRole('option', {
+                    name: 'Prefix filter'
+                })).toBeInTheDocument();
+            });
+            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 ()=>{
+            renderBucketReplicationFormPage();
+            const includeEncryptedToggle = findToggleByLabel('Replicate encrypted objects');
+            expect(includeEncryptedToggle).toBeInTheDocument();
+            await user_event.click(includeEncryptedToggle);
+            await waitFor(()=>{
+                expect(screen.getByText(/encryption is required when replicating encrypted objects/i)).toBeInTheDocument();
+            });
+        });
+    });
+    describe('Automatic Field Behaviors - RTC', ()=>{
+        it('shows metrics requirement when enforceRTC is enabled', async ()=>{
+            renderBucketReplicationFormPage();
+            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 ()=>{
+            renderBucketReplicationFormPage();
+            const filterSelect = screen.getByLabelText(/^filter$/i);
+            await user_event.click(filterSelect);
+            await user_event.click(screen.getByRole('option', {
+                name: 'Tags filter'
+            }));
+            await waitFor(()=>{
+                const deleteMarkerToggle = findToggleByLabel('Delete marker replication');
+                expect(deleteMarkerToggle).toBeDisabled();
+            });
+        });
+        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 waitFor(()=>{
+                const deleteMarkerToggle = findToggleByLabel('Delete marker replication');
+                expect(deleteMarkerToggle).toBeDisabled();
+            });
+        });
+        it('auto-disables deleteMarkerReplication when switching to tag-based filters', async ()=>{
+            renderBucketReplicationFormPage();
+            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 waitFor(()=>{
+                const updatedToggle = findToggleByLabel('Delete marker replication');
+                expect(updatedToggle).not.toBeChecked();
+                expect(updatedToggle).toBeDisabled();
+            });
+        });
+        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 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 ()=>{
+            renderBucketReplicationFormPage();
+            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();
+            });
+        });
+        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');
+            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 ()=>{
+            renderBucketReplicationFormPage();
+            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');
+            });
+        });
+        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');
+            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 ()=>{
+            renderBucketReplicationFormPage();
+            await fillRequiredFields({
+                ruleId: 'minimal-rule'
+            });
+            mockSuccessSubmit(mockMutate);
+            await submitForm('create');
+            await waitFor(()=>{
+                expect(mockMutate).toHaveBeenCalledWith(expect.objectContaining({
+                    Bucket: 'test-bucket',
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/replication-role',
+                        Rules: expect.arrayContaining([
+                            expect.objectContaining({
+                                ID: 'minimal-rule',
+                                Status: 'Enabled',
+                                Priority: 0,
+                                Destination: expect.objectContaining({
+                                    Bucket: 'arn:aws:s3:::destination-bucket'
+                                })
+                            })
+                        ])
+                    }
+                }), expect.any(Object));
+            });
+        });
+        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');
+            const filterSelect = document.querySelector('[id="filterType"]');
+            await user_event.click(filterSelect);
+            await waitFor(()=>{
+                expect(screen.getByRole('option', {
+                    name: 'Prefix filter'
+                })).toBeInTheDocument();
+            });
+            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.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');
+            const storageClassSelect = document.querySelector('[id="storageClass"]');
+            await user_event.click(storageClassSelect);
+            await waitFor(()=>{
+                expect(screen.getByRole('option', {
+                    name: 'Glacier'
+                })).toBeInTheDocument();
+            });
+            await user_event.click(screen.getByRole('option', {
+                name: 'Glacier'
+            }));
+            const switchOwnershipToggle = findToggleByLabel('Switch Object ownership');
+            await user_event.click(switchOwnershipToggle);
+            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.click(enforceRTCToggle);
+            const replicaModToggle = findToggleByLabel('Replica modification sync');
+            await user_event.click(replicaModToggle);
+            mockMutate.mockImplementation((_, options)=>{
+                options?.onSuccess?.();
+            });
+            await waitFor(()=>{
+                const createButton = screen.getByRole('button', {
+                    name: /create/i
+                });
+                expect(createButton).toBeEnabled();
+            });
+            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',
+                    Priority: 5,
+                    Filter: {
+                        Prefix: 'logs/'
+                    },
+                    Destination: expect.objectContaining({
+                        Bucket: 'arn:aws:s3:::cross-account-bucket',
+                        Account: '987654321098',
+                        StorageClass: 'GLACIER',
+                        AccessControlTranslation: {
+                            Owner: 'Destination'
+                        },
+                        EncryptionConfiguration: {
+                            ReplicaKmsKeyID: 'arn:aws:kms:us-east-1:987654321098:key/12345678-1234-1234-1234-123456789012'
+                        },
+                        ReplicationTime: {
+                            Status: 'Enabled',
+                            Time: {
+                                Minutes: 15
+                            }
+                        },
+                        Metrics: expect.objectContaining({
+                            Status: 'Enabled'
+                        })
+                    }),
+                    SourceSelectionCriteria: expect.objectContaining({
+                        SseKmsEncryptedObjects: {
+                            Status: 'Enabled'
+                        },
+                        ReplicaModifications: {
+                            Status: 'Enabled'
+                        }
+                    })
+                });
+            });
+        });
+        it('appends new rule to existing rules array', async ()=>{
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            {
+                                ID: 'existing-rule',
+                                Status: 'Enabled',
+                                Priority: 1,
+                                Destination: {
+                                    Bucket: 'arn:aws:s3:::existing-bucket'
+                                }
+                            }
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage();
+            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'
+            }));
+            mockMutate.mockImplementation((_, options)=>{
+                options?.onSuccess?.();
+            });
+            await waitFor(()=>{
+                const createButton = screen.getByRole('button', {
+                    name: /create/i
+                });
+                expect(createButton).toBeEnabled();
+            });
+            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');
+            });
+        });
+        it('navigates to bucket replication tab on success', async ()=>{
+            renderBucketReplicationFormPage();
+            await fillRequiredFields({
+                roleArn: 'arn:aws:iam::123456789012:role/role',
+                ruleId: 'success-rule'
+            });
+            mockSuccessSubmit(mockMutate);
+            await submitForm('create');
+            await waitFor(()=>{
+                expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket?tab=replication');
+            });
+        });
+        it('displays success toast after rule creation', async ()=>{
+            renderBucketReplicationFormPage();
+            await fillRequiredFields({
+                roleArn: 'arn:aws:iam::123456789012:role/role',
+                ruleId: 'toast-rule'
+            });
+            mockSuccessSubmit(mockMutate);
+            await submitForm('create');
+            await waitFor(()=>{
+                expect(mockShowToast).toHaveBeenCalledWith({
+                    open: true,
+                    message: 'Replication rule created successfully',
+                    status: 'success'
+                });
+            });
+        });
+        it('displays error toast when creation fails', async ()=>{
+            renderBucketReplicationFormPage();
+            await fillRequiredFields({
+                roleArn: 'arn:aws:iam::123456789012:role/role',
+                ruleId: 'error-rule'
+            });
+            mockErrorSubmit(mockMutate, 'Access Denied');
+            await submitForm('create');
+            await waitFor(()=>{
+                expect(mockShowToast).toHaveBeenCalledWith({
+                    open: true,
+                    message: 'Access Denied',
+                    status: 'error'
+                });
+                expect(mockNavigate).not.toHaveBeenCalled();
+            });
+        });
+        it('disables submit button when form is pristine', ()=>{
+            renderBucketReplicationFormPage();
+            const createButton = screen.getByRole('button', {
+                name: /create/i
+            });
+            expect(createButton).toBeDisabled();
+        });
+        it('disables submit button when form is invalid', async ()=>{
+            renderBucketReplicationFormPage();
+            await user_event.type(screen.getByLabelText(/rule id/i), 'test');
+            await waitFor(()=>{
+                const createButton = screen.getByRole('button', {
+                    name: /create/i
+                });
+                expect(createButton).toBeDisabled();
+            });
+        });
+        it('enables submit button when form is valid and dirty', async ()=>{
+            renderBucketReplicationFormPage();
+            await fillRequiredFields({
+                roleArn: 'arn:aws:iam::123456789012:role/role',
+                ruleId: 'valid-rule'
+            });
+            await waitFor(()=>{
+                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 ()=>{
+            const existingRules = [
+                {
+                    ID: 'rule-1',
+                    Status: 'Enabled',
+                    Priority: 1,
+                    Destination: {
+                        Bucket: 'arn:aws:s3:::bucket-1'
+                    }
+                },
+                {
+                    ID: 'rule-2',
+                    Status: 'Enabled',
+                    Priority: 2,
+                    Destination: {
+                        Bucket: 'arn:aws:s3:::bucket-2'
+                    }
+                }
+            ];
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: existingRules
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage('test-bucket', 'rule-1');
+            await waitFor(()=>{
+                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'
+            }));
+            mockMutate.mockImplementation((_, options)=>{
+                options?.onSuccess?.();
+            });
+            await waitFor(()=>{
+                const saveButton = screen.getByRole('button', {
+                    name: /save/i
+                });
+                expect(saveButton).toBeEnabled();
+            });
+            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');
+            });
+        });
+        it('navigates to bucket replication tab on success', async ()=>{
+            const existingRule = {
+                ID: 'edit-rule',
+                Status: 'Enabled',
+                Priority: 1,
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket'
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            existingRule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage('test-bucket', 'edit-rule');
+            await waitFor(()=>{
+                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'
+            }));
+            mockMutate.mockImplementation((_, options)=>{
+                options?.onSuccess?.();
+            });
+            await waitFor(()=>{
+                const saveButton = screen.getByRole('button', {
+                    name: /save/i
+                });
+                expect(saveButton).toBeEnabled();
+            });
+            fireEvent.click(screen.getByRole('button', {
+                name: /save/i
+            }));
+            await waitFor(()=>{
+                expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket?tab=replication');
+            });
+        });
+        it('displays update success toast in edit mode', async ()=>{
+            const existingRule = {
+                ID: 'toast-rule',
+                Status: 'Enabled',
+                Priority: 1,
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket'
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            existingRule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage('test-bucket', 'toast-rule');
+            await waitFor(()=>{
+                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'
+            }));
+            mockMutate.mockImplementation((_, options)=>{
+                options?.onSuccess?.();
+            });
+            await waitFor(()=>{
+                const saveButton = screen.getByRole('button', {
+                    name: /save/i
+                });
+                expect(saveButton).toBeEnabled();
+            });
+            fireEvent.click(screen.getByRole('button', {
+                name: /save/i
+            }));
+            await waitFor(()=>{
+                expect(mockShowToast).toHaveBeenCalledWith({
+                    open: true,
+                    message: 'Replication rule updated successfully',
+                    status: 'success'
+                });
+            });
+        });
+        it('displays error toast with error message on failure', async ()=>{
+            const existingRule = {
+                ID: 'error-rule',
+                Status: 'Enabled',
+                Priority: 1,
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket'
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            existingRule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage('test-bucket', 'error-rule');
+            await waitFor(()=>{
+                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'
+            }));
+            const error = new Error('Network Error');
+            mockMutate.mockImplementation((_, options)=>{
+                options?.onError?.(error);
+            });
+            await waitFor(()=>{
+                const saveButton = screen.getByRole('button', {
+                    name: /save/i
+                });
+                expect(saveButton).toBeEnabled();
+            });
+            fireEvent.click(screen.getByRole('button', {
+                name: /save/i
+            }));
+            await waitFor(()=>{
+                expect(mockShowToast).toHaveBeenCalledWith({
+                    open: true,
+                    message: 'Network Error',
+                    status: 'error'
+                });
+                expect(mockNavigate).not.toHaveBeenCalled();
+            });
+        });
+    });
+    describe('Rule Data Loading in Edit Mode', ()=>{
+        it('loads rule with no filter correctly', async ()=>{
+            const rule = {
+                ID: 'no-filter-rule',
+                Status: 'Enabled',
+                Priority: 1,
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket'
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            rule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            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 ()=>{
+            const rule = {
+                ID: 'prefix-rule',
+                Status: 'Enabled',
+                Priority: 1,
+                Filter: {
+                    Prefix: 'documents/'
+                },
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket'
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            rule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage('test-bucket', 'prefix-rule');
+            await waitFor(()=>{
+                const prefixInput = screen.getByLabelText(/prefix/i);
+                expect(prefixInput).toHaveValue('documents/');
+            });
+        });
+        it('loads rule with single tag filter correctly', async ()=>{
+            const rule = {
+                ID: 'tag-rule',
+                Status: 'Enabled',
+                Priority: 1,
+                Filter: {
+                    Tag: {
+                        Key: 'env',
+                        Value: 'prod'
+                    }
+                },
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket'
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            rule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage('test-bucket', 'tag-rule');
+            await waitFor(()=>{
+                expect(screen.getByDisplayValue('env')).toBeInTheDocument();
+                expect(screen.getByDisplayValue('prod')).toBeInTheDocument();
+            });
+        });
+        it('loads rule with prefix and tags filter correctly', async ()=>{
+            const rule = {
+                ID: 'and-rule',
+                Status: 'Enabled',
+                Priority: 1,
+                Filter: {
+                    And: {
+                        Prefix: 'logs/',
+                        Tags: [
+                            {
+                                Key: 'type',
+                                Value: 'audit'
+                            },
+                            {
+                                Key: 'year',
+                                Value: '2024'
+                            }
+                        ]
+                    }
+                },
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket'
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            rule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            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();
+            });
+        });
+        it('loads rule with includeEncryptedObjects enabled', async ()=>{
+            const rule = {
+                ID: 'encrypted-rule',
+                Status: 'Enabled',
+                Priority: 1,
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket'
+                },
+                SourceSelectionCriteria: {
+                    SseKmsEncryptedObjects: {
+                        Status: 'Enabled'
+                    }
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            rule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage('test-bucket', 'encrypted-rule');
+            await waitFor(()=>{
+                const includeEncryptedToggle = findToggleByLabel('Replicate encrypted objects');
+                expect(includeEncryptedToggle).toBeChecked();
+            });
+        });
+        it('loads rule with encryptReplicatedObjects and KMS Key ID', async ()=>{
+            const rule = {
+                ID: 'encrypt-replica-rule',
+                Status: 'Enabled',
+                Priority: 1,
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket',
+                    EncryptionConfiguration: {
+                        ReplicaKmsKeyID: 'arn:aws:kms:us-east-1:123456789012:key/12345'
+                    }
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            rule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage('test-bucket', 'encrypt-replica-rule');
+            await waitFor(()=>{
+                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');
+            });
+        });
+        it('loads rule with enforceRTC and enableRTCNotification', async ()=>{
+            const rule = {
+                ID: 'rtc-rule',
+                Status: 'Enabled',
+                Priority: 1,
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket',
+                    ReplicationTime: {
+                        Status: 'Enabled',
+                        Time: {
+                            Minutes: 15
+                        }
+                    },
+                    Metrics: {
+                        Status: 'Enabled',
+                        EventThreshold: {
+                            Minutes: 15
+                        }
+                    }
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            rule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage('test-bucket', 'rtc-rule');
+            await waitFor(()=>{
+                expect(screen.getByText('Replication Time Control (RTC)')).toBeInTheDocument();
+            });
+            const enforceRTCToggle = findToggleByLabel('Replication Time Control (RTC)');
+            expect(enforceRTCToggle).toBeChecked();
+        });
+        it('loads rule with replicaModifications enabled', async ()=>{
+            const rule = {
+                ID: 'replica-mod-rule',
+                Status: 'Enabled',
+                Priority: 1,
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket'
+                },
+                SourceSelectionCriteria: {
+                    ReplicaModifications: {
+                        Status: 'Enabled'
+                    }
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            rule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage('test-bucket', 'replica-mod-rule');
+            await waitFor(()=>{
+                const replicaModToggle = findToggleByLabel('Replica modification sync');
+                expect(replicaModToggle).toBeChecked();
+            });
+        });
+        it('loads rule with deleteMarkerReplication enabled', async ()=>{
+            const rule = {
+                ID: 'delete-marker-rule',
+                Status: 'Enabled',
+                Priority: 1,
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket'
+                },
+                DeleteMarkerReplication: {
+                    Status: 'Enabled'
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            rule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage('test-bucket', 'delete-marker-rule');
+            await waitFor(()=>{
+                const deleteMarkerToggle = findToggleByLabel('Delete marker replication');
+                expect(deleteMarkerToggle).toBeChecked();
+            });
+        });
+        it('loads rule with cross-account destination', async ()=>{
+            const rule = {
+                ID: 'cross-account-rule',
+                Status: 'Enabled',
+                Priority: 1,
+                Destination: {
+                    Bucket: 'arn:aws:s3:::cross-account-bucket',
+                    Account: '987654321098'
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            rule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            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');
+                const targetBucketInput = screen.getByLabelText(/target bucket/i);
+                expect(targetBucketInput).toHaveValue('cross-account-bucket');
+            });
+        });
+        it('loads rule with switchObjectOwnership enabled', async ()=>{
+            const rule = {
+                ID: 'ownership-rule',
+                Status: 'Enabled',
+                Priority: 1,
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket',
+                    Account: '987654321098',
+                    AccessControlTranslation: {
+                        Owner: 'Destination'
+                    }
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            rule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage('test-bucket', 'ownership-rule');
+            await waitFor(()=>{
+                const ownershipToggle = findToggleByLabel('Switch Object ownership');
+                expect(ownershipToggle).toBeChecked();
+            });
+        });
+        it('loads rule with custom StorageClass', async ()=>{
+            const rule = {
+                ID: 'storage-class-rule',
+                Status: 'Enabled',
+                Priority: 1,
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket',
+                    StorageClass: 'GLACIER'
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            rule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            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 ()=>{
+            const rule = {
+                ID: 'priority-rule',
+                Status: 'Enabled',
+                Priority: 99,
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket'
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            rule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            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', ()=>{
+            renderBucketReplicationFormPage();
+            const priorityInput = screen.getByLabelText(/rule priority/i);
+            expect(priorityInput).toHaveAttribute('placeholder', 'Example: Auto-assigned: 0');
+        });
+        it('auto-assigns next available priority when rules exist', ()=>{
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            {
+                                ID: 'rule-1',
+                                Status: 'Enabled',
+                                Priority: 5,
+                                Destination: {
+                                    Bucket: 'arn:aws:s3:::bucket'
+                                }
+                            },
+                            {
+                                ID: 'rule-2',
+                                Status: 'Enabled',
+                                Priority: 10,
+                                Destination: {
+                                    Bucket: 'arn:aws:s3:::bucket'
+                                }
+                            }
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage();
+            const priorityInput = screen.getByLabelText(/rule priority/i);
+            expect(priorityInput).toHaveAttribute('placeholder', 'Example: Auto-assigned: 11');
+        });
+        it('allows manual priority override', async ()=>{
+            renderBucketReplicationFormPage();
+            const priorityInput = screen.getByLabelText(/rule priority/i);
+            await user_event.type(priorityInput, '25');
+            expect(priorityInput).toHaveValue(25);
+        });
+        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');
+            const targetBucketSelect = screen.getByLabelText(/target bucket/i);
+            await user_event.click(targetBucketSelect);
+            await user_event.click(screen.getByRole('option', {
+                name: 'destination-bucket'
+            }));
+            mockMutate.mockImplementation((_, options)=>{
+                options?.onSuccess?.();
+            });
+            await waitFor(()=>{
+                const createButton = screen.getByRole('button', {
+                    name: /create/i
+                });
+                expect(createButton).toBeEnabled();
+            });
+            fireEvent.click(screen.getByRole('button', {
+                name: /create/i
+            }));
+            await waitFor(()=>{
+                const call = mockMutate.mock.calls[0][0];
+                expect(call.ReplicationConfiguration.Rules[0].Priority).toBe(0);
+            });
+        });
+    });
+    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 ()=>{
+            renderBucketReplicationFormPage();
+            const targetBucketSelect = screen.getByLabelText(/target bucket/i);
+            await user_event.click(targetBucketSelect);
+            expect(screen.getByRole('option', {
+                name: 'destination-bucket'
+            })).toBeInTheDocument();
+            expect(screen.getByRole('option', {
+                name: 'backup-bucket'
+            })).toBeInTheDocument();
+            expect(screen.queryByRole('option', {
+                name: 'test-bucket'
+            })).not.toBeInTheDocument();
+        });
+        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');
+            });
+        });
+        it('loads available buckets using useBuckets hook', ()=>{
+            renderBucketReplicationFormPage();
+            expect(mockUseBuckets).toHaveBeenCalled();
+        });
+    });
+    describe('Navigation & Button States', ()=>{
+        it('navigates back to bucket replication tab on Cancel', ()=>{
+            renderBucketReplicationFormPage();
+            const cancelButton = screen.getByRole('button', {
+                name: /cancel/i
+            });
+            fireEvent.click(cancelButton);
+            expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket?tab=replication');
+        });
+        it('disables Cancel button when mutation is pending', ()=>{
+            mockUseSetBucketReplication.mockReturnValue({
+                mutate: mockMutate,
+                isPending: true
+            });
+            renderBucketReplicationFormPage();
+            const cancelButton = screen.getByRole('button', {
+                name: /cancel/i
+            });
+            expect(cancelButton).toBeDisabled();
+        });
+        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');
+            const targetBucketSelect = screen.getByLabelText(/target bucket/i);
+            await user_event.click(targetBucketSelect);
+            await user_event.click(screen.getByRole('option', {
+                name: 'destination-bucket'
+            }));
+            await waitFor(()=>{
+                const createButton = screen.getByRole('button', {
+                    name: /create/i
+                });
+                expect(createButton).toBeDisabled();
+            });
+        });
+        it('shows Create button with no icon in create mode', ()=>{
+            renderBucketReplicationFormPage();
+            const createButton = screen.getByRole('button', {
+                name: /create/i
+            });
+            expect(createButton).toBeInTheDocument();
+            expect(createButton.querySelector('svg')).not.toBeInTheDocument();
+        });
+        it('shows Save button with Save icon in edit mode', async ()=>{
+            const existingRule = {
+                ID: 'edit-rule',
+                Status: 'Enabled',
+                Priority: 1,
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket'
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            existingRule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage('test-bucket', 'edit-rule');
+            await waitFor(()=>{
+                const saveButton = screen.getByRole('button', {
+                    name: /save/i
+                });
+                expect(saveButton).toBeInTheDocument();
+                expect(saveButton.querySelector('svg')).toBeInTheDocument();
+            });
+        });
+    });
+    describe('Edge Cases', ()=>{
+        it('handles URL-encoded rule ID in edit mode', async ()=>{
+            const existingRule = {
+                ID: 'rule with spaces',
+                Status: 'Enabled',
+                Priority: 1,
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket'
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            existingRule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage('test-bucket', encodeURIComponent('rule with spaces'));
+            await waitFor(()=>{
+                expect(screen.getByText('rule with spaces')).toBeInTheDocument();
+            });
+        });
+        it('handles rules without Priority field', async ()=>{
+            const rule = {
+                ID: 'no-priority',
+                Status: 'Enabled',
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket'
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            rule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage('test-bucket', 'no-priority');
+            await waitFor(()=>{
+                const priorityInput = screen.getByLabelText(/rule priority/i);
+                expect(priorityInput).toHaveValue(null);
+            });
+        });
+        it('handles rules without StorageClass', async ()=>{
+            const rule = {
+                ID: 'no-storage-class',
+                Status: 'Enabled',
+                Priority: 1,
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket'
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/role',
+                        Rules: [
+                            rule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            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 ()=>{
+            renderBucketReplicationFormPage();
+            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 ()=>{
+            renderBucketReplicationFormPage();
+            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();
+            await waitFor(()=>{
+                expect(ruleIdInput).toHaveValue(validSpecialChars);
+            });
+        });
+        it('validates Priority with boundary values', async ()=>{
+            renderBucketReplicationFormPage();
+            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.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.tab();
+            await waitFor(()=>{
+                expect(priorityInput).toHaveValue(2147483647);
+            });
+        });
+        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'
+                })).toBeInTheDocument();
+            });
+            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 prefixInput = screen.getByLabelText(/prefix/i);
+            await user_event.type(prefixInput, longPrefix);
+            await waitFor(()=>{
+                expect(prefixInput).toHaveValue(longPrefix);
+            });
+        });
+        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.tab();
+            await waitFor(()=>{
+                expect(roleArnInput).toHaveValue('arn:aws:iam::123456789012:role/replication-role');
+            });
+        });
+        it('accepts valid Target Account ID', async ()=>{
+            renderBucketReplicationFormPage();
+            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.tab();
+            await waitFor(()=>{
+                expect(accountIdInput).toHaveValue('123456789012');
+            });
+        });
+        it('handles empty form submission attempt', async ()=>{
+            renderBucketReplicationFormPage();
+            const createButton = screen.getByRole('button', {
+                name: /create/i
+            });
+            expect(createButton).toBeDisabled();
+        });
+        it('validates KMS Key ID format', async ()=>{
+            renderBucketReplicationFormPage();
+            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';
+            await user_event.type(kmsKeyInput, validKmsArn);
+            await waitFor(()=>{
+                expect(kmsKeyInput).toHaveValue(validKmsArn);
+            });
+        });
+    });
+});