github.com/okex/exchain@v1.8.0/libs/tendermint/p2p/netaddress_test.go (about)

     1  package p2p
     2  
     3  import (
     4  	"net"
     5  	"sync"
     6  	"testing"
     7  
     8  	"github.com/stretchr/testify/assert"
     9  	"github.com/stretchr/testify/require"
    10  )
    11  
    12  func TestNewNetAddress(t *testing.T) {
    13  	tcpAddr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:8080")
    14  	require.Nil(t, err)
    15  
    16  	assert.Panics(t, func() {
    17  		NewNetAddress("", tcpAddr)
    18  	})
    19  
    20  	addr := NewNetAddress("deadbeefdeadbeefdeadbeefdeadbeefdeadbeef", tcpAddr)
    21  	assert.Equal(t, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", addr.String())
    22  
    23  	assert.NotPanics(t, func() {
    24  		NewNetAddress("", &net.UDPAddr{IP: net.ParseIP("127.0.0.1"), Port: 8000})
    25  	}, "Calling NewNetAddress with UDPAddr should not panic in testing")
    26  }
    27  
    28  func TestNewNetAddressString(t *testing.T) {
    29  	testCases := []struct {
    30  		name     string
    31  		addr     string
    32  		expected string
    33  		correct  bool
    34  	}{
    35  		{"no node id and no protocol", "127.0.0.1:8080", "", false},
    36  		{"no node id w/ tcp input", "tcp://127.0.0.1:8080", "", false},
    37  		{"no node id w/ udp input", "udp://127.0.0.1:8080", "", false},
    38  
    39  		{
    40  			"no protocol",
    41  			"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
    42  			"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
    43  			true,
    44  		},
    45  		{
    46  			"tcp input",
    47  			"tcp://deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
    48  			"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
    49  			true,
    50  		},
    51  		{
    52  			"udp input",
    53  			"udp://deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
    54  			"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
    55  			true,
    56  		},
    57  		{"malformed tcp input", "tcp//deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", "", false},
    58  		{"malformed udp input", "udp//deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", "", false},
    59  
    60  		// {"127.0.0:8080", false},
    61  		{"invalid host", "notahost", "", false},
    62  		{"invalid port", "127.0.0.1:notapath", "", false},
    63  		{"invalid host w/ port", "notahost:8080", "", false},
    64  		{"just a port", "8082", "", false},
    65  		{"non-existent port", "127.0.0:8080000", "", false},
    66  
    67  		{"too short nodeId", "deadbeef@127.0.0.1:8080", "", false},
    68  		{"too short, not hex nodeId", "this-isnot-hex@127.0.0.1:8080", "", false},
    69  		{"not hex nodeId", "xxxxbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", "", false},
    70  
    71  		{"too short nodeId w/tcp", "tcp://deadbeef@127.0.0.1:8080", "", false},
    72  		{"too short notHex nodeId w/tcp", "tcp://this-isnot-hex@127.0.0.1:8080", "", false},
    73  		{"notHex nodeId w/tcp", "tcp://xxxxbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", "", false},
    74  		{
    75  			"correct nodeId w/tcp",
    76  			"tcp://deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
    77  			"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
    78  			true,
    79  		},
    80  
    81  		{"no node id", "tcp://@127.0.0.1:8080", "", false},
    82  		{"no node id or IP", "tcp://@", "", false},
    83  		{"tcp no host, w/ port", "tcp://:26656", "", false},
    84  		{"empty", "", "", false},
    85  		{"node id delimiter 1", "@", "", false},
    86  		{"node id delimiter 2", " @", "", false},
    87  		{"node id delimiter 3", " @ ", "", false},
    88  	}
    89  
    90  	for _, tc := range testCases {
    91  		tc := tc
    92  		t.Run(tc.name, func(t *testing.T) {
    93  			addr, err := NewNetAddressString(tc.addr)
    94  			if tc.correct {
    95  				if assert.Nil(t, err, tc.addr) {
    96  					assert.Equal(t, tc.expected, addr.String())
    97  				}
    98  			} else {
    99  				assert.NotNil(t, err, tc.addr)
   100  			}
   101  		})
   102  	}
   103  }
   104  
   105  func TestNewNetAddressStrings(t *testing.T) {
   106  	addrs, errs := NewNetAddressStrings([]string{
   107  		"127.0.0.1:8080",
   108  		"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
   109  		"deadbeefdeadbeefdeadbeefdeadbeefdeadbeed@127.0.0.2:8080"})
   110  	assert.Len(t, errs, 1)
   111  	assert.Equal(t, 2, len(addrs))
   112  }
   113  
   114  func TestNewNetAddressIPPort(t *testing.T) {
   115  	addr := NewNetAddressIPPort(net.ParseIP("127.0.0.1"), 8080)
   116  	assert.Equal(t, "127.0.0.1:8080", addr.String())
   117  }
   118  
   119  func TestNetAddressProperties(t *testing.T) {
   120  	// TODO add more test cases
   121  	testCases := []struct {
   122  		addr     string
   123  		valid    bool
   124  		local    bool
   125  		routable bool
   126  	}{
   127  		{"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", true, true, false},
   128  		{"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@ya.ru:80", true, false, true},
   129  	}
   130  
   131  	for _, tc := range testCases {
   132  		addr, err := NewNetAddressString(tc.addr)
   133  		require.Nil(t, err)
   134  
   135  		err = addr.Valid()
   136  		if tc.valid {
   137  			assert.NoError(t, err)
   138  		} else {
   139  			assert.Error(t, err)
   140  		}
   141  		assert.Equal(t, tc.local, addr.Local())
   142  		assert.Equal(t, tc.routable, addr.Routable())
   143  	}
   144  }
   145  
   146  func TestNetAddressReachabilityTo(t *testing.T) {
   147  	// TODO add more test cases
   148  	testCases := []struct {
   149  		addr         string
   150  		other        string
   151  		reachability int
   152  	}{
   153  		{
   154  			"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080",
   155  			"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8081",
   156  			0,
   157  		},
   158  		{"deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@ya.ru:80", "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", 1},
   159  	}
   160  
   161  	for _, tc := range testCases {
   162  		addr, err := NewNetAddressString(tc.addr)
   163  		require.Nil(t, err)
   164  
   165  		other, err := NewNetAddressString(tc.other)
   166  		require.Nil(t, err)
   167  
   168  		assert.Equal(t, tc.reachability, addr.ReachabilityTo(other))
   169  	}
   170  }
   171  
   172  func TestNetAddress_String(t *testing.T) {
   173  	tcpAddr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:8080")
   174  	require.Nil(t, err)
   175  
   176  	netAddr := NewNetAddress("deadbeefdeadbeefdeadbeefdeadbeefdeadbeef", tcpAddr)
   177  
   178  	var wg sync.WaitGroup
   179  
   180  	for i := 0; i < 100; i++ {
   181  		wg.Add(1)
   182  		go func() {
   183  			defer wg.Done()
   184  			_ = netAddr.String()
   185  		}()
   186  	}
   187  
   188  	wg.Wait()
   189  
   190  	s := netAddr.String()
   191  	require.Equal(t, "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef@127.0.0.1:8080", s)
   192  }
   193  
   194  func TestSafeStoreLoad(t *testing.T) {
   195  	tcpAddr, err := net.ResolveTCPAddr("tcp", "127.0.0.1:8080")
   196  	require.Nil(t, err)
   197  
   198  	netAddr := NewNetAddress("deadbeefdeadbeefdeadbeefdeadbeefdeadbeef", tcpAddr)
   199  	str := netAddr.safeLoadStr()
   200  	require.Nil(t, str)
   201  	netAddr.safeStoreStr("test01")
   202  	str = netAddr.safeLoadStr()
   203  	require.NotNil(t, str)
   204  	require.Equal(t, *str, "test01")
   205  }