github.com/keltia/go-ipfs@v0.3.8-0.20150909044612-210793031c63/p2p/net/swarm/swarm_addr_test.go (about)

     1  package swarm
     2  
     3  import (
     4  	"testing"
     5  
     6  	metrics "github.com/ipfs/go-ipfs/metrics"
     7  	addrutil "github.com/ipfs/go-ipfs/p2p/net/swarm/addr"
     8  	peer "github.com/ipfs/go-ipfs/p2p/peer"
     9  	testutil "github.com/ipfs/go-ipfs/util/testutil"
    10  
    11  	ma "github.com/ipfs/go-ipfs/Godeps/_workspace/src/github.com/jbenet/go-multiaddr"
    12  	context "github.com/ipfs/go-ipfs/Godeps/_workspace/src/golang.org/x/net/context"
    13  )
    14  
    15  func TestFilterAddrs(t *testing.T) {
    16  
    17  	m := func(s string) ma.Multiaddr {
    18  		maddr, err := ma.NewMultiaddr(s)
    19  		if err != nil {
    20  			t.Fatal(err)
    21  		}
    22  		return maddr
    23  	}
    24  
    25  	bad := []ma.Multiaddr{
    26  		m("/ip4/1.2.3.4/udp/1234"),           // unreliable
    27  		m("/ip4/1.2.3.4/udp/1234/sctp/1234"), // not in manet
    28  		m("/ip4/1.2.3.4/udp/1234/utp"),       // utp is broken
    29  		m("/ip4/1.2.3.4/udp/1234/udt"),       // udt is broken on arm
    30  		m("/ip6/fe80::1/tcp/0"),              // link local
    31  		m("/ip6/fe80::100/tcp/1234"),         // link local
    32  	}
    33  
    34  	good := []ma.Multiaddr{
    35  		m("/ip4/127.0.0.1/tcp/0"),
    36  		m("/ip6/::1/tcp/0"),
    37  	}
    38  
    39  	goodAndBad := append(good, bad...)
    40  
    41  	// test filters
    42  
    43  	for _, a := range bad {
    44  		if addrutil.AddrUsable(a, true) {
    45  			t.Errorf("addr %s should be unusable", a)
    46  		}
    47  	}
    48  
    49  	for _, a := range good {
    50  		if !addrutil.AddrUsable(a, true) {
    51  			t.Errorf("addr %s should be usable", a)
    52  		}
    53  	}
    54  
    55  	subtestAddrsEqual(t, addrutil.FilterUsableAddrs(bad), []ma.Multiaddr{})
    56  	subtestAddrsEqual(t, addrutil.FilterUsableAddrs(good), good)
    57  	subtestAddrsEqual(t, addrutil.FilterUsableAddrs(goodAndBad), good)
    58  
    59  	// now test it with swarm
    60  
    61  	id, err := testutil.RandPeerID()
    62  	if err != nil {
    63  		t.Fatal(err)
    64  	}
    65  
    66  	ps := peer.NewPeerstore()
    67  	ctx := context.Background()
    68  
    69  	if _, err := NewNetwork(ctx, bad, id, ps, metrics.NewBandwidthCounter()); err == nil {
    70  		t.Fatal("should have failed to create swarm")
    71  	}
    72  
    73  	if _, err := NewNetwork(ctx, goodAndBad, id, ps, metrics.NewBandwidthCounter()); err != nil {
    74  		t.Fatal("should have succeeded in creating swarm", err)
    75  	}
    76  }
    77  
    78  func subtestAddrsEqual(t *testing.T, a, b []ma.Multiaddr) {
    79  	if len(a) != len(b) {
    80  		t.Error(t)
    81  	}
    82  
    83  	in := func(addr ma.Multiaddr, l []ma.Multiaddr) bool {
    84  		for _, addr2 := range l {
    85  			if addr.Equal(addr2) {
    86  				return true
    87  			}
    88  		}
    89  		return false
    90  	}
    91  
    92  	for _, aa := range a {
    93  		if !in(aa, b) {
    94  			t.Errorf("%s not in %s", aa, b)
    95  		}
    96  	}
    97  }
    98  
    99  func TestDialBadAddrs(t *testing.T) {
   100  
   101  	m := func(s string) ma.Multiaddr {
   102  		maddr, err := ma.NewMultiaddr(s)
   103  		if err != nil {
   104  			t.Fatal(err)
   105  		}
   106  		return maddr
   107  	}
   108  
   109  	ctx := context.Background()
   110  	s := makeSwarms(ctx, t, 1)[0]
   111  
   112  	test := func(a ma.Multiaddr) {
   113  		p := testutil.RandPeerIDFatal(t)
   114  		s.peers.AddAddr(p, a, peer.PermanentAddrTTL)
   115  		if _, err := s.Dial(ctx, p); err == nil {
   116  			t.Error("swarm should not dial: %s", m)
   117  		}
   118  	}
   119  
   120  	test(m("/ip6/fe80::1"))                // link local
   121  	test(m("/ip6/fe80::100"))              // link local
   122  	test(m("/ip4/127.0.0.1/udp/1234/utp")) // utp
   123  }