refactor test peer creation to be deterministic and reliable

ipfs · Dec 21, 2014 · c2610af · c2610af
1 parent 364e938
commit c2610af
Show file tree

Hide file tree

Showing 16 changed files with 67 additions and 91 deletions.
diff --git a/cmd/ipfs/init.go b/cmd/ipfs/init.go
@@ -2,6 +2,7 @@ package main
 
 import (
 	"bytes"
+	"crypto/rand"
 	"encoding/base64"
 	"fmt"
 	"os"
@@ -252,7 +253,7 @@ func identityConfig(nbits int) (config.Identity, error) {
 	}
 
 	fmt.Printf("generating key pair...")
-	sk, pk, err := ci.GenerateKeyPair(ci.RSA, nbits)
+	sk, pk, err := ci.GenerateKeyPair(ci.RSA, nbits, rand.Reader)
 	if err != nil {
 		return ident, err
 	}

diff --git a/cmd/seccat/seccat.go b/cmd/seccat/seccat.go
@@ -115,7 +115,7 @@ func setupPeer(a args) (peer.Peer, peer.Peerstore, error) {
 	}
 
 	out("generating key pair...")
-	sk, pk, err := ci.GenerateKeyPair(ci.RSA, a.keybits)
+	sk, pk, err := ci.GenerateKeyPair(ci.RSA, a.keybits, u.NewTimeSeededRand())
 	if err != nil {
 		return nil, nil, err
 	}

diff --git a/core/mock.go b/core/mock.go
@@ -1,6 +1,8 @@
 package core
 
 import (
+	"crypto/rand"
+
 	ds "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore"
 	syncds "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore/sync"
 	"github.com/jbenet/go-ipfs/blocks/blockstore"
@@ -20,7 +22,7 @@ func NewMockNode() (*IpfsNode, error) {
 	nd := new(IpfsNode)
 
 	// Generate Identity
-	sk, pk, err := ci.GenerateKeyPair(ci.RSA, 1024)
+	sk, pk, err := ci.GenerateKeyPair(ci.RSA, 1024, rand.Reader)
 	if err != nil {
 		return nil, err
 	}

diff --git a/crypto/key.go b/crypto/key.go
@@ -7,6 +7,7 @@ import (
 	"bytes"
 	"errors"
 	"fmt"
+	"io"
 
 	"crypto/elliptic"
 	"crypto/hmac"
@@ -74,10 +75,10 @@ type PubKey interface {
 type GenSharedKey func([]byte) ([]byte, error)
 
 // Generates a keypair of the given type and bitsize
-func GenerateKeyPair(typ, bits int) (PrivKey, PubKey, error) {
+func GenerateKeyPair(typ, bits int, src io.Reader) (PrivKey, PubKey, error) {
 	switch typ {
 	case RSA:
-		priv, err := rsa.GenerateKey(rand.Reader, bits)
+		priv, err := rsa.GenerateKey(src, bits)
 		if err != nil {
 			return nil, nil, err
 		}

diff --git a/crypto/key_test.go b/crypto/key_test.go
@@ -1,9 +1,12 @@
 package crypto
 
-import "testing"
+import (
+	u "github.com/jbenet/go-ipfs/util"
+	"testing"
+)
 
 func TestRsaKeys(t *testing.T) {
-	sk, pk, err := GenerateKeyPair(RSA, 512)
+	sk, pk, err := GenerateKeyPair(RSA, 512, u.NewTimeSeededRand())
 	if err != nil {
 		t.Fatal(err)
 	}
@@ -69,7 +72,7 @@ func testKeyEquals(t *testing.T, k Key) {
 		t.Fatal("Key not equal to key with same bytes.")
 	}
 
-	sk, pk, err := GenerateKeyPair(RSA, 512)
+	sk, pk, err := GenerateKeyPair(RSA, 512, u.NewTimeSeededRand())
 	if err != nil {
 		t.Fatal(err)
 	}

diff --git a/crypto/spipe/spipe_test.go b/crypto/spipe/spipe_test.go
@@ -8,12 +8,13 @@ import (
 	ci "github.com/jbenet/go-ipfs/crypto"
 	"github.com/jbenet/go-ipfs/peer"
 	"github.com/jbenet/go-ipfs/util"
+	u "github.com/jbenet/go-ipfs/util"
 	"github.com/jbenet/go-ipfs/util/pipes"
 	testutil "github.com/jbenet/go-ipfs/util/testutil"
 )
 
 func getPeer(tb testing.TB) peer.Peer {
-	privk, pubk, err := ci.GenerateKeyPair(ci.RSA, 1024)
+	privk, pubk, err := ci.GenerateKeyPair(ci.RSA, 1024, u.NewTimeSeededRand())
 	if err != nil {
 		tb.Fatal(err)
 	}

diff --git a/namesys/resolve_test.go b/namesys/resolve_test.go
@@ -16,7 +16,7 @@ func TestRoutingResolve(t *testing.T) {
 	resolver := NewRoutingResolver(d)
 	publisher := NewRoutingPublisher(d)
 
-	privk, pubk, err := ci.GenerateKeyPair(ci.RSA, 512)
+	privk, pubk, err := ci.GenerateKeyPair(ci.RSA, 512, u.NewTimeSeededRand())
 	if err != nil {
 		t.Fatal(err)
 	}

diff --git a/net/conn/dial_test.go b/net/conn/dial_test.go
@@ -4,33 +4,12 @@ import (
 	"io"
 	"testing"
 
-	ci "github.com/jbenet/go-ipfs/crypto"
 	peer "github.com/jbenet/go-ipfs/peer"
 	testutil "github.com/jbenet/go-ipfs/util/testutil"
 
 	context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
-	ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
 )
 
-func setupPeer(addr string) (peer.Peer, error) {
-	tcp, err := ma.NewMultiaddr(addr)
-	if err != nil {
-		return nil, err
-	}
-
-	sk, pk, err := ci.GenerateKeyPair(ci.RSA, 512)
-	if err != nil {
-		return nil, err
-	}
-
-	p, err := testutil.NewPeerWithKeyPair(sk, pk)
-	if err != nil {
-		return nil, err
-	}
-	p.AddAddress(tcp)
-	return p, nil
-}
-
 func echoListen(ctx context.Context, listener Listener) {
 	for {
 		c, err := listener.Accept()
@@ -59,12 +38,12 @@ func setupSingleConn(t *testing.T, ctx context.Context, a1, a2 string) (a, b Con
 
 func setupConn(t *testing.T, ctx context.Context, a1, a2 string, secure bool) (a, b Conn) {
 
-	p1, err := setupPeer(a1)
+	p1, err := testutil.PeerWithKeysAndStringAddress(a1)
 	if err != nil {
 		t.Fatal("error setting up peer", err)
 	}
 
-	p2, err := setupPeer(a2)
+	p2, err := testutil.PeerWithKeysAndStringAddress(a2)
 	if err != nil {
 		t.Fatal("error setting up peer", err)
 	}
@@ -114,12 +93,12 @@ func setupConn(t *testing.T, ctx context.Context, a1, a2 string, secure bool) (a
 func TestDialer(t *testing.T) {
 	// t.Skip("Skipping in favor of another test")
 
-	p1, err := setupPeer("/ip4/127.0.0.1/tcp/4234")
+	p1, err := testutil.PeerWithKeysAndStringAddress("/ip4/127.0.0.1/tcp/4234")
 	if err != nil {
 		t.Fatal("error setting up peer", err)
 	}
 
-	p2, err := setupPeer("/ip4/127.0.0.1/tcp/4235")
+	p2, err := testutil.PeerWithKeysAndStringAddress("/ip4/127.0.0.1/tcp/4235")
 	if err != nil {
 		t.Fatal("error setting up peer", err)
 	}
@@ -187,12 +166,12 @@ func TestDialer(t *testing.T) {
 func TestDialAddr(t *testing.T) {
 	// t.Skip("Skipping in favor of another test")
 
-	p1, err := setupPeer("/ip4/127.0.0.1/tcp/4334")
+	p1, err := testutil.PeerWithKeysAndStringAddress("/ip4/127.0.0.1/tcp/4334")
 	if err != nil {
 		t.Fatal("error setting up peer", err)
 	}
 
-	p2, err := setupPeer("/ip4/127.0.0.1/tcp/4335")
+	p2, err := testutil.PeerWithKeysAndStringAddress("/ip4/127.0.0.1/tcp/4335")
 	if err != nil {
 		t.Fatal("error setting up peer", err)
 	}

diff --git a/net/mock/mock_net.go b/net/mock/mock_net.go
@@ -41,7 +41,7 @@ func New(ctx context.Context) Mocknet {
 }
 
 func (mn *mocknet) GenPeer() (inet.Network, error) {
-	p, err := testutil.PeerWithNewKeys()
+	p, err := testutil.DeterministicPeer(int64(len(mn.nets)))
 	if err != nil {
 		return nil, err
 	}

diff --git a/net/swarm/swarm_test.go b/net/swarm/swarm_test.go
@@ -7,14 +7,12 @@ import (
 	"testing"
 	"time"
 
-	ci "github.com/jbenet/go-ipfs/crypto"
 	peer "github.com/jbenet/go-ipfs/peer"
 	u "github.com/jbenet/go-ipfs/util"
 	errors "github.com/jbenet/go-ipfs/util/debugerror"
 	testutil "github.com/jbenet/go-ipfs/util/testutil"
 
 	context "github.com/jbenet/go-ipfs/Godeps/_workspace/src/code.google.com/p/go.net/context"
-	ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
 )
 
 func EchoStreamHandler(stream *Stream) {
@@ -48,30 +46,14 @@ func EchoStreamHandler(stream *Stream) {
 	}()
 }
 
-func setupPeer(t *testing.T, addr string) peer.Peer {
-	tcp, err := ma.NewMultiaddr(addr)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	sk, pk, err := ci.GenerateKeyPair(ci.RSA, 512)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	p, err := testutil.NewPeerWithKeyPair(sk, pk)
-	if err != nil {
-		t.Fatal(err)
-	}
-	p.AddAddress(tcp)
-	return p
-}
-
 func makeSwarms(ctx context.Context, t *testing.T, addrs []string) ([]*Swarm, []peer.Peer) {
 	swarms := []*Swarm{}
 
 	for _, addr := range addrs {
-		local := setupPeer(t, addr)
+		local, err := testutil.PeerWithKeysAndStringAddress(addr)
+		if err != nil {
+			t.Fatal(err)
+		}
 		peerstore := peer.NewPeerstore()
 		swarm, err := NewSwarm(ctx, local.Addresses(), local, peerstore)
 		if err != nil {

diff --git a/routing/dht/dht_test.go b/routing/dht/dht_test.go
@@ -11,7 +11,6 @@ import (
 	ds "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-datastore"
 	ma "github.com/jbenet/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
 
-	ci "github.com/jbenet/go-ipfs/crypto"
 	inet "github.com/jbenet/go-ipfs/net"
 	peer "github.com/jbenet/go-ipfs/peer"
 	u "github.com/jbenet/go-ipfs/util"
@@ -60,7 +59,7 @@ func setupDHTS(ctx context.Context, n int, t *testing.T) ([]ma.Multiaddr, []peer
 
 	var peers []peer.Peer
 	for i := 0; i < n; i++ {
-		p := makePeer(addrs[i])
+		p := makePeer(addrs[i], int64(i))
 		peers = append(peers, p)
 	}
 
@@ -72,20 +71,8 @@ func setupDHTS(ctx context.Context, n int, t *testing.T) ([]ma.Multiaddr, []peer
 	return addrs, peers, dhts
 }
 
-func makePeerString(t *testing.T, addr string) peer.Peer {
-	maddr, err := ma.NewMultiaddr(addr)
-	if err != nil {
-		t.Fatal(err)
-	}
-	return makePeer(maddr)
-}
-
-func makePeer(addr ma.Multiaddr) peer.Peer {
-	sk, pk, err := ci.GenerateKeyPair(ci.RSA, 512)
-	if err != nil {
-		panic(err)
-	}
-	p, err := testutil.NewPeerWithKeyPair(sk, pk)
+func makePeer(addr ma.Multiaddr, seed int64) peer.Peer {
+	p, err := testutil.DeterministicPeer(seed)
 	if err != nil {
 		panic(err)
 	}
@@ -100,8 +87,8 @@ func TestPing(t *testing.T) {
 	addrA := randMultiaddr(t)
 	addrB := randMultiaddr(t)
 
-	peerA := makePeer(addrA)
-	peerB := makePeer(addrB)
+	peerA := makePeer(addrA, 1)
+	peerB := makePeer(addrB, 2)
 
 	dhtA := setupDHT(ctx, t, peerA)
 	dhtB := setupDHT(ctx, t, peerB)
@@ -139,8 +126,8 @@ func TestValueGetSet(t *testing.T) {
 	addrA := randMultiaddr(t)
 	addrB := randMultiaddr(t)
 
-	peerA := makePeer(addrA)
-	peerB := makePeer(addrB)
+	peerA := makePeer(addrA, 1)
+	peerB := makePeer(addrB, 2)
 
 	dhtA := setupDHT(ctx, t, peerA)
 	dhtB := setupDHT(ctx, t, peerB)
@@ -517,8 +504,8 @@ func TestConnectCollision(t *testing.T) {
 		addrA := randMultiaddr(t)
 		addrB := randMultiaddr(t)
 
-		peerA := makePeer(addrA)
-		peerB := makePeer(addrB)
+		peerA := makePeer(addrA, int64((rtime*2)+1))
+		peerB := makePeer(addrB, int64((rtime*2)+2))
 
 		dhtA := setupDHT(ctx, t, peerA)
 		dhtB := setupDHT(ctx, t, peerB)

diff --git a/routing/dht/ext_test.go b/routing/dht/ext_test.go
@@ -34,8 +34,8 @@ func TestGetFailures(t *testing.T) {
 	nets := mn.Nets()
 	peers := mn.Peers()
 
-	ps := peer.NewPeerstore()
-	d := NewDHT(ctx, peers[0], ps, nets[0], ds.NewMapDatastore())
+	psa := peer.NewPeerstore()
+	d := NewDHT(ctx, peers[0], psa, nets[0], ds.NewMapDatastore())
 	d.Update(ctx, peers[1])
 
 	// This one should time out

diff --git a/routing/dht/query.go b/routing/dht/query.go
@@ -155,6 +155,7 @@ func (r *dhtQueryRunner) Run(peers []peer.Peer) (*dhtQueryResult, error) {
 }
 
 func (r *dhtQueryRunner) addPeerToQuery(next peer.Peer, benchmark peer.Peer) {
+	log.Debugf("try to add peer: %s", next)
 	if next == nil {
 		// wtf why are peers nil?!?
 		log.Error("Query getting nil peers!!!\n")
@@ -163,18 +164,21 @@ func (r *dhtQueryRunner) addPeerToQuery(next peer.Peer, benchmark peer.Peer) {
 
 	// if new peer is ourselves...
 	if next.ID().Equal(r.query.dialer.LocalPeer().ID()) {
+		log.Debug("query peer was ourself")
 		return
 	}
 
 	// if new peer further away than whom we got it from, don't bother (loops)
 	if benchmark != nil && kb.Closer(benchmark.ID(), next.ID(), r.query.key) {
+		log.Debug("query peer was not closer")
 		return
 	}
 
 	// if already seen, no need.
 	r.Lock()
 	_, found := r.peersSeen[next.Key()]
 	if found {
+		log.Debug("query peer was already seen")
 		r.Unlock()
 		return
 	}