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

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

@@ -0,0 +1,574 @@
+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";
+import { useCreateBucket, useSetBucketEncryption, useSetBucketObjectLockConfiguration, useSetBucketVersioning } from "../../hooks/index.js";
+import { createMockMutationResult, createTestWrapper } from "../../test/testUtils.js";
+import { BucketCreate } from "../buckets/BucketCreate.js";
+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(),
+        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'),
+        useNavigate: ()=>mockNavigate
+    }));
+jest.mock('@scality/core-ui', ()=>({
+        ...jest.requireActual('@scality/core-ui'),
+        useToast: ()=>({
+                showToast: mockShowToast
+            })
+    }));
+const renderBucketCreate = (props = {})=>{
+    const Wrapper = createTestWrapper();
+    return render(/*#__PURE__*/ jsx(Wrapper, {
+        children: /*#__PURE__*/ jsx(MemoryRouter, {
+            children: /*#__PURE__*/ jsx(BucketCreate, {
+                ...props
+            })
+        })
+    }));
+};
+const mockMutations = {
+    createBucket: jest.fn(),
+    setVersioning: 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);
+    await user_event.type(nameInput, name);
+};
+const submitForm = async ()=>{
+    await waitFor(()=>{
+        const createButton = screen.getByRole('button', {
+            name: /^create$/i
+        });
+        expect(createButton).not.toBeDisabled();
+    }, {
+        timeout: 3000
+    });
+    const createButton = screen.getByRole('button', {
+        name: /^create$/i
+    });
+    await user_event.click(createButton);
+};
+describe('BucketCreate', ()=>{
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        setupMocks();
+    });
+    it('renders form with required fields', ()=>{
+        renderBucketCreate();
+        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();
+    });
+    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.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 ()=>{
+        renderBucketCreate();
+        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 ()=>{
+        renderBucketCreate();
+        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 ()=>{
+        renderBucketCreate();
+        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 ()=>{
+        renderBucketCreate();
+        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 ()=>{
+        renderBucketCreate();
+        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 ()=>{
+        renderBucketCreate();
+        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 ()=>{
+        renderBucketCreate({
+            validationContext: {
+                existingBuckets: [
+                    'existing-bucket',
+                    'another-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 ()=>{
+        renderBucketCreate();
+        const validNames = [
+            'my-bucket-123',
+            'my.bucket.name',
+            'test-bucket.example',
+            '123-bucket-456'
+        ];
+        for (const name of validNames){
+            const input = screen.getByLabelText(/bucket name/i);
+            await user_event.clear(input);
+            await user_event.type(input, name);
+            await user_event.tab();
+            await waitFor(()=>{
+                expect(screen.queryByText(/bucket names must be 3-63 characters/i)).not.toBeInTheDocument();
+                expect(screen.queryByText(/bucket names cannot contain/i)).not.toBeInTheDocument();
+                expect(screen.queryByText(/bucket names must not/i)).not.toBeInTheDocument();
+            });
+        }
+    });
+    it('allows bucket creation when name is unique', async ()=>{
+        renderBucketCreate({
+            validationContext: {
+                existingBuckets: [
+                    'existing-bucket',
+                    'another-bucket'
+                ]
+            }
+        });
+        await fillBucketName('new-unique-bucket');
+        await waitFor(()=>{
+            expect(screen.getByRole('button', {
+                name: /^create$/i
+            })).not.toBeDisabled();
+        });
+    });
+    it('disables create button when form is invalid', ()=>{
+        renderBucketCreate();
+        expect(screen.getByRole('button', {
+            name: /^create$/i
+        })).toBeDisabled();
+    });
+    it('enables create button when bucket name is valid', async ()=>{
+        renderBucketCreate();
+        await fillBucketName('test-bucket');
+        await waitFor(()=>{
+            expect(screen.getByRole('button', {
+                name: /^create$/i
+            })).not.toBeDisabled();
+        });
+    });
+    it('creates bucket with basic configuration', async ()=>{
+        renderBucketCreate();
+        await fillBucketName('test-bucket');
+        await submitForm();
+        expect(mockMutations.createBucket).toHaveBeenCalledWith({
+            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 ()=>{
+        renderBucketCreate();
+        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'
+        });
+        expect(mockNavigate).toHaveBeenCalledWith('/buckets/my-bucket');
+    });
+    it('shows error toast when bucket creation fails', async ()=>{
+        renderBucketCreate();
+        await fillBucketName('test-bucket');
+        await submitForm();
+        const errorCallback = mockMutations.createBucket.mock.calls[0][1].onError;
+        const error = new Error('Bucket already exists');
+        errorCallback(error);
+        expect(mockShowToast).toHaveBeenCalledWith({
+            open: true,
+            message: 'Bucket already exists',
+            status: 'error'
+        });
+    });
+    it('enables versioning when requested', async ()=>{
+        renderBucketCreate();
+        await fillBucketName('test-bucket');
+        const versioningCheckbox = screen.getByRole('checkbox', {
+            name: /versioning/i
+        });
+        await user_event.click(versioningCheckbox);
+        await submitForm();
+        const successCallback = mockMutations.createBucket.mock.calls[0][1].onSuccess;
+        successCallback();
+        expect(mockMutations.setVersioning).toHaveBeenCalledWith({
+            Bucket: 'test-bucket',
+            VersioningConfiguration: {
+                Status: 'Enabled'
+            }
+        }, expect.objectContaining({
+            onSuccess: expect.any(Function),
+            onError: expect.any(Function)
+        }));
+    });
+    it('disables versioning checkbox when object lock is enabled', async ()=>{
+        renderBucketCreate();
+        await fillBucketName('test-bucket');
+        const objectLockCheckbox = screen.getByRole('checkbox', {
+            name: /object-lock/i
+        });
+        await user_event.click(objectLockCheckbox);
+        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 ()=>{
+        renderBucketCreate();
+        await fillBucketName('test-bucket');
+        const objectLockCheckbox = screen.getByRole('checkbox', {
+            name: /object-lock/i
+        });
+        await user_event.click(objectLockCheckbox);
+        await submitForm();
+        expect(mockMutations.createBucket).toHaveBeenCalledWith(expect.objectContaining({
+            ObjectLockEnabledForBucket: true
+        }), expect.any(Object));
+        const successCallback = mockMutations.createBucket.mock.calls[0][1].onSuccess;
+        successCallback();
+        expect(mockMutations.setVersioning).not.toHaveBeenCalled();
+    });
+    it('configures object lock retention when enabled', async ()=>{
+        renderBucketCreate();
+        await fillBucketName('test-bucket');
+        await user_event.click(screen.getByRole('checkbox', {
+            name: /object-lock/i
+        }));
+        await user_event.click(screen.getByRole('checkbox', {
+            name: /default retention/i
+        }));
+        await submitForm();
+        const createSuccessCallback = mockMutations.createBucket.mock.calls[0][1].onSuccess;
+        createSuccessCallback();
+        expect(mockMutations.setVersioning).not.toHaveBeenCalled();
+        expect(mockMutations.setObjectLock).toHaveBeenCalledWith({
+            Bucket: 'test-bucket',
+            ObjectLockConfiguration: {
+                ObjectLockEnabled: 'Enabled',
+                Rule: {
+                    DefaultRetention: {
+                        Mode: 'GOVERNANCE',
+                        Days: 1,
+                        Years: void 0
+                    }
+                }
+            }
+        }, expect.objectContaining({
+            onSuccess: expect.any(Function),
+            onError: expect.any(Function)
+        }));
+    });
+    it('calls custom onSubmit when provided', async ()=>{
+        const customSubmit = jest.fn();
+        renderBucketCreate({
+            onSubmit: customSubmit
+        });
+        await fillBucketName('test-bucket');
+        await submitForm();
+        expect(customSubmit).toHaveBeenCalledWith(expect.objectContaining({
+            name: 'test-bucket',
+            isVersioning: false,
+            isObjectLockEnabled: false
+        }));
+        expect(mockMutations.createBucket).not.toHaveBeenCalled();
+    });
+    it('calls custom onCancel when provided', ()=>{
+        const customCancel = jest.fn();
+        renderBucketCreate({
+            onCancel: customCancel
+        });
+        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', ()=>{
+        renderBucketCreate();
+        const cancelButton = screen.getByRole('button', {
+            name: /cancel/i
+        });
+        fireEvent.click(cancelButton);
+        expect(mockNavigate).toHaveBeenCalledWith('/buckets');
+    });
+    it('renders injected children', ()=>{
+        renderBucketCreate({
+            children: /*#__PURE__*/ jsx("div", {
+                "data-testid": "custom-field",
+                children: "Custom Field"
+            })
+        });
+        expect(screen.getByTestId('custom-field')).toBeInTheDocument();
+    });
+    it('shows loading state during bucket creation', async ()=>{
+        renderBucketCreate();
+        await fillBucketName('test-bucket');
+        await submitForm();
+        setupMocks({
+            isPending: true
+        });
+        expect(mockMutations.createBucket).toHaveBeenCalled();
+    });
+    it('shows error toast when versioning configuration fails', async ()=>{
+        renderBucketCreate();
+        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');
+        versioningErrorCallback(error);
+        expect(mockShowToast).toHaveBeenCalledWith({
+            open: true,
+            message: 'Failed to enable versioning',
+            status: 'error'
+        });
+    });
+    it('shows error toast when object lock configuration fails', async ()=>{
+        renderBucketCreate();
+        await fillBucketName('test-bucket');
+        await user_event.click(screen.getByRole('checkbox', {
+            name: /object-lock/i
+        }));
+        await user_event.click(screen.getByRole('checkbox', {
+            name: /default retention/i
+        }));
+        await submitForm();
+        const createSuccessCallback = mockMutations.createBucket.mock.calls[0][1].onSuccess;
+        createSuccessCallback();
+        expect(mockMutations.setVersioning).not.toHaveBeenCalled();
+        const objectLockErrorCallback = mockMutations.setObjectLock.mock.calls[0][1].onError;
+        const error = new Error('Failed to configure retention');
+        objectLockErrorCallback(error);
+        expect(mockShowToast).toHaveBeenCalledWith({
+            open: true,
+            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 {};