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

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

@@ -0,0 +1,272 @@
+import { jsx } from "react/jsx-runtime";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { createTestWrapper } from "../../test/testUtils.js";
+import { DeleteBucketButton } from "../buckets/DeleteBucketButton.js";
+import { useIsBucketEmpty } from "../../hooks/useIsBucketEmpty.js";
+import { useDeleteBucket } from "../../hooks/bucketOperations.js";
+jest.mock("../../hooks/useIsBucketEmpty");
+jest.mock("../../hooks/bucketOperations");
+const mockUseIsBucketEmpty = jest.mocked(useIsBucketEmpty);
+const mockUseDeleteBucket = jest.mocked(useDeleteBucket);
+const renderDeleteBucketButton = (props = {})=>{
+    const Wrapper = createTestWrapper();
+    return render(/*#__PURE__*/ jsx(Wrapper, {
+        children: /*#__PURE__*/ jsx(DeleteBucketButton, {
+            bucketName: "test-bucket",
+            ...props
+        })
+    }));
+};
+const mockDeleteBucket = jest.fn();
+const mockHookDefaults = ()=>{
+    mockUseIsBucketEmpty.mockReturnValue({
+        isEmpty: true,
+        isLoading: false,
+        error: null
+    });
+    mockUseDeleteBucket.mockReturnValue({
+        mutate: mockDeleteBucket,
+        status: "idle"
+    });
+};
+describe("DeleteBucketButton", ()=>{
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockHookDefaults();
+    });
+    it("renders delete button with correct label", ()=>{
+        renderDeleteBucketButton();
+        expect(screen.getByRole("button", {
+            name: /delete bucket/i
+        })).toBeInTheDocument();
+    });
+    it("enables button when bucket is empty", ()=>{
+        mockUseIsBucketEmpty.mockReturnValue({
+            isEmpty: true,
+            isLoading: false,
+            error: null
+        });
+        renderDeleteBucketButton();
+        const button = screen.getByRole("button", {
+            name: /delete bucket/i
+        });
+        expect(button).not.toBeDisabled();
+    });
+    it("disables button when bucket is not empty", ()=>{
+        mockUseIsBucketEmpty.mockReturnValue({
+            isEmpty: false,
+            isLoading: false,
+            error: null
+        });
+        renderDeleteBucketButton();
+        const button = screen.getByRole("button", {
+            name: /delete bucket/i
+        });
+        expect(button).toBeDisabled();
+    });
+    it("disables button when checking if bucket is empty", ()=>{
+        mockUseIsBucketEmpty.mockReturnValue({
+            isEmpty: null,
+            isLoading: true,
+            error: null
+        });
+        renderDeleteBucketButton();
+        const button = screen.getByRole("button", {
+            name: /delete bucket/i
+        });
+        expect(button).toBeDisabled();
+    });
+    it("disables button when disabled prop is true", ()=>{
+        renderDeleteBucketButton({
+            disabled: true
+        });
+        const button = screen.getByRole("button", {
+            name: /delete bucket/i
+        });
+        expect(button).toBeDisabled();
+    });
+    it("shows tooltip when bucket is not empty", ()=>{
+        mockUseIsBucketEmpty.mockReturnValue({
+            isEmpty: false,
+            isLoading: false,
+            error: null
+        });
+        renderDeleteBucketButton();
+        expect(screen.getByRole("button", {
+            name: /delete bucket/i
+        })).toBeInTheDocument();
+    });
+    it("shows checking tooltip when loading", ()=>{
+        mockUseIsBucketEmpty.mockReturnValue({
+            isEmpty: null,
+            isLoading: true,
+            error: null
+        });
+        renderDeleteBucketButton();
+        expect(screen.getByRole("button", {
+            name: /delete bucket/i
+        })).toBeInTheDocument();
+    });
+    it("opens confirmation modal when button is clicked", ()=>{
+        renderDeleteBucketButton();
+        const button = screen.getByRole("button", {
+            name: /delete bucket/i
+        });
+        fireEvent.click(button);
+        expect(screen.getByText("Confirmation")).toBeInTheDocument();
+        expect(screen.getByText(/are you sure you want to delete bucket: test-bucket/i)).toBeInTheDocument();
+    });
+    it("shows cancel and delete buttons in modal", ()=>{
+        renderDeleteBucketButton();
+        const button = screen.getByRole("button", {
+            name: /delete bucket/i
+        });
+        fireEvent.click(button);
+        expect(screen.getByRole("button", {
+            name: /cancel/i
+        })).toBeInTheDocument();
+        expect(screen.getByRole("button", {
+            name: /^delete$/i
+        })).toBeInTheDocument();
+    });
+    it("closes modal when cancel is clicked", ()=>{
+        renderDeleteBucketButton();
+        const deleteButton = screen.getByRole("button", {
+            name: /delete bucket/i
+        });
+        fireEvent.click(deleteButton);
+        const cancelButton = screen.getByRole("button", {
+            name: /cancel/i
+        });
+        fireEvent.click(cancelButton);
+        expect(screen.queryByText("Confirmation")).not.toBeInTheDocument();
+    });
+    it("calls delete mutation when delete is confirmed", ()=>{
+        renderDeleteBucketButton();
+        const deleteButton = screen.getByRole("button", {
+            name: /delete bucket/i
+        });
+        fireEvent.click(deleteButton);
+        const confirmButton = screen.getByRole("button", {
+            name: /^delete$/i
+        });
+        fireEvent.click(confirmButton);
+        expect(mockDeleteBucket).toHaveBeenCalledWith({
+            Bucket: "test-bucket"
+        }, expect.objectContaining({
+            onSuccess: expect.any(Function),
+            onError: expect.any(Function)
+        }));
+    });
+    it("calls onDeleteSuccess callback when delete succeeds", ()=>{
+        const onDeleteSuccess = jest.fn();
+        renderDeleteBucketButton({
+            onDeleteSuccess
+        });
+        const deleteButton = screen.getByRole("button", {
+            name: /delete bucket/i
+        });
+        fireEvent.click(deleteButton);
+        const confirmButton = screen.getByRole("button", {
+            name: /^delete$/i
+        });
+        fireEvent.click(confirmButton);
+        const successCallback = mockDeleteBucket.mock.calls[0][1].onSuccess;
+        successCallback();
+        expect(onDeleteSuccess).toHaveBeenCalledWith("test-bucket");
+    });
+    it("calls onDeleteError callback when delete fails", ()=>{
+        const onDeleteError = jest.fn();
+        const testError = new Error("Delete failed");
+        renderDeleteBucketButton({
+            onDeleteError
+        });
+        const deleteButton = screen.getByRole("button", {
+            name: /delete bucket/i
+        });
+        fireEvent.click(deleteButton);
+        const confirmButton = screen.getByRole("button", {
+            name: /^delete$/i
+        });
+        fireEvent.click(confirmButton);
+        const errorCallback = mockDeleteBucket.mock.calls[0][1].onError;
+        errorCallback(testError);
+        expect(onDeleteError).toHaveBeenCalledWith(testError);
+    });
+    it("handles non-Error objects in onError callback", ()=>{
+        const onDeleteError = jest.fn();
+        renderDeleteBucketButton({
+            onDeleteError
+        });
+        const deleteButton = screen.getByRole("button", {
+            name: /delete bucket/i
+        });
+        fireEvent.click(deleteButton);
+        const confirmButton = screen.getByRole("button", {
+            name: /^delete$/i
+        });
+        fireEvent.click(confirmButton);
+        const errorCallback = mockDeleteBucket.mock.calls[0][1].onError;
+        errorCallback("string error");
+        expect(onDeleteError).toHaveBeenCalledWith(new Error("Delete failed"));
+    });
+    it("closes modal when delete succeeds", async ()=>{
+        renderDeleteBucketButton();
+        const deleteButton = screen.getByRole("button", {
+            name: /delete bucket/i
+        });
+        fireEvent.click(deleteButton);
+        expect(screen.getByText("Confirmation")).toBeInTheDocument();
+        const confirmButton = screen.getByRole("button", {
+            name: /^delete$/i
+        });
+        fireEvent.click(confirmButton);
+        const successCallback = mockDeleteBucket.mock.calls[0][1].onSuccess;
+        successCallback();
+        await waitFor(()=>{
+            expect(screen.queryByText("Confirmation")).not.toBeInTheDocument();
+        });
+    });
+    it("shows loading state in delete button when deletion is pending", ()=>{
+        mockUseDeleteBucket.mockReturnValue({
+            mutate: mockDeleteBucket,
+            status: "pending"
+        });
+        renderDeleteBucketButton();
+        const deleteButton = screen.getByRole("button", {
+            name: /delete bucket/i
+        });
+        fireEvent.click(deleteButton);
+        const confirmButton = screen.getByRole("button", {
+            name: /^delete$/i
+        });
+        expect(confirmButton).toBeDisabled();
+    });
+    it("works without optional callbacks", ()=>{
+        expect(()=>{
+            renderDeleteBucketButton();
+            const deleteButton = screen.getByRole("button", {
+                name: /delete bucket/i
+            });
+            fireEvent.click(deleteButton);
+            const confirmButton = screen.getByRole("button", {
+                name: /^delete$/i
+            });
+            fireEvent.click(confirmButton);
+            const successCallback = mockDeleteBucket.mock.calls[0][1].onSuccess;
+            const errorCallback = mockDeleteBucket.mock.calls[0][1].onError;
+            successCallback();
+            errorCallback(new Error("test"));
+        }).not.toThrow();
+    });
+    it("displays correct bucket name in confirmation message", ()=>{
+        renderDeleteBucketButton({
+            bucketName: "my-special-bucket"
+        });
+        const deleteButton = screen.getByRole("button", {
+            name: /delete bucket/i
+        });
+        fireEvent.click(deleteButton);
+        expect(screen.getByText(/are you sure you want to delete bucket: my-special-bucket/i)).toBeInTheDocument();
+    });
+});

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

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

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

@@ -0,0 +1,196 @@
+import { jsx } from "react/jsx-runtime";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { MemoryRouter } from "react-router-dom";
+import { createTestWrapper } from "../../test/testUtils.js";
+import { DeleteBucketConfigRuleButton } from "../buckets/DeleteBucketConfigRuleButton.js";
+const mockLifecycleRules = [
+    {
+        ID: "rule-1",
+        Status: "Enabled",
+        Expiration: {
+            Days: 30
+        }
+    },
+    {
+        ID: "rule-2",
+        Status: "Disabled",
+        NoncurrentVersionExpiration: {
+            NoncurrentDays: 90
+        }
+    }
+];
+describe("DeleteBucketConfigRuleButton", ()=>{
+    let mockUpdate;
+    let mockDelete;
+    const renderButton = (props = {})=>{
+        const defaultProps = {
+            bucketName: "test-bucket",
+            ruleId: "rule-1",
+            rules: mockLifecycleRules,
+            ruleType: "lifecycle",
+            updateMutation: {
+                mutate: mockUpdate,
+                status: "idle"
+            },
+            deleteMutation: {
+                mutate: mockDelete,
+                status: "idle"
+            },
+            buildUpdateInput: (remainingRules)=>({
+                    LifecycleConfiguration: {
+                        Rules: remainingRules
+                    }
+                }),
+            invalidationKeys: [
+                "GetBucketLifecycle"
+            ],
+            successMessage: "Rule deleted successfully",
+            errorMessage: "Failed to delete rule"
+        };
+        const Wrapper = createTestWrapper();
+        return render(/*#__PURE__*/ jsx(MemoryRouter, {
+            children: /*#__PURE__*/ jsx(Wrapper, {
+                children: /*#__PURE__*/ jsx(DeleteBucketConfigRuleButton, {
+                    ...defaultProps,
+                    ...props
+                })
+            })
+        }));
+    };
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockUpdate = jest.fn();
+        mockDelete = jest.fn();
+    });
+    it("renders delete button", ()=>{
+        renderButton();
+        const deleteButton = screen.getByRole("button", {
+            name: /delete rule/i
+        });
+        expect(deleteButton).toBeInTheDocument();
+    });
+    it("opens confirmation modal when clicked", ()=>{
+        renderButton();
+        const deleteButton = screen.getByRole("button", {
+            name: /delete rule/i
+        });
+        fireEvent.click(deleteButton);
+        expect(screen.getByText(/are you sure you want to delete the lifecycle rule/i)).toBeInTheDocument();
+        expect(screen.getByText(/rule-1/)).toBeInTheDocument();
+    });
+    it("closes modal when cancel is clicked", ()=>{
+        renderButton();
+        fireEvent.click(screen.getByRole("button", {
+            name: /delete rule/i
+        }));
+        expect(screen.getByText(/are you sure/i)).toBeInTheDocument();
+        fireEvent.click(screen.getByRole("button", {
+            name: /cancel/i
+        }));
+        expect(screen.queryByText(/are you sure/i)).not.toBeInTheDocument();
+    });
+    it("calls update when deleting a rule with remaining rules", async ()=>{
+        renderButton();
+        fireEvent.click(screen.getByRole("button", {
+            name: /delete rule/i
+        }));
+        fireEvent.click(screen.getByRole("button", {
+            name: /^delete$/i
+        }));
+        await waitFor(()=>{
+            expect(mockUpdate).toHaveBeenCalled();
+            const callArgs = mockUpdate.mock.calls[0][0];
+            expect(callArgs.Bucket).toBe("test-bucket");
+            expect(callArgs.LifecycleConfiguration.Rules).toHaveLength(1);
+            expect(callArgs.LifecycleConfiguration.Rules[0].ID).toBe("rule-2");
+        });
+    });
+    it("calls delete when deleting the last rule", async ()=>{
+        renderButton({
+            rules: [
+                mockLifecycleRules[0]
+            ]
+        });
+        fireEvent.click(screen.getByRole("button", {
+            name: /delete rule/i
+        }));
+        fireEvent.click(screen.getByRole("button", {
+            name: /^delete$/i
+        }));
+        await waitFor(()=>{
+            expect(mockDelete).toHaveBeenCalledWith({
+                Bucket: "test-bucket"
+            }, expect.any(Object));
+        });
+    });
+    it("closes modal after successful deletion", async ()=>{
+        mockUpdate.mockImplementation((_, options)=>{
+            options.onSuccess();
+        });
+        renderButton();
+        fireEvent.click(screen.getByRole("button", {
+            name: /delete rule/i
+        }));
+        fireEvent.click(screen.getByRole("button", {
+            name: /^delete$/i
+        }));
+        await waitFor(()=>{
+            expect(screen.queryByText(/are you sure/i)).not.toBeInTheDocument();
+        });
+    });
+    it("closes modal after failed deletion", async ()=>{
+        const consoleError = jest.spyOn(console, "error").mockImplementation(()=>{});
+        mockUpdate.mockImplementation((_, options)=>{
+            options.onError(new Error("Delete failed"));
+        });
+        renderButton();
+        fireEvent.click(screen.getByRole("button", {
+            name: /delete rule/i
+        }));
+        fireEvent.click(screen.getByRole("button", {
+            name: /^delete$/i
+        }));
+        await waitFor(()=>{
+            expect(mockUpdate).toHaveBeenCalled();
+        });
+        await waitFor(()=>{
+            expect(screen.queryByText(/are you sure/i)).not.toBeInTheDocument();
+        });
+        consoleError.mockRestore();
+    });
+    it("disables buttons while deletion is in progress", ()=>{
+        renderButton({
+            updateMutation: {
+                mutate: mockUpdate,
+                status: "pending"
+            }
+        });
+        fireEvent.click(screen.getByRole("button", {
+            name: /delete rule/i
+        }));
+        const cancelButton = screen.getByRole("button", {
+            name: /cancel/i
+        });
+        const confirmButton = screen.getByRole("button", {
+            name: /^delete$/i
+        });
+        expect(cancelButton).toBeDisabled();
+        expect(confirmButton).toBeDisabled();
+    });
+    it("stops event propagation when delete button is clicked", ()=>{
+        renderButton();
+        const deleteButton = screen.getByRole("button", {
+            name: /delete rule/i
+        });
+        const mockStopPropagation = jest.fn();
+        const clickEvent = new MouseEvent("click", {
+            bubbles: true
+        });
+        Object.defineProperty(clickEvent, "stopPropagation", {
+            value: mockStopPropagation,
+            writable: true
+        });
+        deleteButton.dispatchEvent(clickEvent);
+        expect(mockStopPropagation).toHaveBeenCalled();
+    });
+});

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

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