github.com/metacurrency/holochain@v0.1.0-alpha-26.0.20200915073418-5c83169c9b5b/node_test.go

package holochain

import (
	"bytes"
	"context"
	"errors"
	"fmt"
	. "github.com/holochain/holochain-proto/hash"
	net "github.com/libp2p/go-libp2p-net"
	peer "github.com/libp2p/go-libp2p-peer"
	pstore "github.com/libp2p/go-libp2p-peerstore"
	ma "github.com/multiformats/go-multiaddr"
	. "github.com/smartystreets/goconvey/convey"
	"io/ioutil"
	"os"
	"path/filepath"
	"testing"
	"time"
)

func TestNodeConstants(t *testing.T) {
	Convey("node constants should have the right values", t, func() {
		So(ERROR_RESPONSE, ShouldEqual, 0)
		So(OK_RESPONSE, ShouldEqual, 1)
		So(PUT_REQUEST, ShouldEqual, 2)
		So(DEL_REQUEST, ShouldEqual, 3)
		So(MOD_REQUEST, ShouldEqual, 4)
		So(GET_REQUEST, ShouldEqual, 5)
		So(LINK_REQUEST, ShouldEqual, 6)
		So(GETLINK_REQUEST, ShouldEqual, 7)
		So(DELETELINK_REQUEST, ShouldEqual, 8)
		So(GOSSIP_REQUEST, ShouldEqual, 9)
		So(VALIDATE_PUT_REQUEST, ShouldEqual, 10)
		So(VALIDATE_LINK_REQUEST, ShouldEqual, 11)
		So(VALIDATE_DEL_REQUEST, ShouldEqual, 12)
		So(VALIDATE_MOD_REQUEST, ShouldEqual, 13)
		So(APP_MESSAGE, ShouldEqual, 14)
		So(LISTADD_REQUEST, ShouldEqual, 15)
		So(FIND_NODE_REQUEST, ShouldEqual, 16)
	})
}

func TestNodeMDNSDiscovery(t *testing.T) {
	nodesCount := 4
	mt := setupMultiNodeTesting(nodesCount)
	defer mt.cleanupMultiNodeTesting()
	nodes := mt.nodes

	node0 := nodes[0].node
	node1 := nodes[1].node
	node2 := nodes[2].node
	node3 := nodes[3].node

	Convey("nodes should find eachother via mdns", t, func() {
		So(len(node0.host.Peerstore().Peers()), ShouldEqual, 1)
		So(len(node1.host.Peerstore().Peers()), ShouldEqual, 1)
		So(len(node2.host.Peerstore().Peers()), ShouldEqual, 1)

		err := node0.EnableMDNSDiscovery(nodes[0], time.Second/4)
		So(err, ShouldBeNil)
		err = node1.EnableMDNSDiscovery(nodes[1], time.Second/4)
		So(err, ShouldBeNil)
		err = node2.EnableMDNSDiscovery(nodes[2], time.Second/4)
		So(err, ShouldBeNil)

		time.Sleep(time.Millisecond * 500)

		So(len(node0.host.Peerstore().Peers()), ShouldEqual, 3)
		So(len(node1.host.Peerstore().Peers()), ShouldEqual, 3)
		So(len(node2.host.Peerstore().Peers()), ShouldEqual, 3)
	})

	Convey("nodes should confirm connectability before adding nodes found via mdns", t, func() {
		So(len(node3.host.Peerstore().Peers()), ShouldEqual, 1)

		// shut-down node2 so the new node can't connect to it
		node2.Close()

		err := node3.EnableMDNSDiscovery(nodes[3], time.Second/4)
		So(err, ShouldBeNil)
		time.Sleep(time.Millisecond * 500)

		/*for _, p := range node3.host.Peerstore().Peers() {
			fmt.Printf("PERR:%v\n", p)
			for _, a := range node3.host.Peerstore().Addrs(p) {
				fmt.Printf("    ADDR:%v\n", a)
			}
		}*/

		// mdns still reporting nodes2
		So(len(node3.host.Peerstore().Peers()), ShouldEqual, 4)
		//	So(len(node3.host.Peerstore().Addrs(nodes[2].nodeID)), ShouldEqual, 0)
	})
}

func TestNewNode(t *testing.T) {

	node, err := makeNode(1234, "")
	defer node.Close()
	Convey("It should create a node", t, func() {
		So(err, ShouldBeNil)
		So(node.NetAddr.String(), ShouldEqual, "/ip4/127.0.0.1/tcp/1234")
		So(node.HashAddr.Pretty(), ShouldEqual, "QmNN6oDiV4GsfKDXPVmGLdBLLXCM28Jnm7pz7WD63aiwSG")
	})

	Convey("It should send between nodes", t, func() {
		node2, err := makeNode(4321, "node2")
		So(err, ShouldBeNil)
		defer node2.Close()

		node.host.Peerstore().AddAddr(node2.HashAddr, node2.NetAddr, pstore.PermanentAddrTTL)
		var payload string
		node2.host.SetStreamHandler("/testprotocol/1.0.0", func(s net.Stream) {
			defer s.Close()

			buf := make([]byte, 1024)
			n, err := s.Read(buf)
			if err != nil {
				payload = err.Error()
			} else {
				payload = string(buf[:n])
			}

			_, err = s.Write([]byte("I got: " + payload))

			if err != nil {
				panic(err)
			}
		})

		s, err := node.host.NewStream(node.ctx, node2.HashAddr, "/testprotocol/1.0.0")
		So(err, ShouldBeNil)
		_, err = s.Write([]byte("greetings"))
		So(err, ShouldBeNil)

		out, err := ioutil.ReadAll(s)
		So(err, ShouldBeNil)
		So(payload, ShouldEqual, "greetings")
		So(string(out), ShouldEqual, "I got: greetings")
	})
}

func TestNewMessage(t *testing.T) {
	node, err := makeNode(1234, "node1")
	if err != nil {
		panic(err)
	}
	defer node.Close()
	Convey("It should create a new message", t, func() {
		now := time.Now()
		m := node.NewMessage(PUT_REQUEST, "fish")
		So(now.Before(m.Time), ShouldBeTrue) // poor check, but at least makes sure the time was set to something just after the NewMessage call was made
		So(m.Type, ShouldEqual, PUT_REQUEST)
		So(m.Body, ShouldEqual, "fish")
		So(m.From, ShouldEqual, node.HashAddr)
	})
}

func TestNodeSend(t *testing.T) {
	d, _, h := PrepareTestChain("test")
	defer CleanupTestChain(h, d)

	node1, err := makeNode(1234, "node1")
	if err != nil {
		panic(err)
	}
	h.node.Close()
	h.node = node1

	d2, _, h2 := PrepareTestChain("test2")
	defer CleanupTestChain(h2, d2)
	h2.node.Close()

	node2, err := makeNode(1235, "node2")
	if err != nil {
		panic(err)
	}
	defer node2.Close()
	h2.node = node2
	os.Remove(filepath.Join(h2.DBPath(), DHTStoreFileName))
	h2.dht = NewDHT(h2)

	h.Activate()

	Convey("It should start the DHT protocols", t, func() {
		err := h2.dht.Start()
		So(err, ShouldBeNil)
	})
	Convey("It should start the Nucleus protocols", t, func() {
		err := h2.nucleus.Start()
		So(err, ShouldBeNil)
	})

	node2.host.Peerstore().AddAddr(node1.HashAddr, node1.NetAddr, pstore.PermanentAddrTTL)

	Convey("It should fail on messages without a source", t, func() {
		m := Message{Type: PUT_REQUEST, Body: "fish"}
		So(len(node1.host.Peerstore().Peers()), ShouldEqual, 1)
		r, err := node2.Send(context.Background(), ActionProtocol, node1.HashAddr, &m)
		So(err, ShouldBeNil)
		So(len(node1.host.Peerstore().Peers()), ShouldEqual, 2) // node1's peerstore should now have node2
		So(r.Type, ShouldEqual, ERROR_RESPONSE)
		So(r.From, ShouldEqual, node1.HashAddr) // response comes from who we sent to
		So(r.Body.(ErrorResponse).Message, ShouldEqual, "message must have a source")
	})

	Convey("It should fail on incorrect message types", t, func() {
		m := node1.NewMessage(PUT_REQUEST, "fish")
		r, err := node1.Send(context.Background(), ValidateProtocol, node2.HashAddr, m)
		So(err, ShouldBeNil)
		So(r.Type, ShouldEqual, ERROR_RESPONSE)
		So(r.From, ShouldEqual, node2.HashAddr) // response comes from who we sent to
		So(r.Body.(ErrorResponse).Message, ShouldEqual, "message type 2 not in holochain-validate protocol")

		m = node2.NewMessage(PUT_REQUEST, "fish")
		r, err = node2.Send(context.Background(), GossipProtocol, node1.HashAddr, m)
		So(err, ShouldBeNil)
		So(r.Type, ShouldEqual, ERROR_RESPONSE)
		So(r.From, ShouldEqual, node1.HashAddr) // response comes from who we sent to
		So(r.Body.(ErrorResponse).Message, ShouldEqual, "message type 2 not in holochain-gossip protocol")

		m = node2.NewMessage(GOSSIP_REQUEST, "fish")
		r, err = node2.Send(context.Background(), ActionProtocol, node1.HashAddr, m)
		So(err, ShouldBeNil)
		So(r.Type, ShouldEqual, ERROR_RESPONSE)
		So(r.From, ShouldEqual, node1.HashAddr) // response comes from who we sent to
		So(r.Body.(ErrorResponse).Message, ShouldEqual, "message type 9 not in holochain-action protocol")

	})

	Convey("It should respond with err on bad request on invalid PUT_REQUESTS", t, func() {
		hash, _ := NewHash("QmY8Mzg9F69e5P9AoQPYat6x5HEhc1TVGs11tmfNSzkqh2")

		m := node2.NewMessage(PUT_REQUEST, HoldReq{EntryHash: hash})
		r, err := node2.Send(context.Background(), ActionProtocol, node1.HashAddr, m)
		So(err, ShouldBeNil)
		So(r.Type, ShouldEqual, ERROR_RESPONSE)
		So(r.From, ShouldEqual, node1.HashAddr) // response comes from who we sent to
		So(r.Body.(ErrorResponse).Code, ShouldEqual, ErrHashNotFoundCode)
	})

	Convey("It should respond with OK if valid request", t, func() {
		m := node2.NewMessage(GOSSIP_REQUEST, GossipReq{})
		r, err := node2.Send(context.Background(), GossipProtocol, node1.HashAddr, m)
		So(err, ShouldBeNil)
		So(r.Type, ShouldEqual, OK_RESPONSE)
		So(r.From, ShouldEqual, node1.HashAddr) // response comes from who we sent to
		So(fmt.Sprintf("%T", r.Body), ShouldEqual, "holochain.Gossip")
	})

	Convey("it should respond with err on messages from nodes on the blockedlist", t, func() {
		node1.Block(node2.HashAddr)
		m := node2.NewMessage(GOSSIP_REQUEST, GossipReq{})
		r, err := node2.Send(context.Background(), GossipProtocol, node1.HashAddr, m)
		So(err, ShouldBeNil)
		So(r.Type, ShouldEqual, ERROR_RESPONSE)
		So(r.From, ShouldEqual, node1.HashAddr) // response comes from who we sent to
		So(r.Body.(ErrorResponse).Code, ShouldEqual, ErrBlockedListedCode)
	})

	Convey("it should respond with err on messages to nodes on the blockedlist", t, func() {
		node1.Block(node2.HashAddr)
		m := node1.NewMessage(GOSSIP_REQUEST, GossipReq{})
		_, err = node1.Send(context.Background(), GossipProtocol, node2.HashAddr, m)
		So(err, ShouldEqual, ErrBlockedListed)
	})

}

func TestNodeBlockedList(t *testing.T) {
	Convey("it should be set up from a peerlist", t, func() {
		node, _ := makeNode(1234, "node1")
		defer node.Close()
		node2, _ := makeNode(1235, "node2")
		defer node2.Close()

		So(node.IsBlocked(node2.HashAddr), ShouldBeFalse)
		node.InitBlockedList(PeerList{Records: []PeerRecord{PeerRecord{ID: node2.HashAddr}}})
		So(node.IsBlocked(node2.HashAddr), ShouldBeTrue)
		node.Unblock(node2.HashAddr)
		So(node.IsBlocked(node2.HashAddr), ShouldBeFalse)
		node.Block(node2.HashAddr)
		So(node.IsBlocked(node2.HashAddr), ShouldBeTrue)
	})
}

func TestMessageCoding(t *testing.T) {
	node, err := makeNode(1234, "node1")
	if err != nil {
		panic(err)
	}
	defer node.Close()

	m := node.NewMessage(PUT_REQUEST, "foo")
	var d []byte
	Convey("It should encode and decode put messages", t, func() {
		d, err = m.Encode()
		So(err, ShouldBeNil)

		var m2 Message
		r := bytes.NewReader(d)
		err = m2.Decode(r)
		So(err, ShouldBeNil)

		So(fmt.Sprintf("%v", m), ShouldEqual, fmt.Sprintf("%v", &m2))
	})

	m = node.NewMessage(GET_REQUEST, "foo")
	Convey("It should encode and decode get messages", t, func() {
		d, err = m.Encode()
		So(err, ShouldBeNil)

		var m2 Message
		r := bytes.NewReader(d)
		err = m2.Decode(r)
		So(err, ShouldBeNil)

		So(fmt.Sprintf("%v", m), ShouldEqual, fmt.Sprintf("%v", &m2))
	})

	Convey("It should encode and decode get OK_RESPONSE", t, func() {
		body := GetResp{}
		body.Entry = GobEntry{C: "3"}

		m = node.NewMessage(OK_RESPONSE, body)
		d, err = m.Encode()
		So(err, ShouldBeNil)

		var m2 Message
		r := bytes.NewReader(d)
		err = m2.Decode(r)
		So(err, ShouldBeNil)

		So(fmt.Sprintf("%v", m), ShouldEqual, fmt.Sprintf("%v", &m2))
	})

}

func TestFingerprintMessage(t *testing.T) {
	Convey("it should create a unique fingerprint for messages", t, func() {
		var id peer.ID
		var mp *Message

		f, err := mp.Fingerprint()
		So(err, ShouldBeNil)
		So(f.String(), ShouldEqual, NullHash().String())
		now := time.Unix(1, 1) // pick a constant time so the test will always work
		m := Message{Type: PUT_REQUEST, Time: now, Body: "foo", From: id}

		f, err = m.Fingerprint()
		So(err, ShouldBeNil)
		So(f.String(), ShouldEqual, "QmTZf2qqYiKbJbQVpFyidMVyAtb1S4xQNV52LcX9LDVTQn")
		m = Message{Type: PUT_REQUEST, Time: now, Body: "foo1", From: id}

		f, err = m.Fingerprint()
		So(err, ShouldBeNil)
		So(f.String(), ShouldEqual, "QmP2WUSMWAuZrX2nqWcEyei7GDCwVaetkynQESFDrHNkGa")
		now = time.Unix(1, 2) // pick a constant time so the test will always work
		m = Message{Type: PUT_REQUEST, Time: now, Body: "foo", From: id}

		f, err = m.Fingerprint()
		So(err, ShouldBeNil)
		So(f.String(), ShouldEqual, "QmTZf2qqYiKbJbQVpFyidMVyAtb1S4xQNV52LcX9LDVTQn")
		m = Message{Type: GET_REQUEST, Time: now, Body: "foo", From: id}

		f, err = m.Fingerprint()
		So(err, ShouldBeNil)
		So(f.String(), ShouldEqual, "Qmd7v7bxE7xRCj3Amhx8kyj7DbUGJdbKzuiUUahx3ARPec")
	})
}

func TestErrorCoding(t *testing.T) {
	Convey("it should encode and decode errors", t, func() {
		er := NewErrorResponse(ErrHashNotFound)
		So(er.DecodeResponseError(), ShouldEqual, ErrHashNotFound)
		er = NewErrorResponse(ErrHashDeleted)
		So(er.DecodeResponseError(), ShouldEqual, ErrHashDeleted)
		er = NewErrorResponse(ErrHashModified)
		So(er.DecodeResponseError(), ShouldEqual, ErrHashModified)
		er = NewErrorResponse(ErrHashRejected)
		So(er.DecodeResponseError(), ShouldEqual, ErrHashRejected)
		er = NewErrorResponse(ErrLinkNotFound)
		So(er.DecodeResponseError(), ShouldEqual, ErrLinkNotFound)

		er = NewErrorResponse(errors.New("Some Error"))
		So(er.Code, ShouldEqual, ErrUnknownCode)
		So(er.DecodeResponseError().Error(), ShouldEqual, "Some Error")
	})
}

func TestAddPeer(t *testing.T) {
	nodesCount := 4
	mt := setupMultiNodeTesting(nodesCount)
	defer mt.cleanupMultiNodeTesting()
	nodes := mt.nodes

	h := nodes[0]
	somePeer := nodes[1].node.HashAddr
	pi := pstore.PeerInfo{ID: somePeer, Addrs: []ma.Multiaddr{nodes[1].node.NetAddr}}
	Convey("it should add a peer to the peer store and the gossip list with public key", t, func() {
		So(h.node.routingTable.Size(), ShouldEqual, 0)
		So(len(h.node.peerstore.Peers()), ShouldEqual, 1)
		if h.Config.EnableWorldModel {
			So(len(h.world.nodes), ShouldEqual, 0)
		}
		err := h.AddPeer(pi)
		So(err, ShouldBeNil)
		So(len(h.node.peerstore.Peers()), ShouldEqual, 2)
		glist, err := h.dht.getGossipers()
		So(err, ShouldBeNil)
		So(len(glist), ShouldEqual, 1)
		So(glist[0], ShouldEqual, somePeer)
		So(h.node.routingTable.Size(), ShouldEqual, 1)

		if h.Config.EnableWorldModel {
			So(len(h.world.nodes), ShouldEqual, 1)
			node1ID, _, _ := nodes[1].agent.NodeID()
			So(h.world.nodes[node1ID].PubKey.Equals(nodes[1].agent.PubKey()), ShouldBeTrue)
		}

	})

	Convey("it should not add a blocked peer", t, func() {
		blockedPeer := nodes[2].node.HashAddr
		bpi := pstore.PeerInfo{ID: blockedPeer, Addrs: []ma.Multiaddr{nodes[2].node.NetAddr}}
		h.node.Block(blockedPeer)
		err := h.AddPeer(bpi)
		So(err, ShouldEqual, ErrBlockedListed)
		So(len(h.node.peerstore.Peers()), ShouldEqual, 2)
		glist, err := h.dht.getGossipers()
		So(err, ShouldBeNil)
		So(len(glist), ShouldEqual, 1)
		So(glist[0], ShouldEqual, somePeer)
		So(h.node.routingTable.Size(), ShouldEqual, 1)
	})

	Convey("it should clear the peer's Address list if connection fails", t, func() {
		closedNode := nodes[nodesCount-1].node
		pi := pstore.PeerInfo{ID: closedNode.HashAddr, Addrs: []ma.Multiaddr{closedNode.NetAddr}}
		closedNode.Close()
		err := h.AddPeer(pi)
		So(err, ShouldEqual, nil)
		So(len(h.node.peerstore.Addrs(pi.ID)), ShouldEqual, 0)
	})
}

func TestNodeRouting(t *testing.T) {
	d, _, h := PrepareTestChain("test")
	defer CleanupTestChain(h, d)
	node := h.node

	start := 0
	testPeerCount := 20
	peers := []peer.ID{}

	peers = addTestPeers(h, peers, start, testPeerCount)
	Convey("populating routing", t, func() {
		p := node.HashAddr
		srch := node.routingTable.NearestPeers(HashFromPeerID(p), 5)
		nearest := fmt.Sprintf("%d %v", len(srch), srch)
		So(nearest, ShouldEqual, "5 [<peer.ID P9vKpw> <peer.ID P9QXqa> <peer.ID PrUBh5> <peer.ID Pn94bj> <peer.ID QHFWTH>]")
		start = testPeerCount
		testPeerCount += 5
		peers = addTestPeers(h, peers, start, testPeerCount)
		srch = node.routingTable.NearestPeers(HashFromPeerID(p), 5)
		nearest = fmt.Sprintf("%d %v", len(srch), srch)

		// adding a few more yields one which is closer
		So(nearest, ShouldEqual, "5 [<peer.ID NSQqJR> <peer.ID P9vKpw> <peer.ID P9QXqa> <peer.ID PrUBh5> <peer.ID Pn94bj>]")
		//		node.routingTable.Print()
	})
}

func TestNodeAppSendResolution(t *testing.T) {
	// if this is too high we can face `dial backoff` errors
	// https://github.com/holochain/holochain-proto/issues/706
	nodesCount := 20
	mt := setupMultiNodeTesting(nodesCount)
	defer mt.cleanupMultiNodeTesting()
	ringConnect(t, mt.ctx, mt.nodes, nodesCount)
	node1 := mt.nodes[0].node
	node2 := mt.nodes[nodesCount/2].node

	Convey("sending to nodes we aren't directly connected to should resolve", t, func() {
		m := node2.NewMessage(GOSSIP_REQUEST, GossipReq{})
		r, err := node2.Send(mt.ctx, GossipProtocol, node1.HashAddr, m)
		So(err, ShouldBeNil)
		So(r.Type, ShouldEqual, OK_RESPONSE)
		So(r.From, ShouldEqual, node1.HashAddr) // response comes from who we sent to
		So(fmt.Sprintf("%T", r.Body), ShouldEqual, "holochain.Gossip")
	})
}

func TestActivePeers(t *testing.T) {
	node, _ := makeNode(1234, "")
	defer node.Close()
	Convey("self node should be active", t, func() {
		So(node.isPeerActive(node.HashAddr), ShouldBeTrue)
	})

	otherPeer, _ := makePeer("foo")
	Convey("a peer not in the peerstore be considered inactive", t, func() {
		So(node.isPeerActive(otherPeer), ShouldBeFalse)
	})

	Convey("a peer without an address in the peerstore should be considered inactive", t, func() {
		node.peerstore.AddAddrs(otherPeer, []ma.Multiaddr{}, PeerTTL)
		So(node.isPeerActive(otherPeer), ShouldBeFalse)
	})

	Convey("it should be able to filter out inactive peers from a list", t, func() {
		filteredList := node.filterInactviePeers([]peer.ID{node.HashAddr, otherPeer}, 0)
		So(len(filteredList), ShouldEqual, 1)
		So(filteredList[0], ShouldEqual, node.HashAddr)
	})

	Convey("it should be able to limit number returned when filtering out inactive peers", t, func() {
		addr, err := ma.NewMultiaddr("/ip4/127.0.0.1/tcp/1234")
		if err != nil {
			panic(err)
		}
		node.peerstore.AddAddrs(otherPeer, []ma.Multiaddr{addr}, PeerTTL)
		filteredList := node.filterInactviePeers([]peer.ID{node.HashAddr, otherPeer}, 0)
		So(len(filteredList), ShouldEqual, 2)
		So(filteredList[0], ShouldEqual, node.HashAddr)
		So(filteredList[1], ShouldEqual, otherPeer)

		filteredList = node.filterInactviePeers([]peer.ID{node.HashAddr, otherPeer}, 1)
		So(len(filteredList), ShouldEqual, 1)
	})
}

func TestNodeStress(t *testing.T) {
	nodesCount := 4
	mt := setupMultiNodeTesting(nodesCount)
	defer mt.cleanupMultiNodeTesting()
	nodes := mt.nodes
	h1 := nodes[0]
	h2 := nodes[1]
	h3 := nodes[2]
	h4 := nodes[3]
	node1 := h1.node
	node2 := h2.node
	node3 := h3.node
	node4 := h4.node
	starConnectMutual(t, mt.ctx, nodes, nodesCount)

	Convey("hammering a node should work", t, func() {
		var i int
		var err error
		var r Message
		//count := 1000
		count := 10
		s1 := make(chan bool, count)
		s2 := make(chan bool, count)
		for i = 0; i < count; i++ {
			hash := commit(h1, "evenNumbers", fmt.Sprintf("%d", i*2))
			m := node1.NewMessage(PUT_REQUEST, HoldReq{EntryHash: hash})
			r, err = node1.Send(mt.ctx, ActionProtocol, node2.HashAddr, m)
			if err != nil || r.Type != OK_RESPONSE {
				break
			}
			go func() {
				r, err = node1.Send(mt.ctx, ActionProtocol, node3.HashAddr, m)
				if err != nil {
					panic(err)
				}
				s1 <- true
			}()
			go func() {
				r, err = node1.Send(mt.ctx, ActionProtocol, node4.HashAddr, m)
				if err != nil {
					panic(err)
				}
				s2 <- true
			}()
		}
		for i = 0; i < count; i++ {
			<-s1
			<-s2
		}
		So(i, ShouldEqual, count)
		So(err, ShouldBeNil)
		So(r.Type, ShouldEqual, OK_RESPONSE)
	})
}

func TestNodeRoutingTableBootstrap(t *testing.T) {
	nodesCount := 10
	mt := setupMultiNodeTesting(nodesCount)
	defer mt.cleanupMultiNodeTesting()
	nodes := mt.nodes

	rt := nodes[0].node.routingTable
	Convey("it should should bootstrap the routing table", t, func() {
		So(rt.Size(), ShouldEqual, 0)
		So(rt.IsEmpty(), ShouldBeTrue)

		// connect up all the nodes except 0
		for i := 0; i < nodesCount-1; i++ {
			connect(t, mt.ctx, nodes[i], nodes[i+1])
			nodes[i].node.routingTable.Update(nodes[i+1].nodeID)
		}

		//now call routing refresh to boostrap the table
		RoutingRefreshTask(nodes[0])
		So(rt.Size(), ShouldEqual, 9)
		So(rt.IsEmpty(), ShouldBeFalse)
	})
}