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

package/dist/components/objects/ObjectLock/ObjectLockRetentionSettings.js

@@ -0,0 +1,211 @@
+import { Fragment, jsx, jsxs } from "react/jsx-runtime";
+import { Checkbox, FormGroup, FormSection, Stack, Text } from "@scality/core-ui";
+import { convertRemToPixels } from "@scality/core-ui/dist/components/tablev2/TableUtils";
+import { Controller, useFormContext } from "react-hook-form";
+import { Input, Select } from "@scality/core-ui/dist/next";
+function ObjectLockRetentionSettings({ isEditRetentionSettings = false }) {
+    const { control, register, watch, formState: { errors }, setValue } = useFormContext();
+    const isDefaultRetentionEnabled = watch("isDefaultRetentionEnabled");
+    const isObjectLockEnabled = watch("isObjectLockEnabled");
+    const matchVersioning = (checked)=>{
+        if (checked) setValue("isVersioning", true);
+    };
+    return /*#__PURE__*/ jsxs(FormSection, {
+        title: isEditRetentionSettings ? void 0 : {
+            name: "Object-lock"
+        },
+        forceLabelWidth: convertRemToPixels(17.5),
+        children: [
+            /*#__PURE__*/ jsx(FormGroup, {
+                id: "isObjectLockEnabled",
+                label: "Object-lock",
+                content: /*#__PURE__*/ jsx(Checkbox, {
+                    id: "isObjectLockEnabled",
+                    label: isObjectLockEnabled ? "Enabled" : "Disabled",
+                    disabled: isEditRetentionSettings && isObjectLockEnabled,
+                    ...register("isObjectLockEnabled", {
+                        onChange (e) {
+                            matchVersioning(e.target.checked);
+                        }
+                    })
+                }),
+                labelHelpTooltip: /*#__PURE__*/ jsxs("ul", {
+                    children: [
+                        /*#__PURE__*/ jsx("li", {
+                            children: "Permanently allows objects in this bucket to be locked"
+                        }),
+                        /*#__PURE__*/ jsx("li", {
+                            children: "Object-lock option cannot be removed after bucket creation, but you will be able to disable the retention itself on edition."
+                        }),
+                        /*#__PURE__*/ jsx("li", {
+                            children: "Once the bucket is created, you might be blocked from deleting the objects and the bucket."
+                        }),
+                        /*#__PURE__*/ jsx("li", {
+                            children: "Enabling Object-lock automatically activates Versioning for the bucket, and you won’t be able to suspend Versioning."
+                        })
+                    ]
+                }),
+                helpErrorPosition: "bottom",
+                disabled: isEditRetentionSettings
+            }),
+            isObjectLockEnabled && /*#__PURE__*/ jsxs(Fragment, {
+                children: [
+                    /*#__PURE__*/ jsx(FormGroup, {
+                        id: "isDefaultRetentionEnabled",
+                        label: "Default Retention",
+                        helpErrorPosition: "bottom",
+                        labelHelpTooltip: isEditRetentionSettings ? /*#__PURE__*/ jsxs("ul", {
+                            children: [
+                                /*#__PURE__*/ jsx("li", {
+                                    children: "These settings apply only to new objects placed into the bucket without any specific object-lock parameters."
+                                }),
+                                /*#__PURE__*/ jsx("li", {
+                                    children: "Automatically protect objects put into this bucket from being deleted or overwritten."
+                                }),
+                                /*#__PURE__*/ jsx("li", {
+                                    children: "If objects are uploaded into the bucket with their own Retention settings, these will override the Default Retention setting placed on the bucket."
+                                })
+                            ]
+                        }) : /*#__PURE__*/ jsxs("ul", {
+                            children: [
+                                /*#__PURE__*/ jsx("li", {
+                                    children: "Automatically protect objects put into this bucket from being deleted or overwritten."
+                                }),
+                                /*#__PURE__*/ jsx("li", {
+                                    children: "These settings apply only to new objects placed into the bucket without any specific object-lock parameters."
+                                }),
+                                /*#__PURE__*/ jsx("li", {
+                                    children: "You can activate this option after the bucket creation."
+                                }),
+                                /*#__PURE__*/ jsx("li", {
+                                    children: "If objects are uploaded into the bucket with their own Retention settings, these will override the Default Retention setting placed on the bucket."
+                                })
+                            ]
+                        }),
+                        content: /*#__PURE__*/ jsx(Checkbox, {
+                            id: "isDefaultRetentionEnabled",
+                            label: isDefaultRetentionEnabled ? "Active" : "Inactive",
+                            ...register("isDefaultRetentionEnabled")
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(FormGroup, {
+                        id: "objectlockMode",
+                        label: "Retention mode",
+                        direction: "vertical",
+                        disabled: !isDefaultRetentionEnabled,
+                        helpErrorPosition: "bottom",
+                        content: /*#__PURE__*/ jsx("div", {
+                            style: {
+                                opacity: isDefaultRetentionEnabled ? 1 : 0.5
+                            },
+                            children: /*#__PURE__*/ jsxs(Stack, {
+                                direction: "vertical",
+                                children: [
+                                    /*#__PURE__*/ jsxs(Stack, {
+                                        direction: "vertical",
+                                        children: [
+                                            /*#__PURE__*/ jsxs(Stack, {
+                                                children: [
+                                                    /*#__PURE__*/ jsx("input", {
+                                                        id: "locktype-governance",
+                                                        type: "radio",
+                                                        value: "GOVERNANCE",
+                                                        disabled: !isDefaultRetentionEnabled,
+                                                        ...register("retentionMode")
+                                                    }),
+                                                    /*#__PURE__*/ jsx("label", {
+                                                        htmlFor: "locktype-governance",
+                                                        children: "Governance"
+                                                    })
+                                                ]
+                                            }),
+                                            /*#__PURE__*/ jsx(Text, {
+                                                color: "textSecondary",
+                                                isEmphazed: true,
+                                                variant: "Smaller",
+                                                children: "A user with a specific IAM permissions can overwrite/delete protected object versions during the retention period."
+                                            })
+                                        ]
+                                    }),
+                                    /*#__PURE__*/ jsxs(Stack, {
+                                        children: [
+                                            /*#__PURE__*/ jsx("input", {
+                                                id: "locktype-compliance",
+                                                type: "radio",
+                                                value: "COMPLIANCE",
+                                                disabled: !isDefaultRetentionEnabled,
+                                                ...register("retentionMode")
+                                            }),
+                                            /*#__PURE__*/ jsx("label", {
+                                                htmlFor: "locktype-compliance",
+                                                children: "Compliance"
+                                            })
+                                        ]
+                                    }),
+                                    /*#__PURE__*/ jsx(Text, {
+                                        color: "textSecondary",
+                                        isEmphazed: true,
+                                        variant: "Smaller",
+                                        children: "No one can overwrite protected object versions during the retention period."
+                                    })
+                                ]
+                            })
+                        })
+                    }),
+                    /*#__PURE__*/ jsx(FormGroup, {
+                        id: "retentionPeriod",
+                        label: "Retention period",
+                        direction: "horizontal",
+                        helpErrorPosition: "bottom",
+                        help: "Must be a positive whole number.",
+                        error: errors.retentionPeriod?.message,
+                        disabled: !isDefaultRetentionEnabled,
+                        content: /*#__PURE__*/ jsxs(Stack, {
+                            direction: "horizontal",
+                            children: [
+                                /*#__PURE__*/ jsx(Controller, {
+                                    control: control,
+                                    name: "retentionPeriod",
+                                    render: ({ field: { onChange, value: retentionPeriod } })=>/*#__PURE__*/ jsx(Input, {
+                                            id: "retentionPeriod",
+                                            name: "retentionPeriod",
+                                            value: retentionPeriod,
+                                            onChange: (e)=>onChange(e.target.valueAsNumber),
+                                            type: "number",
+                                            step: "1",
+                                            min: "1",
+                                            size: "2/3"
+                                        })
+                                }),
+                                /*#__PURE__*/ jsx(Controller, {
+                                    control: control,
+                                    name: "retentionPeriodFrequencyChoice",
+                                    defaultValue: "DAYS",
+                                    render: ({ field: { onChange, value: retentionPeriodFrequencyChoice } })=>/*#__PURE__*/ jsxs(Select, {
+                                            id: "retentionPeriodFrequencyChoice",
+                                            onChange: onChange,
+                                            placeholder: "retentionPeriodFrequencyChoice",
+                                            value: retentionPeriodFrequencyChoice,
+                                            disabled: !isDefaultRetentionEnabled,
+                                            size: "1/3",
+                                            children: [
+                                                /*#__PURE__*/ jsx(Select.Option, {
+                                                    value: "DAYS",
+                                                    children: "Days"
+                                                }),
+                                                /*#__PURE__*/ jsx(Select.Option, {
+                                                    value: "YEARS",
+                                                    children: "Years"
+                                                })
+                                            ]
+                                        })
+                                })
+                            ]
+                        })
+                    })
+                ]
+            })
+        ]
+    });
+}
+export { ObjectLockRetentionSettings as default };

package/dist/components/objects/ObjectLock/ObjectLockSettings.d.ts

@@ -0,0 +1,9 @@
+import Joi from "joi";
+export declare const objectLockRetentionSettingsValidationRules: {
+    isObjectLockEnabled: Joi.BooleanSchema<boolean>;
+    isDefaultRetentionEnabled: Joi.BooleanSchema<boolean>;
+    retentionMode: Joi.AlternativesSchema<any>;
+    retentionPeriod: Joi.AlternativesSchema<any>;
+    retentionPeriodFrequencyChoice: Joi.AlternativesSchema<any>;
+};
+export declare function ObjectLockSettings(): import("react/jsx-runtime").JSX.Element;

package/dist/components/objects/ObjectLock/ObjectLockSettings.js

@@ -0,0 +1,158 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useEffect, useRef } from "react";
+import { useNavigate, useParams } from "react-router-dom";
+import { FormProvider, useForm } from "react-hook-form";
+import { joiResolver } from "@hookform/resolvers/joi";
+import joi from "joi";
+import { Form, Icon, Loader, Stack, Text, useToast } from "@scality/core-ui";
+import { Button } from "@scality/core-ui/dist/next";
+import { useGetBucketObjectLockConfiguration, useSetBucketObjectLockConfiguration } from "../../../hooks/index.js";
+import ObjectLockRetentionSettings from "./ObjectLockRetentionSettings.js";
+const objectLockRetentionSettingsValidationRules = {
+    isObjectLockEnabled: joi.boolean(),
+    isDefaultRetentionEnabled: joi.boolean().default(false),
+    retentionMode: joi.when("isDefaultRetentionEnabled", {
+        is: joi.equal(true),
+        then: joi.string().valid("GOVERNANCE", "COMPLIANCE").required(),
+        otherwise: joi.any()
+    }),
+    retentionPeriod: joi.when("isDefaultRetentionEnabled", {
+        is: joi.equal(true),
+        then: joi.number().integer().min(1).required(),
+        otherwise: joi.any()
+    }),
+    retentionPeriodFrequencyChoice: joi.when("isDefaultRetentionEnabled", {
+        is: joi.equal(true),
+        then: joi.string().valid("DAYS", "YEARS").required(),
+        otherwise: joi.any()
+    })
+};
+const schema = joi.object(objectLockRetentionSettingsValidationRules);
+function ObjectLockSettings() {
+    const { bucketName } = useParams();
+    const navigate = useNavigate();
+    const { showToast } = useToast();
+    const { data: objectLockData, status: objectLockStatus } = useGetBucketObjectLockConfiguration({
+        Bucket: bucketName
+    });
+    const setBucketObjectLockMutation = useSetBucketObjectLockConfiguration();
+    const isObjectLockEnabled = objectLockData?.ObjectLockConfiguration?.ObjectLockEnabled === "Enabled";
+    const defaultRetention = objectLockData?.ObjectLockConfiguration?.Rule?.DefaultRetention;
+    const useFormMethods = useForm({
+        mode: "all",
+        resolver: joiResolver(schema),
+        defaultValues: {
+            isObjectLockEnabled: isObjectLockEnabled,
+            isDefaultRetentionEnabled: !!defaultRetention,
+            retentionMode: defaultRetention?.Mode || "GOVERNANCE",
+            retentionPeriod: defaultRetention?.Days || defaultRetention?.Years || 1,
+            retentionPeriodFrequencyChoice: defaultRetention ? defaultRetention?.Days ? "DAYS" : "YEARS" : "DAYS"
+        }
+    });
+    const { watch, setValue, handleSubmit, formState: { isValid } } = useFormMethods;
+    const isObjectLockEnabledValue = watch("isObjectLockEnabled");
+    const isFormInitialized = useRef(false);
+    useEffect(()=>{
+        if ("success" === objectLockStatus && objectLockData && !isFormInitialized.current) {
+            const isEnabled = objectLockData.ObjectLockConfiguration?.ObjectLockEnabled === "Enabled";
+            const defaultRet = objectLockData.ObjectLockConfiguration?.Rule?.DefaultRetention;
+            setValue("isObjectLockEnabled", isEnabled);
+            setValue("isDefaultRetentionEnabled", !!defaultRet);
+            if (defaultRet) {
+                setValue("retentionMode", defaultRet.Mode);
+                setValue("retentionPeriod", defaultRet.Days || defaultRet.Years || 1);
+                setValue("retentionPeriodFrequencyChoice", defaultRet.Days ? "DAYS" : "YEARS");
+            }
+            isFormInitialized.current = true;
+        }
+    }, [
+        objectLockData,
+        objectLockStatus,
+        setValue
+    ]);
+    const handleCancel = ()=>{
+        navigate(`/buckets/${bucketName}`);
+    };
+    const onSubmit = (data)=>{
+        setBucketObjectLockMutation.mutate({
+            Bucket: bucketName,
+            ObjectLockConfiguration: data.isObjectLockEnabled ? {
+                ObjectLockEnabled: "Enabled",
+                ...data.isDefaultRetentionEnabled && {
+                    Rule: {
+                        DefaultRetention: {
+                            Mode: data.retentionMode,
+                            ..."DAYS" === data.retentionPeriodFrequencyChoice ? {
+                                Days: data.retentionPeriod
+                            } : {
+                                Years: data.retentionPeriod
+                            }
+                        }
+                    }
+                }
+            } : void 0
+        }, {
+            onSuccess: ()=>{
+                showToast({
+                    open: true,
+                    message: "Object Lock settings saved successfully",
+                    status: "success"
+                });
+                navigate(`/buckets/${bucketName}`);
+            },
+            onError: (error)=>{
+                const errorMessage = error instanceof Error ? error.message : "Failed to save Object Lock settings";
+                showToast({
+                    open: true,
+                    message: errorMessage,
+                    status: "error"
+                });
+            }
+        });
+    };
+    if ("pending" === objectLockStatus) return /*#__PURE__*/ jsx(Loader, {
+        centered: true,
+        children: /*#__PURE__*/ jsx(Text, {
+            children: "Loading retention settings..."
+        })
+    });
+    return /*#__PURE__*/ jsx(FormProvider, {
+        ...useFormMethods,
+        children: /*#__PURE__*/ jsx(Form, {
+            onSubmit: handleSubmit(onSubmit),
+            requireMode: "partial",
+            layout: {
+                kind: "page",
+                title: "Object-lock settings"
+            },
+            rightActions: /*#__PURE__*/ jsxs(Stack, {
+                gap: "r16",
+                children: [
+                    /*#__PURE__*/ jsx(Button, {
+                        id: "cancel-btn",
+                        variant: "outline",
+                        onClick: handleCancel,
+                        type: "button",
+                        label: "Cancel",
+                        disabled: setBucketObjectLockMutation.isPending
+                    }),
+                    /*#__PURE__*/ jsx(Button, {
+                        disabled: !isValid || !isObjectLockEnabledValue || setBucketObjectLockMutation.isPending,
+                        id: "edit-retention-setting-btn",
+                        type: "submit",
+                        variant: "primary",
+                        label: "Save",
+                        icon: /*#__PURE__*/ jsx(Icon, {
+                            name: "Save"
+                        }),
+                        isLoading: setBucketObjectLockMutation.isPending
+                    })
+                ]
+            }),
+            children: /*#__PURE__*/ jsx(ObjectLockRetentionSettings, {
+                isEditRetentionSettings: true
+            })
+        })
+    });
+}
+export { ObjectLockSettings, objectLockRetentionSettingsValidationRules };

package/dist/components/objects/ObjectLock/ObjectLockSettingsUtils.d.ts

@@ -0,0 +1,8 @@
+import type { GetObjectRetentionCommandOutput } from "@aws-sdk/client-s3";
+export declare function getDefaultRetention(retentionData: GetObjectRetentionCommandOutput | null | undefined): {
+    isDefaultRetentionEnabled: boolean;
+    defaultRetentionUntilDate: Date;
+    defaultRetentionMode: import("@aws-sdk/client-s3").ObjectLockRetentionMode;
+};
+export declare function getDefaultMinRetainUntilDate(d: Date | null | undefined, mode: string): string;
+export declare function getRetainUntilDateHint(dateString: string): string;

package/dist/components/objects/ObjectLock/ObjectLockSettingsUtils.js

@@ -0,0 +1,39 @@
+function getDefaultRetention(retentionData) {
+    const isDefaultRetentionEnabled = retentionData?.Retention !== void 0 && null !== retentionData.Retention;
+    const defaultRetentionUntilDate = retentionData?.Retention?.RetainUntilDate ? new Date(retentionData.Retention.RetainUntilDate) : new Date();
+    const defaultRetentionMode = retentionData?.Retention?.Mode || "GOVERNANCE";
+    return {
+        isDefaultRetentionEnabled,
+        defaultRetentionUntilDate,
+        defaultRetentionMode
+    };
+}
+function getDefaultMinRetainUntilDate(d, mode) {
+    const tomorrow = new Date();
+    tomorrow.setDate(tomorrow.getDate() + 1);
+    const futureDate = formatDateForInput(tomorrow);
+    if (!d) return futureDate;
+    const previousRetainUntilDate = "GOVERNANCE" === mode ? formatDateForInput(d) : formatDateForInput(addDays(d, 1));
+    return previousRetainUntilDate > futureDate ? previousRetainUntilDate : futureDate;
+}
+function formatDateForInput(date) {
+    const year = date.getFullYear();
+    const month = String(date.getMonth() + 1).padStart(2, "0");
+    const day = String(date.getDate()).padStart(2, "0");
+    return `${year}-${month}-${day}`;
+}
+function addDays(date, days) {
+    const result = new Date(date);
+    result.setDate(result.getDate() + days);
+    return result;
+}
+function getRetainUntilDateHint(dateString) {
+    const now = new Date();
+    const retainUntilDate = new Date(dateString);
+    const diffInMs = retainUntilDate.getTime() - now.getTime();
+    const diffInDays = Math.floor(diffInMs / 86400000);
+    if (diffInDays < 1) return "(within 24 hours from now)";
+    if (1 === diffInDays) return "(1 day from now)";
+    return `(${diffInDays} days from now)`;
+}
+export { getDefaultMinRetainUntilDate, getDefaultRetention, getRetainUntilDateHint };

package/dist/components/objects/ObjectLock/__tests__/EditRetentionButton.test.d.ts

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

package/dist/components/objects/ObjectLock/__tests__/EditRetentionButton.test.js

@@ -0,0 +1,204 @@
+import { jsx } from "react/jsx-runtime";
+import { fireEvent, render, screen } from "@testing-library/react";
+import { MemoryRouter, useNavigate } from "react-router-dom";
+import { createTestWrapper } from "../../../../test/testUtils.js";
+import { EditRetentionButton } from "../EditRetentionButton.js";
+import { useISVBucketStatus } from "../../../../hooks/index.js";
+jest.mock("../../../../hooks");
+jest.mock("react-router-dom", ()=>({
+        ...jest.requireActual("react-router-dom"),
+        useNavigate: jest.fn()
+    }));
+const mockUseISVBucketStatus = jest.mocked(useISVBucketStatus);
+const mockUseNavigate = jest.mocked(useNavigate);
+const renderEditRetentionButton = (props = {})=>{
+    const Wrapper = createTestWrapper();
+    const mockNavigate = jest.fn();
+    mockUseNavigate.mockReturnValue(mockNavigate);
+    const result = render(/*#__PURE__*/ jsx(MemoryRouter, {
+        children: /*#__PURE__*/ jsx(Wrapper, {
+            children: /*#__PURE__*/ jsx(EditRetentionButton, {
+                bucketName: "test-bucket",
+                ...props
+            })
+        })
+    }));
+    return {
+        ...result,
+        navigate: mockNavigate
+    };
+};
+beforeEach(()=>{
+    jest.clearAllMocks();
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: false,
+        isCommvaultBucket: false,
+        isISVManaged: false,
+        isvApplication: void 0,
+        isLoading: false,
+        bucketTagsStatus: "success"
+    });
+});
+it("renders edit button", ()=>{
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeInTheDocument();
+});
+it("navigates to object lock settings page when clicked", ()=>{
+    const { navigate } = renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    fireEvent.click(editButton);
+    expect(navigate).toHaveBeenCalledWith("/buckets/test-bucket/objects/object-lock-settings");
+});
+it("navigates with correct bucket name", ()=>{
+    const { navigate } = renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    fireEvent.click(editButton);
+    expect(navigate).toHaveBeenCalledWith("/buckets/test-bucket/objects/object-lock-settings");
+});
+it("is enabled for regular buckets without ISV tags", ()=>{
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).not.toBeDisabled();
+});
+it("is disabled for Veeam Backup & Replication buckets", ()=>{
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: true,
+        isCommvaultBucket: false,
+        isISVManaged: true,
+        isvApplication: "Veeam",
+        isLoading: false,
+        bucketTagsStatus: "success"
+    });
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeDisabled();
+});
+it("is disabled for Veeam Office 365 v6/v7 buckets", ()=>{
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: true,
+        isCommvaultBucket: false,
+        isISVManaged: true,
+        isvApplication: "Veeam",
+        isLoading: false,
+        bucketTagsStatus: "success"
+    });
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeDisabled();
+});
+it("is disabled for Veeam Office 365 v8+ buckets", ()=>{
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: true,
+        isCommvaultBucket: false,
+        isISVManaged: true,
+        isvApplication: "Veeam",
+        isLoading: false,
+        bucketTagsStatus: "success"
+    });
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeDisabled();
+});
+it("is disabled for Commvault buckets", ()=>{
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: false,
+        isCommvaultBucket: true,
+        isISVManaged: true,
+        isvApplication: "Commvault",
+        isLoading: false,
+        bucketTagsStatus: "success"
+    });
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeDisabled();
+});
+it("is disabled for ISV buckets tagged as Veeam Backup for Microsoft 365", ()=>{
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: true,
+        isCommvaultBucket: false,
+        isISVManaged: true,
+        isvApplication: "Veeam",
+        isLoading: false,
+        bucketTagsStatus: "success"
+    });
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeDisabled();
+});
+it("is disabled for ISV buckets tagged as Veeam Backup & Replication", ()=>{
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: true,
+        isCommvaultBucket: false,
+        isISVManaged: true,
+        isvApplication: "Veeam",
+        isLoading: false,
+        bucketTagsStatus: "success"
+    });
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeDisabled();
+});
+it("handles missing bucket tags gracefully", ()=>{
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).not.toBeDisabled();
+});
+it("handles empty TagSet gracefully", ()=>{
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).not.toBeDisabled();
+});
+it("is enabled for buckets with non-ISV tags", ()=>{
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).not.toBeDisabled();
+});
+it("handles bucket tagging query error gracefully", ()=>{
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).not.toBeDisabled();
+});
+it("shows loading state when fetching bucket tags", ()=>{
+    mockUseISVBucketStatus.mockReturnValue({
+        isVeeamBucket: false,
+        isCommvaultBucket: false,
+        isISVManaged: false,
+        isvApplication: void 0,
+        isLoading: true,
+        bucketTagsStatus: "pending"
+    });
+    renderEditRetentionButton();
+    const editButton = screen.getByRole("button", {
+        name: /edit default retention/i
+    });
+    expect(editButton).toBeInTheDocument();
+});

package/dist/components/objects/ObjectLock/__tests__/ObjectLockSettings.test.d.ts

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