allow func(...) (err) back

generator_test.go

@@ -0,0 +1,141 @@
+package rpc
+
+import (
+	"os"
+	"reflect"
+	"strings"
+	"testing"
+)
+
+type User struct {
+	ID       int    `json:"id"`
+	Username string `json:"username"`
+	IsActive bool   `json:"is_active"`
+	PtrField *int   `json:"ptr_field"`
+}
+
+type Order struct {
+	OrderID int    `json:"order_id"`
+	Items   []Item `json:"items"`
+}
+
+type Item struct {
+	Name string `json:"name"`
+}
+
+type MockAPI struct{}
+
+func (s *MockAPI) GetUser(id int) (User, error) { return User{}, nil }
+func (s *MockAPI) CreateOrder(o Order) error    { return nil }
+func (s *MockAPI) NoArgs() error                { return nil }
+
+func TestGoTypeToTS(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    any
+		expected string
+	}{
+		{"Int", 42, "number"},
+		{"String", "hello", "string"},
+		{"Bool", true, "boolean"},
+		{"Slice", []string{}, "string[]"},
+		{"Byte Slice", []byte{}, "string"},
+		{"Pointer", new(int), "number"},
+		{"Map", map[string]int{}, "{ [key: string]: number }"},
+		{"Struct", User{}, "User"},
+		{"Anon Struct", struct {
+			Name string `json:"name"`
+		}{Name: "test"}, "{ name: string }"},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			typ := reflect.TypeOf(tt.input)
+			got := goTypeToTS(typ)
+			if got != tt.expected {
+				t.Errorf("goTypeToTS() = %v, want %v", got, tt.expected)
+			}
+		})
+	}
+}
+
+func TestCollectStructs(t *testing.T) {
+	structs := make(map[string]reflect.Type)
+
+	// Test nested collection
+	collectStructs(reflect.TypeOf(Order{}), structs)
+
+	if _, ok := structs["Order"]; !ok {
+		t.Error("Expected Order in map")
+	}
+	if _, ok := structs["Item"]; !ok {
+		t.Error("Expected Item (nested) in map")
+	}
+}
+
+func TestGenerateTS_Success(t *testing.T) {
+	api := &MockAPI{}
+	output, err := GenerateTS(reflect.TypeOf(api), "TestClient")
+	if err != nil {
+		t.Fatalf("GenerateTS failed: %v", err)
+	}
+
+	expectedStrings := []string{
+		"export interface User {",
+		"id: number;",
+		"is_active: boolean;",
+		"export interface TestClient {",
+		"GetUser(arg0: number): Promise<RPCResult<User>>;",
+		"CreateOrder(order: Order): Promise<RPCResult<any>>;",
+		"useBackend(url: string = '/ws')",
+	}
+
+	for _, s := range expectedStrings {
+		if !strings.Contains(output, s) {
+			t.Errorf("Generated TS missing expected string: %s", s)
+		}
+	}
+}
+
+type APIWithTooManyReturns struct{}
+
+func (s *APIWithTooManyReturns) Bad(id int) (int, int, error) { return 0, 0, nil }
+
+type APIWithNoErrorHandler struct{}
+
+func (s *APIWithNoErrorHandler) Bad(id int) int { return 0 }
+
+func TestGenerateTS_Validation(t *testing.T) {
+	type BadAPI struct{}
+
+	t.Run("InvalidReturnCount", func(t *testing.T) {
+		api := &APIWithTooManyReturns{}
+		_, err := GenerateTS(reflect.TypeOf(api), "Client")
+		if err == nil {
+			t.Error("Expected error for method with 3 return values")
+		}
+	})
+
+	t.Run("NoResidentError", func(t *testing.T) {
+		api := &APIWithNoErrorHandler{}
+		_, err := GenerateTS(reflect.TypeOf(api), "Client")
+		if err == nil {
+			t.Error("Expected error for method missing 'error' return type")
+		}
+	})
+}
+
+func TestGenClient(t *testing.T) {
+	tmpFile := "test_client.ts"
+	defer os.Remove(tmpFile)
+
+	api := &MockAPI{}
+	err := GenClient(api, tmpFile)
+	if err != nil {
+		t.Fatalf("GenClient failed: %v", err)
+	}
+
+	if _, err := os.Stat(tmpFile); os.IsNotExist(err) {
+		t.Error("GenClient did not create the file")
+	}
+}