@0xsequence/marketplace-sdk 0.8.12 → 0.10.0

package/src/react/hooks/__tests__/useCheckoutOptions.test.tsx

@@ -0,0 +1,158 @@
+import { renderHook, server, waitFor } from '@test';
+import { HttpResponse, http } from 'msw';
+import { zeroAddress } from 'viem';
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { useAccount } from 'wagmi';
+import { MarketplaceKind } from '../../_internal';
+import {
+	mockCheckoutOptions,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
+import type { UseCheckoutOptionsParams } from '../useCheckoutOptions';
+import { useCheckoutOptions } from '../useCheckoutOptions';
+
+// Mock wagmi useAccount hook
+vi.mock('wagmi', () => ({
+	useAccount: vi.fn(),
+}));
+
+const mockUseAccount = vi.mocked(useAccount);
+
+describe('useCheckoutOptions', () => {
+	const defaultArgs: UseCheckoutOptionsParams = {
+		chainId: 1,
+		orders: [
+			{
+				collectionAddress: zeroAddress,
+				orderId: '123',
+				marketplace: MarketplaceKind.sequence_marketplace_v2,
+			},
+		],
+		additionalFee: 0,
+		query: {},
+	};
+
+	beforeEach(() => {
+		mockUseAccount.mockReturnValue({
+			address: zeroAddress,
+		} as unknown as ReturnType<typeof useAccount>);
+	});
+
+	it('should fetch checkout options successfully', async () => {
+		const { result } = renderHook(() => useCheckoutOptions(defaultArgs));
+
+		// Initially loading
+		expect(result.current.isLoading).toBe(true);
+		expect(result.current.data).toBeUndefined();
+
+		// Wait for data to be loaded
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Verify the data matches our mock
+		expect(result.current.data).toEqual(mockCheckoutOptions);
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should handle error states', async () => {
+		// Override the handler for this test to return an error
+		server.use(
+			http.post(mockMarketplaceEndpoint('CheckoutOptionsMarketplace'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch checkout options' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() => useCheckoutOptions(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should refetch when args change', async () => {
+		const { result, rerender } = renderHook(() =>
+			useCheckoutOptions(defaultArgs),
+		);
+
+		// Wait for initial data
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Change args and rerender
+		const firstOrder = defaultArgs.orders?.[0];
+		if (!firstOrder) throw new Error('Expected defaultArgs.orders to exist');
+
+		const newArgs = {
+			...defaultArgs,
+			orders: [
+				{
+					...firstOrder,
+					orderId: '456',
+				},
+			],
+		};
+
+		rerender(() => useCheckoutOptions(newArgs));
+
+		// Wait for new data
+		await waitFor(() => {
+			expect(result.current.data).toBeDefined();
+		});
+
+		// Verify that the query was refetched with new args
+		expect(result.current.data).toBeDefined();
+		expect(result.current.isSuccess).toBe(true);
+	});
+
+	it('should handle disabled query when wallet not connected', async () => {
+		// Mock wallet not connected
+		mockUseAccount.mockReturnValue({
+			address: undefined,
+		} as unknown as ReturnType<typeof useAccount>);
+
+		const { result } = renderHook(() => useCheckoutOptions(defaultArgs));
+
+		// Should not make request when wallet not connected
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.error).toBeNull();
+	});
+
+	it('should handle multiple orders', async () => {
+		const multiOrderArgs: UseCheckoutOptionsParams = {
+			chainId: 137,
+			orders: [
+				{
+					collectionAddress: zeroAddress,
+					orderId: '123',
+					marketplace: MarketplaceKind.sequence_marketplace_v2,
+				},
+				{
+					collectionAddress:
+						'0x1234567890123456789012345678901234567890' as `0x${string}`,
+					orderId: '456',
+					marketplace: MarketplaceKind.opensea,
+				},
+			],
+			additionalFee: 100,
+			query: {},
+		};
+
+		const { result } = renderHook(() => useCheckoutOptions(multiOrderArgs));
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.data).toBeDefined();
+		expect(result.current.error).toBeNull();
+	});
+});

package/src/react/hooks/__tests__/useCheckoutOptionsSalesContract.test.tsx

@@ -1,17 +1,22 @@
 import { skipToken } from '@tanstack/react-query';
-import { renderHook, waitFor } from '@test';
+import { renderHook, server, waitFor } from '@test';
+import { HttpResponse, http } from 'msw';
 import type { Address } from 'viem';
+import { zeroAddress } from 'viem';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
+import { useAccount } from 'wagmi';
+import {
+	mockCheckoutOptions,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
 import { useCheckoutOptionsSalesContract } from '../useCheckoutOptionsSalesContract';
 
-// Mock wagmi's useAccount hook
-vi.mock('wagmi', async () => {
-	const actual = await vi.importActual('wagmi');
-	return {
-		...actual,
-		useAccount: vi.fn(() => ({ address: '0xTestWallet' as Address })),
-	};
-});
+// Mock wagmi useAccount hook
+vi.mock('wagmi', () => ({
+	useAccount: vi.fn(),
+}));
+
+const mockUseAccount = vi.mocked(useAccount);
 
 const mockContractAddress =
 	'0x1234567890123456789012345678901234567890' as Address;
@@ -21,6 +26,9 @@ const mockCollectionAddress =
 describe('useCheckoutOptionsSalesContract', () => {
 	beforeEach(() => {
 		vi.clearAllMocks();
+		mockUseAccount.mockReturnValue({
+			address: zeroAddress,
+		} as unknown as ReturnType<typeof useAccount>);
 	});
 
 	afterEach(() => {
@@ -51,15 +59,8 @@ describe('useCheckoutOptionsSalesContract', () => {
 			expect(result.current.isSuccess).toBe(true);
 		});
 
-		// Check the response
-		expect(result.current.data).toEqual({
-			options: {
-				crypto: 'all',
-				swap: [],
-				nftCheckout: [],
-				onRamp: [],
-			},
-		});
+		// Check the response matches our mock
+		expect(result.current.data).toEqual(mockCheckoutOptions);
 	});
 
 	it('should handle skipToken', () => {
@@ -96,8 +97,7 @@ describe('useCheckoutOptionsSalesContract', () => {
 			expect(result.current.isSuccess).toBe(true);
 		});
 
-		expect(result.current.data).toBeDefined();
-		expect(result.current.data?.options).toBeDefined();
+		expect(result.current.data).toEqual(mockCheckoutOptions);
 	});
 
 	it('should refetch when args change', async () => {
@@ -135,23 +135,16 @@ describe('useCheckoutOptionsSalesContract', () => {
 		expect(result.current.data).toEqual(firstData);
 	});
 
-	it('should use wallet address from useAccount', async () => {
-		const { useAccount } = await import('wagmi');
-		const mockUseAccount = vi.mocked(useAccount);
-
-		// Set a specific address
-		mockUseAccount.mockReturnValue({
-			address: '0xSpecificWallet' as Address,
-			isConnected: true,
-			isConnecting: false,
-			isDisconnected: false,
-			isReconnecting: false,
-			connector: null,
-			addresses: undefined,
-			chain: undefined,
-			chainId: undefined,
-			status: 'connected',
-		} as unknown as ReturnType<typeof useAccount>);
+	it('should handle error states', async () => {
+		// Override the handler for this test to return an error
+		server.use(
+			http.post(mockMarketplaceEndpoint('CheckoutOptionsSalesContract'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch checkout options' } },
+					{ status: 500 },
+				);
+			}),
+		);
 
 		const { result } = renderHook(() =>
 			useCheckoutOptionsSalesContract({
@@ -163,28 +156,17 @@ describe('useCheckoutOptionsSalesContract', () => {
 		);
 
 		await waitFor(() => {
-			expect(result.current.isSuccess).toBe(true);
+			expect(result.current.isError).toBe(true);
 		});
 
-		expect(result.current.data).toBeDefined();
+		expect(result.current.error).toBeDefined();
+		expect(result.current.data).toBeUndefined();
 	});
 
 	it('should handle when wallet is not connected', async () => {
-		const { useAccount } = await import('wagmi');
-		const mockUseAccount = vi.mocked(useAccount);
-
-		// No wallet connected
+		// Mock wallet not connected for this test
 		mockUseAccount.mockReturnValue({
 			address: undefined,
-			isConnected: false,
-			isConnecting: false,
-			isDisconnected: true,
-			isReconnecting: false,
-			connector: null,
-			addresses: undefined,
-			chain: undefined,
-			chainId: undefined,
-			status: 'disconnected',
 		} as unknown as ReturnType<typeof useAccount>);
 
 		const { result } = renderHook(() =>
@@ -196,14 +178,10 @@ describe('useCheckoutOptionsSalesContract', () => {
 			}),
 		);
 
-		// The hook will still try to fetch even without a wallet (using undefined)
-		// Wait for it to complete
-		await waitFor(() => {
-			expect(result.current.isSuccess).toBe(true);
-		});
-
-		// The API should still return data even without wallet
-		expect(result.current.data).toBeDefined();
+		// Should not make request when wallet not connected
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.error).toBeNull();
 	});
 
 	it('should handle empty items array', async () => {
@@ -216,10 +194,9 @@ describe('useCheckoutOptionsSalesContract', () => {
 			}),
 		);
 
-		await waitFor(() => {
-			expect(result.current.isSuccess).toBe(true);
-		});
-
-		expect(result.current.data).toBeDefined();
+		// Should not make request when items array is empty
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.error).toBeNull();
 	});
 });

package/src/react/hooks/__tests__/useCollectible.test.tsx

@@ -1,16 +1,16 @@
 import { renderHook, server, waitFor } from '@test';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
 import {
 	mockMetadataEndpoint,
 	mockTokenMetadata,
 } from '../../_internal/api/__mocks__/metadata.msw';
-import type { UseCollectibleArgs } from '../useCollectible';
+import type { UseCollectibleParams } from '../useCollectible';
 import { useCollectible } from '../useCollectible';
 
 describe('useCollectible', () => {
-	const defaultArgs: UseCollectibleArgs = {
+	const defaultArgs: UseCollectibleParams = {
 		chainId: 1,
 		collectionAddress: zeroAddress,
 		collectibleId: '1',
@@ -84,7 +84,7 @@ describe('useCollectible', () => {
 	});
 
 	it('should handle undefined query params', async () => {
-		const argsWithoutQuery: UseCollectibleArgs = {
+		const argsWithoutQuery: UseCollectibleParams = {
 			chainId: 1,
 			collectionAddress: zeroAddress,
 			collectibleId: '1',
@@ -101,19 +101,17 @@ describe('useCollectible', () => {
 		expect(result.current.error).toBeNull();
 	});
 
-	it('should validate input parameters', async () => {
-		const invalidArgs: UseCollectibleArgs = {
-			...defaultArgs,
-			// @ts-expect-error
-			chainId: {}, // Using an object instead of a string/number will fail validation
-		};
+	it('should not fetch when required params are missing', async () => {
+		const incompleteArgs = {
+			chainId: 1,
+			// Missing collectionAddress and collectibleId
+		} as UseCollectibleParams;
 
-		const { result } = renderHook(() => useCollectible(invalidArgs));
+		const { result } = renderHook(() => useCollectible(incompleteArgs));
 
-		await waitFor(() => {
-			expect(result.current.isError).toBe(true);
-		});
-
-		expect(result.current.error).toBeDefined();
+		// Should not be loading since enabled condition fails
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.isFetching).toBe(false);
+		expect(result.current.data).toBeUndefined();
 	});
 });

package/src/react/hooks/__tests__/useCollection.test.tsx

@@ -1,16 +1,16 @@
 import { renderHook, server, waitFor } from '@test';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
 import {
 	mockEthCollection,
 	mockMetadataEndpoint,
 } from '../../_internal/api/__mocks__/metadata.msw';
-import type { UseCollectionArgs } from '../useCollection';
+import type { UseCollectionParams } from '../useCollection';
 import { useCollection } from '../useCollection';
 
 describe('useCollection', () => {
-	const defaultArgs: UseCollectionArgs = {
+	const defaultArgs: UseCollectionParams = {
 		chainId: mockEthCollection.chainId,
 		collectionAddress: mockEthCollection.address,
 	};
@@ -81,7 +81,7 @@ describe('useCollection', () => {
 	});
 
 	it('should handle undefined query params', async () => {
-		const argsWithoutQuery: UseCollectionArgs = {
+		const argsWithoutQuery: UseCollectionParams = {
 			chainId: 1,
 			collectionAddress: zeroAddress,
 			query: {},

package/src/react/hooks/__tests__/useCollectionBalanceDetails.test.tsx

@@ -1,6 +1,6 @@
 import { renderHook, server } from '@test';
 import { waitFor } from '@testing-library/react';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
 import {
@@ -139,29 +139,20 @@ describe('useCollectionBalanceDetails', () => {
 		expect(result.current.data?.balances[0].contractAddress).toBe(zeroAddress);
 	});
 
-	it('should handle validation errors', () => {
-		expect(() =>
-			renderHook(() =>
-				useCollectionBalanceDetails({
-					chainId: 'invalid-chain-id' as unknown as number,
-					filter: {
-						accountAddresses: [zeroAddress],
-						omitNativeBalances: true,
-					},
-				}),
-			),
-		).toThrow();
-
-		expect(() =>
-			renderHook(() =>
-				useCollectionBalanceDetails({
-					chainId: 1,
-					filter: {
-						accountAddresses: ['invalid-address' as unknown as `0x${string}`],
-						omitNativeBalances: true,
-					},
-				}),
-			),
-		).toThrow();
+	it('should handle disabled query when required params are missing', async () => {
+		const { result } = renderHook(() =>
+			useCollectionBalanceDetails({
+				chainId: 1,
+				filter: {
+					accountAddresses: [], // Empty array should disable the query
+					omitNativeBalances: true,
+				},
+			}),
+		);
+
+		// Query should be disabled when accountAddresses is empty
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.error).toBeNull();
 	});
 });

package/src/react/hooks/__tests__/useCollectionDetails.test.tsx

@@ -1,5 +1,5 @@
 import { renderHook, server, waitFor } from '@test';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
 import {

package/src/react/hooks/__tests__/useCollectionDetailsPolling.test.tsx

@@ -1,5 +1,5 @@
 import { renderHook, server, waitFor } from '@test';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import {
@@ -45,7 +45,9 @@ describe('useCollectionDetailsPolling', () => {
 		);
 
 		const { result } = renderHook(() =>
-			useCollectionDetailsPolling(defaultArgs),
+			useCollectionDetailsPolling({
+				...defaultArgs,
+			}),
 		);
 
 		// Initially loading
@@ -90,7 +92,11 @@ describe('useCollectionDetailsPolling', () => {
 			}),
 		);
 
-		renderHook(() => useCollectionDetailsPolling(defaultArgs));
+		renderHook(() =>
+			useCollectionDetailsPolling({
+				...defaultArgs,
+			}),
+		);
 
 		// Fast-forward through all attempts
 		for (let i = 0; i < 30; i++) {
@@ -116,7 +122,9 @@ describe('useCollectionDetailsPolling', () => {
 		);
 
 		const { result } = renderHook(() =>
-			useCollectionDetailsPolling(defaultArgs),
+			useCollectionDetailsPolling({
+				...defaultArgs,
+			}),
 		);
 
 		await waitFor(() => {

package/src/react/hooks/__tests__/useComparePrices.test.tsx

@@ -1,5 +1,6 @@
 import { renderHook, server, waitFor } from '@test';
-import { http, HttpResponse } from 'msw';
+import { USDC_ADDRESS } from '@test/const';
+import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
 import {
@@ -14,7 +15,7 @@ describe('useComparePrices', () => {
 		priceAmountRaw: '1000000000000000000', // 1 ETH
 		priceCurrencyAddress: zeroAddress,
 		compareToPriceAmountRaw: '1000000', // 1 USDC (6 decimals)
-		compareToPriceCurrencyAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48', // USDC
+		compareToPriceCurrencyAddress: USDC_ADDRESS,
 		query: {},
 	};
 
@@ -30,7 +31,7 @@ describe('useComparePrices', () => {
 		// Setup USDC currency with exchange rate of 1 USD
 		const usdcCurrency = {
 			...mockCurrencies[1],
-			contractAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+			contractAddress: USDC_ADDRESS,
 			decimals: 6,
 			exchangeRate: 1, // 1 USDC = $1
 		};
@@ -84,7 +85,7 @@ describe('useComparePrices', () => {
 		// Setup USDC currency with exchange rate of 1 USD
 		const usdcCurrency = {
 			...mockCurrencies[1],
-			contractAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+			contractAddress: USDC_ADDRESS,
 			decimals: 6,
 			exchangeRate: 1, // 1 USDC = $1
 		};
@@ -134,7 +135,7 @@ describe('useComparePrices', () => {
 		// Setup USDC currency with exchange rate of 1 USD
 		const usdcCurrency = {
 			...mockCurrencies[1],
-			contractAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+			contractAddress: USDC_ADDRESS,
 			decimals: 6,
 			exchangeRate: 1, // 1 USDC = $1
 		};
@@ -183,7 +184,7 @@ describe('useComparePrices', () => {
 		// Setup USDC currency with exchange rate of 1 USD
 		const usdcCurrency = {
 			...mockCurrencies[1],
-			contractAddress: '0xA0b86991c6218b36c1d19D4a2e9Eb0cE3606eB48',
+			contractAddress: USDC_ADDRESS,
 			decimals: 6,
 			exchangeRate: 1, // 1 USDC = $1
 		};

package/src/react/hooks/__tests__/useConvertPriceToUSD.test.tsx

@@ -1,16 +1,16 @@
 import { renderHook, server, waitFor } from '@test';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
 import {
 	mockCurrencies,
 	mockMarketplaceEndpoint,
 } from '../../_internal/api/__mocks__/marketplace.msw';
-import type { UseConvertPriceToUSDArgs } from '../useConvertPriceToUSD';
+import type { UseConvertPriceToUSDParams } from '../useConvertPriceToUSD';
 import { useConvertPriceToUSD } from '../useConvertPriceToUSD';
 
 describe('useConvertPriceToUSD', () => {
-	const defaultArgs: UseConvertPriceToUSDArgs = {
+	const defaultArgs: UseConvertPriceToUSDParams = {
 		chainId: 1,
 		currencyAddress: zeroAddress,
 		amountRaw: '1000000000000000000', // 1 ETH
@@ -113,7 +113,7 @@ describe('useConvertPriceToUSD', () => {
 		);
 
 		const { result, rerender } = renderHook(
-			(args: UseConvertPriceToUSDArgs = defaultArgs) =>
+			(args: UseConvertPriceToUSDParams = defaultArgs) =>
 				useConvertPriceToUSD(args),
 		);
 

package/src/react/hooks/__tests__/useCountListingsForCollectible.test.tsx

@@ -1,5 +1,5 @@
 import { renderHook, server, waitFor } from '@test';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
 import { mockMarketplaceEndpoint } from '../../_internal/api/__mocks__/marketplace.msw';
@@ -28,7 +28,7 @@ describe('useCountListingsForCollectible', () => {
 		});
 
 		// Verify the data matches our mock
-		expect(result.current.data).toEqual({ count: 1 });
+		expect(result.current.data).toEqual(1);
 		expect(result.current.error).toBeNull();
 	});
 

package/src/react/hooks/__tests__/useCountOfCollectables.test.tsx

@@ -1,20 +1,20 @@
 import { renderHook, server, waitFor } from '@test';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
 import { OrderSide } from '../../_internal';
 import { mockMarketplaceEndpoint } from '../../_internal/api/__mocks__/marketplace.msw';
-import type { UseCountOfCollectablesArgs } from '../useCountOfCollectables';
+import type { UseCountOfCollectablesParams } from '../useCountOfCollectables';
 import { useCountOfCollectables } from '../useCountOfCollectables';
 
 describe('useCountOfCollectables', () => {
-	const defaultArgs: UseCountOfCollectablesArgs = {
+	const defaultArgs: UseCountOfCollectablesParams = {
 		chainId: 1,
 		collectionAddress: zeroAddress,
 		query: {},
 	};
 
-	const defaultArgsWithFilter: UseCountOfCollectablesArgs = {
+	const defaultArgsWithFilter: UseCountOfCollectablesParams = {
 		...defaultArgs,
 		filter: {
 			includeEmpty: true,
@@ -109,7 +109,7 @@ describe('useCountOfCollectables', () => {
 	});
 
 	it('should handle undefined query params', async () => {
-		const argsWithoutQuery: UseCountOfCollectablesArgs = {
+		const argsWithoutQuery: UseCountOfCollectablesParams = {
 			chainId: 1,
 			collectionAddress: zeroAddress,
 		};

package/src/react/hooks/__tests__/useCountOffersForCollectible.test.tsx

@@ -1,5 +1,5 @@
 import { renderHook, server, waitFor } from '@test';
-import { http, HttpResponse } from 'msw';
+import { HttpResponse, http } from 'msw';
 import { zeroAddress } from 'viem';
 import { describe, expect, it } from 'vitest';
 import { mockMarketplaceEndpoint } from '../../_internal/api/__mocks__/marketplace.msw';
@@ -28,7 +28,7 @@ describe('useCountOffersForCollectible', () => {
 		});
 
 		// Verify the data matches our mock
-		expect(result.current.data).toEqual({ count: 1 });
+		expect(result.current.data).toMatchInlineSnapshot('1');
 		expect(result.current.error).toBeNull();
 	});