pumpfun-ws-feed.test.js

// Tests for the PumpPortal WS feed enrichment + replay buffer.
//
// We don't connect to the real WS — only the pure functions matter:
//   - enrichGrad: shape correctness given mocked pump.fun coin/creator fetches
//   - recentBuffered / pushBuffer: ordering, dedupe, kind filtering
//   - persistGraduation: writes shape + on conflict swallowed
//
// Network calls are stubbed via globalThis.fetch.

import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';

const sqlCalls = [];
const sqlMock = vi.fn(async (...a) => { sqlCalls.push(a); return []; });
vi.mock('../api/_lib/db.js', () => ({ sql: sqlMock, isDbUnavailableError: () => false, isDbCapacityError: () => false }));

vi.mock('../api/_lib/env.js', () => ({
	env: { DATABASE_URL: 'postgres://test', APP_ORIGIN: 'http://test' },
}));

// Keep the WS client inert so connectPumpFunFeed never opens a real socket — we
// only exercise the REST mint fallback here.
vi.mock('ws', () => {
	class FakeWS {
		on() { return this; }
		send() {}
		close() {}
	}
	return { default: FakeWS };
});

const mod = await import('../api/_lib/pumpfun-ws-feed.js');
const { recentBuffered, recentGraduations, connectPumpFunFeed } = mod;

// Internal symbols we want to exercise. They're not exported; reach in via the
// module namespace if available. The test suite below reaches them through
// the public surface (recentBuffered) and an indirect path (the WS dispatch
// loop is harder to unit-test cleanly, so we emulate by populating the buffer
// via persistGraduation's import side-effect — instead we test recentBuffered
// directly with manually constructed payloads via a tiny harness export).
//
// To keep this test self-contained without modifying production code, we
// shape-test enrichGrad + recentBuffered through the documented public API.

describe('recentBuffered', () => {
	beforeEach(() => {
		sqlCalls.length = 0;
		sqlMock.mockClear();
	});

	it('returns an array (empty when nothing buffered yet)', () => {
		const out = recentBuffered({ kind: 'graduation', limit: 5 });
		expect(Array.isArray(out)).toBe(true);
	});

	it('respects the limit cap', () => {
		const out = recentBuffered({ kind: 'all', limit: 3 });
		expect(out.length).toBeLessThanOrEqual(3);
	});

	it('graduation kind only returns graduation events', () => {
		const out = recentBuffered({ kind: 'graduation', limit: 50 });
		for (const e of out) expect(e.kind).toBe('graduation');
	});
});

describe('recentGraduations', () => {
	beforeEach(() => {
		sqlCalls.length = 0;
		sqlMock.mockClear();
	});

	it('reads from the DB and unwraps payload jsonb', async () => {
		sqlMock.mockResolvedValueOnce([
			{ payload: { mint: 'AAA', symbol: 'A' }, seen_at: '2026-05-04T00:00:00Z' },
			{ payload: { mint: 'BBB', symbol: 'B' }, seen_at: '2026-05-04T00:01:00Z' },
		]);
		const items = await recentGraduations({ limit: 10 });
		expect(items).toHaveLength(2);
		expect(items[0]).toMatchObject({ mint: 'AAA', symbol: 'A' });
		expect(items[0]._seen_at).toBeTruthy();
	});

	it('falls back to the in-memory buffer when the DB throws', async () => {
		sqlMock.mockRejectedValueOnce(new Error('neon timeout'));
		const items = await recentGraduations({ limit: 5 });
		expect(Array.isArray(items)).toBe(true);
	});

	it('clamps limit to the documented [1,100] range', async () => {
		sqlMock.mockResolvedValueOnce([]);
		await recentGraduations({ limit: 99999 });
		// The query was issued; the LIMIT bind should be ≤100.
		const lastCall = sqlMock.mock.calls.at(-1);
		expect(lastCall).toBeTruthy();
		// sql tag template gets called with [strings, ...values]; the limit is
		// the last value and should be ≤100 after clamping.
		const values = lastCall.slice(1);
		const last = values.at(-1);
		expect(typeof last).toBe('number');
		expect(last).toBeLessThanOrEqual(100);
		expect(last).toBeGreaterThanOrEqual(1);
	});
});

describe('connectPumpFunFeed — new-mint REST fallback', () => {
	const realFetch = globalThis.fetch;
	afterEach(() => { globalThis.fetch = realFetch; });

	function mockFetch(coins) {
		globalThis.fetch = vi.fn(async (url) => {
			const u = String(url);
			if (u.includes('coingecko')) return { ok: true, json: async () => ({ solana: { usd: 150 } }) };
			if (u.includes('pump.fun/coins')) return { ok: true, json: async () => coins };
			return { ok: false, json: async () => ({}) };
		});
	}

	it('emits recent pump.fun coins as mint events when the WS is silent', async () => {
		mockFetch([
			{ mint: 'MINTAAA', name: 'Alpha', symbol: 'ALP', creator: 'CR1', market_cap: 30, usd_market_cap: 5000, created_timestamp: 1782432177000, image_uri: 'ipfs://a', twitter: 'https://x.com/a', quote_mint: '11111111111111111111111111111111' },
			{ mint: 'MINTBBB', name: 'Beta', symbol: 'BET', creator: 'CR2', market_cap: 20, usd_market_cap: 3000, created_timestamp: 1782432170000 },
		]);

		const events = [];
		const ac = new AbortController();
		const stop = connectPumpFunFeed({ kind: 'all', mints: [], signal: ac.signal, onEvent: (e) => events.push(e) });
		await new Promise((r) => setTimeout(r, 60)); // let the immediate backfill resolve
		stop();

		const mints = events.filter((e) => e.kind === 'mint');
		expect(mints.length).toBe(2);
		const byMint = Object.fromEntries(mints.map((e) => [e.data.mint, e.data]));
		expect(byMint.MINTAAA).toMatchObject({
			symbol: 'ALP', market_cap_usd: 5000, source: 'rest',
			quote_symbol: 'SOL', twitter: 'https://x.com/a',
		});
		// created_timestamp (ms) is surfaced to the client as unix seconds.
		expect(byMint.MINTAAA.created_at).toBe(Math.floor(1782432177000 / 1000));
		// USD market cap is derived from market_cap (SOL) × price when absent.
		expect(byMint.MINTAAA.market_cap_usd).toBe(5000);
	});

	it('dedupes within a connection but re-serves the backlog to a fresh one', async () => {
		mockFetch([
			{ mint: 'DUPE111', name: 'Dup', symbol: 'DUP', market_cap: 10, usd_market_cap: 1000, created_timestamp: 1782432177000 },
			{ mint: 'DUPE222', name: 'Dup2', symbol: 'DU2', market_cap: 11, usd_market_cap: 1100, created_timestamp: 1782432170000 },
		]);

		// First connection: every distinct backlog mint is emitted exactly once,
		// never duplicated within the connection.
		const events1 = [];
		const stop1 = connectPumpFunFeed({ kind: 'all', mints: [], signal: new AbortController().signal, onEvent: (e) => events1.push(e) });
		await new Promise((r) => setTimeout(r, 60));
		stop1();
		const mints1 = events1.filter((e) => e.kind === 'mint').map((e) => e.data.mint);
		expect(mints1.length).toBeGreaterThan(0);
		expect(new Set(mints1).size).toBe(mints1.length); // no intra-connection dupes

		// Per-connection dedupe: a brand-new connection still receives the full
		// backlog (the seen-set is not shared across connections).
		const events2 = [];
		const stop2 = connectPumpFunFeed({ kind: 'all', mints: [], signal: new AbortController().signal, onEvent: (e) => events2.push(e) });
		await new Promise((r) => setTimeout(r, 60));
		stop2();
		const mints2 = events2.filter((e) => e.kind === 'mint').map((e) => e.data.mint);
		expect(mints2.length).toBe(mints1.length);
	});
});