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

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

@@ -0,0 +1,316 @@
+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, Route, Routes } from "react-router-dom";
+import { createTestWrapper } from "../../test/testUtils.js";
+import { BucketNotificationCreatePage } from "../buckets/notifications/BucketNotificationCreatePage.js";
+import { useGetBucketNotification, useSetBucketNotification } from "../../hooks/index.js";
+jest.mock("../../hooks", ()=>({
+        useGetBucketNotification: jest.fn(),
+        useSetBucketNotification: jest.fn()
+    }));
+const mockUseGetBucketNotification = jest.mocked(useGetBucketNotification);
+const mockUseSetBucketNotification = jest.mocked(useSetBucketNotification);
+const mockNavigate = jest.fn();
+jest.mock("react-router-dom", ()=>({
+        ...jest.requireActual("react-router-dom"),
+        useNavigate: ()=>mockNavigate
+    }));
+const renderBucketNotificationCreatePage = (bucketName = "test-bucket")=>{
+    const Wrapper = createTestWrapper();
+    return render(/*#__PURE__*/ jsx(MemoryRouter, {
+        initialEntries: [
+            `/buckets/${bucketName}/notifications/create`
+        ],
+        children: /*#__PURE__*/ jsx(Wrapper, {
+            children: /*#__PURE__*/ jsx(Routes, {
+                children: /*#__PURE__*/ jsx(Route, {
+                    path: "/buckets/:bucketName/notifications/create",
+                    element: /*#__PURE__*/ jsx(BucketNotificationCreatePage, {})
+                })
+            })
+        })
+    }));
+};
+describe("BucketNotificationCreatePage", ()=>{
+    const mockMutate = jest.fn();
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockNavigate.mockClear();
+        mockUseGetBucketNotification.mockReturnValue({
+            data: void 0
+        });
+        mockUseSetBucketNotification.mockReturnValue({
+            mutate: mockMutate,
+            isPending: false
+        });
+    });
+    it("renders create notification form with all fields", ()=>{
+        renderBucketNotificationCreatePage();
+        expect(screen.getByText("Create Bucket Notification")).toBeInTheDocument();
+        expect(screen.getByLabelText(/rule name/i)).toBeInTheDocument();
+        expect(screen.getByText("Events")).toBeInTheDocument();
+        expect(screen.getByLabelText(/destination queue/i)).toBeInTheDocument();
+        expect(screen.getByLabelText(/prefix/i)).toBeInTheDocument();
+        expect(screen.getByLabelText(/suffix/i)).toBeInTheDocument();
+    });
+    it("disables create button when form is pristine", ()=>{
+        renderBucketNotificationCreatePage();
+        expect(screen.getByRole("button", {
+            name: /create/i
+        })).toBeDisabled();
+    });
+    it("shows validation error when rule name is empty", async ()=>{
+        renderBucketNotificationCreatePage();
+        const ruleNameInput = screen.getByLabelText(/rule name/i);
+        await user_event.type(ruleNameInput, "a");
+        await user_event.clear(ruleNameInput);
+        await waitFor(()=>{
+            expect(screen.getByText(/this field is required/i)).toBeInTheDocument();
+        });
+    });
+    it("shows validation error when rule name already exists", async ()=>{
+        const existingConfig = {
+            QueueConfigurations: [
+                {
+                    Id: "existing-rule",
+                    QueueArn: "arn:aws:sqs:us-east-1:123:queue",
+                    Events: [
+                        "s3:ObjectCreated:*"
+                    ]
+                }
+            ]
+        };
+        mockUseGetBucketNotification.mockReturnValue({
+            data: existingConfig
+        });
+        renderBucketNotificationCreatePage();
+        const ruleNameInput = screen.getByLabelText(/rule name/i);
+        await user_event.type(ruleNameInput, "existing-rule");
+        await waitFor(()=>{
+            expect(screen.getByText(/a rule with this name already exists/i)).toBeInTheDocument();
+        });
+    });
+    it("shows validation error when queue ARN is invalid", async ()=>{
+        renderBucketNotificationCreatePage();
+        const queueArnInput = screen.getByLabelText(/destination queue/i);
+        await user_event.type(queueArnInput, "invalid-arn");
+        await waitFor(()=>{
+            expect(screen.getByText(/must be a valid arn/i)).toBeInTheDocument();
+        });
+    });
+    it("shows validation error when no event is selected", async ()=>{
+        renderBucketNotificationCreatePage();
+        const ruleNameInput = screen.getByLabelText(/rule name/i);
+        await user_event.type(ruleNameInput, "test-rule");
+        const queueArnInput = screen.getByLabelText(/destination queue/i);
+        await user_event.type(queueArnInput, "arn:aws:sqs:us-east-1:123:queue");
+        await waitFor(()=>{
+            expect(screen.getByRole("button", {
+                name: /create/i
+            })).toBeDisabled();
+        });
+    });
+    it("enables create button when form is valid", async ()=>{
+        renderBucketNotificationCreatePage();
+        await user_event.type(screen.getByLabelText(/rule name/i), "test-rule");
+        await user_event.type(screen.getByLabelText(/destination queue/i), "arn:aws:sqs:us-east-1:123:queue");
+        const checkbox = screen.getByRole("checkbox", {
+            name: /s3:ObjectCreated:\*/i
+        });
+        fireEvent.click(checkbox);
+        await waitFor(()=>{
+            expect(screen.getByRole("button", {
+                name: /create/i
+            })).toBeEnabled();
+        });
+    });
+    it("creates notification with all fields and navigates on success", async ()=>{
+        renderBucketNotificationCreatePage();
+        await user_event.type(screen.getByLabelText(/rule name/i), "test-rule");
+        await user_event.type(screen.getByLabelText(/destination queue/i), "arn:aws:sqs:us-east-1:123:my-queue");
+        fireEvent.click(screen.getByRole("checkbox", {
+            name: /s3:ObjectCreated:Put/i
+        }));
+        await user_event.type(screen.getByLabelText(/prefix/i), "uploads/");
+        await user_event.type(screen.getByLabelText(/suffix/i), ".jpg");
+        mockMutate.mockImplementation((_, options)=>{
+            options?.onSuccess?.();
+        });
+        const createButton = screen.getByRole("button", {
+            name: /create/i
+        });
+        await waitFor(()=>expect(createButton).toBeEnabled());
+        fireEvent.click(createButton);
+        await waitFor(()=>{
+            expect(mockMutate).toHaveBeenCalledWith({
+                Bucket: "test-bucket",
+                NotificationConfiguration: {
+                    QueueConfigurations: [
+                        {
+                            Id: "test-rule",
+                            QueueArn: "arn:aws:sqs:us-east-1:123:my-queue",
+                            Events: [
+                                "s3:ObjectCreated:Put"
+                            ],
+                            Filter: {
+                                Key: {
+                                    FilterRules: [
+                                        {
+                                            Name: "prefix",
+                                            Value: "uploads/"
+                                        },
+                                        {
+                                            Name: "suffix",
+                                            Value: ".jpg"
+                                        }
+                                    ]
+                                }
+                            }
+                        }
+                    ]
+                }
+            }, expect.any(Object));
+            expect(mockNavigate).toHaveBeenCalledWith("/buckets/test-bucket");
+        });
+    });
+    it("creates notification without filters when not provided", async ()=>{
+        renderBucketNotificationCreatePage();
+        await user_event.type(screen.getByLabelText(/rule name/i), "test-rule");
+        await user_event.type(screen.getByLabelText(/destination queue/i), "arn:aws:sqs:us-east-1:123:my-queue");
+        fireEvent.click(screen.getByRole("checkbox", {
+            name: /s3:ObjectRemoved:\*/i
+        }));
+        mockMutate.mockImplementation((_, options)=>{
+            options?.onSuccess?.();
+        });
+        const createButton = screen.getByRole("button", {
+            name: /create/i
+        });
+        await waitFor(()=>expect(createButton).toBeEnabled());
+        fireEvent.click(createButton);
+        await waitFor(()=>{
+            expect(mockMutate).toHaveBeenCalledWith({
+                Bucket: "test-bucket",
+                NotificationConfiguration: {
+                    QueueConfigurations: [
+                        {
+                            Id: "test-rule",
+                            QueueArn: "arn:aws:sqs:us-east-1:123:my-queue",
+                            Events: [
+                                "s3:ObjectRemoved:*"
+                            ]
+                        }
+                    ]
+                }
+            }, expect.any(Object));
+        });
+    });
+    it("preserves existing queue configurations when creating new notification", async ()=>{
+        const existingConfig = {
+            QueueConfigurations: [
+                {
+                    Id: "existing-rule",
+                    QueueArn: "arn:aws:sqs:us-east-1:123:existing-queue",
+                    Events: [
+                        "s3:ObjectCreated:*"
+                    ]
+                }
+            ]
+        };
+        mockUseGetBucketNotification.mockReturnValue({
+            data: existingConfig
+        });
+        renderBucketNotificationCreatePage();
+        await user_event.type(screen.getByLabelText(/rule name/i), "new-rule");
+        await user_event.type(screen.getByLabelText(/destination queue/i), "arn:aws:sqs:us-east-1:123:new-queue");
+        fireEvent.click(screen.getByRole("checkbox", {
+            name: /^s3:ObjectRemoved:Delete$/i
+        }));
+        mockMutate.mockImplementation((_, options)=>{
+            options?.onSuccess?.();
+        });
+        const createButton = screen.getByRole("button", {
+            name: /create/i
+        });
+        await waitFor(()=>expect(createButton).toBeEnabled());
+        fireEvent.click(createButton);
+        await waitFor(()=>{
+            const call = mockMutate.mock.calls[0][0];
+            expect(call.NotificationConfiguration.QueueConfigurations).toHaveLength(2);
+            expect(call.NotificationConfiguration.QueueConfigurations[0]).toEqual(existingConfig.QueueConfigurations[0]);
+            expect(call.NotificationConfiguration.QueueConfigurations[1]).toMatchObject({
+                Id: "new-rule",
+                QueueArn: "arn:aws:sqs:us-east-1:123:new-queue",
+                Events: [
+                    "s3:ObjectRemoved:Delete"
+                ]
+            });
+        });
+    });
+    it("displays error message when creation fails", async ()=>{
+        renderBucketNotificationCreatePage();
+        await user_event.type(screen.getByLabelText(/rule name/i), "test-rule");
+        await user_event.type(screen.getByLabelText(/destination queue/i), "arn:aws:sqs:us-east-1:123:my-queue");
+        fireEvent.click(screen.getByRole("checkbox", {
+            name: /s3:ObjectCreated:\*/i
+        }));
+        const error = new Error("Access Denied");
+        mockMutate.mockImplementation((_, options)=>{
+            options?.onError?.(error);
+        });
+        const createButton = screen.getByRole("button", {
+            name: /create/i
+        });
+        await waitFor(()=>expect(createButton).toBeEnabled());
+        fireEvent.click(createButton);
+        await waitFor(()=>{
+            expect(mockNavigate).not.toHaveBeenCalled();
+        });
+    });
+    it("handles cancel button click and navigates back", ()=>{
+        renderBucketNotificationCreatePage();
+        const cancelButton = screen.getByRole("button", {
+            name: /cancel/i
+        });
+        fireEvent.click(cancelButton);
+        expect(mockNavigate).toHaveBeenCalledWith("/buckets/test-bucket");
+    });
+    it("allows selecting multiple events", async ()=>{
+        renderBucketNotificationCreatePage();
+        await user_event.type(screen.getByLabelText(/rule name/i), "multi-event");
+        await user_event.type(screen.getByLabelText(/destination queue/i), "arn:aws:sqs:us-east-1:123:queue");
+        fireEvent.click(screen.getByRole("checkbox", {
+            name: /^s3:ObjectCreated:Put$/i
+        }));
+        fireEvent.click(screen.getByRole("checkbox", {
+            name: /^s3:ObjectCreated:Copy$/i
+        }));
+        fireEvent.click(screen.getByRole("checkbox", {
+            name: /^s3:ObjectRemoved:Delete$/i
+        }));
+        mockMutate.mockImplementation((_, options)=>{
+            options?.onSuccess?.();
+        });
+        const createButton = screen.getByRole("button", {
+            name: /create/i
+        });
+        await waitFor(()=>expect(createButton).toBeEnabled());
+        fireEvent.click(createButton);
+        await waitFor(()=>{
+            expect(mockMutate).toHaveBeenCalledWith(expect.objectContaining({
+                NotificationConfiguration: {
+                    QueueConfigurations: [
+                        expect.objectContaining({
+                            Events: expect.arrayContaining([
+                                "s3:ObjectCreated:Put",
+                                "s3:ObjectCreated:Copy",
+                                "s3:ObjectRemoved:Delete"
+                            ])
+                        })
+                    ]
+                }
+            }), expect.any(Object));
+        });
+    });
+});

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

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