@scality/data-browser-library 1.1.5 → 1.1.7

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

@@ -112,7 +112,10 @@ describe('BucketReplicationFormPage', ()=>{
             },
             status: 'success'
         });
-        mockUseFeatures.mockReturnValue(true);
+        mockUseFeatures.mockImplementation((feature)=>{
+            if ('replicationAdvanced' === feature) return true;
+            return false;
+        });
         mockUseISVBucketStatus.mockReturnValue({
             isVeeamBucket: false,
             isCommvaultBucket: false,
@@ -1971,7 +1974,10 @@ describe('BucketReplicationFormPage', ()=>{
             });
         });
         it('shows Additional Options section when replicationAdvanced is enabled', ()=>{
-            mockUseFeatures.mockReturnValue(true);
+            mockUseFeatures.mockImplementation((feature)=>{
+                if ('replicationAdvanced' === feature) return true;
+                return false;
+            });
             renderBucketReplicationFormPage();
             expect(screen.getByText('Replication Time Control (RTC)')).toBeInTheDocument();
             expect(screen.getByText('RTC metrics and notifications')).toBeInTheDocument();
@@ -1979,4 +1985,203 @@ describe('BucketReplicationFormPage', ()=>{
             expect(screen.getByText('Delete marker replication')).toBeInTheDocument();
         });
     });
+    describe('Feature Flag - replicationV1', ()=>{
+        it('submits rule in V1 format when replicationV1 feature is enabled', async ()=>{
+            mockUseFeatures.mockImplementation((feature)=>{
+                if ('replicationV1' === feature) return true;
+                return false;
+            });
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: '',
+                        Rules: []
+                    }
+                },
+                status: 'success'
+            });
+            mockSuccessSubmit(mockMutate);
+            renderBucketReplicationFormPage();
+            await user_event.type(screen.getByRole('textbox', {
+                name: /role arn/i
+            }), 'arn:aws:iam::123456789012:role/replication');
+            await user_event.type(screen.getByRole('textbox', {
+                name: /rule id/i
+            }), 'test-rule-v1');
+            const targetBucketSelect = screen.getByLabelText(/target bucket/i);
+            await user_event.click(targetBucketSelect);
+            await user_event.click(screen.getByRole('option', {
+                name: 'destination-bucket'
+            }));
+            await submitForm('create');
+            await waitFor(()=>{
+                expect(mockMutate).toHaveBeenCalled();
+            });
+            const submittedRule = mockMutate.mock.calls[0][0].ReplicationConfiguration.Rules[0];
+            expect(submittedRule.Prefix).toBe('');
+            expect(submittedRule.ID).toBe('test-rule-v1');
+            expect(submittedRule.Status).toBe('Enabled');
+            expect(submittedRule.Destination.Bucket).toBe('arn:aws:s3:::destination-bucket');
+            expect(submittedRule).not.toHaveProperty('Filter');
+            expect(submittedRule).not.toHaveProperty('Priority');
+            expect(submittedRule).not.toHaveProperty('DeleteMarkerReplication');
+            expect(submittedRule).not.toHaveProperty('SourceSelectionCriteria');
+        });
+        it('hides V2-only fields when replicationV1 is enabled', ()=>{
+            mockUseFeatures.mockImplementation((feature)=>{
+                if ('replicationV1' === feature) return true;
+                return false;
+            });
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: '',
+                        Rules: []
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage();
+            expect(screen.getByRole('textbox', {
+                name: /role arn/i
+            })).toBeInTheDocument();
+            expect(screen.getByRole('textbox', {
+                name: /rule id/i
+            })).toBeInTheDocument();
+            expect(screen.queryByRole('spinbutton', {
+                name: /rule priority/i
+            })).not.toBeInTheDocument();
+            expect(screen.queryByText('Encryption')).not.toBeInTheDocument();
+            expect(screen.queryByText('Additional Options')).not.toBeInTheDocument();
+        });
+        it('shows simplified destination without cross-account in V1 mode', ()=>{
+            mockUseFeatures.mockImplementation((feature)=>{
+                if ('replicationV1' === feature) return true;
+                return false;
+            });
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: '',
+                        Rules: []
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage();
+            expect(screen.getByText(/Target Bucket/i)).toBeInTheDocument();
+            expect(screen.queryByText(/Same account destination/i)).not.toBeInTheDocument();
+        });
+        it('shows only prefix filter (no filter type selector) in V1 mode', ()=>{
+            mockUseFeatures.mockImplementation((feature)=>{
+                if ('replicationV1' === feature) return true;
+                return false;
+            });
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: '',
+                        Rules: []
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage();
+            expect(screen.getByRole('textbox', {
+                name: /prefix/i
+            })).toBeInTheDocument();
+            expect(screen.queryByText('All objects')).not.toBeInTheDocument();
+            expect(screen.queryByText('Tags filter')).not.toBeInTheDocument();
+        });
+        it('allows submission without priority in V1 mode', async ()=>{
+            mockUseFeatures.mockImplementation((feature)=>{
+                if ('replicationV1' === feature) return true;
+                return false;
+            });
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: '',
+                        Rules: []
+                    }
+                },
+                status: 'success'
+            });
+            mockSuccessSubmit(mockMutate);
+            renderBucketReplicationFormPage();
+            await user_event.type(screen.getByRole('textbox', {
+                name: /role arn/i
+            }), 'arn:aws:iam::123456789012:role/repl');
+            await user_event.type(screen.getByRole('textbox', {
+                name: /rule id/i
+            }), 'v1-rule');
+            const targetBucketSelect = screen.getByLabelText(/target bucket/i);
+            await user_event.click(targetBucketSelect);
+            await user_event.click(screen.getByRole('option', {
+                name: 'destination-bucket'
+            }));
+            await submitForm('create');
+            await waitFor(()=>{
+                expect(mockMutate).toHaveBeenCalled();
+            });
+            const submittedRule = mockMutate.mock.calls[0][0].ReplicationConfiguration.Rules[0];
+            expect(submittedRule.Prefix).toBe('');
+            expect(submittedRule).not.toHaveProperty('Priority');
+        });
+        it('loads existing V1 rule (with Prefix at rule level) for editing', async ()=>{
+            mockUseFeatures.mockImplementation((feature)=>{
+                if ('replicationV1' === feature) return true;
+                return false;
+            });
+            const v1Rule = {
+                ID: 'existing-v1-rule',
+                Status: 'Enabled',
+                Prefix: 'documents/',
+                Destination: {
+                    Bucket: 'arn:aws:s3:::destination-bucket',
+                    StorageClass: 'STANDARD'
+                }
+            };
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: 'arn:aws:iam::123456789012:role/repl',
+                        Rules: [
+                            v1Rule
+                        ]
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage('test-bucket', 'existing-v1-rule');
+            await waitFor(()=>{
+                expect(screen.getByText('existing-v1-rule')).toBeInTheDocument();
+            });
+            const prefixInput = screen.getByRole('textbox', {
+                name: /prefix/i
+            });
+            expect(prefixInput.value).toBe('documents/');
+        });
+        it('shows all V2 fields when replicationV1 is not enabled', ()=>{
+            mockUseFeatures.mockImplementation((feature)=>{
+                if ('replicationAdvanced' === feature) return true;
+                return false;
+            });
+            mockUseGetBucketReplication.mockReturnValue({
+                data: {
+                    ReplicationConfiguration: {
+                        Role: '',
+                        Rules: []
+                    }
+                },
+                status: 'success'
+            });
+            renderBucketReplicationFormPage();
+            expect(screen.getByRole('spinbutton', {
+                name: /rule priority/i
+            })).toBeInTheDocument();
+            expect(screen.getByText(/^Encryption/)).toBeInTheDocument();
+            expect(screen.getByText(/^Additional Options/)).toBeInTheDocument();
+        });
+    });
 });

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

@@ -3,11 +3,30 @@ import { fireEvent, render, screen, waitFor } from "@testing-library/react";
 import user_event from "@testing-library/user-event";
 import { createTestWrapper } from "../../test/testUtils.js";
 import { CreateFolderButton } from "../objects/CreateFolderButton.js";
+const mockMutate = jest.fn();
+jest.mock('../../hooks', ()=>({
+        ...jest.requireActual('../../hooks'),
+        useCreateFolder: ()=>({
+                mutate: mockMutate,
+                mutateAsync: jest.fn(),
+                reset: jest.fn(),
+                isPending: false,
+                isIdle: true,
+                isError: false,
+                isSuccess: false,
+                status: 'idle',
+                data: void 0,
+                error: null
+            })
+    }));
 describe('CreateFolderButton', ()=>{
     const defaultProps = {
         bucket: 'test-bucket',
         prefix: 'test-prefix'
     };
+    beforeEach(()=>{
+        mockMutate.mockClear();
+    });
     const renderCreateFolderButton = (props = {})=>{
         const Wrapper = createTestWrapper();
         return render(/*#__PURE__*/ jsx(Wrapper, {
@@ -144,4 +163,52 @@ describe('CreateFolderButton', ()=>{
         await user_event.type(input, '/invalid');
         expect(saveButton).toBeDisabled();
     });
+    it('constructs correct key when prefix has trailing slash', async ()=>{
+        renderCreateFolderButton({
+            prefix: 'documents/'
+        });
+        fireEvent.click(screen.getByRole('button', {
+            name: /folder/i
+        }));
+        await waitFor(()=>screen.getByText('Create a folder'));
+        await user_event.type(screen.getByRole('textbox'), 'sub-folder');
+        fireEvent.click(screen.getByRole('button', {
+            name: /save/i
+        }));
+        expect(mockMutate).toHaveBeenCalledWith(expect.objectContaining({
+            Key: 'documents/sub-folder/'
+        }), expect.anything());
+    });
+    it('constructs correct key when prefix has no trailing slash', async ()=>{
+        renderCreateFolderButton({
+            prefix: 'documents'
+        });
+        fireEvent.click(screen.getByRole('button', {
+            name: /folder/i
+        }));
+        await waitFor(()=>screen.getByText('Create a folder'));
+        await user_event.type(screen.getByRole('textbox'), 'sub-folder');
+        fireEvent.click(screen.getByRole('button', {
+            name: /save/i
+        }));
+        expect(mockMutate).toHaveBeenCalledWith(expect.objectContaining({
+            Key: 'documents/sub-folder/'
+        }), expect.anything());
+    });
+    it('constructs correct key when prefix is empty', async ()=>{
+        renderCreateFolderButton({
+            prefix: ''
+        });
+        fireEvent.click(screen.getByRole('button', {
+            name: /folder/i
+        }));
+        await waitFor(()=>screen.getByText('Create a folder'));
+        await user_event.type(screen.getByRole('textbox'), 'new-folder');
+        fireEvent.click(screen.getByRole('button', {
+            name: /save/i
+        }));
+        expect(mockMutate).toHaveBeenCalledWith(expect.objectContaining({
+            Key: 'new-folder/'
+        }), expect.anything());
+    });
 });