fix: allow string and int types for backtrace number field

Author: joshuap

internal/hbapi/types.go

@@ -1,6 +1,32 @@
 package hbapi
 
-import "time"
+import (
+	"encoding/json"
+	"fmt"
+	"time"
+)
+
+// StringOrInt is a custom type that can unmarshal from either a string or integer JSON value
+type StringOrInt string
+
+// UnmarshalJSON implements json.Unmarshaler interface to handle both string and integer values
+func (s *StringOrInt) UnmarshalJSON(data []byte) error {
+	// Try to unmarshal as string first
+	var str string
+	if err := json.Unmarshal(data, &str); err == nil {
+		*s = StringOrInt(str)
+		return nil
+	}
+
+	// If that fails, try as integer
+	var num int
+	if err := json.Unmarshal(data, &num); err == nil {
+		*s = StringOrInt(fmt.Sprintf("%d", num))
+		return nil
+	}
+
+	return fmt.Errorf("StringOrInt: cannot unmarshal %s into string or integer", data)
+}
 
 // User represents a Honeybadger user
 type User struct {
@@ -95,7 +121,7 @@ type NoticeRequest struct {
 
 // BacktraceEntry represents a single entry in the error backtrace
 type BacktraceEntry struct {
-	Number  string                 `json:"number"`
+	Number  StringOrInt            `json:"number"`
 	File    string                 `json:"file"`
 	Method  string                 `json:"method"`
 	Source  map[string]interface{} `json:"source,omitempty"`

internal/hbapi/types_test.go

@@ -0,0 +1,145 @@
+package hbapi
+
+import (
+	"encoding/json"
+	"testing"
+)
+
+func TestStringOrInt_UnmarshalJSON(t *testing.T) {
+	tests := []struct {
+		name    string
+		input   string
+		want    string
+		wantErr bool
+	}{
+		{
+			name:    "string value",
+			input:   `"123"`,
+			want:    "123",
+			wantErr: false,
+		},
+		{
+			name:    "integer value",
+			input:   `123`,
+			want:    "123",
+			wantErr: false,
+		},
+		{
+			name:    "zero integer",
+			input:   `0`,
+			want:    "0",
+			wantErr: false,
+		},
+		{
+			name:    "negative integer",
+			input:   `-1`,
+			want:    "-1",
+			wantErr: false,
+		},
+		{
+			name:    "boolean value should fail",
+			input:   `true`,
+			wantErr: true,
+		},
+		{
+			name:    "object value should fail",
+			input:   `{}`,
+			wantErr: true,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var s StringOrInt
+			err := json.Unmarshal([]byte(tt.input), &s)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("StringOrInt.UnmarshalJSON() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !tt.wantErr && string(s) != tt.want {
+				t.Errorf("StringOrInt.UnmarshalJSON() = %v, want %v", s, tt.want)
+			}
+		})
+	}
+}
+
+func TestBacktraceEntry_UnmarshalJSON(t *testing.T) {
+	tests := []struct {
+		name    string
+		input   string
+		want    BacktraceEntry
+		wantErr bool
+	}{
+		{
+			name: "number as string",
+			input: `{
+				"number": "42",
+				"file": "/path/to/file.js",
+				"method": "someMethod"
+			}`,
+			want: BacktraceEntry{
+				Number: "42",
+				File:   "/path/to/file.js",
+				Method: "someMethod",
+			},
+			wantErr: false,
+		},
+		{
+			name: "number as integer",
+			input: `{
+				"number": 42,
+				"file": "/path/to/file.js",
+				"method": "someMethod"
+			}`,
+			want: BacktraceEntry{
+				Number: "42",
+				File:   "/path/to/file.js",
+				Method: "someMethod",
+			},
+			wantErr: false,
+		},
+		{
+			name: "complete backtrace entry with source",
+			input: `{
+				"number": 10,
+				"file": "/app/index.js",
+				"method": "handleError",
+				"source": {"10": "throw new Error();"},
+				"context": "app"
+			}`,
+			want: BacktraceEntry{
+				Number:  "10",
+				File:    "/app/index.js",
+				Method:  "handleError",
+				Source:  map[string]interface{}{"10": "throw new Error();"},
+				Context: "app",
+			},
+			wantErr: false,
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var entry BacktraceEntry
+			err := json.Unmarshal([]byte(tt.input), &entry)
+			if (err != nil) != tt.wantErr {
+				t.Errorf("BacktraceEntry.UnmarshalJSON() error = %v, wantErr %v", err, tt.wantErr)
+				return
+			}
+			if !tt.wantErr {
+				if string(entry.Number) != string(tt.want.Number) {
+					t.Errorf("BacktraceEntry.Number = %v, want %v", entry.Number, tt.want.Number)
+				}
+				if entry.File != tt.want.File {
+					t.Errorf("BacktraceEntry.File = %v, want %v", entry.File, tt.want.File)
+				}
+				if entry.Method != tt.want.Method {
+					t.Errorf("BacktraceEntry.Method = %v, want %v", entry.Method, tt.want.Method)
+				}
+				if entry.Context != tt.want.Context {
+					t.Errorf("BacktraceEntry.Context = %v, want %v", entry.Context, tt.want.Context)
+				}
+			}
+		})
+	}
+}