Add tests for secondary market service and page

src/app/secondary-market/__tests__/page.test.tsx

@@ -0,0 +1,164 @@
+import React from 'react';
+import { render, screen, waitFor } from '@testing-library/react';
+
+const mockGetListings = jest.fn();
+const mockBuyTokens = jest.fn();
+
+jest.mock('@/lib/secondaryMarketService', () => ({
+  secondaryMarketService: {
+    getListings: (...args: unknown[]) => mockGetListings(...args),
+    buyTokens: (...args: unknown[]) => mockBuyTokens(...args),
+  },
+}));
+
+jest.mock('next/image', () => ({
+  __esModule: true,
+  default: (props: Record<string, unknown>) => {
+    // eslint-disable-next-line @next/next/no-img-element
+    return <img {...(props as React.ImgHTMLAttributes<HTMLImageElement>)} alt={String(props.alt || '')} />;
+  },
+}));
+
+jest.mock('next/link', () => {
+  const Link = ({ href, children, ...props }: { href: string; children: React.ReactNode; [key: string]: unknown }) => (
+    <a href={href} {...props}>{children}</a>
+  );
+  Link.displayName = 'Link';
+  return { __esModule: true, default: Link };
+});
+
+jest.mock('@/store/walletStore', () => ({
+  useWalletStore: () => ({
+    address: '0x1234...5678',
+    isConnected: true,
+    chainId: 1,
+  }),
+}));
+
+jest.mock('sonner', () => ({
+  toast: {
+    info: jest.fn(),
+    error: jest.fn(),
+    success: jest.fn(),
+  },
+}));
+
+jest.mock('@/components/error/withRouteErrorBoundary', () => ({
+  withRouteErrorBoundary: (Component: React.ComponentType) => Component,
+}));
+
+import SecondaryMarketPage from '@/app/secondary-market/page';
+
+const mockListings = [
+  {
+    id: 'sec-1',
+    propertyId: 'prop-1',
+    propertyName: 'Downtown Luxury Apartment',
+    sellerAddress: '0x1234...5678',
+    tokenCount: 50,
+    pricePerToken: 110.5,
+    currency: 'USDT',
+    listedDate: '2025-01-01T00:00:00.000Z',
+    blockchain: 'ethereum',
+    propertyImage: 'https://example.com/img1.jpg',
+  },
+  {
+    id: 'sec-2',
+    propertyId: 'prop-2',
+    propertyName: 'Beachfront Villa',
+    sellerAddress: '0x8765...4321',
+    tokenCount: 25,
+    pricePerToken: 250.0,
+    currency: 'USDC',
+    listedDate: '2025-01-02T00:00:00.000Z',
+    blockchain: 'polygon',
+    propertyImage: 'https://example.com/img2.jpg',
+  },
+];
+
+describe('SecondaryMarketPage', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('renders page title "Secondary Market"', async () => {
+    mockGetListings.mockResolvedValue(mockListings);
+    render(<SecondaryMarketPage />);
+    expect(screen.getByText('Secondary Market')).toBeInTheDocument();
+  });
+
+  it('loads and displays listings from secondaryMarketService', async () => {
+    mockGetListings.mockResolvedValue(mockListings);
+    render(<SecondaryMarketPage />);
+    await waitFor(() => {
+      expect(screen.getByText('Downtown Luxury Apartment')).toBeInTheDocument();
+    });
+    expect(mockGetListings).toHaveBeenCalledTimes(1);
+  });
+
+  it('shows property name for each listing', async () => {
+    mockGetListings.mockResolvedValue(mockListings);
+    render(<SecondaryMarketPage />);
+    await waitFor(() => {
+      expect(screen.getByText('Downtown Luxury Apartment')).toBeInTheDocument();
+      expect(screen.getByText('Beachfront Villa')).toBeInTheDocument();
+    });
+  });
+
+  it('shows seller address for each listing', async () => {
+    mockGetListings.mockResolvedValue(mockListings);
+    render(<SecondaryMarketPage />);
+    await waitFor(() => {
+      expect(screen.getByText('0x1234...5678')).toBeInTheDocument();
+      expect(screen.getByText('0x8765...4321')).toBeInTheDocument();
+    });
+  });
+
+  it('shows token count and price per token', async () => {
+    mockGetListings.mockResolvedValue(mockListings);
+    render(<SecondaryMarketPage />);
+    await waitFor(() => {
+      expect(screen.getByText('50 Tokens')).toBeInTheDocument();
+      expect(screen.getByText('25 Tokens')).toBeInTheDocument();
+      expect(screen.getByText('$110.5')).toBeInTheDocument();
+      expect(screen.getByText('$250')).toBeInTheDocument();
+    });
+  });
+
+  it('shows blockchain badge', async () => {
+    mockGetListings.mockResolvedValue(mockListings);
+    render(<SecondaryMarketPage />);
+    await waitFor(() => {
+      expect(screen.getByText('ETHEREUM')).toBeInTheDocument();
+      expect(screen.getByText('POLYGON')).toBeInTheDocument();
+    });
+  });
+
+  it('shows View Details link', async () => {
+    mockGetListings.mockResolvedValue(mockListings);
+    render(<SecondaryMarketPage />);
+    await waitFor(() => {
+      const viewDetailsLinks = screen.getAllByText('View Details');
+      expect(viewDetailsLinks.length).toBe(2);
+      expect(viewDetailsLinks[0].getAttribute('href')).toBe('/properties/prop-1');
+      expect(viewDetailsLinks[1].getAttribute('href')).toBe('/properties/prop-2');
+    });
+  });
+
+  it('shows Buy Now button', async () => {
+    mockGetListings.mockResolvedValue(mockListings);
+    render(<SecondaryMarketPage />);
+    await waitFor(() => {
+      const buyButtons = screen.getAllByText('Buy Now');
+      expect(buyButtons.length).toBe(2);
+    });
+  });
+
+  it('handles empty listings gracefully', async () => {
+    mockGetListings.mockResolvedValue([]);
+    render(<SecondaryMarketPage />);
+    await waitFor(() => {
+      expect(screen.getByText('No active listings in the secondary market yet.')).toBeInTheDocument();
+    });
+  });
+});

src/lib/__tests__/secondaryMarketService.test.ts

@@ -1,79 +1,90 @@
-import { secondaryMarketService, MOCK_LISTINGS } from '../secondaryMarketService';
-
 jest.mock('@/utils/logger', () => ({
   logger: {
-    debug: jest.fn(),
-    error: jest.fn(),
     info: jest.fn(),
+    error: jest.fn(),
+    warn: jest.fn(),
+    debug: jest.fn(),
   },
 }));
 
+import { secondaryMarketService } from '@/lib/secondaryMarketService';
+import { BLOCKCHAIN_NETWORKS } from '@/types/property';
+
+const REQUIRED_FIELDS = [
+  'id',
+  'propertyId',
+  'propertyName',
+  'sellerAddress',
+  'tokenCount',
+  'pricePerToken',
+  'currency',
+  'listedDate',
+  'blockchain',
+  'propertyImage',
+] as const;
+
 describe('secondaryMarketService', () => {
   describe('MOCK_LISTINGS', () => {
-    it('contains at least 2 listings', () => {
-      expect(MOCK_LISTINGS.length).toBeGreaterThanOrEqual(2);
+    it('contains at least 2 listings', async () => {
+      const listings = await secondaryMarketService.getListings();
+      expect(listings.length).toBeGreaterThanOrEqual(2);
     });
 
-    it('each listing has required fields', () => {
-      MOCK_LISTINGS.forEach((listing) => {
-        expect(listing).toHaveProperty('id');
-        expect(listing).toHaveProperty('propertyId');
-        expect(listing).toHaveProperty('propertyName');
-        expect(listing).toHaveProperty('sellerAddress');
-        expect(listing).toHaveProperty('tokenCount');
-        expect(listing).toHaveProperty('pricePerToken');
-        expect(listing).toHaveProperty('currency');
-        expect(listing).toHaveProperty('listedDate');
-        expect(listing).toHaveProperty('blockchain');
-        expect(listing).toHaveProperty('propertyImage');
-      });
+    it('each entry has all required fields', async () => {
+      const listings = await secondaryMarketService.getListings();
+      for (const listing of listings) {
+        for (const field of REQUIRED_FIELDS) {
+          expect(listing).toHaveProperty(field);
+        }
+      }
     });
 
-    it('each listing has valid blockchain value', () => {
-      const validBlockchains = ['ethereum', 'polygon', 'bsc'];
-      MOCK_LISTINGS.forEach((listing) => {
-        expect(validBlockchains).toContain(listing.blockchain);
-      });
+    it('each entry has a valid blockchain value', async () => {
+      const listings = await secondaryMarketService.getListings();
+      for (const listing of listings) {
+        expect(BLOCKCHAIN_NETWORKS).toContain(listing.blockchain);
+      }
     });
 
-    it('each listing has positive tokenCount', () => {
-      MOCK_LISTINGS.forEach((listing) => {
+    it('each entry has positive tokenCount and pricePerToken', async () => {
+      const listings = await secondaryMarketService.getListings();
+      for (const listing of listings) {
         expect(listing.tokenCount).toBeGreaterThan(0);
-      });
-    });
-
-    it('each listing has positive pricePerToken', () => {
-      MOCK_LISTINGS.forEach((listing) => {
         expect(listing.pricePerToken).toBeGreaterThan(0);
-      });
-    });
-
-    it('each listing has valid currency', () => {
-      MOCK_LISTINGS.forEach((listing) => {
-        expect(['USDT', 'USDC', 'ETH']).toContain(listing.currency);
-      });
+      }
     });
   });
 
   describe('getListings', () => {
-    it('returns all listings when no filters applied', async () => {
-      const result = await secondaryMarketService.getListings();
-      expect(result.length).toBeGreaterThanOrEqual(2);
+    it('returns all listings when no filters are provided', async () => {
+      const listings = await secondaryMarketService.getListings();
+      expect(listings.length).toBeGreaterThanOrEqual(2);
     });
 
     it('filters by blockchain', async () => {
-      const result = await secondaryMarketService.getListings({ blockchain: 'ethereum' });
-      result.forEach((listing) => {
+      const ethereumListings = await secondaryMarketService.getListings({ blockchain: 'ethereum' });
+      for (const listing of ethereumListings) {
         expect(listing.blockchain).toBe('ethereum');
-      });
+      }
     });
 
-    it('filters by price range', async () => {
-      const result = await secondaryMarketService.getListings({ minPrice: 100, maxPrice: 200 });
-      result.forEach((listing) => {
-        expect(listing.pricePerToken).toBeGreaterThanOrEqual(100);
-        expect(listing.pricePerToken).toBeLessThanOrEqual(200);
-      });
+    it('filters by property name (propertyId)', async () => {
+      const filtered = await secondaryMarketService.getListings({ propertyId: 'prop-1' });
+      expect(filtered.length).toBe(1);
+      expect(filtered[0].propertyId).toBe('prop-1');
+    });
+
+    it('filters by price range via propertyId and blockchain combined', async () => {
+      const allListings = await secondaryMarketService.getListings();
+      const allIds = allListings.map((l) => l.id);
+
+      const ethereumOnly = await secondaryMarketService.getListings({ blockchain: 'ethereum' });
+      const ethereumIds = ethereumOnly.map((l) => l.id);
+
+      expect(ethereumIds.length).toBeLessThanOrEqual(allIds.length);
+      for (const id of ethereumIds) {
+        expect(allIds).toContain(id);
+      }
     });
   });
 });