helper_test.go 6.9 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202
  1. // Copyright 2015 The go-ethereum Authors
  2. // This file is part of the go-ethereum library.
  3. //
  4. // The go-ethereum library is free software: you can redistribute it and/or modify
  5. // it under the terms of the GNU Lesser General Public License as published by
  6. // the Free Software Foundation, either version 3 of the License, or
  7. // (at your option) any later version.
  8. //
  9. // The go-ethereum library is distributed in the hope that it will be useful,
  10. // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11. // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12. // GNU Lesser General Public License for more details.
  13. //
  14. // You should have received a copy of the GNU Lesser General Public License
  15. // along with the go-ethereum library. If not, see <http://www.gnu.org/licenses/>.
  16. // This file contains some shares testing functionality, common to multiple
  17. // different files and modules being tested.
  18. package eth
  19. import (
  20. "crypto/ecdsa"
  21. "crypto/rand"
  22. "math/big"
  23. "sort"
  24. "sync"
  25. "testing"
  26. "github.com/ethereum/go-ethereum/common"
  27. "github.com/ethereum/go-ethereum/consensus/ethash"
  28. "github.com/ethereum/go-ethereum/core"
  29. "github.com/ethereum/go-ethereum/core/types"
  30. "github.com/ethereum/go-ethereum/core/vm"
  31. "github.com/ethereum/go-ethereum/crypto"
  32. "github.com/ethereum/go-ethereum/eth/downloader"
  33. "github.com/ethereum/go-ethereum/ethdb"
  34. "github.com/ethereum/go-ethereum/event"
  35. "github.com/ethereum/go-ethereum/p2p"
  36. "github.com/ethereum/go-ethereum/p2p/discover"
  37. "github.com/ethereum/go-ethereum/params"
  38. )
  39. var (
  40. testBankKey, _ = crypto.HexToECDSA("b71c71a67e1177ad4e901695e1b4b9ee17ae16c6668d313eac2f96dbcda3f291")
  41. testBank = crypto.PubkeyToAddress(testBankKey.PublicKey)
  42. )
  43. // newTestProtocolManager creates a new protocol manager for testing purposes,
  44. // with the given number of blocks already known, and potential notification
  45. // channels for different events.
  46. func newTestProtocolManager(mode downloader.SyncMode, blocks int, generator func(int, *core.BlockGen), newtx chan<- []*types.Transaction) (*ProtocolManager, *ethdb.MemDatabase, error) {
  47. var (
  48. evmux = new(event.TypeMux)
  49. engine = ethash.NewFaker()
  50. db = ethdb.NewMemDatabase()
  51. gspec = &core.Genesis{
  52. Config: params.TestChainConfig,
  53. Alloc: core.GenesisAlloc{testBank: {Balance: big.NewInt(1000000)}},
  54. }
  55. genesis = gspec.MustCommit(db)
  56. blockchain, _ = core.NewBlockChain(db, nil, gspec.Config, engine, vm.Config{})
  57. )
  58. chain, _ := core.GenerateChain(gspec.Config, genesis, ethash.NewFaker(), db, blocks, generator)
  59. if _, err := blockchain.InsertChain(chain); err != nil {
  60. panic(err)
  61. }
  62. pm, err := NewProtocolManager(gspec.Config, mode, DefaultConfig.NetworkId, evmux, &testTxPool{added: newtx}, engine, blockchain, db)
  63. if err != nil {
  64. return nil, nil, err
  65. }
  66. pm.Start(1000)
  67. return pm, db, nil
  68. }
  69. // newTestProtocolManagerMust creates a new protocol manager for testing purposes,
  70. // with the given number of blocks already known, and potential notification
  71. // channels for different events. In case of an error, the constructor force-
  72. // fails the test.
  73. func newTestProtocolManagerMust(t *testing.T, mode downloader.SyncMode, blocks int, generator func(int, *core.BlockGen), newtx chan<- []*types.Transaction) (*ProtocolManager, *ethdb.MemDatabase) {
  74. pm, db, err := newTestProtocolManager(mode, blocks, generator, newtx)
  75. if err != nil {
  76. t.Fatalf("Failed to create protocol manager: %v", err)
  77. }
  78. return pm, db
  79. }
  80. // testTxPool is a fake, helper transaction pool for testing purposes
  81. type testTxPool struct {
  82. txFeed event.Feed
  83. pool []*types.Transaction // Collection of all transactions
  84. added chan<- []*types.Transaction // Notification channel for new transactions
  85. lock sync.RWMutex // Protects the transaction pool
  86. }
  87. // AddRemotes appends a batch of transactions to the pool, and notifies any
  88. // listeners if the addition channel is non nil
  89. func (p *testTxPool) AddRemotes(txs []*types.Transaction) []error {
  90. p.lock.Lock()
  91. defer p.lock.Unlock()
  92. p.pool = append(p.pool, txs...)
  93. if p.added != nil {
  94. p.added <- txs
  95. }
  96. return make([]error, len(txs))
  97. }
  98. // Pending returns all the transactions known to the pool
  99. func (p *testTxPool) Pending() (map[common.Address]types.Transactions, error) {
  100. p.lock.RLock()
  101. defer p.lock.RUnlock()
  102. batches := make(map[common.Address]types.Transactions)
  103. for _, tx := range p.pool {
  104. from, _ := types.Sender(types.HomesteadSigner{}, tx)
  105. batches[from] = append(batches[from], tx)
  106. }
  107. for _, batch := range batches {
  108. sort.Sort(types.TxByNonce(batch))
  109. }
  110. return batches, nil
  111. }
  112. func (p *testTxPool) SubscribeNewTxsEvent(ch chan<- core.NewTxsEvent) event.Subscription {
  113. return p.txFeed.Subscribe(ch)
  114. }
  115. // newTestTransaction create a new dummy transaction.
  116. func newTestTransaction(from *ecdsa.PrivateKey, nonce uint64, datasize int) *types.Transaction {
  117. tx := types.NewTransaction(nonce, common.Address{}, big.NewInt(0), 100000, big.NewInt(0), make([]byte, datasize))
  118. tx, _ = types.SignTx(tx, types.HomesteadSigner{}, from)
  119. return tx
  120. }
  121. // testPeer is a simulated peer to allow testing direct network calls.
  122. type testPeer struct {
  123. net p2p.MsgReadWriter // Network layer reader/writer to simulate remote messaging
  124. app *p2p.MsgPipeRW // Application layer reader/writer to simulate the local side
  125. *peer
  126. }
  127. // newTestPeer creates a new peer registered at the given protocol manager.
  128. func newTestPeer(name string, version int, pm *ProtocolManager, shake bool) (*testPeer, <-chan error) {
  129. // Create a message pipe to communicate through
  130. app, net := p2p.MsgPipe()
  131. // Generate a random id and create the peer
  132. var id discover.NodeID
  133. rand.Read(id[:])
  134. peer := pm.newPeer(version, p2p.NewPeer(id, name, nil), net)
  135. // Start the peer on a new thread
  136. errc := make(chan error, 1)
  137. go func() {
  138. select {
  139. case pm.newPeerCh <- peer:
  140. errc <- pm.handle(peer)
  141. case <-pm.quitSync:
  142. errc <- p2p.DiscQuitting
  143. }
  144. }()
  145. tp := &testPeer{app: app, net: net, peer: peer}
  146. // Execute any implicitly requested handshakes and return
  147. if shake {
  148. var (
  149. genesis = pm.blockchain.Genesis()
  150. head = pm.blockchain.CurrentHeader()
  151. td = pm.blockchain.GetTd(head.Hash(), head.Number.Uint64())
  152. )
  153. tp.handshake(nil, td, head.Hash(), genesis.Hash())
  154. }
  155. return tp, errc
  156. }
  157. // handshake simulates a trivial handshake that expects the same state from the
  158. // remote side as we are simulating locally.
  159. func (p *testPeer) handshake(t *testing.T, td *big.Int, head common.Hash, genesis common.Hash) {
  160. msg := &statusData{
  161. ProtocolVersion: uint32(p.version),
  162. NetworkId: DefaultConfig.NetworkId,
  163. TD: td,
  164. CurrentBlock: head,
  165. GenesisBlock: genesis,
  166. }
  167. if err := p2p.ExpectMsg(p.app, StatusMsg, msg); err != nil {
  168. t.Fatalf("status recv: %v", err)
  169. }
  170. if err := p2p.Send(p.app, StatusMsg, msg); err != nil {
  171. t.Fatalf("status send: %v", err)
  172. }
  173. }
  174. // close terminates the local side of the peer, notifying the remote protocol
  175. // manager of termination.
  176. func (p *testPeer) close() {
  177. p.app.Close()
  178. }