p2p/netaddress_test.go

   1 package p2p
   2
   3 import (
   4         "net"
   5         "testing"
   6
   7         "github.com/stretchr/testify/assert"
   8         "github.com/stretchr/testify/require"
   9 )
  10
  11 func TestNewNetAddress(t *testing.T) {
  12         assert, require := assert.New(t), require.New(t)
  13
  14         tcpAddr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:8080")
  15         require.Nil(err)
  16         addr := NewNetAddress(tcpAddr)
  17
  18         assert.Equal("127.0.0.1:8080", addr.String())
  19
  20         assert.NotPanics(func() {
  21                 NewNetAddress(&net.UDPAddr{IP: net.ParseIP("127.0.0.1"), Port: 8000})
  22         }, "Calling NewNetAddress with UDPAddr should not panic in testing")
  23 }
  24
  25 func TestNewNetAddressString(t *testing.T) {
  26         assert := assert.New(t)
  27
  28         tests := []struct {
  29                 addr    string
  30                 correct bool
  31         }{
  32                 {"127.0.0.1:8080", true},
  33                 // {"127.0.0:8080", false},
  34                 {"a", false},
  35                 {"127.0.0.1:a", false},
  36                 {"a:8080", false},
  37                 {"8082", false},
  38                 {"127.0.0:8080000", false},
  39         }
  40
  41         for _, t := range tests {
  42                 addr, err := NewNetAddressString(t.addr)
  43                 if t.correct {
  44                         if assert.Nil(err, t.addr) {
  45                                 assert.Equal(t.addr, addr.String())
  46                         }
  47                 } else {
  48                         assert.NotNil(err, t.addr)
  49                 }
  50         }
  51 }
  52
  53 func TestNewNetAddressStrings(t *testing.T) {
  54         assert, require := assert.New(t), require.New(t)
  55         addrs, err := NewNetAddressStrings([]string{"127.0.0.1:8080", "127.0.0.2:8080"})
  56         require.Nil(err)
  57
  58         assert.Equal(2, len(addrs))
  59 }
  60
  61 func TestNewNetAddressIPPort(t *testing.T) {
  62         assert := assert.New(t)
  63         addr := NewNetAddressIPPort(net.ParseIP("127.0.0.1"), 8080)
  64
  65         assert.Equal("127.0.0.1:8080", addr.String())
  66 }
  67
  68 func TestNetAddressProperties(t *testing.T) {
  69         assert, require := assert.New(t), require.New(t)
  70
  71         // TODO add more test cases
  72         tests := []struct {
  73                 addr     string
  74                 valid    bool
  75                 local    bool
  76                 routable bool
  77         }{
  78                 {"127.0.0.1:8080", true, true, false},
  79                 {"ya.ru:80", true, false, true},
  80         }
  81
  82         for _, t := range tests {
  83                 addr, err := NewNetAddressString(t.addr)
  84                 require.Nil(err)
  85
  86                 assert.Equal(t.valid, addr.Valid())
  87                 assert.Equal(t.local, addr.Local())
  88                 assert.Equal(t.routable, addr.Routable())
  89         }
  90 }
  91
  92 func TestNetAddressReachabilityTo(t *testing.T) {
  93         assert, require := assert.New(t), require.New(t)
  94
  95         // TODO add more test cases
  96         tests := []struct {
  97                 addr         string
  98                 other        string
  99                 reachability int
 100         }{
 101                 {"127.0.0.1:8080", "127.0.0.1:8081", 0},
 102                 {"ya.ru:80", "127.0.0.1:8080", 1},
 103         }
 104
 105         for _, t := range tests {
 106                 addr, err := NewNetAddressString(t.addr)
 107                 require.Nil(err)
 108
 109                 other, err := NewNetAddressString(t.other)
 110                 require.Nil(err)
 111
 112                 assert.Equal(t.reachability, addr.ReachabilityTo(other))
 113         }
 114 }