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

package/dist/test/testUtils.d.ts

@@ -0,0 +1,181 @@
+/**
+ * @fileoverview Test utilities for data-browser-library
+ *
+ * This file provides common utilities for testing:
+ * - Test configuration and credentials
+ * - Mock setup utilities (S3, DOM, etc.)
+ * - React Testing Library wrappers
+ * - React Query wrappers
+ * - Global configuration utilities
+ * - Factory pattern validation utilities
+ * - Form testing helpers
+ */
+import React from "react";
+import { S3Client, PutObjectCommand } from "@aws-sdk/client-s3";
+import { UseQueryResult } from "@tanstack/react-query";
+import { S3BrowserConfig, S3Credentials } from "../types";
+import type { S3Configuration, DevelopmentConfiguration } from "../config/types";
+/**
+ * Default S3 configuration for tests
+ */
+export declare const testConfig: S3BrowserConfig;
+/**
+ * Default S3 credentials for tests
+ */
+export declare const testCredentials: S3Credentials;
+/**
+ * Mock S3 client for tests
+ */
+export declare const mockS3Client: {
+    send: jest.Mock<any, any, any>;
+};
+export declare const MockedS3Client: jest.MockedClass<typeof S3Client>;
+export declare const MockedPutObjectCommand: jest.MockedClass<typeof PutObjectCommand>;
+/**
+ * Sets up S3 mocks for testing
+ */
+export declare const setupS3Mocks: () => void;
+/**
+ * Common mock setup that should be run before each test
+ */
+export declare const setupCommonMocks: () => void;
+/**
+ * Mocks DOM measurements APIs for virtualization and layout testing
+ * AutoSizer uses offsetWidth and offsetHeight which Jest/JSDom doesn't support
+ * @param width - The mock width in pixels
+ * @param height - The mock height in pixels
+ */
+export declare function mockOffsetSize(width: number, height: number): void;
+/**
+ * Creates a simple QueryClient wrapper for tests that don't need DataBrowser context
+ */
+export declare const createQueryWrapper: () => ({ children }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Creates a test wrapper with DataBrowser context and QueryClient
+ */
+export declare const createTestWrapper: (config?: S3BrowserConfig, credentials?: S3Credentials) => ({ children }: {
+    children: React.ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+/**
+ * Renders a hook with the standard test wrapper
+ */
+export declare const renderHookWithWrapper: <TProps, TResult>(hook: (props: TProps) => TResult, options?: {
+    initialProps?: TProps;
+    config?: S3BrowserConfig;
+    credentials?: S3Credentials;
+}) => import("@testing-library/react").RenderHookResult<TResult, TProps>;
+/**
+ * Creates a test File object
+ */
+export declare const createTestFile: (name: string, content: string, type?: string) => File;
+type GlobalConfigOverrides = {
+    s3?: Partial<S3Configuration>;
+    dev?: Partial<DevelopmentConfiguration>;
+    environment?: {
+        isDevelopment?: boolean;
+        isProduction?: boolean;
+    };
+};
+/**
+ * Override global configuration for testing specific scenarios
+ * Useful for testing different deployment environments or proxy configurations
+ */
+export declare const overrideGlobalConfig: (overrides: GlobalConfigOverrides) => void;
+/**
+ * Reset global configuration to test defaults
+ * Should be called in afterEach or afterAll to ensure test isolation
+ */
+export declare const resetGlobalConfig: () => void;
+/**
+ * Test helper for running tests with specific global configuration
+ */
+export declare const withGlobalConfig: (overrides: GlobalConfigOverrides, testFn: () => void | Promise<void>) => () => Promise<void>;
+/**
+ * Creates a factory test error
+ */
+export declare const createFactoryTestError: (testContext: string, operationName: string, details?: string) => Error;
+/**
+ * Validates that a hook follows the expected factory pattern
+ */
+export declare const validateFactoryHook: (hook: any, operationName: string) => void;
+/**
+ * Validates that a hook result has expected React Query properties
+ */
+export declare const validateHookResult: (result: any, hookType: "query" | "mutation" | "infiniteQuery") => void;
+/**
+ * Creates a mock UseMutationResult for testing React Query mutations
+ *
+ * This helper provides a complete mock object that matches the UseMutationResult type
+ * from @tanstack/react-query, eliminating the need for 'as any' type assertions.
+ *
+ * @param mutate - The mocked mutate function (usually jest.fn())
+ * @param overrides - Optional overrides for any properties (e.g., { isPending: true })
+ * @returns A complete UseMutationResult mock object
+ *
+ * @example
+ * ```ts
+ * const mockCreateBucket = jest.fn();
+ * const mockResult = createMockMutationResult(mockCreateBucket, { isPending: true });
+ * mockUseCreateBucket.mockReturnValue(mockResult);
+ * ```
+ */
+export declare const createMockMutationResult: (mutate: jest.Mock, overrides?: {}) => {
+    mutate: jest.Mock<any, any, any>;
+    mutateAsync: jest.Mock<any, any, any>;
+    reset: jest.Mock<any, any, any>;
+    isPending: false;
+    isIdle: true;
+    isError: false;
+    isSuccess: false;
+    status: "idle";
+    data: undefined;
+    error: null;
+    variables: undefined;
+    context: undefined;
+    failureCount: number;
+    failureReason: null;
+    isPaused: false;
+    submittedAt: number;
+};
+/**
+ * Creates a mock UseQueryResult for testing React Query queries
+ *
+ * This helper provides a complete mock object that matches the UseQueryResult type
+ * from @tanstack/react-query, eliminating the need for 'as any' type assertions.
+ *
+ * @param overrides - Optional overrides for any properties (e.g., { isLoading: true, data: mockData })
+ * @returns A complete UseQueryResult mock object
+ *
+ * @example
+ * ```ts
+ * const mockQueryResult = createMockQueryResult({ isLoading: true });
+ * mockUseGetBucketPolicy.mockReturnValue(mockQueryResult);
+ * ```
+ */
+export declare const createMockQueryResult: <T, E = Error>(overrides?: Partial<UseQueryResult<T, E>>) => UseQueryResult<T, E>;
+/**
+ * Finds a Toggle input element by its label text
+ * Traverses the DOM to locate the associated checkbox input
+ * @param labelText - The text content of the label
+ * @returns The toggle input element or null if not found
+ */
+export declare const findToggleByLabel: (labelText: string) => HTMLInputElement | null;
+/**
+ * Waits for a submit button to be enabled and clicks it
+ * @param buttonName - The type of button to click ("create" or "save")
+ */
+export declare const submitForm: (buttonName?: "create" | "save") => Promise<void>;
+/**
+ * Sets up a mock mutation to simulate successful form submission
+ * @param mockMutate - The jest mock function for the mutation
+ */
+export declare const mockSuccessSubmit: (mockMutate: jest.Mock) => void;
+/**
+ * Sets up a mock mutation to simulate failed form submission
+ * @param mockMutate - The jest mock function for the mutation
+ * @param errorMessage - The error message to return (default: "Network Error")
+ */
+export declare const mockErrorSubmit: (mockMutate: jest.Mock, errorMessage?: string) => void;
+export { setupMswServer, overrideHandlers } from "./msw";

package/dist/test/testUtils.js

@@ -0,0 +1,310 @@
+import { jsx } from "react/jsx-runtime";
+import "react";
+import { PutObjectCommand, S3Client } from "@aws-sdk/client-s3";
+import { QueryClient, QueryClientProvider } from "@tanstack/react-query";
+import { fireEvent, renderHook, screen, waitFor } from "@testing-library/react";
+import { coreUIAvailableThemes } from "@scality/core-ui/dist/style/theme";
+import { CoreUiThemeProvider } from "@scality/core-ui/dist/next";
+import { ToastProvider } from "@scality/core-ui";
+import { DataBrowserProvider } from "../components/providers/DataBrowserProvider.js";
+import { overrideHandlers, setupMswServer } from "./msw/index.js";
+var __webpack_require__ = {};
+(()=>{
+    __webpack_require__.g = (()=>{
+        if ('object' == typeof globalThis) return globalThis;
+        try {
+            return this || new Function('return this')();
+        } catch (e) {
+            if ('object' == typeof window) return window;
+        }
+    })();
+})();
+const testConfig = {
+    endpoint: "https://s3.amazonaws.com",
+    region: "us-east-1",
+    forcePathStyle: true
+};
+const testCredentials = {
+    accessKeyId: "test-access-key",
+    secretAccessKey: "test-secret-key",
+    sessionToken: "test-session-token"
+};
+const mockS3Client = {
+    send: jest.fn()
+};
+const MockedS3Client = S3Client;
+const MockedPutObjectCommand = PutObjectCommand;
+const setupS3Mocks = ()=>{
+    jest.clearAllMocks();
+    MockedS3Client.mockImplementation(()=>mockS3Client);
+    MockedPutObjectCommand.mockImplementation((input)=>({
+            input,
+            resolveMiddleware: jest.fn()
+        }));
+};
+const setupCommonMocks = ()=>{
+    setupS3Mocks();
+};
+function mockOffsetSize(width, height) {
+    __webpack_require__.g.ResizeObserver = jest.fn().mockImplementation(()=>({
+            observe: jest.fn(),
+            unobserve: jest.fn(),
+            disconnect: jest.fn()
+        }));
+    Element.prototype.getBoundingClientRect = jest.fn(()=>({
+            width: width || 800,
+            height: height || 600,
+            top: 0,
+            left: 0,
+            bottom: height || 600,
+            right: width || 800,
+            x: 0,
+            y: 0,
+            toJSON: jest.fn()
+        }));
+    Object.defineProperties(window.HTMLElement.prototype, {
+        offsetHeight: {
+            get: ()=>height || 600,
+            configurable: true
+        },
+        offsetWidth: {
+            get: ()=>width || 800,
+            configurable: true
+        },
+        scrollHeight: {
+            get: ()=>height || 600,
+            configurable: true
+        },
+        scrollWidth: {
+            get: ()=>width || 800,
+            configurable: true
+        }
+    });
+    const mockComputedStyle = {
+        fontSize: "14px",
+        paddingLeft: "0px",
+        paddingRight: "0px",
+        paddingTop: "0px",
+        paddingBottom: "0px",
+        getPropertyValue: jest.fn((prop)=>{
+            const styles = {
+                "font-size": "14px",
+                "padding-left": "0px",
+                "padding-right": "0px",
+                "padding-top": "0px",
+                "padding-bottom": "0px"
+            };
+            return styles[prop] || "";
+        })
+    };
+    jest.spyOn(window, "getComputedStyle").mockImplementation(()=>mockComputedStyle);
+}
+const createQueryWrapper = ()=>{
+    const queryClient = new QueryClient({
+        defaultOptions: {
+            queries: {
+                retry: false
+            },
+            mutations: {
+                retry: false
+            }
+        }
+    });
+    const theme = coreUIAvailableThemes.darkRebrand;
+    return ({ children })=>/*#__PURE__*/ jsx(QueryClientProvider, {
+            client: queryClient,
+            children: /*#__PURE__*/ jsx(CoreUiThemeProvider, {
+                theme: theme,
+                children: children
+            })
+        });
+};
+const createTestWrapper = (config = testConfig, credentials = testCredentials)=>{
+    const queryClient = new QueryClient({
+        defaultOptions: {
+            queries: {
+                retry: false
+            },
+            mutations: {
+                retry: false
+            }
+        }
+    });
+    const getConfig = ()=>({
+            ...config,
+            credentials
+        });
+    const theme = coreUIAvailableThemes.darkRebrand;
+    return ({ children })=>/*#__PURE__*/ jsx(DataBrowserProvider, {
+            queryClient: queryClient,
+            getS3Config: getConfig,
+            theme: theme,
+            enableDevtools: false,
+            children: /*#__PURE__*/ jsx(CoreUiThemeProvider, {
+                theme: theme,
+                children: /*#__PURE__*/ jsx(ToastProvider, {
+                    children: children
+                })
+            })
+        });
+};
+const renderHookWithWrapper = (hook, options)=>{
+    const { config, credentials, ...renderOptions } = options || {};
+    return renderHook(hook, {
+        wrapper: createTestWrapper(config, credentials),
+        ...renderOptions
+    });
+};
+const createTestFile = (name, content, type = "text/plain")=>new File([
+        content
+    ], name, {
+        type
+    });
+const overrideGlobalConfig = (overrides)=>{
+    const currentS3 = globalThis.__S3_CONFIG__;
+    const currentDev = globalThis.__DEV_CONFIG__;
+    if (overrides.s3) globalThis.__S3_CONFIG__ = {
+        ...currentS3,
+        ...overrides.s3
+    };
+    if (overrides.dev) globalThis.__DEV_CONFIG__ = {
+        ...currentDev,
+        ...overrides.dev
+    };
+    if (overrides.environment) {
+        if (void 0 !== overrides.environment.isDevelopment) globalThis.__IS_DEVELOPMENT__ = overrides.environment.isDevelopment;
+        if (void 0 !== overrides.environment.isProduction) globalThis.__IS_PRODUCTION__ = overrides.environment.isProduction;
+    }
+};
+const resetGlobalConfig = ()=>{
+    globalThis.__S3_CONFIG__ = {
+        endpoint: "http://localhost:8000",
+        region: "us-east-1",
+        realHost: "s3.amazonaws.com",
+        forcePathStyle: true
+    };
+    globalThis.__DEV_CONFIG__ = {
+        useProxy: false,
+        proxyEndpoint: "http://localhost:3000/api/s3",
+        proxyBasePath: "/api/s3",
+        proxyHost: "localhost",
+        proxyPort: 3000
+    };
+    globalThis.__IS_DEVELOPMENT__ = true;
+    globalThis.__IS_PRODUCTION__ = false;
+};
+const withGlobalConfig = (overrides, testFn)=>async ()=>{
+        overrideGlobalConfig(overrides);
+        try {
+            await testFn();
+        } finally{
+            resetGlobalConfig();
+        }
+    };
+const createFactoryTestError = (testContext, operationName, details)=>new Error(`Factory Test Failure [${testContext}]: ${operationName} - ${details || "Unknown error"}. Check factory implementation and hook usage patterns.`);
+const validateFactoryHook = (hook, operationName)=>{
+    if ("function" != typeof hook) throw createFactoryTestError("Factory Validation", operationName, "hook should be a function - check if useCreate*Hook factory is properly returning a hook function");
+};
+const validateHookResult = (result, hookType)=>{
+    const commonProps = [
+        "isError",
+        "isSuccess",
+        "data",
+        "error"
+    ];
+    const queryProps = [
+        "isLoading"
+    ];
+    const mutationProps = [
+        "mutate",
+        "mutateAsync",
+        "isPending"
+    ];
+    const infiniteProps = [
+        "hasNextPage",
+        "fetchNextPage",
+        "isFetchingNextPage"
+    ];
+    const expectedProps = [
+        ...commonProps,
+        ..."query" === hookType ? queryProps : [],
+        ..."mutation" === hookType ? mutationProps : [],
+        ..."infiniteQuery" === hookType ? infiniteProps : []
+    ];
+    for (const prop of expectedProps)if (!(prop in result)) throw createFactoryTestError("Hook Validation", hookType, `Missing property '${prop}' - check if factory is returning proper React Query hook result`);
+};
+const createMockMutationResult = (mutate, overrides = {})=>({
+        mutate,
+        mutateAsync: jest.fn(),
+        reset: jest.fn(),
+        isPending: false,
+        isIdle: true,
+        isError: false,
+        isSuccess: false,
+        status: "idle",
+        data: void 0,
+        error: null,
+        variables: void 0,
+        context: void 0,
+        failureCount: 0,
+        failureReason: null,
+        isPaused: false,
+        submittedAt: 0,
+        ...overrides
+    });
+const createMockQueryResult = (overrides = {})=>({
+        data: void 0,
+        error: null,
+        isError: false,
+        isLoading: false,
+        isLoadingError: false,
+        isRefetchError: false,
+        isSuccess: false,
+        status: "pending",
+        dataUpdatedAt: 0,
+        errorUpdatedAt: 0,
+        failureCount: 0,
+        failureReason: null,
+        errorUpdateCount: 0,
+        isFetched: false,
+        isFetchedAfterMount: false,
+        isFetching: false,
+        isInitialLoading: false,
+        isPaused: false,
+        isPlaceholderData: false,
+        isPending: false,
+        isRefetching: false,
+        isStale: false,
+        refetch: jest.fn(),
+        ...overrides
+    });
+const findToggleByLabel = (labelText)=>{
+    const label = screen.getByText(labelText);
+    let current = label.parentElement;
+    while(current && !current.querySelector('input[type="checkbox"]'))current = current.parentElement;
+    return current?.querySelector('input[type="checkbox"]');
+};
+const submitForm = async (buttonName = "create")=>{
+    await waitFor(()=>{
+        const button = screen.getByRole("button", {
+            name: "create" === buttonName ? /create/i : /save/i
+        });
+        expect(button).toBeEnabled();
+    });
+    const button = screen.getByRole("button", {
+        name: "create" === buttonName ? /create/i : /save/i
+    });
+    fireEvent.click(button);
+};
+const mockSuccessSubmit = (mockMutate)=>{
+    mockMutate.mockImplementation((_, options)=>{
+        options?.onSuccess?.();
+    });
+};
+const mockErrorSubmit = (mockMutate, errorMessage = "Network Error")=>{
+    const error = new Error(errorMessage);
+    mockMutate.mockImplementation((_, options)=>{
+        options?.onError?.(error);
+    });
+};
+export { MockedPutObjectCommand, MockedS3Client, createFactoryTestError, createMockMutationResult, createMockQueryResult, createQueryWrapper, createTestFile, createTestWrapper, findToggleByLabel, mockErrorSubmit, mockOffsetSize, mockS3Client, mockSuccessSubmit, overrideGlobalConfig, overrideHandlers, renderHookWithWrapper, resetGlobalConfig, setupCommonMocks, setupMswServer, setupS3Mocks, submitForm, testConfig, testCredentials, validateFactoryHook, validateHookResult, withGlobalConfig };

package/dist/test/utils/errorHandling.test.d.ts

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