hive-stream 3.0.2 → 3.0.4

package/tests/hive-rates.spec.ts

@@ -1,443 +0,0 @@
-import { HiveRates } from '../src/hive-rates';
-import { CoinGeckoExchange } from '../src/exchanges/coingecko';
-import { Exchange } from '../src/exchanges/exchange';
-import { NetworkError, ValidationError, RatesError } from '../src/types/rates';
-
-// Mock fetch for tests
-const mockFetch = jest.fn() as jest.MockedFunction<typeof fetch>;
-global.fetch = mockFetch;
-
-class MockExchange extends Exchange {
-    public readonly exchangeId = 'mock-exchange';
-    public shouldSucceed = true;
-    public mockHiveRate = 0.5;
-    public mockHbdRate = 1.0;
-
-    constructor(config: Partial<{ cacheDuration: number; maxRetries: number; retryDelay: number }> = {}) {
-        // Use shorter timeouts for tests
-        super({
-            cacheDuration: config.cacheDuration ?? 100,
-            maxRetries: config.maxRetries ?? 1,
-            retryDelay: config.retryDelay ?? 10
-        });
-    }
-
-    public async fetchRates(): Promise<boolean> {
-        if (!this.shouldSucceed) {
-            throw new Error('Mock exchange error');
-        }
-
-        this.rateUsdHive = this.mockHiveRate;
-        this.rateUsdHbd = this.mockHbdRate;
-        return true;
-    }
-}
-
-describe('HiveRates', () => {
-    let hiveRates: HiveRates;
-    let mockExchange: MockExchange;
-
-    beforeEach(() => {
-        mockExchange = new MockExchange({ cacheDuration: 100 });
-        hiveRates = new HiveRates({ cacheDuration: 100 }, [mockExchange]);
-        mockFetch.mockClear();
-        jest.clearAllTimers();
-        jest.useFakeTimers();
-    });
-
-    afterEach(() => {
-        jest.useRealTimers();
-    });
-
-    describe('constructor', () => {
-        it('should use default CoinGecko exchange when no custom exchanges provided', () => {
-            const rates = new HiveRates();
-            expect(rates).toBeDefined();
-        });
-
-        it('should use custom exchanges when provided', () => {
-            const customExchange = new MockExchange();
-            const rates = new HiveRates({}, [customExchange]);
-            expect(rates).toBeDefined();
-        });
-
-        it('should use default config when none provided', () => {
-            const rates = new HiveRates();
-            expect(rates).toBeDefined();
-        });
-    });
-
-    describe('fetchRates', () => {
-        beforeEach(() => {
-            // Mock successful fiat API response
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: async () => ({
-                    usd: {
-                        eur: 0.85,
-                        gbp: 0.73,
-                        jpy: 110,
-                        cad: 1.25,
-                        aud: 1.35
-                    }
-                }),
-            } as Response);
-        });
-
-        it('should fetch rates successfully', async () => {
-            const result = await hiveRates.fetchRates();
-            
-            expect(result).toBe(true);
-            
-            // Check crypto rates
-            const cryptoRates = hiveRates.getCryptoRates();
-            expect(cryptoRates.hive).toBe(0.5);
-            expect(cryptoRates.hbd).toBe(1.0);
-
-            // Check some cross rates
-            expect(hiveRates.getRate('EUR', 'HIVE')).toBeCloseTo(0.5 * 0.85);
-            expect(hiveRates.getRate('GBP', 'HBD')).toBeCloseTo(1.0 * 0.73);
-        });
-
-        it('should handle crypto fetch failure gracefully', async () => {
-            mockExchange.shouldSucceed = false;
-
-            const result = await hiveRates.fetchRates();
-            
-            // Should still succeed if fiat rates succeed
-            expect(result).toBe(true);
-        }, 10000);
-
-        it('should handle fiat fetch failure gracefully', async () => {
-            mockFetch.mockRejectedValue(new Error('Fiat API error'));
-
-            // Should still succeed if crypto rates succeed
-            const result = await hiveRates.fetchRates();
-            expect(result).toBe(true);
-        });
-
-        it('should return false when both crypto and fiat fail', async () => {
-            mockExchange.shouldSucceed = false;
-            mockFetch.mockRejectedValue(new Error('All APIs failed'));
-
-            const result = await hiveRates.fetchRates();
-            expect(result).toBe(false);
-        }, 10000);
-
-        it('should calculate average rates from multiple exchanges', async () => {
-            const exchange1 = new MockExchange();
-            exchange1.mockHiveRate = 0.4;
-            exchange1.mockHbdRate = 0.9;
-            
-            const exchange2 = new MockExchange();
-            exchange2.mockHiveRate = 0.6;
-            exchange2.mockHbdRate = 1.1;
-
-            const rates = new HiveRates({ cacheDuration: 100 }, [exchange1, exchange2]);
-            
-            await rates.fetchRates();
-            
-            const cryptoRates = rates.getCryptoRates();
-            expect(cryptoRates.hive).toBe(0.5); // Average of 0.4 and 0.6
-            expect(cryptoRates.hbd).toBe(1.0);  // Average of 0.9 and 1.1
-        });
-
-        it('should ignore invalid crypto rates in average calculation', async () => {
-            const exchange1 = new MockExchange();
-            exchange1.mockHiveRate = 0.5;
-            exchange1.mockHbdRate = 1.0;
-            
-            const exchange2 = new MockExchange();
-            exchange2.mockHiveRate = 0; // Invalid
-            exchange2.mockHbdRate = -1; // Invalid
-
-            const rates = new HiveRates({ cacheDuration: 100 }, [exchange1, exchange2]);
-            
-            await rates.fetchRates();
-            
-            const cryptoRates = rates.getCryptoRates();
-            expect(cryptoRates.hive).toBe(0.5); // Only valid rate used
-            expect(cryptoRates.hbd).toBe(1.0);  // Only valid rate used
-        });
-    });
-
-    describe('rate retrieval methods', () => {
-        beforeEach(async () => {
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: async () => ({
-                    usd: {
-                        eur: 0.85,
-                        gbp: 0.73,
-                        jpy: 110
-                    }
-                }),
-            } as Response);
-
-            await hiveRates.fetchRates();
-        });
-
-        it('should get specific rate correctly', () => {
-            const rate = hiveRates.getRate('EUR', 'HIVE');
-            expect(rate).toBeCloseTo(0.5 * 0.85);
-        });
-
-        it('should return null for non-existent rate', () => {
-            const rate = hiveRates.getRate('XYZ' as any, 'HIVE');
-            expect(rate).toBeNull();
-        });
-
-        it('should get all rates', () => {
-            const allRates = hiveRates.getAllRates();
-            expect(typeof allRates).toBe('object');
-            expect(allRates['EUR_HIVE']).toBeCloseTo(0.5 * 0.85);
-            expect(allRates['GBP_HBD']).toBeCloseTo(1.0 * 0.73);
-        });
-
-        it('should get crypto rates only', () => {
-            const cryptoRates = hiveRates.getCryptoRates();
-            expect(cryptoRates.hive).toBe(0.5);
-            expect(cryptoRates.hbd).toBe(1.0);
-        });
-
-        it('should get fiat rates only', () => {
-            const fiatRates = hiveRates.getFiatRates();
-            expect(fiatRates.EUR).toBe(0.85);
-            expect(fiatRates.GBP).toBe(0.73);
-            expect(fiatRates.JPY).toBe(110);
-        });
-
-        it('should support legacy method', () => {
-            const rate = hiveRates.fiatToHiveRate('EUR', 'HIVE');
-            expect(rate).toBeCloseTo(0.5 * 0.85);
-        });
-    });
-
-    describe('caching behavior', () => {
-        beforeEach(() => {
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: async () => ({
-                    usd: { eur: 0.85 }
-                }),
-            } as Response);
-        });
-
-        it('should respect cache duration', async () => {
-            // First fetch
-            await hiveRates.fetchRates();
-            
-            // Second fetch within cache duration should not call API
-            mockFetch.mockClear();
-            await hiveRates.fetchRates();
-            
-            expect(mockFetch).not.toHaveBeenCalled();
-        });
-
-        it('should fetch when cache expires', async () => {
-            // First fetch
-            await hiveRates.fetchRates();
-            
-            // Advance time beyond cache duration
-            jest.advanceTimersByTime(150);
-            
-            // Second fetch should call API
-            mockFetch.mockClear();
-            await hiveRates.fetchRates();
-            
-            expect(mockFetch).toHaveBeenCalled();
-        });
-
-        it('should track last fetch times', async () => {
-            const timesBefore = hiveRates.getLastFetchTimes();
-            expect(timesBefore.crypto).toBeUndefined();
-            expect(timesBefore.fiat).toBeUndefined();
-
-            await hiveRates.fetchRates();
-
-            const timesAfter = hiveRates.getLastFetchTimes();
-            expect(timesAfter.crypto).toBeDefined();
-            expect(timesAfter.fiat).toBeDefined();
-        });
-
-        it('should report cache validity', async () => {
-            const validityBefore = hiveRates.isCacheValid();
-            expect(validityBefore.crypto).toBe(false);
-            expect(validityBefore.fiat).toBe(false);
-
-            await hiveRates.fetchRates();
-
-            const validityAfter = hiveRates.isCacheValid();
-            expect(validityAfter.crypto).toBe(true);
-            expect(validityAfter.fiat).toBe(true);
-
-            jest.advanceTimersByTime(150);
-
-            const validityExpired = hiveRates.isCacheValid();
-            expect(validityExpired.crypto).toBe(false);
-            expect(validityExpired.fiat).toBe(false);
-        });
-    });
-
-    describe('fiat API handling', () => {
-        it('should try multiple fiat endpoints', async () => {
-            // First endpoint fails, second succeeds
-            mockFetch
-                .mockRejectedValueOnce(new Error('First endpoint failed'))
-                .mockResolvedValueOnce({
-                    ok: true,
-                    json: async () => ({
-                        usd: { eur: 0.85 }
-                    }),
-                } as Response);
-
-            const result = await hiveRates.fetchRates();
-            expect(result).toBe(true);
-            expect(mockFetch).toHaveBeenCalledTimes(2);
-        });
-
-        it('should handle all fiat endpoints failing', async () => {
-            mockFetch.mockRejectedValue(new Error('All endpoints failed'));
-
-            // This should still succeed because crypto fetch succeeds
-            const result = await hiveRates.fetchRates();
-            expect(result).toBe(true);
-        });
-
-        it('should validate fiat response format', async () => {
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: async () => ({ invalid: 'format' }),
-            } as Response);
-
-            // Should still succeed because crypto fetch succeeds, fiat just fails silently
-            const result = await hiveRates.fetchRates();
-            expect(result).toBe(true);
-        });
-
-        it('should filter invalid fiat rates', async () => {
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: async () => ({
-                    usd: {
-                        eur: 0.85,
-                        invalid: 'string',
-                        nan: NaN,
-                        negative: -1,
-                        zero: 0
-                    }
-                }),
-            } as Response);
-
-            await hiveRates.fetchRates();
-            
-            const fiatRates = hiveRates.getFiatRates();
-            expect(fiatRates.EUR).toBe(0.85);
-            expect(fiatRates.INVALID).toBeUndefined();
-            expect(fiatRates.NAN).toBeUndefined();
-            expect(fiatRates.NEGATIVE).toBeUndefined();
-            expect(fiatRates.ZERO).toBeUndefined();
-        });
-
-        it('should convert currency codes to uppercase', async () => {
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: async () => ({
-                    usd: {
-                        eur: 0.85,
-                        gbp: 0.73
-                    }
-                }),
-            } as Response);
-
-            await hiveRates.fetchRates();
-            
-            const fiatRates = hiveRates.getFiatRates();
-            expect(fiatRates.EUR).toBe(0.85);
-            expect(fiatRates.GBP).toBe(0.73);
-        });
-    });
-
-    describe('error handling', () => {
-        it('should throw RatesError for unexpected errors', async () => {
-            // Mock an unexpected error in fetchCryptoRates
-            const originalMethod = hiveRates['fetchCryptoRates'];
-            hiveRates['fetchCryptoRates'] = jest.fn().mockImplementation(() => {
-                throw new TypeError('Unexpected error');
-            });
-
-            await expect(hiveRates.fetchRates()).rejects.toThrow(RatesError);
-            await expect(hiveRates.fetchRates()).rejects.toThrow('Unexpected error');
-
-            // Restore original method
-            hiveRates['fetchCryptoRates'] = originalMethod;
-        });
-
-        it('should preserve known error types', async () => {
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: async () => ({ invalid: 'format' }),
-            } as Response);
-
-            // Should still succeed because crypto fetch succeeds, fiat just fails silently  
-            const result = await hiveRates.fetchRates();
-            expect(result).toBe(true);
-        });
-    });
-
-    describe('edge cases', () => {
-        it('should handle empty fiat rates response', async () => {
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: async () => ({
-                    usd: {}
-                }),
-            } as Response);
-
-            // Should still succeed because crypto fetch succeeds, fiat just fails silently
-            const result = await hiveRates.fetchRates();
-            expect(result).toBe(true);
-        });
-
-        it('should handle no valid crypto rates', async () => {
-            mockExchange.mockHiveRate = 0;
-            mockExchange.mockHbdRate = 0;
-            
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: async () => ({
-                    usd: { eur: 0.85 }
-                }),
-            } as Response);
-
-            const result = await hiveRates.fetchRates();
-            expect(result).toBe(true);
-            
-            const cryptoRates = hiveRates.getCryptoRates();
-            expect(cryptoRates.hive).toBeUndefined();
-            expect(cryptoRates.hbd).toBeUndefined();
-        });
-
-        it('should handle partial crypto rates', async () => {
-            mockExchange.mockHiveRate = 0.5;
-            mockExchange.mockHbdRate = 0; // Invalid
-            
-            mockFetch.mockResolvedValue({
-                ok: true,
-                json: async () => ({
-                    usd: { eur: 0.85 }
-                }),
-            } as Response);
-
-            await hiveRates.fetchRates();
-            
-            const cryptoRates = hiveRates.getCryptoRates();
-            expect(cryptoRates.hive).toBe(0.5);
-            expect(cryptoRates.hbd).toBeUndefined();
-            
-            // Should still calculate HIVE rates but not HBD rates
-            expect(hiveRates.getRate('EUR', 'HIVE')).toBeCloseTo(0.5 * 0.85);
-            expect(hiveRates.getRate('EUR', 'HBD')).toBeNull();
-        });
-    });
-});

package/tests/integration/hive-rates.integration.spec.ts

@@ -1,35 +0,0 @@
-import { HiveRates } from '../../src/hive-rates';
-
-const shouldRunIntegration = process.env.RUN_INTEGRATION === 'true';
-
-describe('HiveRates Integration Test', () => {
-    (shouldRunIntegration ? it : it.skip)('should fetch real rates successfully', async () => {
-        const hiveRates = new HiveRates();
-        
-        const result = await hiveRates.fetchRates();
-        expect(result).toBe(true);
-        
-        // Check that we have some crypto rates
-        const cryptoRates = hiveRates.getCryptoRates();
-        expect(cryptoRates.hive).toBeGreaterThan(0);
-        expect(cryptoRates.hbd).toBeGreaterThan(0);
-        
-        // Check that we have some fiat rates
-        const fiatRates = hiveRates.getFiatRates();
-        expect(Object.keys(fiatRates).length).toBeGreaterThan(0);
-        expect(fiatRates.EUR).toBeGreaterThan(0);
-        
-        // Check that cross rates are calculated
-        const eurHiveRate = hiveRates.getRate('EUR', 'HIVE');
-        expect(eurHiveRate).toBeGreaterThan(0);
-        
-        const gbpHbdRate = hiveRates.getRate('GBP', 'HBD');
-        expect(gbpHbdRate).toBeGreaterThan(0);
-        
-        console.log('Sample rates:');
-        console.log(`HIVE: $${cryptoRates.hive?.toFixed(6)}`);
-        console.log(`HBD: $${cryptoRates.hbd?.toFixed(6)}`);
-        console.log(`EUR/HIVE: ${eurHiveRate?.toFixed(6)}`);
-        console.log(`GBP/HBD: ${gbpHbdRate?.toFixed(6)}`);
-    }, 30000); // 30 second timeout for real API calls
-});

package/tests/metadata.spec.ts

@@ -1,63 +0,0 @@
-import { TimeAction } from '../src/actions';
-import { Config } from '../src/config';
-import { HIVE_STREAM_METADATA, getHiveStreamMetadata } from '../src/metadata';
-
-describe('metadata exports', () => {
-    test('returns a stable frozen metadata object', () => {
-        const meta = getHiveStreamMetadata();
-
-        expect(meta).toBe(HIVE_STREAM_METADATA);
-        expect(Object.isFrozen(meta)).toBe(true);
-        expect(Object.isFrozen(meta.config)).toBe(true);
-        expect(Object.isFrozen(meta.subscriptions)).toBe(true);
-        expect(Object.isFrozen(meta.writeOperations)).toBe(true);
-    });
-
-    test('includes config defaults aligned with Config source', () => {
-        const map = new Map(HIVE_STREAM_METADATA.config.options.map((option) => [option.key, option.defaultValue]));
-        const builderMap = new Map(HIVE_STREAM_METADATA.config.options.map((option) => [option.key, option.builderKey]));
-
-        expect(map.get('JSON_ID')).toBe(Config.JSON_ID);
-        expect(map.get('PAYLOAD_IDENTIFIER')).toBe(Config.PAYLOAD_IDENTIFIER);
-        expect(map.get('HIVE_ENGINE_ID')).toBe(Config.HIVE_ENGINE_ID);
-        expect(map.get('BLOCK_CHECK_INTERVAL')).toBe(Config.BLOCK_CHECK_INTERVAL);
-        expect(builderMap.get('JSON_ID')).toBe('jsonId');
-        expect(builderMap.get('PAYLOAD_IDENTIFIER')).toBe('payloadIdentifier');
-        expect(builderMap.get('BLOCK_CHECK_INTERVAL')).toBe('blockCheckInterval');
-    });
-
-    test('includes expected subscription metadata', () => {
-        const transfer = HIVE_STREAM_METADATA.subscriptions.find((item) => item.method === 'onTransfer');
-        const customJsonId = HIVE_STREAM_METADATA.subscriptions.find((item) => item.method === 'onCustomJsonId');
-
-        expect(transfer).toBeDefined();
-        expect(transfer?.accountFilterBuiltIn).toBe(true);
-
-        expect(customJsonId).toBeDefined();
-        expect(customJsonId?.idFilterBuiltIn).toBe(true);
-    });
-
-    test('exposes valid time action values from TimeAction source', () => {
-        expect(HIVE_STREAM_METADATA.timeAction.validValues).toEqual(TimeAction.getValidTimeValues());
-    });
-
-    test('lists contract triggers and supported operations', () => {
-        expect(HIVE_STREAM_METADATA.contracts.payload.supportedTriggers).toEqual([
-            'custom_json',
-            'transfer',
-            'time',
-            'escrow_transfer',
-            'escrow_approve',
-            'escrow_dispute',
-            'escrow_release',
-            'recurrent_transfer'
-        ]);
-
-        expect(HIVE_STREAM_METADATA.contracts.payload.supportedOperations).toEqual([
-            'transfer',
-            'custom_json',
-            'escrow_transfer',
-            'recurrent_transfer'
-        ]);
-    });
-});

package/tests/setup.ts

@@ -1,30 +0,0 @@
-import { GlobalWithFetchMock } from 'jest-fetch-mock';
-
-// (global as any).console = {
-//     log: jest.fn(), // console.log are ignored in tests
-
-//     // Keep native behaviour for other methods, use those to print out things in your own tests, not `console.log`
-//     error: console.error,
-//     warn: console.warn,
-//     info: console.info,
-//     debug: console.debug,
-// };
-
-const fetchMock = require('jest-fetch-mock');
-const customGlobal: GlobalWithFetchMock = global as unknown as GlobalWithFetchMock;
-
-// Safely assign fetch mock
-if (!customGlobal.fetch) {
-    customGlobal.fetch = fetchMock;
-} else {
-    Object.defineProperty(customGlobal, 'fetch', {
-        value: fetchMock,
-        writable: true,
-        configurable: true
-    });
-}
-customGlobal.fetchMock = customGlobal.fetch;
-
-process.on('unhandledRejection', (error) => {
-  throw error; // Or whatever you like...
-});