hive-stream 3.0.2 → 3.0.4

package/tests/contracts/token.contract.spec.ts

@@ -1,90 +0,0 @@
-import { createTokenContract } from '../../src/contracts/token.contract';
-import { Streamer } from '../../src/streamer';
-import { createMockAdapter } from '../helpers/mock-adapter';
-
-const createContext = (streamer: Streamer, adapter: any, sender: string) => ({
-    trigger: 'custom_json' as const,
-    streamer,
-    adapter,
-    config: streamer['config'],
-    block: { number: 123, id: 'block123', previousId: 'prevblock123', time: new Date() },
-    transaction: { id: 'txn123' },
-    sender,
-    customJson: { id: 'hivestream', json: {}, isSignedWithActiveKey: true }
-});
-
-describe('TokenContract', () => {
-    let streamer: Streamer;
-    let adapter: any;
-    let contract: ReturnType<typeof createTokenContract>;
-
-    beforeEach(async () => {
-        streamer = new Streamer();
-        adapter = createMockAdapter();
-        await streamer.registerAdapter(adapter);
-        contract = createTokenContract();
-        await streamer.registerContract(contract);
-    });
-
-    afterEach(async () => {
-        await streamer.stop();
-    });
-
-    test('Creates a token', async () => {
-        const ctx = createContext(streamer, adapter, 'alice');
-        const payload = {
-            symbol: 'TEST',
-            name: 'Test Token',
-            url: 'https://example.com',
-            precision: 3,
-            maxSupply: '1000000'
-        };
-
-        await contract.actions.createToken.handler(payload, ctx);
-
-        expect(adapter.queries.join(' ')).toContain('INSERT INTO tokens');
-        expect(adapter.events.length).toBeGreaterThan(0);
-        expect(adapter.events[0].action).toBe('createToken');
-    });
-
-    test('Rejects duplicate token symbols', async () => {
-        adapter.setTestContext({ existingToken: 'TEST' });
-        const ctx = createContext(streamer, adapter, 'alice');
-        const payload = {
-            symbol: 'TEST',
-            name: 'Test Token',
-            maxSupply: '1000000'
-        };
-
-        await expect(contract.actions.createToken.handler(payload, ctx))
-            .rejects
-            .toThrow('Token with symbol TEST already exists');
-    });
-
-    test('Prevents non-creators from issuing tokens', async () => {
-        const ctx = createContext(streamer, adapter, 'bob');
-        const payload = {
-            symbol: 'TEST',
-            to: 'carol',
-            amount: '100'
-        };
-
-        await expect(contract.actions.issueTokens.handler(payload, ctx))
-            .rejects
-            .toThrow('Only the token creator can issue new tokens');
-    });
-
-    test('Prevents transfers with insufficient balance', async () => {
-        adapter.setTestContext({ insufficientBalance: true });
-        const ctx = createContext(streamer, adapter, 'alice');
-        const payload = {
-            symbol: 'TEST',
-            to: 'bob',
-            amount: '9999'
-        };
-
-        await expect(contract.actions.transferTokens.handler(payload, ctx))
-            .rejects
-            .toThrow('Insufficient balance');
-    });
-});

package/tests/exchanges/coingecko.exchange.spec.ts

@@ -1,169 +0,0 @@
-import { CoinGeckoExchange } from '../../src/exchanges/coingecko';
-import { NetworkError, ValidationError } from '../../src/types/rates';
-import { mockSuccessfulApis, mockNetworkErrors, mockHttpErrors, mockInvalidResponses, cleanupMocks } from '../helpers/mock-fetch';
-
-describe('CoinGeckoExchange', () => {
-    let exchange: CoinGeckoExchange;
-
-    beforeEach(() => {
-        exchange = new CoinGeckoExchange();
-    });
-
-    afterEach(() => {
-        cleanupMocks();
-    });
-
-    describe('fetchRates', () => {
-        it('should fetch rates successfully', async () => {
-            mockSuccessfulApis();
-
-            const success = await exchange.fetchRates();
-
-            expect(success).toBe(true);
-            expect(exchange.rateUsdHive).toBe(0.25);
-            expect(exchange.rateUsdHbd).toBe(1.00);
-        });
-
-        it('should handle network errors', async () => {
-            mockNetworkErrors();
-
-            await expect(exchange.fetchRates()).rejects.toThrow(NetworkError);
-        });
-
-        it('should handle HTTP errors', async () => {
-            mockHttpErrors(500);
-
-            await expect(exchange.fetchRates()).rejects.toThrow(NetworkError);
-        });
-
-        it('should handle invalid JSON responses', async () => {
-            mockInvalidResponses();
-
-            await expect(exchange.fetchRates()).rejects.toThrow(ValidationError);
-        });
-
-        it('should retry on failure', async () => {
-            const retryExchange = new CoinGeckoExchange({ maxRetries: 3, retryDelay: 100 });
-            
-            // Mock first two calls to fail, third to succeed
-            let callCount = 0;
-            global.fetch = jest.fn().mockImplementation(() => {
-                callCount++;
-                if (callCount <= 2) {
-                    return Promise.reject(new Error('Network error'));
-                }
-                return Promise.resolve({
-                    ok: true,
-                    json: () => Promise.resolve({
-                        hive: { usd: 0.25 },
-                        'hive_dollar': { usd: 1.00 }
-                    })
-                });
-            });
-
-            const success = await retryExchange.updateRates();
-            
-            expect(success).toBe(true);
-            expect(retryExchange.rateUsdHive).toBe(0.25);
-            expect(callCount).toBe(3);
-        }, 10000); // Increase timeout for retry test
-
-        it('should respect timeout', async () => {
-            const timeoutExchange = new CoinGeckoExchange({ timeout: 100 });
-            
-            // Mock a delayed response
-            global.fetch = jest.fn().mockImplementation(() => 
-                new Promise((resolve) => {
-                    setTimeout(() => resolve({
-                        ok: true,
-                        json: () => Promise.resolve({ hive: { usd: 0.25 } })
-                    }), 200); // Longer than timeout
-                })
-            );
-
-            await expect(timeoutExchange.fetchRates()).rejects.toThrow();
-        });
-
-        it('should validate rate values', async () => {
-            // Mock response with invalid rates
-            global.fetch = jest.fn().mockResolvedValue({
-                ok: true,
-                json: () => Promise.resolve({
-                    hive: { usd: -1 }, // Invalid negative rate
-                    'hive_dollar': { usd: 1.00 }
-                })
-            });
-
-            await expect(exchange.fetchRates()).rejects.toThrow(ValidationError);
-        });
-
-        it('should handle missing rate data', async () => {
-            // Mock response with missing hive data
-            global.fetch = jest.fn().mockResolvedValue({
-                ok: true,
-                json: () => Promise.resolve({
-                    'hive_dollar': { usd: 1.00 }
-                    // Missing hive data
-                })
-            });
-
-            await expect(exchange.fetchRates()).rejects.toThrow(ValidationError);
-        });
-    });
-
-    describe('caching', () => {
-        it('should use cached rates when valid', async () => {
-            mockSuccessfulApis();
-
-            // First fetch
-            const rates1 = await exchange.updateRates();
-            
-            // Second fetch should use cache
-            const rates2 = await exchange.updateRates();
-
-            expect(rates1).toBe(true);
-            expect(rates2).toBe(false);
-            expect(global.fetch).toHaveBeenCalledTimes(1);
-        });
-
-        it('should refresh cache when expired', async () => {
-            const shortCacheExchange = new CoinGeckoExchange({ cacheDuration: 100 });
-            mockSuccessfulApis();
-
-            // First fetch
-            await shortCacheExchange.updateRates();
-
-            // Wait for cache to expire
-            await new Promise(resolve => setTimeout(resolve, 150));
-
-            // Second fetch should hit API again
-            await shortCacheExchange.updateRates();
-
-            expect(global.fetch).toHaveBeenCalledTimes(2);
-        });
-
-        it('should report cache validity correctly', async () => {
-            mockSuccessfulApis();
-
-            expect(exchange.isCacheValid()).toBe(false);
-
-            await exchange.updateRates();
-            
-            expect(exchange.isCacheValid()).toBe(true);
-        });
-
-        it('should report last fetch time', async () => {
-            mockSuccessfulApis();
-
-            expect(exchange.getLastFetchTime()).toBeUndefined();
-
-            const beforeFetch = Date.now();
-            await exchange.updateRates();
-            const afterFetch = Date.now();
-
-            const lastFetchTime = exchange.getLastFetchTime();
-            expect(lastFetchTime).toBeGreaterThanOrEqual(beforeFetch);
-            expect(lastFetchTime).toBeLessThanOrEqual(afterFetch);
-        });
-    });
-});

package/tests/exchanges/exchange.base.spec.ts

@@ -1,246 +0,0 @@
-import { Exchange } from '../../src/exchanges/exchange';
-import { NetworkError, RateConfig } from '../../src/types/rates';
-
-// Mock fetch for tests
-const mockFetch = jest.fn() as jest.MockedFunction<typeof fetch>;
-global.fetch = mockFetch;
-
-class TestExchange extends Exchange {
-    public readonly exchangeId = 'test-exchange';
-    public shouldSucceed = true;
-    public fetchCallCount = 0;
-
-    public async fetchRates(): Promise<boolean> {
-        this.fetchCallCount++;
-        
-        if (!this.shouldSucceed) {
-            throw new Error('Test error');
-        }
-
-        this.rateUsdHive = 0.5;
-        this.rateUsdHbd = 1.0;
-        return true;
-    }
-}
-
-describe('Exchange', () => {
-    let exchange: TestExchange;
-
-    beforeEach(() => {
-        exchange = new TestExchange({ cacheDuration: 100, maxRetries: 2, retryDelay: 10 });
-        mockFetch.mockClear();
-        jest.clearAllTimers();
-        jest.useFakeTimers();
-    });
-
-    afterEach(() => {
-        jest.useRealTimers();
-    });
-
-    describe('constructor', () => {
-        it('should use default config when none provided', () => {
-            const exchange = new TestExchange();
-            expect(exchange.isCacheValid()).toBe(false);
-        });
-
-        it('should accept custom config', () => {
-            const config: RateConfig = {
-                cacheDuration: 5000,
-                maxRetries: 5,
-                retryDelay: 2000,
-                timeout: 15000
-            };
-            
-            const exchange = new TestExchange(config);
-            expect(exchange).toBeDefined();
-        });
-    });
-
-    describe('updateRates', () => {
-        it('should fetch rates successfully', async () => {
-            const result = await exchange.updateRates();
-            
-            expect(result).toBe(true);
-            expect(exchange.fetchCallCount).toBe(1);
-            expect(exchange.rateUsdHive).toBe(0.5);
-            expect(exchange.rateUsdHbd).toBe(1.0);
-        });
-
-        it('should return false when cache is valid', async () => {
-            // First fetch
-            await exchange.updateRates();
-            expect(exchange.fetchCallCount).toBe(1);
-
-            // Second fetch should use cache
-            const result = await exchange.updateRates();
-            expect(result).toBe(false);
-            expect(exchange.fetchCallCount).toBe(1);
-        });
-
-        it('should update when cache expires', async () => {
-            // First fetch
-            await exchange.updateRates();
-            expect(exchange.fetchCallCount).toBe(1);
-
-            // Advance time beyond cache duration
-            jest.advanceTimersByTime(150);
-
-            // Second fetch should happen
-            const result = await exchange.updateRates();
-            expect(result).toBe(true);
-            expect(exchange.fetchCallCount).toBe(2);
-        });
-
-        it('should retry on failure', async () => {
-            let callCount = 0;
-            exchange.fetchRates = jest.fn().mockImplementation(() => {
-                callCount++;
-                if (callCount === 1) {
-                    throw new Error('Test error');
-                }
-                exchange.rateUsdHive = 0.5;
-                exchange.rateUsdHbd = 1.0;
-                return Promise.resolve(true);
-            });
-
-            const resultPromise = exchange.updateRates();
-            await jest.runAllTimersAsync();
-            const result = await resultPromise;
-            expect(result).toBe(true);
-            expect(exchange.fetchRates).toHaveBeenCalledTimes(2);
-        }, 10000);
-
-        it('should throw NetworkError after max retries', async () => {
-            exchange.shouldSucceed = false;
-
-            const resultPromise = exchange.updateRates();
-            const expectation = expect(resultPromise).rejects.toThrow(NetworkError);
-            const messageExpectation = expect(resultPromise).rejects.toThrow('Failed to fetch rates after 2 attempts');
-            await jest.runAllTimersAsync();
-            await expectation;
-            await messageExpectation;
-            expect(exchange.fetchCallCount).toBe(2);
-        }, 10000);
-    });
-
-    describe('fetchWithTimeout', () => {
-        beforeEach(() => {
-            // Reset to use real fetch for this test
-            (global.fetch as any) = mockFetch;
-        });
-
-        it('should fetch successfully within timeout', async () => {
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-                json: async () => ({ test: 'data' }),
-            } as Response);
-
-            const response = await exchange['fetchWithTimeout']('https://example.com');
-            expect(response.ok).toBe(true);
-        });
-
-        it('should throw NetworkError for HTTP errors', async () => {
-            mockFetch.mockResolvedValueOnce({
-                ok: false,
-                status: 404,
-                statusText: 'Not Found',
-            } as Response);
-
-            await expect(exchange['fetchWithTimeout']('https://example.com'))
-                .rejects.toThrow(NetworkError);
-        });
-
-        it('should include proper headers', async () => {
-            mockFetch.mockResolvedValueOnce({
-                ok: true,
-            } as Response);
-
-            await exchange['fetchWithTimeout']('https://example.com');
-
-            expect(mockFetch).toHaveBeenCalledWith(
-                'https://example.com',
-                expect.objectContaining({
-                    headers: {
-                        'User-Agent': 'hive-stream/3.0.0',
-                        'Accept': 'application/json',
-                    },
-                })
-            );
-        });
-
-        it('should handle timeout', async () => {
-            const exchange = new TestExchange({ timeout: 50 });
-            
-            // Mock fetch to never resolve (timeout scenario)
-            mockFetch.mockImplementationOnce((_, options) => 
-                new Promise((_, reject) => {
-                    const signal = options?.signal as AbortSignal | undefined;
-                    if (signal) {
-                        signal.addEventListener('abort', () => {
-                            reject(new Error('Aborted'));
-                        });
-                    }
-                })
-            );
-
-            const timeoutPromise = exchange['fetchWithTimeout']('https://example.com');
-            const timeoutExpectation = expect(timeoutPromise).rejects.toThrow();
-            await jest.advanceTimersByTimeAsync(60);
-            await timeoutExpectation;
-        }, 1000);
-    });
-
-    describe('utility methods', () => {
-        it('should track last fetch time correctly', async () => {
-            expect(exchange.getLastFetchTime()).toBeUndefined();
-
-            await exchange.updateRates();
-            
-            const fetchTime = exchange.getLastFetchTime();
-            expect(fetchTime).toBeDefined();
-            expect(typeof fetchTime).toBe('number');
-        });
-
-        it('should report cache validity correctly', async () => {
-            expect(exchange.isCacheValid()).toBe(false);
-
-            await exchange.updateRates();
-            expect(exchange.isCacheValid()).toBe(true);
-
-            jest.advanceTimersByTime(150);
-            expect(exchange.isCacheValid()).toBe(false);
-        });
-
-        it('should handle cache check with no previous fetch', () => {
-            expect(exchange.isCacheValid()).toBe(false);
-        });
-    });
-
-    describe('error handling', () => {
-        it('should preserve original error types in retries', async () => {
-            let callCount = 0;
-            exchange.fetchRates = jest.fn().mockImplementation(() => {
-                callCount++;
-                if (callCount === 1) {
-                    throw new NetworkError('First failure', 'test');
-                }
-                return Promise.resolve(true);
-            });
-
-            const resultPromise = exchange.updateRates();
-            await jest.runAllTimersAsync();
-            const result = await resultPromise;
-            expect(result).toBe(true);
-            expect(exchange.fetchRates).toHaveBeenCalledTimes(2);
-        }, 10000);
-
-        it('should handle non-Error rejections', async () => {
-            exchange.fetchRates = jest.fn().mockRejectedValue('string error');
-
-            const resultPromise = exchange.updateRates();
-            const expectation = expect(resultPromise).rejects.toThrow(NetworkError);
-            await jest.runAllTimersAsync();
-            await expectation;
-        }, 10000);
-    });
-});