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

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

@@ -1,26 +1,54 @@
+import * as __rspack_external__providers_DataBrowserProvider_js_b116b609 from "../providers/DataBrowserProvider.js";
 import { jsx } from "react/jsx-runtime";
 import { fireEvent, render, screen, waitFor } from "@testing-library/react";
 import user_event from "@testing-library/user-event";
-import { MemoryRouter } from "react-router-dom";
+import { MemoryRouter } from "react-router";
+import { useCreateBucket, useSetBucketEncryption, useSetBucketObjectLockConfiguration, useSetBucketVersioning } from "../../hooks/index.js";
 import { createMockMutationResult, createTestWrapper } from "../../test/testUtils.js";
 import { BucketCreate } from "../buckets/BucketCreate.js";
-import { useCreateBucket, useSetBucketObjectLockConfiguration, useSetBucketVersioning } from "../../hooks/index.js";
-jest.mock("../../hooks", ()=>({
+var __webpack_modules__ = {
+    "../providers/DataBrowserProvider" (module) {
+        module.exports = __rspack_external__providers_DataBrowserProvider_js_b116b609;
+    }
+};
+var __webpack_module_cache__ = {};
+function __webpack_require__(moduleId) {
+    var cachedModule = __webpack_module_cache__[moduleId];
+    if (void 0 !== cachedModule) return cachedModule.exports;
+    var module = __webpack_module_cache__[moduleId] = {
+        exports: {}
+    };
+    __webpack_modules__[moduleId](module, module.exports, __webpack_require__);
+    return module.exports;
+}
+jest.mock('../../hooks', ()=>({
         useCreateBucket: jest.fn(),
         useSetBucketVersioning: jest.fn(),
-        useSetBucketObjectLockConfiguration: jest.fn()
+        useSetBucketObjectLockConfiguration: jest.fn(),
+        useSetBucketEncryption: jest.fn()
+    }));
+jest.mock('../providers/DataBrowserProvider', ()=>({
+        ...jest.requireActual('../providers/DataBrowserProvider'),
+        useDataBrowserConfig: jest.fn(()=>({
+                s3Capabilities: {
+                    bucketEncryption: false
+                }
+            }))
     }));
 const mockUseCreateBucket = jest.mocked(useCreateBucket);
 const mockUseSetBucketVersioning = jest.mocked(useSetBucketVersioning);
 const mockUseSetBucketObjectLockConfiguration = jest.mocked(useSetBucketObjectLockConfiguration);
+const mockUseSetBucketEncryption = jest.mocked(useSetBucketEncryption);
+const { useDataBrowserConfig } = __webpack_require__("../providers/DataBrowserProvider");
+const mockUseDataBrowserConfig = jest.mocked(useDataBrowserConfig);
 const mockNavigate = jest.fn();
 const mockShowToast = jest.fn();
-jest.mock("react-router", ()=>({
-        ...jest.requireActual("react-router"),
+jest.mock('react-router', ()=>({
+        ...jest.requireActual('react-router'),
         useNavigate: ()=>mockNavigate
     }));
-jest.mock("@scality/core-ui", ()=>({
-        ...jest.requireActual("@scality/core-ui"),
+jest.mock('@scality/core-ui', ()=>({
+        ...jest.requireActual('@scality/core-ui'),
         useToast: ()=>({
                 showToast: mockShowToast
             })
@@ -38,12 +66,14 @@ const renderBucketCreate = (props = {})=>{
 const mockMutations = {
     createBucket: jest.fn(),
     setVersioning: jest.fn(),
-    setObjectLock: jest.fn()
+    setObjectLock: jest.fn(),
+    setBucketEncryption: jest.fn()
 };
 const setupMocks = (overrides = {})=>{
     mockUseCreateBucket.mockReturnValue(createMockMutationResult(mockMutations.createBucket, overrides));
     mockUseSetBucketVersioning.mockReturnValue(createMockMutationResult(mockMutations.setVersioning));
     mockUseSetBucketObjectLockConfiguration.mockReturnValue(createMockMutationResult(mockMutations.setObjectLock));
+    mockUseSetBucketEncryption.mockReturnValue(createMockMutationResult(mockMutations.setBucketEncryption));
 };
 const fillBucketName = async (name)=>{
     const nameInput = screen.getByLabelText(/bucket name/i);
@@ -51,108 +81,108 @@ const fillBucketName = async (name)=>{
 };
 const submitForm = async ()=>{
     await waitFor(()=>{
-        const createButton = screen.getByRole("button", {
+        const createButton = screen.getByRole('button', {
             name: /^create$/i
         });
         expect(createButton).not.toBeDisabled();
     }, {
         timeout: 3000
     });
-    const createButton = screen.getByRole("button", {
+    const createButton = screen.getByRole('button', {
         name: /^create$/i
     });
     await user_event.click(createButton);
 };
-describe("BucketCreate", ()=>{
+describe('BucketCreate', ()=>{
     beforeEach(()=>{
         jest.clearAllMocks();
         setupMocks();
     });
-    it("renders form with required fields", ()=>{
+    it('renders form with required fields', ()=>{
         renderBucketCreate();
-        expect(screen.getByText("Create a New Bucket")).toBeInTheDocument();
+        expect(screen.getByText('Create a New Bucket')).toBeInTheDocument();
         expect(screen.getByLabelText(/bucket name/i)).toBeInTheDocument();
-        expect(screen.getByText("Versioning")).toBeInTheDocument();
-        expect(screen.getByText("Object-lock")).toBeInTheDocument();
+        expect(screen.getByText('Versioning')).toBeInTheDocument();
+        expect(screen.getByText('Object-lock')).toBeInTheDocument();
     });
-    it("shows validation error for invalid bucket name with uppercase", async ()=>{
+    it('shows validation error for invalid bucket name with uppercase', async ()=>{
         renderBucketCreate();
-        await user_event.type(screen.getByLabelText(/bucket name/i), "INVALID");
+        await user_event.type(screen.getByLabelText(/bucket name/i), 'INVALID');
         await user_event.tab();
         await waitFor(()=>{
             expect(screen.getByText(/bucket names can include only lowercase/i)).toBeInTheDocument();
         });
     });
-    it("shows validation error for bucket name starting with hyphen", async ()=>{
+    it('shows validation error for bucket name starting with hyphen', async ()=>{
         renderBucketCreate();
-        await user_event.type(screen.getByLabelText(/bucket name/i), "-invalid");
+        await user_event.type(screen.getByLabelText(/bucket name/i), '-invalid');
         await user_event.tab();
         await waitFor(()=>{
             expect(screen.getByText(/bucket names can include only lowercase/i)).toBeInTheDocument();
         });
     });
-    it("shows validation error for bucket name ending with hyphen", async ()=>{
+    it('shows validation error for bucket name ending with hyphen', async ()=>{
         renderBucketCreate();
-        await user_event.type(screen.getByLabelText(/bucket name/i), "invalid-");
+        await user_event.type(screen.getByLabelText(/bucket name/i), 'invalid-');
         await user_event.tab();
         await waitFor(()=>{
             expect(screen.getByText(/bucket names can include only lowercase/i)).toBeInTheDocument();
         });
     });
-    it("shows validation error for bucket name with adjacent periods", async ()=>{
+    it('shows validation error for bucket name with adjacent periods', async ()=>{
         renderBucketCreate();
-        await user_event.type(screen.getByLabelText(/bucket name/i), "test..bucket");
+        await user_event.type(screen.getByLabelText(/bucket name/i), 'test..bucket');
         await user_event.tab();
         await waitFor(()=>{
             expect(screen.getByText(/bucket names cannot contain two adjacent periods/i)).toBeInTheDocument();
         });
     });
-    it("shows validation error for bucket name formatted as IP address", async ()=>{
+    it('shows validation error for bucket name formatted as IP address', async ()=>{
         renderBucketCreate();
-        await user_event.type(screen.getByLabelText(/bucket name/i), "192.168.1.1");
+        await user_event.type(screen.getByLabelText(/bucket name/i), '192.168.1.1');
         await user_event.tab();
         await waitFor(()=>{
             expect(screen.getByText(/bucket names must not be formatted as an ip address/i)).toBeInTheDocument();
         });
     });
-    it("shows validation error for bucket name with forbidden prefix", async ()=>{
+    it('shows validation error for bucket name with forbidden prefix', async ()=>{
         renderBucketCreate();
-        await user_event.type(screen.getByLabelText(/bucket name/i), "xn--test");
+        await user_event.type(screen.getByLabelText(/bucket name/i), 'xn--test');
         await user_event.tab();
         await waitFor(()=>{
             expect(screen.getByText(/bucket names must not start with/i)).toBeInTheDocument();
         });
     });
-    it("shows validation error for bucket name with forbidden suffix", async ()=>{
+    it('shows validation error for bucket name with forbidden suffix', async ()=>{
         renderBucketCreate();
-        await user_event.type(screen.getByLabelText(/bucket name/i), "test-s3alias");
+        await user_event.type(screen.getByLabelText(/bucket name/i), 'test-s3alias');
         await user_event.tab();
         await waitFor(()=>{
             expect(screen.getByText(/bucket names must not end with/i)).toBeInTheDocument();
         });
     });
-    it("shows validation error for duplicate bucket name when context provided", async ()=>{
+    it('shows validation error for duplicate bucket name when context provided', async ()=>{
         renderBucketCreate({
             validationContext: {
                 existingBuckets: [
-                    "existing-bucket",
-                    "another-bucket"
+                    'existing-bucket',
+                    'another-bucket'
                 ]
             }
         });
-        await user_event.type(screen.getByLabelText(/bucket name/i), "existing-bucket");
+        await user_event.type(screen.getByLabelText(/bucket name/i), 'existing-bucket');
         await user_event.tab();
         await waitFor(()=>{
             expect(screen.getByText(/a bucket with this name already exists/i)).toBeInTheDocument();
         });
     });
-    it("accepts valid bucket names with dots and hyphens", async ()=>{
+    it('accepts valid bucket names with dots and hyphens', async ()=>{
         renderBucketCreate();
         const validNames = [
-            "my-bucket-123",
-            "my.bucket.name",
-            "test-bucket.example",
-            "123-bucket-456"
+            'my-bucket-123',
+            'my.bucket.name',
+            'test-bucket.example',
+            '123-bucket-456'
         ];
         for (const name of validNames){
             const input = screen.getByLabelText(/bucket name/i);
@@ -166,79 +196,79 @@ describe("BucketCreate", ()=>{
             });
         }
     });
-    it("allows bucket creation when name is unique", async ()=>{
+    it('allows bucket creation when name is unique', async ()=>{
         renderBucketCreate({
             validationContext: {
                 existingBuckets: [
-                    "existing-bucket",
-                    "another-bucket"
+                    'existing-bucket',
+                    'another-bucket'
                 ]
             }
         });
-        await fillBucketName("new-unique-bucket");
+        await fillBucketName('new-unique-bucket');
         await waitFor(()=>{
-            expect(screen.getByRole("button", {
+            expect(screen.getByRole('button', {
                 name: /^create$/i
             })).not.toBeDisabled();
         });
     });
-    it("disables create button when form is invalid", ()=>{
+    it('disables create button when form is invalid', ()=>{
         renderBucketCreate();
-        expect(screen.getByRole("button", {
+        expect(screen.getByRole('button', {
             name: /^create$/i
         })).toBeDisabled();
     });
-    it("enables create button when bucket name is valid", async ()=>{
+    it('enables create button when bucket name is valid', async ()=>{
         renderBucketCreate();
-        await fillBucketName("test-bucket");
+        await fillBucketName('test-bucket');
         await waitFor(()=>{
-            expect(screen.getByRole("button", {
+            expect(screen.getByRole('button', {
                 name: /^create$/i
             })).not.toBeDisabled();
         });
     });
-    it("creates bucket with basic configuration", async ()=>{
+    it('creates bucket with basic configuration', async ()=>{
         renderBucketCreate();
-        await fillBucketName("test-bucket");
+        await fillBucketName('test-bucket');
         await submitForm();
         expect(mockMutations.createBucket).toHaveBeenCalledWith({
-            Bucket: "test-bucket",
+            Bucket: 'test-bucket',
             ObjectLockEnabledForBucket: void 0
         }, expect.objectContaining({
             onSuccess: expect.any(Function),
             onError: expect.any(Function)
         }));
     });
-    it("shows success toast and navigates after bucket creation", async ()=>{
+    it('shows success toast and navigates after bucket creation', async ()=>{
         renderBucketCreate();
-        await fillBucketName("my-bucket");
+        await fillBucketName('my-bucket');
         await submitForm();
         const successCallback = mockMutations.createBucket.mock.calls[0][1].onSuccess;
         successCallback();
         expect(mockShowToast).toHaveBeenCalledWith({
             open: true,
             message: 'Bucket "my-bucket" created successfully',
-            status: "success"
+            status: 'success'
         });
-        expect(mockNavigate).toHaveBeenCalledWith("/buckets/my-bucket");
+        expect(mockNavigate).toHaveBeenCalledWith('/buckets/my-bucket');
     });
-    it("shows error toast when bucket creation fails", async ()=>{
+    it('shows error toast when bucket creation fails', async ()=>{
         renderBucketCreate();
-        await fillBucketName("test-bucket");
+        await fillBucketName('test-bucket');
         await submitForm();
         const errorCallback = mockMutations.createBucket.mock.calls[0][1].onError;
-        const error = new Error("Bucket already exists");
+        const error = new Error('Bucket already exists');
         errorCallback(error);
         expect(mockShowToast).toHaveBeenCalledWith({
             open: true,
-            message: "Bucket already exists",
-            status: "error"
+            message: 'Bucket already exists',
+            status: 'error'
         });
     });
-    it("enables versioning when requested", async ()=>{
+    it('enables versioning when requested', async ()=>{
         renderBucketCreate();
-        await fillBucketName("test-bucket");
-        const versioningCheckbox = screen.getByRole("checkbox", {
+        await fillBucketName('test-bucket');
+        const versioningCheckbox = screen.getByRole('checkbox', {
             name: /versioning/i
         });
         await user_event.click(versioningCheckbox);
@@ -246,32 +276,32 @@ describe("BucketCreate", ()=>{
         const successCallback = mockMutations.createBucket.mock.calls[0][1].onSuccess;
         successCallback();
         expect(mockMutations.setVersioning).toHaveBeenCalledWith({
-            Bucket: "test-bucket",
+            Bucket: 'test-bucket',
             VersioningConfiguration: {
-                Status: "Enabled"
+                Status: 'Enabled'
             }
         }, expect.objectContaining({
             onSuccess: expect.any(Function),
             onError: expect.any(Function)
         }));
     });
-    it("disables versioning checkbox when object lock is enabled", async ()=>{
+    it('disables versioning checkbox when object lock is enabled', async ()=>{
         renderBucketCreate();
-        await fillBucketName("test-bucket");
-        const objectLockCheckbox = screen.getByRole("checkbox", {
+        await fillBucketName('test-bucket');
+        const objectLockCheckbox = screen.getByRole('checkbox', {
             name: /object-lock/i
         });
         await user_event.click(objectLockCheckbox);
-        const versioningCheckbox = screen.getByRole("checkbox", {
+        const versioningCheckbox = screen.getByRole('checkbox', {
             name: /versioning/i
         });
         expect(versioningCheckbox).toBeDisabled();
         expect(screen.getByText(/automatically activated when object-lock is enabled/i)).toBeInTheDocument();
     });
-    it("enables versioning automatically when object lock is enabled", async ()=>{
+    it('enables versioning automatically when object lock is enabled', async ()=>{
         renderBucketCreate();
-        await fillBucketName("test-bucket");
-        const objectLockCheckbox = screen.getByRole("checkbox", {
+        await fillBucketName('test-bucket');
+        const objectLockCheckbox = screen.getByRole('checkbox', {
             name: /object-lock/i
         });
         await user_event.click(objectLockCheckbox);
@@ -283,13 +313,13 @@ describe("BucketCreate", ()=>{
         successCallback();
         expect(mockMutations.setVersioning).not.toHaveBeenCalled();
     });
-    it("configures object lock retention when enabled", async ()=>{
+    it('configures object lock retention when enabled', async ()=>{
         renderBucketCreate();
-        await fillBucketName("test-bucket");
-        await user_event.click(screen.getByRole("checkbox", {
+        await fillBucketName('test-bucket');
+        await user_event.click(screen.getByRole('checkbox', {
             name: /object-lock/i
         }));
-        await user_event.click(screen.getByRole("checkbox", {
+        await user_event.click(screen.getByRole('checkbox', {
             name: /default retention/i
         }));
         await submitForm();
@@ -297,12 +327,12 @@ describe("BucketCreate", ()=>{
         createSuccessCallback();
         expect(mockMutations.setVersioning).not.toHaveBeenCalled();
         expect(mockMutations.setObjectLock).toHaveBeenCalledWith({
-            Bucket: "test-bucket",
+            Bucket: 'test-bucket',
             ObjectLockConfiguration: {
-                ObjectLockEnabled: "Enabled",
+                ObjectLockEnabled: 'Enabled',
                 Rule: {
                     DefaultRetention: {
-                        Mode: "GOVERNANCE",
+                        Mode: 'GOVERNANCE',
                         Days: 1,
                         Years: void 0
                     }
@@ -313,83 +343,83 @@ describe("BucketCreate", ()=>{
             onError: expect.any(Function)
         }));
     });
-    it("calls custom onSubmit when provided", async ()=>{
+    it('calls custom onSubmit when provided', async ()=>{
         const customSubmit = jest.fn();
         renderBucketCreate({
             onSubmit: customSubmit
         });
-        await fillBucketName("test-bucket");
+        await fillBucketName('test-bucket');
         await submitForm();
         expect(customSubmit).toHaveBeenCalledWith(expect.objectContaining({
-            name: "test-bucket",
+            name: 'test-bucket',
             isVersioning: false,
             isObjectLockEnabled: false
         }));
         expect(mockMutations.createBucket).not.toHaveBeenCalled();
     });
-    it("calls custom onCancel when provided", ()=>{
+    it('calls custom onCancel when provided', ()=>{
         const customCancel = jest.fn();
         renderBucketCreate({
             onCancel: customCancel
         });
-        const cancelButton = screen.getByRole("button", {
+        const cancelButton = screen.getByRole('button', {
             name: /cancel/i
         });
         fireEvent.click(cancelButton);
         expect(customCancel).toHaveBeenCalled();
         expect(mockNavigate).not.toHaveBeenCalled();
     });
-    it("navigates to buckets list when cancel is clicked without custom handler", ()=>{
+    it('navigates to buckets list when cancel is clicked without custom handler', ()=>{
         renderBucketCreate();
-        const cancelButton = screen.getByRole("button", {
+        const cancelButton = screen.getByRole('button', {
             name: /cancel/i
         });
         fireEvent.click(cancelButton);
-        expect(mockNavigate).toHaveBeenCalledWith("/buckets");
+        expect(mockNavigate).toHaveBeenCalledWith('/buckets');
     });
-    it("renders injected children", ()=>{
+    it('renders injected children', ()=>{
         renderBucketCreate({
             children: /*#__PURE__*/ jsx("div", {
                 "data-testid": "custom-field",
                 children: "Custom Field"
             })
         });
-        expect(screen.getByTestId("custom-field")).toBeInTheDocument();
+        expect(screen.getByTestId('custom-field')).toBeInTheDocument();
     });
-    it("shows loading state during bucket creation", async ()=>{
+    it('shows loading state during bucket creation', async ()=>{
         renderBucketCreate();
-        await fillBucketName("test-bucket");
+        await fillBucketName('test-bucket');
         await submitForm();
         setupMocks({
             isPending: true
         });
         expect(mockMutations.createBucket).toHaveBeenCalled();
     });
-    it("shows error toast when versioning configuration fails", async ()=>{
+    it('shows error toast when versioning configuration fails', async ()=>{
         renderBucketCreate();
-        await fillBucketName("test-bucket");
-        await user_event.click(screen.getByRole("checkbox", {
+        await fillBucketName('test-bucket');
+        await user_event.click(screen.getByRole('checkbox', {
             name: /versioning/i
         }));
         await submitForm();
         const createSuccessCallback = mockMutations.createBucket.mock.calls[0][1].onSuccess;
         createSuccessCallback();
         const versioningErrorCallback = mockMutations.setVersioning.mock.calls[0][1].onError;
-        const error = new Error("Failed to enable versioning");
+        const error = new Error('Failed to enable versioning');
         versioningErrorCallback(error);
         expect(mockShowToast).toHaveBeenCalledWith({
             open: true,
-            message: "Failed to enable versioning",
-            status: "error"
+            message: 'Failed to enable versioning',
+            status: 'error'
         });
     });
-    it("shows error toast when object lock configuration fails", async ()=>{
+    it('shows error toast when object lock configuration fails', async ()=>{
         renderBucketCreate();
-        await fillBucketName("test-bucket");
-        await user_event.click(screen.getByRole("checkbox", {
+        await fillBucketName('test-bucket');
+        await user_event.click(screen.getByRole('checkbox', {
             name: /object-lock/i
         }));
-        await user_event.click(screen.getByRole("checkbox", {
+        await user_event.click(screen.getByRole('checkbox', {
             name: /default retention/i
         }));
         await submitForm();
@@ -397,12 +427,148 @@ describe("BucketCreate", ()=>{
         createSuccessCallback();
         expect(mockMutations.setVersioning).not.toHaveBeenCalled();
         const objectLockErrorCallback = mockMutations.setObjectLock.mock.calls[0][1].onError;
-        const error = new Error("Failed to configure retention");
+        const error = new Error('Failed to configure retention');
         objectLockErrorCallback(error);
         expect(mockShowToast).toHaveBeenCalledWith({
             open: true,
-            message: "Failed to configure retention",
-            status: "error"
+            message: 'Failed to configure retention',
+            status: 'error'
+        });
+    });
+    describe('Bucket Encryption Feature', ()=>{
+        beforeEach(()=>{
+            mockUseDataBrowserConfig.mockReturnValue({
+                s3Capabilities: {
+                    bucketEncryption: false
+                }
+            });
+        });
+        it('does not show encryption checkbox when feature is disabled', ()=>{
+            mockUseDataBrowserConfig.mockReturnValue({
+                s3Capabilities: {
+                    bucketEncryption: false
+                }
+            });
+            renderBucketCreate();
+            expect(screen.queryByText(/encryption/i)).not.toBeInTheDocument();
+        });
+        it('shows encryption checkbox when feature is enabled', ()=>{
+            mockUseDataBrowserConfig.mockReturnValue({
+                s3Capabilities: {
+                    bucketEncryption: true
+                }
+            });
+            renderBucketCreate();
+            expect(screen.getByText(/encryption/i)).toBeInTheDocument();
+        });
+        it('creates bucket with encryption when enabled', async ()=>{
+            mockUseDataBrowserConfig.mockReturnValue({
+                s3Capabilities: {
+                    bucketEncryption: true
+                }
+            });
+            renderBucketCreate();
+            await fillBucketName('test-bucket');
+            const encryptionCheckbox = screen.getByLabelText(/encryption/i);
+            await user_event.click(encryptionCheckbox);
+            await submitForm();
+            const createSuccessCallback = mockMutations.createBucket.mock.calls[0][1].onSuccess;
+            createSuccessCallback();
+            expect(mockMutations.setBucketEncryption).toHaveBeenCalledWith({
+                Bucket: 'test-bucket',
+                ServerSideEncryptionConfiguration: {
+                    Rules: [
+                        {
+                            ApplyServerSideEncryptionByDefault: {
+                                SSEAlgorithm: 'AES256'
+                            }
+                        }
+                    ]
+                }
+            }, expect.objectContaining({
+                onSuccess: expect.any(Function),
+                onError: expect.any(Function)
+            }));
+        });
+        it('creates bucket without encryption when checkbox not selected', async ()=>{
+            mockUseDataBrowserConfig.mockReturnValue({
+                s3Capabilities: {
+                    bucketEncryption: true
+                }
+            });
+            renderBucketCreate();
+            await fillBucketName('test-bucket');
+            await submitForm();
+            const createSuccessCallback = mockMutations.createBucket.mock.calls[0][1].onSuccess;
+            createSuccessCallback();
+            expect(mockMutations.setBucketEncryption).not.toHaveBeenCalled();
+            expect(mockShowToast).toHaveBeenCalledWith({
+                open: true,
+                message: 'Bucket "test-bucket" created successfully',
+                status: 'success'
+            });
+        });
+        it('applies encryption after versioning when both enabled', async ()=>{
+            mockUseDataBrowserConfig.mockReturnValue({
+                s3Capabilities: {
+                    bucketEncryption: true
+                }
+            });
+            renderBucketCreate();
+            await fillBucketName('test-bucket');
+            await user_event.click(screen.getByLabelText(/versioning/i));
+            await user_event.click(screen.getByLabelText(/encryption/i));
+            await submitForm();
+            const createSuccessCallback = mockMutations.createBucket.mock.calls[0][1].onSuccess;
+            createSuccessCallback();
+            expect(mockMutations.setVersioning).toHaveBeenCalled();
+            const versioningSuccessCallback = mockMutations.setVersioning.mock.calls[0][1].onSuccess;
+            versioningSuccessCallback();
+            expect(mockMutations.setBucketEncryption).toHaveBeenCalledWith(expect.objectContaining({
+                Bucket: 'test-bucket'
+            }), expect.any(Object));
+        });
+        it('applies encryption after object lock retention when enabled', async ()=>{
+            mockUseDataBrowserConfig.mockReturnValue({
+                s3Capabilities: {
+                    bucketEncryption: true
+                }
+            });
+            renderBucketCreate();
+            await fillBucketName('test-bucket');
+            await user_event.click(screen.getByLabelText(/object-lock/i));
+            await user_event.click(screen.getByLabelText(/default retention/i));
+            await user_event.click(screen.getByLabelText(/encryption/i));
+            await submitForm();
+            const createSuccessCallback = mockMutations.createBucket.mock.calls[0][1].onSuccess;
+            createSuccessCallback();
+            expect(mockMutations.setObjectLock).toHaveBeenCalled();
+            const objectLockSuccessCallback = mockMutations.setObjectLock.mock.calls[0][1].onSuccess;
+            objectLockSuccessCallback();
+            expect(mockMutations.setBucketEncryption).toHaveBeenCalledWith(expect.objectContaining({
+                Bucket: 'test-bucket'
+            }), expect.any(Object));
+        });
+        it('shows error toast when encryption configuration fails', async ()=>{
+            mockUseDataBrowserConfig.mockReturnValue({
+                s3Capabilities: {
+                    bucketEncryption: true
+                }
+            });
+            renderBucketCreate();
+            await fillBucketName('test-bucket');
+            await user_event.click(screen.getByLabelText(/encryption/i));
+            await submitForm();
+            const createSuccessCallback = mockMutations.createBucket.mock.calls[0][1].onSuccess;
+            createSuccessCallback();
+            const encryptionErrorCallback = mockMutations.setBucketEncryption.mock.calls[0][1].onError;
+            const error = new Error('Failed to enable encryption');
+            encryptionErrorCallback(error);
+            expect(mockShowToast).toHaveBeenCalledWith({
+                open: true,
+                message: 'Failed to enable encryption',
+                status: 'error'
+            });
         });
     });
 });

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

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