func TestGivePeersMessage(t *testing.T) {
d := newDefaultDaemon()
defer shutdown(d)
addrs := []string{addr, addrb, "7"}
peers := make([]*pex.Peer, 3)
for i, addr := range addrs {
peers[i] = &pex.Peer{Addr: addr}
}
m := NewGivePeersMessage(peers)
assert.Equal(t, len(m.GetPeers()), 2)
testSimpleMessageHandler(t, d, m)
assert.Equal(t, m.GetPeers()[0], addrs[0])
assert.Equal(t, m.GetPeers()[1], addrs[1])
// Test disabled
d.Peers.Config.Disabled = true
m.Process(d)
assert.Equal(t, len(d.Peers.Peers.Peerlist), 0)
// Test serialization
m = NewGivePeersMessage(peers)
b := encoder.Serialize(m)
m2 := GivePeersMessage{}
assert.Nil(t, encoder.DeserializeRaw(b, &m2))
assert.Equal(t, *m, m2)
// Peers should be added to the pex when processed
d.Peers.Config.Disabled = false
m.Process(d)
assert.Equal(t, len(d.Peers.Peers.Peerlist), 2)
gnet.EraseMessages()
}
func TransactionDeserialize(b []byte) Transaction {
t := Transaction{}
if err := encoder.DeserializeRaw(b, &t); err != nil {
log.Panic("Failed to deserialize transaction")
}
return t
}
func TestPingMessage(t *testing.T) {
d := newDefaultDaemon()
defer shutdown(d)
p := d.Pool.Pool
m := &PingMessage{}
testSimpleMessageHandler(t, d, m)
m.c = messageContext(addr)
go p.ConnectionWriteLoop(m.c.Conn)
defer m.c.Conn.Close()
assert.NotPanics(t, func() { m.Process(d) })
// A pong message should have been sent
wait()
assert.Equal(t, len(p.SendResults), 1)
if len(p.SendResults) == 0 {
t.Fatalf("SendResults empty, would block")
}
sr := <-p.SendResults
assert.Equal(t, sr.Connection, m.c.Conn)
assert.Nil(t, sr.Error)
_, ok := sr.Message.(*PongMessage)
assert.True(t, ok)
assert.False(t, m.c.Conn.LastSent.IsZero())
// Test serialization
mm := PingMessage{}
b := encoder.Serialize(mm)
m2 := PingMessage{}
assert.Nil(t, encoder.DeserializeRaw(b, &m2))
assert.Equal(t, mm, m2)
gnet.EraseMessages()
}
//decode block to bytes
func Dec_block(b []byte) (SignedBlock, error) {
if len(b) < 16 {
log.Panic()
}
var dln uint64 = le_Uint64(b[0:8])
var seq uint64 = le_Uint64(b[8:16])
var chk uint64 = le_Uint64(b[16:24])
if dln != uint64(len(b)) {
log.Panic("Dec_block, length check failed")
}
b = b[24:] //cleave off header
if chk != FnvsHash(b) {
log.Panic("Dec_block, checksum failed")
}
var sb SignedBlock
err := encoder.DeserializeRaw(b, &sb)
if err != nil {
log.Panic("Dec_block, deserialization failed")
}
if seq != sb.Block.Head.BkSeq {
log.Panic("Dec_block, seq mismatch")
}
return sb, nil
}
func TestGetPeersMessage(t *testing.T) {
d := newDefaultDaemon()
defer shutdown(d)
p := d.Pool
m := NewGetPeersMessage()
testSimpleMessageHandler(t, d, m)
d.Peers.Peers.AddPeer(addr)
q, err := d.Peers.Peers.AddPeer(addrb)
assert.Nil(t, err)
q.Private = true
d.Peers.Config.ReplyCount = 100
m.c = messageContext(addr)
// Peers disabled
d.Peers.Config.Disabled = true
assert.NotPanics(t, func() { m.Process(d) })
wait()
assert.Equal(t, len(p.Pool.SendResults), 0)
assert.True(t, m.c.Conn.LastSent.IsZero())
// Peers enabled
d.Peers.Config.Disabled = false
m.c = messageContext(addr)
defer m.c.Conn.Close()
go p.Pool.ConnectionWriteLoop(m.c.Conn)
assert.NotPanics(t, func() { m.Process(d) })
wait()
assert.Equal(t, len(p.Pool.SendResults), 1)
if len(p.Pool.SendResults) == 0 {
t.Fatal("SendResults empty, would block")
}
sr := <-p.Pool.SendResults
assert.Nil(t, sr.Error)
assert.Equal(t, sr.Connection, m.c.Conn)
msg, ok := sr.Message.(*GivePeersMessage)
assert.True(t, ok)
// Private peer should not be included
ipAddr, err := NewIPAddr(addr)
assert.Nil(t, err)
assert.Equal(t, msg.Peers, []IPAddr{ipAddr})
assert.False(t, m.c.Conn.LastSent.IsZero())
// If no peers, nothing should happen
m.c.Conn.LastSent = util.ZeroTime()
delete(d.Peers.Peers.Peerlist, addr)
assert.NotPanics(t, func() { m.Process(d) })
wait()
assert.Equal(t, len(p.Pool.SendResults), 0)
assert.True(t, m.c.Conn.LastSent.IsZero())
// Test serialization
m = NewGetPeersMessage()
b := encoder.Serialize(m)
m2 := GetPeersMessage{}
assert.Nil(t, encoder.DeserializeRaw(b, &m2))
assert.Equal(t, *m, m2)
gnet.EraseMessages()
}
func (bt *BlockTree) getBlock(hash cipher.SHA256) *coin.Block {
bin := bt.blocks.Get(hash[:])
if bin == nil {
return nil
}
block := coin.Block{}
if err := encoder.DeserializeRaw(bin, &block); err != nil {
return nil
}
return &block
}
func getBucketValue(db *bolt.DB, name []byte, key []byte, value interface{}) error {
return db.View(func(tx *bolt.Tx) error {
b := tx.Bucket(name)
bin := b.Get(key)
if bin == nil {
value = nil
return nil
}
return encoder.DeserializeRaw(bin, value)
})
}
// Get returns signature of specific block
func (bs BlockSigs) Get(hash cipher.SHA256) (cipher.Sig, error) {
bin := bs.Sigs.Get(hash[:])
if bin == nil {
return cipher.Sig{}, fmt.Errorf("no sig for %v", hash.Hex())
}
var sig cipher.Sig
if err := encoder.DeserializeRaw(bin, &sig); err != nil {
return cipher.Sig{}, err
}
return sig, nil
}
// Get return nil on not found.
func (au *addressUx) Get(address cipher.Address) ([]cipher.SHA256, error) {
uxHashes := []cipher.SHA256{}
bin := au.bkt.Get(address.Bytes())
if bin == nil {
return nil, nil
}
if err := encoder.DeserializeRaw(bin, &uxHashes); err != nil {
return nil, err
}
return uxHashes, nil
}
func (bt *BlockTree) getHashInDepth(depth uint64, filter func(ps []coin.HashPair) cipher.SHA256) (cipher.SHA256, error) {
key := itob(depth)
pairsBin := bt.tree.Get(key)
pairs := []coin.HashPair{}
if err := encoder.DeserializeRaw(pairsBin, &pairs); err != nil {
return cipher.SHA256{}, err
}
hash := filter(pairs)
return hash, nil
}
func LoadSerializedBlockchain(filename string) (*SerializedBlockchain, error) {
sbc := &SerializedBlockchain{}
data, err := ioutil.ReadFile(filename)
if err != nil {
return nil, err
}
err = encoder.DeserializeRaw(data, sbc)
if err != nil {
return nil, err
}
return sbc, nil
}
func TestIntroductionMessageHandle(t *testing.T) {
d := newDefaultDaemon()
defer shutdown(d)
mc := messageContext(addr)
m := NewIntroductionMessage(d.Messages.Mirror, d.Config.Version,
d.Pool.Pool.Config.Port)
// Test valid handling
m.Mirror = d.Messages.Mirror + 1
err := m.Handle(mc, d)
assert.Nil(t, err)
if len(d.messageEvents) == 0 {
t.Fatalf("messageEvent is empty")
}
<-d.messageEvents
assert.True(t, m.valid)
m.valid = false
// Test matching mirror
m.Mirror = d.Messages.Mirror
err = m.Handle(mc, d)
assert.Equal(t, err, DisconnectSelf)
m.Mirror = d.Messages.Mirror + 1
assert.False(t, m.valid)
// Test mismatched d.Config.Version
m.Version = d.Config.Version + 1
err = m.Handle(mc, d)
assert.Equal(t, err, DisconnectInvalidVersion)
assert.False(t, m.valid)
// Test serialization
m = NewIntroductionMessage(d.Messages.Mirror, d.Config.Version,
d.Pool.Pool.Config.Port)
b := encoder.Serialize(m)
m2 := IntroductionMessage{}
assert.Nil(t, encoder.DeserializeRaw(b, &m2))
assert.Equal(t, *m, m2)
// Test already connected
d.mirrorConnections[m.Mirror] = make(map[string]uint16)
d.mirrorConnections[m.Mirror][addrIP] = addrPort + 1
err = m.Handle(mc, d)
assert.Equal(t, err, DisconnectConnectedTwice)
delete(d.mirrorConnections, m.Mirror)
assert.False(t, m.valid)
for len(d.messageEvents) > 0 {
<-d.messageEvents
}
gnet.EraseMessages()
}
// GetAllBlockHashInDepth returns all block hash of N depth in the tree.
func (bt *BlockTree) GetAllBlockHashInDepth(depth uint64) ([]cipher.SHA256, error) {
key := itob(depth)
pairsBin := bt.tree.Get(key)
pairs := []coin.HashPair{}
if err := encoder.DeserializeRaw(pairsBin, &pairs); err != nil {
return []cipher.SHA256{}, err
}
hashes := make([]cipher.SHA256, len(pairs))
for i, hp := range pairs {
hashes[i] = hp.Hash
}
return hashes, nil
}
func TestGetBlocksMessageHandle(t *testing.T) {
d := newDefaultDaemon()
defer shutdown(d)
m := NewGetBlocksMessage(uint64(1))
assert.Equal(t, m.LastBlock, uint64(1))
testSimpleMessageHandler(t, d, m)
// Test serialization
m = NewGetBlocksMessage(uint64(106))
b := encoder.Serialize(m)
m2 := GetBlocksMessage{}
assert.Nil(t, encoder.DeserializeRaw(b, &m2))
assert.Equal(t, *m, m2)
}
// Get get transaction by tx hash, return nil on not found.
func (txs transactions) Get(hash cipher.SHA256) (*Transaction, error) {
bin := txs.bkt.Get(hash[:])
if bin == nil {
return nil, nil
}
// deserialize tx
var tx Transaction
if err := encoder.DeserializeRaw(bin, &tx); err != nil {
return nil, err
}
return &tx, nil
}
func TestPongMessage(t *testing.T) {
cmsgs := NewMessagesConfig()
cmsgs.Register()
m := &PongMessage{}
// Pongs dont do anything
assert.Nil(t, m.Handle(messageContext(addr), nil))
gnet.EraseMessages()
// Test serialization
mm := PongMessage{}
b := encoder.Serialize(mm)
m2 := PongMessage{}
assert.Nil(t, encoder.DeserializeRaw(b, &m2))
assert.Equal(t, mm, m2)
}
func getHashPairInDepth(tree *bolt.Bucket, dep uint64, fn func(hp coin.HashPair) bool) ([]coin.HashPair, error) {
v := tree.Get(itob(dep))
if v == nil {
return []coin.HashPair{}, nil
}
hps := []coin.HashPair{}
if err := encoder.DeserializeRaw(v, &hps); err != nil {
return nil, err
}
pairs := []coin.HashPair{}
for _, ps := range hps {
if fn(ps) {
pairs = append(pairs, ps)
}
}
return pairs, nil
}
func TestGiveBlocksMessageHandle(t *testing.T) {
d := newDefaultDaemon()
defer shutdown(d)
_, mv := setupVisor()
blocks := []visor.SignedBlock{mv.GetGenesisBlock()}
m := NewGiveBlocksMessage(blocks)
assert.Equal(t, m.Blocks, blocks)
testSimpleMessageHandler(t, d, m)
// Test serialization
bks, err := makeBlocks(mv, 4)
assert.Nil(t, err)
blocks = append(blocks, bks...)
m = NewGiveBlocksMessage(blocks)
b := encoder.Serialize(m)
m2 := GiveBlocksMessage{}
assert.Nil(t, encoder.DeserializeRaw(b, &m2))
assert.Equal(t, *m, m2)
}
func LoadBlockSigs(filename string) (BlockSigs, error) {
bs := NewBlockSigs()
data, err := ioutil.ReadFile(filename)
if err != nil {
return bs, err
}
sigs := BlockSigsSerialized{make([]BlockSigSerialized, 0)}
err = encoder.DeserializeRaw(data, &sigs)
if err != nil {
return bs, err
}
bs.Sigs = make(map[uint64]cipher.Sig, len(sigs.Sigs))
for _, s := range sigs.Sigs {
bs.Sigs[s.BkSeq] = s.Sig
if s.BkSeq > bs.MaxSeq {
bs.MaxSeq = s.BkSeq
}
}
return bs, nil
}
func TestAnnounceTxnsMessageHandle(t *testing.T) {
d := newDefaultDaemon()
defer shutdown(d)
tx := createUnconfirmedTxn()
txns := []cipher.SHA256{tx.Txn.Hash()}
m := NewAnnounceTxnsMessage(txns)
assert.Equal(t, m.Txns, txns)
testSimpleMessageHandler(t, d, m)
// Test serialization
tx = createUnconfirmedTxn()
txns = append(txns, tx.Txn.Hash())
tx = createUnconfirmedTxn()
txns = append(txns, tx.Txn.Hash())
m = NewAnnounceTxnsMessage(txns)
assert.Equal(t, len(m.Txns), 3)
b := encoder.Serialize(m)
m2 := AnnounceTxnsMessage{}
assert.Nil(t, encoder.DeserializeRaw(b, &m2))
assert.Equal(t, *m, m2)
}
func TestGiveTxnsMessageHandle(t *testing.T) {
d := newDefaultDaemon()
defer shutdown(d)
tx := createUnconfirmedTxn()
txns := coin.Transactions{tx.Txn}
m := NewGiveTxnsMessage(txns)
assert.Equal(t, m.Txns, txns)
testSimpleMessageHandler(t, d, m)
// Test serialization
tx = createUnconfirmedTxn()
txns = append(txns, tx.Txn)
tx = createUnconfirmedTxn()
txns = append(txns, tx.Txn)
m = NewGiveTxnsMessage(txns)
assert.Equal(t, len(m.Txns), 3)
b := encoder.Serialize(m)
m2 := GiveTxnsMessage{}
assert.Nil(t, encoder.DeserializeRaw(b, &m2))
assert.Equal(t, *m, m2)
}
//creates block from byte array
func BlockFromBytes(data []byte) (Block, error) {
var b Block
return b, encoder.DeserializeRaw(data, &b)
}