Test AI-reworked tx test runner to bundle test cases in batches to avoid CI overload/timeout

Author: holgerd77

packages/tx/test/transactionRunner.spec.ts

@@ -55,59 +55,112 @@ const EIPs: Record<string, number[] | undefined> = {
 
 describe('TransactionTests', async () => {
   const fileFilterRegex = file !== undefined ? new RegExp(file + '[^\\w]') : undefined
-  await getTests(
-    (
-      _filename: string,
-      subDir: string,
-      testName: string,
-      testData: OfficialTransactionTestData,
-    ) => {
-      for (const forkName of forkNames) {
-        if (testData.result[forkName] === undefined) {
-          continue
-        }
-        it(`${testName} - [${forkName}]`, () => {
-          const forkTestData = testData.result[forkName]
-          const shouldBeInvalid = forkTestData.exception !== undefined
-
-          const rawTx = hexToBytes(testData.txbytes as PrefixedHexString)
-          const hardfork = forkNameMap[forkName]
-          const common = new Common({ chain: Mainnet, hardfork })
-          const activateEIPs = EIPs[forkName]
-          if (activateEIPs !== undefined) {
-            common.setEIPs(activateEIPs)
-          }
 
-          let tx
-          let sender
-          let hash
-          let isValid
-          try {
-            tx = createTxFromRLP(rawTx, { common })
-            sender = tx.getSenderAddress().toString()
-            hash = bytesToHex(tx.hash())
-            if (!tx.isValid()) {
-              throw EthereumJSErrorWithoutCode('Tx is invalid')
-            }
-            isValid = true
-          } catch {
-            if (!shouldBeInvalid) {
-              assert.fail('Tx creation threw an error, but should be valid')
-            }
-            // Tx is correctly marked as "invalid", so test has passed
-            return
-          }
+  // Collect all test data first to batch tests more efficiently
+  const testDataCollection: Array<{
+    filename: string
+    subDir: string
+    testName: string
+    testData: OfficialTransactionTestData
+  }> = []
 
-          const senderIsCorrect = forkTestData.sender === sender
-          const hashIsCorrect = forkTestData.hash === hash
-          assert.isTrue(isValid, 'tx is valid')
-          assert.isTrue(senderIsCorrect, 'sender is correct')
-          assert.isTrue(hashIsCorrect, 'hash is correct')
-        }, 120000)
-      }
+  await getTests(
+    (filename: string, subDir: string, testName: string, testData: OfficialTransactionTestData) => {
+      testDataCollection.push({ filename, subDir, testName, testData })
     },
     fileFilterRegex,
     undefined,
     'TransactionTests',
   )
+
+  // Process tests in batches to reduce worker load
+  const BATCH_SIZE = 50
+  for (let i = 0; i < testDataCollection.length; i += BATCH_SIZE) {
+    const batch = testDataCollection.slice(i, i + BATCH_SIZE)
+
+    describe(`Batch ${Math.floor(i / BATCH_SIZE) + 1}`, () => {
+      for (const { testName, testData } of batch) {
+        // Group tests by test name to reduce individual test count
+        it(`${testName}`, () => {
+          const results: Array<{ fork: string; passed: boolean; error?: string }> = []
+
+          for (const forkName of forkNames) {
+            if (testData.result[forkName] === undefined) {
+              continue
+            }
+
+            try {
+              const forkTestData = testData.result[forkName]
+              const shouldBeInvalid = forkTestData.exception !== undefined
+
+              const rawTx = hexToBytes(testData.txbytes as PrefixedHexString)
+              const hardfork = forkNameMap[forkName]
+              const common = new Common({ chain: Mainnet, hardfork })
+              const activateEIPs = EIPs[forkName]
+              if (activateEIPs !== undefined) {
+                common.setEIPs(activateEIPs)
+              }
+
+              let tx
+              let sender
+              let hash
+              let isValid
+              try {
+                tx = createTxFromRLP(rawTx, { common })
+                sender = tx.getSenderAddress().toString()
+                hash = bytesToHex(tx.hash())
+                if (!tx.isValid()) {
+                  throw EthereumJSErrorWithoutCode('Tx is invalid')
+                }
+                isValid = true
+              } catch {
+                if (!shouldBeInvalid) {
+                  results.push({
+                    fork: forkName,
+                    passed: false,
+                    error: 'Tx creation threw an error, but should be valid',
+                  })
+                  continue
+                }
+                // Tx is correctly marked as "invalid", so test has passed
+                results.push({ fork: forkName, passed: true })
+                continue
+              }
+
+              const senderIsCorrect = forkTestData.sender === sender
+              const hashIsCorrect = forkTestData.hash === hash
+
+              if (!isValid) {
+                results.push({ fork: forkName, passed: false, error: 'tx is not valid' })
+                continue
+              }
+              if (!senderIsCorrect) {
+                results.push({ fork: forkName, passed: false, error: 'sender is not correct' })
+                continue
+              }
+              if (!hashIsCorrect) {
+                results.push({ fork: forkName, passed: false, error: 'hash is not correct' })
+                continue
+              }
+
+              results.push({ fork: forkName, passed: true })
+            } catch (error) {
+              results.push({
+                fork: forkName,
+                passed: false,
+                error: error instanceof Error ? error.message : String(error),
+              })
+            }
+          }
+
+          // Check if all fork tests passed
+          const failedResults = results.filter((r) => !r.passed)
+          if (failedResults.length > 0) {
+            const errorMessages = failedResults.map((r) => `${r.fork}: ${r.error}`).join('; ')
+            assert.fail(`Test failed for forks: ${errorMessages}`)
+          }
+        }, 300000) // Increased timeout for batched tests
+      }
+    })
+  }
 })