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

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

@@ -1,10 +1,10 @@
 import { renderHook, waitFor } from "@testing-library/react";
-import { useCreateS3InfiniteQueryHook } from "../useCreateS3InfiniteQueryHook.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 { useCreateS3InfiniteQueryHook } from "../useCreateS3InfiniteQueryHook.js";
+jest.mock('../../useS3Client');
+jest.mock('../../../utils/errorHandling');
 const mockUseS3Client = useS3Client;
 const mockCreateS3OperationError = createS3OperationError;
 class MockCommand {
@@ -16,82 +16,82 @@ class MockCommand {
 const mockS3Client = {
     send: jest.fn()
 };
-describe("useCreateS3InfiniteQueryHook - Pagination Logic", ()=>{
+describe('useCreateS3InfiniteQueryHook - Pagination Logic', ()=>{
     beforeEach(()=>{
         jest.clearAllMocks();
         mockUseS3Client.mockReturnValue(mockS3Client);
     });
-    it("should create a functioning infinite query hook", ()=>{
-        const useInfiniteQuery = useCreateS3InfiniteQueryHook(MockCommand, "ListObjects");
-        validateFactoryHook(useInfiniteQuery, "ListObjects");
+    it('should create a functioning infinite query hook', ()=>{
+        const useInfiniteQuery = useCreateS3InfiniteQueryHook(MockCommand, 'ListObjects');
+        validateFactoryHook(useInfiniteQuery, 'ListObjects');
         const { result } = renderHook(()=>useInfiniteQuery({
-                Bucket: "test-bucket"
+                Bucket: 'test-bucket'
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
-        validateHookResult(result.current, "infiniteQuery");
+        validateHookResult(result.current, 'infiniteQuery');
     });
-    it("should handle getPaginationParams for different operations", async ()=>{
+    it('should handle getPaginationParams for different operations', async ()=>{
         const mockResponse = {
             IsTruncated: false
         };
         mockS3Client.send.mockResolvedValue(mockResponse);
-        const useListObjects = useCreateS3InfiniteQueryHook(MockCommand, "ListObjects");
+        const useListObjects = useCreateS3InfiniteQueryHook(MockCommand, 'ListObjects');
         const { result: listResult } = renderHook(()=>useListObjects({
-                Bucket: "test-bucket"
+                Bucket: 'test-bucket'
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
-        const useListVersions = useCreateS3InfiniteQueryHook(MockCommand, "ListObjectVersions");
+        const useListVersions = useCreateS3InfiniteQueryHook(MockCommand, 'ListObjectVersions');
         const { result: versionsResult } = renderHook(()=>useListVersions({
-                Bucket: "test-bucket"
+                Bucket: 'test-bucket'
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         await waitFor(()=>{
-            expect(listResult.current.fetchStatus).not.toBe("idle");
-            expect(versionsResult.current.fetchStatus).not.toBe("idle");
+            expect(listResult.current.fetchStatus).not.toBe('idle');
+            expect(versionsResult.current.fetchStatus).not.toBe('idle');
         });
-        expect(typeof listResult.current.fetchNextPage).toBe("function");
-        expect(typeof versionsResult.current.fetchNextPage).toBe("function");
+        expect(typeof listResult.current.fetchNextPage).toBe('function');
+        expect(typeof versionsResult.current.fetchNextPage).toBe('function');
     });
-    it("should handle Prefix parameter in enabled logic correctly", ()=>{
-        const useInfiniteQuery = useCreateS3InfiniteQueryHook(MockCommand, "ListObjects");
+    it('should handle Prefix parameter in enabled logic correctly', ()=>{
+        const useInfiniteQuery = useCreateS3InfiniteQueryHook(MockCommand, 'ListObjects');
         const { result: undefinedResult } = renderHook(()=>useInfiniteQuery({
-                Bucket: "test-bucket",
+                Bucket: 'test-bucket',
                 Prefix: void 0
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
-        expect(undefinedResult.current.fetchStatus).toBe("idle");
+        expect(undefinedResult.current.fetchStatus).toBe('idle');
         const { result: definedResult } = renderHook(()=>useInfiniteQuery({
-                Bucket: "test-bucket",
-                Prefix: "folder/"
+                Bucket: 'test-bucket',
+                Prefix: 'folder/'
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
-        expect(definedResult.current.fetchStatus).not.toBe("idle");
+        expect(definedResult.current.fetchStatus).not.toBe('idle');
     });
-    it("should handle pagination data correctly", async ()=>{
+    it('should handle pagination data correctly', async ()=>{
         const mockFirstPage = {
             Contents: [
                 {
-                    Key: "file1.txt"
+                    Key: 'file1.txt'
                 },
                 {
-                    Key: "file2.txt"
+                    Key: 'file2.txt'
                 }
             ],
             IsTruncated: true,
-            NextContinuationToken: "token123"
+            NextContinuationToken: 'token123'
         };
         const mockSecondPage = {
             Contents: [
                 {
-                    Key: "file3.txt"
+                    Key: 'file3.txt'
                 },
                 {
-                    Key: "file4.txt"
+                    Key: 'file4.txt'
                 }
             ],
             IsTruncated: false
@@ -101,11 +101,11 @@ describe("useCreateS3InfiniteQueryHook - Pagination Logic", ()=>{
             callCount++;
             return Promise.resolve(1 === callCount ? mockFirstPage : mockSecondPage);
         });
-        const useInfiniteQuery = useCreateS3InfiniteQueryHook(MockCommand, "ListObjects");
+        const useInfiniteQuery = useCreateS3InfiniteQueryHook(MockCommand, 'ListObjects');
         const { result } = renderHook(()=>useInfiniteQuery({
-                Bucket: "test-bucket"
+                Bucket: 'test-bucket'
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         await waitFor(()=>{
             expect(result.current.isSuccess).toBe(true);
@@ -123,30 +123,30 @@ describe("useCreateS3InfiniteQueryHook - Pagination Logic", ()=>{
         expect(finalData?.pages?.[1]).toEqual(mockSecondPage);
         expect(result.current.hasNextPage).toBe(false);
     });
-    it("should handle ListObjectVersions pagination patterns", async ()=>{
+    it('should handle ListObjectVersions pagination patterns', async ()=>{
         const mockVersionsResponse = {
             Versions: [
                 {
-                    Key: "file1.txt",
-                    VersionId: "v1"
+                    Key: 'file1.txt',
+                    VersionId: 'v1'
                 }
             ],
             DeleteMarkers: [
                 {
-                    Key: "file2.txt",
-                    VersionId: "v2"
+                    Key: 'file2.txt',
+                    VersionId: 'v2'
                 }
             ],
             IsTruncated: true,
-            NextKeyMarker: "file1.txt",
-            NextVersionIdMarker: "v1"
+            NextKeyMarker: 'file1.txt',
+            NextVersionIdMarker: 'v1'
         };
         mockS3Client.send.mockResolvedValue(mockVersionsResponse);
-        const useVersionsQuery = useCreateS3InfiniteQueryHook(MockCommand, "ListObjectVersions");
+        const useVersionsQuery = useCreateS3InfiniteQueryHook(MockCommand, 'ListObjectVersions');
         const { result } = renderHook(()=>useVersionsQuery({
-                Bucket: "test-bucket"
+                Bucket: 'test-bucket'
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         await waitFor(()=>{
             expect(result.current.isSuccess).toBe(true);
@@ -155,67 +155,67 @@ describe("useCreateS3InfiniteQueryHook - Pagination Logic", ()=>{
         expect(data?.pages).toHaveLength(1);
         expect(data?.pages?.[0]).toEqual(mockVersionsResponse);
         expect(result.current.hasNextPage).toBe(true);
-        expect(mockVersionsResponse.NextKeyMarker).toBe("file1.txt");
-        expect(mockVersionsResponse.NextVersionIdMarker).toBe("v1");
+        expect(mockVersionsResponse.NextKeyMarker).toBe('file1.txt');
+        expect(mockVersionsResponse.NextVersionIdMarker).toBe('v1');
     });
-    it("should handle infinite query errors with context", async ()=>{
-        const mockError = new Error("S3 List Error");
-        const enhancedError = new Error("Enhanced S3 List Error");
+    it('should handle infinite query errors with context', async ()=>{
+        const mockError = new Error('S3 List Error');
+        const enhancedError = new Error('Enhanced S3 List Error');
         mockS3Client.send.mockRejectedValue(mockError);
         mockCreateS3OperationError.mockReturnValue(enhancedError);
-        const useInfiniteQuery = useCreateS3InfiniteQueryHook(MockCommand, "ListObjects");
+        const useInfiniteQuery = useCreateS3InfiniteQueryHook(MockCommand, 'ListObjects');
         const { result } = renderHook(()=>useInfiniteQuery({
-                Bucket: "test-bucket"
+                Bucket: 'test-bucket'
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         await waitFor(()=>{
             expect(result.current.isError).toBe(true);
         });
         expect(result.current.error).toBe(enhancedError);
-        expect(mockCreateS3OperationError).toHaveBeenCalledWith(mockError, "ListObjects", "test-bucket");
+        expect(mockCreateS3OperationError).toHaveBeenCalledWith(mockError, 'ListObjects', 'test-bucket');
     });
-    it("should handle fetchNextPage correctly", async ()=>{
+    it('should handle fetchNextPage correctly', async ()=>{
         const mockFirstPage = {
             Contents: [
                 {
-                    Key: "file1.txt"
+                    Key: 'file1.txt'
                 }
             ],
             IsTruncated: true,
-            NextContinuationToken: "token123"
+            NextContinuationToken: 'token123'
         };
         mockS3Client.send.mockResolvedValue(mockFirstPage);
-        const useInfiniteQuery = useCreateS3InfiniteQueryHook(MockCommand, "ListObjects");
+        const useInfiniteQuery = useCreateS3InfiniteQueryHook(MockCommand, 'ListObjects');
         const { result } = renderHook(()=>useInfiniteQuery({
-                Bucket: "test-bucket"
+                Bucket: 'test-bucket'
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         await waitFor(()=>{
             expect(result.current.isSuccess).toBe(true);
         });
-        expect(typeof result.current.fetchNextPage).toBe("function");
+        expect(typeof result.current.fetchNextPage).toBe('function');
         expect(result.current.isFetchingNextPage).toBe(false);
         expect(result.current.hasNextPage).toBe(true);
         expect(()=>result.current.fetchNextPage()).not.toThrow();
     });
-    it("should handle infinite query options correctly", ()=>{
-        const useInfiniteQuery = useCreateS3InfiniteQueryHook(MockCommand, "ListObjects");
+    it('should handle infinite query options correctly', ()=>{
+        const useInfiniteQuery = useCreateS3InfiniteQueryHook(MockCommand, 'ListObjects');
         const customOptions = {
             enabled: false,
             staleTime: 10000,
             refetchOnWindowFocus: false
         };
         const { result } = renderHook(()=>useInfiniteQuery({
-                Bucket: "test-bucket"
+                Bucket: 'test-bucket'
             }, customOptions), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
-        expect(result.current.fetchStatus).toBe("idle");
+        expect(result.current.fetchStatus).toBe('idle');
         expect(result.current.isLoading).toBe(false);
     });
-    it("should pass AbortSignal correctly for infinite queries", async ()=>{
+    it('should pass AbortSignal correctly for infinite queries', async ()=>{
         let capturedAbortSignal;
         mockS3Client.send.mockImplementation((_command, options)=>{
             capturedAbortSignal = options?.abortSignal;
@@ -224,11 +224,11 @@ describe("useCreateS3InfiniteQueryHook - Pagination Logic", ()=>{
                 IsTruncated: false
             });
         });
-        const useInfiniteQuery = useCreateS3InfiniteQueryHook(MockCommand, "ListObjects");
+        const useInfiniteQuery = useCreateS3InfiniteQueryHook(MockCommand, 'ListObjects');
         const { result } = renderHook(()=>useInfiniteQuery({
-                Bucket: "test-bucket"
+                Bucket: 'test-bucket'
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         await waitFor(()=>{
             expect(result.current.isSuccess).toBe(true);
@@ -236,17 +236,17 @@ describe("useCreateS3InfiniteQueryHook - Pagination Logic", ()=>{
         expect(capturedAbortSignal).toBeInstanceOf(AbortSignal);
         expect(capturedAbortSignal?.aborted).toBe(false);
     });
-    it("should handle empty result sets correctly", async ()=>{
+    it('should handle empty result sets correctly', async ()=>{
         const mockEmptyResponse = {
             Contents: [],
             IsTruncated: false
         };
         mockS3Client.send.mockResolvedValue(mockEmptyResponse);
-        const useInfiniteQuery = useCreateS3InfiniteQueryHook(MockCommand, "ListObjects");
+        const useInfiniteQuery = useCreateS3InfiniteQueryHook(MockCommand, 'ListObjects');
         const { result } = renderHook(()=>useInfiniteQuery({
-                Bucket: "test-bucket"
+                Bucket: 'test-bucket'
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         await waitFor(()=>{
             expect(result.current.isSuccess).toBe(true);

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(()=>{