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

package/dist/hooks/factories/__tests__/useCreateS3LoginHook.test.js

@@ -1,10 +1,10 @@
 import { renderHook, waitFor } from "@testing-library/react";
-import { useCreateS3LoginHook } from "../useCreateS3LoginHook.js";
-import { createS3Client } from "../../../utils/s3Client.js";
+import { createTestWrapper, validateFactoryHook, validateHookResult } from "../../../test/testUtils.js";
 import { createS3OperationError } from "../../../utils/errorHandling.js";
-import { createQueryWrapper, validateFactoryHook, validateHookResult } from "../../../test/testUtils.js";
-jest.mock("../../../utils/s3Client");
-jest.mock("../../../utils/errorHandling");
+import { createS3Client } from "../../../utils/s3Client.js";
+import { useCreateS3LoginHook } from "../useCreateS3LoginHook.js";
+jest.mock('../../../utils/s3Client');
+jest.mock('../../../utils/errorHandling');
 const mockCreateS3Client = createS3Client;
 const mockCreateS3OperationError = createS3OperationError;
 class MockLoginCommand {
@@ -16,33 +16,33 @@ class MockLoginCommand {
 const mockS3Client = {
     send: jest.fn()
 };
-describe("useCreateS3LoginHook - Login Factory Specific", ()=>{
+describe('useCreateS3LoginHook - Login Factory Specific', ()=>{
     const mockLoginConfig = {
-        endpoint: "https://s3.amazonaws.com",
-        region: "us-east-1",
+        endpoint: 'https://s3.amazonaws.com',
+        region: 'us-east-1',
         forcePathStyle: false,
         credentials: {
-            accessKeyId: "test-access-key",
-            secretAccessKey: "test-secret-key"
+            accessKeyId: 'test-access-key',
+            secretAccessKey: 'test-secret-key'
         }
     };
     beforeEach(()=>{
         jest.clearAllMocks();
         mockCreateS3Client.mockReturnValue(mockS3Client);
     });
-    it("should create a functioning login mutation hook", ()=>{
-        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, "S3 Authentication");
-        validateFactoryHook(useLoginMutation, "S3 Authentication");
+    it('should create a functioning login mutation hook', ()=>{
+        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, 'S3 Authentication');
+        validateFactoryHook(useLoginMutation, 'S3 Authentication');
         const { result } = renderHook(()=>useLoginMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
-        validateHookResult(result.current, "mutation");
+        validateHookResult(result.current, 'mutation');
     });
-    it("should authenticate successfully with valid credentials", async ()=>{
+    it('should authenticate successfully with valid credentials', async ()=>{
         mockS3Client.send.mockResolvedValueOnce({});
-        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, "S3 Authentication");
+        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, 'S3 Authentication');
         const { result } = renderHook(()=>useLoginMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         result.current.mutate(mockLoginConfig);
         await waitFor(()=>{
@@ -54,27 +54,27 @@ describe("useCreateS3LoginHook - Login Factory Specific", ()=>{
         });
         expect(mockCreateS3Client).toHaveBeenCalledWith(mockLoginConfig);
     });
-    it("should handle authentication failure", async ()=>{
-        const mockError = new Error("Access Denied");
-        const enhancedError = new Error("Enhanced S3 Authentication Error");
+    it('should handle authentication failure', async ()=>{
+        const mockError = new Error('Access Denied');
+        const enhancedError = new Error('Enhanced S3 Authentication Error');
         mockS3Client.send.mockRejectedValueOnce(mockError);
         mockCreateS3OperationError.mockReturnValueOnce(enhancedError);
-        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, "S3 Authentication");
+        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, 'S3 Authentication');
         const { result } = renderHook(()=>useLoginMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         result.current.mutate(mockLoginConfig);
         await waitFor(()=>{
             expect(result.current.isError).toBe(true);
         });
         expect(result.current.error).toBe(enhancedError);
-        expect(mockCreateS3OperationError).toHaveBeenCalledWith(mockError, "S3 Authentication");
+        expect(mockCreateS3OperationError).toHaveBeenCalledWith(mockError, 'S3 Authentication');
     });
-    it("should create its own S3 client instead of using context client", async ()=>{
+    it('should create its own S3 client instead of using context client', async ()=>{
         mockS3Client.send.mockResolvedValueOnce({});
-        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, "S3 Authentication");
+        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, 'S3 Authentication');
         const { result } = renderHook(()=>useLoginMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         result.current.mutate(mockLoginConfig);
         await waitFor(()=>{
@@ -83,18 +83,18 @@ describe("useCreateS3LoginHook - Login Factory Specific", ()=>{
         expect(mockCreateS3Client).toHaveBeenCalledWith(mockLoginConfig);
         expect(mockCreateS3Client).toHaveBeenCalledTimes(1);
     });
-    it("should handle mutation callbacks correctly", async ()=>{
+    it('should handle mutation callbacks correctly', async ()=>{
         const onSuccess = jest.fn();
         const onError = jest.fn();
         const onSettled = jest.fn();
         mockS3Client.send.mockResolvedValueOnce({});
-        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, "S3 Authentication");
+        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, 'S3 Authentication');
         const { result } = renderHook(()=>useLoginMutation({
                 onSuccess,
                 onError,
                 onSettled
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         result.current.mutate(mockLoginConfig);
         await waitFor(()=>{
@@ -108,34 +108,34 @@ describe("useCreateS3LoginHook - Login Factory Specific", ()=>{
         expect(onError).not.toHaveBeenCalled();
         expect(onSettled).toHaveBeenCalledWith(expectedResult, null, mockLoginConfig, void 0, expect.any(Object));
     });
-    it("should handle network errors during authentication", async ()=>{
-        const networkError = new Error("Network timeout");
-        const enhancedError = new Error("Enhanced Network Error");
+    it('should handle network errors during authentication', async ()=>{
+        const networkError = new Error('Network timeout');
+        const enhancedError = new Error('Enhanced Network Error');
         mockS3Client.send.mockRejectedValueOnce(networkError);
         mockCreateS3OperationError.mockReturnValueOnce(enhancedError);
-        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, "S3 Authentication");
+        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, 'S3 Authentication');
         const { result } = renderHook(()=>useLoginMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         result.current.mutate(mockLoginConfig);
         await waitFor(()=>{
             expect(result.current.isError).toBe(true);
         });
         expect(result.current.error).toBe(enhancedError);
-        expect(mockCreateS3OperationError).toHaveBeenCalledWith(networkError, "S3 Authentication");
+        expect(mockCreateS3OperationError).toHaveBeenCalledWith(networkError, 'S3 Authentication');
     });
-    it("should work with credentials containing session token", async ()=>{
+    it('should work with credentials containing session token', async ()=>{
         const configWithToken = {
             ...mockLoginConfig,
             credentials: {
                 ...mockLoginConfig.credentials,
-                sessionToken: "test-session-token"
+                sessionToken: 'test-session-token'
             }
         };
         mockS3Client.send.mockResolvedValueOnce({});
-        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, "S3 Authentication");
+        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, 'S3 Authentication');
         const { result } = renderHook(()=>useLoginMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         result.current.mutate(configWithToken);
         await waitFor(()=>{
@@ -147,15 +147,15 @@ describe("useCreateS3LoginHook - Login Factory Specific", ()=>{
             authenticated: true
         });
     });
-    it("should handle custom endpoint configurations", async ()=>{
+    it('should handle custom endpoint configurations', async ()=>{
         const customEndpointConfig = {
             ...mockLoginConfig,
-            endpoint: "https://custom-s3.example.com"
+            endpoint: 'https://custom-s3.example.com'
         };
         mockS3Client.send.mockResolvedValueOnce({});
-        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, "S3 Authentication");
+        const useLoginMutation = useCreateS3LoginHook(MockLoginCommand, 'S3 Authentication');
         const { result } = renderHook(()=>useLoginMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         result.current.mutate(customEndpointConfig);
         await waitFor(()=>{

package/dist/hooks/factories/__tests__/useCreateS3MutationHook.test.js

@@ -1,10 +1,10 @@
 import { renderHook, waitFor } from "@testing-library/react";
-import { useCreateS3MutationHook } from "../useCreateS3MutationHook.js";
-import { useS3Client } from "../../useS3Client.js";
+import { createTestWrapper, validateFactoryHook, validateHookResult } from "../../../test/testUtils.js";
 import { createS3OperationError } from "../../../utils/errorHandling.js";
-import { createQueryWrapper, validateFactoryHook, validateHookResult } from "../../../test/testUtils.js";
-jest.mock("../../useS3Client");
-jest.mock("../../../utils/errorHandling");
+import { useS3Client } from "../../useS3Client.js";
+import { useCreateS3MutationHook } from "../useCreateS3MutationHook.js";
+jest.mock('../../useS3Client');
+jest.mock('../../../utils/errorHandling');
 const mockUseS3Client = useS3Client;
 const mockCreateS3OperationError = createS3OperationError;
 class MockCommand {
@@ -16,44 +16,44 @@ class MockCommand {
 const mockS3Client = {
     send: jest.fn()
 };
-describe("useCreateS3MutationHook - Factory Specific", ()=>{
+describe('useCreateS3MutationHook - Factory Specific', ()=>{
     beforeEach(()=>{
         jest.clearAllMocks();
         mockUseS3Client.mockReturnValue(mockS3Client);
     });
-    it("should create a functioning mutation hook", ()=>{
-        const useMutation = useCreateS3MutationHook(MockCommand, "testMutation");
-        validateFactoryHook(useMutation, "testMutation");
+    it('should create a functioning mutation hook', ()=>{
+        const useMutation = useCreateS3MutationHook(MockCommand, 'testMutation');
+        validateFactoryHook(useMutation, 'testMutation');
         const { result } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
-        validateHookResult(result.current, "mutation");
+        validateHookResult(result.current, 'mutation');
     });
-    it("should accept invalidation keys parameter", ()=>{
-        const useMutation = useCreateS3MutationHook(MockCommand, "testMutation", [
-            "ListObjects",
-            "TestQuery"
+    it('should accept invalidation keys parameter', ()=>{
+        const useMutation = useCreateS3MutationHook(MockCommand, 'testMutation', [
+            'ListObjects',
+            'TestQuery'
         ]);
-        validateFactoryHook(useMutation, "testMutation");
+        validateFactoryHook(useMutation, 'testMutation');
         const { result } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
-        validateHookResult(result.current, "mutation");
+        validateHookResult(result.current, 'mutation');
     });
-    it("should execute mutation successfully", async ()=>{
+    it('should execute mutation successfully', async ()=>{
         const mockResponse = {
             success: true,
-            key: "uploaded-file.txt"
+            key: 'uploaded-file.txt'
         };
         mockS3Client.send.mockResolvedValue(mockResponse);
-        const useMutation = useCreateS3MutationHook(MockCommand, "PutObject");
+        const useMutation = useCreateS3MutationHook(MockCommand, 'PutObject');
         const { result } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         result.current.mutate({
-            Bucket: "test-bucket",
-            Key: "test-file.txt",
-            Body: "content"
+            Bucket: 'test-bucket',
+            Key: 'test-file.txt',
+            Body: 'content'
         });
         await waitFor(()=>{
             expect(result.current.isSuccess).toBe(true);
@@ -61,32 +61,32 @@ describe("useCreateS3MutationHook - Factory Specific", ()=>{
         expect(result.current.data).toEqual(mockResponse);
         expect(mockS3Client.send).toHaveBeenCalledWith(expect.objectContaining({
             input: {
-                Bucket: "test-bucket",
-                Key: "test-file.txt",
-                Body: "content"
+                Bucket: 'test-bucket',
+                Key: 'test-file.txt',
+                Body: 'content'
             }
         }));
     });
-    it("should handle mutation errors with proper context", async ()=>{
-        const mockError = new Error("Access Denied");
-        const enhancedError = new Error("Enhanced Access Denied");
+    it('should handle mutation errors with proper context', async ()=>{
+        const mockError = new Error('Access Denied');
+        const enhancedError = new Error('Enhanced Access Denied');
         mockS3Client.send.mockRejectedValue(mockError);
         mockCreateS3OperationError.mockReturnValue(enhancedError);
-        const useMutation = useCreateS3MutationHook(MockCommand, "PutObject");
+        const useMutation = useCreateS3MutationHook(MockCommand, 'PutObject');
         const { result } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         result.current.mutate({
-            Bucket: "test-bucket",
-            Key: "test-file.txt"
+            Bucket: 'test-bucket',
+            Key: 'test-file.txt'
         });
         await waitFor(()=>{
             expect(result.current.isError).toBe(true);
         });
         expect(result.current.error).toBe(enhancedError);
-        expect(mockCreateS3OperationError).toHaveBeenCalledWith(mockError, "PutObject", "test-bucket");
+        expect(mockCreateS3OperationError).toHaveBeenCalledWith(mockError, 'PutObject', 'test-bucket');
     });
-    it("should handle mutation callbacks correctly", async ()=>{
+    it('should handle mutation callbacks correctly', async ()=>{
         const mockResponse = {
             success: true
         };
@@ -94,17 +94,17 @@ describe("useCreateS3MutationHook - Factory Specific", ()=>{
         const onError = jest.fn();
         const onSettled = jest.fn();
         mockS3Client.send.mockResolvedValue(mockResponse);
-        const useMutation = useCreateS3MutationHook(MockCommand, "PutObject");
+        const useMutation = useCreateS3MutationHook(MockCommand, 'PutObject');
         const { result } = renderHook(()=>useMutation({
                 onSuccess,
                 onError,
                 onSettled
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         const variables = {
-            Bucket: "test-bucket",
-            Key: "test-file.txt"
+            Bucket: 'test-bucket',
+            Key: 'test-file.txt'
         };
         result.current.mutate(variables);
         await waitFor(()=>{
@@ -114,28 +114,28 @@ describe("useCreateS3MutationHook - Factory Specific", ()=>{
         expect(onError).not.toHaveBeenCalled();
         expect(onSettled).toHaveBeenCalledWith(mockResponse, null, variables, void 0, expect.any(Object));
     });
-    it("should handle mutation with invalidation keys", async ()=>{
+    it('should handle mutation with invalidation keys', async ()=>{
         const mockResponse = {
             success: true
         };
         mockS3Client.send.mockResolvedValue(mockResponse);
-        const useMutation = useCreateS3MutationHook(MockCommand, "PutObject", [
-            "ListObjects",
-            "TestQuery"
+        const useMutation = useCreateS3MutationHook(MockCommand, 'PutObject', [
+            'ListObjects',
+            'TestQuery'
         ]);
         const { result } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         result.current.mutate({
-            Bucket: "test-bucket",
-            Key: "test-file.txt"
+            Bucket: 'test-bucket',
+            Key: 'test-file.txt'
         });
         await waitFor(()=>{
             expect(result.current.isSuccess).toBe(true);
         });
         expect(result.current.data).toEqual(mockResponse);
     });
-    it("should handle concurrent mutations correctly", async ()=>{
+    it('should handle concurrent mutations correctly', async ()=>{
         const mockResponse1 = {
             success: true,
             id: 1
@@ -149,20 +149,20 @@ describe("useCreateS3MutationHook - Factory Specific", ()=>{
             callCount++;
             return Promise.resolve(1 === callCount ? mockResponse1 : mockResponse2);
         });
-        const useMutation = useCreateS3MutationHook(MockCommand, "PutObject");
+        const useMutation = useCreateS3MutationHook(MockCommand, 'PutObject');
         const { result: result1 } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         const { result: result2 } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         result1.current.mutate({
-            Bucket: "test-bucket",
-            Key: "file1.txt"
+            Bucket: 'test-bucket',
+            Key: 'file1.txt'
         });
         result2.current.mutate({
-            Bucket: "test-bucket",
-            Key: "file2.txt"
+            Bucket: 'test-bucket',
+            Key: 'file2.txt'
         });
         await waitFor(()=>{
             expect(result1.current.isSuccess).toBe(true);
@@ -172,7 +172,7 @@ describe("useCreateS3MutationHook - Factory Specific", ()=>{
         expect(result2.current.data).toEqual(mockResponse2);
         expect(mockS3Client.send).toHaveBeenCalledTimes(2);
     });
-    it("should pass command correctly for mutations", async ()=>{
+    it('should pass command correctly for mutations', async ()=>{
         let capturedCommand;
         mockS3Client.send.mockImplementation((command)=>{
             capturedCommand = command;
@@ -180,21 +180,21 @@ describe("useCreateS3MutationHook - Factory Specific", ()=>{
                 success: true
             });
         });
-        const useMutation = useCreateS3MutationHook(MockCommand, "PutObject");
+        const useMutation = useCreateS3MutationHook(MockCommand, 'PutObject');
         const { result } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         result.current.mutate({
-            Bucket: "test-bucket",
-            Key: "test-file.txt"
+            Bucket: 'test-bucket',
+            Key: 'test-file.txt'
         });
         await waitFor(()=>{
             expect(result.current.isSuccess).toBe(true);
         });
         expect(capturedCommand).toBeInstanceOf(MockCommand);
         expect(capturedCommand.input).toEqual({
-            Bucket: "test-bucket",
-            Key: "test-file.txt"
+            Bucket: 'test-bucket',
+            Key: 'test-file.txt'
         });
     });
 });