X-Git-Url: http://git.osdn.net/view?p=bytom%2Fvapor.git;a=blobdiff_plain;f=netsync%2Fchainmgr%2Ftool_test.go;h=4a3badd97b2f82d098b908fdc72ea89b15ca82ed;hp=34f0cc6eb710c7ca0609408debf00d38f4694b30;hb=669d176c004324fe81a26261a6e41ddea95b6f17;hpb=7e01ede3ce5d3688fa29f30bc766593beb9508e4

diff --git a/netsync/chainmgr/tool_test.go b/netsync/chainmgr/tool_test.go
index 34f0cc6e..4a3badd9 100644
--- a/netsync/chainmgr/tool_test.go
+++ b/netsync/chainmgr/tool_test.go
@@ -4,9 +4,11 @@ import (
 	"errors"
 	"math/rand"
 	"net"
+	"time"
 
-	wire "github.com/tendermint/go-wire"
+	"github.com/tendermint/go-wire"
 	"github.com/tendermint/tmlibs/flowrate"
+	dbm "github.com/vapor/database/leveldb"
 
 	"github.com/vapor/consensus"
 	"github.com/vapor/netsync/peers"
@@ -21,7 +23,7 @@ type P2PPeer struct {
 	flag consensus.ServiceFlag
 
 	srcPeer    *P2PPeer
-	remoteNode *ChainManager
+	remoteNode *Manager
 	msgCh      chan []byte
 	async      bool
 }
@@ -48,11 +50,15 @@ func (p *P2PPeer) IsLAN() bool {
 	return false
 }
 
+func (p *P2PPeer) RemoteAddrHost() string {
+	return ""
+}
+
 func (p *P2PPeer) ServiceFlag() consensus.ServiceFlag {
 	return p.flag
 }
 
-func (p *P2PPeer) SetConnection(srcPeer *P2PPeer, node *ChainManager) {
+func (p *P2PPeer) SetConnection(srcPeer *P2PPeer, node *Manager) {
 	p.srcPeer = srcPeer
 	p.remoteNode = node
 }
@@ -79,6 +85,7 @@ func (p *P2PPeer) setAsync(b bool) {
 func (p *P2PPeer) postMan() {
 	for msgBytes := range p.msgCh {
 		msgType, msg, _ := decodeMessage(msgBytes)
+		time.Sleep(10 * time.Millisecond)
 		p.remoteNode.processMsg(p.srcPeer, msgType, msg)
 	}
 }
@@ -89,23 +96,26 @@ func NewPeerSet() *PeerSet {
 	return &PeerSet{}
 }
 
-func (ps *PeerSet) AddBannedPeer(string) error { return nil }
-func (ps *PeerSet) StopPeerGracefully(string)  {}
+func (ps *PeerSet) IsBanned(ip string, level byte, reason string) bool {
+	return false
+}
+
+func (ps *PeerSet) StopPeerGracefully(string) {}
 
 type NetWork struct {
-	nodes map[*ChainManager]P2PPeer
+	nodes map[*Manager]P2PPeer
 }
 
 func NewNetWork() *NetWork {
-	return &NetWork{map[*ChainManager]P2PPeer{}}
+	return &NetWork{map[*Manager]P2PPeer{}}
 }
 
-func (nw *NetWork) Register(node *ChainManager, addr, id string, flag consensus.ServiceFlag) {
+func (nw *NetWork) Register(node *Manager, addr, id string, flag consensus.ServiceFlag) {
 	peer := NewP2PPeer(addr, id, flag)
 	nw.nodes[node] = *peer
 }
 
-func (nw *NetWork) HandsShake(nodeA, nodeB *ChainManager) (*P2PPeer, *P2PPeer, error) {
+func (nw *NetWork) HandsShake(nodeA, nodeB *Manager) (*P2PPeer, *P2PPeer, error) {
 	B2A, ok := nw.nodes[nodeA]
 	if !ok {
 		return nil, nil, errors.New("can't find nodeA's p2p peer on network")
@@ -120,7 +130,8 @@ func (nw *NetWork) HandsShake(nodeA, nodeB *ChainManager) (*P2PPeer, *P2PPeer, e
 
 	nodeA.AddPeer(&A2B)
 	nodeB.AddPeer(&B2A)
-
+	nodeA.SendStatus(B2A.srcPeer)
+	nodeB.SendStatus(A2B.srcPeer)
 	A2B.setAsync(true)
 	B2A.setAsync(true)
 	return &B2A, &A2B, nil
@@ -150,18 +161,47 @@ func mockBlocks(startBlock *types.Block, height uint64) []*types.Block {
 	return blocks
 }
 
-func mockSync(blocks []*types.Block) *ChainManager {
-	chain := mock.NewChain()
+func mockErrorBlocks(startBlock *types.Block, height uint64, errBlockHeight uint64) []*types.Block {
+	blocks := []*types.Block{}
+	indexBlock := &types.Block{}
+	if startBlock == nil {
+		indexBlock = &types.Block{BlockHeader: types.BlockHeader{Version: uint64(rand.Uint32())}}
+		blocks = append(blocks, indexBlock)
+	} else {
+		indexBlock = startBlock
+	}
+
+	for indexBlock.Height < height {
+		block := &types.Block{
+			BlockHeader: types.BlockHeader{
+				Height:            indexBlock.Height + 1,
+				PreviousBlockHash: indexBlock.Hash(),
+				Version:           uint64(rand.Uint32()),
+			},
+		}
+		if block.Height == errBlockHeight {
+			block.TransactionsMerkleRoot = bc.NewHash([32]byte{0x1})
+		}
+		blocks = append(blocks, block)
+		indexBlock = block
+	}
+	return blocks
+}
+
+func mockSync(blocks []*types.Block, mempool *mock.Mempool, fastSyncDB dbm.DB) *Manager {
+	chain := mock.NewChain(mempool)
 	peers := peers.NewPeerSet(NewPeerSet())
 	chain.SetBestBlockHeader(&blocks[len(blocks)-1].BlockHeader)
 	for _, block := range blocks {
 		chain.SetBlockByHeight(block.Height, block)
 	}
 
-	return &ChainManager{
+	return &Manager{
 		chain:       chain,
-		blockKeeper: newBlockKeeper(chain, peers),
+		blockKeeper: newBlockKeeper(chain, peers, fastSyncDB),
 		peers:       peers,
+		mempool:     mempool,
+		txSyncCh:    make(chan *txSyncMsg),
 	}
 }