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

package/dist/components/objects/ObjectDetails/__tests__/ObjectSummary.test.js

@@ -0,0 +1,813 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { cleanup, render, screen, waitFor } from "@testing-library/react";
+import user_event from "@testing-library/user-event";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { ObjectSummary } from "../ObjectSummary.js";
+import { DataBrowserUICustomizationProvider } from "../../../../contexts/DataBrowserUICustomizationContext.js";
+import { useObjectLegalHold, useObjectMetadata, useObjectRetention, useSetObjectLegalHold } from "../../../../hooks/index.js";
+import { useToast } from "@scality/core-ui";
+jest.mock("../../../../hooks");
+jest.mock("@scality/core-ui", ()=>{
+    const actual = jest.requireActual("@scality/core-ui");
+    return {
+        ...actual,
+        useToast: jest.fn()
+    };
+});
+const mockUseObjectMetadata = jest.mocked(useObjectMetadata);
+const mockUseObjectLegalHold = jest.mocked(useObjectLegalHold);
+const mockUseObjectRetention = jest.mocked(useObjectRetention);
+const mockUseSetObjectLegalHold = jest.mocked(useSetObjectLegalHold);
+const mockUseToast = jest.mocked(useToast);
+const mockObjectMetadata = {
+    VersionId: "test-version-id",
+    ContentLength: 1024,
+    LastModified: new Date("2024-01-01"),
+    ETag: '"abc123def456"'
+};
+const mockLegalHoldData = {
+    LegalHold: {
+        Status: "OFF"
+    }
+};
+const mockRetentionData = {
+    Retention: {
+        Mode: "GOVERNANCE",
+        RetainUntilDate: "2024-12-31T23:59:59Z"
+    }
+};
+const setupMockDefaults = ()=>{
+    mockUseObjectMetadata.mockReturnValue({
+        data: mockObjectMetadata,
+        status: "success"
+    });
+    mockUseObjectLegalHold.mockReturnValue({
+        data: mockLegalHoldData,
+        status: "success"
+    });
+    mockUseObjectRetention.mockReturnValue({
+        data: mockRetentionData,
+        status: "success"
+    });
+    mockUseSetObjectLegalHold.mockReturnValue({
+        mutate: jest.fn(),
+        isPending: false
+    });
+    mockUseToast.mockReturnValue({
+        showToast: jest.fn()
+    });
+};
+const renderWithProviders = (ui, { customizationConfig = {} } = {})=>{
+    const queryClient = new QueryClient({
+        defaultOptions: {
+            queries: {
+                retry: false
+            },
+            mutations: {
+                retry: false
+            }
+        }
+    });
+    return render(/*#__PURE__*/ jsx(QueryClientProvider, {
+        client: queryClient,
+        children: /*#__PURE__*/ jsx(DataBrowserUICustomizationProvider, {
+            config: customizationConfig,
+            children: ui
+        })
+    }));
+};
+describe("ObjectSummary", ()=>{
+    const defaultProps = {
+        bucketName: "test-bucket",
+        objectKey: "test-object.txt"
+    };
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        setupMockDefaults();
+    });
+    describe("Default Fields", ()=>{
+        describe("Information Section", ()=>{
+            it("should render all default information fields", ()=>{
+                renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                    ...defaultProps
+                }));
+                expect(screen.getByText("Information")).toBeInTheDocument();
+                expect(screen.getByText("Name")).toBeInTheDocument();
+                expect(screen.getByText("Version ID")).toBeInTheDocument();
+                expect(screen.getByText("Size")).toBeInTheDocument();
+                expect(screen.getByText("Modified On")).toBeInTheDocument();
+                expect(screen.getByText("ETag")).toBeInTheDocument();
+                expect(screen.getByText("Location")).toBeInTheDocument();
+            });
+            it("should display object name", ()=>{
+                renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                    ...defaultProps
+                }));
+                expect(screen.getByText("test-object.txt")).toBeInTheDocument();
+            });
+            it("should display version ID from metadata", ()=>{
+                renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                    ...defaultProps
+                }));
+                expect(screen.getByText("test-version-id")).toBeInTheDocument();
+            });
+            it("should display formatted size", ()=>{
+                renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                    ...defaultProps
+                }));
+                expect(screen.getByText(/1 KB/i)).toBeInTheDocument();
+            });
+            it("should display formatted date", ()=>{
+                renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                    ...defaultProps
+                }));
+                const dateElements = screen.getAllByText(/2024/);
+                expect(dateElements.length).toBeGreaterThan(0);
+            });
+            it("should display ETag without quotes", ()=>{
+                renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                    ...defaultProps
+                }));
+                expect(screen.getByText("abc123def456")).toBeInTheDocument();
+            });
+            it("should display default location", ()=>{
+                renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                    ...defaultProps
+                }));
+                expect(screen.getByText("default")).toBeInTheDocument();
+            });
+        });
+        describe("Data Protection Section", ()=>{
+            it("should render data protection section", ()=>{
+                renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                    ...defaultProps
+                }));
+                expect(screen.getByText("Data protection")).toBeInTheDocument();
+            });
+            it("should display retention lock information", ()=>{
+                renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                    ...defaultProps
+                }));
+                expect(screen.getByText("Lock")).toBeInTheDocument();
+                expect(screen.getByText(/GOVERNANCE/)).toBeInTheDocument();
+                expect(screen.getByText(/until/)).toBeInTheDocument();
+            });
+            it("should display legal hold toggle when available", ()=>{
+                renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                    ...defaultProps
+                }));
+                expect(screen.getByText("Legal Hold")).toBeInTheDocument();
+                expect(screen.getByRole("checkbox")).toBeInTheDocument();
+            });
+            it("should show legal hold as inactive by default", ()=>{
+                renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                    ...defaultProps
+                }));
+                const toggle = screen.getByRole("checkbox");
+                expect(toggle).not.toBeChecked();
+            });
+        });
+    });
+    describe("Loading States", ()=>{
+        it("should show loader for pending metadata", ()=>{
+            mockUseObjectMetadata.mockReturnValueOnce({
+                data: void 0,
+                status: "pending"
+            });
+            const { container } = renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            const loaders = container.querySelectorAll("svg");
+            expect(loaders.length).toBeGreaterThan(0);
+        });
+        it("should show error state for failed metadata", ()=>{
+            mockUseObjectMetadata.mockReturnValueOnce({
+                data: void 0,
+                status: "error"
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            const errors = screen.getAllByText("Error");
+            expect(errors.length).toBeGreaterThan(0);
+        });
+        it("should show N/A when retention is not available", ()=>{
+            mockUseObjectRetention.mockReturnValueOnce({
+                data: void 0,
+                status: "error"
+            });
+            mockUseObjectLegalHold.mockReturnValueOnce({
+                data: void 0,
+                status: "error"
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            expect(screen.getByText("No Retention")).toBeInTheDocument();
+            expect(screen.getAllByText("N/A").length).toBeGreaterThan(0);
+        });
+    });
+    describe("Version ID Handling", ()=>{
+        it("should prefer metadata version ID over prop", ()=>{
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps,
+                versionId: "prop-version-id"
+            }));
+            expect(screen.getByText("test-version-id")).toBeInTheDocument();
+            expect(screen.queryByText("prop-version-id")).not.toBeInTheDocument();
+        });
+        it("should fallback to prop version ID when metadata is unavailable", ()=>{
+            mockUseObjectMetadata.mockReturnValueOnce({
+                data: {
+                    ...mockObjectMetadata,
+                    VersionId: void 0
+                },
+                status: "success"
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps,
+                versionId: "fallback-version-id"
+            }));
+            expect(screen.getByText("fallback-version-id")).toBeInTheDocument();
+        });
+        it("should show N/A when no version ID is available", ()=>{
+            mockUseObjectMetadata.mockReturnValueOnce({
+                data: {
+                    ...mockObjectMetadata,
+                    VersionId: void 0
+                },
+                status: "success"
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            expect(screen.getAllByText("N/A").length).toBeGreaterThan(0);
+        });
+    });
+    describe("ETag Handling Edge Cases", ()=>{
+        it("should handle null ETag gracefully", ()=>{
+            mockUseObjectMetadata.mockReturnValueOnce({
+                data: {
+                    ...mockObjectMetadata,
+                    ETag: null
+                },
+                status: "success"
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            expect(screen.getAllByText("N/A").length).toBeGreaterThan(0);
+        });
+        it("should handle undefined ETag gracefully", ()=>{
+            mockUseObjectMetadata.mockReturnValueOnce({
+                data: {
+                    ...mockObjectMetadata,
+                    ETag: void 0
+                },
+                status: "success"
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            expect(screen.getAllByText("N/A").length).toBeGreaterThan(0);
+        });
+        it("should handle metadata error state gracefully", ()=>{
+            mockUseObjectMetadata.mockReturnValueOnce({
+                data: void 0,
+                status: "error"
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            expect(screen.getAllByText("Error").length).toBeGreaterThan(0);
+        });
+        it("should remove quotes from ETag", ()=>{
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            expect(screen.getByText("abc123def456")).toBeInTheDocument();
+            expect(screen.queryByText('"abc123def456"')).not.toBeInTheDocument();
+        });
+        it("should handle ETag without quotes", ()=>{
+            mockUseObjectMetadata.mockReturnValueOnce({
+                data: {
+                    ...mockObjectMetadata,
+                    ETag: "unquoted-etag"
+                },
+                status: "success"
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            expect(screen.getByText("unquoted-etag")).toBeInTheDocument();
+        });
+    });
+    describe("Custom Fields", ()=>{
+        describe("Information Section", ()=>{
+            it("should render custom information fields", ()=>{
+                const CustomField = ({ entityName })=>/*#__PURE__*/ jsxs("div", {
+                        children: [
+                            "Custom Field for ",
+                            entityName
+                        ]
+                    });
+                const customConfig = {
+                    extraObjectSummaryInformation: [
+                        {
+                            id: "custom-field",
+                            label: "Custom Field",
+                            render: CustomField
+                        }
+                    ]
+                };
+                renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                    ...defaultProps
+                }), {
+                    customizationConfig: customConfig
+                });
+                expect(screen.getByText("Custom Field")).toBeInTheDocument();
+                expect(screen.getByText(/custom field for test-object.txt/i)).toBeInTheDocument();
+            });
+            it("should replace default fields with same ID", ()=>{
+                const CustomLocationField = ()=>/*#__PURE__*/ jsx("div", {
+                        children: "Custom Location Value"
+                    });
+                const customConfig = {
+                    extraObjectSummaryInformation: [
+                        {
+                            id: "location",
+                            label: "Custom Location",
+                            render: CustomLocationField
+                        }
+                    ]
+                };
+                renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                    ...defaultProps
+                }), {
+                    customizationConfig: customConfig
+                });
+                expect(screen.getByText("Custom Location")).toBeInTheDocument();
+                expect(screen.getByText("Custom Location Value")).toBeInTheDocument();
+                expect(screen.queryByText("default")).not.toBeInTheDocument();
+            });
+            it("should add multiple custom fields", ()=>{
+                const Field1 = ()=>/*#__PURE__*/ jsx("div", {
+                        children: "Field 1 Value"
+                    });
+                const Field2 = ()=>/*#__PURE__*/ jsx("div", {
+                        children: "Field 2 Value"
+                    });
+                const Field3 = ()=>/*#__PURE__*/ jsx("div", {
+                        children: "Field 3 Value"
+                    });
+                const customConfig = {
+                    extraObjectSummaryInformation: [
+                        {
+                            id: "field1",
+                            label: "Field 1",
+                            render: Field1
+                        },
+                        {
+                            id: "field2",
+                            label: "Field 2",
+                            render: Field2
+                        },
+                        {
+                            id: "field3",
+                            label: "Field 3",
+                            render: Field3
+                        }
+                    ]
+                };
+                renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                    ...defaultProps
+                }), {
+                    customizationConfig: customConfig
+                });
+                expect(screen.getByText("Field 1")).toBeInTheDocument();
+                expect(screen.getByText("Field 2")).toBeInTheDocument();
+                expect(screen.getByText("Field 3")).toBeInTheDocument();
+                expect(screen.getByText("Field 1 Value")).toBeInTheDocument();
+                expect(screen.getByText("Field 2 Value")).toBeInTheDocument();
+                expect(screen.getByText("Field 3 Value")).toBeInTheDocument();
+            });
+            it("should pass entityName prop to custom field components", ()=>{
+                const CustomField = ({ entityName })=>/*#__PURE__*/ jsxs("div", {
+                        "data-testid": "custom-field",
+                        children: [
+                            "EntityName: ",
+                            entityName
+                        ]
+                    });
+                const customConfig = {
+                    extraObjectSummaryInformation: [
+                        {
+                            id: "test-field",
+                            label: "Test Field",
+                            render: CustomField
+                        }
+                    ]
+                };
+                renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                    ...defaultProps,
+                    objectKey: "my-special-file.txt"
+                }), {
+                    customizationConfig: customConfig
+                });
+                expect(screen.getByTestId("custom-field")).toHaveTextContent("EntityName: my-special-file.txt");
+            });
+        });
+        describe("Data Protection Section", ()=>{
+            it("should render custom data protection fields", ()=>{
+                const CustomProtectionField = ()=>/*#__PURE__*/ jsx("div", {
+                        children: "Custom Protection Info"
+                    });
+                const customConfig = {
+                    extraObjectSummaryDataProtection: [
+                        {
+                            id: "custom-protection",
+                            label: "Custom Protection",
+                            render: CustomProtectionField
+                        }
+                    ]
+                };
+                renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                    ...defaultProps
+                }), {
+                    customizationConfig: customConfig
+                });
+                expect(screen.getByText("Custom Protection")).toBeInTheDocument();
+                expect(screen.getByText("Custom Protection Info")).toBeInTheDocument();
+            });
+            it("should replace default data protection fields", ()=>{
+                const CustomLockField = ()=>/*#__PURE__*/ jsx("div", {
+                        children: "Custom Lock Status"
+                    });
+                const customConfig = {
+                    extraObjectSummaryDataProtection: [
+                        {
+                            id: "lock",
+                            label: "Custom Lock",
+                            render: CustomLockField
+                        }
+                    ]
+                };
+                renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                    ...defaultProps
+                }), {
+                    customizationConfig: customConfig
+                });
+                expect(screen.getByText("Custom Lock")).toBeInTheDocument();
+                expect(screen.getByText("Custom Lock Status")).toBeInTheDocument();
+                expect(screen.queryByText(/GOVERNANCE/)).not.toBeInTheDocument();
+            });
+        });
+        describe("Optional Labels", ()=>{
+            it("should handle fields without labels", ()=>{
+                const FieldWithoutLabel = ()=>/*#__PURE__*/ jsx("div", {
+                        children: "Content Only"
+                    });
+                const customConfig = {
+                    extraObjectSummaryInformation: [
+                        {
+                            id: "no-label-field",
+                            render: FieldWithoutLabel
+                        }
+                    ]
+                };
+                renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                    ...defaultProps
+                }), {
+                    customizationConfig: customConfig
+                });
+                expect(screen.getByText("Content Only")).toBeInTheDocument();
+            });
+        });
+    });
+    describe("Legal Hold Toggle", ()=>{
+        it("should call mutation when toggle is clicked", async ()=>{
+            const user = user_event.setup();
+            const mockMutate = jest.fn();
+            mockUseObjectRetention.mockReturnValueOnce({
+                data: mockRetentionData,
+                status: "success"
+            });
+            mockUseObjectLegalHold.mockReturnValueOnce({
+                data: mockLegalHoldData,
+                status: "success"
+            });
+            mockUseSetObjectLegalHold.mockReturnValueOnce({
+                mutate: mockMutate,
+                isPending: false
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            const toggle = screen.getByRole("checkbox");
+            await user.click(toggle);
+            await waitFor(()=>{
+                expect(mockMutate).toHaveBeenCalled();
+            });
+        });
+        it("should call mutation with correct parameters", async ()=>{
+            const user = user_event.setup();
+            const mockMutate = jest.fn();
+            mockUseObjectRetention.mockReturnValueOnce({
+                data: mockRetentionData,
+                status: "success"
+            });
+            mockUseObjectLegalHold.mockReturnValueOnce({
+                data: mockLegalHoldData,
+                status: "success"
+            });
+            mockUseSetObjectLegalHold.mockReturnValueOnce({
+                mutate: mockMutate,
+                isPending: false
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            const toggle = screen.getByRole("checkbox");
+            await user.click(toggle);
+            await waitFor(()=>{
+                expect(mockMutate).toHaveBeenCalledWith(expect.objectContaining({
+                    Bucket: "test-bucket",
+                    Key: "test-object.txt",
+                    LegalHold: {
+                        Status: "ON"
+                    }
+                }), expect.any(Object));
+            });
+        });
+        it("should show success toast with correct message when enabling legal hold", async ()=>{
+            const user = user_event.setup();
+            const mockShowToast = jest.fn();
+            const mockMutate = jest.fn((_params, callbacks)=>{
+                callbacks.onSuccess();
+            });
+            mockUseToast.mockReturnValue({
+                showToast: mockShowToast
+            });
+            mockUseObjectRetention.mockReturnValueOnce({
+                data: mockRetentionData,
+                status: "success"
+            });
+            mockUseObjectLegalHold.mockReturnValueOnce({
+                data: mockLegalHoldData,
+                status: "success"
+            });
+            mockUseSetObjectLegalHold.mockReturnValueOnce({
+                mutate: mockMutate,
+                isPending: false
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            const toggle = screen.getByRole("checkbox");
+            await user.click(toggle);
+            await waitFor(()=>{
+                expect(mockShowToast).toHaveBeenCalledWith({
+                    open: true,
+                    message: "Legal hold active",
+                    status: "success"
+                });
+            });
+        });
+        it("should show error toast when mutation fails with Error instance", async ()=>{
+            const user = user_event.setup();
+            const mockShowToast = jest.fn();
+            const testError = new Error("Network error");
+            const mockMutate = jest.fn((_params, callbacks)=>{
+                callbacks.onError(testError);
+            });
+            mockUseToast.mockReturnValue({
+                showToast: mockShowToast
+            });
+            mockUseObjectRetention.mockReturnValueOnce({
+                data: mockRetentionData,
+                status: "success"
+            });
+            mockUseObjectLegalHold.mockReturnValueOnce({
+                data: mockLegalHoldData,
+                status: "success"
+            });
+            mockUseSetObjectLegalHold.mockReturnValueOnce({
+                mutate: mockMutate,
+                isPending: false
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            const toggle = screen.getByRole("checkbox");
+            await user.click(toggle);
+            await waitFor(()=>{
+                expect(mockShowToast).toHaveBeenCalledWith({
+                    open: true,
+                    message: "Network error",
+                    status: "error"
+                });
+            });
+        });
+        it("should show generic error message when mutation fails with non-Error object", async ()=>{
+            const user = user_event.setup();
+            const mockShowToast = jest.fn();
+            const mockMutate = jest.fn((_params, callbacks)=>{
+                callbacks.onError({
+                    message: "Custom error"
+                });
+            });
+            mockUseToast.mockReturnValue({
+                showToast: mockShowToast
+            });
+            mockUseObjectRetention.mockReturnValueOnce({
+                data: mockRetentionData,
+                status: "success"
+            });
+            mockUseObjectLegalHold.mockReturnValueOnce({
+                data: mockLegalHoldData,
+                status: "success"
+            });
+            mockUseSetObjectLegalHold.mockReturnValueOnce({
+                mutate: mockMutate,
+                isPending: false
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            const toggle = screen.getByRole("checkbox");
+            await user.click(toggle);
+            await waitFor(()=>{
+                expect(mockShowToast).toHaveBeenCalledWith({
+                    open: true,
+                    message: "Failed to update legal hold",
+                    status: "error"
+                });
+            });
+        });
+        it("should disable toggle while updating", ()=>{
+            mockUseObjectRetention.mockReturnValueOnce({
+                data: mockRetentionData,
+                status: "success"
+            });
+            mockUseObjectLegalHold.mockReturnValueOnce({
+                data: mockLegalHoldData,
+                status: "success"
+            });
+            mockUseSetObjectLegalHold.mockReturnValueOnce({
+                mutate: jest.fn(),
+                isPending: true
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            const toggle = screen.getByRole("checkbox");
+            expect(toggle).toHaveAttribute("aria-disabled", "true");
+        });
+        it("should show checked toggle when legal hold is enabled", ()=>{
+            mockUseObjectRetention.mockReturnValueOnce({
+                data: mockRetentionData,
+                status: "success"
+            });
+            mockUseObjectLegalHold.mockReturnValueOnce({
+                data: {
+                    LegalHold: {
+                        Status: "ON"
+                    }
+                },
+                status: "success"
+            });
+            mockUseSetObjectLegalHold.mockReturnValueOnce({
+                mutate: jest.fn(),
+                isPending: false
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            const toggle = screen.getByRole("checkbox");
+            expect(toggle).toBeChecked();
+            expect(toggle).toHaveAttribute("aria-checked", "true");
+        });
+        it("should show unchecked toggle when legal hold is disabled", ()=>{
+            mockUseObjectRetention.mockReturnValueOnce({
+                data: mockRetentionData,
+                status: "success"
+            });
+            mockUseObjectLegalHold.mockReturnValueOnce({
+                data: {
+                    LegalHold: {
+                        Status: "OFF"
+                    }
+                },
+                status: "success"
+            });
+            mockUseSetObjectLegalHold.mockReturnValueOnce({
+                mutate: jest.fn(),
+                isPending: false
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            const toggle = screen.getByRole("checkbox");
+            expect(toggle).not.toBeChecked();
+            expect(toggle).toHaveAttribute("aria-checked", "false");
+        });
+    });
+    describe("Copy Buttons", ()=>{
+        it("should render copy buttons for version ID and ETag", ()=>{
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            const copyButtons = screen.getAllByRole("button", {
+                name: /copy/i
+            });
+            expect(copyButtons.length).toBeGreaterThanOrEqual(2);
+        });
+        it("should display version ID value correctly", ()=>{
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            expect(screen.getByText("test-version-id")).toBeInTheDocument();
+            const copyButtons = screen.getAllByRole("button", {
+                name: /copy/i
+            });
+            expect(copyButtons.length).toBeGreaterThan(0);
+        });
+        it("should display ETag value correctly", ()=>{
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            expect(screen.getByText("abc123def456")).toBeInTheDocument();
+            const copyButtons = screen.getAllByRole("button", {
+                name: /copy/i
+            });
+            expect(copyButtons.length).toBeGreaterThan(0);
+        });
+    });
+    describe("Field Ordering", ()=>{
+        it("should maintain default field order", ()=>{
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            expect(screen.getByText("Information")).toBeInTheDocument();
+            expect(screen.getByText("Name")).toBeInTheDocument();
+            expect(screen.getByText("Version ID")).toBeInTheDocument();
+            expect(screen.getByText("Size")).toBeInTheDocument();
+            expect(screen.getByText("Modified On")).toBeInTheDocument();
+            expect(screen.getByText("ETag")).toBeInTheDocument();
+            expect(screen.getByText("Location")).toBeInTheDocument();
+            expect(screen.getByText("Data protection")).toBeInTheDocument();
+            expect(screen.getByText("Lock")).toBeInTheDocument();
+            expect(screen.getByText("Legal Hold")).toBeInTheDocument();
+        });
+        it("should append custom fields after default fields", ()=>{
+            const CustomField = ()=>/*#__PURE__*/ jsx("div", {
+                    children: "Custom Field Content"
+                });
+            const customConfig = {
+                extraObjectSummaryInformation: [
+                    {
+                        id: "custom-field",
+                        label: "Custom Field",
+                        render: CustomField
+                    }
+                ]
+            };
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }), {
+                customizationConfig: customConfig
+            });
+            const allText = document.body.textContent || "";
+            const locationIndex = allText.indexOf("Location");
+            const customFieldIndex = allText.indexOf("Custom Field");
+            expect(locationIndex).toBeLessThan(customFieldIndex);
+        });
+    });
+    describe("Performance", ()=>{
+        it("should memoize information fields", ()=>{
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            const firstRender = screen.getByText("test-object.txt");
+            expect(firstRender).toBeInTheDocument();
+            cleanup();
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            const secondRender = screen.getByText("test-object.txt");
+            expect(secondRender).toBeInTheDocument();
+        });
+        it("should not recalculate fields when unrelated props change", ()=>{
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            expect(screen.getByText("test-object.txt")).toBeInTheDocument();
+            cleanup();
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps,
+                versionId: "new-version"
+            }));
+            expect(screen.getByText("test-object.txt")).toBeInTheDocument();
+        });
+    });
+});