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

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

@@ -0,0 +1,479 @@
+import { jsx } from "react/jsx-runtime";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { useGetBucketAcl, useGetBucketCors, useGetBucketLocation, useGetBucketObjectLockConfiguration, useGetBucketPolicy, useGetBucketVersioning } from "../../hooks/index.js";
+import { createTestWrapper } from "../../test/testUtils.js";
+import { BucketOverview } from "../buckets/BucketOverview.js";
+jest.mock("../../hooks");
+const mockUseGetBucketVersioning = jest.mocked(useGetBucketVersioning);
+const mockUseGetBucketAcl = jest.mocked(useGetBucketAcl);
+const mockUseGetBucketLocation = jest.mocked(useGetBucketLocation);
+const mockUseGetBucketCors = jest.mocked(useGetBucketCors);
+const mockUseGetBucketObjectLockConfiguration = jest.mocked(useGetBucketObjectLockConfiguration);
+const mockUseGetBucketPolicy = jest.mocked(useGetBucketPolicy);
+const renderBucketOverview = (props = {})=>{
+    const Wrapper = createTestWrapper();
+    return render(/*#__PURE__*/ jsx(Wrapper, {
+        children: /*#__PURE__*/ jsx(BucketOverview, {
+            bucketName: "test-bucket",
+            ...props
+        })
+    }));
+};
+const mockHookDefaults = ()=>{
+    mockUseGetBucketVersioning.mockReturnValue({
+        data: {
+            Status: "Enabled"
+        },
+        status: "success"
+    });
+    mockUseGetBucketAcl.mockReturnValue({
+        data: {
+            Owner: {
+                DisplayName: "test-owner"
+            },
+            Grants: [
+                {
+                    Grantee: {
+                        DisplayName: "test-grantee"
+                    }
+                }
+            ]
+        },
+        status: "success"
+    });
+    mockUseGetBucketLocation.mockReturnValue({
+        data: {
+            LocationConstraint: "us-west-2"
+        },
+        status: "success"
+    });
+    mockUseGetBucketCors.mockReturnValue({
+        data: {
+            CORSRules: []
+        },
+        status: "success"
+    });
+    mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+        data: {
+            ObjectLockConfiguration: {
+                ObjectLockEnabled: "Disabled"
+            }
+        },
+        status: "success"
+    });
+    mockUseGetBucketPolicy.mockReturnValue({
+        data: void 0,
+        error: null,
+        status: "success"
+    });
+};
+describe("BucketOverview", ()=>{
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockHookDefaults();
+    });
+    it("renders bucket overview with all sections", ()=>{
+        renderBucketOverview();
+        expect(screen.getByText("General")).toBeInTheDocument();
+        expect(screen.getByText("Data protection")).toBeInTheDocument();
+        expect(screen.getByText("Permissions")).toBeInTheDocument();
+    });
+    it("displays bucket name correctly", ()=>{
+        renderBucketOverview({
+            bucketName: "my-test-bucket"
+        });
+        expect(screen.getByText("my-test-bucket")).toBeInTheDocument();
+    });
+    it("shows versioning status when enabled", ()=>{
+        mockUseGetBucketVersioning.mockReturnValue({
+            data: {
+                Status: "Enabled"
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("Active")).toBeInTheDocument();
+    });
+    it("shows versioning status when disabled", ()=>{
+        mockUseGetBucketVersioning.mockReturnValue({
+            data: {
+                Status: "Suspended"
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("Inactive")).toBeInTheDocument();
+    });
+    it("displays bucket location", ()=>{
+        mockUseGetBucketLocation.mockReturnValue({
+            data: {
+                LocationConstraint: "eu-west-1"
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("eu-west-1")).toBeInTheDocument();
+    });
+    it("shows default location when LocationConstraint is null", ()=>{
+        mockUseGetBucketLocation.mockReturnValue({
+            data: {
+                LocationConstraint: null
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("us-east-1")).toBeInTheDocument();
+    });
+    it("shows object-lock enabled status", ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: "Enabled"
+                }
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("Enabled")).toBeInTheDocument();
+    });
+    it("shows object-lock disabled status", ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: "Disabled"
+                }
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("Disabled")).toBeInTheDocument();
+    });
+    it("displays bucket owner from ACL", ()=>{
+        mockUseGetBucketAcl.mockReturnValue({
+            data: {
+                Owner: {
+                    DisplayName: "bucket-owner"
+                },
+                Grants: []
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("bucket-owner")).toBeInTheDocument();
+    });
+    it("shows ACL grantees count", ()=>{
+        mockUseGetBucketAcl.mockReturnValue({
+            data: {
+                Owner: {
+                    DisplayName: "owner"
+                },
+                Grants: [
+                    {
+                        Grantee: {
+                            DisplayName: "user1"
+                        }
+                    },
+                    {
+                        Grantee: {
+                            DisplayName: "user2"
+                        }
+                    },
+                    {
+                        Grantee: {
+                            DisplayName: "user3"
+                        }
+                    }
+                ]
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("3 Grantees")).toBeInTheDocument();
+    });
+    it("shows single grantee without plural", ()=>{
+        mockUseGetBucketAcl.mockReturnValue({
+            data: {
+                Owner: {
+                    DisplayName: "owner"
+                },
+                Grants: [
+                    {
+                        Grantee: {
+                            DisplayName: "user1"
+                        }
+                    }
+                ]
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("1 Grantee")).toBeInTheDocument();
+    });
+    it("shows CORS enabled when rules exist", ()=>{
+        mockUseGetBucketCors.mockReturnValue({
+            data: {
+                CORSRules: [
+                    {
+                        AllowedMethods: [
+                            "GET"
+                        ],
+                        AllowedOrigins: [
+                            "*"
+                        ]
+                    }
+                ]
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("Yes")).toBeInTheDocument();
+    });
+    it("shows CORS disabled when no rules exist", ()=>{
+        mockUseGetBucketCors.mockReturnValue({
+            data: {
+                CORSRules: []
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        const corsValues = screen.getAllByText("No");
+        expect(corsValues.length).toBeGreaterThan(0);
+    });
+    it("detects public bucket from ACL grants", ()=>{
+        mockUseGetBucketAcl.mockReturnValue({
+            data: {
+                Owner: {
+                    DisplayName: "owner"
+                },
+                Grants: [
+                    {
+                        Grantee: {
+                            URI: "http://acs.amazonaws.com/groups/global/AllUsers"
+                        },
+                        Permission: "READ"
+                    }
+                ]
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("Yes")).toBeInTheDocument();
+    });
+    it("shows non-public bucket when no public grants", ()=>{
+        mockUseGetBucketAcl.mockReturnValue({
+            data: {
+                Owner: {
+                    DisplayName: "owner"
+                },
+                Grants: [
+                    {
+                        Grantee: {
+                            DisplayName: "private-user"
+                        },
+                        Permission: "READ"
+                    }
+                ]
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        const publicValues = screen.getAllByText("No");
+        expect(publicValues.length).toBeGreaterThan(0);
+    });
+    it("shows loading states while data is being fetched", ()=>{
+        mockUseGetBucketVersioning.mockReturnValue({
+            data: void 0,
+            status: "pending"
+        });
+        mockUseGetBucketAcl.mockReturnValue({
+            data: void 0,
+            status: "pending"
+        });
+        renderBucketOverview();
+        const loaders = document.querySelectorAll('[data-testid="loader"], .loader, [class*="loader"]');
+        expect(loaders.length).toBeGreaterThan(0);
+    });
+    it("shows error states when API calls fail", ()=>{
+        mockUseGetBucketVersioning.mockReturnValue({
+            data: void 0,
+            status: "error"
+        });
+        mockUseGetBucketLocation.mockReturnValue({
+            data: void 0,
+            status: "error"
+        });
+        renderBucketOverview();
+        const errorElements = screen.getAllByText("Error");
+        expect(errorElements.length).toBeGreaterThan(0);
+    });
+    it("handles empty bucket button click", ()=>{
+        const onEmptyBucket = jest.fn();
+        renderBucketOverview({
+            onEmptyBucket,
+            isEmptyBucketDisabled: false
+        });
+        const emptyButton = screen.getByRole("button", {
+            name: /empty bucket/i
+        });
+        fireEvent.click(emptyButton);
+        expect(onEmptyBucket).toHaveBeenCalled();
+    });
+    it("handles delete bucket button click", ()=>{
+        const onDeleteBucket = jest.fn();
+        renderBucketOverview({
+            onDeleteBucket
+        });
+        const deleteButton = screen.getByRole("button", {
+            name: /delete bucket/i
+        });
+        fireEvent.click(deleteButton);
+        expect(onDeleteBucket).toHaveBeenCalled();
+    });
+    it("disables empty button when specified", ()=>{
+        renderBucketOverview({
+            isEmptyBucketDisabled: true
+        });
+        const emptyButton = screen.getByRole("button", {
+            name: /empty bucket/i
+        });
+        expect(emptyButton).toBeDisabled();
+    });
+    it("disables delete button when specified", ()=>{
+        renderBucketOverview({
+            isDeleteBucketDisabled: true
+        });
+        const deleteButton = screen.getByRole("button", {
+            name: /delete bucket/i
+        });
+        expect(deleteButton).toBeDisabled();
+    });
+    it("renders custom empty button when provided", ()=>{
+        const renderEmptyButton = jest.fn(()=>/*#__PURE__*/ jsx("button", {
+                children: "Custom Empty Button"
+            }));
+        renderBucketOverview({
+            renderEmptyButton
+        });
+        expect(screen.getByText("Custom Empty Button")).toBeInTheDocument();
+        expect(renderEmptyButton).toHaveBeenCalledWith("test-bucket");
+    });
+    it("renders custom delete button when provided", ()=>{
+        const renderDeleteButton = jest.fn(()=>/*#__PURE__*/ jsx("button", {
+                children: "Custom Delete Button"
+            }));
+        renderBucketOverview({
+            renderDeleteButton
+        });
+        expect(screen.getByText("Custom Delete Button")).toBeInTheDocument();
+        expect(renderDeleteButton).toHaveBeenCalledWith("test-bucket");
+    });
+    it("works when no callbacks are provided", ()=>{
+        expect(()=>{
+            renderBucketOverview();
+            const emptyButton = screen.getByRole("button", {
+                name: /empty bucket/i
+            });
+            const deleteButton = screen.getByRole("button", {
+                name: /delete bucket/i
+            });
+            fireEvent.click(emptyButton);
+            fireEvent.click(deleteButton);
+        }).not.toThrow();
+    });
+    it("handles missing ACL data gracefully", ()=>{
+        mockUseGetBucketAcl.mockReturnValue({
+            data: void 0,
+            status: "success"
+        });
+        renderBucketOverview();
+        const naElements = screen.getAllByText("N/A");
+        expect(naElements.length).toBeGreaterThan(0);
+    });
+    it("handles missing versioning data gracefully", ()=>{
+        mockUseGetBucketVersioning.mockReturnValue({
+            data: void 0,
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("Inactive")).toBeInTheDocument();
+    });
+    it("handles CORS error state", ()=>{
+        mockUseGetBucketCors.mockReturnValue({
+            data: void 0,
+            status: "error"
+        });
+        renderBucketOverview();
+        const corsValues = screen.getAllByText("No");
+        expect(corsValues.length).toBeGreaterThan(0);
+    });
+    it("handles object lock error state", ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: void 0,
+            status: "error"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("Disabled")).toBeInTheDocument();
+    });
+    describe("Bucket Policy", ()=>{
+        it("shows 'Configured' when policy exists", ()=>{
+            mockUseGetBucketPolicy.mockReturnValue({
+                data: {
+                    Policy: '{"Version":"2012-10-17","Statement":[]}'
+                },
+                error: null,
+                status: "success"
+            });
+            renderBucketOverview();
+            expect(screen.getByText("Configured")).toBeInTheDocument();
+        });
+        it("shows 'Not configured' when no policy exists", ()=>{
+            mockUseGetBucketPolicy.mockReturnValue({
+                data: void 0,
+                error: null,
+                status: "success"
+            });
+            renderBucketOverview();
+            expect(screen.getByText("Not configured")).toBeInTheDocument();
+        });
+        it("shows 'Error' when policy fetch fails with non-NoSuchBucketPolicy error", ()=>{
+            const genericError = new Error("Network error");
+            mockUseGetBucketPolicy.mockReturnValue({
+                data: void 0,
+                error: genericError,
+                status: "error"
+            });
+            renderBucketOverview();
+            const errorElements = screen.getAllByText("Error");
+            expect(errorElements.length).toBeGreaterThan(0);
+        });
+        it("shows 'Not configured' when policy does not exist (NoSuchBucketPolicy)", ()=>{
+            const noSuchPolicyError = new Error("Policy does not exist");
+            noSuchPolicyError.name = "NoSuchBucketPolicy";
+            mockUseGetBucketPolicy.mockReturnValue({
+                data: void 0,
+                error: noSuchPolicyError,
+                status: "error"
+            });
+            renderBucketOverview();
+            expect(screen.getByText("Not configured")).toBeInTheDocument();
+        });
+        it("calls onEditPolicy when edit button is clicked", ()=>{
+            const onEditPolicy = jest.fn();
+            mockUseGetBucketPolicy.mockReturnValue({
+                data: {
+                    Policy: '{"Version":"2012-10-17","Statement":[]}'
+                },
+                error: null,
+                status: "success"
+            });
+            renderBucketOverview({
+                onEditPolicy
+            });
+            const editButton = screen.getByRole("button", {
+                name: /edit/i
+            });
+            fireEvent.click(editButton);
+            expect(onEditPolicy).toHaveBeenCalledWith("test-bucket");
+        });
+    });
+});

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

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

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

@@ -0,0 +1,213 @@
+import { jsx } from "react/jsx-runtime";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { MemoryRouter, Route, Routes } from "react-router-dom";
+import { createTestWrapper } from "../../test/testUtils.js";
+import { BucketPolicyPage } from "../buckets/BucketPolicyPage.js";
+import { useGetBucketPolicy, useSetBucketPolicy } from "../../hooks/index.js";
+jest.mock("../../hooks", ()=>({
+        useGetBucketPolicy: jest.fn(),
+        useSetBucketPolicy: jest.fn()
+    }));
+jest.mock("../Editor", ()=>({
+        Editor: ({ value, onChange })=>/*#__PURE__*/ jsx("textarea", {
+                "data-testid": "policy-editor",
+                value: value,
+                onChange: (e)=>onChange(e.target.value)
+            })
+    }));
+const mockUseGetBucketPolicy = jest.mocked(useGetBucketPolicy);
+const mockUseSetBucketPolicy = jest.mocked(useSetBucketPolicy);
+const mockNavigate = jest.fn();
+jest.mock("react-router-dom", ()=>({
+        ...jest.requireActual("react-router-dom"),
+        useNavigate: ()=>mockNavigate
+    }));
+const existingPolicy = {
+    Version: "2012-10-17",
+    Statement: [
+        {
+            Sid: "ExistingStatement",
+            Effect: "Allow",
+            Principal: "*",
+            Action: "s3:GetObject",
+            Resource: "arn:aws:s3:::test-bucket/*"
+        }
+    ]
+};
+const renderBucketPolicyPage = (bucketName = "test-bucket")=>{
+    const Wrapper = createTestWrapper();
+    return render(/*#__PURE__*/ jsx(MemoryRouter, {
+        initialEntries: [
+            `/buckets/${bucketName}/policy`
+        ],
+        children: /*#__PURE__*/ jsx(Wrapper, {
+            children: /*#__PURE__*/ jsx(Routes, {
+                children: /*#__PURE__*/ jsx(Route, {
+                    path: "/buckets/:bucketName/policy",
+                    element: /*#__PURE__*/ jsx(BucketPolicyPage, {})
+                })
+            })
+        })
+    }));
+};
+describe("BucketPolicyPage", ()=>{
+    const mockMutate = jest.fn();
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockNavigate.mockClear();
+        mockUseSetBucketPolicy.mockReturnValue({
+            mutate: mockMutate,
+            isPending: false
+        });
+    });
+    it("shows loading state while fetching policy", ()=>{
+        mockUseGetBucketPolicy.mockReturnValue({
+            data: void 0,
+            status: "pending",
+            error: null
+        });
+        renderBucketPolicyPage();
+        expect(screen.getByText("Loading policy...")).toBeInTheDocument();
+    });
+    it("renders create mode with default policy template when no policy exists", async ()=>{
+        const noSuchPolicyError = new Error("Policy does not exist");
+        noSuchPolicyError.name = "NoSuchBucketPolicy";
+        mockUseGetBucketPolicy.mockReturnValue({
+            data: void 0,
+            status: "error",
+            error: noSuchPolicyError
+        });
+        renderBucketPolicyPage();
+        await waitFor(()=>{
+            expect(screen.getByText("Bucket Policy Creation")).toBeInTheDocument();
+        });
+        const editor = screen.getByTestId("policy-editor");
+        expect(editor.value).toContain("ExampleStatement");
+    });
+    it("renders edit mode with existing policy", async ()=>{
+        mockUseGetBucketPolicy.mockReturnValue({
+            data: {
+                Policy: JSON.stringify(existingPolicy)
+            },
+            status: "success",
+            error: null
+        });
+        renderBucketPolicyPage();
+        await waitFor(()=>{
+            expect(screen.getByText("Bucket Policy Edition")).toBeInTheDocument();
+        });
+        const editor = screen.getByTestId("policy-editor");
+        expect(JSON.parse(editor.value)).toEqual(existingPolicy);
+    });
+    it("validates JSON format and shows error for invalid input", async ()=>{
+        const noSuchPolicyError = new Error("Policy does not exist");
+        noSuchPolicyError.name = "NoSuchBucketPolicy";
+        mockUseGetBucketPolicy.mockReturnValue({
+            data: void 0,
+            status: "error",
+            error: noSuchPolicyError
+        });
+        renderBucketPolicyPage();
+        await waitFor(()=>{
+            expect(screen.getByTestId("policy-editor")).toBeInTheDocument();
+        });
+        const editor = screen.getByTestId("policy-editor");
+        fireEvent.change(editor, {
+            target: {
+                value: "{ invalid json"
+            }
+        });
+        await waitFor(()=>{
+            expect(screen.getByText(/Invalid JSON format/i)).toBeInTheDocument();
+        });
+    });
+    it("saves valid policy and navigates back on success", async ()=>{
+        const noSuchPolicyError = new Error("Policy does not exist");
+        noSuchPolicyError.name = "NoSuchBucketPolicy";
+        mockUseGetBucketPolicy.mockReturnValue({
+            data: void 0,
+            status: "error",
+            error: noSuchPolicyError
+        });
+        renderBucketPolicyPage();
+        await waitFor(()=>{
+            expect(screen.getByTestId("policy-editor")).toBeInTheDocument();
+        });
+        const editor = screen.getByTestId("policy-editor");
+        const validPolicy = JSON.stringify(existingPolicy, null, 2);
+        fireEvent.change(editor, {
+            target: {
+                value: validPolicy
+            }
+        });
+        mockMutate.mockImplementation((_, options)=>{
+            options?.onSuccess?.();
+        });
+        const saveButton = screen.getByRole("button", {
+            name: /save/i
+        });
+        await waitFor(()=>{
+            expect(saveButton).not.toBeDisabled();
+        });
+        fireEvent.click(saveButton);
+        await waitFor(()=>{
+            expect(mockMutate).toHaveBeenCalledWith({
+                Bucket: "test-bucket",
+                Policy: JSON.stringify(existingPolicy)
+            }, expect.any(Object));
+            expect(mockNavigate).toHaveBeenCalledWith("/buckets/test-bucket");
+        });
+    });
+    it("displays error message when save fails", async ()=>{
+        const noSuchPolicyError = new Error("Policy does not exist");
+        noSuchPolicyError.name = "NoSuchBucketPolicy";
+        mockUseGetBucketPolicy.mockReturnValue({
+            data: void 0,
+            status: "error",
+            error: noSuchPolicyError
+        });
+        renderBucketPolicyPage();
+        await waitFor(()=>{
+            expect(screen.getByTestId("policy-editor")).toBeInTheDocument();
+        });
+        const editor = screen.getByTestId("policy-editor");
+        const validPolicy = JSON.stringify(existingPolicy, null, 2);
+        fireEvent.change(editor, {
+            target: {
+                value: validPolicy
+            }
+        });
+        const saveError = new Error("Access Denied");
+        mockMutate.mockImplementation((_, options)=>{
+            options?.onError?.(saveError);
+        });
+        const saveButton = screen.getByRole("button", {
+            name: /save/i
+        });
+        await waitFor(()=>{
+            expect(saveButton).not.toBeDisabled();
+        });
+        fireEvent.click(saveButton);
+        await waitFor(()=>{
+            expect(screen.getByText(/Save policy error: Access Denied/i)).toBeInTheDocument();
+            expect(mockNavigate).not.toHaveBeenCalled();
+        });
+    });
+    it("handles cancel button click and navigates back", async ()=>{
+        const noSuchPolicyError = new Error("Policy does not exist");
+        noSuchPolicyError.name = "NoSuchBucketPolicy";
+        mockUseGetBucketPolicy.mockReturnValue({
+            data: void 0,
+            status: "error",
+            error: noSuchPolicyError
+        });
+        renderBucketPolicyPage();
+        await waitFor(()=>{
+            const cancelButton = screen.getByRole("button", {
+                name: /cancel/i
+            });
+            fireEvent.click(cancelButton);
+        });
+        expect(mockNavigate).toHaveBeenCalledWith("/buckets/test-bucket");
+    });
+});

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

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