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

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

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

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

@@ -0,0 +1,268 @@
+import { jsx } from "react/jsx-runtime";
+import { fireEvent, render, screen, waitFor } from "@testing-library/react";
+import { MemoryRouter, Route, Routes } from "react-router-dom";
+import { createMockMutationResult, createMockQueryResult, createTestWrapper } from "../../test/testUtils.js";
+import { BucketPolicyPage } from "../buckets/BucketPolicyPage.js";
+import { useGetBucketPolicy, useISVBucketStatus, useSetBucketPolicy } from "../../hooks/index.js";
+jest.mock("../../hooks", ()=>({
+        useGetBucketPolicy: jest.fn(),
+        useSetBucketPolicy: jest.fn(),
+        useISVBucketStatus: 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 mockUseISVBucketStatus = jest.mocked(useISVBucketStatus);
+const mockNavigate = jest.fn();
+const createNoSuchPolicyError = ()=>{
+    const error = new Error("Policy does not exist");
+    error.name = "NoSuchBucketPolicy";
+    return error;
+};
+const mockNoPolicyExists = ()=>{
+    mockUseGetBucketPolicy.mockReturnValue(createMockQueryResult({
+        status: "error",
+        error: createNoSuchPolicyError()
+    }));
+};
+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(createMockMutationResult(mockMutate));
+        mockUseISVBucketStatus.mockReturnValue({
+            isVeeamBucket: false,
+            isCommvaultBucket: false,
+            isISVManaged: false,
+            isvApplication: void 0,
+            isLoading: false,
+            bucketTagsStatus: "success"
+        });
+    });
+    it("shows loading state while fetching policy", ()=>{
+        mockUseGetBucketPolicy.mockReturnValue(createMockQueryResult({
+            status: "pending"
+        }));
+        renderBucketPolicyPage();
+        expect(screen.getByText("Loading policy...")).toBeInTheDocument();
+    });
+    it("renders create mode with default policy template when no policy exists", async ()=>{
+        mockNoPolicyExists();
+        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(createMockQueryResult({
+            data: {
+                Policy: JSON.stringify(existingPolicy),
+                $metadata: {}
+            },
+            status: "success"
+        }));
+        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 ()=>{
+        mockNoPolicyExists();
+        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 ()=>{
+        mockNoPolicyExists();
+        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 ()=>{
+        mockNoPolicyExists();
+        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 ()=>{
+        mockNoPolicyExists();
+        renderBucketPolicyPage();
+        await waitFor(()=>{
+            const cancelButton = screen.getByRole("button", {
+                name: /cancel/i
+            });
+            fireEvent.click(cancelButton);
+        });
+        expect(mockNavigate).toHaveBeenCalledWith("/buckets/test-bucket");
+    });
+    it("shows loading state when ISV bucket status is loading", ()=>{
+        mockUseGetBucketPolicy.mockReturnValue(createMockQueryResult({
+            status: "success",
+            data: {
+                Policy: JSON.stringify(existingPolicy),
+                $metadata: {}
+            }
+        }));
+        mockUseISVBucketStatus.mockReturnValue({
+            isVeeamBucket: false,
+            isCommvaultBucket: false,
+            isISVManaged: false,
+            isvApplication: void 0,
+            isLoading: true,
+            bucketTagsStatus: "pending"
+        });
+        renderBucketPolicyPage();
+        expect(screen.getByText("Loading policy...")).toBeInTheDocument();
+    });
+    it("displays warning banner when bucket is managed by Veeam", async ()=>{
+        mockNoPolicyExists();
+        mockUseISVBucketStatus.mockReturnValue({
+            isVeeamBucket: true,
+            isCommvaultBucket: false,
+            isISVManaged: true,
+            isvApplication: "Veeam",
+            isLoading: false,
+            bucketTagsStatus: "success"
+        });
+        renderBucketPolicyPage();
+        await waitFor(()=>{
+            expect(screen.getByTestId("policy-editor")).toBeInTheDocument();
+        });
+        expect(screen.getByText(/Warning:/i)).toBeInTheDocument();
+        expect(screen.getByText(/Veeam/i)).toBeInTheDocument();
+    });
+    it("displays warning banner when bucket is managed by Commvault", async ()=>{
+        mockNoPolicyExists();
+        mockUseISVBucketStatus.mockReturnValue({
+            isVeeamBucket: false,
+            isCommvaultBucket: true,
+            isISVManaged: true,
+            isvApplication: "Commvault",
+            isLoading: false,
+            bucketTagsStatus: "success"
+        });
+        renderBucketPolicyPage();
+        await waitFor(()=>{
+            expect(screen.getByTestId("policy-editor")).toBeInTheDocument();
+        });
+        expect(screen.getByText(/Warning:/i)).toBeInTheDocument();
+        expect(screen.getByText(/Commvault/i)).toBeInTheDocument();
+    });
+    it("does not display warning banner when bucket is not ISV managed", async ()=>{
+        mockNoPolicyExists();
+        mockUseISVBucketStatus.mockReturnValue({
+            isVeeamBucket: false,
+            isCommvaultBucket: false,
+            isISVManaged: false,
+            isvApplication: void 0,
+            isLoading: false,
+            bucketTagsStatus: "success"
+        });
+        renderBucketPolicyPage();
+        await waitFor(()=>{
+            expect(screen.getByTestId("policy-editor")).toBeInTheDocument();
+        });
+        expect(screen.queryByText((_content, element)=>element?.textContent?.includes("This bucket is managed by") || false)).not.toBeInTheDocument();
+    });
+});

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

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