@scality/data-browser-library 1.0.8 → 1.1.0

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

@@ -1,16 +1,19 @@
 import { jsx } from "react/jsx-runtime";
 import { fireEvent, render, screen, waitFor } from "@testing-library/react";
 import { MemoryRouter, Route, Routes } from "react-router";
-import { useDeleteBucketCors, useGetBucketCors, useSetBucketCors } from "../../hooks/index.js";
+import { useDeleteBucketCors, useGetBucketCors, useISVBucketStatus, useSetBucketCors } from "../../hooks/index.js";
 import { createMockMutationResult, createMockQueryResult, createTestWrapper } from "../../test/testUtils.js";
+import { EnhancedS3Error, ErrorCategory } from "../../utils/errorHandling.js";
 import { BucketCorsPage } from "../buckets/BucketCorsPage.js";
 jest.mock('../../hooks', ()=>({
         useGetBucketCors: jest.fn(),
         useSetBucketCors: jest.fn(),
         useDeleteBucketCors: jest.fn(),
+        useISVBucketStatus: jest.fn(),
         useBucketConfigEditor: jest.requireActual('../../hooks').useBucketConfigEditor
     }));
-jest.mock('../Editor', ()=>({
+jest.mock('@scality/core-ui/dist/next', ()=>({
+        ...jest.requireActual('@scality/core-ui/dist/next'),
         Editor: ({ value, onChange })=>/*#__PURE__*/ jsx("textarea", {
                 "data-testid": "cors-editor",
                 value: value,
@@ -20,6 +23,7 @@ jest.mock('../Editor', ()=>({
 const mockUseGetBucketCors = jest.mocked(useGetBucketCors);
 const mockUseSetBucketCors = jest.mocked(useSetBucketCors);
 const mockUseDeleteBucketCors = jest.mocked(useDeleteBucketCors);
+const mockUseISVBucketStatus = jest.mocked(useISVBucketStatus);
 const mockNavigate = jest.fn();
 jest.mock('react-router', ()=>({
         ...jest.requireActual('react-router'),
@@ -43,11 +47,7 @@ const existingCorsRules = [
         MaxAgeSeconds: 3600
     }
 ];
-const createNoSuchCorsError = ()=>{
-    const error = new Error('CORS configuration does not exist');
-    error.name = 'NoSuchCORSConfiguration';
-    return error;
-};
+const createNoSuchCorsError = ()=>new EnhancedS3Error('CORS configuration does not exist', 'NoSuchCORSConfiguration', ErrorCategory.NOT_FOUND, new Error('CORS configuration does not exist'), 404);
 const mockNoCorsExists = ()=>{
     mockUseGetBucketCors.mockReturnValue(createMockQueryResult({
         status: 'error',
@@ -86,6 +86,15 @@ describe('BucketCorsPage', ()=>{
         jest.clearAllMocks();
         mockUseSetBucketCors.mockReturnValue(createMockMutationResult(mockSaveMutate));
         mockUseDeleteBucketCors.mockReturnValue(createMockMutationResult(mockDeleteMutate));
+        mockUseISVBucketStatus.mockReturnValue({
+            isVeeamBucket: false,
+            isCommvaultBucket: false,
+            isKastenBucket: false,
+            isISVManaged: false,
+            isvApplication: void 0,
+            isLoading: false,
+            bucketTagsStatus: 'success'
+        });
     });
     it('shows loading state while fetching CORS configuration', ()=>{
         mockUseGetBucketCors.mockReturnValue(createMockQueryResult({
@@ -94,14 +103,32 @@ describe('BucketCorsPage', ()=>{
         renderBucketCorsPage();
         expect(screen.getByText('Loading CORS configuration...')).toBeInTheDocument();
     });
-    it('shows create mode with default template when no CORS exists', async ()=>{
+    it('shows create mode with empty editor when no CORS exists', async ()=>{
         mockNoCorsExists();
         renderBucketCorsPage();
         await waitFor(()=>{
             expect(screen.getByText('Create Bucket CORS')).toBeInTheDocument();
         });
         const editor = screen.getByTestId('cors-editor');
-        expect(editor.value).toContain('AllowedHeaders');
+        expect(editor.value).toBe('');
+        expect(screen.getByText('Empty CORS rule')).toBeInTheDocument();
+    });
+    it('loads standard template when clicking the template button', async ()=>{
+        mockNoCorsExists();
+        renderBucketCorsPage();
+        await waitFor(()=>{
+            expect(screen.getByText('Empty CORS rule')).toBeInTheDocument();
+        });
+        fireEvent.click(screen.getByRole('button', {
+            name: /Load a template/i
+        }));
+        await waitFor(()=>{
+            const editor = screen.getByTestId('cors-editor');
+            expect(editor.value).toContain('AllowedMethods');
+            expect(editor.value).toContain('GET');
+            expect(editor.value).toContain('PUT');
+        });
+        expect(screen.queryByText('Empty CORS rule')).not.toBeInTheDocument();
     });
     it('shows edit mode with existing CORS rules', async ()=>{
         mockCorsExists();
@@ -248,6 +275,37 @@ describe('BucketCorsPage', ()=>{
             expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket');
         });
     });
+    it('renders nothing while ISV bucket status is loading', ()=>{
+        mockNoCorsExists();
+        mockUseISVBucketStatus.mockReturnValue({
+            isVeeamBucket: false,
+            isCommvaultBucket: false,
+            isKastenBucket: false,
+            isISVManaged: false,
+            isvApplication: void 0,
+            isLoading: true,
+            bucketTagsStatus: 'pending'
+        });
+        renderBucketCorsPage();
+        expect(screen.queryByText('Loading CORS configuration...')).not.toBeInTheDocument();
+        expect(screen.queryByTestId('cors-editor')).not.toBeInTheDocument();
+    });
+    it('redirects to bucket overview when bucket is ISV-managed', ()=>{
+        mockNoCorsExists();
+        mockUseISVBucketStatus.mockReturnValue({
+            isVeeamBucket: true,
+            isCommvaultBucket: false,
+            isKastenBucket: false,
+            isISVManaged: true,
+            isvApplication: 'Veeam',
+            isLoading: false,
+            bucketTagsStatus: 'success'
+        });
+        renderBucketCorsPage();
+        expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket', {
+            replace: true
+        });
+    });
     it('shows error message when fetching CORS fails with unexpected error', ()=>{
         const accessDeniedError = new Error('Access Denied');
         accessDeniedError.name = 'AccessDenied';

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

@@ -10,6 +10,7 @@ import * as __rspack_external__contexts_DataBrowserUICustomizationContext_js_f26
 jest.mock('../../hooks');
 jest.mock('../../hooks/useISVBucketDetection');
 jest.mock('../../hooks/useFeatures');
+jest.mock('../../hooks/useIsBucketEmpty');
 const mockUseParams = jest.fn();
 const mockUseNavigate = jest.fn();
 jest.mock('react-router', ()=>({

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

@@ -51,6 +51,12 @@ const renderBucketLifecycleFormPage = (bucketName = 'test-bucket', ruleId)=>{
         })
     }));
 };
+const findStatusToggle = ()=>{
+    const label = document.querySelector('[for="status"]');
+    let current = label?.parentElement;
+    while(current && !current.querySelector('input[type="checkbox"]'))current = current.parentElement;
+    return current?.querySelector('input[type="checkbox"]');
+};
 describe('BucketLifecycleFormPage', ()=>{
     const mockMutate = jest.fn();
     const enableExpirationAction = async ()=>{
@@ -134,7 +140,7 @@ describe('BucketLifecycleFormPage', ()=>{
         it('renders required form fields in create mode', ()=>{
             renderBucketLifecycleFormPage();
             expect(screen.getByLabelText(/rule id/i)).toBeInTheDocument();
-            expect(screen.getByLabelText(/status/i)).toBeInTheDocument();
+            expect(document.querySelector('[id="label-status"]')).toBeInTheDocument();
             expect(screen.getByLabelText(/filter/i)).toBeInTheDocument();
         });
         it('renders all lifecycle action toggles', ()=>{
@@ -358,11 +364,13 @@ describe('BucketLifecycleFormPage', ()=>{
             await waitFor(()=>{
                 expect(screen.getByText('Edit Lifecycle Rule')).toBeInTheDocument();
             });
-            const statusSelect = screen.getByLabelText(/status/i);
-            await user_event.click(statusSelect);
-            await user_event.click(screen.getByRole('option', {
-                name: 'Disabled'
-            }));
+            let statusToggle = null;
+            await waitFor(()=>{
+                statusToggle = findStatusToggle();
+                expect(statusToggle).toBeInTheDocument();
+                expect(statusToggle).toBeChecked();
+            });
+            fireEvent.click(statusToggle);
             mockSuccessSubmit(mockMutate);
             await submitForm('save');
             await waitFor(()=>{
@@ -393,11 +401,8 @@ describe('BucketLifecycleFormPage', ()=>{
             await waitFor(()=>{
                 expect(screen.getByText('Edit Lifecycle Rule')).toBeInTheDocument();
             });
-            const statusSelect = screen.getByLabelText(/status/i);
-            await user_event.click(statusSelect);
-            await user_event.click(screen.getByRole('option', {
-                name: 'Disabled'
-            }));
+            const statusToggle = findStatusToggle();
+            fireEvent.click(statusToggle);
             mockSuccessSubmit(mockMutate);
             await submitForm('save');
             await waitFor(()=>{

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

@@ -3,12 +3,15 @@ import { fireEvent, render, screen, waitFor } from "@testing-library/react";
 import user_event from "@testing-library/user-event";
 import { MemoryRouter, Route, Routes } from "react-router";
 import { useGetBucketNotification, useSetBucketNotification } from "../../hooks/index.js";
+import { useSupportedNotificationEvents } from "../../hooks/useSupportedNotificationEvents.js";
 import { createTestWrapper } from "../../test/testUtils.js";
 import { BucketNotificationFormPage } from "../buckets/notifications/BucketNotificationFormPage.js";
 jest.mock('../../hooks', ()=>({
         useGetBucketNotification: jest.fn(),
         useSetBucketNotification: jest.fn()
     }));
+jest.mock('../../hooks/useSupportedNotificationEvents');
+const mockUseSupportedNotificationEvents = jest.mocked(useSupportedNotificationEvents);
 const mockUseGetBucketNotification = jest.mocked(useGetBucketNotification);
 const mockUseSetBucketNotification = jest.mocked(useSetBucketNotification);
 const mockNavigate = jest.fn();
@@ -61,6 +64,7 @@ describe('BucketNotificationFormPage', ()=>{
             mutate: mockMutate,
             isPending: false
         });
+        mockUseSupportedNotificationEvents.mockReturnValue(void 0);
     });
     describe('Create Mode', ()=>{
         it('renders create notification form with all fields', ()=>{
@@ -379,5 +383,46 @@ describe('BucketNotificationFormPage', ()=>{
             fireEvent.click(cancelButton);
             expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket?tab=notification');
         });
+        it('filters out unsupported events when populating form in edit mode', async ()=>{
+            const configWithUnsupportedEvents = {
+                QueueConfigurations: [
+                    {
+                        Id: 'existing-rule',
+                        QueueArn: 'arn:aws:sqs:us-east-1:123:existing-queue',
+                        Events: [
+                            's3:ObjectCreated:Put',
+                            's3:ObjectRemoved:Delete',
+                            's3:IntelligentTiering'
+                        ]
+                    }
+                ]
+            };
+            mockUseGetBucketNotification.mockReturnValue({
+                data: configWithUnsupportedEvents,
+                status: 'success'
+            });
+            mockUseSupportedNotificationEvents.mockReturnValue([
+                's3:ObjectCreated:*',
+                's3:ObjectCreated:Put',
+                's3:ObjectCreated:Post',
+                's3:ObjectCreated:Copy',
+                's3:ObjectCreated:CompleteMultipartUpload',
+                's3:ObjectRemoved:*',
+                's3:ObjectRemoved:Delete',
+                's3:ObjectRemoved:DeleteMarkerCreated'
+            ]);
+            renderEditPage();
+            await waitFor(()=>{
+                expect(screen.getByRole('checkbox', {
+                    name: 's3:ObjectCreated:Put'
+                })).toBeChecked();
+            });
+            expect(screen.getByRole('checkbox', {
+                name: 's3:ObjectRemoved:Delete'
+            })).toBeChecked();
+            expect(screen.queryByRole('checkbox', {
+                name: 's3:IntelligentTiering'
+            })).not.toBeInTheDocument();
+        });
     });
 });

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

@@ -4,6 +4,7 @@ import { MemoryRouter } from "react-router";
 import { useGetBucketAcl, useGetBucketCors, useGetBucketLocation, useGetBucketObjectLockConfiguration, useGetBucketPolicy, useGetBucketTagging, useGetBucketVersioning, useISVBucketStatus } from "../../hooks/index.js";
 import { useFeatures } from "../../hooks/useFeatures.js";
 import { applyBucketMocks, createTestWrapper } from "../../test/testUtils.js";
+import { EnhancedS3Error, ErrorCategory } from "../../utils/errorHandling.js";
 import { BucketOverview, useBucketOverviewContext } from "../buckets/BucketOverview.js";
 import * as __rspack_external__contexts_DataBrowserUICustomizationContext_js_f267b01c from "../../contexts/DataBrowserUICustomizationContext.js";
 jest.mock('../../hooks');
@@ -588,8 +589,7 @@ describe('BucketOverview', ()=>{
             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';
+            const noSuchPolicyError = new EnhancedS3Error('Policy does not exist', 'NoSuchBucketPolicy', ErrorCategory.NOT_FOUND, new Error('Policy does not exist'), 404);
             mockUseGetBucketPolicy.mockReturnValue({
                 data: void 0,
                 error: noSuchPolicyError,
@@ -617,6 +617,96 @@ describe('BucketOverview', ()=>{
             expect(onEditPolicy).toHaveBeenCalledWith('test-bucket');
         });
     });
+    describe('ISV-managed buckets', ()=>{
+        it('disables CORS edit button when bucket is ISV-managed', ()=>{
+            mockUseISVBucketStatus.mockReturnValue({
+                isVeeamBucket: true,
+                isCommvaultBucket: false,
+                isKastenBucket: false,
+                isISVManaged: true,
+                isvApplication: 'Veeam',
+                isLoading: false,
+                bucketTagsStatus: 'success'
+            });
+            mockUseGetBucketCors.mockReturnValue({
+                data: {
+                    CORSRules: [
+                        {
+                            AllowedMethods: [
+                                'GET'
+                            ],
+                            AllowedOrigins: [
+                                '*'
+                            ]
+                        }
+                    ]
+                },
+                status: 'success',
+                error: null
+            });
+            renderBucketOverview();
+            const corsButton = screen.getByRole('button', {
+                name: /bucket CORS/i
+            });
+            expect(corsButton).toBeDisabled();
+        });
+        it('disables bucket policy edit button when bucket is ISV-managed', ()=>{
+            mockUseISVBucketStatus.mockReturnValue({
+                isVeeamBucket: false,
+                isCommvaultBucket: true,
+                isKastenBucket: false,
+                isISVManaged: true,
+                isvApplication: 'Commvault',
+                isLoading: false,
+                bucketTagsStatus: 'success'
+            });
+            mockUseGetBucketPolicy.mockReturnValue({
+                data: {
+                    Policy: '{"Version":"2012-10-17","Statement":[]}'
+                },
+                error: null,
+                status: 'success'
+            });
+            renderBucketOverview();
+            const policyButton = screen.getByRole('button', {
+                name: /bucket policy/i
+            });
+            expect(policyButton).toBeDisabled();
+            expect(screen.getByText('Configured')).toBeInTheDocument();
+        });
+        it('enables CORS and policy edit buttons when bucket is not ISV-managed', ()=>{
+            mockUseGetBucketCors.mockReturnValue({
+                data: {
+                    CORSRules: [
+                        {
+                            AllowedMethods: [
+                                'GET'
+                            ],
+                            AllowedOrigins: [
+                                '*'
+                            ]
+                        }
+                    ]
+                },
+                status: 'success',
+                error: null
+            });
+            mockUseGetBucketPolicy.mockReturnValue({
+                data: {
+                    Policy: '{"Version":"2012-10-17","Statement":[]}'
+                },
+                error: null,
+                status: 'success'
+            });
+            renderBucketOverview();
+            expect(screen.getByRole('button', {
+                name: /bucket CORS/i
+            })).not.toBeDisabled();
+            expect(screen.getByRole('button', {
+                name: /bucket policy/i
+            })).not.toBeDisabled();
+        });
+    });
     describe('Extra Sections', ()=>{
         it('renders extra sections between General and Data Protection', ()=>{
             const Wrapper = createTestWrapper();

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

@@ -1,16 +1,19 @@
 import { jsx } from "react/jsx-runtime";
 import { fireEvent, render, screen, waitFor } from "@testing-library/react";
 import { MemoryRouter, Route, Routes } from "react-router";
-import { useGetBucketPolicy, useISVBucketStatus, useSetBucketPolicy } from "../../hooks/index.js";
+import { useDeleteBucketPolicy, useGetBucketPolicy, useISVBucketStatus, useSetBucketPolicy } from "../../hooks/index.js";
 import { createMockMutationResult, createMockQueryResult, createTestWrapper } from "../../test/testUtils.js";
+import { EnhancedS3Error, ErrorCategory } from "../../utils/errorHandling.js";
 import { BucketPolicyPage } from "../buckets/BucketPolicyPage.js";
 jest.mock('../../hooks', ()=>({
         useGetBucketPolicy: jest.fn(),
         useSetBucketPolicy: jest.fn(),
+        useDeleteBucketPolicy: jest.fn(),
         useISVBucketStatus: jest.fn(),
         useBucketConfigEditor: jest.requireActual('../../hooks').useBucketConfigEditor
     }));
-jest.mock('../Editor', ()=>({
+jest.mock('@scality/core-ui/dist/next', ()=>({
+        ...jest.requireActual('@scality/core-ui/dist/next'),
         Editor: ({ value, onChange })=>/*#__PURE__*/ jsx("textarea", {
                 "data-testid": "policy-editor",
                 value: value,
@@ -19,13 +22,10 @@ jest.mock('../Editor', ()=>({
     }));
 const mockUseGetBucketPolicy = jest.mocked(useGetBucketPolicy);
 const mockUseSetBucketPolicy = jest.mocked(useSetBucketPolicy);
+const mockUseDeleteBucketPolicy = jest.mocked(useDeleteBucketPolicy);
 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 createNoSuchPolicyError = ()=>new EnhancedS3Error('Policy does not exist', 'NoSuchBucketPolicy', ErrorCategory.NOT_FOUND, new Error('Policy does not exist'), 404);
 const mockNoPolicyExists = ()=>{
     mockUseGetBucketPolicy.mockReturnValue(createMockQueryResult({
         status: 'error',
@@ -66,10 +66,12 @@ const renderBucketPolicyPage = (bucketName = 'test-bucket')=>{
 };
 describe('BucketPolicyPage', ()=>{
     const mockMutate = jest.fn();
+    const mockDeleteMutate = jest.fn();
     beforeEach(()=>{
         jest.clearAllMocks();
         mockNavigate.mockClear();
         mockUseSetBucketPolicy.mockReturnValue(createMockMutationResult(mockMutate));
+        mockUseDeleteBucketPolicy.mockReturnValue(createMockMutationResult(mockDeleteMutate));
         mockUseISVBucketStatus.mockReturnValue({
             isVeeamBucket: false,
             isCommvaultBucket: false,
@@ -87,14 +89,31 @@ describe('BucketPolicyPage', ()=>{
         renderBucketPolicyPage();
         expect(screen.getByText('Loading policy...')).toBeInTheDocument();
     });
-    it('renders create mode with default policy template when no policy exists', async ()=>{
+    it('renders create mode with empty editor when no policy exists', async ()=>{
         mockNoPolicyExists();
         renderBucketPolicyPage();
         await waitFor(()=>{
             expect(screen.getByText('Create Bucket Policy')).toBeInTheDocument();
         });
         const editor = screen.getByTestId('policy-editor');
-        expect(editor.value).toContain('ExampleStatement');
+        expect(editor.value).toBe('');
+        expect(screen.getByText('Empty bucket policy')).toBeInTheDocument();
+    });
+    it('loads standard template when clicking the template button', async ()=>{
+        mockNoPolicyExists();
+        renderBucketPolicyPage();
+        await waitFor(()=>{
+            expect(screen.getByText('Empty bucket policy')).toBeInTheDocument();
+        });
+        fireEvent.click(screen.getByRole('button', {
+            name: /Load a template/i
+        }));
+        await waitFor(()=>{
+            const editor = screen.getByTestId('policy-editor');
+            expect(editor.value).toContain('ExampleStatement');
+            expect(editor.value).toContain('s3:GetObject');
+        });
+        expect(screen.queryByText('Empty bucket policy')).not.toBeInTheDocument();
     });
     it('renders edit mode with existing policy', async ()=>{
         mockUseGetBucketPolicy.mockReturnValue(createMockQueryResult({
@@ -194,7 +213,43 @@ describe('BucketPolicyPage', ()=>{
         });
         expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket');
     });
-    it('shows loading state when ISV bucket status is loading', ()=>{
+    it('deletes bucket policy when saving empty content', async ()=>{
+        mockUseGetBucketPolicy.mockReturnValue(createMockQueryResult({
+            data: {
+                Policy: JSON.stringify(existingPolicy),
+                $metadata: {}
+            },
+            status: 'success'
+        }));
+        renderBucketPolicyPage();
+        const editor = await screen.findByTestId('policy-editor');
+        await waitFor(()=>{
+            expect(editor.value).toContain('ExistingStatement');
+        });
+        fireEvent.change(editor, {
+            target: {
+                value: ''
+            }
+        });
+        mockDeleteMutate.mockImplementation((_, options)=>{
+            options?.onSuccess?.();
+        });
+        await waitFor(()=>{
+            expect(screen.getByRole('button', {
+                name: /save/i
+            })).not.toBeDisabled();
+        });
+        fireEvent.click(screen.getByRole('button', {
+            name: /save/i
+        }));
+        await waitFor(()=>{
+            expect(mockDeleteMutate).toHaveBeenCalledWith({
+                Bucket: 'test-bucket'
+            }, expect.any(Object));
+            expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket');
+        });
+    });
+    it('renders nothing while ISV bucket status is loading', ()=>{
         mockUseGetBucketPolicy.mockReturnValue(createMockQueryResult({
             status: 'success',
             data: {
@@ -212,9 +267,10 @@ describe('BucketPolicyPage', ()=>{
             bucketTagsStatus: 'pending'
         });
         renderBucketPolicyPage();
-        expect(screen.getByText('Loading policy...')).toBeInTheDocument();
+        expect(screen.queryByText('Loading policy...')).not.toBeInTheDocument();
+        expect(screen.queryByTestId('policy-editor')).not.toBeInTheDocument();
     });
-    it('displays warning banner when bucket is managed by Veeam', async ()=>{
+    it('redirects to bucket overview when bucket is ISV-managed', ()=>{
         mockNoPolicyExists();
         mockUseISVBucketStatus.mockReturnValue({
             isVeeamBucket: true,
@@ -226,45 +282,8 @@ describe('BucketPolicyPage', ()=>{
             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,
-            isKastenBucket: false,
-            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,
-            isKastenBucket: false,
-            isISVManaged: false,
-            isvApplication: void 0,
-            isLoading: false,
-            bucketTagsStatus: 'success'
-        });
-        renderBucketPolicyPage();
-        await waitFor(()=>{
-            expect(screen.getByTestId('policy-editor')).toBeInTheDocument();
+        expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket', {
+            replace: true
         });
-        expect(screen.queryByText((_content, element)=>element?.textContent?.includes('This bucket is managed by') || false)).not.toBeInTheDocument();
     });
 });