@scality/data-browser-library 1.0.0-preview.11

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.d.ts

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

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

@@ -0,0 +1,147 @@
+import { jsx } from "react/jsx-runtime";
+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", ()=>{
+    const defaultProps = {
+        bucket: "test-bucket",
+        prefix: "test-prefix"
+    };
+    const renderCreateFolderButton = (props = {})=>{
+        const Wrapper = createTestWrapper();
+        return render(/*#__PURE__*/ jsx(Wrapper, {
+            children: /*#__PURE__*/ jsx(CreateFolderButton, {
+                ...defaultProps,
+                ...props
+            })
+        }));
+    };
+    it("renders button with default label", ()=>{
+        renderCreateFolderButton();
+        expect(screen.getByRole("button", {
+            name: /folder/i
+        })).toBeInTheDocument();
+    });
+    it("renders button with custom label", ()=>{
+        renderCreateFolderButton({
+            label: "Add New Folder"
+        });
+        expect(screen.getByRole("button", {
+            name: /add new folder/i
+        })).toBeInTheDocument();
+    });
+    it("opens modal when button is clicked", async ()=>{
+        renderCreateFolderButton();
+        fireEvent.click(screen.getByRole("button", {
+            name: /folder/i
+        }));
+        await waitFor(()=>{
+            expect(screen.getByText("Create a folder")).toBeInTheDocument();
+        });
+    });
+    it("closes modal when cancel button is clicked", async ()=>{
+        renderCreateFolderButton();
+        fireEvent.click(screen.getByRole("button", {
+            name: /folder/i
+        }));
+        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();
+        });
+    });
+    it("disables save button when folder name is empty", async ()=>{
+        renderCreateFolderButton();
+        fireEvent.click(screen.getByRole("button", {
+            name: /folder/i
+        }));
+        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 ()=>{
+        renderCreateFolderButton();
+        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", {
+            name: /save/i
+        })).toBeEnabled();
+    });
+    it("disables save button and shows error when folder name starts with slash", async ()=>{
+        renderCreateFolderButton();
+        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", {
+            name: /save/i
+        })).toBeDisabled();
+    });
+    it("triggers mutation when save is clicked with valid folder name", async ()=>{
+        renderCreateFolderButton();
+        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", {
+            name: /save/i
+        });
+        expect(saveButton).toBeEnabled();
+        fireEvent.click(saveButton);
+        expect(screen.getByText("Create a folder")).toBeInTheDocument();
+    });
+    it("clears folder name when modal is closed", async ()=>{
+        renderCreateFolderButton();
+        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", {
+            name: /cancel/i
+        }));
+        await waitFor(()=>{
+            expect(screen.queryByText("Create a folder")).not.toBeInTheDocument();
+        });
+        fireEvent.click(screen.getByRole("button", {
+            name: /folder/i
+        }));
+        await waitFor(()=>screen.getByText("Create a folder"));
+        expect(screen.getByRole("textbox")).toHaveValue("");
+    });
+    it("shows info message about folder creation", async ()=>{
+        renderCreateFolderButton();
+        fireEvent.click(screen.getByRole("button", {
+            name: /folder/i
+        }));
+        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 ()=>{
+        renderCreateFolderButton();
+        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", {
+            name: /save/i
+        });
+        expect(saveButton).toBeDisabled();
+        await user_event.type(input, "valid-folder");
+        expect(saveButton).toBeEnabled();
+        await user_event.clear(input);
+        await user_event.type(input, "/invalid");
+        expect(saveButton).toBeDisabled();
+    });
+});

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

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