p2p/netaddress_test.go

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