xmlrpc/integration_test.go at main · ninech/xmlrpc · GitHub

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
//go:build integration

package xmlrpc

import (
	"context"
	"fmt"
	"log"
	"sync"
	"testing"
	"time"
)

func ExampleNewClientWithOptions() {
	client, err := NewClientWithOptions("https://bugzilla.mozilla.org/xmlrpc.cgi")
	if err != nil {
		log.Fatal(err)
	}
	defer client.Close()

	var result struct {
		Version string `xmlrpc:"version"`
	}
	if err := client.Call("Bugzilla.version", nil, &result); err != nil {
		log.Fatal(err)
	}
	fmt.Printf("Version: %s\n", result.Version) // Version: 4.2.7+
}

func TestIntegration_CallWithoutArgs(t *testing.T) {
	client := newIntegrationClient(t)
	defer client.Close()

	var result time.Time
	if err := client.Call("service.time", nil, &result); err != nil {
		t.Fatalf("service.time error: %v", err)
	}
	t.Logf("service.time: %v", result)
}

func TestIntegration_CallWithOneArg(t *testing.T) {
	client := newIntegrationClient(t)
	defer client.Close()

	var result string
	if err := client.Call("service.upcase", "xmlrpc", &result); err != nil {
		t.Fatalf("service.upcase error: %v", err)
	}

	if result != "XMLRPC" {
		t.Fatalf("expected XMLRPC, got %s", result)
	}
}

func TestIntegration_CallWithTwoArgs(t *testing.T) {
	client := newIntegrationClient(t)
	defer client.Close()

	var sum int
	if err := client.Call("service.sum", []any{2, 3}, &sum); err != nil {
		t.Fatalf("service.sum error: %v", err)
	}

	if sum != 5 {
		t.Fatalf("expected 5, got %d", sum)
	}
}

func TestIntegration_FaultError(t *testing.T) {
	client := newIntegrationClient(t)
	defer client.Close()

	var result int
	err := client.Call("service.error", nil, &result)
	if err == nil {
		t.Fatal("expected error, got nil")
	}

	fault, ok := err.(FaultError)
	if !ok {
		t.Fatalf("expected FaultError, got %T: %v", err, err)
	}
	t.Logf("Got expected fault: %v", fault)
}

func TestIntegration_CallContext(t *testing.T) {
	client := newIntegrationClient(t)
	defer client.Close()

	ctx, cancel := context.WithTimeout(t.Context(), 5*time.Second)
	defer cancel()

	var result string
	if err := client.CallContext(ctx, "service.upcase", "test", &result); err != nil {
		t.Fatalf("CallContext error: %v", err)
	}

	if result != "TEST" {
		t.Fatalf("expected TEST, got %s", result)
	}
}

func TestIntegration_Concurrent(t *testing.T) {
	client := newIntegrationClient(t)
	defer client.Close()

	var wg sync.WaitGroup
	for range 50 {
		wg.Add(1)
		go func() {
			defer wg.Done()
			var result time.Time
			if err := client.Call("service.time", nil, &result); err != nil {
				t.Errorf("concurrent call error: %v", err)
			}
		}()
	}
	wg.Wait()
}

func newIntegrationClient(t *testing.T) *Client {
	client, err := NewClientWithOptions("http://localhost:5001")
	if err != nil {
		t.Fatalf("failed to create client: %v", err)
	}
	return client
}