netsync/chainmgr/tx_keeper_test.go

   1 package chainmgr
   2
   3 import (
   4         "io/ioutil"
   5         "os"
   6         "reflect"
   7         "testing"
   8         "time"
   9
  10         "github.com/davecgh/go-spew/spew"
  11
  12         "github.com/vapor/consensus"
  13         dbm "github.com/vapor/database/leveldb"
  14         "github.com/vapor/protocol"
  15         "github.com/vapor/protocol/bc"
  16         "github.com/vapor/protocol/bc/types"
  17         "github.com/vapor/test/mock"
  18 )
  19
  20 const txsNumber = 2000
  21
  22 func getTransactions() []*types.Tx {
  23         txs := []*types.Tx{}
  24         for i := 0; i < txsNumber; i++ {
  25                 txInput := types.NewSpendInput(nil, bc.NewHash([32]byte{0x01}), *consensus.BTMAssetID, uint64(i), 1, []byte{0x51})
  26                 txInput.CommitmentSuffix = []byte{0, 1, 2}
  27                 txInput.WitnessSuffix = []byte{0, 1, 2}
  28
  29                 tx := &types.Tx{
  30
  31                         TxData: types.TxData{
  32                                 //SerializedSize: uint64(i * 10),
  33                                 Inputs: []*types.TxInput{
  34                                         txInput,
  35                                 },
  36                                 Outputs: []*types.TxOutput{
  37                                         types.NewIntraChainOutput(*consensus.BTMAssetID, uint64(i), []byte{0x6a}),
  38                                 },
  39                         },
  40                         Tx: &bc.Tx{
  41                                 ID: bc.Hash{V0: uint64(i), V1: uint64(i), V2: uint64(i), V3: uint64(i)},
  42                         },
  43                 }
  44                 txs = append(txs, tx)
  45         }
  46         return txs
  47 }
  48
  49 func TestSyncMempool(t *testing.T) {
  50         tmpDir, err := ioutil.TempDir(".", "")
  51         if err != nil {
  52                 t.Fatalf("failed to create temporary data folder: %v", err)
  53         }
  54         defer os.RemoveAll(tmpDir)
  55         testDBA := dbm.NewDB("testdba", "leveldb", tmpDir)
  56         testDBB := dbm.NewDB("testdbb", "leveldb", tmpDir)
  57
  58         blocks := mockBlocks(nil, 5)
  59         a := mockSync(blocks, &mock.Mempool{}, testDBA)
  60         b := mockSync(blocks, &mock.Mempool{}, testDBB)
  61
  62         netWork := NewNetWork()
  63         netWork.Register(a, "192.168.0.1", "test node A", consensus.SFFullNode)
  64         netWork.Register(b, "192.168.0.2", "test node B", consensus.SFFullNode)
  65         if B2A, A2B, err := netWork.HandsShake(a, b); err != nil {
  66                 t.Errorf("fail on peer hands shake %v", err)
  67         } else {
  68                 go B2A.postMan()
  69                 go A2B.postMan()
  70         }
  71
  72         go a.syncMempoolLoop()
  73         a.syncMempool("test node B")
  74         wantTxs := getTransactions()
  75         a.txSyncCh <- &txSyncMsg{"test node B", wantTxs}
  76
  77         timeout := time.NewTimer(2 * time.Second)
  78         defer timeout.Stop()
  79         ticker := time.NewTicker(500 * time.Millisecond)
  80         defer ticker.Stop()
  81
  82         gotTxs := []*protocol.TxDesc{}
  83         for {
  84                 select {
  85                 case <-ticker.C:
  86                         gotTxs = b.mempool.GetTransactions()
  87                         if len(gotTxs) >= txsNumber {
  88                                 goto out
  89                         }
  90                 case <-timeout.C:
  91                         t.Fatalf("mempool sync timeout")
  92                 }
  93         }
  94
  95 out:
  96         if len(gotTxs) != txsNumber {
  97                 t.Fatalf("mempool sync txs num err. got:%d want:%d", len(gotTxs), txsNumber)
  98         }
  99
 100         for i, gotTx := range gotTxs {
 101                 index := gotTx.Tx.Inputs[0].Amount()
 102                 if !reflect.DeepEqual(gotTx.Tx.Inputs[0].Amount(), wantTxs[index].Inputs[0].Amount()) {
 103                         t.Fatalf("mempool tx err. index:%d\n,gotTx:%s\n,wantTx:%s", i, spew.Sdump(gotTx.Tx.Inputs), spew.Sdump(wantTxs[0].Inputs))
 104                 }
 105
 106                 if !reflect.DeepEqual(gotTx.Tx.Outputs[0].AssetAmount(), wantTxs[index].Outputs[0].AssetAmount()) {
 107                         t.Fatalf("mempool tx err. index:%d\n,gotTx:%s\n,wantTx:%s", i, spew.Sdump(gotTx.Tx.Outputs), spew.Sdump(wantTxs[0].Outputs))
 108                 }
 109
 110         }
 111
 112 }