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

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

@@ -1,21 +1,70 @@
-import { jsx } from "react/jsx-runtime";
+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, useGetBucketVersioning } from "../../hooks/index.js";
+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();
-    return render(/*#__PURE__*/ jsx(Wrapper, {
-        children: /*#__PURE__*/ jsx(BucketOverview, {
-            bucketName: "test-bucket",
-            ...props
+    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
+                            })
+                        ]
+                    })
+                ]
+            })
         })
     }));
 };
@@ -66,6 +115,21 @@ const mockHookDefaults = ()=>{
         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(()=>{
@@ -148,6 +212,126 @@ describe("BucketOverview", ()=>{
         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: {
@@ -406,14 +590,34 @@ describe("BucketOverview", ()=>{
         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"
+            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({
@@ -476,4 +680,90 @@ describe("BucketOverview", ()=>{
             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();
+        });
+    });
 });

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

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