github.com/nspcc-dev/neo-go@v0.105.2-0.20240517133400-6be757af3eba/pkg/network/payload/address_test.go (about)

     1  package payload
     2  
     3  import (
     4  	"fmt"
     5  	"net"
     6  	"testing"
     7  	"time"
     8  
     9  	"github.com/nspcc-dev/neo-go/internal/testserdes"
    10  	"github.com/nspcc-dev/neo-go/pkg/network/capability"
    11  	"github.com/stretchr/testify/assert"
    12  	"github.com/stretchr/testify/require"
    13  )
    14  
    15  func TestEncodeDecodeAddress(t *testing.T) {
    16  	var (
    17  		e, _ = net.ResolveTCPAddr("tcp", "127.0.0.1:2000")
    18  		ts   = time.Now()
    19  		addr = NewAddressAndTime(e, ts, capability.Capabilities{
    20  			{
    21  				Type: capability.TCPServer,
    22  				Data: &capability.Server{Port: uint16(e.Port)},
    23  			},
    24  		})
    25  	)
    26  
    27  	assert.Equal(t, ts.UTC().Unix(), int64(addr.Timestamp))
    28  
    29  	// On Windows or macOS localhost can be resolved to 4-bytes IPv4.
    30  	expected := make(net.IP, 16)
    31  	copy(expected, e.IP[:])
    32  
    33  	aatip := make(net.IP, 16)
    34  	copy(aatip, addr.IP[:])
    35  
    36  	assert.Equal(t, expected, aatip)
    37  	assert.Equal(t, 1, len(addr.Capabilities))
    38  	assert.Equal(t, capability.Capability{
    39  		Type: capability.TCPServer,
    40  		Data: &capability.Server{Port: uint16(e.Port)},
    41  	}, addr.Capabilities[0])
    42  
    43  	testserdes.EncodeDecodeBinary(t, addr, new(AddressAndTime))
    44  }
    45  
    46  func fillAddressList(al *AddressList) {
    47  	for i := 0; i < len(al.Addrs); i++ {
    48  		e, _ := net.ResolveTCPAddr("tcp", fmt.Sprintf("127.0.0.1:20%d", i))
    49  		al.Addrs[i] = NewAddressAndTime(e, time.Now(), capability.Capabilities{
    50  			{
    51  				Type: capability.TCPServer,
    52  				Data: &capability.Server{Port: 123},
    53  			},
    54  		})
    55  	}
    56  }
    57  
    58  func TestEncodeDecodeAddressList(t *testing.T) {
    59  	var lenList uint8 = 4
    60  	addrList := NewAddressList(int(lenList))
    61  	fillAddressList(addrList)
    62  	testserdes.EncodeDecodeBinary(t, addrList, new(AddressList))
    63  }
    64  
    65  func TestEncodeDecodeBadAddressList(t *testing.T) {
    66  	var newAL = new(AddressList)
    67  	addrList := NewAddressList(MaxAddrsCount + 1)
    68  	fillAddressList(addrList)
    69  
    70  	bin, err := testserdes.EncodeBinary(addrList)
    71  	require.NoError(t, err)
    72  	err = testserdes.DecodeBinary(bin, newAL)
    73  	require.Error(t, err)
    74  
    75  	addrList = NewAddressList(0)
    76  	bin, err = testserdes.EncodeBinary(addrList)
    77  	require.NoError(t, err)
    78  	err = testserdes.DecodeBinary(bin, newAL)
    79  	require.Error(t, err)
    80  }
    81  
    82  func TestGetTCPAddress(t *testing.T) {
    83  	t.Run("bad, no capability", func(t *testing.T) {
    84  		p := &AddressAndTime{}
    85  		copy(p.IP[:], net.IPv4(1, 1, 1, 1))
    86  		p.Capabilities = append(p.Capabilities, capability.Capability{
    87  			Type: capability.TCPServer,
    88  			Data: &capability.Server{Port: 123},
    89  		})
    90  		s, err := p.GetTCPAddress()
    91  		require.NoError(t, err)
    92  		require.Equal(t, "1.1.1.1:123", s)
    93  	})
    94  	t.Run("bad, no capability", func(t *testing.T) {
    95  		p := &AddressAndTime{}
    96  		s, err := p.GetTCPAddress()
    97  		fmt.Println(s, err)
    98  	})
    99  }