From 99c60ebb9cc35de8a734a01185da149becda8ed9 Mon Sep 17 00:00:00 2001 From: sina haseli Date: Fri, 13 Dec 2024 22:23:16 +0330 Subject: [PATCH] Add tests for debug tracing methods --- eth/tracers/api_test.go | 420 ++++++++++++++++++++++++++++++++++++++++ 1 file changed, 420 insertions(+) diff --git a/eth/tracers/api_test.go b/eth/tracers/api_test.go index e786853ede..98687131ff 100644 --- a/eth/tracers/api_test.go +++ b/eth/tracers/api_test.go @@ -23,8 +23,10 @@ import ( "errors" "fmt" "math/big" + "os" "reflect" "slices" + "strings" "sync/atomic" "testing" "time" @@ -45,6 +47,7 @@ import ( "github.com/ethereum/go-ethereum/ethdb" "github.com/ethereum/go-ethereum/internal/ethapi" "github.com/ethereum/go-ethereum/params" + "github.com/ethereum/go-ethereum/rlp" "github.com/ethereum/go-ethereum/rpc" ) @@ -547,6 +550,111 @@ func TestTraceTransaction(t *testing.T) { } } +func TestTraceBlockFromFile(t *testing.T) { + t.Parallel() + + // Set up test accounts and a simple genesis block + accounts := newAccounts(2) + genesis := &core.Genesis{ + Config: params.TestChainConfig, + Alloc: types.GenesisAlloc{ + accounts[0].addr: {Balance: big.NewInt(params.Ether)}, + }, + } + genBlock := 3 + signer := types.HomesteadSigner{} + backend := newTestBackend(nil, genBlock, genesis, func(i int, b *core.BlockGen) { + // Add a simple transaction to the block + tx, _ := types.SignTx(types.NewTx(&types.LegacyTx{ + Nonce: uint64(i), + To: &accounts[1].addr, + Value: big.NewInt(1000), + Gas: params.TxGas, + GasPrice: b.BaseFee(), + Data: nil, + }), signer, accounts[0].key) + b.AddTx(tx) + }) + + defer backend.teardown() + + api := NewAPI(backend) + + var testCases = []struct { + name string + file string + setupFile func(file string) // Optional setup for the file + expectErr bool + expected common.Hash // Expected trace results + expectMsg string // For error assertions + }{ + { + name: "Valid trace from file", + file: "valid_block.rlp", + setupFile: func(file string) { + createTestFile(file, validBlockData(backend.chain.GetBlockByNumber(backend.chain.CurrentBlock().Number.Uint64()))) + }, + expected: backend.chain.GetBlockByNumber(backend.chain.CurrentBlock().Number.Uint64()).Transactions()[0].Hash(), + }, + { + name: "File not found", + file: "non_existent_file.rlp", + expectErr: true, + expectMsg: "could not read file", + }, + { + name: "Invalid block data", + file: "invalid_block.rlp", + setupFile: func(file string) { + createTestFile(file, []byte("invalid data")) + }, + expectErr: true, + expectMsg: "could not decode block", + }, + } + + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + if tc.setupFile != nil { + defer os.Remove(tc.file) // Clean up + tc.setupFile(tc.file) + } + + ctx := context.Background() + result, err := api.TraceBlockFromFile(ctx, tc.file, nil) + fmt.Println(&result) + + if tc.expectErr { + if err == nil || !strings.Contains(err.Error(), tc.expectMsg) { + t.Fatalf("expected error containing '%s', got '%v'", tc.expectMsg, err) + } + return + } + + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + + if !reflect.DeepEqual(result[0].TxHash, tc.expected) { + t.Errorf("result mismatch, want %v, got %v", tc.expected, result) + } + }) + } +} + +func createTestFile(name string, data []byte) { + _ = os.WriteFile(name, data, 0644) +} + +func validBlockData(block *types.Block) []byte { + // Fetch the first block and RLP encode it + encodedBlock, err := rlp.EncodeToBytes(block) + if err != nil { + panic(fmt.Errorf("failed to encode block: %v", err)) + } + return encodedBlock +} + func TestTraceBlock(t *testing.T) { t.Parallel() @@ -637,6 +745,318 @@ func TestTraceBlock(t *testing.T) { } } +func TestTraceBadBlock(t *testing.T) { + t.Parallel() + + // Setup a test backend with valid transactions + accounts := newAccounts(2) + genesis := &core.Genesis{ + Config: params.TestChainConfig, + Alloc: types.GenesisAlloc{ + accounts[0].addr: {Balance: big.NewInt(params.Ether)}, + }, + } + signer := types.HomesteadSigner{} + var badBlockHash, genesisHash common.Hash + + backend := newTestBackend(t, 2, genesis, func(i int, b *core.BlockGen) { + tx, _ := types.SignTx(types.NewTx(&types.LegacyTx{ + Nonce: uint64(i), + To: &accounts[1].addr, + Value: big.NewInt(1000), + Gas: params.TxGas, + GasPrice: b.BaseFee(), + Data: nil, + }), signer, accounts[0].key) + b.AddTx(tx) + }) + defer backend.teardown() + + // Add the genesis block to the bad block database + genesisBlock := backend.chain.GetBlockByNumber(0) + if genesisBlock == nil { + t.Fatalf("failed to fetch genesis block") + } + genesisHash = genesisBlock.Hash() + rawdb.WriteBadBlock(backend.chaindb, genesisBlock) + + // Create a bad block by corrupting the first block after genesis + badBlock := backend.chain.GetBlockByNumber(1) + if badBlock == nil { + t.Fatalf("failed to fetch block 1") + } + badBlock.Header().ParentHash = common.HexToHash("0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef") // Simulate corruption + badBlockHash = badBlock.Hash() + rawdb.WriteBadBlock(backend.chaindb, badBlock) + + // Test cases + api := NewAPI(backend) + var testCases = []struct { + name string + hash common.Hash + expectErr bool + expectMsg string + }{ + { + name: "Genesis block", + hash: genesisHash, + expectErr: true, + expectMsg: "genesis is not traceable", + }, + { + name: "Valid bad block", + hash: badBlockHash, + expectErr: false, + }, + { + name: "Non-existent block", + hash: common.HexToHash("0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"), + expectErr: true, + expectMsg: fmt.Sprintf("block %s not found", common.HexToHash("0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef")), + }, + } + + // Execute test cases + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + ctx := context.Background() + result, err := api.TraceBadBlock(ctx, tc.hash, nil) + + if tc.expectErr { + if err == nil || !strings.Contains(err.Error(), tc.expectMsg) { + t.Fatalf("expected error containing '%s', got: %v", tc.expectMsg, err) + } + return + } + + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + + if tc.name == "Valid bad block" && len(result) == 0 { + t.Fatalf("expected trace results for bad block, got none") + } + }) + } +} + +func TestStandardTraceBadBlockToFile(t *testing.T) { + t.Parallel() + + // Setup a test backend with valid transactions + accounts := newAccounts(2) + genesis := &core.Genesis{ + Config: params.TestChainConfig, + Alloc: types.GenesisAlloc{ + accounts[0].addr: {Balance: big.NewInt(params.Ether)}, + }, + } + signer := types.HomesteadSigner{} + var badBlockHash common.Hash + + backend := newTestBackend(t, 2, genesis, func(i int, b *core.BlockGen) { + tx, _ := types.SignTx(types.NewTx(&types.LegacyTx{ + Nonce: uint64(i), + To: &accounts[1].addr, + Value: big.NewInt(1000), + Gas: params.TxGas, + GasPrice: b.BaseFee(), + Data: nil, + }), signer, accounts[0].key) + b.AddTx(tx) + }) + defer backend.teardown() + + // Create a bad block by corrupting the first block after genesis + badBlock := backend.chain.GetBlockByNumber(1) + if badBlock == nil { + t.Fatalf("failed to fetch block 1") + } + badBlock.Header().ParentHash = common.HexToHash("0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef") // Simulate corruption + badBlockHash = badBlock.Hash() + rawdb.WriteBadBlock(backend.chaindb, badBlock) + + // Test cases + api := NewAPI(backend) + var testCases = []struct { + name string + hash common.Hash + config *StdTraceConfig + expectErr bool + expectMsg string + validateFn func(files []string) + }{ + { + name: "Valid bad block", + hash: badBlockHash, + config: nil, // Use default StdTraceConfig + expectErr: false, + validateFn: func(files []string) { + if len(files) == 0 { + t.Fatalf("expected at least one output file, got none") + } + for _, file := range files { + if _, err := os.Stat(file); os.IsNotExist(err) { + t.Fatalf("expected output file %s to exist", file) + } + // Clean up the file after test + os.Remove(file) + } + }, + }, + { + name: "Non-existent block", + hash: common.HexToHash("0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"), + config: nil, + expectErr: true, + expectMsg: fmt.Sprintf("block %s not found", common.HexToHash("0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef")), + }, + } + + // Execute test cases + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + ctx := context.Background() + files, err := api.StandardTraceBadBlockToFile(ctx, tc.hash, tc.config) + + if tc.expectErr { + if err == nil || !strings.Contains(err.Error(), tc.expectMsg) { + t.Fatalf("expected error containing '%s', got: %v", tc.expectMsg, err) + } + return + } + + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + + // Validate the output files + if tc.validateFn != nil { + tc.validateFn(files) + } + }) + } +} + +func TestIntermediateRoots(t *testing.T) { + t.Parallel() + + // Setup a test backend with valid transactions + accounts := newAccounts(2) + genesis := &core.Genesis{ + Config: params.TestChainConfig, + Alloc: types.GenesisAlloc{ + accounts[0].addr: {Balance: big.NewInt(params.Ether)}, + }, + } + signer := types.HomesteadSigner{} + var badBlockHash, genesisHash common.Hash + + backend := newTestBackend(t, 2, genesis, func(i int, b *core.BlockGen) { + tx, _ := types.SignTx(types.NewTx(&types.LegacyTx{ + Nonce: uint64(i), + To: &accounts[1].addr, + Value: big.NewInt(1000), + Gas: params.TxGas, + GasPrice: b.BaseFee(), + Data: nil, + }), signer, accounts[0].key) + b.AddTx(tx) + }) + defer backend.teardown() + + // Fetch a valid block and store its hash + validBlock := backend.chain.GetBlockByNumber(1) + if validBlock == nil { + t.Fatalf("failed to fetch block 1") + } + // validBlockHash = validBlock.Hash() + + // Corrupt the valid block to create a bad block + badBlock := backend.chain.GetBlockByNumber(1) + badBlock.Header().ParentHash = common.HexToHash("0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef") + badBlockHash = badBlock.Hash() + rawdb.WriteBadBlock(backend.chaindb, badBlock) + + // Add the genesis block for testing + genesisBlock := backend.chain.GetBlockByNumber(0) + genesisHash = genesisBlock.Hash() + + // Test cases + api := NewAPI(backend) + var testCases = []struct { + name string + hash common.Hash + config *TraceConfig + expectErr bool + expectMsg string + validateFn func(roots []common.Hash) + }{ + // { + // name: "Valid block", + // hash: validBlockHash, + // config: nil, // Default TraceConfig + // expectErr: false, + // validateFn: func(roots []common.Hash) { + // if len(roots) == 0 { + // t.Fatalf("expected non-empty intermediate roots, got none") + // } + // if roots[len(roots)-1] != validBlock.Root() { + // t.Fatalf("final intermediate root does not match block state root") + // } + // }, + // }, + { + name: "Bad block", + hash: badBlockHash, + config: nil, + expectErr: false, + validateFn: func(roots []common.Hash) { + if len(roots) == 0 { + t.Fatalf("expected non-empty intermediate roots, got none") + } + }, + }, + { + name: "Genesis block", + hash: genesisHash, + config: nil, + expectErr: true, + expectMsg: "genesis is not traceable", + }, + { + name: "Non-existent block", + hash: common.HexToHash("0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef"), + config: nil, + expectErr: true, + expectMsg: fmt.Sprintf("block %s not found", common.HexToHash("0xdeadbeefdeadbeefdeadbeefdeadbeefdeadbeef")), + }, + } + + // Execute test cases + for _, tc := range testCases { + t.Run(tc.name, func(t *testing.T) { + ctx := context.Background() + roots, err := api.IntermediateRoots(ctx, tc.hash, tc.config) + + if tc.expectErr { + if err == nil || !strings.Contains(err.Error(), tc.expectMsg) { + t.Fatalf("expected error containing '%s', got: %v", tc.expectMsg, err) + } + return + } + + if err != nil { + t.Fatalf("unexpected error: %v", err) + } + + if tc.validateFn != nil { + tc.validateFn(roots) + } + }) + } +} + func TestTracingWithOverrides(t *testing.T) { t.Parallel() // Initialize test accounts