Node improvements (#47)

* block partial persist

* replaced refactored files with old one.

* removed gokit/log from deps

* Tweaks to not overburden remote nodes with getheaders/getblocks

* Changed Transporter interface to not take the server as argument due to a cause of race warning from the compiler

* started server test suite

* more test + return errors from message handlers

* removed --race from build

* Little improvements.

pkg/network/server_test.go

@@ -1,92 +1,114 @@
 package network
 
 import (
-	"os"
 	"testing"
 
 	"github.com/CityOfZion/neo-go/pkg/network/payload"
 	"github.com/CityOfZion/neo-go/pkg/util"
-	log "github.com/go-kit/kit/log"
 	"github.com/stretchr/testify/assert"
 )
 
-func TestRegisterPeer(t *testing.T) {
-	s := newTestServer()
+func TestSendVersion(t *testing.T) {
+	var (
+		s = newTestServer()
+		p = newLocalPeer(t)
+	)
+	s.ListenTCP = 3000
+	s.UserAgent = "/test/"
+
+	p.messageHandler = func(t *testing.T, msg *Message) {
+		assert.Equal(t, CMDVersion, msg.CommandType())
+		assert.IsType(t, msg.Payload, &payload.Version{})
+		version := msg.Payload.(*payload.Version)
+		assert.NotZero(t, version.Nonce)
+		assert.Equal(t, uint16(3000), version.Port)
+		assert.Equal(t, uint64(1), version.Services)
+		assert.Equal(t, uint32(0), version.Version)
+		assert.Equal(t, []byte("/test/"), version.UserAgent)
+		assert.Equal(t, uint32(0), version.StartHeight)
+	}
+
+	s.sendVersion(p)
+}
+
+func TestRequestPeerInfo(t *testing.T) {
+	var (
+		s = newTestServer()
+		p = newLocalPeer(t)
+	)
+
+	p.messageHandler = func(t *testing.T, msg *Message) {
+		assert.Equal(t, CMDGetAddr, msg.CommandType())
+		assert.Nil(t, msg.Payload)
+	}
+	s.requestPeerInfo(p)
+}
+
+// Server should reply with a verack after receiving a valid version.
+func TestVerackAfterHandleVersionCmd(t *testing.T) {
+	var (
+		s = newTestServer()
+		p = newLocalPeer(t)
+	)
+	p.endpoint = util.NewEndpoint("0.0.0.0:3000")
+
+	// Should have a verack
+	p.messageHandler = func(t *testing.T, msg *Message) {
+		assert.Equal(t, CMDVerack, msg.CommandType())
+	}
+	version := payload.NewVersion(1337, 3000, "/NEO-GO/", 0, true)
+
+	if err := s.handleVersionCmd(p, version); err != nil {
+		t.Fatal(err)
+	}
+}
+
+// Server should not reply with a verack after receiving a
+// invalid version and disconnects the peer.
+func TestServerNotSendsVerack(t *testing.T) {
+	var (
+		s = newTestServer()
+		p = newLocalPeer(t)
+	)
+	s.id = 1
 	go s.run()
 
-	assert.NotZero(t, s.id)
-	assert.Zero(t, s.PeerCount())
+	p.endpoint = util.NewEndpoint("0.0.0.0:3000")
+	s.register <- p
 
-	lenPeers := 10
-	for i := 0; i < lenPeers; i++ {
-		s.register <- newTestPeer()
+	// Port should mismatch
+	version := payload.NewVersion(1337, 2000, "/NEO-GO/", 0, true)
+	err := s.handleVersionCmd(p, version)
+	assert.NotNil(t, err)
+	assert.Equal(t, errPortMismatch, err)
+
+	// identical id's
+	version = payload.NewVersion(1, 3000, "/NEO-GO/", 0, true)
+	err = s.handleVersionCmd(p, version)
+	assert.NotNil(t, err)
+	assert.Equal(t, errIdenticalID, err)
+}
+
+func TestRequestPeers(t *testing.T) {
+	var (
+		s = newTestServer()
+		p = newLocalPeer(t)
+	)
+	p.messageHandler = func(t *testing.T, msg *Message) {
+		assert.Nil(t, msg.Payload)
+		assert.Equal(t, CMDGetAddr, msg.CommandType())
 	}
-	assert.Equal(t, lenPeers, s.PeerCount())
+	s.requestPeerInfo(p)
 }
 
-func TestUnregisterPeer(t *testing.T) {
-	s := newTestServer()
-	go s.run()
-
-	peer := newTestPeer()
-	s.register <- peer
-	s.register <- newTestPeer()
-	s.register <- newTestPeer()
-	assert.Equal(t, 3, s.PeerCount())
-
-	s.unregister <- peerDrop{peer, nil}
-	assert.Equal(t, 2, s.PeerCount())
-}
-
-type testNode struct{}
-
-func (t testNode) version() *payload.Version {
-	return &payload.Version{}
-}
-
-func (t testNode) handleProto(msg *Message, p Peer) error {
-	return nil
-}
-
-func newTestServer() *Server {
-	return &Server{
-		logger:        log.NewLogfmtLogger(os.Stderr),
-		id:            util.RandUint32(1000000, 9999999),
-		quit:          make(chan struct{}, 1),
-		register:      make(chan Peer),
-		unregister:    make(chan peerDrop),
-		badAddrOp:     make(chan func(map[string]bool)),
-		badAddrOpDone: make(chan struct{}),
-		peerOp:        make(chan func(map[Peer]bool)),
-		peerOpDone:    make(chan struct{}),
-		proto:         testNode{},
+func TestRequestHeaders(t *testing.T) {
+	var (
+		s = newTestServer()
+		p = newLocalPeer(t)
+	)
+	p.messageHandler = func(t *testing.T, msg *Message) {
+		assert.IsType(t, &payload.GetBlocks{}, msg.Payload)
+		assert.Equal(t, CMDGetHeaders, msg.CommandType())
 	}
-}
-
-type testPeer struct {
-	done chan struct{}
-}
-
-func newTestPeer() testPeer {
-	return testPeer{
-		done: make(chan struct{}),
-	}
-}
-
-func (p testPeer) Version() *payload.Version {
-	return &payload.Version{}
-}
-
-func (p testPeer) Endpoint() util.Endpoint {
-	return util.Endpoint{}
-}
-
-func (p testPeer) Send(msg *Message) {}
-
-func (p testPeer) Done() chan struct{} {
-	return p.done
-}
-
-func (p testPeer) Disconnect(err error) {
-
+	s.requestHeaders(p)
 }