hive-stream 3.0.0 → 3.0.1

package/tests/contracts/token.contract.spec.ts

@@ -1,334 +1,90 @@
-import { TokenContract } from '../../src/contracts/token.contract';
-import { MockAdapter } from '../helpers/mock-adapter';
+import { createTokenContract } from '../../src/contracts/token.contract';
+import { Streamer } from '../../src/streamer';
+import { createMockAdapter } from '../helpers/mock-adapter';
+
+const createContext = (streamer: Streamer, adapter: any, sender: string) => ({
+    trigger: 'custom_json' as const,
+    streamer,
+    adapter,
+    config: streamer['config'],
+    block: { number: 123, id: 'block123', previousId: 'prevblock123', time: new Date() },
+    transaction: { id: 'txn123' },
+    sender,
+    customJson: { id: 'hivestream', json: {}, isSignedWithActiveKey: true }
+});
 
 describe('TokenContract', () => {
-    let tokenContract: TokenContract;
-    let mockAdapter: MockAdapter;
-    let mockStreamer: any;
-
-    beforeEach(() => {
-        mockAdapter = new MockAdapter();
-        mockStreamer = {
-            getAdapter: () => mockAdapter
-        };
-
-        tokenContract = new TokenContract();
-        tokenContract._instance = mockStreamer;
-        tokenContract.updateBlockInfo(12345, 'block123', 'prevblock123', 'txn123');
+    let streamer: Streamer;
+    let adapter: any;
+    let contract: ReturnType<typeof createTokenContract>;
+
+    beforeEach(async () => {
+        streamer = new Streamer();
+        adapter = createMockAdapter();
+        await streamer.registerAdapter(adapter);
+        contract = createTokenContract();
+        await streamer.registerContract(contract);
     });
 
-    describe('createToken', () => {
-        it('should create a new token successfully', async () => {
-            mockAdapter.reset();
-            tokenContract.create();
-            mockAdapter.setQueryResult([]); // No existing token with same symbol
-
-            const payload = {
-                symbol: 'TEST',
-                name: 'Test Token',
-                precision: 3,
-                maxSupply: '1000000'
-            };
-
-            await (tokenContract as any).createToken(payload, { sender: 'alice' });
-
-            const insertQuery = mockAdapter.queries.find(q => q.includes('INSERT INTO tokens'));
-            expect(insertQuery).toBeDefined();
-            expect(mockAdapter.events.length).toBe(1);
-            expect(mockAdapter.events[0].action).toBe('createToken');
-        });
-
-        it('should reject invalid token symbol', async () => {
-            const payload = {
-                symbol: 'invalid-symbol',
-                name: 'Test Token',
-                maxSupply: '1000000'
-            };
-
-            await expect((tokenContract as any).createToken(payload, { sender: 'alice' }))
-                .rejects.toThrow('Symbol must be 1-10 uppercase alphanumeric characters');
-        });
-
-        it('should reject invalid max supply', async () => {
-            const payload = {
-                symbol: 'TEST',
-                name: 'Test Token',
-                maxSupply: '0'
-            };
-
-            await expect((tokenContract as any).createToken(payload, { sender: 'alice' }))
-                .rejects.toThrow('Maximum supply must be between 1 and 9007199254740991');
-        });
-
-        it('should reject max supply too large', async () => {
-            const payload = {
-                symbol: 'TEST',
-                name: 'Test Token',
-                maxSupply: '9007199254740992'
-            };
-
-            await expect((tokenContract as any).createToken(payload, { sender: 'alice' }))
-                .rejects.toThrow('Maximum supply must be between 1 and 9007199254740991');
-        });
-
-        it('should reject invalid precision', async () => {
-            const payload = {
-                symbol: 'TEST',
-                name: 'Test Token',
-                precision: 9,
-                maxSupply: '1000000'
-            };
-
-            await expect((tokenContract as any).createToken(payload, { sender: 'alice' }))
-                .rejects.toThrow('Precision must be between 0 and 8');
-        });
-
-        it('should create token with URL', async () => {
-            mockAdapter.reset();
-            tokenContract.create();
-            mockAdapter.setQueryResult([]); // No existing token with same symbol
-
-            const payload = {
-                symbol: 'TEST',
-                name: 'Test Token',
-                url: 'https://example.com/token',
-                precision: 3,
-                maxSupply: '1000000'
-            };
-
-            await (tokenContract as any).createToken(payload, { sender: 'alice' });
-
-            const insertQuery = mockAdapter.queries.find(q => q.includes('INSERT INTO tokens'));
-            expect(insertQuery).toBeDefined();
-            expect(mockAdapter.events.length).toBe(1);
-            expect(mockAdapter.events[0].action).toBe('createToken');
-        });
-
-        it('should reject URL too long', async () => {
-            const longUrl = 'https://example.com/' + 'a'.repeat(250);
-            const payload = {
-                symbol: 'TEST',
-                name: 'Test Token',
-                url: longUrl,
-                maxSupply: '1000000'
-            };
-
-            await expect((tokenContract as any).createToken(payload, { sender: 'alice' }))
-                .rejects.toThrow('URL must be 256 characters or less');
-        });
+    afterEach(async () => {
+        await streamer.stop();
     });
 
-    describe('issueTokens', () => {
-        it('should issue tokens successfully', async () => {
-            mockAdapter.reset();
-            mockAdapter.setTestContext({ noExistingBalance: true });
-            tokenContract.create();
-            
-            mockAdapter.setQueryResult([{
-                symbol: 'TEST',
-                name: 'Test Token',
-                creator: 'alice',
-                precision: 3,
-                current_supply: '0',
-                max_supply: '1000000'
-            }]);
-
-            const payload = {
-                symbol: 'TEST',
-                to: 'bob',
-                amount: '100',
-                memo: 'Initial distribution'
-            };
-
-            await (tokenContract as any).issueTokens(payload, { sender: 'alice' });
-
-            const updateQuery = mockAdapter.queries.find(q => q.includes('UPDATE tokens SET current_supply'));
-            const insertQuery = mockAdapter.queries.find(q => q.includes('INSERT INTO token_balances'));
-            expect(updateQuery).toBeDefined();
-            expect(insertQuery).toBeDefined();
-            expect(mockAdapter.events.length).toBe(1);
-            expect(mockAdapter.events[0].action).toBe('issueTokens');
-        });
-
-        it('should reject issuance by non-creator', async () => {
-            mockAdapter.reset();
-            tokenContract.create();
-            
-            mockAdapter.setQueryResult([{
-                symbol: 'TEST',
-                name: 'Test Token',
-                creator: 'alice',
-                precision: 3,
-                current_supply: '0',
-                max_supply: '1000000'
-            }]);
-
-            const payload = {
-                symbol: 'TEST',
-                to: 'bob',
-                amount: '100'
-            };
-
-            await expect((tokenContract as any).issueTokens(payload, { sender: 'charlie' }))
-                .rejects.toThrow('Only the token creator can issue new tokens');
-        });
-
-        it('should reject issuance exceeding max supply', async () => {
-            mockAdapter.reset();
-            mockAdapter.setTestContext({ maxSupplyExceeded: true });
-            tokenContract.create();
-            
-            mockAdapter.setQueryResult([{
-                symbol: 'TEST',
-                name: 'Test Token',
-                creator: 'alice',
-                precision: 3,
-                current_supply: '999999',
-                max_supply: '1000000'
-            }]);
+    test('Creates a token', async () => {
+        const ctx = createContext(streamer, adapter, 'alice');
+        const payload = {
+            symbol: 'TEST',
+            name: 'Test Token',
+            url: 'https://example.com',
+            precision: 3,
+            maxSupply: '1000000'
+        };
 
-            const payload = {
-                symbol: 'TEST',
-                to: 'bob',
-                amount: '100'
-            };
+        await contract.actions.createToken.handler(payload, ctx);
 
-            await expect((tokenContract as any).issueTokens(payload, { sender: 'alice' }))
-                .rejects.toThrow('Cannot issue tokens: would exceed maximum supply');
-        });
+        expect(adapter.queries.join(' ')).toContain('INSERT INTO tokens');
+        expect(adapter.events.length).toBeGreaterThan(0);
+        expect(adapter.events[0].action).toBe('createToken');
     });
 
-    describe('transferTokens', () => {
-        it('should transfer tokens successfully', async () => {
-            mockAdapter.reset();
-            tokenContract.create();
-
-            const payload = {
-                symbol: 'TEST',
-                to: 'bob',
-                amount: '100',
-                memo: 'Payment'
-            };
-
-            await (tokenContract as any).transferTokens(payload, { sender: 'alice' });
-
-            const updateQuery = mockAdapter.queries.find(q => q.includes('UPDATE token_balances SET balance'));
-            const insertQuery = mockAdapter.queries.find(q => q.includes('INSERT INTO token_transfers'));
-            expect(updateQuery).toBeDefined();
-            expect(insertQuery).toBeDefined();
-            expect(mockAdapter.events.length).toBe(1);
-            expect(mockAdapter.events[0].action).toBe('transferTokens');
-        });
-
-        it('should reject transfer with insufficient balance', async () => {
-            mockAdapter.reset();
-            mockAdapter.setTestContext({ insufficientBalance: true });
-            tokenContract.create();
-
-            const payload = {
-                symbol: 'TEST',
-                to: 'bob',
-                amount: '100'
-            };
-
-            await expect((tokenContract as any).transferTokens(payload, { sender: 'alice' }))
-                .rejects.toThrow('Insufficient balance');
-        });
-
-        it('should reject transfer of non-existent token', async () => {
-            mockAdapter.reset();
-            mockAdapter.setTestContext({ nonExistentToken: 'NONEXISTENT' });
-            tokenContract.create();
-
-            const payload = {
-                symbol: 'NONEXISTENT',
-                to: 'bob',
-                amount: '100'
-            };
+    test('Rejects duplicate token symbols', async () => {
+        adapter.setTestContext({ existingToken: 'TEST' });
+        const ctx = createContext(streamer, adapter, 'alice');
+        const payload = {
+            symbol: 'TEST',
+            name: 'Test Token',
+            maxSupply: '1000000'
+        };
 
-            await expect((tokenContract as any).transferTokens(payload, { sender: 'alice' }))
-                .rejects.toThrow('Token NONEXISTENT does not exist');
-        });
+        await expect(contract.actions.createToken.handler(payload, ctx))
+            .rejects
+            .toThrow('Token with symbol TEST already exists');
     });
 
-    describe('getBalance', () => {
-        it('should return balance for existing account', async () => {
-            mockAdapter.reset();
-            tokenContract.create();
-            
-            mockAdapter.setQueryResult([{ balance: '500' }]);
-
-            const payload = {
-                account: 'alice',
-                symbol: 'TEST'
-            };
-
-            await (tokenContract as any).getBalance(payload, { sender: 'bob' });
-
-            const selectQuery = mockAdapter.queries.find(q => q.includes('SELECT balance FROM token_balances'));
-            expect(selectQuery).toBeDefined();
-            expect(mockAdapter.events.length).toBe(1);
-            expect(mockAdapter.events[0].action).toBe('getBalance');
-        });
-
-        it('should return zero balance for non-existent account', async () => {
-            mockAdapter.reset();
-            mockAdapter.setTestContext({ zeroBalance: true });
-            tokenContract.create();
-
-            const payload = {
-                account: 'alice',
-                symbol: 'TEST'
-            };
-
-            await (tokenContract as any).getBalance(payload, { sender: 'bob' });
+    test('Prevents non-creators from issuing tokens', async () => {
+        const ctx = createContext(streamer, adapter, 'bob');
+        const payload = {
+            symbol: 'TEST',
+            to: 'carol',
+            amount: '100'
+        };
 
-            expect(mockAdapter.events[0].data.data.balance).toBe('0');
-        });
+        await expect(contract.actions.issueTokens.handler(payload, ctx))
+            .rejects
+            .toThrow('Only the token creator can issue new tokens');
     });
 
-    describe('getTokenInfo', () => {
-        it('should return token information', async () => {
-            mockAdapter.reset();
-            tokenContract.create();
-            
-            const tokenData = {
-                symbol: 'TEST',
-                name: 'Test Token',
-                url: 'https://example.com/token',
-                precision: 3,
-                max_supply: '1000000',
-                current_supply: '500000',
-                creator: 'alice',
-                created_at: new Date()
-            };
-
-            mockAdapter.setQueryResult([tokenData]);
-
-            const payload = {
-                symbol: 'TEST'
-            };
-
-            await (tokenContract as any).getTokenInfo(payload, { sender: 'bob' });
-
-            const selectQuery = mockAdapter.queries.find(q => q.includes('SELECT * FROM tokens'));
-            expect(selectQuery).toBeDefined();
-            expect(mockAdapter.events.length).toBe(1);
-            expect(mockAdapter.events[0].action).toBe('getTokenInfo');
-            expect(mockAdapter.events[0].data.data.token_info).toEqual(tokenData);
-        });
-
-        it('should reject request for non-existent token', async () => {
-            mockAdapter.reset();
-            mockAdapter.setTestContext({ nonExistentToken: 'NONEXISTENT' });
-            tokenContract.create();
-
-            const payload = {
-                symbol: 'NONEXISTENT'
-            };
+    test('Prevents transfers with insufficient balance', async () => {
+        adapter.setTestContext({ insufficientBalance: true });
+        const ctx = createContext(streamer, adapter, 'alice');
+        const payload = {
+            symbol: 'TEST',
+            to: 'bob',
+            amount: '9999'
+        };
 
-            await expect((tokenContract as any).getTokenInfo(payload, { sender: 'bob' }))
-                .rejects.toThrow('Token NONEXISTENT does not exist');
-        });
+        await expect(contract.actions.transferTokens.handler(payload, ctx))
+            .rejects
+            .toThrow('Insufficient balance');
     });
-});
+});

package/tests/exchanges/coingecko.exchange.spec.ts

@@ -0,0 +1,169 @@
+import { CoinGeckoExchange } from '../../src/exchanges/coingecko';
+import { NetworkError, ValidationError } from '../../src/types/rates';
+import { mockSuccessfulApis, mockNetworkErrors, mockHttpErrors, mockInvalidResponses, cleanupMocks } from '../helpers/mock-fetch';
+
+describe('CoinGeckoExchange', () => {
+    let exchange: CoinGeckoExchange;
+
+    beforeEach(() => {
+        exchange = new CoinGeckoExchange();
+    });
+
+    afterEach(() => {
+        cleanupMocks();
+    });
+
+    describe('fetchRates', () => {
+        it('should fetch rates successfully', async () => {
+            mockSuccessfulApis();
+
+            const success = await exchange.fetchRates();
+
+            expect(success).toBe(true);
+            expect(exchange.rateUsdHive).toBe(0.25);
+            expect(exchange.rateUsdHbd).toBe(1.00);
+        });
+
+        it('should handle network errors', async () => {
+            mockNetworkErrors();
+
+            await expect(exchange.fetchRates()).rejects.toThrow(NetworkError);
+        });
+
+        it('should handle HTTP errors', async () => {
+            mockHttpErrors(500);
+
+            await expect(exchange.fetchRates()).rejects.toThrow(NetworkError);
+        });
+
+        it('should handle invalid JSON responses', async () => {
+            mockInvalidResponses();
+
+            await expect(exchange.fetchRates()).rejects.toThrow(ValidationError);
+        });
+
+        it('should retry on failure', async () => {
+            const retryExchange = new CoinGeckoExchange({ maxRetries: 3, retryDelay: 100 });
+            
+            // Mock first two calls to fail, third to succeed
+            let callCount = 0;
+            global.fetch = jest.fn().mockImplementation(() => {
+                callCount++;
+                if (callCount <= 2) {
+                    return Promise.reject(new Error('Network error'));
+                }
+                return Promise.resolve({
+                    ok: true,
+                    json: () => Promise.resolve({
+                        hive: { usd: 0.25 },
+                        'hive_dollar': { usd: 1.00 }
+                    })
+                });
+            });
+
+            const success = await retryExchange.updateRates();
+            
+            expect(success).toBe(true);
+            expect(retryExchange.rateUsdHive).toBe(0.25);
+            expect(callCount).toBe(3);
+        }, 10000); // Increase timeout for retry test
+
+        it('should respect timeout', async () => {
+            const timeoutExchange = new CoinGeckoExchange({ timeout: 100 });
+            
+            // Mock a delayed response
+            global.fetch = jest.fn().mockImplementation(() => 
+                new Promise((resolve) => {
+                    setTimeout(() => resolve({
+                        ok: true,
+                        json: () => Promise.resolve({ hive: { usd: 0.25 } })
+                    }), 200); // Longer than timeout
+                })
+            );
+
+            await expect(timeoutExchange.fetchRates()).rejects.toThrow();
+        });
+
+        it('should validate rate values', async () => {
+            // Mock response with invalid rates
+            global.fetch = jest.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({
+                    hive: { usd: -1 }, // Invalid negative rate
+                    'hive_dollar': { usd: 1.00 }
+                })
+            });
+
+            await expect(exchange.fetchRates()).rejects.toThrow(ValidationError);
+        });
+
+        it('should handle missing rate data', async () => {
+            // Mock response with missing hive data
+            global.fetch = jest.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({
+                    'hive_dollar': { usd: 1.00 }
+                    // Missing hive data
+                })
+            });
+
+            await expect(exchange.fetchRates()).rejects.toThrow(ValidationError);
+        });
+    });
+
+    describe('caching', () => {
+        it('should use cached rates when valid', async () => {
+            mockSuccessfulApis();
+
+            // First fetch
+            const rates1 = await exchange.updateRates();
+            
+            // Second fetch should use cache
+            const rates2 = await exchange.updateRates();
+
+            expect(rates1).toBe(true);
+            expect(rates2).toBe(false);
+            expect(global.fetch).toHaveBeenCalledTimes(1);
+        });
+
+        it('should refresh cache when expired', async () => {
+            const shortCacheExchange = new CoinGeckoExchange({ cacheDuration: 100 });
+            mockSuccessfulApis();
+
+            // First fetch
+            await shortCacheExchange.updateRates();
+
+            // Wait for cache to expire
+            await new Promise(resolve => setTimeout(resolve, 150));
+
+            // Second fetch should hit API again
+            await shortCacheExchange.updateRates();
+
+            expect(global.fetch).toHaveBeenCalledTimes(2);
+        });
+
+        it('should report cache validity correctly', async () => {
+            mockSuccessfulApis();
+
+            expect(exchange.isCacheValid()).toBe(false);
+
+            await exchange.updateRates();
+            
+            expect(exchange.isCacheValid()).toBe(true);
+        });
+
+        it('should report last fetch time', async () => {
+            mockSuccessfulApis();
+
+            expect(exchange.getLastFetchTime()).toBeUndefined();
+
+            const beforeFetch = Date.now();
+            await exchange.updateRates();
+            const afterFetch = Date.now();
+
+            const lastFetchTime = exchange.getLastFetchTime();
+            expect(lastFetchTime).toBeGreaterThanOrEqual(beforeFetch);
+            expect(lastFetchTime).toBeLessThanOrEqual(afterFetch);
+        });
+    });
+});