@0xsequence/marketplace-sdk 0.5.2 → 0.5.4

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

@@ -0,0 +1,232 @@
+import { describe, expect, it } from 'vitest';
+import { useListCollectibles } from '../useListCollectibles';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { zeroAddress } from 'viem';
+import type { UseListCollectiblesArgs } from '../useListCollectibles';
+import { http, HttpResponse } from 'msw';
+import {
+	mockCollectibleOrder,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
+import { server } from '../../_internal/test/setup';
+import {
+	MarketplaceKind,
+	OrderSide,
+} from '../../_internal/api/marketplace.gen';
+import type { ListCollectiblesArgs } from '../../_internal';
+
+describe('useListCollectibles', () => {
+	const defaultArgs: UseListCollectiblesArgs = {
+		chainId: '1',
+		collectionAddress: zeroAddress,
+		side: OrderSide.listing,
+		query: {
+			enabled: true,
+		},
+	};
+
+	it('should fetch collectibles successfully', async () => {
+		// Set up the default success handler
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return HttpResponse.json({
+					collectibles: [mockCollectibleOrder],
+					page: { page: 1, pageSize: 30, more: false },
+				});
+			}),
+		);
+
+		const { result } = renderHook(() => useListCollectibles(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?.pages[0]).toEqual({
+			collectibles: [mockCollectibleOrder],
+			page: { page: 1, pageSize: 30, more: false },
+		});
+		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('ListCollectibles'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch collectibles' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() => useListCollectibles(defaultArgs));
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should handle infinite pagination correctly', async () => {
+		// Mock responses for different pages
+		const pages = [
+			{
+				collectibles: [mockCollectibleOrder],
+				page: { page: 1, pageSize: 30, more: true },
+			},
+			{
+				collectibles: [{ ...mockCollectibleOrder, tokenId: '2' }],
+				page: { page: 2, pageSize: 30, more: false },
+			},
+		];
+
+		let currentPage = 0;
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				const response = pages[currentPage];
+				currentPage = Math.min(currentPage + 1, pages.length - 1);
+				return HttpResponse.json(response);
+			}),
+		);
+
+		const { result } = renderHook(() => useListCollectibles(defaultArgs));
+
+		// Wait for initial data
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Verify first page
+		expect(result.current.data?.pages[0]).toEqual(pages[0]);
+		expect(result.current.hasNextPage).toBe(true);
+
+		// Fetch next page
+		await result.current.fetchNextPage();
+
+		// Wait for second page to load
+		await waitFor(() => {
+			expect(result.current.isFetchingNextPage).toBe(false);
+		});
+
+		// Verify both pages are present
+		expect(result.current.data?.pages).toHaveLength(2);
+		expect(result.current.data?.pages[1]).toEqual(pages[1]);
+		expect(result.current.hasNextPage).toBe(false);
+	});
+
+	it('should handle disabled queries', async () => {
+		// Set up a mock handler to ensure no requests are made
+		let requestMade = false;
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				requestMade = true;
+				return HttpResponse.json({
+					collectibles: [mockCollectibleOrder],
+					page: { page: 1, pageSize: 30, more: false },
+				});
+			}),
+		);
+
+		const disabledArgs: UseListCollectiblesArgs = {
+			...defaultArgs,
+			query: {
+				enabled: false,
+			},
+		};
+
+		const { result } = renderHook(() => useListCollectibles(disabledArgs));
+
+		// For disabled queries, we expect no loading state and no data
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.error).toBeNull();
+		expect(requestMade).toBe(false);
+	});
+
+	it('should refetch when args change', async () => {
+		// Set up the success handler
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return HttpResponse.json({
+					collectibles: [mockCollectibleOrder],
+					page: { page: 1, pageSize: 30, more: false },
+				});
+			}),
+		);
+
+		let currentArgs = defaultArgs;
+		const { result, rerender } = renderHook(() =>
+			useListCollectibles(currentArgs),
+		);
+
+		// Wait for initial data
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Change args and rerender
+		currentArgs = {
+			...defaultArgs,
+			collectionAddress:
+				'0x1234567890123456789012345678901234567890' as `0x${string}`,
+		};
+
+		rerender();
+
+		// Wait for new data
+		await waitFor(() => {
+			expect(result.current.data?.pages[0]).toBeDefined();
+		});
+
+		// Verify that the query was refetched with new args
+		expect(result.current.data?.pages[0]).toBeDefined();
+		expect(result.current.isSuccess).toBe(true);
+	});
+
+	it('should handle filter parameters', async () => {
+		const argsWithFilter: UseListCollectiblesArgs = {
+			...defaultArgs,
+			filter: {
+				includeEmpty: true,
+				searchText: 'test',
+				marketplaces: [MarketplaceKind.sequence_marketplace_v2],
+			},
+		};
+
+		let requestArgs: ListCollectiblesArgs | undefined;
+		server.use(
+			http.post(
+				mockMarketplaceEndpoint('ListCollectibles'),
+				async ({ request }) => {
+					requestArgs = (await request.json()) as ListCollectiblesArgs;
+					return HttpResponse.json({
+						collectibles: [mockCollectibleOrder],
+						page: { page: 1, pageSize: 30, more: false },
+					});
+				},
+			),
+		);
+
+		const { result } = renderHook(() => useListCollectibles(argsWithFilter));
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Verify that filter parameters were passed correctly
+		expect(requestArgs?.filter).toEqual({
+			includeEmpty: true,
+			searchText: 'test',
+			marketplaces: [MarketplaceKind.sequence_marketplace_v2],
+		});
+	});
+});

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

@@ -0,0 +1,217 @@
+import { waitFor } from '@testing-library/react';
+import { http, HttpResponse } from 'msw';
+import { zeroAddress } from 'viem';
+import { describe, expect, it } from 'vitest';
+import {
+	mockCollectibleOrder,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
+import { OrderSide } from '../../_internal/api/marketplace.gen';
+import { renderHook } from '../../_internal/test-utils';
+import { server } from '../../_internal/test/setup';
+import { useListCollectiblesPaginated } from '../useListCollectiblesPaginated';
+import type { UseListCollectiblesPaginatedArgs } from '../useListCollectiblesPaginated';
+
+describe('useListCollectiblesPaginated', () => {
+	const defaultArgs: UseListCollectiblesPaginatedArgs = {
+		chainId: '1',
+		collectionAddress: zeroAddress,
+		side: OrderSide.listing,
+		query: {
+			enabled: true,
+			page: 1,
+			pageSize: 30,
+		},
+	};
+
+	it('should fetch collectibles successfully', async () => {
+		// Set up mock response
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return HttpResponse.json({
+					collectibles: [mockCollectibleOrder],
+					page: { page: 1, pageSize: 30, more: false },
+				});
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useListCollectiblesPaginated(defaultArgs),
+		);
+
+		// Wait for the query to complete
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Verify the data
+		expect(result.current.data?.collectibles).toEqual([mockCollectibleOrder]);
+		expect(result.current.data?.page).toEqual({
+			page: 1,
+			pageSize: 30,
+			more: false,
+		});
+	});
+
+	it('should handle error states', async () => {
+		// Override the handler to return an error
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch collectibles' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useListCollectiblesPaginated(defaultArgs),
+		);
+
+		// Wait for the error state
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should handle pagination correctly', async () => {
+		// Set up mock response for page 2
+		const modifiedCollectibleOrder = {
+			...mockCollectibleOrder,
+			metadata: {
+				...mockCollectibleOrder.metadata,
+				tokenId: '2',
+			},
+		};
+
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return HttpResponse.json({
+					collectibles: [modifiedCollectibleOrder],
+					page: { page: 2, pageSize: 20, more: false },
+				});
+			}),
+		);
+
+		const paginatedArgs: UseListCollectiblesPaginatedArgs = {
+			...defaultArgs,
+			query: {
+				enabled: true,
+				page: 2,
+				pageSize: 20,
+			},
+		};
+
+		const { result } = renderHook(() =>
+			useListCollectiblesPaginated(paginatedArgs),
+		);
+
+		// Wait for the query to complete
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Verify the data for page 2
+		expect(result.current.data?.collectibles[0].metadata.tokenId).toBe('2');
+		expect(result.current.data?.page).toEqual({
+			page: 2,
+			pageSize: 20,
+			more: false,
+		});
+	});
+
+	it('should refetch when args change', async () => {
+		// Set up initial mock response
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return HttpResponse.json({
+					collectibles: [mockCollectibleOrder],
+					page: { page: 1, pageSize: 30, more: true },
+				});
+			}),
+		);
+
+		let currentArgs = defaultArgs;
+		const { result, rerender } = renderHook(() =>
+			useListCollectiblesPaginated(currentArgs),
+		);
+
+		// Wait for initial data
+		await waitFor(() => {
+			expect(result.current.isSuccess).toBe(true);
+		});
+
+		// Change args and rerender
+		currentArgs = {
+			...defaultArgs,
+			query: {
+				...defaultArgs.query,
+				page: 2,
+			},
+		};
+
+		// Set up mock response for page 2
+		const modifiedCollectibleOrder = {
+			...mockCollectibleOrder,
+			metadata: {
+				...mockCollectibleOrder.metadata,
+				tokenId: '2',
+			},
+		};
+
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				return HttpResponse.json({
+					collectibles: [modifiedCollectibleOrder],
+					page: { page: 2, pageSize: 30, more: false },
+				});
+			}),
+		);
+
+		rerender();
+
+		// Wait for new data
+		await waitFor(() => {
+			expect(result.current.data?.page?.page).toBe(2);
+		});
+
+		// Verify new data
+		expect(result.current.data?.collectibles[0].metadata.tokenId).toBe('2');
+	});
+
+	it('should not fetch when enabled is false', async () => {
+		// Set up a mock handler to ensure no requests are made
+		let requestMade = false;
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectibles'), () => {
+				requestMade = true;
+				return HttpResponse.json({
+					collectibles: [mockCollectibleOrder],
+					page: { page: 1, pageSize: 30, more: false },
+				});
+			}),
+		);
+
+		const disabledArgs: UseListCollectiblesPaginatedArgs = {
+			...defaultArgs,
+			query: {
+				enabled: false,
+				page: 1,
+				pageSize: 30,
+			},
+		};
+
+		const { result } = renderHook(() =>
+			useListCollectiblesPaginated(disabledArgs),
+		);
+
+		// For disabled queries, we expect no loading state and no data
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.error).toBeNull();
+		expect(requestMade).toBe(false);
+	});
+});

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

@@ -0,0 +1,235 @@
+import { describe, expect, it, beforeEach } from 'vitest';
+import { useListCollectionActivities } from '../useListCollectionActivities';
+import { renderHook, waitFor } from '../../_internal/test-utils';
+import { zeroAddress } from 'viem';
+import type { UseListCollectionActivitiesArgs } from '../useListCollectionActivities';
+import { http, HttpResponse } from 'msw';
+import {
+	mockActivity,
+	mockMarketplaceEndpoint,
+} from '../../_internal/api/__mocks__/marketplace.msw';
+import { server } from '../../_internal/test/setup';
+import { SortOrder } from '../../_internal/api/marketplace.gen';
+import type { ListCollectionActivitiesArgs } from '../../_internal/api/marketplace.gen';
+
+describe('useListCollectionActivities', () => {
+	const defaultArgs: UseListCollectionActivitiesArgs = {
+		chainId: '1',
+		collectionAddress: zeroAddress,
+		query: {
+			enabled: true,
+			page: 1,
+			pageSize: 10,
+		},
+	};
+
+	// Reset handlers before each test
+	beforeEach(() => {
+		server.resetHandlers();
+	});
+
+	it('should fetch collection activities successfully', async () => {
+		// Set up the default success handler
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectionActivities'), () => {
+				return HttpResponse.json({
+					activities: [mockActivity],
+					page: { page: 1, pageSize: 10, more: false },
+				});
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useListCollectionActivities(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({
+			activities: [mockActivity],
+			page: { page: 1, pageSize: 10, more: false },
+		});
+		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('ListCollectionActivities'), () => {
+				return HttpResponse.json(
+					{ error: { message: 'Failed to fetch activities' } },
+					{ status: 500 },
+				);
+			}),
+		);
+
+		const { result } = renderHook(() =>
+			useListCollectionActivities(defaultArgs),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isError).toBe(true);
+		});
+
+		expect(result.current.error).toBeDefined();
+		expect(result.current.data).toBeUndefined();
+	});
+
+	it('should handle disabled queries', async () => {
+		// Set up a mock handler to ensure no requests are made
+		let requestMade = false;
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectionActivities'), () => {
+				requestMade = true;
+				return HttpResponse.json({
+					activities: [mockActivity],
+					page: { page: 1, pageSize: 10, more: false },
+				});
+			}),
+		);
+
+		const disabledArgs: UseListCollectionActivitiesArgs = {
+			...defaultArgs,
+			query: {
+				enabled: false,
+				page: 1,
+				pageSize: 10,
+			},
+		};
+
+		const { result } = renderHook(() =>
+			useListCollectionActivities(disabledArgs),
+		);
+
+		// For disabled queries, we expect no loading state and no data
+		expect(result.current.isLoading).toBe(false);
+		expect(result.current.data).toBeUndefined();
+		expect(result.current.error).toBeNull();
+		expect(requestMade).toBe(false);
+	});
+
+	it('should refetch when args change', async () => {
+		// Set up the success handler
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectionActivities'), () => {
+				return HttpResponse.json({
+					activities: [mockActivity],
+					page: { page: 1, pageSize: 10, more: false },
+				});
+			}),
+		);
+
+		let currentArgs = defaultArgs;
+		const { result, rerender } = renderHook(() =>
+			useListCollectionActivities(currentArgs),
+		);
+
+		// Wait for initial data
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		// Change args and rerender
+		currentArgs = {
+			...defaultArgs,
+			collectionAddress:
+				'0x1234567890123456789012345678901234567890' as `0x${string}`,
+		};
+
+		rerender();
+
+		// 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 sorting parameters', async () => {
+		const argsWithSort: UseListCollectionActivitiesArgs = {
+			...defaultArgs,
+			query: {
+				enabled: true,
+				page: 1,
+				pageSize: 10,
+				sort: [{ column: 'createdAt', order: SortOrder.DESC }],
+			},
+		};
+
+		let requestArgs: ListCollectionActivitiesArgs | null = null;
+
+		server.use(
+			http.post(
+				mockMarketplaceEndpoint('ListCollectionActivities'),
+				async ({ request }) => {
+					requestArgs = (await request.json()) as ListCollectionActivitiesArgs;
+					return HttpResponse.json({
+						activities: [mockActivity],
+						page: { page: 1, pageSize: 10, more: false },
+					});
+				},
+			),
+		);
+
+		const { result } = renderHook(() =>
+			useListCollectionActivities(argsWithSort),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		await waitFor(() => {
+			expect(requestArgs).not.toBeNull();
+			expect(requestArgs?.page?.sort).toEqual([
+				{ column: 'createdAt', order: SortOrder.DESC },
+			]);
+		});
+	});
+
+	it('should handle pagination correctly', async () => {
+		// Override the handler for this test to return paginated data
+		server.use(
+			http.post(mockMarketplaceEndpoint('ListCollectionActivities'), () => {
+				return HttpResponse.json({
+					activities: [mockActivity],
+					page: { page: 2, pageSize: 20, more: false },
+				});
+			}),
+		);
+
+		const paginatedArgs: UseListCollectionActivitiesArgs = {
+			...defaultArgs,
+			query: {
+				enabled: true,
+				page: 2,
+				pageSize: 20,
+			},
+		};
+
+		const { result } = renderHook(() =>
+			useListCollectionActivities(paginatedArgs),
+		);
+
+		await waitFor(() => {
+			expect(result.current.isLoading).toBe(false);
+		});
+
+		expect(result.current.data?.page).toEqual({
+			page: 2,
+			pageSize: 20,
+			more: false,
+		});
+	});
+});