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

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

@@ -1,56 +1,56 @@
 import { renderHook, waitFor } from "@testing-library/react";
-import { useCreateS3FunctionMutationHook } 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 { useCreateS3FunctionMutationHook } from "../useCreateS3MutationHook.js";
+jest.mock('../../useS3Client');
+jest.mock('../../../utils/errorHandling');
 const mockUseS3Client = useS3Client;
 const mockCreateS3OperationError = createS3OperationError;
 const mockS3Client = {
     config: {}
 };
 const mockOperation = jest.fn();
-describe("useCreateS3FunctionMutationHook - Factory Specific", ()=>{
+describe('useCreateS3FunctionMutationHook - Factory Specific', ()=>{
     beforeEach(()=>{
         jest.clearAllMocks();
         mockUseS3Client.mockReturnValue(mockS3Client);
         mockOperation.mockReset();
     });
-    it("should create a functioning mutation hook", ()=>{
+    it('should create a functioning mutation hook', ()=>{
         const useMutation = useCreateS3FunctionMutationHook(mockOperation);
-        validateFactoryHook(useMutation, "function-based mutation");
+        validateFactoryHook(useMutation, 'function-based mutation');
         const { result } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
-        validateHookResult(result.current, "mutation");
+        validateHookResult(result.current, 'mutation');
     });
-    it("should accept invalidation keys parameter", ()=>{
+    it('should accept invalidation keys parameter', ()=>{
         const useMutation = useCreateS3FunctionMutationHook(mockOperation, [
-            "PresignedUrls",
-            "TestQuery"
+            'PresignedUrls',
+            'TestQuery'
         ]);
-        validateFactoryHook(useMutation, "function-based mutation");
+        validateFactoryHook(useMutation, 'function-based mutation');
         const { result } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
-        validateHookResult(result.current, "mutation");
+        validateHookResult(result.current, 'mutation');
     });
-    it("should execute function operation successfully", async ()=>{
+    it('should execute function operation successfully', async ()=>{
         const mockResponse = {
-            Url: "https://presigned.url",
+            Url: 'https://presigned.url',
             ExpiresAt: new Date(),
-            Bucket: "test-bucket",
-            Key: "test-key"
+            Bucket: 'test-bucket',
+            Key: 'test-key'
         };
         mockOperation.mockResolvedValue(mockResponse);
         const useMutation = useCreateS3FunctionMutationHook(mockOperation);
         const { result } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         const inputParams = {
-            Bucket: "test-bucket",
-            Key: "test-key",
+            Bucket: 'test-bucket',
+            Key: 'test-key',
             expiresIn: 3600
         };
         result.current.mutate(inputParams);
@@ -61,30 +61,30 @@ describe("useCreateS3FunctionMutationHook - Factory Specific", ()=>{
         expect(mockOperation).toHaveBeenCalledWith(mockS3Client, inputParams);
         expect(mockOperation).toHaveBeenCalledTimes(1);
     });
-    it("should handle function operation errors", async ()=>{
-        const mockError = new Error("Presigned URL generation failed");
+    it('should handle function operation errors', async ()=>{
+        const mockError = new Error('Presigned URL generation failed');
         mockOperation.mockRejectedValue(mockError);
         const useMutation = useCreateS3FunctionMutationHook(mockOperation);
         const { result } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         result.current.mutate({
-            Bucket: "test-bucket",
-            Key: "test-key"
+            Bucket: 'test-bucket',
+            Key: 'test-key'
         });
         await waitFor(()=>{
             expect(result.current.isError).toBe(true);
         });
         expect(result.current.error).toBe(mockError);
         expect(mockOperation).toHaveBeenCalledWith(mockS3Client, {
-            Bucket: "test-bucket",
-            Key: "test-key"
+            Bucket: 'test-bucket',
+            Key: 'test-key'
         });
         expect(mockCreateS3OperationError).not.toHaveBeenCalled();
     });
-    it("should handle function operation with internal error wrapping", async ()=>{
-        const mockInternalError = new Error("Internal operation error");
-        const mockWrappedError = new Error("Wrapped operation error");
+    it('should handle function operation with internal error wrapping', async ()=>{
+        const mockInternalError = new Error('Internal operation error');
+        const mockWrappedError = new Error('Wrapped operation error');
         const mockOperationWithErrorHandling = jest.fn().mockImplementation(async ()=>{
             try {
                 throw mockInternalError;
@@ -95,24 +95,24 @@ describe("useCreateS3FunctionMutationHook - Factory Specific", ()=>{
         });
         const useMutation = useCreateS3FunctionMutationHook(mockOperationWithErrorHandling);
         const { result } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         result.current.mutate({
-            Bucket: "test-bucket",
-            Key: "test-key"
+            Bucket: 'test-bucket',
+            Key: 'test-key'
         });
         await waitFor(()=>{
             expect(result.current.isError).toBe(true);
         });
         expect(result.current.error).toBe(mockWrappedError);
         expect(mockOperationWithErrorHandling).toHaveBeenCalledWith(mockS3Client, {
-            Bucket: "test-bucket",
-            Key: "test-key"
+            Bucket: 'test-bucket',
+            Key: 'test-key'
         });
     });
-    it("should handle mutation callbacks correctly", async ()=>{
+    it('should handle mutation callbacks correctly', async ()=>{
         const mockResponse = {
-            Url: "https://presigned.url",
+            Url: 'https://presigned.url',
             ExpiresAt: new Date()
         };
         const onSuccess = jest.fn();
@@ -125,11 +125,11 @@ describe("useCreateS3FunctionMutationHook - Factory Specific", ()=>{
                 onError,
                 onSettled
             }), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         const variables = {
-            Bucket: "test-bucket",
-            Key: "test-key"
+            Bucket: 'test-bucket',
+            Key: 'test-key'
         };
         result.current.mutate(variables);
         await waitFor(()=>{
@@ -139,38 +139,38 @@ describe("useCreateS3FunctionMutationHook - Factory Specific", ()=>{
         expect(onError).not.toHaveBeenCalled();
         expect(onSettled).toHaveBeenCalledWith(mockResponse, null, variables, void 0, expect.any(Object));
     });
-    it("should handle function operation with invalidation keys", async ()=>{
+    it('should handle function operation with invalidation keys', async ()=>{
         const mockResponse = {
             success: true
         };
         mockOperation.mockResolvedValue(mockResponse);
         const useMutation = useCreateS3FunctionMutationHook(mockOperation, [
-            "PresignedUrls",
-            "ObjectList"
+            'PresignedUrls',
+            'ObjectList'
         ]);
         const { result } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         result.current.mutate({
-            Bucket: "test-bucket",
-            Key: "test-key"
+            Bucket: 'test-bucket',
+            Key: 'test-key'
         });
         await waitFor(()=>{
             expect(result.current.isSuccess).toBe(true);
         });
         expect(result.current.data).toEqual(mockResponse);
         expect(mockOperation).toHaveBeenCalledWith(mockS3Client, {
-            Bucket: "test-bucket",
-            Key: "test-key"
+            Bucket: 'test-bucket',
+            Key: 'test-key'
         });
     });
-    it("should handle concurrent function operations correctly", async ()=>{
+    it('should handle concurrent function operations correctly', async ()=>{
         const mockResponse1 = {
-            Url: "https://presigned1.url",
+            Url: 'https://presigned1.url',
             ExpiresAt: new Date()
         };
         const mockResponse2 = {
-            Url: "https://presigned2.url",
+            Url: 'https://presigned2.url',
             ExpiresAt: new Date()
         };
         let callCount = 0;
@@ -180,18 +180,18 @@ describe("useCreateS3FunctionMutationHook - Factory Specific", ()=>{
         });
         const useMutation = useCreateS3FunctionMutationHook(mockOperation);
         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);
@@ -201,7 +201,7 @@ describe("useCreateS3FunctionMutationHook - Factory Specific", ()=>{
         expect(result2.current.data).toEqual(mockResponse2);
         expect(mockOperation).toHaveBeenCalledTimes(2);
     });
-    it("should pass correct parameters to function operation", async ()=>{
+    it('should pass correct parameters to function operation', async ()=>{
         const mockResponse = {
             success: true
         };
@@ -214,12 +214,12 @@ describe("useCreateS3FunctionMutationHook - Factory Specific", ()=>{
         });
         const useMutation = useCreateS3FunctionMutationHook(mockOperation);
         const { result } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         const inputParams = {
-            Bucket: "test-bucket",
-            Key: "test-key",
-            ContentType: "text/plain",
+            Bucket: 'test-bucket',
+            Key: 'test-key',
+            ContentType: 'text/plain',
             expiresIn: 1800
         };
         result.current.mutate(inputParams);
@@ -229,25 +229,25 @@ describe("useCreateS3FunctionMutationHook - Factory Specific", ()=>{
         expect(capturedClient).toBe(mockS3Client);
         expect(capturedParams).toEqual(inputParams);
     });
-    it("should handle complex function operations with metadata", async ()=>{
+    it('should handle complex function operations with metadata', async ()=>{
         const mockResponse = {
-            Url: "https://complex-presigned.url",
-            ExpiresAt: new Date("2024-01-01T12:00:00Z"),
-            Bucket: "complex-bucket",
-            Key: "complex/path/file.txt",
-            VersionId: "version123"
+            Url: 'https://complex-presigned.url',
+            ExpiresAt: new Date('2024-01-01T12:00:00Z'),
+            Bucket: 'complex-bucket',
+            Key: 'complex/path/file.txt',
+            VersionId: 'version123'
         };
         mockOperation.mockResolvedValue(mockResponse);
         const useMutation = useCreateS3FunctionMutationHook(mockOperation);
         const { result } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         const complexParams = {
-            Bucket: "complex-bucket",
-            Key: "complex/path/file.txt",
-            VersionId: "version123",
-            ResponseContentType: "application/json",
-            ResponseContentDisposition: "attachment; filename=data.json",
+            Bucket: 'complex-bucket',
+            Key: 'complex/path/file.txt',
+            VersionId: 'version123',
+            ResponseContentType: 'application/json',
+            ResponseContentDisposition: 'attachment; filename=data.json',
             expiresIn: 7200
         };
         result.current.mutate(complexParams);
@@ -257,14 +257,14 @@ describe("useCreateS3FunctionMutationHook - Factory Specific", ()=>{
         expect(result.current.data).toEqual(mockResponse);
         expect(mockOperation).toHaveBeenCalledWith(mockS3Client, complexParams);
     });
-    it("should handle function operations without parameters", async ()=>{
+    it('should handle function operations without parameters', async ()=>{
         const mockResponse = {
-            status: "operation completed"
+            status: 'operation completed'
         };
         mockOperation.mockResolvedValue(mockResponse);
         const useMutation = useCreateS3FunctionMutationHook(mockOperation);
         const { result } = renderHook(()=>useMutation(), {
-            wrapper: createQueryWrapper()
+            wrapper: createTestWrapper()
         });
         result.current.mutate(void 0);
         await waitFor(()=>{

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);