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

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

@@ -0,0 +1,325 @@
+import { jsx } from "react/jsx-runtime";
+import { fireEvent, render, screen, within } from "@testing-library/react";
+import { MemoryRouter } from "react-router";
+import { createTestWrapper, mockOffsetSize } from "../../test/testUtils.js";
+import { BucketLifecycleList } from "../buckets/BucketLifecycleList.js";
+const renderBucketLifecycleList = (props = {})=>{
+    const Wrapper = createTestWrapper();
+    return render(/*#__PURE__*/ jsx(MemoryRouter, {
+        children: /*#__PURE__*/ jsx(Wrapper, {
+            children: /*#__PURE__*/ jsx(BucketLifecycleList, {
+                bucketName: "test-bucket",
+                lifecycleRules: [],
+                ...props
+            })
+        })
+    }));
+};
+const mockLifecycleRules = [
+    {
+        ID: "rule-1",
+        Status: "Enabled",
+        Expiration: {
+            Days: 30
+        }
+    },
+    {
+        ID: "rule-2",
+        Status: "Disabled",
+        NoncurrentVersionExpiration: {
+            NoncurrentDays: 90
+        }
+    },
+    {
+        ID: "rule-3",
+        Status: "Enabled",
+        AbortIncompleteMultipartUpload: {
+            DaysAfterInitiation: 7
+        },
+        Expiration: {
+            Days: 365
+        },
+        NoncurrentVersionExpiration: {
+            NoncurrentDays: 30
+        }
+    }
+];
+const mockRuleWithDate = {
+    ID: "rule-with-date",
+    Status: "Enabled",
+    Expiration: {
+        Date: new Date("2025-12-31T00:00:00Z")
+    }
+};
+const mockRuleWithSingleDay = {
+    ID: "rule-single-day",
+    Status: "Enabled",
+    Expiration: {
+        Days: 1
+    }
+};
+describe("BucketLifecycleList", ()=>{
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockOffsetSize(800, 600);
+    });
+    it("shows a table with proper headers", ()=>{
+        renderBucketLifecycleList({
+            lifecycleRules: mockLifecycleRules
+        });
+        expect(screen.getByRole("grid")).toBeInTheDocument();
+        expect(screen.getByText("Rule ID")).toBeInTheDocument();
+        expect(screen.getByText("Status")).toBeInTheDocument();
+        expect(screen.getByText("Actions")).toBeInTheDocument();
+    });
+    it("displays lifecycle rules with their IDs", ()=>{
+        renderBucketLifecycleList({
+            lifecycleRules: mockLifecycleRules
+        });
+        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", ()=>{
+        renderBucketLifecycleList({
+            lifecycleRules: mockLifecycleRules
+        });
+        const activeStatuses = screen.getAllByText("Active");
+        expect(activeStatuses.length).toBe(2);
+    });
+    it("displays status as Inactive for Disabled rules", ()=>{
+        renderBucketLifecycleList({
+            lifecycleRules: mockLifecycleRules
+        });
+        expect(screen.getByText("Inactive")).toBeInTheDocument();
+    });
+    it("displays single action correctly", ()=>{
+        const singleActionRule = [
+            {
+                ID: "single-action-rule",
+                Status: "Enabled",
+                Expiration: {
+                    Days: 30
+                }
+            }
+        ];
+        renderBucketLifecycleList({
+            lifecycleRules: singleActionRule
+        });
+        expect(screen.getByText(/Expire current \(30 days\)/)).toBeInTheDocument();
+    });
+    it("displays multiple actions with +N more indicator", ()=>{
+        renderBucketLifecycleList({
+            lifecycleRules: mockLifecycleRules
+        });
+        expect(screen.getByText(/\+2/)).toBeInTheDocument();
+    });
+    it("pluralizes days correctly - singular", ()=>{
+        renderBucketLifecycleList({
+            lifecycleRules: [
+                mockRuleWithSingleDay
+            ]
+        });
+        expect(screen.getByText(/1 day/)).toBeInTheDocument();
+    });
+    it("pluralizes days correctly - plural", ()=>{
+        renderBucketLifecycleList({
+            lifecycleRules: mockLifecycleRules
+        });
+        expect(screen.getByText(/30 days/)).toBeInTheDocument();
+    });
+    it("displays Abort Incomplete MPU action", ()=>{
+        const mpuRule = [
+            {
+                ID: "mpu-rule",
+                Status: "Enabled",
+                AbortIncompleteMultipartUpload: {
+                    DaysAfterInitiation: 7
+                }
+            }
+        ];
+        renderBucketLifecycleList({
+            lifecycleRules: mpuRule
+        });
+        expect(screen.getByText(/Abort Incomplete MPU \(7 days\)/)).toBeInTheDocument();
+    });
+    it("displays dates in formatted format", ()=>{
+        renderBucketLifecycleList({
+            lifecycleRules: [
+                mockRuleWithDate
+            ]
+        });
+        const gridElement = screen.getByRole("grid");
+        expect(gridElement).toHaveTextContent("2025");
+    });
+    it("handles edit button click", ()=>{
+        const onEditRule = jest.fn();
+        renderBucketLifecycleList({
+            lifecycleRules: mockLifecycleRules,
+            onEditRule
+        });
+        const editButtons = screen.getAllByRole("button", {
+            name: /edit rule/i
+        });
+        expect(editButtons.length).toBeGreaterThanOrEqual(3);
+        fireEvent.click(editButtons[0]);
+        expect(onEditRule).toHaveBeenCalled();
+        expect(onEditRule).toHaveBeenCalledWith(expect.any(String));
+    });
+    it("renders delete buttons for each rule", ()=>{
+        renderBucketLifecycleList({
+            lifecycleRules: mockLifecycleRules
+        });
+        const deleteButtons = screen.getAllByRole("button", {
+            name: /delete rule/i
+        });
+        expect(deleteButtons.length).toBeGreaterThanOrEqual(3);
+    });
+    it("handles empty lifecycle rules list", ()=>{
+        renderBucketLifecycleList({
+            lifecycleRules: []
+        });
+        expect(screen.getByRole("grid")).toBeInTheDocument();
+        expect(screen.getByText("Rule ID")).toBeInTheDocument();
+    });
+    it("handles lifecycle rules without IDs", ()=>{
+        const rulesWithoutIds = [
+            {
+                ID: void 0,
+                Status: "Enabled"
+            },
+            {
+                Status: "Disabled"
+            }
+        ];
+        renderBucketLifecycleList({
+            lifecycleRules: rulesWithoutIds
+        });
+        const dashes = screen.getAllByText("-");
+        expect(dashes.length).toBeGreaterThan(0);
+    });
+    it("shows loading state when lifecycleStatus is loading", ()=>{
+        renderBucketLifecycleList({
+            lifecycleRules: [],
+            lifecycleStatus: "loading"
+        });
+        expect(screen.getByRole("grid")).toBeInTheDocument();
+        expect(screen.queryByText("rule-1")).not.toBeInTheDocument();
+    });
+    it("shows error state when lifecycleStatus is error", ()=>{
+        renderBucketLifecycleList({
+            lifecycleRules: [],
+            lifecycleStatus: "error"
+        });
+        expect(screen.getByRole("grid")).toBeInTheDocument();
+        expect(screen.queryByText("rule-1")).not.toBeInTheDocument();
+    });
+    it("shows data when lifecycleStatus is success", ()=>{
+        renderBucketLifecycleList({
+            lifecycleRules: mockLifecycleRules,
+            lifecycleStatus: "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", ()=>{
+        renderBucketLifecycleList({
+            lifecycleRules: mockLifecycleRules
+        });
+        expect(()=>{
+            const createButton = screen.getByRole("button", {
+                name: /create rule/i
+            });
+            fireEvent.click(createButton);
+            const editButtons = screen.getAllByLabelText("Edit rule");
+            fireEvent.click(editButtons[0]);
+            const deleteButtons = screen.getAllByLabelText("Delete rule");
+            fireEvent.click(deleteButtons[0]);
+        }).not.toThrow();
+    });
+    it("renders rows that can be selected", ()=>{
+        renderBucketLifecycleList({
+            lifecycleRules: mockLifecycleRules
+        });
+        const rows = screen.getAllByRole("row");
+        expect(rows.length).toBeGreaterThan(1);
+        const firstDataRow = rows[1];
+        expect(firstDataRow).toHaveAttribute("aria-selected");
+    });
+    it("displays noncurrent version expiration with keep versions", ()=>{
+        const ruleWithKeep = [
+            {
+                ID: "rule-with-keep",
+                Status: "Enabled",
+                NoncurrentVersionExpiration: {
+                    NoncurrentDays: 90,
+                    NewerNoncurrentVersions: 3
+                }
+            }
+        ];
+        renderBucketLifecycleList({
+            lifecycleRules: ruleWithKeep
+        });
+        expect(screen.getByText(/90 days, keep 3/)).toBeInTheDocument();
+    });
+    it("displays transition actions", ()=>{
+        const ruleWithTransition = [
+            {
+                ID: "transition-rule",
+                Status: "Enabled",
+                Transitions: [
+                    {
+                        Days: 60,
+                        StorageClass: "GLACIER"
+                    }
+                ]
+            }
+        ];
+        renderBucketLifecycleList({
+            lifecycleRules: ruleWithTransition
+        });
+        expect(screen.getByText(/Transition current \(60 days\)/)).toBeInTheDocument();
+    });
+    it("displays noncurrent version transition actions", ()=>{
+        const ruleWithNoncurrentTransition = [
+            {
+                ID: "noncurrent-transition-rule",
+                Status: "Enabled",
+                NoncurrentVersionTransitions: [
+                    {
+                        NoncurrentDays: 30,
+                        StorageClass: "GLACIER"
+                    }
+                ]
+            }
+        ];
+        renderBucketLifecycleList({
+            lifecycleRules: ruleWithNoncurrentTransition
+        });
+        expect(screen.getByText(/Transition noncurrent \(30 days\)/)).toBeInTheDocument();
+    });
+    it("displays expired object delete marker action", ()=>{
+        const ruleWithDeleteMarker = [
+            {
+                ID: "delete-marker-rule",
+                Status: "Enabled",
+                Expiration: {
+                    ExpiredObjectDeleteMarker: true
+                }
+            }
+        ];
+        renderBucketLifecycleList({
+            lifecycleRules: ruleWithDeleteMarker
+        });
+        expect(screen.getByText("Delete expired markers")).toBeInTheDocument();
+    });
+    it("shows info icon for multiple actions", ()=>{
+        renderBucketLifecycleList({
+            lifecycleRules: mockLifecycleRules
+        });
+        const rows = screen.getAllByRole("row");
+        const ruleWithMultipleActions = rows.find((row)=>within(row).queryByText(/\+2/));
+        expect(ruleWithMultipleActions).toBeInTheDocument();
+    });
+});

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

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