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

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

@@ -0,0 +1,618 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import user_event from "@testing-library/user-event";
+import { MemoryRouter, Route, Routes } from "react-router";
+import { useGetBucketLifecycle, useSetBucketLifecycle } from "../../hooks/bucketConfiguration.js";
+import { createTestWrapper, findToggleByLabel, mockErrorSubmit, mockOffsetSize, mockSuccessSubmit, submitForm } from "../../test/testUtils.js";
+import { BucketLifecycleFormPage } from "../buckets/BucketLifecycleFormPage.js";
+jest.mock('../../hooks/bucketConfiguration', ()=>({
+        useGetBucketLifecycle: jest.fn(),
+        useSetBucketLifecycle: jest.fn()
+    }));
+const mockUseGetBucketLifecycle = jest.mocked(useGetBucketLifecycle);
+const mockUseSetBucketLifecycle = jest.mocked(useSetBucketLifecycle);
+const mockNavigate = jest.fn();
+const mockShowToast = jest.fn();
+jest.mock('react-router', ()=>({
+        ...jest.requireActual('react-router'),
+        useNavigate: ()=>mockNavigate
+    }));
+jest.mock('@scality/core-ui', ()=>({
+        ...jest.requireActual('@scality/core-ui'),
+        useToast: ()=>({
+                showToast: mockShowToast
+            })
+    }));
+const renderBucketLifecycleFormPage = (bucketName = 'test-bucket', ruleId)=>{
+    const Wrapper = createTestWrapper();
+    const path = ruleId ? `/buckets/${bucketName}/lifecycle/${ruleId}/edit` : `/buckets/${bucketName}/lifecycle/create`;
+    return render(/*#__PURE__*/ jsx(MemoryRouter, {
+        initialEntries: [
+            path
+        ],
+        children: /*#__PURE__*/ jsx(Wrapper, {
+            children: /*#__PURE__*/ jsxs(Routes, {
+                children: [
+                    /*#__PURE__*/ jsx(Route, {
+                        path: "/buckets/:bucketName/lifecycle/create",
+                        element: /*#__PURE__*/ jsx(BucketLifecycleFormPage, {})
+                    }),
+                    /*#__PURE__*/ jsx(Route, {
+                        path: "/buckets/:bucketName/lifecycle/:ruleId/edit",
+                        element: /*#__PURE__*/ jsx(BucketLifecycleFormPage, {})
+                    })
+                ]
+            })
+        })
+    }));
+};
+describe('BucketLifecycleFormPage', ()=>{
+    const mockMutate = jest.fn();
+    const enableExpirationAction = async ()=>{
+        const expirationToggle = findToggleByLabel('Expiration current version');
+        await user_event.click(expirationToggle);
+    };
+    const fillRequiredFields = async (ruleId)=>{
+        await user_event.type(screen.getByLabelText(/rule id/i), ruleId);
+        await enableExpirationAction();
+    };
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockNavigate.mockClear();
+        mockShowToast.mockClear();
+        mockOffsetSize(800, 600);
+        mockUseGetBucketLifecycle.mockReturnValue({
+            data: void 0,
+            status: 'success'
+        });
+        mockUseSetBucketLifecycle.mockReturnValue({
+            mutate: mockMutate,
+            isPending: false
+        });
+    });
+    describe('Page Rendering', ()=>{
+        it('renders create mode with correct title', ()=>{
+            renderBucketLifecycleFormPage();
+            expect(screen.getByText('Create Lifecycle Rule')).toBeInTheDocument();
+        });
+        it('renders edit mode with correct title when rule exists', async ()=>{
+            const existingRule = {
+                ID: 'test-rule',
+                Status: 'Enabled',
+                Filter: {},
+                Expiration: {
+                    Days: 30
+                }
+            };
+            mockUseGetBucketLifecycle.mockReturnValue({
+                data: {
+                    Rules: [
+                        existingRule
+                    ]
+                },
+                status: 'success'
+            });
+            renderBucketLifecycleFormPage('test-bucket', 'test-rule');
+            await waitFor(()=>{
+                expect(screen.getByText('Edit Lifecycle Rule')).toBeInTheDocument();
+            });
+        });
+        it('shows loading state when fetching lifecycle data', ()=>{
+            mockUseGetBucketLifecycle.mockReturnValue({
+                data: void 0,
+                status: 'pending'
+            });
+            renderBucketLifecycleFormPage();
+            expect(screen.getByText('Loading...')).toBeInTheDocument();
+        });
+        it('shows error when rule not found in edit mode', ()=>{
+            mockUseGetBucketLifecycle.mockReturnValue({
+                data: {
+                    Rules: []
+                },
+                status: 'success'
+            });
+            renderBucketLifecycleFormPage('test-bucket', 'non-existent');
+            expect(screen.getByText('Rule not found')).toBeInTheDocument();
+        });
+    });
+    describe('Form Fields - Initial State', ()=>{
+        it('renders required form fields in create mode', ()=>{
+            renderBucketLifecycleFormPage();
+            expect(screen.getByLabelText(/rule id/i)).toBeInTheDocument();
+            expect(screen.getByLabelText(/status/i)).toBeInTheDocument();
+            expect(screen.getByLabelText(/filter/i)).toBeInTheDocument();
+        });
+        it('renders all lifecycle action toggles', ()=>{
+            renderBucketLifecycleFormPage();
+            expect(screen.getByText('Transition current version')).toBeInTheDocument();
+            expect(screen.getByText('Expiration current version')).toBeInTheDocument();
+            expect(screen.getByText('Transition noncurrent version')).toBeInTheDocument();
+            expect(screen.getByText('Expiration noncurrent version')).toBeInTheDocument();
+            expect(screen.getByText('Expire incomplete multipart upload')).toBeInTheDocument();
+        });
+        it('shows all filter type options when filter select is opened', async ()=>{
+            renderBucketLifecycleFormPage();
+            const filterSelect = screen.getByLabelText(/filter/i);
+            await user_event.click(filterSelect);
+            expect(screen.getByRole('option', {
+                name: 'All objects'
+            })).toBeInTheDocument();
+            expect(screen.getByRole('option', {
+                name: 'Prefix filter'
+            })).toBeInTheDocument();
+            expect(screen.getByRole('option', {
+                name: 'Tags filter'
+            })).toBeInTheDocument();
+            expect(screen.getByRole('option', {
+                name: 'Prefix and tags filter'
+            })).toBeInTheDocument();
+        });
+        it('disables rule ID input in edit mode', async ()=>{
+            const existingRule = {
+                ID: 'test-rule',
+                Status: 'Enabled',
+                Filter: {},
+                Expiration: {
+                    Days: 30
+                }
+            };
+            mockUseGetBucketLifecycle.mockReturnValue({
+                data: {
+                    Rules: [
+                        existingRule
+                    ]
+                },
+                status: 'success'
+            });
+            renderBucketLifecycleFormPage('test-bucket', 'test-rule');
+            await waitFor(()=>{
+                expect(screen.getByText('test-rule')).toBeInTheDocument();
+            });
+            expect(screen.queryByRole('textbox', {
+                name: /rule id/i
+            })).not.toBeInTheDocument();
+        });
+    });
+    describe('Form Validation', ()=>{
+        it('validates rule ID is required', async ()=>{
+            renderBucketLifecycleFormPage();
+            const ruleIdInput = screen.getByLabelText(/rule id/i);
+            await user_event.type(ruleIdInput, 'test');
+            await user_event.clear(ruleIdInput);
+            await user_event.tab();
+            await waitFor(()=>{
+                expect(screen.getByText(/rule id is required/i)).toBeInTheDocument();
+            });
+        });
+        it('validates rule ID uniqueness against existing rules', async ()=>{
+            mockUseGetBucketLifecycle.mockReturnValue({
+                data: {
+                    Rules: [
+                        {
+                            ID: 'existing-rule',
+                            Status: 'Enabled',
+                            Expiration: {
+                                Days: 30
+                            }
+                        }
+                    ]
+                },
+                status: 'success'
+            });
+            renderBucketLifecycleFormPage();
+            const ruleIdInput = screen.getByLabelText(/rule id/i);
+            await user_event.type(ruleIdInput, 'existing-rule');
+            await user_event.tab();
+            await waitFor(()=>{
+                expect(screen.getByText(/a rule with this id already exists/i)).toBeInTheDocument();
+            });
+        });
+        it('disables create button when form is pristine', ()=>{
+            renderBucketLifecycleFormPage();
+            const createButton = screen.getByRole('button', {
+                name: /create/i
+            });
+            expect(createButton).toBeDisabled();
+        });
+        it('disables create button when no lifecycle action is enabled', async ()=>{
+            renderBucketLifecycleFormPage();
+            await user_event.type(screen.getByLabelText(/rule id/i), 'test-rule');
+            const createButton = screen.getByRole('button', {
+                name: /create/i
+            });
+            expect(createButton).toBeDisabled();
+        });
+        it('enables create button when form is valid and has at least one action', async ()=>{
+            renderBucketLifecycleFormPage();
+            await fillRequiredFields('valid-rule');
+            await waitFor(()=>{
+                const createButton = screen.getByRole('button', {
+                    name: /create/i
+                });
+                expect(createButton).toBeEnabled();
+            });
+        });
+    });
+    describe('Form Submission - Create Mode', ()=>{
+        it('submits minimal lifecycle rule with expiration action', async ()=>{
+            renderBucketLifecycleFormPage();
+            await fillRequiredFields('minimal-rule');
+            mockSuccessSubmit(mockMutate);
+            await submitForm('create');
+            await waitFor(()=>{
+                expect(mockMutate).toHaveBeenCalledWith(expect.objectContaining({
+                    Bucket: 'test-bucket',
+                    LifecycleConfiguration: {
+                        Rules: expect.arrayContaining([
+                            expect.objectContaining({
+                                ID: 'minimal-rule',
+                                Status: 'Enabled',
+                                Filter: {},
+                                Expiration: {
+                                    Days: 30
+                                }
+                            })
+                        ])
+                    }
+                }), expect.any(Object));
+            });
+        });
+        it('navigates to bucket lifecycle tab on successful creation', async ()=>{
+            renderBucketLifecycleFormPage();
+            await fillRequiredFields('success-rule');
+            mockSuccessSubmit(mockMutate);
+            await submitForm('create');
+            await waitFor(()=>{
+                expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket?tab=lifecycle');
+            });
+        });
+        it('displays success toast after rule creation', async ()=>{
+            renderBucketLifecycleFormPage();
+            await fillRequiredFields('toast-rule');
+            mockSuccessSubmit(mockMutate);
+            await submitForm('create');
+            await waitFor(()=>{
+                expect(mockShowToast).toHaveBeenCalledWith({
+                    open: true,
+                    message: 'Lifecycle rule created successfully',
+                    status: 'success'
+                });
+            });
+        });
+        it('displays error toast when creation fails', async ()=>{
+            renderBucketLifecycleFormPage();
+            await fillRequiredFields('error-rule');
+            mockErrorSubmit(mockMutate, 'Access Denied');
+            await submitForm('create');
+            await waitFor(()=>{
+                expect(mockShowToast).toHaveBeenCalledWith({
+                    open: true,
+                    message: 'Access Denied',
+                    status: 'error'
+                });
+                expect(mockNavigate).not.toHaveBeenCalled();
+            });
+        });
+        it('appends new rule to existing rules on creation', async ()=>{
+            mockUseGetBucketLifecycle.mockReturnValue({
+                data: {
+                    Rules: [
+                        {
+                            ID: 'existing-rule',
+                            Status: 'Enabled',
+                            Filter: {},
+                            Expiration: {
+                                Days: 90
+                            }
+                        }
+                    ]
+                },
+                status: 'success'
+            });
+            renderBucketLifecycleFormPage();
+            await fillRequiredFields('new-rule');
+            mockSuccessSubmit(mockMutate);
+            await submitForm('create');
+            await waitFor(()=>{
+                const call = mockMutate.mock.calls[0][0];
+                expect(call.LifecycleConfiguration.Rules).toHaveLength(2);
+                expect(call.LifecycleConfiguration.Rules[0].ID).toBe('existing-rule');
+                expect(call.LifecycleConfiguration.Rules[1].ID).toBe('new-rule');
+            });
+        });
+    });
+    describe('Form Submission - Edit Mode', ()=>{
+        it('updates existing rule in edit mode', async ()=>{
+            const existingRule = {
+                ID: 'update-rule',
+                Status: 'Enabled',
+                Filter: {},
+                Expiration: {
+                    Days: 30
+                }
+            };
+            mockUseGetBucketLifecycle.mockReturnValue({
+                data: {
+                    Rules: [
+                        existingRule
+                    ]
+                },
+                status: 'success'
+            });
+            renderBucketLifecycleFormPage('test-bucket', 'update-rule');
+            await waitFor(()=>{
+                expect(screen.getByText('Edit Lifecycle Rule')).toBeInTheDocument();
+            });
+            const statusSelect = screen.getByLabelText(/status/i);
+            await user_event.click(statusSelect);
+            await user_event.click(screen.getByRole('option', {
+                name: 'Disabled'
+            }));
+            mockSuccessSubmit(mockMutate);
+            await submitForm('save');
+            await waitFor(()=>{
+                const call = mockMutate.mock.calls[0][0];
+                expect(call.LifecycleConfiguration.Rules).toHaveLength(1);
+                expect(call.LifecycleConfiguration.Rules[0].ID).toBe('update-rule');
+                expect(call.LifecycleConfiguration.Rules[0].Status).toBe('Disabled');
+            });
+        });
+        it('displays update success toast in edit mode', async ()=>{
+            const existingRule = {
+                ID: 'edit-rule',
+                Status: 'Enabled',
+                Filter: {},
+                Expiration: {
+                    Days: 30
+                }
+            };
+            mockUseGetBucketLifecycle.mockReturnValue({
+                data: {
+                    Rules: [
+                        existingRule
+                    ]
+                },
+                status: 'success'
+            });
+            renderBucketLifecycleFormPage('test-bucket', 'edit-rule');
+            await waitFor(()=>{
+                expect(screen.getByText('Edit Lifecycle Rule')).toBeInTheDocument();
+            });
+            const statusSelect = screen.getByLabelText(/status/i);
+            await user_event.click(statusSelect);
+            await user_event.click(screen.getByRole('option', {
+                name: 'Disabled'
+            }));
+            mockSuccessSubmit(mockMutate);
+            await submitForm('save');
+            await waitFor(()=>{
+                expect(mockShowToast).toHaveBeenCalledWith({
+                    open: true,
+                    message: 'Lifecycle rule updated successfully',
+                    status: 'success'
+                });
+            });
+        });
+        it('disables save button when form is not dirty', async ()=>{
+            const existingRule = {
+                ID: 'unchanged-rule',
+                Status: 'Enabled',
+                Filter: {},
+                Expiration: {
+                    Days: 30
+                }
+            };
+            mockUseGetBucketLifecycle.mockReturnValue({
+                data: {
+                    Rules: [
+                        existingRule
+                    ]
+                },
+                status: 'success'
+            });
+            renderBucketLifecycleFormPage('test-bucket', 'unchanged-rule');
+            await waitFor(()=>{
+                expect(screen.getByText('Edit Lifecycle Rule')).toBeInTheDocument();
+            });
+            const saveButton = screen.getByRole('button', {
+                name: /save/i
+            });
+            expect(saveButton).toBeDisabled();
+        });
+    });
+    describe('Rule Data Loading', ()=>{
+        it('loads rule with prefix filter correctly', async ()=>{
+            const rule = {
+                ID: 'prefix-rule',
+                Status: 'Enabled',
+                Filter: {
+                    Prefix: 'documents/'
+                },
+                Expiration: {
+                    Days: 90
+                }
+            };
+            mockUseGetBucketLifecycle.mockReturnValue({
+                data: {
+                    Rules: [
+                        rule
+                    ]
+                },
+                status: 'success'
+            });
+            renderBucketLifecycleFormPage('test-bucket', 'prefix-rule');
+            await waitFor(()=>{
+                const prefixInput = screen.getByLabelText(/prefix/i);
+                expect(prefixInput).toHaveValue('documents/');
+            });
+        });
+        it('loads rule with single tag filter correctly', async ()=>{
+            const rule = {
+                ID: 'tag-rule',
+                Status: 'Enabled',
+                Filter: {
+                    Tag: {
+                        Key: 'env',
+                        Value: 'prod'
+                    }
+                },
+                Expiration: {
+                    Days: 180
+                }
+            };
+            mockUseGetBucketLifecycle.mockReturnValue({
+                data: {
+                    Rules: [
+                        rule
+                    ]
+                },
+                status: 'success'
+            });
+            renderBucketLifecycleFormPage('test-bucket', 'tag-rule');
+            await waitFor(()=>{
+                expect(screen.getByDisplayValue('env')).toBeInTheDocument();
+                expect(screen.getByDisplayValue('prod')).toBeInTheDocument();
+            });
+        });
+        it('loads rule with expiration days correctly', async ()=>{
+            const rule = {
+                ID: 'expiration-rule',
+                Status: 'Enabled',
+                Filter: {},
+                Expiration: {
+                    Days: 365
+                }
+            };
+            mockUseGetBucketLifecycle.mockReturnValue({
+                data: {
+                    Rules: [
+                        rule
+                    ]
+                },
+                status: 'success'
+            });
+            renderBucketLifecycleFormPage('test-bucket', 'expiration-rule');
+            await waitFor(()=>{
+                const expirationToggle = findToggleByLabel('Expiration current version');
+                expect(expirationToggle).toBeChecked();
+                const daysInput = screen.getByLabelText(/^days$/i);
+                expect(daysInput).toHaveValue(365);
+            });
+        });
+        it('loads rule with noncurrent version expiration correctly', async ()=>{
+            const rule = {
+                ID: 'noncurrent-rule',
+                Status: 'Enabled',
+                Filter: {},
+                NoncurrentVersionExpiration: {
+                    NoncurrentDays: 90,
+                    NewerNoncurrentVersions: 3
+                }
+            };
+            mockUseGetBucketLifecycle.mockReturnValue({
+                data: {
+                    Rules: [
+                        rule
+                    ]
+                },
+                status: 'success'
+            });
+            renderBucketLifecycleFormPage('test-bucket', 'noncurrent-rule');
+            await waitFor(()=>{
+                const noncurrentExpirationToggle = findToggleByLabel('Expiration noncurrent version');
+                expect(noncurrentExpirationToggle).toBeChecked();
+                const noncurrentDaysInput = screen.getByLabelText(/noncurrent days/i);
+                expect(noncurrentDaysInput).toHaveValue(90);
+                const keepVersionsInput = screen.getByLabelText(/keep newer versions/i);
+                expect(keepVersionsInput).toHaveValue(3);
+            });
+        });
+        it('loads rule with abort incomplete multipart upload correctly', async ()=>{
+            const rule = {
+                ID: 'mpu-rule',
+                Status: 'Enabled',
+                Filter: {},
+                AbortIncompleteMultipartUpload: {
+                    DaysAfterInitiation: 7
+                }
+            };
+            mockUseGetBucketLifecycle.mockReturnValue({
+                data: {
+                    Rules: [
+                        rule
+                    ]
+                },
+                status: 'success'
+            });
+            renderBucketLifecycleFormPage('test-bucket', 'mpu-rule');
+            await waitFor(()=>{
+                const mpuToggle = findToggleByLabel('Expire incomplete multipart upload');
+                expect(mpuToggle).toBeChecked();
+                const mpuDaysInput = screen.getByLabelText(/days after initiation/i);
+                expect(mpuDaysInput).toHaveValue(7);
+            });
+        });
+        it('loads rule with transition correctly', async ()=>{
+            const rule = {
+                ID: 'transition-rule',
+                Status: 'Enabled',
+                Filter: {},
+                Transitions: [
+                    {
+                        Days: 30,
+                        StorageClass: 'GLACIER'
+                    }
+                ]
+            };
+            mockUseGetBucketLifecycle.mockReturnValue({
+                data: {
+                    Rules: [
+                        rule
+                    ]
+                },
+                status: 'success'
+            });
+            renderBucketLifecycleFormPage('test-bucket', 'transition-rule');
+            await waitFor(()=>{
+                const transitionToggle = findToggleByLabel('Transition current version');
+                expect(transitionToggle).toBeChecked();
+            });
+        });
+    });
+    describe('Navigation', ()=>{
+        it('navigates back to bucket lifecycle tab when cancel is clicked', ()=>{
+            renderBucketLifecycleFormPage();
+            const cancelButton = screen.getByRole('button', {
+                name: /cancel/i
+            });
+            fireEvent.click(cancelButton);
+            expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket?tab=lifecycle');
+        });
+        it('disables cancel button when mutation is pending', ()=>{
+            mockUseSetBucketLifecycle.mockReturnValue({
+                mutate: mockMutate,
+                isPending: true
+            });
+            renderBucketLifecycleFormPage();
+            const cancelButton = screen.getByRole('button', {
+                name: /cancel/i
+            });
+            expect(cancelButton).toBeDisabled();
+        });
+        it('disables submit button when mutation is pending', async ()=>{
+            mockUseSetBucketLifecycle.mockReturnValue({
+                mutate: mockMutate,
+                isPending: true
+            });
+            renderBucketLifecycleFormPage();
+            await fillRequiredFields('test-rule');
+            await waitFor(()=>{
+                const createButton = screen.getByRole('button', {
+                    name: /create/i
+                });
+                expect(createButton).toBeDisabled();
+            });
+        });
+    });
+});

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

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