hive-stream 3.0.0 → 3.0.2

package/tests/streamer.spec.ts

@@ -1,5 +1,6 @@
 import { TimeAction } from '../src/actions';
 import { Streamer } from '../src/streamer';
+import { action as contractAction, defineContract } from '../src/contracts/contract';
 import { createMockAdapter } from './helpers/mock-adapter';
 
 describe('Streamer', () => {
@@ -40,17 +41,20 @@ describe('Streamer', () => {
 
             await sut.registerAdapter(adapter);
 
-            expect(adapter.create).toBeCalled();
+            expect(adapter.create).toHaveBeenCalled();
         });
     });
 
     describe('Actions', () => {
         test('Registers a new action', async () => {
-            const mockContract = {
-                testmethod: jest.fn()
-            };
+            const mockContract = defineContract({
+                name: 'testcontract',
+                actions: {
+                    testmethod: contractAction(jest.fn(), { trigger: 'time' })
+                }
+            });
             
-            sut.registerContract('testcontract', mockContract);
+            await sut.registerContract(mockContract);
             
             const adapter = {
                 create: jest.fn().mockResolvedValue(true),
@@ -70,7 +74,7 @@ describe('Streamer', () => {
                 db: null
             } as any;
 
-            sut.registerAdapter(adapter);
+            await sut.registerAdapter(adapter);
 
             const action = new TimeAction('1m', 'testoneminute', 'testcontract', 'testmethod');
 
@@ -82,11 +86,14 @@ describe('Streamer', () => {
         });
 
         test('Does not allow duplicate actions of the same id', async () => {
-            const mockContract = {
-                testmethod: jest.fn()
-            };
+            const mockContract = defineContract({
+                name: 'testcontract',
+                actions: {
+                    testmethod: contractAction(jest.fn(), { trigger: 'time' })
+                }
+            });
             
-            sut.registerContract('testcontract', mockContract);
+            await sut.registerContract(mockContract);
             
             const adapter = {
                 create: jest.fn().mockResolvedValue(true),
@@ -106,7 +113,7 @@ describe('Streamer', () => {
                 db: null
             } as any;
 
-            sut.registerAdapter(adapter);
+            await sut.registerAdapter(adapter);
 
             const action = new TimeAction('1m', 'testoneminute', 'testcontract', 'testmethod');
             const action2 = new TimeAction('1m', 'testoneminute', 'testcontract', 'testmethod');
@@ -118,11 +125,14 @@ describe('Streamer', () => {
         });
 
         test('Registers actions loaded from adapter loadActions call', async () => {
-            const mockContract = {
-                testmethod: jest.fn()
-            };
+            const mockContract = defineContract({
+                name: 'testcontract',
+                actions: {
+                    testmethod: contractAction(jest.fn(), { trigger: 'time' })
+                }
+            });
             
-            sut.registerContract('testcontract', mockContract);
+            await sut.registerContract(mockContract);
             
             const adapter = {
                 create: jest.fn().mockResolvedValue(true),
@@ -131,7 +141,7 @@ describe('Streamer', () => {
                     timeValue: '1m',
                     id: 'testoneminute',
                     contractName: 'testcontract',
-                    contractMethod: 'testmethod',
+                    contractAction: 'testmethod',
                     payload: {},
                     date: new Date().toISOString(),
                     enabled: true,
@@ -164,51 +174,67 @@ describe('Streamer', () => {
     });
 
     describe('Contracts', () => {
-        test('Should register a new contract', () => {
-            const contract = {
-                myMethod: jest.fn()
-            };
+        test('Should register a new contract', async () => {
+            const contract = defineContract({
+                name: 'testcontract',
+                actions: {
+                    myMethod: contractAction(jest.fn())
+                }
+            });
 
-            sut.registerContract('testcontract', contract);
+            await sut.registerContract(contract);
 
-            expect(contract['_instance']).toBeInstanceOf(Streamer);
             expect(sut['contracts'].length).toStrictEqual(1);
         });
 
-        test('Should register a new contract and call its create method', () => {
-            const contract = {
-                create: jest.fn(),
-                myMethod: jest.fn()
-            };
-
-            sut.registerContract('testcontract', contract);
-
-            expect(contract.create).toBeCalled();
-            expect(contract['_instance']).toBeInstanceOf(Streamer);
+        test('Should register a new contract and call its create hook', async () => {
+            const createHook = jest.fn();
+            const contract = defineContract({
+                name: 'testcontract',
+                hooks: {
+                    create: createHook
+                },
+                actions: {
+                    myMethod: contractAction(jest.fn())
+                }
+            });
+
+            await sut.registerContract(contract);
+
+            expect(createHook).toHaveBeenCalled();
             expect(sut['contracts'].length).toStrictEqual(1);
         });
 
-        test('Should unregister a registered contract', () => {
-            const contract = {
-                myMethod: jest.fn()
-            };
+        test('Should unregister a registered contract', async () => {
+            const contract = defineContract({
+                name: 'testcontract',
+                actions: {
+                    myMethod: contractAction(jest.fn())
+                }
+            });
 
-            sut.registerContract('testcontract', contract);
-            sut.unregisterContract('testcontract');
+            await sut.registerContract(contract);
+            await sut.unregisterContract('testcontract');
 
             expect(sut['contracts'].length).toStrictEqual(0);
         });
 
-        test('Should unregister a registered contract and call its destroy method', () => {
-            const contract = {
-                destroy: jest.fn(),
-                myMethod: jest.fn()
-            };
-
-            sut.registerContract('testcontract', contract);
-            sut.unregisterContract('testcontract');
-
-            expect(contract.destroy).toBeCalled();
+        test('Should unregister a registered contract and call its destroy hook', async () => {
+            const destroyHook = jest.fn();
+            const contract = defineContract({
+                name: 'testcontract',
+                hooks: {
+                    destroy: destroyHook
+                },
+                actions: {
+                    myMethod: contractAction(jest.fn())
+                }
+            });
+
+            await sut.registerContract(contract);
+            await sut.unregisterContract('testcontract');
+
+            expect(destroyHook).toHaveBeenCalled();
             expect(sut['contracts'].length).toStrictEqual(0);
         });
     });
@@ -246,4 +272,71 @@ describe('Streamer', () => {
 
         sut.stop();
     });
-});
+
+    test('Start method should respect RESUME_FROM_STATE false', async () => {
+        sut.setConfig({ LAST_BLOCK_NUMBER: 123, RESUME_FROM_STATE: false });
+        
+        const adapter = {
+            create: jest.fn().mockResolvedValue(true),
+            destroy: jest.fn(),
+            loadActions: jest.fn().mockResolvedValue([]),
+            loadState: jest.fn().mockResolvedValue({ lastBlockNumber: 999 }),
+            saveState: jest.fn().mockResolvedValue(true),
+            processBlock: jest.fn(),
+            processOperation: jest.fn(),
+            processTransfer: jest.fn(),
+            processCustomJson: jest.fn(),
+            find: jest.fn(),
+            findOne: jest.fn(),
+            insert: jest.fn(),
+            replace: jest.fn(),
+            client: null,
+            db: null
+        } as any;
+
+        await sut.registerAdapter(adapter);
+
+        jest.spyOn(sut as any, 'getBlock').mockImplementation(() => true);
+        jest.spyOn(sut as any, 'getLatestBlock').mockImplementation(() => true);
+
+        await sut.start();
+
+        expect(sut['lastBlockNumber']).toStrictEqual(123);
+
+        sut.stop();
+    });
+
+    test('getBlock should process multiple blocks per batch when behind', async () => {
+        const adapter = createMockAdapter();
+        await sut.registerAdapter(adapter);
+
+        sut.setConfig({ CATCH_UP_BATCH_SIZE: 3, BLOCK_CHECK_INTERVAL: 1, DEBUG_MODE: false });
+        sut['lastBlockNumber'] = 10;
+
+        const mockBlock = {
+            block_id: 'block-id',
+            previous: 'prev-id',
+            transaction_ids: ['trx-1'],
+            timestamp: '2023-01-01T00:00:00',
+            transactions: []
+        };
+
+        sut['client'] = {
+            database: {
+                getDynamicGlobalProperties: jest.fn().mockResolvedValue({
+                    head_block_number: 20,
+                    time: '2023-01-01T00:00:00'
+                }),
+                getBlock: jest.fn().mockResolvedValue(mockBlock)
+            }
+        } as any;
+
+        const loadBlockSpy = jest.spyOn(sut as any, 'loadBlock');
+
+        await (sut as any).getBlock();
+        clearTimeout(sut['blockNumberTimeout']);
+
+        expect(loadBlockSpy).toHaveBeenCalledTimes(3);
+        expect(sut['lastBlockNumber']).toStrictEqual(13);
+    });
+});

package/tests/types/rates.spec.ts

@@ -0,0 +1,216 @@
+import { 
+    RatesError, 
+    NetworkError, 
+    ValidationError,
+    ExchangeRates,
+    HiveRates,
+    CryptoRates,
+    ExchangeResponse,
+    FiatResponse,
+    RateConfig,
+    CurrencyPair,
+    SupportedCrypto,
+    SupportedFiat
+} from '../../src/types/rates';
+
+describe('Types and Error Classes', () => {
+    describe('RatesError', () => {
+        it('should create basic RatesError', () => {
+            const error = new RatesError('Test message', 'TEST_CODE');
+            
+            expect(error.message).toBe('Test message');
+            expect(error.code).toBe('TEST_CODE');
+            expect(error.name).toBe('RatesError');
+            expect(error.source).toBeUndefined();
+        });
+
+        it('should create RatesError with source', () => {
+            const error = new RatesError('Test message', 'TEST_CODE', 'test-source');
+            
+            expect(error.source).toBe('test-source');
+        });
+
+        it('should be instance of Error', () => {
+            const error = new RatesError('Test', 'CODE');
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(RatesError);
+        });
+    });
+
+    describe('NetworkError', () => {
+        it('should create NetworkError', () => {
+            const error = new NetworkError('Network failed');
+            
+            expect(error.message).toBe('Network failed');
+            expect(error.code).toBe('NETWORK_ERROR');
+            expect(error.name).toBe('NetworkError');
+        });
+
+        it('should create NetworkError with source', () => {
+            const error = new NetworkError('Network failed', 'api-endpoint');
+            
+            expect(error.source).toBe('api-endpoint');
+        });
+
+        it('should be instance of RatesError', () => {
+            const error = new NetworkError('Test');
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(RatesError);
+            expect(error).toBeInstanceOf(NetworkError);
+        });
+    });
+
+    describe('ValidationError', () => {
+        it('should create ValidationError', () => {
+            const error = new ValidationError('Invalid data');
+            
+            expect(error.message).toBe('Invalid data');
+            expect(error.code).toBe('VALIDATION_ERROR');
+            expect(error.name).toBe('ValidationError');
+        });
+
+        it('should create ValidationError with source', () => {
+            const error = new ValidationError('Invalid data', 'response-parser');
+            
+            expect(error.source).toBe('response-parser');
+        });
+
+        it('should be instance of RatesError', () => {
+            const error = new ValidationError('Test');
+            expect(error).toBeInstanceOf(Error);
+            expect(error).toBeInstanceOf(RatesError);
+            expect(error).toBeInstanceOf(ValidationError);
+        });
+    });
+
+    describe('Type Definitions', () => {
+        it('should accept valid ExchangeRates', () => {
+            const rates: ExchangeRates = {
+                EUR: 0.85,
+                GBP: 0.73,
+                JPY: 110
+            };
+            
+            expect(typeof rates.EUR).toBe('number');
+            expect(typeof rates.GBP).toBe('number');
+            expect(typeof rates.JPY).toBe('number');
+        });
+
+        it('should accept valid HiveRates', () => {
+            const rates: HiveRates = {
+                'USD_EUR': 0.85,
+                'EUR_HIVE': 0.425,
+                'GBP_HBD': 0.73
+            };
+            
+            expect(typeof rates['USD_EUR']).toBe('number');
+            expect(typeof rates['EUR_HIVE']).toBe('number');
+            expect(typeof rates['GBP_HBD']).toBe('number');
+        });
+
+        it('should accept valid CryptoRates', () => {
+            const rates: CryptoRates = {
+                usdHive: 0.5,
+                usdHbd: 1.0
+            };
+            
+            expect(rates.usdHive).toBe(0.5);
+            expect(rates.usdHbd).toBe(1.0);
+        });
+
+        it('should accept valid ExchangeResponse', () => {
+            const successResponse: ExchangeResponse = {
+                success: true,
+                rates: { usdHive: 0.5, usdHbd: 1.0 }
+            };
+            
+            const errorResponse: ExchangeResponse = {
+                success: false,
+                error: 'API failed'
+            };
+            
+            expect(successResponse.success).toBe(true);
+            expect(successResponse.rates).toBeDefined();
+            expect(errorResponse.success).toBe(false);
+            expect(errorResponse.error).toBe('API failed');
+        });
+
+        it('should accept valid FiatResponse', () => {
+            const successResponse: FiatResponse = {
+                success: true,
+                rates: { EUR: 0.85, GBP: 0.73 }
+            };
+            
+            const errorResponse: FiatResponse = {
+                success: false,
+                error: 'API failed'
+            };
+            
+            expect(successResponse.success).toBe(true);
+            expect(successResponse.rates).toBeDefined();
+            expect(errorResponse.success).toBe(false);
+            expect(errorResponse.error).toBe('API failed');
+        });
+
+        it('should accept valid RateConfig', () => {
+            const config: RateConfig = {
+                cacheDuration: 3600000,
+                maxRetries: 3,
+                retryDelay: 1000,
+                timeout: 10000
+            };
+            
+            expect(config.cacheDuration).toBe(3600000);
+            expect(config.maxRetries).toBe(3);
+            expect(config.retryDelay).toBe(1000);
+            expect(config.timeout).toBe(10000);
+        });
+
+        it('should accept partial RateConfig', () => {
+            const config: RateConfig = {
+                cacheDuration: 5000
+            };
+            
+            expect(config.cacheDuration).toBe(5000);
+            expect(config.maxRetries).toBeUndefined();
+        });
+
+        it('should work with CurrencyPair type', () => {
+            const pair1: CurrencyPair = 'USD_EUR';
+            const pair2: CurrencyPair = 'EUR_HIVE';
+            const pair3: CurrencyPair = 'GBP_HBD';
+            
+            expect(pair1).toBe('USD_EUR');
+            expect(pair2).toBe('EUR_HIVE');
+            expect(pair3).toBe('GBP_HBD');
+        });
+
+        it('should work with SupportedCrypto type', () => {
+            const crypto1: SupportedCrypto = 'HIVE';
+            const crypto2: SupportedCrypto = 'HBD';
+            
+            expect(crypto1).toBe('HIVE');
+            expect(crypto2).toBe('HBD');
+        });
+
+        it('should work with SupportedFiat type', () => {
+            const fiat1: SupportedFiat = 'USD';
+            const fiat2: SupportedFiat = 'EUR';
+            const fiat3: SupportedFiat = 'GBP';
+            const fiat4: SupportedFiat = 'JPY';
+            const fiat5: SupportedFiat = 'CAD';
+            const fiat6: SupportedFiat = 'AUD';
+            const fiat7: SupportedFiat = 'CHF';
+            const fiat8: SupportedFiat = 'CNY';
+            
+            expect(fiat1).toBe('USD');
+            expect(fiat2).toBe('EUR');
+            expect(fiat3).toBe('GBP');
+            expect(fiat4).toBe('JPY');
+            expect(fiat5).toBe('CAD');
+            expect(fiat6).toBe('AUD');
+            expect(fiat7).toBe('CHF');
+            expect(fiat8).toBe('CNY');
+        });
+    });
+});

package/tests/utils.spec.ts

@@ -16,7 +16,7 @@ describe('Utils', () => {
         });
     
         test('Invalid numeric values passed', () => {
-            expect(Utils.roundPrecision('dasd', 3)).toBeNaN();
+            expect(Utils.roundPrecision('dasd' as any, 3)).toBeNaN();
         });
     });
 
@@ -76,17 +76,38 @@ describe('Utils', () => {
     
             const value = await Utils.convertHiveAmount(amount, fiatSymbol, hiveSymbol);
             
-            expect(fetch).toBeCalledWith('https://api.coingecko.com/api/v3/simple/price?ids=hive,hive_dollar&vs_currencies=usd');
-            expect(fetch).toBeCalledWith('https://cdn.jsdelivr.net/npm/@fawazahmed0/currency-api@latest/v1/currencies/usd.json');
+            expect(fetch).toHaveBeenNthCalledWith(
+                1,
+                'https://api.coingecko.com/api/v3/simple/price?ids=hive,hive_dollar&vs_currencies=usd',
+                expect.objectContaining({
+                    headers: expect.objectContaining({
+                        'User-Agent': 'hive-stream/3.0.0',
+                        'Accept': 'application/json'
+                    })
+                })
+            );
+            expect(fetch).toHaveBeenNthCalledWith(
+                2,
+                'https://cdn.jsdelivr.net/npm/@fawazahmed0/currency-api@latest/v1/currencies/usd.json',
+                expect.objectContaining({
+                    headers: expect.objectContaining({
+                        'User-Agent': 'hive-stream/3.0.0',
+                        'Accept': 'application/json',
+                        'Cache-Control': 'no-cache'
+                    })
+                })
+            );
 
             expect(value).toStrictEqual(Number((amount / 0.229951).toFixed(3))); // amount / HIVE price from CoinGecko (fiat to HIVE conversion)
         });
     });
 
     describe('Get transfer URL', () => {
-        test('Gets a transfer URL string', () => {
-            expect(Utils.getTransferUrl('beggars', 'TEST123', '10.000 HIVE', 'http://localhost:5001')).toStrictEqual(`https://hivesigner.com/sign/transfer?to=beggars&memo=TEST123&amount=10.000 HIVE&redirect_uri=http://localhost:5001`);
+        test('Gets a transfer URL string with proper URL encoding', () => {
+            const result = Utils.getTransferUrl('beggars', 'TEST123', '10.000 HIVE', 'http://localhost:5001');
+            const expected = 'https://hivesigner.com/sign/transfer?to=beggars&memo=TEST123&amount=10.000%20HIVE&redirect_uri=http%3A%2F%2Flocalhost%3A5001';
+            expect(result).toStrictEqual(expected);
         });
     });
 
-});
+});