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

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

@@ -1,479 +1,784 @@
-import { jsx } from "react/jsx-runtime";
+import { jsx, jsxs } 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");
+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 { BucketOverview, useBucketOverviewContext } from "../buckets/BucketOverview.js";
+import * as __rspack_external__contexts_DataBrowserUICustomizationContext_js_f267b01c from "../../contexts/DataBrowserUICustomizationContext.js";
+jest.mock('../../hooks');
+jest.mock('../../hooks/useFeatures');
 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 mockUseGetBucketTagging = jest.mocked(useGetBucketTagging);
+const mockUseISVBucketStatus = jest.mocked(useISVBucketStatus);
+const mockUseFeatures = jest.mocked(useFeatures);
+const mockUseDataBrowserUICustomization = (config = {})=>{
+    jest.spyOn(__rspack_external__contexts_DataBrowserUICustomizationContext_js_f267b01c, 'useDataBrowserUICustomization').mockReturnValue(config);
+};
 const renderBucketOverview = (props = {})=>{
+    const { bucketName = 'test-bucket', onEmptyBucket, onDeleteBucket, onEditPolicy, renderEmptyButton, renderDeleteButton, isEmptyBucketDisabled, isDeleteBucketDisabled } = props;
     const Wrapper = createTestWrapper();
-    return render(/*#__PURE__*/ jsx(Wrapper, {
-        children: /*#__PURE__*/ jsx(BucketOverview, {
-            bucketName: "test-bucket",
-            ...props
+    return render(/*#__PURE__*/ jsx(MemoryRouter, {
+        children: /*#__PURE__*/ jsx(Wrapper, {
+            children: /*#__PURE__*/ jsxs(BucketOverview, {
+                bucketName: bucketName,
+                children: [
+                    /*#__PURE__*/ jsx(BucketOverview.Actions, {
+                        onEmptyBucket: onEmptyBucket,
+                        onDeleteBucket: onDeleteBucket,
+                        renderEmptyButton: renderEmptyButton,
+                        renderDeleteButton: renderDeleteButton,
+                        isEmptyBucketDisabled: isEmptyBucketDisabled,
+                        isDeleteBucketDisabled: isDeleteBucketDisabled
+                    }),
+                    /*#__PURE__*/ jsxs(BucketOverview.Sections, {
+                        children: [
+                            /*#__PURE__*/ jsx(BucketOverview.GeneralSection, {}),
+                            /*#__PURE__*/ jsx(BucketOverview.DataProtectionSection, {}),
+                            /*#__PURE__*/ jsx(BucketOverview.PermissionsSection, {
+                                onEditPolicy: onEditPolicy
+                            })
+                        ]
+                    })
+                ]
+            })
         })
     }));
 };
-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"
-    });
+const mockHookDefaults = (overrides = {})=>{
+    applyBucketMocks({
+        useGetBucketVersioning: mockUseGetBucketVersioning,
+        useGetBucketAcl: mockUseGetBucketAcl,
+        useGetBucketLocation: mockUseGetBucketLocation,
+        useGetBucketCors: mockUseGetBucketCors,
+        useGetBucketObjectLockConfiguration: mockUseGetBucketObjectLockConfiguration,
+        useGetBucketPolicy: mockUseGetBucketPolicy,
+        useGetBucketTagging: mockUseGetBucketTagging,
+        useISVBucketStatus: mockUseISVBucketStatus,
+        useFeatures: mockUseFeatures
+    }, overrides);
 };
-describe("BucketOverview", ()=>{
+describe('BucketOverview', ()=>{
     beforeEach(()=>{
         jest.clearAllMocks();
         mockHookDefaults();
+        mockUseDataBrowserUICustomization({});
     });
-    it("renders bucket overview with all sections", ()=>{
+    it('renders bucket overview with all sections', ()=>{
         renderBucketOverview();
-        expect(screen.getByText("General")).toBeInTheDocument();
-        expect(screen.getByText("Data protection")).toBeInTheDocument();
-        expect(screen.getByText("Permissions")).toBeInTheDocument();
+        expect(screen.getByText('General')).toBeInTheDocument();
+        expect(screen.getByText('Data protection')).toBeInTheDocument();
+        expect(screen.getByText('Permissions')).toBeInTheDocument();
     });
-    it("displays bucket name correctly", ()=>{
+    it('displays bucket name correctly', ()=>{
         renderBucketOverview({
-            bucketName: "my-test-bucket"
+            bucketName: 'my-test-bucket'
         });
-        expect(screen.getByText("my-test-bucket")).toBeInTheDocument();
+        expect(screen.getByText('my-test-bucket')).toBeInTheDocument();
     });
-    it("shows versioning status when enabled", ()=>{
+    it('shows versioning status when enabled', ()=>{
         mockUseGetBucketVersioning.mockReturnValue({
             data: {
-                Status: "Enabled"
+                Status: 'Enabled'
             },
-            status: "success"
+            status: 'success'
         });
         renderBucketOverview();
-        expect(screen.getByText("Active")).toBeInTheDocument();
+        expect(screen.getByText('Active')).toBeInTheDocument();
     });
-    it("shows versioning status when disabled", ()=>{
+    it('shows versioning status when disabled', ()=>{
         mockUseGetBucketVersioning.mockReturnValue({
             data: {
-                Status: "Suspended"
+                Status: 'Suspended'
             },
-            status: "success"
+            status: 'success'
         });
         renderBucketOverview();
-        expect(screen.getByText("Inactive")).toBeInTheDocument();
+        expect(screen.getByText('Inactive')).toBeInTheDocument();
     });
-    it("displays bucket location", ()=>{
+    it('displays bucket location', ()=>{
         mockUseGetBucketLocation.mockReturnValue({
             data: {
-                LocationConstraint: "eu-west-1"
+                LocationConstraint: 'eu-west-1'
             },
-            status: "success"
+            status: 'success'
         });
         renderBucketOverview();
-        expect(screen.getByText("eu-west-1")).toBeInTheDocument();
+        expect(screen.getByText('eu-west-1')).toBeInTheDocument();
     });
-    it("shows default location when LocationConstraint is null", ()=>{
+    it('shows default location when LocationConstraint is null', ()=>{
         mockUseGetBucketLocation.mockReturnValue({
             data: {
                 LocationConstraint: null
             },
-            status: "success"
+            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('shows default retention as Inactive when not configured', ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: 'Enabled'
+                }
+            },
+            status: 'success'
         });
         renderBucketOverview();
-        expect(screen.getByText("us-east-1")).toBeInTheDocument();
+        expect(screen.getByText('Inactive')).toBeInTheDocument();
     });
-    it("shows object-lock enabled status", ()=>{
+    it('shows default retention with days in Governance mode', ()=>{
         mockUseGetBucketObjectLockConfiguration.mockReturnValue({
             data: {
                 ObjectLockConfiguration: {
-                    ObjectLockEnabled: "Enabled"
+                    ObjectLockEnabled: 'Enabled',
+                    Rule: {
+                        DefaultRetention: {
+                            Mode: 'GOVERNANCE',
+                            Days: 30
+                        }
+                    }
                 }
             },
-            status: "success"
+            status: 'success'
         });
         renderBucketOverview();
-        expect(screen.getByText("Enabled")).toBeInTheDocument();
+        expect(screen.getByText('Governance - 30 days')).toBeInTheDocument();
     });
-    it("shows object-lock disabled status", ()=>{
+    it('shows default retention with single day', ()=>{
         mockUseGetBucketObjectLockConfiguration.mockReturnValue({
             data: {
                 ObjectLockConfiguration: {
-                    ObjectLockEnabled: "Disabled"
+                    ObjectLockEnabled: 'Enabled',
+                    Rule: {
+                        DefaultRetention: {
+                            Mode: 'COMPLIANCE',
+                            Days: 1
+                        }
+                    }
                 }
             },
-            status: "success"
+            status: 'success'
         });
         renderBucketOverview();
-        expect(screen.getByText("Disabled")).toBeInTheDocument();
+        expect(screen.getByText('Compliance - 1 day')).toBeInTheDocument();
     });
-    it("displays bucket owner from ACL", ()=>{
+    it('shows default retention with years in Compliance mode', ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: 'Enabled',
+                    Rule: {
+                        DefaultRetention: {
+                            Mode: 'COMPLIANCE',
+                            Years: 7
+                        }
+                    }
+                }
+            },
+            status: 'success'
+        });
+        renderBucketOverview();
+        expect(screen.getByText('Compliance - 7 years')).toBeInTheDocument();
+    });
+    it('shows default retention with single year', ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: 'Enabled',
+                    Rule: {
+                        DefaultRetention: {
+                            Mode: 'GOVERNANCE',
+                            Years: 1
+                        }
+                    }
+                }
+            },
+            status: 'success'
+        });
+        renderBucketOverview();
+        expect(screen.getByText('Governance - 1 year')).toBeInTheDocument();
+    });
+    it('shows edit retention button when object lock is enabled', ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: 'Enabled',
+                    Rule: {
+                        DefaultRetention: {
+                            Mode: 'GOVERNANCE',
+                            Days: 30
+                        }
+                    }
+                }
+            },
+            status: 'success'
+        });
+        renderBucketOverview();
+        const editButton = screen.getByRole('button', {
+            name: /edit default retention/i
+        });
+        expect(editButton).toBeInTheDocument();
+    });
+    it('does not show edit retention button when object lock is disabled', ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: 'Disabled'
+                }
+            },
+            status: 'success'
+        });
+        renderBucketOverview();
+        const editButton = screen.queryByRole('button', {
+            name: /edit default retention/i
+        });
+        expect(editButton).not.toBeInTheDocument();
+    });
+    it('displays bucket owner from ACL', ()=>{
         mockUseGetBucketAcl.mockReturnValue({
             data: {
                 Owner: {
-                    DisplayName: "bucket-owner"
+                    DisplayName: 'bucket-owner'
                 },
                 Grants: []
             },
-            status: "success"
+            status: 'success'
         });
         renderBucketOverview();
-        expect(screen.getByText("bucket-owner")).toBeInTheDocument();
+        expect(screen.getByText('bucket-owner')).toBeInTheDocument();
     });
-    it("shows ACL grantees count", ()=>{
+    it('shows ACL grantees count', ()=>{
         mockUseGetBucketAcl.mockReturnValue({
             data: {
                 Owner: {
-                    DisplayName: "owner"
+                    DisplayName: 'owner'
                 },
                 Grants: [
                     {
                         Grantee: {
-                            DisplayName: "user1"
+                            DisplayName: 'user1'
                         }
                     },
                     {
                         Grantee: {
-                            DisplayName: "user2"
+                            DisplayName: 'user2'
                         }
                     },
                     {
                         Grantee: {
-                            DisplayName: "user3"
+                            DisplayName: 'user3'
                         }
                     }
                 ]
             },
-            status: "success"
+            status: 'success'
         });
         renderBucketOverview();
-        expect(screen.getByText("3 Grantees")).toBeInTheDocument();
+        expect(screen.getByText('3 Grantees')).toBeInTheDocument();
     });
-    it("shows single grantee without plural", ()=>{
+    it('shows single grantee without plural', ()=>{
         mockUseGetBucketAcl.mockReturnValue({
             data: {
                 Owner: {
-                    DisplayName: "owner"
+                    DisplayName: 'owner'
                 },
                 Grants: [
                     {
                         Grantee: {
-                            DisplayName: "user1"
+                            DisplayName: 'user1'
                         }
                     }
                 ]
             },
-            status: "success"
+            status: 'success'
         });
         renderBucketOverview();
-        expect(screen.getByText("1 Grantee")).toBeInTheDocument();
+        expect(screen.getByText('1 Grantee')).toBeInTheDocument();
     });
-    it("shows CORS enabled when rules exist", ()=>{
+    it('shows CORS enabled when rules exist', ()=>{
         mockUseGetBucketCors.mockReturnValue({
             data: {
                 CORSRules: [
                     {
                         AllowedMethods: [
-                            "GET"
+                            'GET'
                         ],
                         AllowedOrigins: [
-                            "*"
+                            '*'
                         ]
                     }
                 ]
             },
-            status: "success"
+            status: 'success',
+            error: null
         });
         renderBucketOverview();
-        expect(screen.getByText("Yes")).toBeInTheDocument();
+        const yesElements = screen.getAllByText('Yes');
+        expect(yesElements.length).toBeGreaterThanOrEqual(1);
     });
-    it("shows CORS disabled when no rules exist", ()=>{
+    it('shows CORS disabled when no rules exist', ()=>{
         mockUseGetBucketCors.mockReturnValue({
             data: {
                 CORSRules: []
             },
-            status: "success"
+            status: 'success',
+            error: null
         });
         renderBucketOverview();
-        const corsValues = screen.getAllByText("No");
-        expect(corsValues.length).toBeGreaterThan(0);
+        const noElements = screen.getAllByText('No');
+        expect(noElements.length).toBeGreaterThanOrEqual(1);
     });
-    it("detects public bucket from ACL grants", ()=>{
+    it('detects public bucket from ACL grants', ()=>{
         mockUseGetBucketAcl.mockReturnValue({
             data: {
                 Owner: {
-                    DisplayName: "owner"
+                    DisplayName: 'owner'
                 },
                 Grants: [
                     {
                         Grantee: {
-                            URI: "http://acs.amazonaws.com/groups/global/AllUsers"
+                            URI: 'http://acs.amazonaws.com/groups/global/AllUsers'
                         },
-                        Permission: "READ"
+                        Permission: 'READ'
                     }
                 ]
             },
-            status: "success"
+            status: 'success'
         });
         renderBucketOverview();
-        expect(screen.getByText("Yes")).toBeInTheDocument();
+        expect(screen.getByText('Yes')).toBeInTheDocument();
     });
-    it("shows non-public bucket when no public grants", ()=>{
+    it('shows non-public bucket when no public grants', ()=>{
         mockUseGetBucketAcl.mockReturnValue({
             data: {
                 Owner: {
-                    DisplayName: "owner"
+                    DisplayName: 'owner'
                 },
                 Grants: [
                     {
                         Grantee: {
-                            DisplayName: "private-user"
+                            DisplayName: 'private-user'
                         },
-                        Permission: "READ"
+                        Permission: 'READ'
                     }
                 ]
             },
-            status: "success"
+            status: 'success'
         });
         renderBucketOverview();
-        const publicValues = screen.getAllByText("No");
+        const publicValues = screen.getAllByText('No');
         expect(publicValues.length).toBeGreaterThan(0);
     });
-    it("shows loading states while data is being fetched", ()=>{
+    it('shows loading states while data is being fetched', ()=>{
         mockUseGetBucketVersioning.mockReturnValue({
             data: void 0,
-            status: "pending"
+            status: 'pending'
         });
         mockUseGetBucketAcl.mockReturnValue({
             data: void 0,
-            status: "pending"
+            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", ()=>{
+    it('shows error states when API calls fail', ()=>{
         mockUseGetBucketVersioning.mockReturnValue({
             data: void 0,
-            status: "error"
+            status: 'error'
         });
         mockUseGetBucketLocation.mockReturnValue({
             data: void 0,
-            status: "error"
+            status: 'error'
         });
         renderBucketOverview();
-        const errorElements = screen.getAllByText("Error");
+        const errorElements = screen.getAllByText('Error');
         expect(errorElements.length).toBeGreaterThan(0);
     });
-    it("handles empty bucket button click", ()=>{
+    it('handles empty bucket button click', ()=>{
         const onEmptyBucket = jest.fn();
         renderBucketOverview({
             onEmptyBucket,
             isEmptyBucketDisabled: false
         });
-        const emptyButton = screen.getByRole("button", {
+        const emptyButton = screen.getByRole('button', {
             name: /empty bucket/i
         });
         fireEvent.click(emptyButton);
         expect(onEmptyBucket).toHaveBeenCalled();
     });
-    it("handles delete bucket button click", ()=>{
+    it('handles delete bucket button click', ()=>{
         const onDeleteBucket = jest.fn();
         renderBucketOverview({
             onDeleteBucket
         });
-        const deleteButton = screen.getByRole("button", {
+        const deleteButton = screen.getByRole('button', {
             name: /delete bucket/i
         });
         fireEvent.click(deleteButton);
         expect(onDeleteBucket).toHaveBeenCalled();
     });
-    it("disables empty button when specified", ()=>{
+    it('disables empty button when specified', ()=>{
         renderBucketOverview({
             isEmptyBucketDisabled: true
         });
-        const emptyButton = screen.getByRole("button", {
+        const emptyButton = screen.getByRole('button', {
             name: /empty bucket/i
         });
         expect(emptyButton).toBeDisabled();
     });
-    it("disables delete button when specified", ()=>{
+    it('disables delete button when specified', ()=>{
         renderBucketOverview({
             isDeleteBucketDisabled: true
         });
-        const deleteButton = screen.getByRole("button", {
+        const deleteButton = screen.getByRole('button', {
             name: /delete bucket/i
         });
         expect(deleteButton).toBeDisabled();
     });
-    it("renders custom empty button when provided", ()=>{
+    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");
+        expect(screen.getByText('Custom Empty Button')).toBeInTheDocument();
+        expect(renderEmptyButton).toHaveBeenCalledWith('test-bucket');
     });
-    it("renders custom delete button when provided", ()=>{
+    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");
+        expect(screen.getByText('Custom Delete Button')).toBeInTheDocument();
+        expect(renderDeleteButton).toHaveBeenCalledWith('test-bucket');
     });
-    it("works when no callbacks are provided", ()=>{
+    it('works when no callbacks are provided', ()=>{
         expect(()=>{
             renderBucketOverview();
-            const emptyButton = screen.getByRole("button", {
+            const emptyButton = screen.getByRole('button', {
                 name: /empty bucket/i
             });
-            const deleteButton = screen.getByRole("button", {
+            const deleteButton = screen.getByRole('button', {
                 name: /delete bucket/i
             });
             fireEvent.click(emptyButton);
             fireEvent.click(deleteButton);
         }).not.toThrow();
     });
-    it("handles missing ACL data gracefully", ()=>{
+    it('handles missing ACL data gracefully', ()=>{
         mockUseGetBucketAcl.mockReturnValue({
             data: void 0,
-            status: "success"
+            status: 'success'
         });
         renderBucketOverview();
-        const naElements = screen.getAllByText("N/A");
+        const naElements = screen.getAllByText('N/A');
         expect(naElements.length).toBeGreaterThan(0);
     });
-    it("handles missing versioning data gracefully", ()=>{
+    it('handles missing versioning data gracefully', ()=>{
         mockUseGetBucketVersioning.mockReturnValue({
             data: void 0,
-            status: "success"
+            status: 'success'
         });
         renderBucketOverview();
-        expect(screen.getByText("Inactive")).toBeInTheDocument();
+        expect(screen.getByText('Inactive')).toBeInTheDocument();
     });
-    it("handles CORS error state", ()=>{
+    it('handles CORS error state', ()=>{
         mockUseGetBucketCors.mockReturnValue({
             data: void 0,
-            status: "error"
+            status: 'error'
         });
         renderBucketOverview();
-        const corsValues = screen.getAllByText("No");
+        const corsValues = screen.getAllByText('No');
         expect(corsValues.length).toBeGreaterThan(0);
     });
-    it("handles object lock error state", ()=>{
+    it('handles object lock error state (404 - not configured)', ()=>{
+        const notFoundError = new Error('Object Lock configuration does not exist');
+        notFoundError.name = 'NoSuchBucketObjectLockConfiguration';
+        notFoundError.$metadata = {
+            httpStatusCode: 404
+        };
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: void 0,
+            status: 'error',
+            error: notFoundError
+        });
+        renderBucketOverview();
+        expect(screen.getByText('Disabled')).toBeInTheDocument();
+    });
+    it('handles object lock real error state (non-404)', ()=>{
+        const accessDeniedError = new Error('Access Denied');
+        accessDeniedError.name = 'AccessDenied';
+        accessDeniedError.$metadata = {
+            httpStatusCode: 403
+        };
         mockUseGetBucketObjectLockConfiguration.mockReturnValue({
             data: void 0,
-            status: "error"
+            status: 'error',
+            error: accessDeniedError
         });
         renderBucketOverview();
-        expect(screen.getByText("Disabled")).toBeInTheDocument();
+        expect(screen.getByText('Error')).toBeInTheDocument();
     });
-    describe("Bucket Policy", ()=>{
+    describe('Bucket Policy', ()=>{
         it("shows 'Configured' when policy exists", ()=>{
             mockUseGetBucketPolicy.mockReturnValue({
                 data: {
                     Policy: '{"Version":"2012-10-17","Statement":[]}'
                 },
                 error: null,
-                status: "success"
+                status: 'success'
             });
             renderBucketOverview();
-            expect(screen.getByText("Configured")).toBeInTheDocument();
+            expect(screen.getByText('Configured')).toBeInTheDocument();
         });
         it("shows 'Not configured' when no policy exists", ()=>{
             mockUseGetBucketPolicy.mockReturnValue({
                 data: void 0,
                 error: null,
-                status: "success"
+                status: 'success'
             });
             renderBucketOverview();
-            expect(screen.getByText("Not configured")).toBeInTheDocument();
+            const notConfiguredElements = screen.getAllByText('Not configured');
+            expect(notConfiguredElements.length).toBeGreaterThanOrEqual(1);
         });
         it("shows 'Error' when policy fetch fails with non-NoSuchBucketPolicy error", ()=>{
-            const genericError = new Error("Network error");
+            const genericError = new Error('Network error');
             mockUseGetBucketPolicy.mockReturnValue({
                 data: void 0,
                 error: genericError,
-                status: "error"
+                status: 'error'
             });
             renderBucketOverview();
-            const errorElements = screen.getAllByText("Error");
+            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";
+            const noSuchPolicyError = new Error('Policy does not exist');
+            noSuchPolicyError.name = 'NoSuchBucketPolicy';
             mockUseGetBucketPolicy.mockReturnValue({
                 data: void 0,
                 error: noSuchPolicyError,
-                status: "error"
+                status: 'error'
             });
             renderBucketOverview();
-            expect(screen.getByText("Not configured")).toBeInTheDocument();
+            const notConfiguredElements = screen.getAllByText('Not configured');
+            expect(notConfiguredElements.length).toBeGreaterThanOrEqual(1);
         });
-        it("calls onEditPolicy when edit button is clicked", ()=>{
+        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"
+                status: 'success'
             });
             renderBucketOverview({
                 onEditPolicy
             });
-            const editButton = screen.getByRole("button", {
-                name: /edit/i
-            });
-            fireEvent.click(editButton);
-            expect(onEditPolicy).toHaveBeenCalledWith("test-bucket");
+            fireEvent.click(screen.getByRole('button', {
+                name: 'Edit bucket policy'
+            }));
+            expect(onEditPolicy).toHaveBeenCalledWith('test-bucket');
+        });
+    });
+    describe('Extra Sections', ()=>{
+        it('renders extra sections between General and Data Protection', ()=>{
+            const Wrapper = createTestWrapper();
+            const extraSections = [
+                {
+                    id: 'custom-section',
+                    title: 'Custom Section',
+                    render: ()=>/*#__PURE__*/ jsx("div", {
+                            children: "Custom content"
+                        })
+                }
+            ];
+            render(/*#__PURE__*/ jsx(MemoryRouter, {
+                children: /*#__PURE__*/ jsx(Wrapper, {
+                    children: /*#__PURE__*/ jsxs(BucketOverview, {
+                        bucketName: "test-bucket",
+                        children: [
+                            /*#__PURE__*/ jsx(BucketOverview.Actions, {}),
+                            /*#__PURE__*/ jsxs(BucketOverview.Sections, {
+                                children: [
+                                    /*#__PURE__*/ jsx(BucketOverview.GeneralSection, {}),
+                                    extraSections.map((section)=>/*#__PURE__*/ jsx(BucketOverview.Section, {
+                                            title: section.title,
+                                            children: section.render()
+                                        }, section.id)),
+                                    /*#__PURE__*/ jsx(BucketOverview.DataProtectionSection, {}),
+                                    /*#__PURE__*/ jsx(BucketOverview.PermissionsSection, {})
+                                ]
+                            })
+                        ]
+                    })
+                })
+            }));
+            expect(screen.getByText('Custom Section')).toBeInTheDocument();
+            expect(screen.getByText('Custom content')).toBeInTheDocument();
+        });
+        it('extra sections have access to BucketOverview context', ()=>{
+            const CustomSectionContent = ()=>{
+                const { bucketName } = useBucketOverviewContext();
+                return /*#__PURE__*/ jsxs("div", {
+                    children: [
+                        "Bucket name from context: ",
+                        bucketName
+                    ]
+                });
+            };
+            const Wrapper = createTestWrapper();
+            const extraSections = [
+                {
+                    id: 'context-section',
+                    title: 'Context Test',
+                    render: ()=>/*#__PURE__*/ jsx(CustomSectionContent, {})
+                }
+            ];
+            render(/*#__PURE__*/ jsx(MemoryRouter, {
+                children: /*#__PURE__*/ jsx(Wrapper, {
+                    children: /*#__PURE__*/ jsxs(BucketOverview, {
+                        bucketName: "my-custom-bucket",
+                        children: [
+                            /*#__PURE__*/ jsx(BucketOverview.Actions, {}),
+                            /*#__PURE__*/ jsxs(BucketOverview.Sections, {
+                                children: [
+                                    /*#__PURE__*/ jsx(BucketOverview.GeneralSection, {}),
+                                    extraSections.map((section)=>/*#__PURE__*/ jsx(BucketOverview.Section, {
+                                            title: section.title,
+                                            children: section.render()
+                                        }, section.id)),
+                                    /*#__PURE__*/ jsx(BucketOverview.DataProtectionSection, {}),
+                                    /*#__PURE__*/ jsx(BucketOverview.PermissionsSection, {})
+                                ]
+                            })
+                        ]
+                    })
+                })
+            }));
+            expect(screen.getByText('Bucket name from context: my-custom-bucket')).toBeInTheDocument();
+        });
+    });
+    describe('Field Overrides', ()=>{
+        it('renders slot-based field override', ()=>{
+            const Wrapper = createTestWrapper();
+            render(/*#__PURE__*/ jsx(MemoryRouter, {
+                children: /*#__PURE__*/ jsx(Wrapper, {
+                    children: /*#__PURE__*/ jsxs(BucketOverview, {
+                        bucketName: "test-bucket",
+                        children: [
+                            /*#__PURE__*/ jsx(BucketOverview.Actions, {}),
+                            /*#__PURE__*/ jsxs(BucketOverview.Sections, {
+                                children: [
+                                    /*#__PURE__*/ jsx(BucketOverview.GeneralSection, {
+                                        locationField: /*#__PURE__*/ jsx("span", {
+                                            children: "Custom Location Content"
+                                        })
+                                    }),
+                                    /*#__PURE__*/ jsx(BucketOverview.DataProtectionSection, {}),
+                                    /*#__PURE__*/ jsx(BucketOverview.PermissionsSection, {})
+                                ]
+                            })
+                        ]
+                    })
+                })
+            }));
+            expect(screen.getByText('Custom Location Content')).toBeInTheDocument();
+            expect(screen.getByText('test-bucket')).toBeInTheDocument();
+        });
+        it('renders render prop field override', ()=>{
+            const Wrapper = createTestWrapper();
+            render(/*#__PURE__*/ jsx(MemoryRouter, {
+                children: /*#__PURE__*/ jsx(Wrapper, {
+                    children: /*#__PURE__*/ jsxs(BucketOverview, {
+                        bucketName: "test-bucket",
+                        children: [
+                            /*#__PURE__*/ jsx(BucketOverview.Actions, {}),
+                            /*#__PURE__*/ jsxs(BucketOverview.Sections, {
+                                children: [
+                                    /*#__PURE__*/ jsx(BucketOverview.GeneralSection, {
+                                        renderVersioning: (name)=>/*#__PURE__*/ jsxs("span", {
+                                                children: [
+                                                    "Custom Versioning for ",
+                                                    name
+                                                ]
+                                            })
+                                    }),
+                                    /*#__PURE__*/ jsx(BucketOverview.DataProtectionSection, {}),
+                                    /*#__PURE__*/ jsx(BucketOverview.PermissionsSection, {})
+                                ]
+                            })
+                        ]
+                    })
+                })
+            }));
+            expect(screen.getByText('Custom Versioning for test-bucket')).toBeInTheDocument();
+        });
+        it('prioritizes slot prop over render prop over default', ()=>{
+            const Wrapper = createTestWrapper();
+            const renderName = jest.fn(()=>/*#__PURE__*/ jsx("span", {
+                    children: "Render Prop Name"
+                }));
+            render(/*#__PURE__*/ jsx(MemoryRouter, {
+                children: /*#__PURE__*/ jsx(Wrapper, {
+                    children: /*#__PURE__*/ jsxs(BucketOverview, {
+                        bucketName: "test-bucket",
+                        children: [
+                            /*#__PURE__*/ jsx(BucketOverview.Actions, {}),
+                            /*#__PURE__*/ jsxs(BucketOverview.Sections, {
+                                children: [
+                                    /*#__PURE__*/ jsx(BucketOverview.GeneralSection, {
+                                        nameField: /*#__PURE__*/ jsx("span", {
+                                            children: "Slot Prop Name"
+                                        }),
+                                        renderName: renderName
+                                    }),
+                                    /*#__PURE__*/ jsx(BucketOverview.DataProtectionSection, {}),
+                                    /*#__PURE__*/ jsx(BucketOverview.PermissionsSection, {})
+                                ]
+                            })
+                        ]
+                    })
+                })
+            }));
+            expect(screen.getByText('Slot Prop Name')).toBeInTheDocument();
+            expect(renderName).not.toHaveBeenCalled();
         });
     });
 });