added handhsake test error cases

go fmt handshake tests

pkg/p2p/libp2p/internal/handshake/handshake.go

@@ -44,15 +44,15 @@ func (s *Service) Handshake(stream p2p.Stream) (i *Info, err error) {
 		Address:   s.overlay,
 		NetworkID: s.networkID,
 	}); err != nil {
-		return nil, fmt.Errorf("handshake handler: write message: %w", err)
+		return nil, fmt.Errorf("handshake write message: %w", err)
 	}
 
-	s.logger.Tracef("handshake: sent request %s", s.overlay)
+	s.logger.Tracef("handshake sent request %s", s.overlay)
 	if err := r.ReadMsg(&resp); err != nil {
-		return nil, fmt.Errorf("handshake handler: read message: %w", err)
+		return nil, fmt.Errorf("handshake read message: %w", err)
 	}
 
-	s.logger.Tracef("handshake: read response: %s", resp.Address)
+	s.logger.Tracef("handshake read response: %s", resp.Address)
 	return &Info{
 		Address:   resp.Address,
 		NetworkID: resp.NetworkID,
@@ -66,18 +66,18 @@ func (s *Service) Handle(stream p2p.Stream) (i *Info, err error) {
 
 	var req ShakeHand
 	if err := r.ReadMsg(&req); err != nil {
-		return nil, fmt.Errorf("read message: %w", err)
+		return nil, fmt.Errorf("handshake handler read message: %w", err)
 	}
 
-	s.logger.Tracef("handshake: received request %s", req.Address)
+	s.logger.Tracef("handshake handler received request %s", req.Address)
 	if err := w.WriteMsg(&ShakeHand{
 		Address:   s.overlay,
 		NetworkID: s.networkID,
 	}); err != nil {
-		return nil, fmt.Errorf("write message: %w", err)
+		return nil, fmt.Errorf("handshake handler write message: %w", err)
 	}
 
-	s.logger.Tracef("handshake: handled response: %s", s.overlay)
+	s.logger.Tracef("handshake handled response: %s", s.overlay)
 	return &Info{
 		Address:   req.Address,
 		NetworkID: req.NetworkID,

pkg/p2p/libp2p/internal/handshake/handshake_test.go

@@ -2,23 +2,36 @@ package handshake
 
 import (
 	"bytes"
-	"github.com/ethersphere/bee/pkg/logging"
-	"github.com/ethersphere/bee/pkg/p2p/protobuf"
+	"errors"
+	"fmt"
 	"io/ioutil"
 	"testing"
+
+	"github.com/ethersphere/bee/pkg/logging"
+	"github.com/ethersphere/bee/pkg/p2p/protobuf"
 )
 
 type StreamMock struct {
-	ReadBuffer  *bytes.Buffer
-	WriteBuffer *bytes.Buffer
+	readBuffer  *bytes.Buffer
+	writeBuffer *bytes.Buffer
+	readError   error
+	writeError  error
 }
 
 func (s *StreamMock) Read(p []byte) (n int, err error) {
-	return s.ReadBuffer.Read(p)
+	if s.readError != nil {
+		return 0, s.readError
+	}
+
+	return s.readBuffer.Read(p)
 }
 
 func (s *StreamMock) Write(p []byte) (n int, err error) {
-	return s.WriteBuffer.Write(p)
+	if s.writeError != nil {
+		return 0, s.writeError
+	}
+
+	return s.writeBuffer.Write(p)
 }
 
 func (s *StreamMock) Close() error {
@@ -43,8 +56,8 @@ func TestHandshake(t *testing.T) {
 
 		var buffer1 bytes.Buffer
 		var buffer2 bytes.Buffer
-		stream1 := &StreamMock{ReadBuffer: &buffer1, WriteBuffer: &buffer2}
-		stream2 := &StreamMock{ReadBuffer: &buffer2, WriteBuffer: &buffer1}
+		stream1 := &StreamMock{readBuffer: &buffer1, writeBuffer: &buffer2}
+		stream2 := &StreamMock{readBuffer: &buffer2, writeBuffer: &buffer1}
 
 		w, _ := protobuf.NewWriterAndReader(stream2)
 		if err := w.WriteMsg(&ShakeHand{
@@ -64,6 +77,34 @@ func TestHandshake(t *testing.T) {
 			t.Fatalf("got %+v, expected %+v", res, info)
 		}
 	})
+
+	t.Run("ERROR - write error ", func(t *testing.T) {
+		testErr := errors.New("test error")
+		expectedErr := fmt.Errorf("handshake write message: %w", testErr)
+		stream := &StreamMock{writeError: testErr}
+		res, err := handshakeService.Handshake(stream)
+		if err.Error() != expectedErr.Error() {
+			t.Fatal("expected:", expectedErr, "got:", err)
+		}
+
+		if res != nil {
+			t.Fatal("handshake returned non-nil res")
+		}
+	})
+
+	t.Run("ERROR - read error ", func(t *testing.T) {
+		testErr := errors.New("test error")
+		expectedErr := fmt.Errorf("handshake read message: %w", testErr)
+		stream := &StreamMock{writeBuffer: &bytes.Buffer{}, readError: testErr}
+		res, err := handshakeService.Handshake(stream)
+		if err.Error() != expectedErr.Error() {
+			t.Fatal("expected:", expectedErr, "got:", err)
+		}
+
+		if res != nil {
+			t.Fatal("handshake returned non-nil res")
+		}
+	})
 }
 
 func TestHandle(t *testing.T) {
@@ -85,8 +126,8 @@ func TestHandle(t *testing.T) {
 
 		var buffer1 bytes.Buffer
 		var buffer2 bytes.Buffer
-		stream1 := &StreamMock{ReadBuffer: &buffer1, WriteBuffer: &buffer2}
-		stream2 := &StreamMock{ReadBuffer: &buffer2, WriteBuffer: &buffer1}
+		stream1 := &StreamMock{readBuffer: &buffer1, writeBuffer: &buffer2}
+		stream2 := &StreamMock{readBuffer: &buffer2, writeBuffer: &buffer1}
 
 		w, _ := protobuf.NewWriterAndReader(stream2)
 		if err := w.WriteMsg(&ShakeHand{
@@ -116,4 +157,45 @@ func TestHandle(t *testing.T) {
 			t.Fatalf("got %+v, expected %+v", got, node2Info)
 		}
 	})
+
+	t.Run("ERROR - read error ", func(t *testing.T) {
+		testErr := errors.New("test error")
+		expectedErr := fmt.Errorf("handshake handler read message: %w", testErr)
+		stream := &StreamMock{readError: testErr}
+		res, err := handshakeService.Handle(stream)
+		if err.Error() != expectedErr.Error() {
+			t.Fatal("expected:", expectedErr, "got:", err)
+		}
+
+		if res != nil {
+			t.Fatal("handle returned non-nil res")
+		}
+	})
+
+	t.Run("ERROR - write error ", func(t *testing.T) {
+		testErr := errors.New("test error")
+		expectedErr := fmt.Errorf("handshake handler write message: %w", testErr)
+		var buffer bytes.Buffer
+		stream := &StreamMock{readBuffer: &buffer, writeBuffer: &buffer}
+
+		w, _ := protobuf.NewWriterAndReader(stream)
+		if err := w.WriteMsg(&ShakeHand{
+			Address:   "node1",
+			NetworkID: 0,
+			Light:     false,
+		}); err != nil {
+			t.Fatal(err)
+		}
+
+		stream.writeError = testErr
+
+		res, err := handshakeService.Handle(stream)
+		if err.Error() != expectedErr.Error() {
+			t.Fatal("expected:", expectedErr, "got:", err)
+		}
+
+		if res != nil {
+			t.Fatal("handshake returned non-nil res")
+		}
+	})
 }

pkg/p2p/libp2p/libp2p.go

@@ -216,7 +216,7 @@ func New(ctx context.Context, o Options) (*Service, error) {
 		peerID := stream.Conn().RemotePeer()
 		i, err := s.handshakeService.Handle(stream)
 		if err != nil {
-			s.logger.Errorf("handshake with peer %s: %w", peerID, err)
+			s.logger.Errorf("handshake with x %s: %w", peerID, err)
 			// todo: test connection close and refactor
 			stream.Conn().Close()
 			return