handle pointer and value in get code

Author: Aryan Tikarya

errors.go

@@ -6,7 +6,10 @@ import (
 	"reflect"
 )
 
-const eTempWSError = -1111111
+const (
+	eTempWSError     = -1111111
+	defaultErrorCode = 1
+)
 
 type RPCConnectionError struct {
 	err error
@@ -54,12 +57,38 @@ func (e *Errors) Register(c ErrorCode, typ interface{}) {
 	e.byCode[c] = rt
 }
 
+func (e *Errors) getErrorCode(err error) ErrorCode {
+	var code ErrorCode = defaultErrorCode
+
+	// First, try direct type matching
+	if c, ok := e.byType[reflect.TypeOf(err)]; ok {
+		return c
+	}
+
+	// Handle pointer vs. value type discrepancies
+	errType := reflect.TypeOf(err)
+	if errType.Kind() == reflect.Ptr {
+		// Try matching the value type
+		if c, ok := e.byType[errType.Elem()]; ok {
+			return c
+		}
+	} else {
+		// Try matching the pointer type
+		ptrType := reflect.PointerTo(errType)
+		if c, ok := e.byType[ptrType]; ok {
+			return c
+		}
+	}
+
+	return code // Return default code if no match found
+}
+
 type marshalable interface {
 	json.Marshaler
 	json.Unmarshaler
 }
 
-type ErrorCodec interface {
+type RPCErrorCodec interface {
 	FromJSONRPCError(JSONRPCError) error
 	ToJSONRPCError() (JSONRPCError, error)
 }

errors_test.go

@@ -0,0 +1,95 @@
+package jsonrpc
+
+import (
+	"reflect"
+	"testing"
+
+	"github.com/stretchr/testify/require"
+)
+
+// Define a custom error type for testing
+type PointerReceiverError struct {
+	Message string
+}
+
+func (e *PointerReceiverError) Error() string {
+	return e.Message
+}
+
+type ValueReceiverError struct {
+	Message string
+}
+
+func (e ValueReceiverError) Error() string {
+	return e.Message
+}
+
+// Another custom error type
+type AnotherTestError struct {
+	Detail string
+}
+
+func (e *AnotherTestError) Error() string {
+	return e.Detail
+}
+
+// Non-error type for negative testing
+type NotAnError struct {
+	Field string
+}
+
+func TestNewErrors(t *testing.T) {
+	errs := NewErrors()
+
+	if errs.byType == nil {
+		t.Error("Errors.byType should be initialized")
+	}
+
+	if errs.byCode == nil {
+		t.Error("Errors.byCode should be initialized")
+	}
+
+	// Check initial registration
+	expectedType := reflect.TypeOf(&RPCConnectionError{})
+	if code, exists := errs.byCode[eTempWSError]; !exists {
+		t.Errorf("Expected initial ErrorCode %d to be registered", eTempWSError)
+	} else if code != expectedType {
+		t.Errorf("Expected type %v for ErrorCode %d, got %v", expectedType, eTempWSError, code)
+	}
+}
+
+func TestErrors_GetCode_PointerAndValueTypes(t *testing.T) {
+	errs := NewErrors()
+
+	// Register TestError with ErrorCode 100
+	errs.Register(100, new(*PointerReceiverError))
+	errs.Register(101, new(*ValueReceiverError))
+
+	// Create both pointer and value instances
+	ptrErr := &PointerReceiverError{Message: "pointer error"}
+	valErr := ValueReceiverError{Message: "value error"}
+
+	tests := []struct {
+		name     string
+		inputErr error
+		wantCode ErrorCode
+	}{
+		{
+			name:     "Pointer error",
+			inputErr: ptrErr,
+			wantCode: 100,
+		},
+		{
+			name:     "Value error (direct, should not match)",
+			inputErr: valErr,
+			wantCode: 101,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			gotCode := errs.getErrorCode(tt.inputErr)
+			require.Equal(t, tt.wantCode, gotCode, "error code mismatch for %s", tt.name)
+		})
+	}
+}

handler.go

@@ -270,21 +270,19 @@ func (s *handler) getSpan(ctx context.Context, req request) (context.Context, *t
 }
 
 func (s *handler) createError(err error) *JSONRPCError {
-	var code ErrorCode = 1
-	if s.errors != nil {
-		c, ok := s.errors.byType[reflect.TypeOf(err)]
-		if ok {
-			code = c
-		}
+	if err == nil {
+		return nil
 	}
 
+	code := s.errors.getErrorCode(err)
+
 	out := &JSONRPCError{
 		Code:    code,
 		Message: err.Error(),
 	}
 
 	switch m := err.(type) {
-	case ErrorCodec:
+	case RPCErrorCodec:
 		o, err := m.ToJSONRPCError()
 		if err != nil {
 			log.Warnf("Failed to convert error to JSONRPCError: %v", err)
@@ -455,12 +453,12 @@ func (s *handler) handle(ctx context.Context, req request, w func(func(io.Writer
 				Message: err.Error(),
 			}
 
-			if m, ok := err.(ErrorCodec); ok {
-				respErr, err := m.ToJSONRPCError()
+			if m, ok := err.(RPCErrorCodec); ok {
+				rpcErr, err := m.ToJSONRPCError()
 				if err != nil {
 					log.Warnf("Failed to convert error to JSONRPCError: %v", err)
 				} else {
-					resp.Error.Data = respErr.Data
+					respErr.Data = rpcErr.Data
 				}
 			}
 

resp_error_test.go

@@ -35,7 +35,7 @@ func (e *SimpleError) ToJSONRPCError() (JSONRPCError, error) {
 	return JSONRPCError{Message: e.Message}, nil
 }
 
-var _ ErrorCodec = (*SimpleError)(nil)
+var _ RPCErrorCodec = (*SimpleError)(nil)
 
 type DataStringError struct {
 	Message string `json:"message"`
@@ -62,7 +62,7 @@ func (e *DataStringError) ToJSONRPCError() (JSONRPCError, error) {
 	return JSONRPCError{Message: e.Message, Data: e.Data}, nil
 }
 
-var _ ErrorCodec = (*DataStringError)(nil)
+var _ RPCErrorCodec = (*DataStringError)(nil)
 
 type DataComplexError struct {
 	Message      string
@@ -94,7 +94,7 @@ func (e *DataComplexError) ToJSONRPCError() (JSONRPCError, error) {
 	return JSONRPCError{Message: e.Message, Data: data}, nil
 }
 
-var _ ErrorCodec = (*DataComplexError)(nil)
+var _ RPCErrorCodec = (*DataComplexError)(nil)
 
 type MetaError struct {
 	Message string

response.go

@@ -52,7 +52,7 @@ func (e *JSONRPCError) Error() string {
 var (
 	_               error = (*JSONRPCError)(nil)
 	marshalableRT         = reflect.TypeOf(new(marshalable)).Elem()
-	unmarshalableRT       = reflect.TypeOf(new(ErrorCodec)).Elem()
+	unmarshalableRT       = reflect.TypeOf(new(RPCErrorCodec)).Elem()
 )
 
 func (e *JSONRPCError) val(errors *Errors) reflect.Value {
@@ -67,7 +67,7 @@ func (e *JSONRPCError) val(errors *Errors) reflect.Value {
 			}
 
 			if v.Type().Implements(unmarshalableRT) {
-				_ = v.Interface().(ErrorCodec).FromJSONRPCError(*e)
+				_ = v.Interface().(RPCErrorCodec).FromJSONRPCError(*e)
 			}
 
 			if len(e.Meta) > 0 && v.Type().Implements(marshalableRT) {