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

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

@@ -0,0 +1,276 @@
+import { renderHook, waitFor } from "@testing-library/react";
+import { useCreateS3FunctionMutationHook } from "../useCreateS3MutationHook.js";
+import { useS3Client } from "../../useS3Client.js";
+import { createS3OperationError } from "../../../utils/errorHandling.js";
+import { createQueryWrapper, validateFactoryHook, validateHookResult } from "../../../test/testUtils.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", ()=>{
+    beforeEach(()=>{
+        jest.clearAllMocks();
+        mockUseS3Client.mockReturnValue(mockS3Client);
+        mockOperation.mockReset();
+    });
+    it("should create a functioning mutation hook", ()=>{
+        const useMutation = useCreateS3FunctionMutationHook(mockOperation);
+        validateFactoryHook(useMutation, "function-based mutation");
+        const { result } = renderHook(()=>useMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        validateHookResult(result.current, "mutation");
+    });
+    it("should accept invalidation keys parameter", ()=>{
+        const useMutation = useCreateS3FunctionMutationHook(mockOperation, [
+            "PresignedUrls",
+            "TestQuery"
+        ]);
+        validateFactoryHook(useMutation, "function-based mutation");
+        const { result } = renderHook(()=>useMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        validateHookResult(result.current, "mutation");
+    });
+    it("should execute function operation successfully", async ()=>{
+        const mockResponse = {
+            Url: "https://presigned.url",
+            ExpiresAt: new Date(),
+            Bucket: "test-bucket",
+            Key: "test-key"
+        };
+        mockOperation.mockResolvedValue(mockResponse);
+        const useMutation = useCreateS3FunctionMutationHook(mockOperation);
+        const { result } = renderHook(()=>useMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        const inputParams = {
+            Bucket: "test-bucket",
+            Key: "test-key",
+            expiresIn: 3600
+        };
+        result.current.mutate(inputParams);
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        expect(result.current.data).toEqual(mockResponse);
+        expect(mockOperation).toHaveBeenCalledWith(mockS3Client, inputParams);
+        expect(mockOperation).toHaveBeenCalledTimes(1);
+    });
+    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()
+        });
+        result.current.mutate({
+            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"
+        });
+        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");
+        const mockOperationWithErrorHandling = jest.fn().mockImplementation(async ()=>{
+            try {
+                throw mockInternalError;
+            } catch (error) {
+                const wrappedError = mockWrappedError;
+                throw wrappedError;
+            }
+        });
+        const useMutation = useCreateS3FunctionMutationHook(mockOperationWithErrorHandling);
+        const { result } = renderHook(()=>useMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        result.current.mutate({
+            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"
+        });
+    });
+    it("should handle mutation callbacks correctly", async ()=>{
+        const mockResponse = {
+            Url: "https://presigned.url",
+            ExpiresAt: new Date()
+        };
+        const onSuccess = jest.fn();
+        const onError = jest.fn();
+        const onSettled = jest.fn();
+        mockOperation.mockResolvedValue(mockResponse);
+        const useMutation = useCreateS3FunctionMutationHook(mockOperation);
+        const { result } = renderHook(()=>useMutation({
+                onSuccess,
+                onError,
+                onSettled
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        const variables = {
+            Bucket: "test-bucket",
+            Key: "test-key"
+        };
+        result.current.mutate(variables);
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        expect(onSuccess).toHaveBeenCalledWith(mockResponse, variables, void 0, expect.any(Object));
+        expect(onError).not.toHaveBeenCalled();
+        expect(onSettled).toHaveBeenCalledWith(mockResponse, null, variables, void 0, expect.any(Object));
+    });
+    it("should handle function operation with invalidation keys", async ()=>{
+        const mockResponse = {
+            success: true
+        };
+        mockOperation.mockResolvedValue(mockResponse);
+        const useMutation = useCreateS3FunctionMutationHook(mockOperation, [
+            "PresignedUrls",
+            "ObjectList"
+        ]);
+        const { result } = renderHook(()=>useMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        result.current.mutate({
+            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"
+        });
+    });
+    it("should handle concurrent function operations correctly", async ()=>{
+        const mockResponse1 = {
+            Url: "https://presigned1.url",
+            ExpiresAt: new Date()
+        };
+        const mockResponse2 = {
+            Url: "https://presigned2.url",
+            ExpiresAt: new Date()
+        };
+        let callCount = 0;
+        mockOperation.mockImplementation(()=>{
+            callCount++;
+            return Promise.resolve(1 === callCount ? mockResponse1 : mockResponse2);
+        });
+        const useMutation = useCreateS3FunctionMutationHook(mockOperation);
+        const { result: result1 } = renderHook(()=>useMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        const { result: result2 } = renderHook(()=>useMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        result1.current.mutate({
+            Bucket: "test-bucket",
+            Key: "file1.txt"
+        });
+        result2.current.mutate({
+            Bucket: "test-bucket",
+            Key: "file2.txt"
+        });
+        await waitFor(()=>{
+            expect(result1.current.isSuccess).toBe(true);
+            expect(result2.current.isSuccess).toBe(true);
+        });
+        expect(result1.current.data).toEqual(mockResponse1);
+        expect(result2.current.data).toEqual(mockResponse2);
+        expect(mockOperation).toHaveBeenCalledTimes(2);
+    });
+    it("should pass correct parameters to function operation", async ()=>{
+        const mockResponse = {
+            success: true
+        };
+        let capturedClient;
+        let capturedParams;
+        mockOperation.mockImplementation((client, params)=>{
+            capturedClient = client;
+            capturedParams = params;
+            return Promise.resolve(mockResponse);
+        });
+        const useMutation = useCreateS3FunctionMutationHook(mockOperation);
+        const { result } = renderHook(()=>useMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        const inputParams = {
+            Bucket: "test-bucket",
+            Key: "test-key",
+            ContentType: "text/plain",
+            expiresIn: 1800
+        };
+        result.current.mutate(inputParams);
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        expect(capturedClient).toBe(mockS3Client);
+        expect(capturedParams).toEqual(inputParams);
+    });
+    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"
+        };
+        mockOperation.mockResolvedValue(mockResponse);
+        const useMutation = useCreateS3FunctionMutationHook(mockOperation);
+        const { result } = renderHook(()=>useMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        const complexParams = {
+            Bucket: "complex-bucket",
+            Key: "complex/path/file.txt",
+            VersionId: "version123",
+            ResponseContentType: "application/json",
+            ResponseContentDisposition: "attachment; filename=data.json",
+            expiresIn: 7200
+        };
+        result.current.mutate(complexParams);
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        expect(result.current.data).toEqual(mockResponse);
+        expect(mockOperation).toHaveBeenCalledWith(mockS3Client, complexParams);
+    });
+    it("should handle function operations without parameters", async ()=>{
+        const mockResponse = {
+            status: "operation completed"
+        };
+        mockOperation.mockResolvedValue(mockResponse);
+        const useMutation = useCreateS3FunctionMutationHook(mockOperation);
+        const { result } = renderHook(()=>useMutation(), {
+            wrapper: createQueryWrapper()
+        });
+        result.current.mutate(void 0);
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        expect(result.current.data).toEqual(mockResponse);
+        expect(mockOperation).toHaveBeenCalledWith(mockS3Client, void 0);
+    });
+});

package/dist/hooks/factories/__tests__/useCreateS3InfiniteQueryHook.test.d.ts

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

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

@@ -0,0 +1,259 @@
+import { renderHook, waitFor } from "@testing-library/react";
+import { useCreateS3InfiniteQueryHook } from "../useCreateS3InfiniteQueryHook.js";
+import { useS3Client } from "../../useS3Client.js";
+import { createS3OperationError } from "../../../utils/errorHandling.js";
+import { createQueryWrapper, validateFactoryHook, validateHookResult } from "../../../test/testUtils.js";
+jest.mock("../../useS3Client");
+jest.mock("../../../utils/errorHandling");
+const mockUseS3Client = useS3Client;
+const mockCreateS3OperationError = createS3OperationError;
+class MockCommand {
+    input;
+    constructor(input){
+        this.input = input;
+    }
+}
+const mockS3Client = {
+    send: jest.fn()
+};
+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");
+        const { result } = renderHook(()=>useInfiniteQuery({
+                Bucket: "test-bucket"
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        validateHookResult(result.current, "infiniteQuery");
+    });
+    it("should handle getPaginationParams for different operations", async ()=>{
+        const mockResponse = {
+            IsTruncated: false
+        };
+        mockS3Client.send.mockResolvedValue(mockResponse);
+        const useListObjects = useCreateS3InfiniteQueryHook(MockCommand, "ListObjects");
+        const { result: listResult } = renderHook(()=>useListObjects({
+                Bucket: "test-bucket"
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        const useListVersions = useCreateS3InfiniteQueryHook(MockCommand, "ListObjectVersions");
+        const { result: versionsResult } = renderHook(()=>useListVersions({
+                Bucket: "test-bucket"
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        await waitFor(()=>{
+            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");
+    });
+    it("should handle Prefix parameter in enabled logic correctly", ()=>{
+        const useInfiniteQuery = useCreateS3InfiniteQueryHook(MockCommand, "ListObjects");
+        const { result: undefinedResult } = renderHook(()=>useInfiniteQuery({
+                Bucket: "test-bucket",
+                Prefix: void 0
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        expect(undefinedResult.current.fetchStatus).toBe("idle");
+        const { result: definedResult } = renderHook(()=>useInfiniteQuery({
+                Bucket: "test-bucket",
+                Prefix: "folder/"
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        expect(definedResult.current.fetchStatus).not.toBe("idle");
+    });
+    it("should handle pagination data correctly", async ()=>{
+        const mockFirstPage = {
+            Contents: [
+                {
+                    Key: "file1.txt"
+                },
+                {
+                    Key: "file2.txt"
+                }
+            ],
+            IsTruncated: true,
+            NextContinuationToken: "token123"
+        };
+        const mockSecondPage = {
+            Contents: [
+                {
+                    Key: "file3.txt"
+                },
+                {
+                    Key: "file4.txt"
+                }
+            ],
+            IsTruncated: false
+        };
+        let callCount = 0;
+        mockS3Client.send.mockImplementation(()=>{
+            callCount++;
+            return Promise.resolve(1 === callCount ? mockFirstPage : mockSecondPage);
+        });
+        const useInfiniteQuery = useCreateS3InfiniteQueryHook(MockCommand, "ListObjects");
+        const { result } = renderHook(()=>useInfiniteQuery({
+                Bucket: "test-bucket"
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        const firstPageData = result.current.data;
+        expect(firstPageData?.pages).toHaveLength(1);
+        expect(firstPageData?.pages?.[0]).toEqual(mockFirstPage);
+        expect(result.current.hasNextPage).toBe(true);
+        result.current.fetchNextPage();
+        await waitFor(()=>{
+            const data = result.current.data;
+            expect(data?.pages).toHaveLength(2);
+        });
+        const finalData = result.current.data;
+        expect(finalData?.pages?.[1]).toEqual(mockSecondPage);
+        expect(result.current.hasNextPage).toBe(false);
+    });
+    it("should handle ListObjectVersions pagination patterns", async ()=>{
+        const mockVersionsResponse = {
+            Versions: [
+                {
+                    Key: "file1.txt",
+                    VersionId: "v1"
+                }
+            ],
+            DeleteMarkers: [
+                {
+                    Key: "file2.txt",
+                    VersionId: "v2"
+                }
+            ],
+            IsTruncated: true,
+            NextKeyMarker: "file1.txt",
+            NextVersionIdMarker: "v1"
+        };
+        mockS3Client.send.mockResolvedValue(mockVersionsResponse);
+        const useVersionsQuery = useCreateS3InfiniteQueryHook(MockCommand, "ListObjectVersions");
+        const { result } = renderHook(()=>useVersionsQuery({
+                Bucket: "test-bucket"
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        const data = result.current.data;
+        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");
+    });
+    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 { result } = renderHook(()=>useInfiniteQuery({
+                Bucket: "test-bucket"
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        await waitFor(()=>{
+            expect(result.current.isError).toBe(true);
+        });
+        expect(result.current.error).toBe(enhancedError);
+        expect(mockCreateS3OperationError).toHaveBeenCalledWith(mockError, "ListObjects", "test-bucket");
+    });
+    it("should handle fetchNextPage correctly", async ()=>{
+        const mockFirstPage = {
+            Contents: [
+                {
+                    Key: "file1.txt"
+                }
+            ],
+            IsTruncated: true,
+            NextContinuationToken: "token123"
+        };
+        mockS3Client.send.mockResolvedValue(mockFirstPage);
+        const useInfiniteQuery = useCreateS3InfiniteQueryHook(MockCommand, "ListObjects");
+        const { result } = renderHook(()=>useInfiniteQuery({
+                Bucket: "test-bucket"
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        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");
+        const customOptions = {
+            enabled: false,
+            staleTime: 10000,
+            refetchOnWindowFocus: false
+        };
+        const { result } = renderHook(()=>useInfiniteQuery({
+                Bucket: "test-bucket"
+            }, customOptions), {
+            wrapper: createQueryWrapper()
+        });
+        expect(result.current.fetchStatus).toBe("idle");
+        expect(result.current.isLoading).toBe(false);
+    });
+    it("should pass AbortSignal correctly for infinite queries", async ()=>{
+        let capturedAbortSignal;
+        mockS3Client.send.mockImplementation((_command, options)=>{
+            capturedAbortSignal = options?.abortSignal;
+            return Promise.resolve({
+                Contents: [],
+                IsTruncated: false
+            });
+        });
+        const useInfiniteQuery = useCreateS3InfiniteQueryHook(MockCommand, "ListObjects");
+        const { result } = renderHook(()=>useInfiniteQuery({
+                Bucket: "test-bucket"
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        expect(capturedAbortSignal).toBeInstanceOf(AbortSignal);
+        expect(capturedAbortSignal?.aborted).toBe(false);
+    });
+    it("should handle empty result sets correctly", async ()=>{
+        const mockEmptyResponse = {
+            Contents: [],
+            IsTruncated: false
+        };
+        mockS3Client.send.mockResolvedValue(mockEmptyResponse);
+        const useInfiniteQuery = useCreateS3InfiniteQueryHook(MockCommand, "ListObjects");
+        const { result } = renderHook(()=>useInfiniteQuery({
+                Bucket: "test-bucket"
+            }), {
+            wrapper: createQueryWrapper()
+        });
+        await waitFor(()=>{
+            expect(result.current.isSuccess).toBe(true);
+        });
+        const data = result.current.data;
+        expect(data?.pages).toHaveLength(1);
+        expect(data?.pages?.[0]).toEqual(mockEmptyResponse);
+        expect(result.current.hasNextPage).toBe(false);
+    });
+});

package/dist/hooks/factories/__tests__/useCreateS3LoginHook.test.d.ts

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