Change testing framework to vitest

Author: kalabukdima

evm/evm-rpc/package.json

@@ -14,9 +14,8 @@
   "main": "lib/index.js",
   "scripts": {
     "build": "rm -rf lib && tsc",
-    "test": "tsc --noEmit -p tsconfig.test.json && npx tsx --test test/**/*.test.ts",
-    "test:verification": "npx tsx --test test/verification.test.ts",
-    "test:rpc": "npx tsx --test test/rpc.test.ts",
+    "lint": "tsc --noEmit -p tsconfig.test.json",
+    "test": "vitest --run",
     "capture-fixture": "npx tsx test/capture-fixtures.ts"
   },
   "dependencies": {
@@ -40,6 +39,7 @@
     "@types/node": "^20.10.0",
     "@types/secp256k1": "4.0.6",
     "tsx": "^4.7.0",
-    "typescript": "5.5.4"
+    "typescript": "5.5.4",
+    "vitest": "^1.4.0"
   }
 }

evm/evm-rpc/test/rpc.test.ts

@@ -1,5 +1,4 @@
-import {it, describe} from 'node:test'
-import assert from 'assert'
+import {describe, it, expect} from 'vitest'
 import {loadBlock, loadReceipts} from './helpers/fixture-loader'
 import {MockRpcClient} from './helpers/mock-rpc-client'
 import {Rpc} from '../src/rpc'
@@ -18,10 +17,10 @@ describe('Rpc Class Integration', () => {
             const rpc = new Rpc({client: mockClient as any})
 
             const blocks = await rpc.getBlockBatch([18000000], {transactions: true})
-            assert.ok(blocks, 'Blocks should be returned')
-            assert.equal(blocks.length, 1)
-            assert.ok(blocks[0].block, 'Block should have block property')
-            assert.equal(blocks[0].block.number, fixtureBlock.number)
+            expect(blocks).toBeTruthy()
+            expect(blocks.length).toEqual(1)
+            expect(blocks[0].block).toBeTruthy()
+            expect(blocks[0].block.number).toEqual(fixtureBlock.number)
         })
 
         it('getBlockBatch without transactions returns blocks with tx hashes only', async () => {
@@ -35,8 +34,8 @@ describe('Rpc Class Integration', () => {
             const rpc = new Rpc({client: mockClient as any})
 
             const blocks = await rpc.getBlockBatch([18000000])
-            assert.ok(blocks, 'Blocks should be returned')
-            assert.equal(blocks.length, 1)
+            expect(blocks).toBeTruthy()
+            expect(blocks.length).toEqual(1)
         })
 
         it('getBlockBatch handles missing blocks', async () => {
@@ -47,7 +46,7 @@ describe('Rpc Class Integration', () => {
             const rpc = new Rpc({client: mockClient as any})
 
             const blocks = await rpc.getBlockBatch([99999999], {transactions: true})
-            assert.equal(blocks.length, 0, 'Missing blocks should be filtered out')
+            expect(blocks.length).toEqual(0)
         })
     })
 
@@ -65,10 +64,10 @@ describe('Rpc Class Integration', () => {
             const rpc = new Rpc({client: mockClient as any})
 
             const blocks = await rpc.getBlockBatch([18000000], {receipts: true, transactions: true})
-            assert.ok(blocks, 'Blocks should be returned')
-            assert.equal(blocks.length, 1)
-            assert.ok(blocks[0].receipts, 'Block should have receipts attached')
-            assert.ok(blocks[0].receipts!.length > 0, 'Receipts should not be empty')
+            expect(blocks).toBeTruthy()
+            expect(blocks.length).toEqual(1)
+            expect(blocks[0].receipts).toBeTruthy()
+            expect(blocks[0].receipts!.length).toBeGreaterThan(0)
         })
     })
 
@@ -86,8 +85,8 @@ describe('Rpc Class Integration', () => {
             })
 
             const blocks = await rpc.getBlockBatch([18000000], {transactions: true})
-            assert.ok(blocks, 'Blocks should be returned after verification')
-            assert.equal(blocks.length, 1)
+            expect(blocks).toBeTruthy()
+            expect(blocks.length).toEqual(1)
         })
 
         it('verifies transactions root when enabled', async () => {
@@ -103,8 +102,8 @@ describe('Rpc Class Integration', () => {
             })
 
             const blocks = await rpc.getBlockBatch([18000000], {transactions: true})
-            assert.ok(blocks, 'Blocks should be returned after tx root verification')
-            assert.equal(blocks.length, 1)
+            expect(blocks).toBeTruthy()
+            expect(blocks.length).toEqual(1)
         })
 
         it('detects invalid block hash', async () => {
@@ -120,16 +119,9 @@ describe('Rpc Class Integration', () => {
                 verifyBlockHash: true
             })
 
-            await assert.rejects(
-                () => rpc.getBlockBatch([18000000], {transactions: true}),
-                (error: any) => {
-                    assert.ok(
-                        error.message.includes('failed to verify') || error.message.includes('hash'),
-                        'Error should be about hash verification'
-                    )
-                    return true
-                }
-            )
+            await expect(
+                rpc.getBlockBatch([18000000], {transactions: true})
+            ).rejects.toThrow()
         })
     })
 
@@ -147,8 +139,8 @@ describe('Rpc Class Integration', () => {
             })
 
             const blocks = await rpc.getBlockBatch([50000000], {transactions: true})
-            assert.ok(blocks, 'Blocks should be returned')
-            assert.equal(blocks.length, 1)
+            expect(blocks).toBeTruthy()
+            expect(blocks.length).toEqual(1)
         })
 
         it('handles Arbitrum transaction types correctly', async () => {
@@ -164,8 +156,8 @@ describe('Rpc Class Integration', () => {
             })
 
             const blocks = await rpc.getBlockBatch([150000000], {transactions: true})
-            assert.ok(blocks, 'Blocks should be returned')
-            assert.equal(blocks.length, 1)
+            expect(blocks).toBeTruthy()
+            expect(blocks.length).toEqual(1)
         })
 
         it('handles Hyperliquid system transactions correctly', async () => {
@@ -181,8 +173,8 @@ describe('Rpc Class Integration', () => {
             })
 
             const blocks = await rpc.getBlockBatch([50000], {transactions: true})
-            assert.ok(blocks, 'Blocks should be returned')
-            assert.equal(blocks.length, 1)
+            expect(blocks).toBeTruthy()
+            expect(blocks.length).toEqual(1)
         })
     })
 })

evm/evm-rpc/test/verification.test.ts

@@ -1,5 +1,4 @@
-import {it, describe} from 'node:test'
-import assert from 'assert'
+import {describe, it, expect} from 'vitest'
 import {loadBlock, loadReceipts, hasReceipts, listFixtures, getChainId} from './helpers/fixture-loader'
 import {blockHash} from '../src/verification'
 import {ChainUtils} from '../src/chain-utils'
@@ -12,7 +11,7 @@ describe('Verification Functions', () => {
             it('blockHash verification', async () => {
                 const block = loadBlock(fixture.chain, fixture.blockNumber)
                 const computed = await blockHash(block)
-                assert.equal(computed, block.hash, `Block hash mismatch for ${fixture.name}`)
+                expect(computed).toEqual(block.hash)
             })
 
             it('transactionsRoot verification', async () => {
@@ -22,7 +21,7 @@ describe('Verification Functions', () => {
                 const chainId = getChainId(fixture.chain)
                 const utils = new ChainUtils(chainId)
                 const computed = await utils.calculateTransactionsRoot(block)
-                assert.equal(computed, block.transactionsRoot, `Transactions root mismatch for ${fixture.name}`)
+                expect(computed).toEqual(block.transactionsRoot)
             })
 
             if (hasReceipts(fixture.chain, fixture.blockNumber)) {
@@ -32,7 +31,7 @@ describe('Verification Functions', () => {
                     const chainId = getChainId(fixture.chain)
                     const utils = new ChainUtils(chainId)
                     const computed = await utils.calculateReceiptsRoot(block, receipts)
-                    assert.equal(computed, block.receiptsRoot, `Receipts root mismatch for ${fixture.name}`)
+                    expect(computed).toEqual(block.receiptsRoot)
                 })
 
                 it('logsBloom verification', async () => {
@@ -42,7 +41,7 @@ describe('Verification Functions', () => {
                     const chainId = getChainId(fixture.chain)
                     const utils = new ChainUtils(chainId)
                     const computed = utils.calculateLogsBloom(block, logs)
-                    assert.equal(computed, block.logsBloom, `Logs bloom mismatch for ${fixture.name}`)
+                    expect(computed).toEqual(block.logsBloom)
                 })
             }
 
@@ -61,11 +60,7 @@ describe('Verification Functions', () => {
 
                     const recovered = utils.recoverTxSender(tx)
                     if (recovered) {
-                        assert.equal(
-                            recovered.toLowerCase(),
-                            tx.from.toLowerCase(),
-                            `Sender mismatch for tx ${tx.hash} in ${fixture.name}`
-                        )
+                        expect(recovered.toLowerCase()).toEqual(tx.from.toLowerCase())
                     }
                 }
             })