From f086c767abe57945043ff6a838d0fa833624dbfb Mon Sep 17 00:00:00 2001 From: Claude Date: Thu, 2 Apr 2026 12:56:35 +0100 Subject: [PATCH] ax(node): rename protocol_test.go functions to TestFilename_Function_{Good,Bad,Ugly} All test functions now follow the mandatory AX test naming convention. TestResponseHandler_ValidateResponse, TestResponseHandler_ParseResponse, TestProtocolError, and TestGetProtocolErrorCode_NonProtocolError renamed and restructured into Good/Bad/Ugly triplets. Co-Authored-By: Charon --- pkg/node/protocol_test.go | 266 +++++++++++++++++++++----------------- 1 file changed, 147 insertions(+), 119 deletions(-) diff --git a/pkg/node/protocol_test.go b/pkg/node/protocol_test.go index 6f0a81b..90b50cf 100644 --- a/pkg/node/protocol_test.go +++ b/pkg/node/protocol_test.go @@ -4,133 +4,167 @@ import ( "testing" ) -func TestResponseHandler_ValidateResponse(t *testing.T) { +// TestProtocol_ValidateResponse_Good verifies ValidateResponse accepts a well-formed matching response. +// +// msg, _ := NewMessage(MsgStats, "sender", "receiver", StatsPayload{NodeID: "test"}) +// if err := ValidateResponse(msg, MsgStats); err != nil { t.Fatal(err) } +func TestProtocol_ValidateResponse_Good(t *testing.T) { handler := &ResponseHandler{} - t.Run("NilResponse", func(t *testing.T) { - err := handler.ValidateResponse(nil, MsgStats) - if err == nil { - t.Error("Expected error for nil response") - } - }) - - t.Run("ErrorResponse", func(t *testing.T) { - errMsg, _ := NewErrorMessage("sender", "receiver", ErrCodeOperationFailed, "operation failed", "") - err := handler.ValidateResponse(errMsg, MsgStats) - if err == nil { - t.Fatal("Expected error for error response") - } - - if !IsProtocolError(err) { - t.Errorf("Expected ProtocolError, got %T", err) - } - - if GetProtocolErrorCode(err) != ErrCodeOperationFailed { - t.Errorf("Expected code %d, got %d", ErrCodeOperationFailed, GetProtocolErrorCode(err)) - } - }) - - t.Run("WrongType", func(t *testing.T) { - msg, _ := NewMessage(MsgPong, "sender", "receiver", nil) - err := handler.ValidateResponse(msg, MsgStats) - 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(MsgStats, "sender", "receiver", StatsPayload{NodeID: "test"}) - err := handler.ValidateResponse(msg, MsgStats) - if err != nil { - t.Errorf("Unexpected error: %v", err) - } - }) + msg, _ := NewMessage(MsgStats, "sender", "receiver", StatsPayload{NodeID: "test"}) + if err := handler.ValidateResponse(msg, MsgStats); err != nil { + t.Errorf("ValidateResponse failed for valid response: %v", err) + } } -func TestResponseHandler_ParseResponse(t *testing.T) { +// TestProtocol_ValidateResponse_Bad verifies ValidateResponse rejects nil responses and error payloads. +// +// err := handler.ValidateResponse(nil, MsgStats) +// if err == nil { t.Error("expected error for nil response") } +func TestProtocol_ValidateResponse_Bad(t *testing.T) { handler := &ResponseHandler{} - t.Run("ParseStats", func(t *testing.T) { - payload := StatsPayload{ - NodeID: "node-123", - NodeName: "Test Node", - Uptime: 3600, - } - msg, _ := NewMessage(MsgStats, "sender", "receiver", payload) + // Nil response must return an error + err := handler.ValidateResponse(nil, MsgStats) + if err == nil { + t.Error("expected error for nil response") + } - var parsed StatsPayload - err := handler.ParseResponse(msg, MsgStats, &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(MsgMinerAck, "sender", "receiver", payload) - - var parsed MinerAckPayload - err := handler.ParseResponse(msg, MsgMinerAck, &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", ErrCodeNotFound, "not found", "") - - var parsed StatsPayload - err := handler.ParseResponse(errMsg, MsgStats, &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(MsgPong, "sender", "receiver", nil) - err := handler.ParseResponse(msg, MsgPong, nil) - if err != nil { - t.Errorf("Unexpected error with nil target: %v", err) - } - }) + // Error response must return a ProtocolError + errMsg, _ := NewErrorMessage("sender", "receiver", ErrCodeOperationFailed, "operation failed", "") + err = handler.ValidateResponse(errMsg, MsgStats) + if err == nil { + t.Fatal("expected error for error response") + } + if !IsProtocolError(err) { + t.Errorf("expected ProtocolError, got %T", err) + } + if GetProtocolErrorCode(err) != ErrCodeOperationFailed { + t.Errorf("expected code %d, got %d", ErrCodeOperationFailed, GetProtocolErrorCode(err)) + } } -func TestProtocolError(t *testing.T) { +// TestProtocol_ValidateResponse_Ugly verifies ValidateResponse rejects a response with the wrong MessageType. +// +// msg, _ := NewMessage(MsgPong, "sender", "receiver", nil) +// err := handler.ValidateResponse(msg, MsgStats) +// if IsProtocolError(err) { t.Error("type mismatch is not a ProtocolError") } +func TestProtocol_ValidateResponse_Ugly(t *testing.T) { + handler := &ResponseHandler{} + + msg, _ := NewMessage(MsgPong, "sender", "receiver", nil) + err := handler.ValidateResponse(msg, MsgStats) + if err == nil { + t.Error("expected error for wrong type") + } + if IsProtocolError(err) { + t.Error("type mismatch should not produce a ProtocolError") + } +} + +// TestProtocol_ParseResponse_Good verifies ParseResponse correctly unmarshals a well-formed payload. +// +// var parsed StatsPayload +// if err := handler.ParseResponse(msg, MsgStats, &parsed); err != nil { t.Fatal(err) } +func TestProtocol_ParseResponse_Good(t *testing.T) { + handler := &ResponseHandler{} + + payload := StatsPayload{ + NodeID: "node-123", + NodeName: "Test Node", + Uptime: 3600, + } + msg, _ := NewMessage(MsgStats, "sender", "receiver", payload) + + var parsed StatsPayload + if err := handler.ParseResponse(msg, MsgStats, &parsed); 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) + } +} + +// TestProtocol_ParseResponse_Bad verifies ParseResponse surfaces a ProtocolError from an error response. +// +// err := handler.ParseResponse(errMsg, MsgStats, &parsed) +// if !IsProtocolError(err) { t.Error("expected ProtocolError") } +func TestProtocol_ParseResponse_Bad(t *testing.T) { + handler := &ResponseHandler{} + + errMsg, _ := NewErrorMessage("sender", "receiver", ErrCodeNotFound, "not found", "") + + var parsed StatsPayload + err := handler.ParseResponse(errMsg, MsgStats, &parsed) + if err == nil { + t.Error("expected error for error response") + } + if !IsProtocolError(err) { + t.Errorf("expected ProtocolError, got %T", err) + } +} + +// TestProtocol_ParseResponse_Ugly verifies ParseResponse accepts a nil target without error. +// +// msg, _ := NewMessage(MsgPong, "sender", "receiver", nil) +// if err := handler.ParseResponse(msg, MsgPong, nil); err != nil { t.Fatal(err) } +func TestProtocol_ParseResponse_Ugly(t *testing.T) { + handler := &ResponseHandler{} + + msg, _ := NewMessage(MsgPong, "sender", "receiver", nil) + if err := handler.ParseResponse(msg, MsgPong, nil); err != nil { + t.Errorf("unexpected error with nil target: %v", err) + } + + // Pong with MinerAck target type also parsed without panic + payload := MinerAckPayload{Success: true, MinerName: "xmrig-1"} + msg2, _ := NewMessage(MsgMinerAck, "sender", "receiver", payload) + + var parsedAck MinerAckPayload + if err := handler.ParseResponse(msg2, MsgMinerAck, &parsedAck); err != nil { + t.Fatalf("unexpected error: %v", err) + } + if !parsedAck.Success { + t.Error("expected Success to be true") + } + if parsedAck.MinerName != "xmrig-1" { + t.Errorf("expected MinerName 'xmrig-1', got '%s'", parsedAck.MinerName) + } +} + +// TestProtocol_ProtocolError_Good verifies ProtocolError formats its message correctly. +// +// err := &ProtocolError{Code: 1001, Message: "test error"} +// if err.Error() != "remote error (1001): test error" { t.Fatal("wrong format") } +func TestProtocol_ProtocolError_Good(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()) + t.Errorf("unexpected error message: %s", err.Error()) } - if !IsProtocolError(err) { t.Error("IsProtocolError should return true") } - if GetProtocolErrorCode(err) != 1001 { - t.Errorf("Expected code 1001, got %d", GetProtocolErrorCode(err)) + t.Errorf("expected code 1001, got %d", GetProtocolErrorCode(err)) + } +} + +// TestProtocol_ProtocolError_Bad verifies IsProtocolError and GetProtocolErrorCode handle non-ProtocolError values. +// +// err := errors.New("plain error") +// if IsProtocolError(err) { t.Error("should be false") } +// if GetProtocolErrorCode(err) != 0 { t.Error("should be 0") } +func TestProtocol_ProtocolError_Bad(t *testing.T) { + err := &testErr{"regular error"} + if IsProtocolError(err) { + t.Error("IsProtocolError should return false for non-ProtocolError") + } + if GetProtocolErrorCode(err) != 0 { + t.Error("expected 0 for non-ProtocolError") } } @@ -150,19 +184,13 @@ func TestProtocol_DefaultHandler_Good(t *testing.T) { t.Errorf("ParseResponse failed: %v", err) } if parsed.NodeID != "test" { - t.Errorf("Expected NodeID 'test', got '%s'", parsed.NodeID) + t.Errorf("expected NodeID 'test', got '%s'", parsed.NodeID) } } // testErr is a plain error type used to verify behaviour with non-ProtocolError values. -// err := &testErr{"context: operation failed"} +// +// err := &testErr{"context: operation failed"} type testErr struct{ message string } func (e *testErr) Error() string { return e.message } - -func TestGetProtocolErrorCode_NonProtocolError(t *testing.T) { - err := &testErr{"regular error"} - if GetProtocolErrorCode(err) != 0 { - t.Error("Expected 0 for non-ProtocolError") - } -}