pmxtjs 0.1.0 → 0.1.2

package/test/exchanges/kalshi/MarketHistory.test.ts

@@ -1,185 +0,0 @@
-import axios from 'axios';
-import { KalshiExchange } from '../../../src/exchanges/Kalshi';
-
-/**
- * Kalshi getMarketHistory() Test
- * 
- * What: Tests fetching historical OHLCV candlestick data.
- * Why: Historical data is essential for charting and analysis.
- * How: Mocks Kalshi candlestick API responses and verifies data transformation.
- */
-
-jest.mock('axios');
-const mockedAxios = axios as jest.Mocked<typeof axios>;
-
-describe('KalshiExchange - getMarketHistory', () => {
-    let exchange: KalshiExchange;
-
-    beforeEach(() => {
-        exchange = new KalshiExchange();
-        jest.clearAllMocks();
-    });
-
-    it('should fetch and parse candlestick data', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                candlesticks: [
-                    {
-                        end_period_ts: 1704067200,
-                        price: { open: 5200, high: 5300, low: 5100, close: 5250 },
-                        volume: 1000
-                    },
-                    {
-                        end_period_ts: 1704070800,
-                        price: { open: 5250, high: 5400, low: 5200, close: 5350 },
-                        volume: 1500
-                    }
-                ]
-            }
-        });
-
-        const history = await exchange.getMarketHistory('FED-25JAN-B4.75', { resolution: '1h' });
-
-        expect(history.length).toBe(2);
-        expect(history[0].open).toBe(52);  // 5200 / 100 = 52
-        expect(history[0].high).toBe(53);
-        expect(history[0].low).toBe(51);
-        expect(history[0].close).toBe(52.5);
-        expect(history[0].volume).toBe(1000);
-    });
-
-    it('should convert timestamps to milliseconds', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                candlesticks: [{
-                    end_period_ts: 1704067200,
-                    price: { open: 5000, high: 5000, low: 5000, close: 5000 },
-                    volume: 100
-                }]
-            }
-        });
-
-        const history = await exchange.getMarketHistory('TEST-MARKET-B5', { resolution: '1h' });
-
-        expect(history[0].timestamp).toBe(1704067200 * 1000);
-    });
-
-    it('should respect limit parameter', async () => {
-        const mockCandles = Array.from({ length: 100 }, (_, i) => ({
-            end_period_ts: 1704067200 + (i * 3600),
-            price: { open: 5000, high: 5000, low: 5000, close: 5000 },
-            volume: 100
-        }));
-
-        mockedAxios.get.mockResolvedValue({
-            data: { candlesticks: mockCandles }
-        });
-
-        const history = await exchange.getMarketHistory('TEST-MARKET-B5', {
-            resolution: '1h',
-            limit: 20
-        });
-
-        expect(history.length).toBe(20);
-    });
-
-    it('should handle different intervals', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                candlesticks: [{
-                    end_period_ts: 1704067200,
-                    price: { open: 5000, high: 5000, low: 5000, close: 5000 },
-                    volume: 100
-                }]
-            }
-        });
-
-        await exchange.getMarketHistory('TEST-MARKET-B5', { resolution: '1m' });
-        expect(mockedAxios.get).toHaveBeenCalledWith(
-            expect.any(String),
-            expect.objectContaining({
-                params: expect.objectContaining({ period_interval: 1 })
-            })
-        );
-
-        jest.clearAllMocks();
-        mockedAxios.get.mockResolvedValue({
-            data: { candlesticks: [] }
-        });
-
-        await exchange.getMarketHistory('TEST-MARKET-B5', { resolution: '1d' });
-        expect(mockedAxios.get).toHaveBeenCalledWith(
-            expect.any(String),
-            expect.objectContaining({
-                params: expect.objectContaining({ period_interval: 1440 })
-            })
-        );
-    });
-
-    it('should handle start and end timestamps', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: { candlesticks: [] }
-        });
-
-        const start = new Date('2025-01-01T00:00:00Z');
-        const end = new Date('2025-01-02T00:00:00Z');
-
-        await exchange.getMarketHistory('TEST-MARKET-B5', {
-            resolution: '1h',
-            start,
-            end
-        });
-
-        expect(mockedAxios.get).toHaveBeenCalledWith(
-            expect.any(String),
-            expect.objectContaining({
-                params: expect.objectContaining({
-                    start_ts: Math.floor(start.getTime() / 1000),
-                    end_ts: Math.floor(end.getTime() / 1000)
-                })
-            })
-        );
-    });
-
-    it('should handle empty candlesticks array', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: { candlesticks: [] }
-        });
-
-        const history = await exchange.getMarketHistory('TEST-MARKET-B5', { resolution: '1h' });
-
-        expect(history).toEqual([]);
-    });
-
-    it('should handle missing price fields gracefully', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                candlesticks: [{
-                    end_period_ts: 1704067200,
-                    price: {},  // Missing OHLC data
-                    volume: 100
-                }]
-            }
-        });
-
-        const history = await exchange.getMarketHistory('TEST-MARKET-B5', { resolution: '1h' });
-
-        expect(history[0].open).toBe(0);
-        expect(history[0].high).toBe(0);
-        expect(history[0].low).toBe(0);
-        expect(history[0].close).toBe(0);
-    });
-
-    it('should extract series ticker correctly', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: { candlesticks: [] }
-        });
-
-        await exchange.getMarketHistory('FED-25JAN-B4.75', { resolution: '1h' });
-
-        expect(mockedAxios.get).toHaveBeenCalledWith(
-            expect.stringContaining('/series/FED-25JAN/markets/FED-25JAN-B4.75/'),
-            expect.any(Object)
-        );
-    });
-});

package/test/exchanges/kalshi/OrderBook.test.ts

@@ -1,149 +0,0 @@
-import axios from 'axios';
-import { KalshiExchange } from '../../../src/exchanges/Kalshi';
-
-/**
- * Kalshi getOrderBook() Test
- * 
- * What: Tests fetching and parsing of order book data (bids/asks).
- * Why: Order book data is critical for trading and price discovery.
- * How: Mocks Kalshi orderbook API responses and verifies correct parsing and sorting.
- */
-
-jest.mock('axios');
-const mockedAxios = axios as jest.Mocked<typeof axios>;
-
-describe('KalshiExchange - getOrderBook', () => {
-    let exchange: KalshiExchange;
-
-    beforeEach(() => {
-        exchange = new KalshiExchange();
-        jest.clearAllMocks();
-    });
-
-    it('should parse orderbook data correctly', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                orderbook: {
-                    yes: [
-                        [5200, 100],  // price in cents, quantity
-                        [5100, 250],
-                        [5000, 500]
-                    ],
-                    no: [
-                        [4800, 150],
-                        [4900, 200],
-                        [5000, 300]
-                    ]
-                }
-            }
-        });
-
-        const orderbook = await exchange.getOrderBook('FED-25JAN-B4.75');
-
-        expect(orderbook.bids).toBeDefined();
-        expect(orderbook.asks).toBeDefined();
-        expect(orderbook.bids.length).toBe(3);
-        expect(orderbook.asks.length).toBe(3);
-    });
-
-    it('should convert prices from cents to decimals', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                orderbook: {
-                    yes: [[5200, 100]],
-                    no: [[4800, 100]]
-                }
-            }
-        });
-
-        const orderbook = await exchange.getOrderBook('TEST-MARKET');
-
-        expect(orderbook.bids[0].price).toBe(52);  // 5200 / 100 = 52
-        expect(orderbook.asks[0].price).toBe(-47);  // (100 - 4800) / 100 = -47
-    });
-
-    it('should sort bids in descending order', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                orderbook: {
-                    yes: [
-                        [5000, 100],
-                        [5200, 200],
-                        [5100, 150]
-                    ],
-                    no: []
-                }
-            }
-        });
-
-        const orderbook = await exchange.getOrderBook('TEST-MARKET');
-
-        expect(orderbook.bids[0].price).toBeGreaterThanOrEqual(orderbook.bids[1].price);
-        expect(orderbook.bids[1].price).toBeGreaterThanOrEqual(orderbook.bids[2].price);
-    });
-
-    it('should sort asks in ascending order', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                orderbook: {
-                    yes: [],
-                    no: [
-                        [5000, 100],
-                        [4800, 200],
-                        [4900, 150]
-                    ]
-                }
-            }
-        });
-
-        const orderbook = await exchange.getOrderBook('TEST-MARKET');
-
-        expect(orderbook.asks[0].price).toBeLessThanOrEqual(orderbook.asks[1].price);
-        expect(orderbook.asks[1].price).toBeLessThanOrEqual(orderbook.asks[2].price);
-    });
-
-    it('should handle empty orderbook', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                orderbook: {
-                    yes: [],
-                    no: []
-                }
-            }
-        });
-
-        const orderbook = await exchange.getOrderBook('TEST-MARKET');
-
-        expect(orderbook.bids).toEqual([]);
-        expect(orderbook.asks).toEqual([]);
-    });
-
-    it('should include timestamp', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                orderbook: {
-                    yes: [[5200, 100]],
-                    no: [[4800, 100]]
-                }
-            }
-        });
-
-        const orderbook = await exchange.getOrderBook('TEST-MARKET');
-
-        expect(orderbook.timestamp).toBeDefined();
-        expect(typeof orderbook.timestamp).toBe('number');
-    });
-
-    it('should handle missing yes/no fields', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                orderbook: {}
-            }
-        });
-
-        const orderbook = await exchange.getOrderBook('TEST-MARKET');
-
-        expect(orderbook.bids).toEqual([]);
-        expect(orderbook.asks).toEqual([]);
-    });
-});

package/test/exchanges/kalshi/SearchMarkets.test.ts

@@ -1,174 +0,0 @@
-import axios from 'axios';
-import { KalshiExchange } from '../../../src/exchanges/Kalshi';
-
-/**
- * Kalshi searchMarkets() Test
- * 
- * What: Tests the search functionality for finding markets by query string.
- * Why: Search is a critical user-facing feature that must work reliably.
- * How: Mocks API responses with various market data and verifies filtering logic.
- */
-
-jest.mock('axios');
-const mockedAxios = axios as jest.Mocked<typeof axios>;
-
-describe('KalshiExchange - searchMarkets', () => {
-    let exchange: KalshiExchange;
-
-    beforeEach(() => {
-        exchange = new KalshiExchange();
-        jest.clearAllMocks();
-    });
-
-    it('should filter markets by title', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                events: [
-                    {
-                        event_ticker: 'FED-2025',
-                        title: 'Federal Reserve Interest Rate Decision',
-                        markets: [{
-                            ticker: 'FED-25JAN-B4.75',
-                            expiration_time: '2025-01-29T00:00:00Z',
-                            last_price: 5200
-                        }]
-                    },
-                    {
-                        event_ticker: 'PRES-2024',
-                        title: 'Presidential Election 2024',
-                        markets: [{
-                            ticker: 'PRES-2024-TRUMP',
-                            expiration_time: '2024-11-05T00:00:00Z',
-                            last_price: 4800
-                        }]
-                    }
-                ],
-                cursor: null
-            }
-        });
-
-        const results = await exchange.searchMarkets('federal');
-
-        expect(results.length).toBeGreaterThan(0);
-        expect(results[0].title.toLowerCase()).toContain('federal');
-    });
-
-    it('should filter markets by description', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                events: [
-                    {
-                        event_ticker: 'TEST-EVENT',
-                        title: 'Test Event',
-                        sub_title: 'This is about climate change policy',
-                        markets: [{
-                            ticker: 'TEST-MARKET',
-                            subtitle: 'Climate policy details',
-                            expiration_time: '2025-12-31T00:00:00Z',
-                            last_price: 5000
-                        }]
-                    }
-                ],
-                cursor: null
-            }
-        });
-
-        const results = await exchange.searchMarkets('climate');
-
-        expect(results.length).toBeGreaterThan(0);
-    });
-
-    it('should respect limit parameter', async () => {
-        const mockEvents = Array.from({ length: 50 }, (_, i) => ({
-            event_ticker: `EVENT-${i}`,
-            title: `Test Market ${i}`,
-            markets: [{
-                ticker: `MARKET-${i}`,
-                expiration_time: '2025-12-31T00:00:00Z',
-                last_price: 5000
-            }]
-        }));
-
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                events: mockEvents,
-                cursor: null
-            }
-        });
-
-        const results = await exchange.searchMarkets('test', { limit: 5 });
-
-        expect(results.length).toBeLessThanOrEqual(5);
-    });
-
-    it('should return empty array when no matches found', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                events: [{
-                    event_ticker: 'UNRELATED',
-                    title: 'Completely Different Topic',
-                    markets: [{
-                        ticker: 'UNRELATED-MARKET',
-                        expiration_time: '2025-12-31T00:00:00Z',
-                        last_price: 5000
-                    }]
-                }],
-                cursor: null
-            }
-        });
-
-        const results = await exchange.searchMarkets('nonexistent query string');
-
-        expect(results).toEqual([]);
-    });
-
-    it('should handle search errors gracefully', async () => {
-        mockedAxios.get.mockRejectedValue(new Error('Search failed'));
-        const consoleSpy = jest.spyOn(console, 'error').mockImplementation(() => { });
-
-        const results = await exchange.searchMarkets('test');
-
-        expect(results).toEqual([]);
-        expect(consoleSpy).toHaveBeenCalled();
-        consoleSpy.mockRestore();
-    });
-
-    it('should be case-insensitive', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                events: [{
-                    event_ticker: 'TEST',
-                    title: 'FEDERAL RESERVE',
-                    markets: [{
-                        ticker: 'TEST-MARKET',
-                        expiration_time: '2025-12-31T00:00:00Z',
-                        last_price: 5000
-                    }]
-                }],
-                cursor: null
-            }
-        });
-
-        const resultsLower = await exchange.searchMarkets('federal');
-
-        jest.clearAllMocks();
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                events: [{
-                    event_ticker: 'TEST',
-                    title: 'FEDERAL RESERVE',
-                    markets: [{
-                        ticker: 'TEST-MARKET',
-                        expiration_time: '2025-12-31T00:00:00Z',
-                        last_price: 5000
-                    }]
-                }],
-                cursor: null
-            }
-        });
-
-        const resultsUpper = await exchange.searchMarkets('FEDERAL');
-
-        expect(resultsLower.length).toBe(resultsUpper.length);
-    });
-});

package/test/exchanges/kalshi/VolumeFallback.test.ts

@@ -1,44 +0,0 @@
-import axios from 'axios';
-import { KalshiExchange } from '../../../src/exchanges/Kalshi';
-
-/**
- * Kalshi Volume Fallback Test
- * 
- * What: Tests the fallback logic for volume reporting.
- * Why: Kalshi sometimes omits volume_24h for certain markets. In these cases, 
- *      we fall back to total volume to ensure we don't display 0 volume for active markets.
- * How: Mocks a market with 0 volume_24h but non-zero total volume.
- */
-
-jest.mock('axios');
-const mockedAxios = axios as jest.Mocked<typeof axios>;
-
-describe('KalshiExchange - Volume Fallback Mechanism', () => {
-    let exchange: KalshiExchange;
-
-    beforeEach(() => {
-        exchange = new KalshiExchange();
-        jest.clearAllMocks();
-    });
-
-    it('should fallback to total volume if 24h volume is missing or zero', async () => {
-        mockedAxios.get.mockResolvedValue({
-            data: {
-                events: [{
-                    event_ticker: 'KXTEST',
-                    title: 'Test Event',
-                    markets: [{
-                        ticker: 'KXTEST-001',
-                        volume: 5000,
-                        volume_24h: 0,
-                        expiration_time: "2024-12-31T00:00:00Z"
-                    }]
-                }],
-                cursor: ''
-            }
-        });
-
-        const markets = await exchange.fetchMarkets();
-        expect(markets[0].volume24h).toBe(5000);
-    });
-});