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

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

@@ -1,14 +1,16 @@
 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 { MemoryRouter, Route, Routes } from "react-router";
+import { useGetBucketPolicy, useISVBucketStatus, useSetBucketPolicy } from "../../hooks/index.js";
+import { createMockMutationResult, createMockQueryResult, createTestWrapper } from "../../test/testUtils.js";
 import { BucketPolicyPage } from "../buckets/BucketPolicyPage.js";
-import { useGetBucketPolicy, useSetBucketPolicy } from "../../hooks/index.js";
-jest.mock("../../hooks", ()=>({
+jest.mock('../../hooks', ()=>({
         useGetBucketPolicy: jest.fn(),
-        useSetBucketPolicy: jest.fn()
+        useSetBucketPolicy: jest.fn(),
+        useISVBucketStatus: jest.fn(),
+        useBucketConfigEditor: jest.requireActual('../../hooks').useBucketConfigEditor
     }));
-jest.mock("../Editor", ()=>({
+jest.mock('../Editor', ()=>({
         Editor: ({ value, onChange })=>/*#__PURE__*/ jsx("textarea", {
                 "data-testid": "policy-editor",
                 value: value,
@@ -17,24 +19,36 @@ jest.mock("../Editor", ()=>({
     }));
 const mockUseGetBucketPolicy = jest.mocked(useGetBucketPolicy);
 const mockUseSetBucketPolicy = jest.mocked(useSetBucketPolicy);
+const mockUseISVBucketStatus = jest.mocked(useISVBucketStatus);
 const mockNavigate = jest.fn();
-jest.mock("react-router-dom", ()=>({
-        ...jest.requireActual("react-router-dom"),
+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', ()=>({
+        ...jest.requireActual('react-router'),
         useNavigate: ()=>mockNavigate
     }));
 const existingPolicy = {
-    Version: "2012-10-17",
+    Version: '2012-10-17',
     Statement: [
         {
-            Sid: "ExistingStatement",
-            Effect: "Allow",
-            Principal: "*",
-            Action: "s3:GetObject",
-            Resource: "arn:aws:s3:::test-bucket/*"
+            Sid: 'ExistingStatement',
+            Effect: 'Allow',
+            Principal: '*',
+            Action: 's3:GetObject',
+            Resource: 'arn:aws:s3:::test-bucket/*'
         }
     ]
 };
-const renderBucketPolicyPage = (bucketName = "test-bucket")=>{
+const renderBucketPolicyPage = (bucketName = 'test-bucket')=>{
     const Wrapper = createTestWrapper();
     return render(/*#__PURE__*/ jsx(MemoryRouter, {
         initialEntries: [
@@ -50,90 +64,77 @@ const renderBucketPolicyPage = (bucketName = "test-bucket")=>{
         })
     }));
 };
-describe("BucketPolicyPage", ()=>{
+describe('BucketPolicyPage', ()=>{
     const mockMutate = jest.fn();
     beforeEach(()=>{
         jest.clearAllMocks();
         mockNavigate.mockClear();
-        mockUseSetBucketPolicy.mockReturnValue({
-            mutate: mockMutate,
-            isPending: false
+        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({
-            data: void 0,
-            status: "pending",
-            error: null
-        });
+    it('shows loading state while fetching policy', ()=>{
+        mockUseGetBucketPolicy.mockReturnValue(createMockQueryResult({
+            status: 'pending'
+        }));
         renderBucketPolicyPage();
-        expect(screen.getByText("Loading policy...")).toBeInTheDocument();
+        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
-        });
+    it('renders create mode with default policy template when no policy exists', async ()=>{
+        mockNoPolicyExists();
         renderBucketPolicyPage();
         await waitFor(()=>{
-            expect(screen.getByText("Bucket Policy Creation")).toBeInTheDocument();
+            expect(screen.getByText('Create Bucket Policy')).toBeInTheDocument();
         });
-        const editor = screen.getByTestId("policy-editor");
-        expect(editor.value).toContain("ExampleStatement");
+        const editor = screen.getByTestId('policy-editor');
+        expect(editor.value).toContain('ExampleStatement');
     });
-    it("renders edit mode with existing policy", async ()=>{
-        mockUseGetBucketPolicy.mockReturnValue({
+    it('renders edit mode with existing policy', async ()=>{
+        mockUseGetBucketPolicy.mockReturnValue(createMockQueryResult({
             data: {
-                Policy: JSON.stringify(existingPolicy)
+                Policy: JSON.stringify(existingPolicy),
+                $metadata: {}
             },
-            status: "success",
-            error: null
-        });
+            status: 'success'
+        }));
         renderBucketPolicyPage();
         await waitFor(()=>{
-            expect(screen.getByText("Bucket Policy Edition")).toBeInTheDocument();
+            expect(screen.getByText('Edit Bucket Policy')).toBeInTheDocument();
         });
-        const editor = screen.getByTestId("policy-editor");
+        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
-        });
+    it('disables save button for invalid JSON format', async ()=>{
+        mockNoPolicyExists();
         renderBucketPolicyPage();
         await waitFor(()=>{
-            expect(screen.getByTestId("policy-editor")).toBeInTheDocument();
+            expect(screen.getByTestId('policy-editor')).toBeInTheDocument();
         });
-        const editor = screen.getByTestId("policy-editor");
+        const editor = screen.getByTestId('policy-editor');
         fireEvent.change(editor, {
             target: {
-                value: "{ invalid json"
+                value: '{ invalid json'
             }
         });
         await waitFor(()=>{
-            expect(screen.getByText(/Invalid JSON format/i)).toBeInTheDocument();
+            expect(screen.getByRole('button', {
+                name: /save/i
+            })).toBeDisabled();
         });
     });
-    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
-        });
+    it('saves valid policy and navigates back on success', async ()=>{
+        mockNoPolicyExists();
         renderBucketPolicyPage();
         await waitFor(()=>{
-            expect(screen.getByTestId("policy-editor")).toBeInTheDocument();
+            expect(screen.getByTestId('policy-editor')).toBeInTheDocument();
         });
-        const editor = screen.getByTestId("policy-editor");
+        const editor = screen.getByTestId('policy-editor');
         const validPolicy = JSON.stringify(existingPolicy, null, 2);
         fireEvent.change(editor, {
             target: {
@@ -143,71 +144,122 @@ describe("BucketPolicyPage", ()=>{
         mockMutate.mockImplementation((_, options)=>{
             options?.onSuccess?.();
         });
-        const saveButton = screen.getByRole("button", {
+        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",
+                Bucket: 'test-bucket',
                 Policy: JSON.stringify(existingPolicy)
             }, expect.any(Object));
-            expect(mockNavigate).toHaveBeenCalledWith("/buckets/test-bucket");
+            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
-        });
+    it('stays on page and displays error message when save fails', async ()=>{
+        mockNoPolicyExists();
         renderBucketPolicyPage();
         await waitFor(()=>{
-            expect(screen.getByTestId("policy-editor")).toBeInTheDocument();
+            expect(screen.getByTestId('policy-editor')).toBeInTheDocument();
         });
-        const editor = screen.getByTestId("policy-editor");
+        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");
+        const saveError = new Error('Access Denied');
         mockMutate.mockImplementation((_, options)=>{
             options?.onError?.(saveError);
         });
-        const saveButton = screen.getByRole("button", {
+        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();
+            expect(screen.getByText('Access Denied')).toBeInTheDocument();
         });
     });
-    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
-        });
+    it('handles cancel button click and navigates back', async ()=>{
+        mockNoPolicyExists();
         renderBucketPolicyPage();
         await waitFor(()=>{
-            const cancelButton = screen.getByRole("button", {
+            const cancelButton = screen.getByRole('button', {
                 name: /cancel/i
             });
             fireEvent.click(cancelButton);
         });
-        expect(mockNavigate).toHaveBeenCalledWith("/buckets/test-bucket");
+        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

@@ -1 +1,16 @@
+/**
+ * @fileoverview Comprehensive tests for BucketReplicationFormPage component
+ *
+ * This test suite covers:
+ * - Page rendering (create/edit modes, loading states, error states)
+ * - Form fields (initial state, field visibility, conditional rendering)
+ * - Form validation (required fields, uniqueness, format validation)
+ * - Automatic field behaviors (encryption, RTC, delete marker, conditional fields)
+ * - Form submission (create/edit modes, success/error handling, navigation)
+ * - Rule data loading (various filter types, configurations)
+ * - Edge cases (URL encoding, missing fields, special characters)
+ * - Boundary conditions (max lengths, extreme values, format validation)
+ *
+ * @see BucketReplicationFormPage for the component implementation
+ */
 export {};