hive-stream 2.0.5 → 3.0.0

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 = {
+            name: '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 = {
+            name: '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);
+    });
 });