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

     1  package network
     2  
     3  import (
     4  	"net"
     5  	"testing"
     6  
     7  	"github.com/nspcc-dev/neo-go/pkg/network/payload"
     8  	"github.com/stretchr/testify/require"
     9  )
    10  
    11  func connReadStub(conn net.Conn) {
    12  	b := make([]byte, 1024)
    13  	var err error
    14  	for err == nil {
    15  		_, err = conn.Read(b)
    16  	}
    17  }
    18  
    19  func TestPeerHandshake(t *testing.T) {
    20  	server, client := net.Pipe()
    21  
    22  	tcpS := NewTCPPeer(server, "", newTestServer(t, ServerConfig{}))
    23  	tcpS.server.transports[0].Accept() // properly initialize the address list
    24  	tcpC := NewTCPPeer(client, "", newTestServer(t, ServerConfig{}))
    25  	tcpC.server.transports[0].Accept()
    26  
    27  	// Something should read things written into the pipe.
    28  	go connReadStub(tcpS.conn)
    29  	go connReadStub(tcpC.conn)
    30  
    31  	// No handshake yet.
    32  	require.Equal(t, false, tcpS.Handshaked())
    33  	require.Equal(t, false, tcpC.Handshaked())
    34  
    35  	// No ordinary messages can be written.
    36  	require.Error(t, tcpS.EnqueueP2PMessage(&Message{}))
    37  	require.Error(t, tcpC.EnqueueP2PMessage(&Message{}))
    38  
    39  	// Try to mess with VersionAck on both client and server, it should fail.
    40  	require.Error(t, tcpS.SendVersionAck(&Message{}))
    41  	require.Error(t, tcpS.HandleVersionAck())
    42  	require.Error(t, tcpC.SendVersionAck(&Message{}))
    43  	require.Error(t, tcpC.HandleVersionAck())
    44  
    45  	// No handshake yet.
    46  	require.Equal(t, false, tcpS.Handshaked())
    47  	require.Equal(t, false, tcpC.Handshaked())
    48  
    49  	// Now send and handle versions, but in a different order on client and
    50  	// server.
    51  	require.NoError(t, tcpC.SendVersion())
    52  	require.Error(t, tcpC.HandleVersionAck()) // Didn't receive version yet.
    53  	require.NoError(t, tcpS.HandleVersion(&payload.Version{}))
    54  	require.Error(t, tcpS.SendVersionAck(&Message{})) // Didn't send version yet.
    55  	require.NoError(t, tcpC.HandleVersion(&payload.Version{}))
    56  	require.NoError(t, tcpS.SendVersion())
    57  
    58  	// No handshake yet.
    59  	require.Equal(t, false, tcpS.Handshaked())
    60  	require.Equal(t, false, tcpC.Handshaked())
    61  
    62  	// These are sent/received and should fail now.
    63  	require.Error(t, tcpC.SendVersion())
    64  	require.Error(t, tcpS.HandleVersion(&payload.Version{}))
    65  	require.Error(t, tcpC.HandleVersion(&payload.Version{}))
    66  	require.Error(t, tcpS.SendVersion())
    67  
    68  	// Now send and handle ACK, again in a different order on client and
    69  	// server.
    70  	require.NoError(t, tcpC.SendVersionAck(&Message{}))
    71  	require.NoError(t, tcpS.HandleVersionAck())
    72  	require.NoError(t, tcpC.HandleVersionAck())
    73  	require.NoError(t, tcpS.SendVersionAck(&Message{}))
    74  
    75  	// Handshaked now.
    76  	require.Equal(t, true, tcpS.Handshaked())
    77  	require.Equal(t, true, tcpC.Handshaked())
    78  
    79  	// Subsequent ACKing should fail.
    80  	require.Error(t, tcpC.SendVersionAck(&Message{}))
    81  	require.Error(t, tcpS.HandleVersionAck())
    82  	require.Error(t, tcpC.HandleVersionAck())
    83  	require.Error(t, tcpS.SendVersionAck(&Message{}))
    84  
    85  	// Now regular messaging can proceed.
    86  	require.NoError(t, tcpS.EnqueueP2PMessage(&Message{}))
    87  	require.NoError(t, tcpC.EnqueueP2PMessage(&Message{}))
    88  }