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

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

@@ -0,0 +1,1064 @@
+import { jsx, jsxs } from "react/jsx-runtime";
+import { useToast } from "@scality/core-ui";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { cleanup, render, screen, waitFor } from "@testing-library/react";
+import user_event from "@testing-library/user-event";
+import { DataBrowserUICustomizationProvider } from "../../../../contexts/DataBrowserUICustomizationContext.js";
+import { useGetPresignedDownload, useGetPublicAccessBlock, useObjectAcl, useObjectLegalHold, useObjectMetadata, useObjectRetention, useSetObjectAcl, useSetObjectLegalHold } from "../../../../hooks/index.js";
+import { findToggleByLabel } from "../../../../test/testUtils.js";
+import { ObjectSummary } from "../ObjectSummary.js";
+jest.mock('../../../../hooks');
+jest.mock('@scality/core-ui', ()=>{
+    const actual = jest.requireActual('@scality/core-ui');
+    return {
+        ...actual,
+        useToast: jest.fn()
+    };
+});
+jest.mock('../../../providers/DataBrowserProvider', ()=>({
+        ...jest.requireActual('../../../providers/DataBrowserProvider'),
+        useDataBrowserConfig: jest.fn(()=>({
+                endpoint: 'https://s3.example.com',
+                forcePathStyle: false
+            }))
+    }));
+const mockUseObjectMetadata = jest.mocked(useObjectMetadata);
+const mockUseObjectLegalHold = jest.mocked(useObjectLegalHold);
+const mockUseObjectRetention = jest.mocked(useObjectRetention);
+const mockUseSetObjectLegalHold = jest.mocked(useSetObjectLegalHold);
+const mockUseObjectAcl = jest.mocked(useObjectAcl);
+const mockUseSetObjectAcl = jest.mocked(useSetObjectAcl);
+const mockUseGetPublicAccessBlock = jest.mocked(useGetPublicAccessBlock);
+const mockUseGetPresignedDownload = jest.mocked(useGetPresignedDownload);
+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 mockAclDataPrivate = {
+    Grants: [
+        {
+            Grantee: {
+                Type: 'CanonicalUser',
+                ID: 'owner-id'
+            },
+            Permission: 'FULL_CONTROL'
+        }
+    ]
+};
+const mockPublicAccessBlockData = {
+    PublicAccessBlockConfiguration: {
+        BlockPublicAcls: false,
+        IgnorePublicAcls: false
+    }
+};
+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
+    });
+    mockUseObjectAcl.mockReturnValue({
+        data: mockAclDataPrivate,
+        status: 'success'
+    });
+    mockUseSetObjectAcl.mockReturnValue({
+        mutate: jest.fn(),
+        isPending: false
+    });
+    mockUseGetPublicAccessBlock.mockReturnValue({
+        data: mockPublicAccessBlockData,
+        status: 'success'
+    });
+    mockUseGetPresignedDownload.mockReturnValue({
+        mutateAsync: jest.fn(),
+        isPending: false
+    });
+    mockUseToast.mockReturnValue({
+        showToast: jest.fn()
+    });
+};
+const getLegalHoldToggle = ()=>findToggleByLabel('Legal Hold');
+const getPublicToggle = ()=>findToggleByLabel('Public');
+const expectTooltipOnHover = async (element, expectedText)=>{
+    const user = user_event.setup();
+    await user.hover(element);
+    await waitFor(()=>{
+        expect(screen.getByText(expectedText)).toBeInTheDocument();
+    });
+};
+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();
+                expect(screen.getByText('Access')).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(getLegalHoldToggle()).toBeInTheDocument();
+            });
+            it('should show legal hold as inactive by default', ()=>{
+                renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                    ...defaultProps
+                }));
+                const toggle = getLegalHoldToggle();
+                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 = getLegalHoldToggle();
+            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 = getLegalHoldToggle();
+            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 = getLegalHoldToggle();
+            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 = getLegalHoldToggle();
+            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 = getLegalHoldToggle();
+            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 = getLegalHoldToggle();
+            expect(toggle).toBeDisabled();
+        });
+        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 = getLegalHoldToggle();
+            expect(toggle).toBeChecked();
+        });
+        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 = getLegalHoldToggle();
+            expect(toggle).not.toBeChecked();
+        });
+    });
+    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();
+        });
+    });
+    describe('Public Access Toggle', ()=>{
+        const mockAclDataPublic = {
+            Grants: [
+                {
+                    Grantee: {
+                        URI: 'http://acs.amazonaws.com/groups/global/AllUsers'
+                    },
+                    Permission: 'READ'
+                }
+            ]
+        };
+        const mockAclDataPublicFullControl = {
+            Grants: [
+                {
+                    Grantee: {
+                        URI: 'http://acs.amazonaws.com/groups/global/AllUsers'
+                    },
+                    Permission: 'FULL_CONTROL'
+                }
+            ]
+        };
+        it('should render public field in access section', ()=>{
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            expect(screen.getByText('Access')).toBeInTheDocument();
+            expect(screen.getByText('Public')).toBeInTheDocument();
+        });
+        it('should disable toggle with tooltip when public access block fetch fails', async ()=>{
+            mockUseGetPublicAccessBlock.mockReturnValueOnce({
+                data: void 0,
+                status: 'error'
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            const toggle = getPublicToggle();
+            expect(toggle).toBeDisabled();
+            await expectTooltipOnHover(toggle, 'Unable to check public access block settings');
+        });
+        it('should disable toggle with tooltip when BlockPublicAcls is true', async ()=>{
+            mockUseGetPublicAccessBlock.mockReturnValueOnce({
+                data: {
+                    PublicAccessBlockConfiguration: {
+                        BlockPublicAcls: true,
+                        IgnorePublicAcls: false
+                    }
+                },
+                status: 'success'
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            const toggle = getPublicToggle();
+            expect(toggle).toBeDisabled();
+            await expectTooltipOnHover(toggle, 'Public access is blocked at bucket level');
+        });
+        it('should show Active label when object is public with READ permission', ()=>{
+            mockUseObjectAcl.mockReturnValueOnce({
+                data: mockAclDataPublic,
+                status: 'success'
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            expect(screen.getByText('Active')).toBeInTheDocument();
+        });
+        it('should show Active label when object is public with FULL_CONTROL permission', ()=>{
+            mockUseObjectAcl.mockReturnValueOnce({
+                data: mockAclDataPublicFullControl,
+                status: 'success'
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            expect(screen.getByText('Active')).toBeInTheDocument();
+        });
+        it('should show Inactive label when object is private', ()=>{
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            const publicToggle = getPublicToggle();
+            expect(publicToggle).toBeInTheDocument();
+            expect(publicToggle).not.toBeChecked();
+            const inactiveLabels = screen.getAllByText('Inactive');
+            expect(inactiveLabels.length).toBeGreaterThanOrEqual(1);
+        });
+        it('should show public hint message when object is public', ()=>{
+            mockUseObjectAcl.mockReturnValueOnce({
+                data: mockAclDataPublic,
+                status: 'success'
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            expect(screen.getByText('Available to anyone with the link and endpoint access')).toBeInTheDocument();
+        });
+        it('should not show public hint when object is private', ()=>{
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            expect(screen.queryByText('Available to anyone with the link and endpoint access')).not.toBeInTheDocument();
+        });
+        it('should show external link when object is public', ()=>{
+            mockUseObjectAcl.mockReturnValueOnce({
+                data: mockAclDataPublic,
+                status: 'success'
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            expect(screen.getByText('External link')).toBeInTheDocument();
+        });
+        it('should not show external link when object is private', ()=>{
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            expect(screen.queryByText('External link')).not.toBeInTheDocument();
+        });
+        it('should show copy button for external link when public', ()=>{
+            mockUseObjectAcl.mockReturnValueOnce({
+                data: mockAclDataPublic,
+                status: 'success'
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            const copyButtons = screen.getAllByRole('button', {
+                name: /copy/i
+            });
+            expect(copyButtons.length).toBeGreaterThanOrEqual(3);
+        });
+        it('should disable toggle with tooltip when IgnorePublicAcls is true', async ()=>{
+            mockUseGetPublicAccessBlock.mockReturnValueOnce({
+                data: {
+                    PublicAccessBlockConfiguration: {
+                        BlockPublicAcls: false,
+                        IgnorePublicAcls: true
+                    }
+                },
+                status: 'success'
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            const toggle = getPublicToggle();
+            expect(toggle).toBeDisabled();
+            await expectTooltipOnHover(toggle, 'Public access is blocked at bucket level');
+        });
+        it('should hide all public access UI when GetPublicAccessBlock returns 501 Not Implemented', ()=>{
+            const notImplementedError = {
+                statusCode: 501
+            };
+            mockUseObjectAcl.mockReturnValueOnce({
+                data: mockAclDataPublic,
+                status: 'success'
+            });
+            mockUseGetPublicAccessBlock.mockReturnValueOnce({
+                data: void 0,
+                status: 'error',
+                error: notImplementedError
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            expect(screen.queryByText('Public')).not.toBeInTheDocument();
+            expect(screen.queryByText('External link')).not.toBeInTheDocument();
+            expect(screen.queryByText('Available to anyone with the link and endpoint access')).not.toBeInTheDocument();
+        });
+        it('should hide public toggle while GetPublicAccessBlock is pending', ()=>{
+            mockUseGetPublicAccessBlock.mockReturnValueOnce({
+                data: void 0,
+                status: 'pending',
+                error: void 0
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            expect(screen.queryByText('Public')).not.toBeInTheDocument();
+        });
+        it('should disable toggle with tooltip when GetPublicAccessBlock returns other 5xx errors', async ()=>{
+            const serverError = {
+                statusCode: 500
+            };
+            mockUseGetPublicAccessBlock.mockReturnValueOnce({
+                data: void 0,
+                status: 'error',
+                error: serverError
+            });
+            renderWithProviders(/*#__PURE__*/ jsx(ObjectSummary, {
+                ...defaultProps
+            }));
+            const toggle = getPublicToggle();
+            expect(toggle).toBeInTheDocument();
+            expect(toggle).toBeDisabled();
+            await expectTooltipOnHover(toggle, 'Unable to check public access block settings');
+        });
+    });
+});