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

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

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

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

@@ -0,0 +1,408 @@
+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 { createMockMutationResult, createTestWrapper } from "../../test/testUtils.js";
+import { BucketCreate } from "../buckets/BucketCreate.js";
+import { useCreateBucket, useSetBucketObjectLockConfiguration, useSetBucketVersioning } from "../../hooks/index.js";
+jest.mock("../../hooks", ()=>({
+        useCreateBucket: jest.fn(),
+        useSetBucketVersioning: jest.fn(),
+        useSetBucketObjectLockConfiguration: jest.fn()
+    }));
+const mockUseCreateBucket = jest.mocked(useCreateBucket);
+const mockUseSetBucketVersioning = jest.mocked(useSetBucketVersioning);
+const mockUseSetBucketObjectLockConfiguration = jest.mocked(useSetBucketObjectLockConfiguration);
+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()
+};
+const setupMocks = (overrides = {})=>{
+    mockUseCreateBucket.mockReturnValue(createMockMutationResult(mockMutations.createBucket, overrides));
+    mockUseSetBucketVersioning.mockReturnValue(createMockMutationResult(mockMutations.setVersioning));
+    mockUseSetBucketObjectLockConfiguration.mockReturnValue(createMockMutationResult(mockMutations.setObjectLock));
+};
+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"
+        });
+    });
+});

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

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