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

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

@@ -0,0 +1,302 @@
+import { jsx } from "react/jsx-runtime";
+import { act, fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { createTestWrapper } from "../../test/testUtils.js";
+import { DeleteObjectButton } from "../objects/DeleteObjectButton.js";
+import { useDeleteObjects, useGetBucketVersioning } from "../../hooks/index.js";
+jest.mock("../../hooks");
+const mockUseDeleteObjects = jest.mocked(useDeleteObjects);
+const mockUseGetBucketVersioning = jest.mocked(useGetBucketVersioning);
+const mockDeleteObjects = jest.fn();
+const createMockObjects = (count, withVersions = false)=>Array.from({
+        length: count
+    }, (_, i)=>({
+            Key: `file${i + 1}.txt`,
+            displayName: `file${i + 1}.txt`,
+            Size: 1024 * (i + 1),
+            LastModified: new Date(`2023-01-${i + 1}T10:00:00Z`),
+            type: "object",
+            ...withVersions && {
+                VersionId: `version-${i + 1}`
+            }
+        }));
+const createMockFolders = (count)=>Array.from({
+        length: count
+    }, (_, i)=>({
+            Key: `folder${i + 1}/`,
+            displayName: `folder${i + 1}/`,
+            type: "folder",
+            LastModified: void 0
+        }));
+const renderDeleteObjectButton = (props = {})=>{
+    const defaultProps = {
+        objects: createMockObjects(2),
+        bucketName: "test-bucket",
+        ...props
+    };
+    const Wrapper = createTestWrapper();
+    return render(/*#__PURE__*/ jsx(Wrapper, {
+        children: /*#__PURE__*/ jsx(DeleteObjectButton, {
+            ...defaultProps
+        })
+    }));
+};
+const mockHookDefaults = (versioningEnabled = false)=>{
+    mockUseGetBucketVersioning.mockReturnValue({
+        data: {
+            Status: versioningEnabled ? "Enabled" : "Suspended"
+        },
+        isLoading: false,
+        error: null
+    });
+    mockUseDeleteObjects.mockReturnValue({
+        mutate: mockDeleteObjects,
+        isPending: false
+    });
+};
+describe("DeleteObjectButton", ()=>{
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockHookDefaults();
+    });
+    it("renders delete button with correct label and icon", ()=>{
+        renderDeleteObjectButton();
+        const button = screen.getByRole("button", {
+            name: /delete/i
+        });
+        expect(button).toBeInTheDocument();
+        expect(button).toHaveAttribute("id", "object-list-delete-button");
+    });
+    it("disables button when no objects are selected", ()=>{
+        renderDeleteObjectButton({
+            objects: []
+        });
+        const button = screen.getByRole("button", {
+            name: /delete/i
+        });
+        expect(button).toBeDisabled();
+    });
+    it("enables button when objects are selected", ()=>{
+        renderDeleteObjectButton();
+        const button = screen.getByRole("button", {
+            name: /delete/i
+        });
+        expect(button).not.toBeDisabled();
+    });
+    it("opens confirmation modal when delete button is clicked", ()=>{
+        renderDeleteObjectButton();
+        const button = screen.getByRole("button", {
+            name: /delete/i
+        });
+        fireEvent.click(button);
+        expect(screen.getByText("Confirmation")).toBeInTheDocument();
+        expect(screen.getByText(/do you want to.*delete/i)).toBeInTheDocument();
+    });
+    it("shows correct confirmation message for objects without versioning", ()=>{
+        renderDeleteObjectButton({
+            objects: createMockObjects(2)
+        });
+        const button = screen.getByRole("button", {
+            name: /delete/i
+        });
+        fireEvent.click(button);
+        expect(screen.getByText((content, _)=>content.includes("2") && content.includes("object"))).toBeInTheDocument();
+    });
+    it("shows correct confirmation message for mixed objects and folders", ()=>{
+        const mixedObjects = [
+            ...createMockObjects(1),
+            ...createMockFolders(1)
+        ];
+        renderDeleteObjectButton({
+            objects: mixedObjects
+        });
+        const button = screen.getByRole("button", {
+            name: /delete/i
+        });
+        fireEvent.click(button);
+        expect(screen.getByText(/do you want to/i)).toBeInTheDocument();
+        expect(screen.getByText(/delete the selected/i)).toBeInTheDocument();
+    });
+    it("shows permanently delete message for versioned objects with specific versions", ()=>{
+        mockHookDefaults(true);
+        renderDeleteObjectButton({
+            objects: createMockObjects(2, true)
+        });
+        const button = screen.getByRole("button", {
+            name: /delete/i
+        });
+        fireEvent.click(button);
+        expect(screen.getByText("The selected versions will be permanently deleted.")).toBeInTheDocument();
+        expect(screen.getByText(/do you want to/i)).toBeInTheDocument();
+        expect(screen.getByText(/object versions/i)).toBeInTheDocument();
+    });
+    it("displays total size of selected objects", ()=>{
+        const objects = createMockObjects(2);
+        renderDeleteObjectButton({
+            objects
+        });
+        const button = screen.getByRole("button", {
+            name: /delete/i
+        });
+        fireEvent.click(button);
+        expect(screen.getByText(/total.*3.*kb/i)).toBeInTheDocument();
+    });
+    it("shows info banner with deletion message", ()=>{
+        renderDeleteObjectButton();
+        const button = screen.getByRole("button", {
+            name: /delete/i
+        });
+        fireEvent.click(button);
+        expect(screen.getByText(/the selected objects will be permanently deleted/i)).toBeInTheDocument();
+    });
+    it("shows different info message for versioned buckets without specific versions", ()=>{
+        mockHookDefaults(true);
+        renderDeleteObjectButton({
+            objects: createMockObjects(2, false)
+        });
+        const button = screen.getByRole("button", {
+            name: /delete/i
+        });
+        fireEvent.click(button);
+        expect(screen.getByText(/delete markers will be added to the objects/i)).toBeInTheDocument();
+    });
+    it("closes modal when cancel button is clicked", ()=>{
+        renderDeleteObjectButton();
+        const deleteButton = screen.getByRole("button", {
+            name: /delete/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 with correct parameters when deletion is confirmed", ()=>{
+        const objects = createMockObjects(2);
+        renderDeleteObjectButton({
+            objects,
+            bucketName: "my-bucket"
+        });
+        const deleteButton = screen.getByRole("button", {
+            name: /delete/i
+        });
+        fireEvent.click(deleteButton);
+        const confirmButton = document.getElementById("object-delete-delete-button");
+        expect(confirmButton).toBeInTheDocument();
+        fireEvent.click(confirmButton);
+        expect(mockDeleteObjects).toHaveBeenCalledWith({
+            Bucket: "my-bucket",
+            Delete: {
+                Objects: [
+                    {
+                        Key: "file1.txt"
+                    },
+                    {
+                        Key: "file2.txt"
+                    }
+                ]
+            }
+        }, expect.objectContaining({
+            onSuccess: expect.any(Function),
+            onError: expect.any(Function)
+        }));
+    });
+    it("includes version IDs in delete request when objects have versions", ()=>{
+        const objects = createMockObjects(1, true);
+        renderDeleteObjectButton({
+            objects
+        });
+        const deleteButton = screen.getByRole("button", {
+            name: /delete/i
+        });
+        fireEvent.click(deleteButton);
+        const confirmButton = document.getElementById("object-delete-delete-button");
+        fireEvent.click(confirmButton);
+        expect(mockDeleteObjects).toHaveBeenCalledWith(expect.objectContaining({
+            Delete: {
+                Objects: [
+                    {
+                        Key: "file1.txt",
+                        VersionId: "version-1"
+                    }
+                ]
+            }
+        }), expect.any(Object));
+    });
+    it("handles mixed objects and folders in delete request", ()=>{
+        const mixedObjects = [
+            ...createMockObjects(1),
+            ...createMockFolders(1)
+        ];
+        renderDeleteObjectButton({
+            objects: mixedObjects
+        });
+        const deleteButton = screen.getByRole("button", {
+            name: /delete/i
+        });
+        fireEvent.click(deleteButton);
+        const confirmButton = document.getElementById("object-delete-delete-button");
+        fireEvent.click(confirmButton);
+        expect(mockDeleteObjects).toHaveBeenCalledWith(expect.objectContaining({
+            Delete: {
+                Objects: [
+                    {
+                        Key: "file1.txt"
+                    },
+                    {
+                        Key: "folder1/"
+                    }
+                ]
+            }
+        }), expect.any(Object));
+    });
+    it("shows success toast and closes modal when deletion succeeds", async ()=>{
+        renderDeleteObjectButton();
+        const deleteButton = screen.getByRole("button", {
+            name: /delete/i
+        });
+        fireEvent.click(deleteButton);
+        expect(screen.getByText("Confirmation")).toBeInTheDocument();
+        const confirmButton = document.getElementById("object-delete-delete-button");
+        fireEvent.click(confirmButton);
+        await act(async ()=>{
+            const successCallback = mockDeleteObjects.mock.calls[0][1].onSuccess;
+            successCallback();
+        });
+        await waitFor(()=>{
+            expect(screen.queryByText("Confirmation")).not.toBeInTheDocument();
+        });
+    });
+    it("handles non-Error objects in error callback", async ()=>{
+        renderDeleteObjectButton();
+        const deleteButton = screen.getByRole("button", {
+            name: /delete/i
+        });
+        fireEvent.click(deleteButton);
+        const confirmButton = document.getElementById("object-delete-delete-button");
+        fireEvent.click(confirmButton);
+        await act(async ()=>{
+            const errorCallback = mockDeleteObjects.mock.calls[0][1].onError;
+            errorCallback("string error");
+        });
+        expect(mockDeleteObjects.mock.calls[0][1].onError).toBeDefined();
+    });
+    it("updates objects when props change", ()=>{
+        const { rerender } = renderDeleteObjectButton({
+            objects: createMockObjects(1)
+        });
+        expect(screen.getByRole("button", {
+            name: /delete/i
+        })).not.toBeDisabled();
+        const Wrapper = createTestWrapper();
+        rerender(/*#__PURE__*/ jsx(Wrapper, {
+            children: /*#__PURE__*/ jsx(DeleteObjectButton, {
+                objects: [],
+                bucketName: "test-bucket"
+            })
+        }));
+        expect(screen.getByRole("button", {
+            name: /delete/i
+        })).toBeDisabled();
+    });
+});

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

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

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

@@ -0,0 +1,302 @@
+import { jsx } from "react/jsx-runtime";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { createTestWrapper } from "../../test/testUtils.js";
+import { EmptyBucketButton } from "../buckets/EmptyBucketButton.js";
+import { useIsBucketEmpty } from "../../hooks/useIsBucketEmpty.js";
+import { useEmptyBucket } from "../../hooks/useEmptyBucket.js";
+import { useGetBucketObjectLockConfiguration } from "../../hooks/bucketConfiguration.js";
+jest.mock("../../hooks/useIsBucketEmpty");
+jest.mock("../../hooks/useEmptyBucket");
+jest.mock("../../hooks/bucketConfiguration");
+const mockUseIsBucketEmpty = jest.mocked(useIsBucketEmpty);
+const mockUseEmptyBucket = jest.mocked(useEmptyBucket);
+const mockUseGetBucketObjectLockConfiguration = jest.mocked(useGetBucketObjectLockConfiguration);
+const renderEmptyBucketButton = (props = {})=>{
+    const Wrapper = createTestWrapper();
+    return render(/*#__PURE__*/ jsx(Wrapper, {
+        children: /*#__PURE__*/ jsx(EmptyBucketButton, {
+            bucketName: "test-bucket",
+            ...props
+        })
+    }));
+};
+const mockHookDefaults = ()=>{
+    mockUseIsBucketEmpty.mockReturnValue({
+        isEmpty: false,
+        isLoading: false,
+        error: null
+    });
+    mockUseEmptyBucket.mockReturnValue({
+        emptyBucket: jest.fn(),
+        isEmptying: false,
+        error: null,
+        result: null,
+        reset: jest.fn()
+    });
+    mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+        data: void 0,
+        isLoading: false,
+        error: null
+    });
+};
+describe("EmptyBucketButton", ()=>{
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockHookDefaults();
+    });
+    it("renders empty button with correct label", ()=>{
+        renderEmptyBucketButton();
+        expect(screen.getByRole("button", {
+            name: /empty bucket/i
+        })).toBeInTheDocument();
+    });
+    it("disables button when bucket is empty", ()=>{
+        mockUseIsBucketEmpty.mockReturnValue({
+            isEmpty: true,
+            isLoading: false,
+            error: null
+        });
+        renderEmptyBucketButton();
+        const button = screen.getByRole("button", {
+            name: /empty bucket/i
+        });
+        expect(button).toBeDisabled();
+    });
+    it("enables button when bucket is not empty", ()=>{
+        mockUseIsBucketEmpty.mockReturnValue({
+            isEmpty: false,
+            isLoading: false,
+            error: null
+        });
+        renderEmptyBucketButton();
+        const button = screen.getByRole("button", {
+            name: /empty bucket/i
+        });
+        expect(button).not.toBeDisabled();
+    });
+    it("opens confirmation modal when button is clicked", ()=>{
+        renderEmptyBucketButton();
+        const button = screen.getByRole("button", {
+            name: /empty bucket/i
+        });
+        fireEvent.click(button);
+        expect(screen.getByText(/Empty Bucket 'test-bucket'\?/i)).toBeInTheDocument();
+        expect(screen.getByText(/Emptying a bucket removes all contents and cannot be reversed/i)).toBeInTheDocument();
+    });
+    it("shows information list in modal", ()=>{
+        renderEmptyBucketButton();
+        const button = screen.getByRole("button", {
+            name: /empty bucket/i
+        });
+        fireEvent.click(button);
+        expect(screen.getByText(/Emptying a bucket removes all contents and cannot be reversed/i)).toBeInTheDocument();
+        expect(screen.getByText(/New objects added during the empty action may also be removed/i)).toBeInTheDocument();
+    });
+    it("shows confirmation input field", ()=>{
+        renderEmptyBucketButton();
+        const button = screen.getByRole("button", {
+            name: /empty bucket/i
+        });
+        fireEvent.click(button);
+        const input = screen.getByPlaceholderText(/test-bucket/i);
+        expect(input).toBeInTheDocument();
+    });
+    it("disables empty button until bucket name is typed", ()=>{
+        renderEmptyBucketButton();
+        const button = screen.getByRole("button", {
+            name: /empty bucket/i
+        });
+        fireEvent.click(button);
+        const emptyButton = screen.getByRole("button", {
+            name: /^empty$/i
+        });
+        expect(emptyButton).toBeDisabled();
+        const input = screen.getByPlaceholderText(/test-bucket/i);
+        fireEvent.change(input, {
+            target: {
+                value: "test-bucket"
+            }
+        });
+        expect(emptyButton).not.toBeDisabled();
+    });
+    it("closes modal when cancel is clicked", ()=>{
+        renderEmptyBucketButton();
+        const deleteButton = screen.getByRole("button", {
+            name: /empty bucket/i
+        });
+        fireEvent.click(deleteButton);
+        const cancelButton = screen.getByRole("button", {
+            name: /cancel/i
+        });
+        fireEvent.click(cancelButton);
+        expect(screen.queryByText(/Empty Bucket 'test-bucket'\?/i)).not.toBeInTheDocument();
+    });
+    it("resets state when modal is cancelled", ()=>{
+        renderEmptyBucketButton();
+        const button = screen.getByRole("button", {
+            name: /empty bucket/i
+        });
+        fireEvent.click(button);
+        const input = screen.getByPlaceholderText(/test-bucket/i);
+        fireEvent.change(input, {
+            target: {
+                value: "test-bucket"
+            }
+        });
+        expect(input).toHaveValue("test-bucket");
+        const cancelButton = screen.getByRole("button", {
+            name: /cancel/i
+        });
+        fireEvent.click(cancelButton);
+        fireEvent.click(button);
+        const inputAfterReopen = screen.getByPlaceholderText(/test-bucket/i);
+        expect(inputAfterReopen).toHaveValue("");
+    });
+    it("displays correct bucket name in modal title", ()=>{
+        renderEmptyBucketButton({
+            bucketName: "my-special-bucket"
+        });
+        const button = screen.getByRole("button", {
+            name: /empty bucket/i
+        });
+        fireEvent.click(button);
+        expect(screen.getByText(/Empty Bucket 'my-special-bucket'\?/i)).toBeInTheDocument();
+    });
+    it("shows loading state during deletion", async ()=>{
+        const mockEmptyBucket = jest.fn();
+        mockUseEmptyBucket.mockReturnValue({
+            emptyBucket: mockEmptyBucket,
+            isEmptying: true,
+            error: null,
+            result: null,
+            reset: jest.fn()
+        });
+        renderEmptyBucketButton();
+        const button = screen.getByRole("button", {
+            name: /empty bucket/i
+        });
+        fireEvent.click(button);
+        expect(screen.getByText(/Deletion in progress.../i)).toBeInTheDocument();
+    });
+    it("completes empty bucket operation successfully and shows summary", async ()=>{
+        const mockEmptyBucket = jest.fn().mockResolvedValue({
+            success: true,
+            deletedCount: 100,
+            errors: [],
+            limitReached: false
+        });
+        mockUseEmptyBucket.mockReturnValue({
+            emptyBucket: mockEmptyBucket,
+            isEmptying: false,
+            error: null,
+            result: null,
+            reset: jest.fn()
+        });
+        renderEmptyBucketButton();
+        const button = screen.getByRole("button", {
+            name: /empty bucket/i
+        });
+        fireEvent.click(button);
+        const input = screen.getByPlaceholderText(/test-bucket/i);
+        fireEvent.change(input, {
+            target: {
+                value: "test-bucket"
+            }
+        });
+        const emptyButton = screen.getByRole("button", {
+            name: /^empty$/i
+        });
+        fireEvent.click(emptyButton);
+        await waitFor(()=>{
+            expect(mockEmptyBucket).toHaveBeenCalledWith("test-bucket");
+        });
+    });
+    it("displays error when deletion fails", ()=>{
+        mockUseEmptyBucket.mockReturnValue({
+            emptyBucket: jest.fn(),
+            isEmptying: false,
+            error: new Error("Network error"),
+            result: null,
+            reset: jest.fn()
+        });
+        renderEmptyBucketButton();
+        const button = screen.getByRole("button", {
+            name: /empty bucket/i
+        });
+        fireEvent.click(button);
+        expect(screen.getByText(/Network error/i)).toBeInTheDocument();
+    });
+    it("calls emptyBucket when user confirms", async ()=>{
+        const mockEmptyBucket = jest.fn().mockResolvedValue({
+            success: false,
+            deletedCount: 50,
+            errors: [
+                {
+                    key: "file1.txt",
+                    code: "AccessDenied",
+                    message: "Access denied"
+                }
+            ],
+            limitReached: false
+        });
+        mockUseEmptyBucket.mockReturnValue({
+            emptyBucket: mockEmptyBucket,
+            isEmptying: false,
+            error: null,
+            result: null,
+            reset: jest.fn()
+        });
+        renderEmptyBucketButton();
+        const button = screen.getByRole("button", {
+            name: /empty bucket/i
+        });
+        fireEvent.click(button);
+        const input = screen.getByPlaceholderText(/test-bucket/i);
+        fireEvent.change(input, {
+            target: {
+                value: "test-bucket"
+            }
+        });
+        const emptyButton = screen.getByRole("button", {
+            name: /^empty$/i
+        });
+        fireEvent.click(emptyButton);
+        await waitFor(()=>{
+            expect(mockEmptyBucket).toHaveBeenCalledWith("test-bucket");
+        });
+    });
+    it("displays Object Lock warning when enabled", ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: "Enabled"
+                }
+            },
+            isLoading: false,
+            error: null
+        });
+        renderEmptyBucketButton();
+        const button = screen.getByRole("button", {
+            name: /empty bucket/i
+        });
+        fireEvent.click(button);
+        expect(screen.getByText(/locked in governance mode/i)).toBeInTheDocument();
+    });
+    it("does not show Object Lock warning when disabled", ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: "Disabled"
+                }
+            },
+            isLoading: false,
+            error: null
+        });
+        renderEmptyBucketButton();
+        const button = screen.getByRole("button", {
+            name: /empty bucket/i
+        });
+        fireEvent.click(button);
+        expect(screen.queryByText(/locked in governance mode/i)).not.toBeInTheDocument();
+    });
+});

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

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