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

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

@@ -0,0 +1,769 @@
+import * as __WEBPACK_EXTERNAL_MODULE_react_router_dom_5358f3fe__ from "react-router-dom";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { useGetBucketAcl, useGetBucketCors, useGetBucketLocation, useGetBucketObjectLockConfiguration, useGetBucketPolicy, useGetBucketTagging, useGetBucketVersioning, useISVBucketStatus } from "../../hooks/index.js";
+import { createTestWrapper } from "../../test/testUtils.js";
+import { BucketOverview } from "../buckets/BucketOverview.js";
+import { useFeatures } from "../../utils/useFeatures.js";
+var __webpack_modules__ = {
+    "react-router-dom": function(module) {
+        module.exports = __WEBPACK_EXTERNAL_MODULE_react_router_dom_5358f3fe__;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+var external_react_router_dom_ = __webpack_require__("react-router-dom");
+jest.mock("../../hooks");
+jest.mock("../../utils/useFeatures");
+jest.mock("react-router-dom", ()=>({
+        ...jest.requireActual("react-router-dom"),
+        useNavigate: jest.fn()
+    }));
+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 renderBucketOverview = (props = {})=>{
+    const { bucketName = "test-bucket", onEmptyBucket, onDeleteBucket, onEditPolicy, renderEmptyButton, renderDeleteButton, isEmptyBucketDisabled, isDeleteBucketDisabled } = props;
+    const Wrapper = createTestWrapper();
+    const mockNavigate = jest.fn();
+    __webpack_require__("react-router-dom").useNavigate.mockReturnValue(mockNavigate);
+    return render(/*#__PURE__*/ jsx(external_react_router_dom_.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"
+    });
+    mockUseGetBucketTagging.mockReturnValue({
+        data: {
+            TagSet: []
+        },
+        status: "success"
+    });
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: false,
+        isCommvaultBucket: false,
+        isISVManaged: false,
+        isvApplication: void 0,
+        isLoading: false,
+        bucketTagsStatus: "success"
+    });
+    mockUseFeatures.mockReturnValue(false);
+};
+describe("BucketOverview", ()=>{
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockHookDefaults();
+    });
+    it("renders bucket overview with all sections", ()=>{
+        renderBucketOverview();
+        expect(screen.getByText("General")).toBeInTheDocument();
+        expect(screen.getByText("Data protection")).toBeInTheDocument();
+        expect(screen.getByText("Permissions")).toBeInTheDocument();
+    });
+    it("displays bucket name correctly", ()=>{
+        renderBucketOverview({
+            bucketName: "my-test-bucket"
+        });
+        expect(screen.getByText("my-test-bucket")).toBeInTheDocument();
+    });
+    it("shows versioning status when enabled", ()=>{
+        mockUseGetBucketVersioning.mockReturnValue({
+            data: {
+                Status: "Enabled"
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("Active")).toBeInTheDocument();
+    });
+    it("shows versioning status when disabled", ()=>{
+        mockUseGetBucketVersioning.mockReturnValue({
+            data: {
+                Status: "Suspended"
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("Inactive")).toBeInTheDocument();
+    });
+    it("displays bucket location", ()=>{
+        mockUseGetBucketLocation.mockReturnValue({
+            data: {
+                LocationConstraint: "eu-west-1"
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("eu-west-1")).toBeInTheDocument();
+    });
+    it("shows default location when LocationConstraint is null", ()=>{
+        mockUseGetBucketLocation.mockReturnValue({
+            data: {
+                LocationConstraint: null
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("us-east-1")).toBeInTheDocument();
+    });
+    it("shows object-lock enabled status", ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: "Enabled"
+                }
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("Enabled")).toBeInTheDocument();
+    });
+    it("shows object-lock disabled status", ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: "Disabled"
+                }
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("Disabled")).toBeInTheDocument();
+    });
+    it("shows default retention as Inactive when not configured", ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: "Enabled"
+                }
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("Inactive")).toBeInTheDocument();
+    });
+    it("shows default retention with days in Governance mode", ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: "Enabled",
+                    Rule: {
+                        DefaultRetention: {
+                            Mode: "GOVERNANCE",
+                            Days: 30
+                        }
+                    }
+                }
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("Governance - 30 days")).toBeInTheDocument();
+    });
+    it("shows default retention with single day", ()=>{
+        mockUseGetBucketObjectLockConfiguration.mockReturnValue({
+            data: {
+                ObjectLockConfiguration: {
+                    ObjectLockEnabled: "Enabled",
+                    Rule: {
+                        DefaultRetention: {
+                            Mode: "COMPLIANCE",
+                            Days: 1
+                        }
+                    }
+                }
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("Compliance - 1 day")).toBeInTheDocument();
+    });
+    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"
+                },
+                Grants: []
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("bucket-owner")).toBeInTheDocument();
+    });
+    it("shows ACL grantees count", ()=>{
+        mockUseGetBucketAcl.mockReturnValue({
+            data: {
+                Owner: {
+                    DisplayName: "owner"
+                },
+                Grants: [
+                    {
+                        Grantee: {
+                            DisplayName: "user1"
+                        }
+                    },
+                    {
+                        Grantee: {
+                            DisplayName: "user2"
+                        }
+                    },
+                    {
+                        Grantee: {
+                            DisplayName: "user3"
+                        }
+                    }
+                ]
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("3 Grantees")).toBeInTheDocument();
+    });
+    it("shows single grantee without plural", ()=>{
+        mockUseGetBucketAcl.mockReturnValue({
+            data: {
+                Owner: {
+                    DisplayName: "owner"
+                },
+                Grants: [
+                    {
+                        Grantee: {
+                            DisplayName: "user1"
+                        }
+                    }
+                ]
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("1 Grantee")).toBeInTheDocument();
+    });
+    it("shows CORS enabled when rules exist", ()=>{
+        mockUseGetBucketCors.mockReturnValue({
+            data: {
+                CORSRules: [
+                    {
+                        AllowedMethods: [
+                            "GET"
+                        ],
+                        AllowedOrigins: [
+                            "*"
+                        ]
+                    }
+                ]
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("Yes")).toBeInTheDocument();
+    });
+    it("shows CORS disabled when no rules exist", ()=>{
+        mockUseGetBucketCors.mockReturnValue({
+            data: {
+                CORSRules: []
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        const corsValues = screen.getAllByText("No");
+        expect(corsValues.length).toBeGreaterThan(0);
+    });
+    it("detects public bucket from ACL grants", ()=>{
+        mockUseGetBucketAcl.mockReturnValue({
+            data: {
+                Owner: {
+                    DisplayName: "owner"
+                },
+                Grants: [
+                    {
+                        Grantee: {
+                            URI: "http://acs.amazonaws.com/groups/global/AllUsers"
+                        },
+                        Permission: "READ"
+                    }
+                ]
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("Yes")).toBeInTheDocument();
+    });
+    it("shows non-public bucket when no public grants", ()=>{
+        mockUseGetBucketAcl.mockReturnValue({
+            data: {
+                Owner: {
+                    DisplayName: "owner"
+                },
+                Grants: [
+                    {
+                        Grantee: {
+                            DisplayName: "private-user"
+                        },
+                        Permission: "READ"
+                    }
+                ]
+            },
+            status: "success"
+        });
+        renderBucketOverview();
+        const publicValues = screen.getAllByText("No");
+        expect(publicValues.length).toBeGreaterThan(0);
+    });
+    it("shows loading states while data is being fetched", ()=>{
+        mockUseGetBucketVersioning.mockReturnValue({
+            data: void 0,
+            status: "pending"
+        });
+        mockUseGetBucketAcl.mockReturnValue({
+            data: void 0,
+            status: "pending"
+        });
+        renderBucketOverview();
+        const loaders = document.querySelectorAll('[data-testid="loader"], .loader, [class*="loader"]');
+        expect(loaders.length).toBeGreaterThan(0);
+    });
+    it("shows error states when API calls fail", ()=>{
+        mockUseGetBucketVersioning.mockReturnValue({
+            data: void 0,
+            status: "error"
+        });
+        mockUseGetBucketLocation.mockReturnValue({
+            data: void 0,
+            status: "error"
+        });
+        renderBucketOverview();
+        const errorElements = screen.getAllByText("Error");
+        expect(errorElements.length).toBeGreaterThan(0);
+    });
+    it("handles empty bucket button click", ()=>{
+        const onEmptyBucket = jest.fn();
+        renderBucketOverview({
+            onEmptyBucket,
+            isEmptyBucketDisabled: false
+        });
+        const emptyButton = screen.getByRole("button", {
+            name: /empty bucket/i
+        });
+        fireEvent.click(emptyButton);
+        expect(onEmptyBucket).toHaveBeenCalled();
+    });
+    it("handles delete bucket button click", ()=>{
+        const onDeleteBucket = jest.fn();
+        renderBucketOverview({
+            onDeleteBucket
+        });
+        const deleteButton = screen.getByRole("button", {
+            name: /delete bucket/i
+        });
+        fireEvent.click(deleteButton);
+        expect(onDeleteBucket).toHaveBeenCalled();
+    });
+    it("disables empty button when specified", ()=>{
+        renderBucketOverview({
+            isEmptyBucketDisabled: true
+        });
+        const emptyButton = screen.getByRole("button", {
+            name: /empty bucket/i
+        });
+        expect(emptyButton).toBeDisabled();
+    });
+    it("disables delete button when specified", ()=>{
+        renderBucketOverview({
+            isDeleteBucketDisabled: true
+        });
+        const deleteButton = screen.getByRole("button", {
+            name: /delete bucket/i
+        });
+        expect(deleteButton).toBeDisabled();
+    });
+    it("renders custom empty button when provided", ()=>{
+        const renderEmptyButton = jest.fn(()=>/*#__PURE__*/ jsx("button", {
+                children: "Custom Empty Button"
+            }));
+        renderBucketOverview({
+            renderEmptyButton
+        });
+        expect(screen.getByText("Custom Empty Button")).toBeInTheDocument();
+        expect(renderEmptyButton).toHaveBeenCalledWith("test-bucket");
+    });
+    it("renders custom delete button when provided", ()=>{
+        const renderDeleteButton = jest.fn(()=>/*#__PURE__*/ jsx("button", {
+                children: "Custom Delete Button"
+            }));
+        renderBucketOverview({
+            renderDeleteButton
+        });
+        expect(screen.getByText("Custom Delete Button")).toBeInTheDocument();
+        expect(renderDeleteButton).toHaveBeenCalledWith("test-bucket");
+    });
+    it("works when no callbacks are provided", ()=>{
+        expect(()=>{
+            renderBucketOverview();
+            const emptyButton = screen.getByRole("button", {
+                name: /empty bucket/i
+            });
+            const deleteButton = screen.getByRole("button", {
+                name: /delete bucket/i
+            });
+            fireEvent.click(emptyButton);
+            fireEvent.click(deleteButton);
+        }).not.toThrow();
+    });
+    it("handles missing ACL data gracefully", ()=>{
+        mockUseGetBucketAcl.mockReturnValue({
+            data: void 0,
+            status: "success"
+        });
+        renderBucketOverview();
+        const naElements = screen.getAllByText("N/A");
+        expect(naElements.length).toBeGreaterThan(0);
+    });
+    it("handles missing versioning data gracefully", ()=>{
+        mockUseGetBucketVersioning.mockReturnValue({
+            data: void 0,
+            status: "success"
+        });
+        renderBucketOverview();
+        expect(screen.getByText("Inactive")).toBeInTheDocument();
+    });
+    it("handles CORS error state", ()=>{
+        mockUseGetBucketCors.mockReturnValue({
+            data: void 0,
+            status: "error"
+        });
+        renderBucketOverview();
+        const corsValues = screen.getAllByText("No");
+        expect(corsValues.length).toBeGreaterThan(0);
+    });
+    it("handles object lock error state (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",
+            error: accessDeniedError
+        });
+        renderBucketOverview();
+        expect(screen.getByText("Error")).toBeInTheDocument();
+    });
+    describe("Bucket Policy", ()=>{
+        it("shows 'Configured' when policy exists", ()=>{
+            mockUseGetBucketPolicy.mockReturnValue({
+                data: {
+                    Policy: '{"Version":"2012-10-17","Statement":[]}'
+                },
+                error: null,
+                status: "success"
+            });
+            renderBucketOverview();
+            expect(screen.getByText("Configured")).toBeInTheDocument();
+        });
+        it("shows 'Not configured' when no policy exists", ()=>{
+            mockUseGetBucketPolicy.mockReturnValue({
+                data: void 0,
+                error: null,
+                status: "success"
+            });
+            renderBucketOverview();
+            expect(screen.getByText("Not configured")).toBeInTheDocument();
+        });
+        it("shows 'Error' when policy fetch fails with non-NoSuchBucketPolicy error", ()=>{
+            const genericError = new Error("Network error");
+            mockUseGetBucketPolicy.mockReturnValue({
+                data: void 0,
+                error: genericError,
+                status: "error"
+            });
+            renderBucketOverview();
+            const errorElements = screen.getAllByText("Error");
+            expect(errorElements.length).toBeGreaterThan(0);
+        });
+        it("shows 'Not configured' when policy does not exist (NoSuchBucketPolicy)", ()=>{
+            const noSuchPolicyError = new Error("Policy does not exist");
+            noSuchPolicyError.name = "NoSuchBucketPolicy";
+            mockUseGetBucketPolicy.mockReturnValue({
+                data: void 0,
+                error: noSuchPolicyError,
+                status: "error"
+            });
+            renderBucketOverview();
+            expect(screen.getByText("Not configured")).toBeInTheDocument();
+        });
+        it("calls onEditPolicy when edit button is clicked", ()=>{
+            const onEditPolicy = jest.fn();
+            mockUseGetBucketPolicy.mockReturnValue({
+                data: {
+                    Policy: '{"Version":"2012-10-17","Statement":[]}'
+                },
+                error: null,
+                status: "success"
+            });
+            renderBucketOverview({
+                onEditPolicy
+            });
+            const editButton = screen.getByRole("button", {
+                name: /edit/i
+            });
+            fireEvent.click(editButton);
+            expect(onEditPolicy).toHaveBeenCalledWith("test-bucket");
+        });
+    });
+    describe("Field Overrides", ()=>{
+        it("renders slot-based field override", ()=>{
+            const Wrapper = createTestWrapper();
+            render(/*#__PURE__*/ jsx(external_react_router_dom_.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(external_react_router_dom_.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(external_react_router_dom_.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();
+        });
+    });
+});