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

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.js

@@ -222,4 +222,194 @@ describe("BucketList", ()=>{
         fireEvent.click(bucketName.closest('[role="row"]') || bucketName);
         expect(onBucketSelect).not.toHaveBeenCalled();
     });
+    describe("additionalColumns support", ()=>{
+        it("renders additional columns when additionalColumns prop is provided", ()=>{
+            const additionalColumns = [
+                {
+                    Header: "Metrics",
+                    accessor: "metrics",
+                    id: "metrics",
+                    Cell: ()=>/*#__PURE__*/ jsx("span", {
+                            children: "Metrics Data"
+                        })
+                }
+            ];
+            renderBucketList({
+                buckets: mockBuckets,
+                additionalColumns
+            });
+            expect(screen.getByText("Metrics")).toBeInTheDocument();
+            expect(screen.getAllByText("Metrics Data")).toHaveLength(3);
+        });
+        it("renders multiple additional columns in correct order", ()=>{
+            const additionalColumns = [
+                {
+                    Header: "Column A",
+                    accessor: "columnA",
+                    id: "columnA",
+                    Cell: ()=>/*#__PURE__*/ jsx("span", {
+                            children: "A"
+                        })
+                },
+                {
+                    Header: "Column B",
+                    accessor: "columnB",
+                    id: "columnB",
+                    Cell: ()=>/*#__PURE__*/ jsx("span", {
+                            children: "B"
+                        })
+                }
+            ];
+            renderBucketList({
+                buckets: mockBuckets,
+                additionalColumns
+            });
+            const headers = screen.getAllByRole("columnheader");
+            const headerTexts = headers.map((h)=>h.textContent);
+            expect(headerTexts).toContain("Bucket Name");
+            expect(headerTexts).toContain("Storage Location");
+            expect(headerTexts).toContain("Column A");
+            expect(headerTexts).toContain("Column B");
+            expect(headerTexts).toContain("Created on");
+            const bucketNameIndex = headerTexts.indexOf("Bucket Name");
+            const storageLocationIndex = headerTexts.indexOf("Storage Location");
+            const columnAIndex = headerTexts.indexOf("Column A");
+            const columnBIndex = headerTexts.indexOf("Column B");
+            const createdOnIndex = headerTexts.indexOf("Created on");
+            expect(bucketNameIndex).toBeLessThan(storageLocationIndex);
+            expect(storageLocationIndex).toBeLessThan(columnAIndex);
+            expect(columnAIndex).toBeLessThan(columnBIndex);
+            expect(columnBIndex).toBeLessThan(createdOnIndex);
+        });
+        it("works without additional columns (backward compatibility)", ()=>{
+            renderBucketList({
+                buckets: mockBuckets
+            });
+            const headers = screen.getAllByRole("columnheader");
+            const headerTexts = headers.map((h)=>h.textContent);
+            expect(headerTexts).toContain("Bucket Name");
+            expect(headerTexts).toContain("Storage Location");
+            expect(headerTexts).toContain("Created on");
+            expect(headerTexts).toHaveLength(3);
+        });
+    });
+    describe("transformBucketData support", ()=>{
+        it("transforms bucket data when transformBucketData is provided", ()=>{
+            const transformBucketData = jest.fn((bucket)=>({
+                    ...bucket,
+                    metrics: {
+                        value: 100
+                    }
+                }));
+            const additionalColumns = [
+                {
+                    Header: "Metrics",
+                    accessor: "metrics",
+                    id: "metrics",
+                    Cell: ({ value })=>/*#__PURE__*/ jsxs("span", {
+                            children: [
+                                "Value: ",
+                                value.value
+                            ]
+                        })
+                }
+            ];
+            renderBucketList({
+                buckets: mockBuckets,
+                additionalColumns,
+                transformBucketData
+            });
+            expect(transformBucketData).toHaveBeenCalledTimes(3);
+            expect(transformBucketData).toHaveBeenCalledWith(mockBuckets[0]);
+            expect(transformBucketData).toHaveBeenCalledWith(mockBuckets[1]);
+            expect(transformBucketData).toHaveBeenCalledWith(mockBuckets[2]);
+        });
+        it("renders transformed data in additional columns", ()=>{
+            const transformBucketData = (bucket)=>({
+                    ...bucket,
+                    metrics: {
+                        value: "test-bucket-1" === bucket.Name ? 50 : 100
+                    }
+                });
+            const additionalColumns = [
+                {
+                    Header: "Metrics",
+                    accessor: "metrics",
+                    id: "metrics",
+                    Cell: ({ value })=>/*#__PURE__*/ jsxs("span", {
+                            children: [
+                                "Metric: ",
+                                value.value
+                            ]
+                        })
+                }
+            ];
+            renderBucketList({
+                buckets: mockBuckets,
+                additionalColumns,
+                transformBucketData
+            });
+            expect(screen.getByText("Metric: 50")).toBeInTheDocument();
+            expect(screen.getAllByText("Metric: 100")).toHaveLength(2);
+        });
+        it("works without transformBucketData (uses default behavior)", ()=>{
+            const additionalColumns = [
+                {
+                    Header: "Test Column",
+                    accessor: "Name",
+                    id: "testColumn",
+                    Cell: ({ value })=>/*#__PURE__*/ jsxs("span", {
+                            children: [
+                                "Name: ",
+                                value
+                            ]
+                        })
+                }
+            ];
+            renderBucketList({
+                buckets: mockBuckets,
+                additionalColumns
+            });
+            expect(screen.getByText("Name: test-bucket-1")).toBeInTheDocument();
+            expect(screen.getByText("Name: test-bucket-2")).toBeInTheDocument();
+            expect(screen.getByText("Name: test-bucket-3")).toBeInTheDocument();
+        });
+    });
+    describe("generic type support", ()=>{
+        it("maintains type safety with extended bucket types", ()=>{
+            const transformBucketData = (bucket)=>({
+                    ...bucket,
+                    customField: `Custom ${bucket.Name}`,
+                    numericField: 42
+                });
+            const additionalColumns = [
+                {
+                    Header: "Custom",
+                    accessor: "customField",
+                    id: "custom",
+                    Cell: ({ value })=>/*#__PURE__*/ jsx("span", {
+                            children: value
+                        })
+                },
+                {
+                    Header: "Number",
+                    accessor: "numericField",
+                    id: "numeric",
+                    Cell: ({ value })=>/*#__PURE__*/ jsxs("span", {
+                            children: [
+                                "Num: ",
+                                value
+                            ]
+                        })
+                }
+            ];
+            renderBucketList({
+                buckets: mockBuckets,
+                additionalColumns,
+                transformBucketData
+            });
+            expect(screen.getByText("Custom test-bucket-1")).toBeInTheDocument();
+            expect(screen.getAllByText("Num: 42")).toHaveLength(3);
+        });
+    });
 });