path: root/blockpool/errors_test.go

package blockpool

import (
    "testing"
    "time"

    "github.com/ethereum/go-ethereum/common"
    "github.com/ethereum/go-ethereum/core/types"
    "github.com/ethereum/go-ethereum/pow"
)

func TestInvalidBlock(t *testing.T) {
    _, blockPool, blockPoolTester := newTestBlockPool(t)
    blockPoolTester.blockChain[0] = nil
    blockPoolTester.initRefBlockChain(2)
    blockPoolTester.refBlockChain[2] = []int{}

    blockPool.Start()

    peer1 := blockPoolTester.newPeer("peer1", 1, 3)
    peer1.AddPeer()
    go peer1.serveBlocks(2, 3)
    go peer1.serveBlockHashes(3, 2, 1, 0)
    peer1.serveBlocks(0, 1, 2)

    blockPool.Wait(waitTimeout)
    blockPool.Stop()
    blockPoolTester.refBlockChain[2] = []int{}
    blockPoolTester.checkBlockChain(blockPoolTester.refBlockChain)
    if len(peer1.peerErrors) == 1 {
        if peer1.peerErrors[0] != ErrInvalidBlock {
            t.Errorf("wrong error, got %v, expected %v", peer1.peerErrors[0], ErrInvalidBlock)
        }
    } else {
        t.Errorf("expected %v error, got %v", ErrInvalidBlock, peer1.peerErrors)
    }
}

func TestVerifyPoW(t *testing.T) {
    t.Skip() // :FIXME:

    _, blockPool, blockPoolTester := newTestBlockPool(t)
    blockPoolTester.blockChain[0] = nil
    blockPoolTester.initRefBlockChain(3)
    first := false
    blockPoolTester.blockPool.verifyPoW = func(b pow.Block) bool {
        bb, _ := b.(*types.Block)
        indexes := blockPoolTester.hashPool.HashesToIndexes([]common.Hash{bb.Hash()})
        if indexes[0] == 2 && !first {
            first = true
            return false
        } else {
            return true
        }

    }

    blockPool.Start()

    peer1 := blockPoolTester.newPeer("peer1", 1, 3)
    peer2 := blockPoolTester.newPeer("peer2", 1, 3)
    peer1.AddPeer()
    peer2.AddPeer()
    go peer1.serveBlocks(2, 3)
    go peer1.serveBlockHashes(3, 2, 1, 0)
    peer1.serveBlocks(0, 1, 2, 3)
    blockPoolTester.blockPool.verifyPoW = func(b pow.Block) bool {
        return true
    }
    peer2.serveBlocks(1, 2)

    blockPool.Wait(waitTimeout)
    blockPool.Stop()
    blockPoolTester.refBlockChain[3] = []int{}
    blockPoolTester.checkBlockChain(blockPoolTester.refBlockChain)
    if len(peer1.peerErrors) == 1 {
        if peer1.peerErrors[0] != ErrInvalidPoW {
            t.Errorf("wrong error, expected %v, got %v", ErrInvalidPoW, peer1.peerErrors[0])
        }
    } else {
        t.Errorf("expected %v error, got %v", ErrInvalidPoW, peer1.peerErrors)
    }
}

func TestUnrequestedBlock(t *testing.T) {
    t.Skip() // :FIXME:

    _, blockPool, blockPoolTester := newTestBlockPool(t)
    blockPoolTester.blockChain[0] = nil
    blockPool.Start()

    peer1 := blockPoolTester.newPeer("peer1", 1, 3)
    peer1.AddPeer()
    peer1.sendBlocks(1, 2)

    blockPool.Stop()
    if len(peer1.peerErrors) == 1 {
        if peer1.peerErrors[0] != ErrUnrequestedBlock {
            t.Errorf("wrong error, got %v, expected %v", peer1.peerErrors[0], ErrUnrequestedBlock)
        }
    } else {
        t.Errorf("expected %v error, got %v", ErrUnrequestedBlock, peer1.peerErrors)
    }
}

func TestErrInsufficientChainInfo(t *testing.T) {
    _, blockPool, blockPoolTester := newTestBlockPool(t)
    blockPool.Config.BlockHashesTimeout = 100 * time.Millisecond
    blockPool.Start()

    peer1 := blockPoolTester.newPeer("peer1", 1, 3)
    peer1.AddPeer()

    blockPool.Wait(waitTimeout)
    blockPool.Stop()
    if len(peer1.peerErrors) == 1 {
        if peer1.peerErrors[0] != ErrInsufficientChainInfo {
            t.Errorf("wrong error, got %v, expected %v", peer1.peerErrors[0], ErrInsufficientChainInfo)
        }
    } else {
        t.Errorf("expected %v error, got %v", ErrInsufficientChainInfo, peer1.peerErrors)
    }
}

func TestIncorrectTD(t *testing.T) {
    _, blockPool, blockPoolTester := newTestBlockPool(t)
    blockPoolTester.blockChain[0] = nil
    blockPoolTester.initRefBlockChain(3)

    blockPool.Start()

    peer1 := blockPoolTester.newPeer("peer1", 1, 3)
    peer1.AddPeer()
    go peer1.serveBlocks(2, 3)
    go peer1.serveBlockHashes(3, 2, 1, 0)
    peer1.serveBlocks(0, 1, 2)

    blockPool.Wait(waitTimeout)
    blockPool.Stop()
    blockPoolTester.refBlockChain[3] = []int{}
    blockPoolTester.checkBlockChain(blockPoolTester.refBlockChain)
    if len(peer1.peerErrors) == 1 {
        if peer1.peerErrors[0] != ErrIncorrectTD {
            t.Errorf("wrong error, got %v, expected %v", peer1.peerErrors[0], ErrIncorrectTD)
        }
    } else {
        t.Errorf("expected %v error, got %v", ErrIncorrectTD, peer1.peerErrors)
    }
}

func TestSkipIncorrectTDonFutureBlocks(t *testing.T) {
    _, blockPool, blockPoolTester := newTestBlockPool(t)
    blockPoolTester.blockChain[0] = nil
    blockPoolTester.initRefBlockChain(3)

    blockPool.insertChain = func(blocks types.Blocks) error {
        err := blockPoolTester.insertChain(blocks)
        if err == nil {
            for _, block := range blocks {
                if block.Td.Cmp(common.Big3) == 0 {
                    block.Td = common.Big3
                    block.SetQueued(true)
                    break
                }
            }
        }
        return err
    }

    blockPool.Start()

    peer1 := blockPoolTester.newPeer("peer1", 3, 3)
    peer1.AddPeer()
    go peer1.serveBlocks(2, 3)
    go peer1.serveBlockHashes(3, 2, 1, 0)
    peer1.serveBlocks(0, 1, 2)

    blockPool.Wait(waitTimeout)
    blockPool.Stop()
    blockPoolTester.refBlockChain[3] = []int{}
    blockPoolTester.checkBlockChain(blockPoolTester.refBlockChain)
    if len(peer1.peerErrors) > 0 {
        t.Errorf("expected no error, got %v (1 of %v)", peer1.peerErrors[0], len(peer1.peerErrors))
    }
}

func TestPeerSuspension(t *testing.T) {
    _, blockPool, blockPoolTester := newTestBlockPool(t)
    blockPool.Config.PeerSuspensionInterval = 100 * time.Millisecond

    blockPool.Start()

    peer1 := blockPoolTester.newPeer("peer1", 3, 3)
    peer1.AddPeer()
    bestpeer, _ := blockPool.peers.getPeer("peer1")
    if bestpeer == nil {
        t.Errorf("peer1 not best peer")
        return
    }
    peer1.serveBlocks(2, 3)

    blockPool.peers.peerError("peer1", 0, "")
    bestpeer, _ = blockPool.peers.getPeer("peer1")
    if bestpeer != nil {
        t.Errorf("peer1 not removed on error")
        return
    }
    peer1.AddPeer()
    bestpeer, _ = blockPool.peers.getPeer("peer1")
    if bestpeer != nil {
        t.Errorf("peer1 not removed on reconnect")
        return
    }
    time.Sleep(100 * time.Millisecond)
    peer1.AddPeer()

    bestpeer, _ = blockPool.peers.getPeer("peer1")
    if bestpeer == nil {
        t.Errorf("peer1 not connected after PeerSuspensionInterval")
        return
    }
    blockPool.Stop()

}