hive-stream 3.0.2 → 3.0.3

package/tests/streamer-actions.spec.ts

@@ -1,274 +0,0 @@
-import { TimeAction } from '../src/actions';
-import { Streamer } from '../src/streamer';
-import { action, defineContract } from '../src/contracts/contract';
-
-describe('Streamer Time-based Actions', () => {
-    let streamer: Streamer;
-    let mockAdapter: any;
-    let mockContract: any;
-    let testHandler: jest.Mock;
-    let asyncTestHandler: jest.Mock;
-
-    beforeEach(async () => {
-        mockAdapter = {
-            create: jest.fn().mockResolvedValue(true),
-            destroy: jest.fn().mockResolvedValue(true),
-            loadActions: jest.fn().mockResolvedValue([]),
-            loadState: jest.fn().mockResolvedValue({ lastBlockNumber: 0, actions: [] }),
-            saveState: jest.fn().mockResolvedValue(true),
-            processBlock: jest.fn().mockResolvedValue(true),
-            processOperation: jest.fn().mockResolvedValue(true),
-            processTransfer: jest.fn().mockResolvedValue(true),
-            processCustomJson: jest.fn().mockResolvedValue(true),
-            find: jest.fn().mockResolvedValue([]),
-            findOne: jest.fn().mockResolvedValue(null),
-            insert: jest.fn().mockResolvedValue(true),
-            replace: jest.fn().mockResolvedValue(true)
-        };
-
-        testHandler = jest.fn();
-        asyncTestHandler = jest.fn().mockResolvedValue(true);
-
-        mockContract = defineContract({
-            name: 'testcontract',
-            hooks: {
-                create: jest.fn(),
-                destroy: jest.fn()
-            },
-            actions: {
-                testMethod: action(testHandler, { trigger: 'time' }),
-                asyncTestMethod: action(asyncTestHandler, { trigger: 'time' })
-            }
-        });
-
-        streamer = new Streamer({
-            JSON_ID: 'testing',
-            DEBUG_MODE: false
-        });
-
-        await streamer.registerAdapter(mockAdapter);
-        await streamer.registerContract(mockContract);
-    });
-
-    afterEach(async () => {
-        await streamer.stop();
-    });
-
-    describe('Action Registration', () => {
-        test('Should register a new action successfully', async () => {
-            const action = new TimeAction('1m', 'test-action', 'testcontract', 'testMethod');
-            
-            await streamer.registerAction(action);
-            
-            const actions = streamer.getActions();
-            expect(actions).toHaveLength(1);
-            expect(actions[0].id).toBe('test-action');
-            expect(mockAdapter.saveState).toHaveBeenCalled();
-        });
-
-        test('Should not register duplicate action IDs', async () => {
-            const action1 = new TimeAction('1m', 'test-action', 'testcontract', 'testMethod');
-            const action2 = new TimeAction('5m', 'test-action', 'testcontract', 'testMethod');
-            
-            await streamer.registerAction(action1);
-            await streamer.registerAction(action2);
-            
-            const actions = streamer.getActions();
-            expect(actions).toHaveLength(1);
-            expect(actions[0].timeValue).toBe('1m'); // First one should remain
-        });
-
-        test('Should throw error when registering action for non-existent contract', async () => {
-            const action = new TimeAction('1m', 'test-action', 'nonexistent', 'testMethod');
-            
-            await expect(streamer.registerAction(action)).rejects.toThrow(
-                'Contract \'nonexistent\' not found for action \'test-action\''
-            );
-        });
-
-        test('Should throw error when registering action for non-existent action', async () => {
-            const action = new TimeAction('1m', 'test-action', 'testcontract', 'nonexistentMethod');
-            
-            await expect(streamer.registerAction(action)).rejects.toThrow(
-                'Action \'nonexistentMethod\' not found in contract \'testcontract\' for action \'test-action\''
-            );
-        });
-    });
-
-    describe('Action Management', () => {
-        beforeEach(async () => {
-            const action1 = new TimeAction('1m', 'action1', 'testcontract', 'testMethod');
-            const action2 = new TimeAction('5m', 'action2', 'testcontract', 'testMethod');
-            await streamer.registerAction(action1);
-            await streamer.registerAction(action2);
-        });
-
-        test('Should remove action by ID', async () => {
-            const result = await streamer.removeAction('action1');
-            
-            expect(result).toBe(true);
-            expect(streamer.getActions()).toHaveLength(1);
-            expect(streamer.getAction('action1')).toBeUndefined();
-            expect(mockAdapter.saveState).toHaveBeenCalled();
-        });
-
-        test('Should return false when removing non-existent action', async () => {
-            const result = await streamer.removeAction('nonexistent');
-            
-            expect(result).toBe(false);
-            expect(streamer.getActions()).toHaveLength(2);
-        });
-
-        test('Should get action by ID', () => {
-            const action = streamer.getAction('action1');
-            
-            expect(action).toBeDefined();
-            expect(action?.id).toBe('action1');
-        });
-
-        test('Should return undefined for non-existent action', () => {
-            const action = streamer.getAction('nonexistent');
-            
-            expect(action).toBeUndefined();
-        });
-
-        test('Should enable and disable actions', async () => {
-            const action = streamer.getAction('action1');
-            expect(action?.enabled).toBe(true);
-            
-            const result1 = await streamer.setActionEnabled('action1', false);
-            expect(result1).toBe(true);
-            expect(action?.enabled).toBe(false);
-            
-            const result2 = await streamer.setActionEnabled('action1', true);
-            expect(result2).toBe(true);
-            expect(action?.enabled).toBe(true);
-        });
-
-        test('Should reset action date', async () => {
-            const action = streamer.getAction('action1');
-            const originalDate = action?.date;
-            
-            // Wait a bit to ensure time difference
-            await new Promise(resolve => setTimeout(resolve, 10));
-            
-            const result = await streamer.resetAction('action1');
-            
-            expect(result).toBe(true);
-            expect(action?.date.getTime()).toBeGreaterThan(originalDate?.getTime() || 0);
-            expect(mockAdapter.saveState).toHaveBeenCalled();
-        });
-    });
-
-    describe('Action Execution', () => {
-        let testAction: TimeAction;
-
-        beforeEach(async () => {
-            testAction = new TimeAction('1m', 'test-action', 'testcontract', 'testMethod', { testData: 'value' });
-            await streamer.registerAction(testAction);
-            
-            // Mock the blockchain time to be in the future to trigger execution
-            streamer['latestBlockchainTime'] = new Date(Date.now() + 120000); // 2 minutes in future
-        });
-
-        test('Should execute action when time threshold is met', async () => {
-            // Set action date to past to trigger execution
-            testAction.date = new Date(Date.now() - 120000); // 2 minutes ago
-            
-            await streamer['processActions']();
-            
-            expect(testHandler).toHaveBeenCalledWith({ testData: 'value' }, expect.any(Object));
-            expect(testAction.executionCount).toBe(1);
-            expect(testAction.lastExecution).toBeInstanceOf(Date);
-        });
-
-        test('Should not execute action when time threshold is not met', async () => {
-            // Reset the action date to be very recent to ensure it doesn't execute
-            testAction.date = new Date(Date.now() - 10000); // Only 10 seconds ago (less than 1 minute)
-            
-            // Also ensure blockchain time is current, not in the future
-            streamer['latestBlockchainTime'] = new Date();
-            
-            await streamer['processActions']();
-            
-            expect(testHandler).not.toHaveBeenCalled();
-            expect(testAction.executionCount).toBe(0);
-        });
-
-        test('Should not execute disabled actions', async () => {
-            testAction.date = new Date(Date.now() - 120000); // 2 minutes ago
-            testAction.disable();
-            
-            await streamer['processActions']();
-            
-            expect(testHandler).not.toHaveBeenCalled();
-        });
-
-        test('Should not execute actions that have reached max executions', async () => {
-            testAction.date = new Date(Date.now() - 120000); // 2 minutes ago
-            testAction.maxExecutions = 1;
-            testAction.executionCount = 1;
-            
-            await streamer['processActions']();
-            
-            expect(testHandler).not.toHaveBeenCalled();
-        });
-
-        test('Should handle contract method errors gracefully', async () => {
-            testHandler.mockImplementation(() => {
-                throw new Error('Contract method error');
-            });
-            
-            testAction.date = new Date(Date.now() - 120000); // 2 minutes ago
-            
-            // Should not throw, but log error
-            await expect(streamer['processActions']()).resolves.toBeUndefined();
-            
-            expect(testHandler).toHaveBeenCalled();
-            // Action should not increment execution count on error
-            expect(testAction.executionCount).toBe(0);
-        });
-
-        test('Should clean up completed actions', async () => {
-            testAction.maxExecutions = 1;
-            testAction.date = new Date(Date.now() - 120000); // 2 minutes ago
-            
-            await streamer['processActions']();
-            
-            expect(testHandler).toHaveBeenCalled();
-            expect(streamer.getActions()).toHaveLength(0); // Action should be removed
-        });
-    });
-
-    describe('Action Frequencies', () => {
-        const testCases = [
-            { timeValue: '3s', expectedSeconds: 3 },
-            { timeValue: '30s', expectedSeconds: 30 },
-            { timeValue: '1m', expectedSeconds: 60 },
-            { timeValue: 'minute', expectedSeconds: 60 },
-            { timeValue: '15m', expectedSeconds: 900 },
-            { timeValue: '1h', expectedSeconds: 3600 },
-            { timeValue: 'hourly', expectedSeconds: 3600 },
-            { timeValue: '24h', expectedSeconds: 86400 },
-            { timeValue: 'daily', expectedSeconds: 86400 },
-            { timeValue: 'week', expectedSeconds: 604800 }
-        ];
-
-        testCases.forEach(({ timeValue, expectedSeconds }) => {
-            test(`Should execute ${timeValue} action after ${expectedSeconds} seconds`, async () => {
-                const action = new TimeAction(timeValue, `test-${timeValue}`, 'testcontract', 'testMethod');
-                action.date = new Date(Date.now() - (expectedSeconds * 1000 + 1000)); // Past the threshold
-                
-                await streamer.registerAction(action);
-                
-                // Mock blockchain time
-                streamer['latestBlockchainTime'] = new Date();
-                
-                await streamer['processActions']();
-                
-                expect(testHandler).toHaveBeenCalled();
-                expect(action.executionCount).toBe(1);
-            });
-        });
-    });
-});

package/tests/streamer.spec.ts

@@ -1,342 +0,0 @@
-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', () => {
-    let sut: Streamer;
-
-    beforeEach(async () => {
-        sut = new Streamer({
-            JSON_ID: 'testing'
-        });
-        
-        await sut.registerAdapter(createMockAdapter());
-    });
-
-    afterEach(async () => {
-        await sut.stop();
-    });
-
-    describe('Adapters', () => {
-        test('Registers adapter and calls the create lifecycle method', async () => {
-            const adapter = {
-                create: jest.fn().mockResolvedValue(true),
-                destroy: jest.fn(),
-                loadActions: jest.fn().mockResolvedValue([]),
-                loadState: jest.fn().mockResolvedValue(null),
-                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(),
-                addEvent: jest.fn(),
-                client: null,
-                db: null
-            } as any;
-
-            await sut.registerAdapter(adapter);
-
-            expect(adapter.create).toHaveBeenCalled();
-        });
-    });
-
-    describe('Actions', () => {
-        test('Registers a new action', async () => {
-            const mockContract = defineContract({
-                name: 'testcontract',
-                actions: {
-                    testmethod: contractAction(jest.fn(), { trigger: 'time' })
-                }
-            });
-            
-            await sut.registerContract(mockContract);
-            
-            const adapter = {
-                create: jest.fn().mockResolvedValue(true),
-                destroy: jest.fn(),
-                loadActions: jest.fn().mockResolvedValue([]),
-                loadState: jest.fn().mockResolvedValue(null),
-                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);
-
-            const action = new TimeAction('1m', 'testoneminute', 'testcontract', 'testmethod');
-
-            await sut.registerAction(action);
-
-            const foundAction = sut['actions'].find(a => a.id === 'testoneminute');
-
-            expect(foundAction).not.toBeUndefined();
-        });
-
-        test('Does not allow duplicate actions of the same id', async () => {
-            const mockContract = defineContract({
-                name: 'testcontract',
-                actions: {
-                    testmethod: contractAction(jest.fn(), { trigger: 'time' })
-                }
-            });
-            
-            await sut.registerContract(mockContract);
-            
-            const adapter = {
-                create: jest.fn().mockResolvedValue(true),
-                destroy: jest.fn(),
-                loadActions: jest.fn().mockResolvedValue([]),
-                loadState: jest.fn().mockResolvedValue(null),
-                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);
-
-            const action = new TimeAction('1m', 'testoneminute', 'testcontract', 'testmethod');
-            const action2 = new TimeAction('1m', 'testoneminute', 'testcontract', 'testmethod');
-
-            await sut.registerAction(action);
-            await sut.registerAction(action2);
-
-            expect(sut['actions'].length).toStrictEqual(1);
-        });
-
-        test('Registers actions loaded from adapter loadActions call', async () => {
-            const mockContract = defineContract({
-                name: 'testcontract',
-                actions: {
-                    testmethod: contractAction(jest.fn(), { trigger: 'time' })
-                }
-            });
-            
-            await sut.registerContract(mockContract);
-            
-            const adapter = {
-                create: jest.fn().mockResolvedValue(true),
-                destroy: jest.fn(),
-                loadActions: jest.fn().mockResolvedValue([{
-                    timeValue: '1m',
-                    id: 'testoneminute',
-                    contractName: 'testcontract',
-                    contractAction: 'testmethod',
-                    payload: {},
-                    date: new Date().toISOString(),
-                    enabled: true,
-                    executionCount: 0
-                }]),
-                loadState: jest.fn().mockResolvedValue(null),
-                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);
-
-            const action = new TimeAction('1h', 'testonehour', 'testcontract', 'testmethod');
-
-            await sut.registerAction(action);
-
-            const foundAction = sut['actions'].find(a => a.id === 'testoneminute');
-
-            expect(foundAction).not.toBeUndefined();
-        });
-    });
-
-    describe('Contracts', () => {
-        test('Should register a new contract', async () => {
-            const contract = defineContract({
-                name: 'testcontract',
-                actions: {
-                    myMethod: contractAction(jest.fn())
-                }
-            });
-
-            await sut.registerContract(contract);
-
-            expect(sut['contracts'].length).toStrictEqual(1);
-        });
-
-        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', async () => {
-            const contract = defineContract({
-                name: 'testcontract',
-                actions: {
-                    myMethod: contractAction(jest.fn())
-                }
-            });
-
-            await sut.registerContract(contract);
-            await sut.unregisterContract('testcontract');
-
-            expect(sut['contracts'].length).toStrictEqual(0);
-        });
-
-        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);
-        });
-    });
-
-    test('Start method should resume from previous block number', async () => {
-        // Override config to not have a preset LAST_BLOCK_NUMBER
-        sut.setConfig({ LAST_BLOCK_NUMBER: 0 });
-        
-        const adapter = {
-            create: jest.fn().mockResolvedValue(true),
-            destroy: jest.fn(),
-            loadActions: jest.fn().mockResolvedValue([]),
-            loadState: jest.fn().mockResolvedValue({ lastBlockNumber: 509992 }),
-            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(509992);
-
-        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);
-    });
-});