go-p2p/node/protocol_test.go

package node

import (
	"testing"

	core "dappco.re/go/core"
)

func TestProtocol_ResponseHandler_ValidateResponse_Good(t *testing.T) {
	handler := &ResponseHandler{}

	t.Run("NilResponse", func(t *testing.T) {
		err := handler.ValidateResponse(nil, MessageStats)
		if err == nil {
			t.Error("Expected error for nil response")
		}
	})

	t.Run("ErrorResponse", func(t *testing.T) {
		errMsg, _ := NewErrorMessage("sender", "receiver", ErrorCodeOperationFailed, "operation failed", "")
		err := handler.ValidateResponse(errMsg, MessageStats)
		if err == nil {
			t.Fatal("Expected error for error response")
		}

		if !IsProtocolError(err) {
			t.Errorf("Expected ProtocolError, got %T", err)
		}

		if ProtocolErrorCode(err) != ErrorCodeOperationFailed {
			t.Errorf("Expected code %d, got %d", ErrorCodeOperationFailed, ProtocolErrorCode(err))
		}
	})

	t.Run("WrongType", func(t *testing.T) {
		msg, _ := NewMessage(MessagePong, "sender", "receiver", nil)
		err := handler.ValidateResponse(msg, MessageStats)
		if err == nil {
			t.Error("Expected error for wrong type")
		}
		if IsProtocolError(err) {
			t.Error("Should not be a ProtocolError for type mismatch")
		}
	})

	t.Run("ValidResponse", func(t *testing.T) {
		msg, _ := NewMessage(MessageStats, "sender", "receiver", StatsPayload{NodeID: "test"})
		err := handler.ValidateResponse(msg, MessageStats)
		if err != nil {
			t.Errorf("Unexpected error: %v", err)
		}
	})
}

func TestProtocol_ResponseHandler_ParseResponse_Good(t *testing.T) {
	handler := &ResponseHandler{}

	t.Run("ParseStats", func(t *testing.T) {
		payload := StatsPayload{
			NodeID:   "node-123",
			NodeName: "Test Node",
			Uptime:   3600,
		}
		msg, _ := NewMessage(MessageStats, "sender", "receiver", payload)

		var parsed StatsPayload
		err := handler.ParseResponse(msg, MessageStats, &parsed)
		if err != nil {
			t.Fatalf("Unexpected error: %v", err)
		}

		if parsed.NodeID != "node-123" {
			t.Errorf("Expected NodeID 'node-123', got '%s'", parsed.NodeID)
		}
		if parsed.Uptime != 3600 {
			t.Errorf("Expected Uptime 3600, got %d", parsed.Uptime)
		}
	})

	t.Run("ParseMinerAck", func(t *testing.T) {
		payload := MinerAckPayload{
			Success:   true,
			MinerName: "xmrig-1",
		}
		msg, _ := NewMessage(MessageMinerAck, "sender", "receiver", payload)

		var parsed MinerAckPayload
		err := handler.ParseResponse(msg, MessageMinerAck, &parsed)
		if err != nil {
			t.Fatalf("Unexpected error: %v", err)
		}

		if !parsed.Success {
			t.Error("Expected Success to be true")
		}
		if parsed.MinerName != "xmrig-1" {
			t.Errorf("Expected MinerName 'xmrig-1', got '%s'", parsed.MinerName)
		}
	})

	t.Run("ErrorResponse", func(t *testing.T) {
		errMsg, _ := NewErrorMessage("sender", "receiver", ErrorCodeNotFound, "not found", "")

		var parsed StatsPayload
		err := handler.ParseResponse(errMsg, MessageStats, &parsed)
		if err == nil {
			t.Error("Expected error for error response")
		}
		if !IsProtocolError(err) {
			t.Errorf("Expected ProtocolError, got %T", err)
		}
	})

	t.Run("NilTarget", func(t *testing.T) {
		msg, _ := NewMessage(MessagePong, "sender", "receiver", nil)
		err := handler.ParseResponse(msg, MessagePong, nil)
		if err != nil {
			t.Errorf("Unexpected error with nil target: %v", err)
		}
	})
}

func TestProtocol_Error_Bad(t *testing.T) {
	err := &ProtocolError{Code: 1001, Message: "test error"}

	if err.Error() != "remote error (1001): test error" {
		t.Errorf("Unexpected error message: %s", err.Error())
	}

	if !IsProtocolError(err) {
		t.Error("IsProtocolError should return true")
	}

	if ProtocolErrorCode(err) != 1001 {
		t.Errorf("Expected code 1001, got %d", ProtocolErrorCode(err))
	}
}

func TestProtocol_ConvenienceFunctions_Good(t *testing.T) {
	msg, _ := NewMessage(MessageStats, "sender", "receiver", StatsPayload{NodeID: "test"})

	// Test ValidateResponse
	if err := ValidateResponse(msg, MessageStats); err != nil {
		t.Errorf("ValidateResponse failed: %v", err)
	}

	// Test ParseResponse
	var parsed StatsPayload
	if err := ParseResponse(msg, MessageStats, &parsed); err != nil {
		t.Errorf("ParseResponse failed: %v", err)
	}
	if parsed.NodeID != "test" {
		t.Errorf("Expected NodeID 'test', got '%s'", parsed.NodeID)
	}
}

func TestProtocol_GetProtocolErrorCode_NonProtocolError_Bad(t *testing.T) {
	err := core.NewError("regular error")
	if ProtocolErrorCode(err) != 0 {
		t.Error("Expected 0 for non-ProtocolError")
	}
}