added test for getPeerMsg/peerMsg - FAILS

p2p/protocol_test.go

@@ -29,108 +29,52 @@ func testPeerFree() (peer *Peer) {
 	peer.pubkeyHook = func(*peerAddr) error { return nil }
 	peer.ourID = &peerId{}
 	peer.listenAddr = &peerAddr{}
+	peer.otherPeers = func() []*Peer { return nil }
 	return
 }
 
-func TestPeersMsg(t *testing.T) {
+func TestBaseProtocolPeers(t *testing.T) {
-	var peers []*Peer
+	cannedPeerList := []*peerAddr{
-	for i := 0; i < 3; i++ {
+		{IP: net.ParseIP("1.2.3.4"), Port: 2222, Pubkey: []byte{}},
-		peers = append(peers, testPeerFree())
+		{IP: net.ParseIP("5.6.7.8"), Port: 3333, Pubkey: []byte{}},
 	}
-	peer1 := testPeerFree()
-	peer1.newPeerAddr = make(chan *peerAddr)
-	peer1.otherPeers = func() []*Peer {
-		return peers
-	}
-
-	peer2 := testPeerFree()
-	peer2.newPeerAddr = make(chan *peerAddr)
-	peer2.otherPeers = func() []*Peer {
-		return peers
-	}
-
 	rw1, rw2 := MsgPipe()
-	fmt.Printf("all set up\n	")
+	// run matcher, close pipe when addresses have arrived
-
+	addrChan := make(chan *peerAddr, len(cannedPeerList))
-	done := make(chan struct{})
 	go func() {
-		fmt.Printf("expect handshake\n	")
+		for _, want := range cannedPeerList {
-
+			got := <-addrChan
-		if err := expectMsg(rw2, handshakeMsg); err != nil {
+			t.Logf("got peer: %+v", got)
-			t.Error(err)
+			if !reflect.DeepEqual(want, got) {
-		}
+				t.Errorf("mismatch:  got %#v, want %#v", got, want)
-		fmt.Printf("send handshake\n	")
-
-		err := rw2.EncodeMsg(handshakeMsg,
-			baseProtocolVersion,
-			"",
-			[]interface{}{},
-			0,
-			make([]byte, 64),
-		)
-		if err != nil {
-			t.Error(err)
-		}
-		fmt.Printf("send getPeers msg\n")
-
-		if err := rw2.EncodeMsg(getPeersMsg); err != nil {
-			t.Error(err)
-		}
-		fmt.Printf("expecting peersMsg\n")
-		var msg Msg
-		if msg, err = rw2.ReadMsg(); err != nil {
-			t.Error(err)
-			return
-		}
-
-		var addrs []*peerAddr
-		fmt.Printf("got peersMsg\n")
-		if err := msg.Decode(&addrs); err != nil {
-			t.Errorf("msg %v : %v", msg, err)
-		}
-		fmt.Printf("decoding done\n")
-
-		if len(addrs) != 3 {
-			t.Errorf("too few peer addresses, expected %v, got %v", 3, len(addrs))
-		}
-		fmt.Printf("count ok\n")
-
-		for i, p := range peers {
-			if i == len(addrs) {
-				break
-			}
-			addr := addrs[i]
-			fmt.Printf("addr %v: %v\n", i, addr)
-			if addr != p.listenAddr {
-				t.Errorf("incorrect peer address %v (%v)", addr, i)
-			}
-			if addr == nil {
-				t.Errorf("no processing %v", i)
 			}
 		}
-		fmt.Printf("complete\n")
+		close(addrChan)
-		if err := expectMsg(rw2, peersMsg); err != nil {
+		var own []*peerAddr
-			t.Error(err)
+		for _, got = range addrChan {
+			own = append(own, got)
 		}
-
+		if len(own) != 1 || !reflect.DeepEqual(own[0], ourAddr) {
-		if err := rw2.EncodeMsg(discMsg, DiscQuitting); err != nil {
+			t.Errorf("mismatch: peers own address is incorrectly or not given, got %v, want %#v", ownAddr, own)
-			t.Error(err)
 		}
-
+		rw2.Close()
-		close(done)
-		fmt.Printf("done channel closed")
 	}()
-
+	// run first peer
-	fmt.Printf("proto")
+	peer1 := testPeer()
-
+	peer1.otherPeers = func() []*Peer {
-	if err := runBaseProtocol(peer1, rw1); err == nil {
+		pl := make([]*Peer, len(cannedPeerList))
-		t.Errorf("base protocol returned without error")
+		for i, addr := range cannedPeerList {
-	} else if reason, ok := err.(discRequestedError); !ok || reason != DiscQuitting {
+			pl[i] = &Peer{listenAddr: addr}
-		t.Errorf("base protocol returned wrong error: %v", err)
+		}
+		return pl
+	}
+	go runBaseProtocol(peer1, rw1)
+	// run second peer
+	peer2 := testPeer()
+	peer2.newPeerAddr = addrChan // feed peer suggestions into matcher
+	if err := runBaseProtocol(peer2, rw2); err != ErrPipeClosed {
+		t.Errorf("peer2 terminated with unexpected error: %v", err)
 	}
-
-	<-done
-	t.Error("oops")
 }
 
 func TestBaseProtocolDisconnect(t *testing.T) {