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

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__/DeleteBucketConfigRuleButton.test.d.ts

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

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

@@ -0,0 +1,196 @@
+import { jsx } from "react/jsx-runtime";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { MemoryRouter } from "react-router-dom";
+import { createTestWrapper } from "../../test/testUtils.js";
+import { DeleteBucketConfigRuleButton } from "../buckets/DeleteBucketConfigRuleButton.js";
+const mockLifecycleRules = [
+    {
+        ID: "rule-1",
+        Status: "Enabled",
+        Expiration: {
+            Days: 30
+        }
+    },
+    {
+        ID: "rule-2",
+        Status: "Disabled",
+        NoncurrentVersionExpiration: {
+            NoncurrentDays: 90
+        }
+    }
+];
+describe("DeleteBucketConfigRuleButton", ()=>{
+    let mockUpdate;
+    let mockDelete;
+    const renderButton = (props = {})=>{
+        const defaultProps = {
+            bucketName: "test-bucket",
+            ruleId: "rule-1",
+            rules: mockLifecycleRules,
+            ruleType: "lifecycle",
+            updateMutation: {
+                mutate: mockUpdate,
+                status: "idle"
+            },
+            deleteMutation: {
+                mutate: mockDelete,
+                status: "idle"
+            },
+            buildUpdateInput: (remainingRules)=>({
+                    LifecycleConfiguration: {
+                        Rules: remainingRules
+                    }
+                }),
+            invalidationKeys: [
+                "GetBucketLifecycle"
+            ],
+            successMessage: "Rule deleted successfully",
+            errorMessage: "Failed to delete rule"
+        };
+        const Wrapper = createTestWrapper();
+        return render(/*#__PURE__*/ jsx(MemoryRouter, {
+            children: /*#__PURE__*/ jsx(Wrapper, {
+                children: /*#__PURE__*/ jsx(DeleteBucketConfigRuleButton, {
+                    ...defaultProps,
+                    ...props
+                })
+            })
+        }));
+    };
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockUpdate = jest.fn();
+        mockDelete = jest.fn();
+    });
+    it("renders delete button", ()=>{
+        renderButton();
+        const deleteButton = screen.getByRole("button", {
+            name: /delete rule/i
+        });
+        expect(deleteButton).toBeInTheDocument();
+    });
+    it("opens confirmation modal when clicked", ()=>{
+        renderButton();
+        const deleteButton = screen.getByRole("button", {
+            name: /delete rule/i
+        });
+        fireEvent.click(deleteButton);
+        expect(screen.getByText(/are you sure you want to delete the lifecycle rule/i)).toBeInTheDocument();
+        expect(screen.getByText(/rule-1/)).toBeInTheDocument();
+    });
+    it("closes modal when cancel is clicked", ()=>{
+        renderButton();
+        fireEvent.click(screen.getByRole("button", {
+            name: /delete rule/i
+        }));
+        expect(screen.getByText(/are you sure/i)).toBeInTheDocument();
+        fireEvent.click(screen.getByRole("button", {
+            name: /cancel/i
+        }));
+        expect(screen.queryByText(/are you sure/i)).not.toBeInTheDocument();
+    });
+    it("calls update when deleting a rule with remaining rules", async ()=>{
+        renderButton();
+        fireEvent.click(screen.getByRole("button", {
+            name: /delete rule/i
+        }));
+        fireEvent.click(screen.getByRole("button", {
+            name: /^delete$/i
+        }));
+        await waitFor(()=>{
+            expect(mockUpdate).toHaveBeenCalled();
+            const callArgs = mockUpdate.mock.calls[0][0];
+            expect(callArgs.Bucket).toBe("test-bucket");
+            expect(callArgs.LifecycleConfiguration.Rules).toHaveLength(1);
+            expect(callArgs.LifecycleConfiguration.Rules[0].ID).toBe("rule-2");
+        });
+    });
+    it("calls delete when deleting the last rule", async ()=>{
+        renderButton({
+            rules: [
+                mockLifecycleRules[0]
+            ]
+        });
+        fireEvent.click(screen.getByRole("button", {
+            name: /delete rule/i
+        }));
+        fireEvent.click(screen.getByRole("button", {
+            name: /^delete$/i
+        }));
+        await waitFor(()=>{
+            expect(mockDelete).toHaveBeenCalledWith({
+                Bucket: "test-bucket"
+            }, expect.any(Object));
+        });
+    });
+    it("closes modal after successful deletion", async ()=>{
+        mockUpdate.mockImplementation((_, options)=>{
+            options.onSuccess();
+        });
+        renderButton();
+        fireEvent.click(screen.getByRole("button", {
+            name: /delete rule/i
+        }));
+        fireEvent.click(screen.getByRole("button", {
+            name: /^delete$/i
+        }));
+        await waitFor(()=>{
+            expect(screen.queryByText(/are you sure/i)).not.toBeInTheDocument();
+        });
+    });
+    it("closes modal after failed deletion", async ()=>{
+        const consoleError = jest.spyOn(console, "error").mockImplementation(()=>{});
+        mockUpdate.mockImplementation((_, options)=>{
+            options.onError(new Error("Delete failed"));
+        });
+        renderButton();
+        fireEvent.click(screen.getByRole("button", {
+            name: /delete rule/i
+        }));
+        fireEvent.click(screen.getByRole("button", {
+            name: /^delete$/i
+        }));
+        await waitFor(()=>{
+            expect(mockUpdate).toHaveBeenCalled();
+        });
+        await waitFor(()=>{
+            expect(screen.queryByText(/are you sure/i)).not.toBeInTheDocument();
+        });
+        consoleError.mockRestore();
+    });
+    it("disables buttons while deletion is in progress", ()=>{
+        renderButton({
+            updateMutation: {
+                mutate: mockUpdate,
+                status: "pending"
+            }
+        });
+        fireEvent.click(screen.getByRole("button", {
+            name: /delete rule/i
+        }));
+        const cancelButton = screen.getByRole("button", {
+            name: /cancel/i
+        });
+        const confirmButton = screen.getByRole("button", {
+            name: /^delete$/i
+        });
+        expect(cancelButton).toBeDisabled();
+        expect(confirmButton).toBeDisabled();
+    });
+    it("stops event propagation when delete button is clicked", ()=>{
+        renderButton();
+        const deleteButton = screen.getByRole("button", {
+            name: /delete rule/i
+        });
+        const mockStopPropagation = jest.fn();
+        const clickEvent = new MouseEvent("click", {
+            bubbles: true
+        });
+        Object.defineProperty(clickEvent, "stopPropagation", {
+            value: mockStopPropagation,
+            writable: true
+        });
+        deleteButton.dispatchEvent(clickEvent);
+        expect(mockStopPropagation).toHaveBeenCalled();
+    });
+});

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

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