1
2
3
4
5
6 package github
7
8 import (
9 "context"
10 "encoding/json"
11 "fmt"
12 "net/http"
13 "testing"
14
15 "github.com/google/go-cmp/cmp"
16 )
17
18 func TestActivityService_ListEvents(t *testing.T) {
19 client, mux, _, teardown := setup()
20 defer teardown()
21
22 mux.HandleFunc("/events", func(w http.ResponseWriter, r *http.Request) {
23 testMethod(t, r, "GET")
24 testFormValues(t, r, values{
25 "page": "2",
26 })
27 fmt.Fprint(w, `[{"id":"1"},{"id":"2"}]`)
28 })
29
30 opt := &ListOptions{Page: 2}
31 ctx := context.Background()
32 events, _, err := client.Activity.ListEvents(ctx, opt)
33 if err != nil {
34 t.Errorf("Activities.ListEvents returned error: %v", err)
35 }
36
37 want := []*Event{{ID: String("1")}, {ID: String("2")}}
38 if !cmp.Equal(events, want) {
39 t.Errorf("Activities.ListEvents returned %+v, want %+v", events, want)
40 }
41
42 const methodName = "ListEvents"
43 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
44 got, resp, err := client.Activity.ListEvents(ctx, opt)
45 if got != nil {
46 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
47 }
48 return resp, err
49 })
50 }
51
52 func TestActivityService_ListRepositoryEvents(t *testing.T) {
53 client, mux, _, teardown := setup()
54 defer teardown()
55
56 mux.HandleFunc("/repos/o/r/events", func(w http.ResponseWriter, r *http.Request) {
57 testMethod(t, r, "GET")
58 testFormValues(t, r, values{
59 "page": "2",
60 })
61 fmt.Fprint(w, `[{"id":"1"},{"id":"2"}]`)
62 })
63
64 opt := &ListOptions{Page: 2}
65 ctx := context.Background()
66 events, _, err := client.Activity.ListRepositoryEvents(ctx, "o", "r", opt)
67 if err != nil {
68 t.Errorf("Activities.ListRepositoryEvents returned error: %v", err)
69 }
70
71 want := []*Event{{ID: String("1")}, {ID: String("2")}}
72 if !cmp.Equal(events, want) {
73 t.Errorf("Activities.ListRepositoryEvents returned %+v, want %+v", events, want)
74 }
75
76 const methodName = "ListRepositoryEvents"
77 testBadOptions(t, methodName, func() (err error) {
78 _, _, err = client.Activity.ListRepositoryEvents(ctx, "\n", "\n", opt)
79 return err
80 })
81
82 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
83 got, resp, err := client.Activity.ListRepositoryEvents(ctx, "o", "r", opt)
84 if got != nil {
85 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
86 }
87 return resp, err
88 })
89 }
90
91 func TestActivityService_ListRepositoryEvents_invalidOwner(t *testing.T) {
92 client, _, _, teardown := setup()
93 defer teardown()
94
95 ctx := context.Background()
96 _, _, err := client.Activity.ListRepositoryEvents(ctx, "%", "%", nil)
97 testURLParseError(t, err)
98 }
99
100 func TestActivityService_ListIssueEventsForRepository(t *testing.T) {
101 client, mux, _, teardown := setup()
102 defer teardown()
103
104 mux.HandleFunc("/repos/o/r/issues/events", func(w http.ResponseWriter, r *http.Request) {
105 testMethod(t, r, "GET")
106 testFormValues(t, r, values{
107 "page": "2",
108 })
109 fmt.Fprint(w, `[{"id":1},{"id":2}]`)
110 })
111
112 opt := &ListOptions{Page: 2}
113 ctx := context.Background()
114 events, _, err := client.Activity.ListIssueEventsForRepository(ctx, "o", "r", opt)
115 if err != nil {
116 t.Errorf("Activities.ListIssueEventsForRepository returned error: %v", err)
117 }
118
119 want := []*IssueEvent{{ID: Int64(1)}, {ID: Int64(2)}}
120 if !cmp.Equal(events, want) {
121 t.Errorf("Activities.ListIssueEventsForRepository returned %+v, want %+v", events, want)
122 }
123
124 const methodName = "ListIssueEventsForRepository"
125 testBadOptions(t, methodName, func() (err error) {
126 _, _, err = client.Activity.ListIssueEventsForRepository(ctx, "\n", "\n", opt)
127 return err
128 })
129
130 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
131 got, resp, err := client.Activity.ListIssueEventsForRepository(ctx, "o", "r", opt)
132 if got != nil {
133 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
134 }
135 return resp, err
136 })
137 }
138
139 func TestActivityService_ListIssueEventsForRepository_invalidOwner(t *testing.T) {
140 client, _, _, teardown := setup()
141 defer teardown()
142
143 ctx := context.Background()
144 _, _, err := client.Activity.ListIssueEventsForRepository(ctx, "%", "%", nil)
145 testURLParseError(t, err)
146 }
147
148 func TestActivityService_ListEventsForRepoNetwork(t *testing.T) {
149 client, mux, _, teardown := setup()
150 defer teardown()
151
152 mux.HandleFunc("/networks/o/r/events", func(w http.ResponseWriter, r *http.Request) {
153 testMethod(t, r, "GET")
154 testFormValues(t, r, values{
155 "page": "2",
156 })
157 fmt.Fprint(w, `[{"id":"1"},{"id":"2"}]`)
158 })
159
160 opt := &ListOptions{Page: 2}
161 ctx := context.Background()
162 events, _, err := client.Activity.ListEventsForRepoNetwork(ctx, "o", "r", opt)
163 if err != nil {
164 t.Errorf("Activities.ListEventsForRepoNetwork returned error: %v", err)
165 }
166
167 want := []*Event{{ID: String("1")}, {ID: String("2")}}
168 if !cmp.Equal(events, want) {
169 t.Errorf("Activities.ListEventsForRepoNetwork returned %+v, want %+v", events, want)
170 }
171
172 const methodName = "ListEventsForRepoNetwork"
173 testBadOptions(t, methodName, func() (err error) {
174 _, _, err = client.Activity.ListEventsForRepoNetwork(ctx, "\n", "\n", opt)
175 return err
176 })
177
178 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
179 got, resp, err := client.Activity.ListEventsForRepoNetwork(ctx, "o", "r", opt)
180 if got != nil {
181 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
182 }
183 return resp, err
184 })
185 }
186
187 func TestActivityService_ListEventsForRepoNetwork_invalidOwner(t *testing.T) {
188 client, _, _, teardown := setup()
189 defer teardown()
190
191 ctx := context.Background()
192 _, _, err := client.Activity.ListEventsForRepoNetwork(ctx, "%", "%", nil)
193 testURLParseError(t, err)
194 }
195
196 func TestActivityService_ListEventsForOrganization(t *testing.T) {
197 client, mux, _, teardown := setup()
198 defer teardown()
199
200 mux.HandleFunc("/orgs/o/events", func(w http.ResponseWriter, r *http.Request) {
201 testMethod(t, r, "GET")
202 testFormValues(t, r, values{
203 "page": "2",
204 })
205 fmt.Fprint(w, `[{"id":"1"},{"id":"2"}]`)
206 })
207
208 opt := &ListOptions{Page: 2}
209 ctx := context.Background()
210 events, _, err := client.Activity.ListEventsForOrganization(ctx, "o", opt)
211 if err != nil {
212 t.Errorf("Activities.ListEventsForOrganization returned error: %v", err)
213 }
214
215 want := []*Event{{ID: String("1")}, {ID: String("2")}}
216 if !cmp.Equal(events, want) {
217 t.Errorf("Activities.ListEventsForOrganization returned %+v, want %+v", events, want)
218 }
219
220 const methodName = "ListEventsForOrganization"
221 testBadOptions(t, methodName, func() (err error) {
222 _, _, err = client.Activity.ListEventsForOrganization(ctx, "\n", opt)
223 return err
224 })
225
226 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
227 got, resp, err := client.Activity.ListEventsForOrganization(ctx, "o", opt)
228 if got != nil {
229 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
230 }
231 return resp, err
232 })
233 }
234
235 func TestActivityService_ListEventsForOrganization_invalidOrg(t *testing.T) {
236 client, _, _, teardown := setup()
237 defer teardown()
238
239 ctx := context.Background()
240 _, _, err := client.Activity.ListEventsForOrganization(ctx, "%", nil)
241 testURLParseError(t, err)
242 }
243
244 func TestActivityService_ListEventsPerformedByUser_all(t *testing.T) {
245 client, mux, _, teardown := setup()
246 defer teardown()
247
248 mux.HandleFunc("/users/u/events", func(w http.ResponseWriter, r *http.Request) {
249 testMethod(t, r, "GET")
250 testFormValues(t, r, values{
251 "page": "2",
252 })
253 fmt.Fprint(w, `[{"id":"1"},{"id":"2"}]`)
254 })
255
256 opt := &ListOptions{Page: 2}
257 ctx := context.Background()
258 events, _, err := client.Activity.ListEventsPerformedByUser(ctx, "u", false, opt)
259 if err != nil {
260 t.Errorf("Events.ListPerformedByUser returned error: %v", err)
261 }
262
263 want := []*Event{{ID: String("1")}, {ID: String("2")}}
264 if !cmp.Equal(events, want) {
265 t.Errorf("Events.ListPerformedByUser returned %+v, want %+v", events, want)
266 }
267
268 const methodName = "ListEventsPerformedByUser"
269 testBadOptions(t, methodName, func() (err error) {
270 _, _, err = client.Activity.ListEventsPerformedByUser(ctx, "\n", false, opt)
271 return err
272 })
273
274 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
275 got, resp, err := client.Activity.ListEventsPerformedByUser(ctx, "u", false, opt)
276 if got != nil {
277 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
278 }
279 return resp, err
280 })
281 }
282
283 func TestActivityService_ListEventsPerformedByUser_publicOnly(t *testing.T) {
284 client, mux, _, teardown := setup()
285 defer teardown()
286
287 mux.HandleFunc("/users/u/events/public", func(w http.ResponseWriter, r *http.Request) {
288 testMethod(t, r, "GET")
289 fmt.Fprint(w, `[{"id":"1"},{"id":"2"}]`)
290 })
291
292 ctx := context.Background()
293 events, _, err := client.Activity.ListEventsPerformedByUser(ctx, "u", true, nil)
294 if err != nil {
295 t.Errorf("Events.ListPerformedByUser returned error: %v", err)
296 }
297
298 want := []*Event{{ID: String("1")}, {ID: String("2")}}
299 if !cmp.Equal(events, want) {
300 t.Errorf("Events.ListPerformedByUser returned %+v, want %+v", events, want)
301 }
302 }
303
304 func TestActivityService_ListEventsPerformedByUser_invalidUser(t *testing.T) {
305 client, _, _, teardown := setup()
306 defer teardown()
307
308 ctx := context.Background()
309 _, _, err := client.Activity.ListEventsPerformedByUser(ctx, "%", false, nil)
310 testURLParseError(t, err)
311 }
312
313 func TestActivityService_ListEventsReceivedByUser_all(t *testing.T) {
314 client, mux, _, teardown := setup()
315 defer teardown()
316
317 mux.HandleFunc("/users/u/received_events", func(w http.ResponseWriter, r *http.Request) {
318 testMethod(t, r, "GET")
319 testFormValues(t, r, values{
320 "page": "2",
321 })
322 fmt.Fprint(w, `[{"id":"1"},{"id":"2"}]`)
323 })
324
325 opt := &ListOptions{Page: 2}
326 ctx := context.Background()
327 events, _, err := client.Activity.ListEventsReceivedByUser(ctx, "u", false, opt)
328 if err != nil {
329 t.Errorf("Events.ListReceivedByUser returned error: %v", err)
330 }
331
332 want := []*Event{{ID: String("1")}, {ID: String("2")}}
333 if !cmp.Equal(events, want) {
334 t.Errorf("Events.ListReceivedUser returned %+v, want %+v", events, want)
335 }
336
337 const methodName = "ListEventsReceivedByUser"
338 testBadOptions(t, methodName, func() (err error) {
339 _, _, err = client.Activity.ListEventsReceivedByUser(ctx, "\n", false, opt)
340 return err
341 })
342
343 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
344 got, resp, err := client.Activity.ListEventsReceivedByUser(ctx, "u", false, opt)
345 if got != nil {
346 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
347 }
348 return resp, err
349 })
350 }
351
352 func TestActivityService_ListEventsReceivedByUser_publicOnly(t *testing.T) {
353 client, mux, _, teardown := setup()
354 defer teardown()
355
356 mux.HandleFunc("/users/u/received_events/public", func(w http.ResponseWriter, r *http.Request) {
357 testMethod(t, r, "GET")
358 fmt.Fprint(w, `[{"id":"1"},{"id":"2"}]`)
359 })
360
361 ctx := context.Background()
362 events, _, err := client.Activity.ListEventsReceivedByUser(ctx, "u", true, nil)
363 if err != nil {
364 t.Errorf("Events.ListReceivedByUser returned error: %v", err)
365 }
366
367 want := []*Event{{ID: String("1")}, {ID: String("2")}}
368 if !cmp.Equal(events, want) {
369 t.Errorf("Events.ListReceivedByUser returned %+v, want %+v", events, want)
370 }
371 }
372
373 func TestActivityService_ListEventsReceivedByUser_invalidUser(t *testing.T) {
374 client, _, _, teardown := setup()
375 defer teardown()
376
377 ctx := context.Background()
378 _, _, err := client.Activity.ListEventsReceivedByUser(ctx, "%", false, nil)
379 testURLParseError(t, err)
380 }
381
382 func TestActivityService_ListUserEventsForOrganization(t *testing.T) {
383 client, mux, _, teardown := setup()
384 defer teardown()
385
386 mux.HandleFunc("/users/u/events/orgs/o", func(w http.ResponseWriter, r *http.Request) {
387 testMethod(t, r, "GET")
388 testFormValues(t, r, values{
389 "page": "2",
390 })
391 fmt.Fprint(w, `[{"id":"1"},{"id":"2"}]`)
392 })
393
394 opt := &ListOptions{Page: 2}
395 ctx := context.Background()
396 events, _, err := client.Activity.ListUserEventsForOrganization(ctx, "o", "u", opt)
397 if err != nil {
398 t.Errorf("Activities.ListUserEventsForOrganization returned error: %v", err)
399 }
400
401 want := []*Event{{ID: String("1")}, {ID: String("2")}}
402 if !cmp.Equal(events, want) {
403 t.Errorf("Activities.ListUserEventsForOrganization returned %+v, want %+v", events, want)
404 }
405
406 const methodName = "ListUserEventsForOrganization"
407 testBadOptions(t, methodName, func() (err error) {
408 _, _, err = client.Activity.ListUserEventsForOrganization(ctx, "\n", "\n", opt)
409 return err
410 })
411
412 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
413 got, resp, err := client.Activity.ListUserEventsForOrganization(ctx, "o", "u", opt)
414 if got != nil {
415 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
416 }
417 return resp, err
418 })
419 }
420
421 func TestActivityService_EventParsePayload_typed(t *testing.T) {
422 raw := []byte(`{"type": "PushEvent","payload":{"push_id": 1}}`)
423 var event *Event
424 if err := json.Unmarshal(raw, &event); err != nil {
425 t.Fatalf("Unmarshal Event returned error: %v", err)
426 }
427
428 want := &PushEvent{PushID: Int64(1)}
429 got, err := event.ParsePayload()
430 if err != nil {
431 t.Fatalf("ParsePayload returned unexpected error: %v", err)
432 }
433 if !cmp.Equal(got, want) {
434 t.Errorf("Event.ParsePayload returned %+v, want %+v", got, want)
435 }
436 }
437
438
439
440
441 func TestActivityService_EventParsePayload_untyped(t *testing.T) {
442 raw := []byte(`{"type": "UnrecognizedEvent","payload":{"field": "val"}}`)
443 var event *Event
444 if err := json.Unmarshal(raw, &event); err != nil {
445 t.Fatalf("Unmarshal Event returned error: %v", err)
446 }
447
448 want := map[string]interface{}{"field": "val"}
449 got, err := event.ParsePayload()
450 if err != nil {
451 t.Fatalf("ParsePayload returned unexpected error: %v", err)
452 }
453 if !cmp.Equal(got, want) {
454 t.Errorf("Event.ParsePayload returned %+v, want %+v", got, want)
455 }
456 }
457
458 func TestActivityService_EventParsePayload_installation(t *testing.T) {
459 raw := []byte(`{"type": "PullRequestEvent","payload":{"installation":{"id":1}}}`)
460 var event *Event
461 if err := json.Unmarshal(raw, &event); err != nil {
462 t.Fatalf("Unmarshal Event returned error: %v", err)
463 }
464
465 want := &PullRequestEvent{Installation: &Installation{ID: Int64(1)}}
466 got, err := event.ParsePayload()
467 if err != nil {
468 t.Fatalf("ParsePayload returned unexpected error: %v", err)
469 }
470 if !cmp.Equal(got, want) {
471 t.Errorf("Event.ParsePayload returned %+v, want %+v", got, want)
472 }
473 }
474
View as plain text