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

package/dist/components/__tests__/BucketReplicationList.test.d.ts

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,344 @@
+import { jsx } from "react/jsx-runtime";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { MemoryRouter } from "react-router";
+import { createTestWrapper, mockOffsetSize } from "../../test/testUtils.js";
+import { BucketReplicationList } from "../buckets/BucketReplicationList.js";
+const renderBucketReplicationList = (props = {})=>{
+    const Wrapper = createTestWrapper();
+    return render(/*#__PURE__*/ jsx(MemoryRouter, {
+        children: /*#__PURE__*/ jsx(Wrapper, {
+            children: /*#__PURE__*/ jsx(BucketReplicationList, {
+                bucketName: "test-bucket",
+                replicationRules: [],
+                replicationRole: "arn:aws:iam::123456789012:role/replication-role",
+                ...props
+            })
+        })
+    }));
+};
+const mockReplicationRules = [
+    {
+        ID: 'rule-1',
+        Status: 'Enabled',
+        Priority: 1,
+        Destination: {
+            Bucket: 'arn:aws:s3:::destination-bucket-1',
+            StorageClass: 'STANDARD'
+        }
+    },
+    {
+        ID: 'rule-2',
+        Status: 'Disabled',
+        Priority: 2,
+        Destination: {
+            Bucket: 'arn:aws:s3:::123456789012:backup-bucket',
+            StorageClass: 'GLACIER',
+            Account: '123456789012'
+        }
+    },
+    {
+        ID: 'rule-3',
+        Status: 'Enabled',
+        Priority: 100,
+        Destination: {
+            Bucket: 'arn:aws:s3:::logs-backup',
+            StorageClass: 'ONEZONE_IA'
+        }
+    }
+];
+const mockRuleWithoutPriority = {
+    ID: 'no-priority-rule',
+    Status: 'Enabled',
+    Destination: {
+        Bucket: 'arn:aws:s3:::simple-backup'
+    }
+};
+const mockRuleWithoutStorageClass = {
+    ID: 'no-storage-class-rule',
+    Status: 'Enabled',
+    Priority: 5,
+    Destination: {
+        Bucket: 'arn:aws:s3:::mirror-bucket'
+    }
+};
+describe('BucketReplicationList', ()=>{
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockOffsetSize(800, 600);
+    });
+    it('shows a table with proper headers', ()=>{
+        renderBucketReplicationList({
+            replicationRules: mockReplicationRules
+        });
+        expect(screen.getByRole('grid')).toBeInTheDocument();
+        expect(screen.getByText('Rule ID')).toBeInTheDocument();
+        expect(screen.getByText('Status')).toBeInTheDocument();
+        expect(screen.getByText('Destination')).toBeInTheDocument();
+        expect(screen.getByText('Priority')).toBeInTheDocument();
+    });
+    it('displays replication rules with their IDs', ()=>{
+        renderBucketReplicationList({
+            replicationRules: mockReplicationRules
+        });
+        expect(screen.getByText('rule-1')).toBeInTheDocument();
+        expect(screen.getByText('rule-2')).toBeInTheDocument();
+        expect(screen.getByText('rule-3')).toBeInTheDocument();
+    });
+    it('displays status as Active for Enabled rules', ()=>{
+        renderBucketReplicationList({
+            replicationRules: mockReplicationRules
+        });
+        const activeStatuses = screen.getAllByText('Active');
+        expect(activeStatuses.length).toBe(2);
+    });
+    it('displays status as Inactive for Disabled rules', ()=>{
+        renderBucketReplicationList({
+            replicationRules: mockReplicationRules
+        });
+        expect(screen.getByText('Inactive')).toBeInTheDocument();
+    });
+    it('displays replication action with bucket name', ()=>{
+        renderBucketReplicationList({
+            replicationRules: mockReplicationRules
+        });
+        expect(screen.getByText(/Replicate to destination-bucket-1/)).toBeInTheDocument();
+        expect(screen.getByText(/Replicate to backup-bucket/)).toBeInTheDocument();
+        expect(screen.getByText(/Replicate to logs-backup/)).toBeInTheDocument();
+    });
+    it('displays storage class in actions column', ()=>{
+        renderBucketReplicationList({
+            replicationRules: mockReplicationRules
+        });
+        const actionTexts = screen.getAllByText(/Replicate to/);
+        expect(actionTexts.length).toBeGreaterThanOrEqual(3);
+        expect(screen.getByText(/STANDARD/, {
+            exact: false
+        })).toBeInTheDocument();
+        expect(screen.getByText(/GLACIER/, {
+            exact: false
+        })).toBeInTheDocument();
+        expect(screen.getByText(/ONEZONE_IA/, {
+            exact: false
+        })).toBeInTheDocument();
+    });
+    it('displays shortened account ID for cross-account replication', ()=>{
+        renderBucketReplicationList({
+            replicationRules: mockReplicationRules
+        });
+        expect(screen.getByText(/account: 123\.\.\.012/)).toBeInTheDocument();
+    });
+    it('displays priority values correctly', ()=>{
+        renderBucketReplicationList({
+            replicationRules: mockReplicationRules
+        });
+        expect(screen.getByText('1')).toBeInTheDocument();
+        expect(screen.getByText('2')).toBeInTheDocument();
+        expect(screen.getByText('100')).toBeInTheDocument();
+    });
+    it("displays 'None' for rules without priority", ()=>{
+        renderBucketReplicationList({
+            replicationRules: [
+                mockRuleWithoutPriority
+            ]
+        });
+        expect(screen.getByText('None')).toBeInTheDocument();
+    });
+    it('displays action without storage class when not provided', ()=>{
+        renderBucketReplicationList({
+            replicationRules: [
+                mockRuleWithoutStorageClass
+            ]
+        });
+        const actionText = screen.getByText(/Replicate to mirror-bucket/);
+        expect(actionText).toBeInTheDocument();
+        expect(actionText.textContent).toBe('Replicate to mirror-bucket');
+    });
+    it('renders create rule button as enabled', ()=>{
+        renderBucketReplicationList({
+            replicationRules: mockReplicationRules
+        });
+        const createButton = screen.getByRole('button', {
+            name: /create rule/i
+        });
+        expect(createButton).toBeInTheDocument();
+        expect(createButton).toBeEnabled();
+    });
+    it('calls create rule callback when button is clicked', ()=>{
+        const onCreateRule = jest.fn();
+        renderBucketReplicationList({
+            replicationRules: mockReplicationRules,
+            onCreateRule
+        });
+        const createButton = screen.getByRole('button', {
+            name: /create rule/i
+        });
+        expect(createButton).toBeEnabled();
+        fireEvent.click(createButton);
+        expect(onCreateRule).toHaveBeenCalled();
+    });
+    it('handles edit button click', ()=>{
+        const onEditRule = jest.fn();
+        renderBucketReplicationList({
+            replicationRules: mockReplicationRules,
+            onEditRule
+        });
+        const editButtons = screen.getAllByRole('button', {
+            name: /edit rule/i
+        });
+        expect(editButtons.length).toBeGreaterThanOrEqual(3);
+        fireEvent.click(editButtons[0]);
+        expect(onEditRule).toHaveBeenCalledWith(expect.any(String));
+    });
+    it('renders delete buttons for each rule', ()=>{
+        renderBucketReplicationList({
+            replicationRules: mockReplicationRules
+        });
+        const deleteButtons = screen.getAllByRole('button', {
+            name: /delete rule/i
+        });
+        expect(deleteButtons.length).toBeGreaterThanOrEqual(3);
+    });
+    it('handles empty replication rules list', ()=>{
+        renderBucketReplicationList({
+            replicationRules: []
+        });
+        expect(screen.getByRole('grid')).toBeInTheDocument();
+        expect(screen.getByText(/no replication rules found/i)).toBeInTheDocument();
+    });
+    it('handles replication rules without IDs', ()=>{
+        const ruleWithoutId = {
+            Status: 'Enabled',
+            Priority: 1,
+            Destination: {
+                Bucket: 'arn:aws:s3:::test-bucket'
+            }
+        };
+        renderBucketReplicationList({
+            replicationRules: [
+                ruleWithoutId
+            ]
+        });
+        expect(screen.getByText('-')).toBeInTheDocument();
+    });
+    it('shows loading state when replicationStatus is loading', ()=>{
+        renderBucketReplicationList({
+            replicationRules: [],
+            replicationStatus: 'loading'
+        });
+        expect(screen.getByRole('grid')).toBeInTheDocument();
+        expect(screen.queryByText('rule-1')).not.toBeInTheDocument();
+    });
+    it('shows error state when replicationStatus is error', ()=>{
+        renderBucketReplicationList({
+            replicationRules: [],
+            replicationStatus: 'error'
+        });
+        expect(screen.getByRole('grid')).toBeInTheDocument();
+        expect(screen.queryByText('rule-1')).not.toBeInTheDocument();
+    });
+    it('shows data when replicationStatus is success', ()=>{
+        renderBucketReplicationList({
+            replicationRules: mockReplicationRules,
+            replicationStatus: 'success'
+        });
+        expect(screen.getByRole('grid')).toBeInTheDocument();
+        expect(screen.getByText('rule-1')).toBeInTheDocument();
+        expect(screen.getByText('rule-2')).toBeInTheDocument();
+    });
+    it('works when no callbacks are provided', ()=>{
+        expect(()=>{
+            renderBucketReplicationList({
+                replicationRules: mockReplicationRules
+            });
+        }).not.toThrow();
+    });
+    it('renders rows that can be selected', ()=>{
+        renderBucketReplicationList({
+            replicationRules: mockReplicationRules
+        });
+        const rows = screen.getAllByRole('row');
+        expect(rows.length).toBeGreaterThan(3);
+        const dataRows = rows.slice(1);
+        dataRows.forEach((row)=>{
+            expect(row).toHaveAttribute('aria-selected');
+        });
+    });
+    it('displays complex cross-account replication with all details', ()=>{
+        const complexRule = {
+            ID: 'complex-rule',
+            Status: 'Enabled',
+            Priority: 25,
+            Destination: {
+                Bucket: 'arn:aws:s3:::999888777666555:shared-bucket',
+                Account: '999888777666555',
+                StorageClass: 'GLACIER_IR'
+            }
+        };
+        renderBucketReplicationList({
+            replicationRules: [
+                complexRule
+            ]
+        });
+        expect(screen.getByText(/account: 999\.\.\.555/)).toBeInTheDocument();
+        expect(screen.getByText(/GLACIER_IR/)).toBeInTheDocument();
+        expect(screen.getByText(/Replicate to shared-bucket \(account: 999\.\.\.555, GLACIER_IR\)/)).toBeInTheDocument();
+    });
+    it('displays action text without account ID for same-account replication', ()=>{
+        renderBucketReplicationList({
+            replicationRules: [
+                mockReplicationRules[0]
+            ]
+        });
+        const actionText = screen.getByText(/Replicate to destination-bucket-1/);
+        expect(actionText.textContent).not.toContain('account:');
+    });
+    it('renders with custom bucket name and replication role', ()=>{
+        renderBucketReplicationList({
+            replicationRules: mockReplicationRules,
+            bucketName: 'custom-bucket',
+            replicationRole: 'arn:aws:iam::999888777666:role/custom-role'
+        });
+        expect(screen.getByText('rule-1')).toBeInTheDocument();
+        expect(screen.getByText('rule-2')).toBeInTheDocument();
+        expect(screen.getByText('rule-3')).toBeInTheDocument();
+    });
+    it('sorts rules by priority from low to high by default', ()=>{
+        const unsortedRules = [
+            {
+                ID: 'high-priority-rule',
+                Status: 'Enabled',
+                Priority: 100,
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket-high'
+                }
+            },
+            {
+                ID: 'low-priority-rule',
+                Status: 'Enabled',
+                Priority: 1,
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket-low'
+                }
+            },
+            {
+                ID: 'mid-priority-rule',
+                Status: 'Enabled',
+                Priority: 50,
+                Destination: {
+                    Bucket: 'arn:aws:s3:::bucket-mid'
+                }
+            }
+        ];
+        renderBucketReplicationList({
+            replicationRules: unsortedRules
+        });
+        const rows = screen.getAllByRole('row');
+        const dataRows = rows.slice(1);
+        expect(dataRows[0]).toHaveTextContent('low-priority-rule');
+        expect(dataRows[0]).toHaveTextContent('1');
+        expect(dataRows[1]).toHaveTextContent('mid-priority-rule');
+        expect(dataRows[1]).toHaveTextContent('50');
+        expect(dataRows[2]).toHaveTextContent('high-priority-rule');
+        expect(dataRows[2]).toHaveTextContent('100');
+    });
+});

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

@@ -3,10 +3,10 @@ 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";
-describe("CreateFolderButton", ()=>{
+describe('CreateFolderButton', ()=>{
     const defaultProps = {
-        bucket: "test-bucket",
-        prefix: "test-prefix"
+        bucket: 'test-bucket',
+        prefix: 'test-prefix'
     };
     const renderCreateFolderButton = (props = {})=>{
         const Wrapper = createTestWrapper();
@@ -17,131 +17,131 @@ describe("CreateFolderButton", ()=>{
             })
         }));
     };
-    it("renders button with default label", ()=>{
+    it('renders button with default label', ()=>{
         renderCreateFolderButton();
-        expect(screen.getByRole("button", {
+        expect(screen.getByRole('button', {
             name: /folder/i
         })).toBeInTheDocument();
     });
-    it("renders button with custom label", ()=>{
+    it('renders button with custom label', ()=>{
         renderCreateFolderButton({
-            label: "Add New Folder"
+            label: 'Add New Folder'
         });
-        expect(screen.getByRole("button", {
+        expect(screen.getByRole('button', {
             name: /add new folder/i
         })).toBeInTheDocument();
     });
-    it("opens modal when button is clicked", async ()=>{
+    it('opens modal when button is clicked', async ()=>{
         renderCreateFolderButton();
-        fireEvent.click(screen.getByRole("button", {
+        fireEvent.click(screen.getByRole('button', {
             name: /folder/i
         }));
         await waitFor(()=>{
-            expect(screen.getByText("Create a folder")).toBeInTheDocument();
+            expect(screen.getByText('Create a folder')).toBeInTheDocument();
         });
     });
-    it("closes modal when cancel button is clicked", async ()=>{
+    it('closes modal when cancel button is clicked', async ()=>{
         renderCreateFolderButton();
-        fireEvent.click(screen.getByRole("button", {
+        fireEvent.click(screen.getByRole('button', {
             name: /folder/i
         }));
-        await waitFor(()=>screen.getByText("Create a folder"));
-        fireEvent.click(screen.getByRole("button", {
+        await waitFor(()=>screen.getByText('Create a folder'));
+        fireEvent.click(screen.getByRole('button', {
             name: /cancel/i
         }));
         await waitFor(()=>{
-            expect(screen.queryByText("Create a folder")).not.toBeInTheDocument();
+            expect(screen.queryByText('Create a folder')).not.toBeInTheDocument();
         });
     });
-    it("disables save button when folder name is empty", async ()=>{
+    it('disables save button when folder name is empty', async ()=>{
         renderCreateFolderButton();
-        fireEvent.click(screen.getByRole("button", {
+        fireEvent.click(screen.getByRole('button', {
             name: /folder/i
         }));
-        await waitFor(()=>screen.getByText("Create a folder"));
-        expect(screen.getByRole("button", {
+        await waitFor(()=>screen.getByText('Create a folder'));
+        expect(screen.getByRole('button', {
             name: /save/i
         })).toBeDisabled();
     });
-    it("enables save button when valid folder name is entered", async ()=>{
+    it('enables save button when valid folder name is entered', async ()=>{
         renderCreateFolderButton();
-        fireEvent.click(screen.getByRole("button", {
+        fireEvent.click(screen.getByRole('button', {
             name: /folder/i
         }));
-        await waitFor(()=>screen.getByText("Create a folder"));
-        await user_event.type(screen.getByRole("textbox"), "valid-folder");
-        expect(screen.getByRole("button", {
+        await waitFor(()=>screen.getByText('Create a folder'));
+        await user_event.type(screen.getByRole('textbox'), 'valid-folder');
+        expect(screen.getByRole('button', {
             name: /save/i
         })).toBeEnabled();
     });
-    it("disables save button and shows error when folder name starts with slash", async ()=>{
+    it('disables save button and shows error when folder name starts with slash', async ()=>{
         renderCreateFolderButton();
-        fireEvent.click(screen.getByRole("button", {
+        fireEvent.click(screen.getByRole('button', {
             name: /folder/i
         }));
-        await waitFor(()=>screen.getByText("Create a folder"));
-        await user_event.type(screen.getByRole("textbox"), "/invalid-folder");
-        expect(screen.getByRole("button", {
+        await waitFor(()=>screen.getByText('Create a folder'));
+        await user_event.type(screen.getByRole('textbox'), '/invalid-folder');
+        expect(screen.getByRole('button', {
             name: /save/i
         })).toBeDisabled();
     });
-    it("triggers mutation when save is clicked with valid folder name", async ()=>{
+    it('triggers mutation when save is clicked with valid folder name', async ()=>{
         renderCreateFolderButton();
-        fireEvent.click(screen.getByRole("button", {
+        fireEvent.click(screen.getByRole('button', {
             name: /folder/i
         }));
-        await waitFor(()=>screen.getByText("Create a folder"));
-        await user_event.type(screen.getByRole("textbox"), "test-folder");
-        const saveButton = screen.getByRole("button", {
+        await waitFor(()=>screen.getByText('Create a folder'));
+        await user_event.type(screen.getByRole('textbox'), 'test-folder');
+        const saveButton = screen.getByRole('button', {
             name: /save/i
         });
         expect(saveButton).toBeEnabled();
         fireEvent.click(saveButton);
-        expect(screen.getByText("Create a folder")).toBeInTheDocument();
+        expect(screen.getByText('Create a folder')).toBeInTheDocument();
     });
-    it("clears folder name when modal is closed", async ()=>{
+    it('clears folder name when modal is closed', async ()=>{
         renderCreateFolderButton();
-        fireEvent.click(screen.getByRole("button", {
+        fireEvent.click(screen.getByRole('button', {
             name: /folder/i
         }));
-        await waitFor(()=>screen.getByText("Create a folder"));
-        await user_event.type(screen.getByRole("textbox"), "test-folder");
-        fireEvent.click(screen.getByRole("button", {
+        await waitFor(()=>screen.getByText('Create a folder'));
+        await user_event.type(screen.getByRole('textbox'), 'test-folder');
+        fireEvent.click(screen.getByRole('button', {
             name: /cancel/i
         }));
         await waitFor(()=>{
-            expect(screen.queryByText("Create a folder")).not.toBeInTheDocument();
+            expect(screen.queryByText('Create a folder')).not.toBeInTheDocument();
         });
-        fireEvent.click(screen.getByRole("button", {
+        fireEvent.click(screen.getByRole('button', {
             name: /folder/i
         }));
-        await waitFor(()=>screen.getByText("Create a folder"));
-        expect(screen.getByRole("textbox")).toHaveValue("");
+        await waitFor(()=>screen.getByText('Create a folder'));
+        expect(screen.getByRole('textbox')).toHaveValue('');
     });
-    it("shows info message about folder creation", async ()=>{
+    it('shows info message about folder creation', async ()=>{
         renderCreateFolderButton();
-        fireEvent.click(screen.getByRole("button", {
+        fireEvent.click(screen.getByRole('button', {
             name: /folder/i
         }));
-        await waitFor(()=>screen.getByText("Create a folder"));
-        expect(screen.getByText("Creating a folder")).toBeInTheDocument();
+        await waitFor(()=>screen.getByText('Create a folder'));
+        expect(screen.getByText('Creating a folder')).toBeInTheDocument();
         expect(screen.getByText(/ensure the folder name does not begin with a slash/i)).toBeInTheDocument();
     });
-    it("handles folder name validation correctly", async ()=>{
+    it('handles folder name validation correctly', async ()=>{
         renderCreateFolderButton();
-        fireEvent.click(screen.getByRole("button", {
+        fireEvent.click(screen.getByRole('button', {
             name: /folder/i
         }));
-        await waitFor(()=>screen.getByText("Create a folder"));
-        const input = screen.getByRole("textbox");
-        const saveButton = screen.getByRole("button", {
+        await waitFor(()=>screen.getByText('Create a folder'));
+        const input = screen.getByRole('textbox');
+        const saveButton = screen.getByRole('button', {
             name: /save/i
         });
         expect(saveButton).toBeDisabled();
-        await user_event.type(input, "valid-folder");
+        await user_event.type(input, 'valid-folder');
         expect(saveButton).toBeEnabled();
         await user_event.clear(input);
-        await user_event.type(input, "/invalid");
+        await user_event.type(input, '/invalid');
         expect(saveButton).toBeDisabled();
     });
 });