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

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

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

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

@@ -0,0 +1,348 @@
+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";
+import { useGetBucketNotification, useSetBucketNotification } from "../../hooks/index.js";
+import { createTestWrapper } from "../../test/testUtils.js";
+import { BucketNotificationFormPage } from "../buckets/notifications/BucketNotificationFormPage.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', ()=>({
+        ...jest.requireActual('react-router'),
+        useNavigate: ()=>mockNavigate
+    }));
+const renderCreatePage = (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(BucketNotificationFormPage, {})
+                })
+            })
+        })
+    }));
+};
+const renderEditPage = (bucketName = 'test-bucket', ruleId = 'existing-rule')=>{
+    const Wrapper = createTestWrapper();
+    return render(/*#__PURE__*/ jsx(MemoryRouter, {
+        initialEntries: [
+            `/buckets/${bucketName}/notifications/edit/${ruleId}`
+        ],
+        children: /*#__PURE__*/ jsx(Wrapper, {
+            children: /*#__PURE__*/ jsx(Routes, {
+                children: /*#__PURE__*/ jsx(Route, {
+                    path: "/buckets/:bucketName/notifications/edit/:ruleId",
+                    element: /*#__PURE__*/ jsx(BucketNotificationFormPage, {})
+                })
+            })
+        })
+    }));
+};
+describe('BucketNotificationFormPage', ()=>{
+    const mockMutate = jest.fn();
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockNavigate.mockClear();
+        mockUseGetBucketNotification.mockReturnValue({
+            data: void 0,
+            status: 'success'
+        });
+        mockUseSetBucketNotification.mockReturnValue({
+            mutate: mockMutate,
+            isPending: false
+        });
+    });
+    describe('Create Mode', ()=>{
+        it('renders create notification form with all fields', ()=>{
+            renderCreatePage();
+            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', ()=>{
+            renderCreatePage();
+            expect(screen.getByRole('button', {
+                name: /create/i
+            })).toBeDisabled();
+        });
+        it('shows validation error when rule name is empty', async ()=>{
+            renderCreatePage();
+            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,
+                status: 'success'
+            });
+            renderCreatePage();
+            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 ()=>{
+            renderCreatePage();
+            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('enables create button when form is valid', async ()=>{
+            renderCreatePage();
+            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 ()=>{
+            renderCreatePage();
+            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?tab=notification');
+            });
+        });
+        it('handles cancel button click and navigates back', ()=>{
+            renderCreatePage();
+            const cancelButton = screen.getByRole('button', {
+                name: /cancel/i
+            });
+            fireEvent.click(cancelButton);
+            expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket?tab=notification');
+        });
+        it('shows loading state while fetching notification data', ()=>{
+            mockUseGetBucketNotification.mockReturnValue({
+                data: void 0,
+                status: 'pending'
+            });
+            renderCreatePage();
+            expect(screen.getByText(/loading/i)).toBeInTheDocument();
+        });
+        it('shows error message when notification data fails to load', ()=>{
+            mockUseGetBucketNotification.mockReturnValue({
+                data: void 0,
+                status: 'error',
+                error: new Error('Failed to fetch notification configuration')
+            });
+            renderCreatePage();
+            expect(screen.getByText(/failed to fetch notification configuration/i)).toBeInTheDocument();
+        });
+        it('shows generic error message when error is not an Error instance', ()=>{
+            mockUseGetBucketNotification.mockReturnValue({
+                data: void 0,
+                status: 'error',
+                error: 'Unknown error'
+            });
+            renderCreatePage();
+            expect(screen.getByText(/failed to load notification configuration/i)).toBeInTheDocument();
+        });
+    });
+    describe('Edit Mode', ()=>{
+        const existingConfig = {
+            QueueConfigurations: [
+                {
+                    Id: 'existing-rule',
+                    QueueArn: 'arn:aws:sqs:us-east-1:123:existing-queue',
+                    Events: [
+                        's3:ObjectCreated:Put',
+                        's3:ObjectRemoved:Delete'
+                    ],
+                    Filter: {
+                        Key: {
+                            FilterRules: [
+                                {
+                                    Name: 'prefix',
+                                    Value: 'data/'
+                                },
+                                {
+                                    Name: 'suffix',
+                                    Value: '.json'
+                                }
+                            ]
+                        }
+                    }
+                }
+            ]
+        };
+        beforeEach(()=>{
+            mockUseGetBucketNotification.mockReturnValue({
+                data: existingConfig,
+                status: 'success'
+            });
+        });
+        it('renders edit notification form with correct title', ()=>{
+            renderEditPage();
+            expect(screen.getByText('Edit Bucket Notification')).toBeInTheDocument();
+        });
+        it('displays rule name as read-only text in edit mode', ()=>{
+            renderEditPage();
+            expect(screen.getByText('existing-rule')).toBeInTheDocument();
+            expect(screen.queryByRole('textbox', {
+                name: /rule name/i
+            })).not.toBeInTheDocument();
+        });
+        it('pre-fills form with existing rule data', async ()=>{
+            renderEditPage();
+            await waitFor(()=>{
+                expect(screen.getByLabelText(/destination queue/i)).toHaveValue('arn:aws:sqs:us-east-1:123:existing-queue');
+                expect(screen.getByLabelText(/prefix/i)).toHaveValue('data/');
+                expect(screen.getByLabelText(/suffix/i)).toHaveValue('.json');
+            });
+        });
+        it('shows Save button instead of Create in edit mode', ()=>{
+            renderEditPage();
+            expect(screen.getByRole('button', {
+                name: /save/i
+            })).toBeInTheDocument();
+            expect(screen.queryByRole('button', {
+                name: /create/i
+            })).not.toBeInTheDocument();
+        });
+        it('updates notification and navigates on success', async ()=>{
+            renderEditPage();
+            await waitFor(()=>{
+                expect(screen.getByLabelText(/destination queue/i)).toHaveValue('arn:aws:sqs:us-east-1:123:existing-queue');
+            });
+            const queueInput = screen.getByLabelText(/destination queue/i);
+            await user_event.clear(queueInput);
+            await user_event.type(queueInput, 'arn:aws:sqs:us-east-1:123:updated-queue');
+            mockMutate.mockImplementation((_, options)=>{
+                options?.onSuccess?.();
+            });
+            const saveButton = screen.getByRole('button', {
+                name: /save/i
+            });
+            await waitFor(()=>expect(saveButton).toBeEnabled());
+            fireEvent.click(saveButton);
+            await waitFor(()=>{
+                expect(mockMutate).toHaveBeenCalledWith(expect.objectContaining({
+                    Bucket: 'test-bucket',
+                    NotificationConfiguration: {
+                        QueueConfigurations: [
+                            expect.objectContaining({
+                                Id: 'existing-rule',
+                                QueueArn: 'arn:aws:sqs:us-east-1:123:updated-queue'
+                            })
+                        ]
+                    }
+                }), expect.any(Object));
+                expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket?tab=notification');
+            });
+        });
+        it('shows error message when rule not found', ()=>{
+            mockUseGetBucketNotification.mockReturnValue({
+                data: {
+                    QueueConfigurations: []
+                },
+                status: 'success'
+            });
+            renderEditPage('test-bucket', 'non-existent-rule');
+            expect(screen.getByText(/notification rule not found/i)).toBeInTheDocument();
+        });
+        it('shows error message when rule exists but has no Id', ()=>{
+            mockUseGetBucketNotification.mockReturnValue({
+                data: {
+                    QueueConfigurations: [
+                        {
+                            Id: void 0,
+                            QueueArn: 'arn:aws:sqs:us-east-1:123:queue',
+                            Events: [
+                                's3:ObjectCreated:*'
+                            ]
+                        }
+                    ]
+                },
+                status: 'success'
+            });
+            renderEditPage('test-bucket', 'undefined');
+            expect(screen.getByText(/notification rule not found/i)).toBeInTheDocument();
+        });
+        it('handles cancel button click in edit mode', ()=>{
+            renderEditPage();
+            const cancelButton = screen.getByRole('button', {
+                name: /cancel/i
+            });
+            fireEvent.click(cancelButton);
+            expect(mockNavigate).toHaveBeenCalledWith('/buckets/test-bucket?tab=notification');
+        });
+    });
+});

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

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