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

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();
+    });
+});