hive-stream 2.0.6 → 3.0.1

package/tests/adapters/actions-persistence.spec.ts

@@ -0,0 +1,144 @@
+import { TimeAction } from '../../src/actions';
+import { SqliteAdapter } from '../../src/adapters/sqlite.adapter';
+import { MongodbAdapter } from '../../src/adapters/mongodb.adapter';
+import fs from 'fs';
+import path from 'path';
+
+describe('Actions Persistence', () => {
+    describe('SqliteAdapter', () => {
+        let adapter: SqliteAdapter;
+        let testDbPath: string;
+
+        beforeEach(async () => {
+            // Create unique database path for each test
+            testDbPath = path.resolve(__dirname, `../../src/adapters/hive-stream-test-${Date.now()}-${Math.random()}.db`);
+            
+            // Clean up any existing test database
+            if (fs.existsSync(testDbPath)) {
+                fs.unlinkSync(testDbPath);
+            }
+            
+            adapter = new SqliteAdapter(testDbPath);
+            await adapter.create();
+        });
+
+        afterEach(async () => {
+            if (adapter && adapter.getDb()) {
+                await adapter.destroy();
+            }
+            
+            // Clean up test database
+            if (fs.existsSync(testDbPath)) {
+                fs.unlinkSync(testDbPath);
+            }
+        });
+
+        test('Should save and load actions correctly', async () => {
+            const testActions = [
+                new TimeAction('1m', 'action1', 'contract1', 'method1', { data: 'test1' }),
+                new TimeAction('5m', 'action2', 'contract2', 'method2', { data: 'test2' }, new Date('2023-01-01'), false, 5, 10)
+            ];
+            
+            // Serialize actions as they would be in the streamer
+            const serializedActions = testActions.map(a => a.toJSON());
+            
+            const stateData = {
+                lastBlockNumber: 12345,
+                actions: serializedActions
+            };
+            
+            await adapter.saveState(stateData);
+            
+            const loadedActions = await adapter.loadActions();
+            
+            expect(loadedActions).toHaveLength(2);
+            
+            const action1 = loadedActions.find(a => a.id === 'action1');
+            const action2 = loadedActions.find(a => a.id === 'action2');
+            
+            expect(action1).toBeDefined();
+            expect(action1?.timeValue).toBe('1m');
+            expect(action1?.contractName).toBe('contract1');
+            expect(action1?.contractAction).toBe('method1');
+            expect(action1?.payload).toEqual({ data: 'test1' });
+            expect(action1?.enabled).toBe(true);
+            expect(action1?.executionCount).toBe(0);
+            
+            expect(action2).toBeDefined();
+            expect(action2?.timeValue).toBe('5m');
+            expect(action2?.contractName).toBe('contract2');
+            expect(action2?.contractAction).toBe('method2');
+            expect(action2?.payload).toEqual({ data: 'test2' });
+            expect(action2?.enabled).toBe(false);
+            expect(action2?.executionCount).toBe(5);
+            expect(action2?.maxExecutions).toBe(10);
+            expect(action2?.date).toEqual(new Date('2023-01-01'));
+        });
+
+        test('Should handle empty actions array', async () => {
+            const stateData = {
+                lastBlockNumber: 12345,
+                actions: []
+            };
+            
+            await adapter.saveState(stateData);
+            const loadedActions = await adapter.loadActions();
+            
+            expect(loadedActions).toHaveLength(0);
+            expect(Array.isArray(loadedActions)).toBe(true);
+        });
+
+        test('Should handle corrupted action data gracefully', async () => {
+            const stateData = {
+                lastBlockNumber: 12345,
+                actions: [
+                    { timeValue: '1m', id: 'valid-action', contractName: 'test', contractAction: 'test' },
+                    { invalid: 'data' }, // Invalid action
+                    null, // Null action
+                    'invalid string' // Invalid type
+                ]
+            };
+            
+            await adapter.saveState(stateData);
+            const loadedActions = await adapter.loadActions();
+            
+            // Should only load the valid action
+            expect(loadedActions).toHaveLength(1);
+            expect(loadedActions[0].id).toBe('valid-action');
+        });
+
+        test('Should handle missing state gracefully', async () => {
+            const loadedActions = await adapter.loadActions();
+            
+            expect(loadedActions).toHaveLength(0);
+            expect(Array.isArray(loadedActions)).toBe(true);
+        });
+    });
+
+    // Note: MongoDB tests would require a running MongoDB instance
+    // For now, we'll test the serialization logic only
+    describe('MongodbAdapter Serialization', () => {
+        test('Should serialize actions data correctly for MongoDB', () => {
+            const testActions = [
+                new TimeAction('1m', 'action1', 'contract1', 'method1', { data: 'test1' }),
+                new TimeAction('5m', 'action2', 'contract2', 'method2', { data: 'test2' })
+            ];
+            
+            const serializedActions = testActions.map(a => a.toJSON());
+            
+            const stateData = {
+                lastBlockNumber: 12345,
+                actions: serializedActions
+            };
+            
+            // Verify the data structure is valid for MongoDB
+            expect(stateData.actions).toHaveLength(2);
+            expect(stateData.actions[0]).toHaveProperty('timeValue');
+            expect(stateData.actions[0]).toHaveProperty('id');
+            expect(stateData.actions[0]).toHaveProperty('contractName');
+            expect(stateData.actions[0]).toHaveProperty('contractAction');
+            expect(stateData.actions[0]).toHaveProperty('date');
+            expect(typeof stateData.actions[0].date).toBe('string'); // Should be ISO string
+        });
+    });
+});

package/tests/adapters/postgresql.adapter.spec.ts

@@ -0,0 +1,127 @@
+import { PostgreSQLAdapter } from "../../src/adapters/postgresql.adapter";
+
+describe('PostgreSQL Adapter', () => {
+    let sut: PostgreSQLAdapter;
+
+    beforeEach(() => {
+        sut = new PostgreSQLAdapter({
+            host: 'localhost',
+            port: 5432,
+            user: 'test',
+            password: 'test',
+            database: 'test_db'
+        });
+    });
+
+    test('constructor creates adapter with connection config', () => {
+        expect(sut).toBeInstanceOf(PostgreSQLAdapter);
+        expect(sut.getDb()).toBeDefined();
+    });
+
+    test('constructor works with connection string', () => {
+        const adapter = new PostgreSQLAdapter({
+            connectionString: 'postgresql://user:pass@localhost:5432/dbname',
+            ssl: true
+        });
+        
+        expect(adapter).toBeInstanceOf(PostgreSQLAdapter);
+        expect(adapter.getDb()).toBeDefined();
+    });
+
+    test('constructor uses default values when not provided', () => {
+        const adapter = new PostgreSQLAdapter({
+            password: 'test'
+        });
+        
+        expect(adapter).toBeInstanceOf(PostgreSQLAdapter);
+        expect(adapter.getDb()).toBeDefined();
+    });
+
+    test('processOperation sets internal state', async () => {
+        const testData = {
+            blockNumber: 12345,
+            blockId: 'test-block',
+            prevBlockId: 'prev-block',
+            trxId: 'test-tx',
+            blockTime: new Date()
+        };
+
+        await sut.processOperation({}, testData.blockNumber, testData.blockId, testData.prevBlockId, testData.trxId, testData.blockTime);
+
+        // Since these are private properties, we can't directly test them
+        // But we can verify the method doesn't throw
+        expect(true).toBe(true);
+    });
+
+    test('getDb returns knex instance', () => {
+        const db = sut.getDb();
+        expect(db).toBeDefined();
+        expect(typeof db).toBe('function'); // Knex instance is callable
+    });
+
+    test('destroy method is implemented', async () => {
+        // Create a mock knex instance
+        const mockKnex = {
+            destroy: jest.fn().mockResolvedValue(undefined)
+        };
+        (sut as any).db = mockKnex;
+
+        const result = await sut.destroy();
+
+        expect(result).toBe(true);
+        expect(mockKnex.destroy).toHaveBeenCalled();
+    });
+
+    test('query method handles raw SQL', async () => {
+        // Create a mock knex instance
+        const mockKnex = {
+            raw: jest.fn().mockResolvedValue({ rows: [{ id: 1, name: 'test' }] })
+        };
+        (sut as any).db = mockKnex;
+
+        const result = await sut.query('SELECT * FROM test WHERE id = $1', [1]);
+
+        expect(result).toEqual([{ id: 1, name: 'test' }]);
+        expect(mockKnex.raw).toHaveBeenCalledWith('SELECT * FROM test WHERE id = $1', [1]);
+    });
+
+    test('loadState handles missing state gracefully', async () => {
+        // Mock the query to return no results
+        const mockQuery = jest.fn().mockReturnValue({
+            select: jest.fn().mockReturnValue({
+                first: jest.fn().mockResolvedValue(null)
+            })
+        });
+        (sut as any).db = mockQuery;
+
+        const result = await sut.loadState();
+
+        expect(result).toBeNull();
+    });
+
+    test('saveState serializes actions correctly', async () => {
+        const testData = {
+            lastBlockNumber: 12345,
+            actions: [{ id: 'test', type: 'action' }]
+        };
+
+        // Mock the query chain
+        const mockMerge = jest.fn().mockResolvedValue(undefined);
+        const mockOnConflict = jest.fn().mockReturnValue({ merge: mockMerge });
+        const mockInsert = jest.fn().mockReturnValue({ onConflict: mockOnConflict });
+        const mockQuery = jest.fn().mockReturnValue({ insert: mockInsert });
+        (sut as any).db = mockQuery;
+
+        const result = await sut.saveState(testData);
+
+        expect(result).toBe(true);
+        expect(mockQuery).toHaveBeenCalledWith('params');
+        expect(mockInsert).toHaveBeenCalledWith({
+            id: 1,
+            actions: JSON.stringify(testData.actions),
+            lastBlockNumber: 12345
+        });
+        expect(mockOnConflict).toHaveBeenCalledWith('id');
+        expect(mockMerge).toHaveBeenCalled();
+    });
+});

package/tests/adapters/sqlite.adapter.spec.ts

@@ -1,43 +1,181 @@
-import { SqliteAdapter } from "../../src/adapters/sqlite.adapter";
-
-
-describe('SQLite Adapter', () => {
-    let sut: SqliteAdapter;
-
-    beforeEach(() => {
-        sut = new SqliteAdapter();
-    });
-
-    test('find method returns values', async () => {
-        jest.spyOn(sut.db, 'all').mockImplementation((query: any, callback: any) => {
-            return callback(null, [{ id: 1, name: 'John' }]);
-        });
-
-        const result = await sut.find('USERS', { id: 1, name: 'John' });
-
-        expect(result).toEqual([{ id: 1, name: 'John' }]);
-        expect(sut.db.all).toHaveBeenCalledWith('SELECT * FROM USERS WHERE id = 1 AND name = John', expect.any(Function));
-    });
-
-    test('findOne method returns value', async () => {
-        jest.spyOn(sut.db, 'get').mockImplementation((query: any, callback: any) => {
-            return callback(null, { id: 1, name: 'John' });
-        });
-
-        const result = await sut.findOne('USERS', { id: 1, name: 'John', email: 'john@hotmail.com' });
-
-        expect(result).toEqual({ id: 1, name: 'John' });
-        expect(sut.db.get).toHaveBeenCalledWith('SELECT * FROM USERS WHERE id = 1 AND name = John AND email = john@hotmail.com', expect.any(Function));
-    });
-
-    test('replace method replaces value', async () => {
-        jest.spyOn(sut.db, 'run').mockImplementation((query: any, callback: any) => {
-            return callback(null, { id: 1, name: 'John' });
-        });
-
-        const result = await sut.replace('USERS', { id: 1, name: 'John' }, { id: 2, name: 'Johnny' });
-
-        expect(result).toEqual({ id: 2, name: 'Johnny' });
-        expect(sut.db.run).toHaveBeenCalledWith(`REPLACE INTO USERS id = 1 AND name = John VALUES ([object Object])`, expect.any(Function));
-    });
+import { SqliteAdapter } from "../../src/adapters/sqlite.adapter";
+import fs from 'fs';
+import path from 'path';
+
+describe('SQLite Adapter', () => {
+    let sut: SqliteAdapter;
+    let testDbPath: string;
+
+    beforeEach(async () => {
+        testDbPath = path.resolve(__dirname, `../../src/adapters/hive-stream-test-basic-${Date.now()}-${Math.random()}.db`);
+        
+        if (fs.existsSync(testDbPath)) {
+            fs.unlinkSync(testDbPath);
+        }
+        
+        sut = new SqliteAdapter(testDbPath);
+        await sut.create();
+    });
+
+    afterEach(async () => {
+        if (sut && sut.getDb()) {
+            await sut.destroy();
+        }
+        
+        if (fs.existsSync(testDbPath)) {
+            fs.unlinkSync(testDbPath);
+        }
+    });
+
+    test('find method returns values', async () => {
+        // Create a test table
+        await sut.db.schema.createTableIfNotExists('USERS', table => {
+            table.integer('id');
+            table.string('name');
+        });
+        
+        // Insert test data
+        await sut.db('USERS').insert({ id: 1, name: 'John' });
+        
+        const result = await sut.find('USERS', { id: 1, name: 'John' });
+
+        expect(result).toEqual([{ id: 1, name: 'John' }]);
+    });
+
+    test('findOne method returns value', async () => {
+        // Create a test table
+        await sut.db.schema.createTableIfNotExists('USERS', table => {
+            table.integer('id');
+            table.string('name');
+            table.string('email');
+        });
+        
+        // Insert test data
+        await sut.db('USERS').insert({ id: 1, name: 'John', email: 'john@hotmail.com' });
+        
+        const result = await sut.findOne('USERS', { id: 1, name: 'John', email: 'john@hotmail.com' });
+
+        expect(result).toEqual({ id: 1, name: 'John', email: 'john@hotmail.com' });
+    });
+
+    test('replace method replaces value', async () => {
+        // Create a test table
+        await sut.db.schema.createTableIfNotExists('USERS', table => {
+            table.integer('id').primary();
+            table.string('name');
+        });
+        
+        // Insert initial data
+        await sut.db('USERS').insert({ id: 1, name: 'John' });
+        
+        const result = await sut.replace('USERS', { id: 1 }, { id: 1, name: 'Johnny' });
+
+        expect(result).toEqual({ id: 1, name: 'Johnny' });
+        
+        // Verify the data was actually replaced
+        const updatedRecord = await sut.db('USERS').where({ id: 1 }).first();
+        expect(updatedRecord).toEqual({ id: 1, name: 'Johnny' });
+    });
+
+    test('insert method inserts values', async () => {
+        // Create a test table
+        await sut.db.schema.createTableIfNotExists('USERS', table => {
+            table.integer('id');
+            table.string('name');
+        });
+        
+        const result = await sut.insert('USERS', { id: 1, name: 'Alice' });
+        
+        expect(result).toBe(true);
+        
+        // Verify the data was actually inserted
+        const insertedRecord = await sut.db('USERS').where({ id: 1 }).first();
+        expect(insertedRecord).toEqual({ id: 1, name: 'Alice' });
+    });
+
+    test('loadState and saveState work correctly', async () => {
+        const testData = {
+            lastBlockNumber: 12345,
+            actions: [{ id: 'test-action', type: 'test' }]
+        };
+        
+        // Save state
+        const saveResult = await sut.saveState(testData);
+        expect(saveResult).toBe(true);
+        
+        // Load state
+        const loadedState = await sut.loadState();
+        expect(loadedState?.lastBlockNumber).toBe(12345);
+        expect(loadedState?.actions).toEqual([{ id: 'test-action', type: 'test' }]);
+    });
+
+    test('processTransfer works correctly', async () => {
+        const mockPayload = {
+            contract: 'test-contract',
+            action: 'transfer',
+            payload: { amount: '100', recipient: 'bob' }
+        };
+        
+        const mockMetadata = {
+            sender: 'alice',
+            amount: '100 HIVE'
+        };
+        
+        // Set up transaction context
+        await sut.processOperation({}, 12345, 'block123', 'prevblock', 'tx123', new Date());
+        
+        const result = await sut.processTransfer({}, mockPayload, mockMetadata);
+        expect(result).toBe(true);
+        
+        // Verify the transfer was stored
+        const transfers = await sut.getTransfers();
+        expect(transfers).toHaveLength(1);
+        expect(transfers[0].sender).toBe('alice');
+        expect(transfers[0].contractName).toBe('test-contract');
+    });
+
+    test('processCustomJson works correctly', async () => {
+        const mockPayload = {
+            contract: 'test-contract',
+            action: 'custom',
+            payload: { data: 'test' }
+        };
+        
+        const mockMetadata = {
+            sender: 'alice',
+            isSignedWithActiveKey: true
+        };
+        
+        // Set up transaction context
+        await sut.processOperation({}, 12345, 'block123', 'prevblock', 'tx123', new Date());
+        
+        const result = await sut.processCustomJson({}, mockPayload, mockMetadata);
+        expect(result).toBe(true);
+        
+        // Verify the custom JSON was stored
+        const customJson = await sut.getJson();
+        expect(customJson).toHaveLength(1);
+        expect(customJson[0].sender).toBe('alice');
+        expect(customJson[0].contractName).toBe('test-contract');
+        expect(customJson[0].isSignedWithActiveKey).toBe(1);
+    });
+
+    test('query method executes raw SQL', async () => {
+        // Create a test table
+        await sut.db.schema.createTableIfNotExists('USERS', table => {
+            table.integer('id');
+            table.string('name');
+        });
+        
+        // Insert test data
+        await sut.db('USERS').insert({ id: 1, name: 'Alice' });
+        await sut.db('USERS').insert({ id: 2, name: 'Bob' });
+        
+        // Test raw SQL query
+        const result = await sut.query('SELECT * FROM USERS WHERE name = ?', ['Alice']);
+        
+        expect(result).toHaveLength(1);
+        expect(result[0].name).toBe('Alice');
+        expect(result[0].id).toBe(1);
+    });
 });