forked from xanzy/go-gitlab
-
Notifications
You must be signed in to change notification settings - Fork 0
/
gitlab_test.go
184 lines (159 loc) · 4.33 KB
/
gitlab_test.go
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
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
package gitlab
import (
"bytes"
"context"
"encoding/json"
"errors"
"io/ioutil"
"net/http"
"net/http/httptest"
"strings"
"testing"
)
// setup sets up a test HTTP server along with a gitlab.Client that is
// configured to talk to that test server. Tests should register handlers on
// mux which provide mock responses for the API method being tested.
func setup() (*http.ServeMux, *httptest.Server, *Client) {
// mux is the HTTP request multiplexer used with the test server.
mux := http.NewServeMux()
// server is a test HTTP server used to provide mock API responses.
server := httptest.NewServer(mux)
// client is the Gitlab client being tested.
client := NewClient(nil, "")
client.SetBaseURL(server.URL)
return mux, server, client
}
// teardown closes the test HTTP server.
func teardown(server *httptest.Server) {
server.Close()
}
func testURL(t *testing.T, r *http.Request, want string) {
if got := r.RequestURI; got != want {
t.Errorf("Request url: %+v, want %s", got, want)
}
}
func testMethod(t *testing.T, r *http.Request, want string) {
if got := r.Method; got != want {
t.Errorf("Request method: %s, want %s", got, want)
}
}
func testBody(t *testing.T, r *http.Request, want string) {
buffer := new(bytes.Buffer)
_, err := buffer.ReadFrom(r.Body)
if err != nil {
t.Fatalf("Failed to Read Body: %v", err)
}
if got := buffer.String(); got != want {
t.Errorf("Request body: %s, want %s", got, want)
}
}
func errorOption(*http.Request) error {
return errors.New("OptionFunc returns an error")
}
func TestNewClient(t *testing.T) {
c := NewClient(nil, "")
expectedBaseURL := defaultBaseURL + apiVersionPath
if c.BaseURL().String() != expectedBaseURL {
t.Errorf("NewClient BaseURL is %s, want %s", c.BaseURL().String(), expectedBaseURL)
}
if c.UserAgent != userAgent {
t.Errorf("NewClient UserAgent is %s, want %s", c.UserAgent, userAgent)
}
}
func TestSetBaseURL(t *testing.T) {
expectedBaseURL := "http://gitlab.local/foo/" + apiVersionPath
c := NewClient(nil, "")
err := c.SetBaseURL("http://gitlab.local/foo")
if err != nil {
t.Fatalf("Failed to SetBaseURL: %v", err)
}
if c.BaseURL().String() != expectedBaseURL {
t.Errorf("BaseURL is %s, want %s", c.BaseURL().String(), expectedBaseURL)
}
}
func TestCheckResponse(t *testing.T) {
req, err := NewClient(nil, "").NewRequest("GET", "test", nil, nil)
if err != nil {
t.Fatalf("Failed to create request: %v", err)
}
resp := &http.Response{
Request: req,
StatusCode: http.StatusBadRequest,
Body: ioutil.NopCloser(strings.NewReader(`
{
"message": {
"prop1": [
"message 1",
"message 2"
],
"prop2":[
"message 3"
],
"embed1": {
"prop3": [
"msg 1",
"msg2"
]
},
"embed2": {
"prop4": [
"some msg"
]
}
},
"error": "message 1"
}`)),
}
errResp := CheckResponse(resp)
if errResp == nil {
t.Fatal("Expected error response.")
}
want := "GET https://gitlab.com/api/v4/test: 400 {error: message 1}, {message: {embed1: {prop3: [msg 1, msg2]}}, {embed2: {prop4: [some msg]}}, {prop1: [message 1, message 2]}, {prop2: [message 3]}}"
if errResp.Error() != want {
t.Errorf("Expected error: %s, got %s", want, errResp.Error())
}
}
func TestRequestWithContext(t *testing.T) {
ctx := context.WithValue(context.Background(), interface{}("myKey"), interface{}("myValue"))
req, err := NewClient(nil, "").NewRequest("GET", "test", nil, []OptionFunc{WithContext(ctx)})
if err != nil {
t.Fatalf("Failed to create request: %v", err)
}
if req.Context() != ctx {
t.Fatal("Context was not set correctly")
}
}
func TestBoolValue(t *testing.T) {
testCases := map[string]struct {
data []byte
expected bool
}{
"should unmarshal true as true": {
data: []byte("true"),
expected: true,
},
"should unmarshal false as true": {
data: []byte("false"),
expected: false,
},
"should unmarshal \"1\" as true": {
data: []byte(`"1"`),
expected: true,
},
"should unmarshal \"0\" as false": {
data: []byte(`"0"`),
expected: false,
},
}
for name, testCase := range testCases {
t.Run(name, func(t *testing.T) {
var b BoolValue
if err := json.Unmarshal(testCase.data, &b); err != nil {
t.Fatalf("Unexpected error: %v", err)
}
if bool(b) != testCase.expected {
t.Fatalf("Expected %v but got %v", testCase.expected, b)
}
})
}
}