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

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-dom";
+import { createTestWrapper, findToggleByLabel, mockErrorSubmit, mockOffsetSize, mockSuccessSubmit, submitForm } from "../../test/testUtils.js";
+import { BucketLifecycleFormPage } from "../buckets/BucketLifecycleFormPage.js";
+import { useGetBucketLifecycle, useSetBucketLifecycle } from "../../hooks/bucketConfiguration.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-dom", ()=>({
+        ...jest.requireActual("react-router-dom"),
+        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 {};