mirror of
https://github.com/ipfs/kubo.git
synced 2026-02-25 20:37:53 +08:00
131 lines
3.6 KiB
Go
131 lines
3.6 KiB
Go
package net_test
|
|
|
|
import (
|
|
"testing"
|
|
"time"
|
|
|
|
inet "github.com/jbenet/go-ipfs/net"
|
|
handshake "github.com/jbenet/go-ipfs/net/handshake"
|
|
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 GenNetwork(t *testing.T, ctx context.Context) inet.Network {
|
|
p := testutil.RandPeerNetParamsOrFatal(t)
|
|
ps := peer.NewPeerstore()
|
|
ps.AddAddress(p.ID, p.Addr)
|
|
ps.AddPubKey(p.ID, p.PubKey)
|
|
ps.AddPrivKey(p.ID, p.PrivKey)
|
|
n, err := inet.NewNetwork(ctx, ps.Addresses(p.ID), p.ID, ps)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return n
|
|
}
|
|
|
|
func DivulgeAddresses(a, b inet.Network) {
|
|
id := a.LocalPeer()
|
|
addrs := a.Peerstore().Addresses(id)
|
|
b.Peerstore().AddAddresses(id, addrs)
|
|
}
|
|
|
|
func subtestIDService(t *testing.T, postDialWait time.Duration) {
|
|
|
|
// the generated networks should have the id service wired in.
|
|
ctx := context.Background()
|
|
n1 := GenNetwork(t, ctx)
|
|
n2 := GenNetwork(t, ctx)
|
|
|
|
n1p := n1.LocalPeer()
|
|
n2p := n2.LocalPeer()
|
|
|
|
testKnowsAddrs(t, n1, n2p, []ma.Multiaddr{}) // nothing
|
|
testKnowsAddrs(t, n2, n1p, []ma.Multiaddr{}) // nothing
|
|
|
|
// have n2 tell n1, so we can dial...
|
|
DivulgeAddresses(n2, n1)
|
|
|
|
testKnowsAddrs(t, n1, n2p, n2.Peerstore().Addresses(n2p)) // has them
|
|
testKnowsAddrs(t, n2, n1p, []ma.Multiaddr{}) // nothing
|
|
|
|
if err := n1.DialPeer(ctx, n2p); err != nil {
|
|
t.Fatalf("Failed to dial:", err)
|
|
}
|
|
|
|
// we need to wait here if Dial returns before ID service is finished.
|
|
if postDialWait > 0 {
|
|
<-time.After(postDialWait)
|
|
}
|
|
|
|
// the IDService should be opened automatically, by the network.
|
|
// what we should see now is that both peers know about each others listen addresses.
|
|
testKnowsAddrs(t, n1, n2p, n2.Peerstore().Addresses(n2p)) // has them
|
|
testHasProtocolVersions(t, n1, n2p)
|
|
|
|
// now, this wait we do have to do. it's the wait for the Listening side
|
|
// to be done identifying the connection.
|
|
c := n2.ConnsToPeer(n1.LocalPeer())
|
|
if len(c) < 1 {
|
|
t.Fatal("should have connection by now at least.")
|
|
}
|
|
<-n2.IdentifyProtocol().IdentifyWait(c[0])
|
|
|
|
// and the protocol versions.
|
|
testKnowsAddrs(t, n2, n1p, n1.Peerstore().Addresses(n1p)) // has them
|
|
testHasProtocolVersions(t, n2, n1p)
|
|
}
|
|
|
|
func testKnowsAddrs(t *testing.T, n inet.Network, p peer.ID, expected []ma.Multiaddr) {
|
|
actual := n.Peerstore().Addresses(p)
|
|
|
|
if len(actual) != len(expected) {
|
|
t.Error("dont have the same addresses")
|
|
}
|
|
|
|
have := map[string]struct{}{}
|
|
for _, addr := range actual {
|
|
have[addr.String()] = struct{}{}
|
|
}
|
|
for _, addr := range expected {
|
|
if _, found := have[addr.String()]; !found {
|
|
t.Errorf("%s did not have addr for %s: %s", n.LocalPeer(), p, addr)
|
|
// panic("ahhhhhhh")
|
|
}
|
|
}
|
|
}
|
|
|
|
func testHasProtocolVersions(t *testing.T, n inet.Network, p peer.ID) {
|
|
v, err := n.Peerstore().Get(p, "ProtocolVersion")
|
|
if v == nil {
|
|
t.Error("no protocol version")
|
|
return
|
|
}
|
|
if v.(string) != handshake.IpfsVersion.String() {
|
|
t.Error("protocol mismatch", err)
|
|
}
|
|
v, err = n.Peerstore().Get(p, "AgentVersion")
|
|
if v.(string) != handshake.ClientVersion {
|
|
t.Error("agent version mismatch", err)
|
|
}
|
|
}
|
|
|
|
// TestIDServiceWait gives the ID service 100ms to finish after dialing
|
|
// this is becasue it used to be concurrent. Now, Dial wait till the
|
|
// id service is done.
|
|
func TestIDServiceWait(t *testing.T) {
|
|
N := 3
|
|
for i := 0; i < N; i++ {
|
|
subtestIDService(t, 100*time.Millisecond)
|
|
}
|
|
}
|
|
|
|
func TestIDServiceNoWait(t *testing.T) {
|
|
N := 3
|
|
for i := 0; i < N; i++ {
|
|
subtestIDService(t, 0)
|
|
}
|
|
}
|