1
2
3
4
5
6 package github
7
8 import (
9 "context"
10 "encoding/json"
11 "fmt"
12 "net/http"
13 "reflect"
14 "testing"
15
16 "github.com/google/go-cmp/cmp"
17 )
18
19 func TestRepositoriesService_ListHookDeliveries(t *testing.T) {
20 client, mux, _, teardown := setup()
21 defer teardown()
22
23 mux.HandleFunc("/repos/o/r/hooks/1/deliveries", func(w http.ResponseWriter, r *http.Request) {
24 testMethod(t, r, "GET")
25 testFormValues(t, r, values{"cursor": "v1_12077215967"})
26 fmt.Fprint(w, `[{"id":1}, {"id":2}]`)
27 })
28
29 opt := &ListCursorOptions{Cursor: "v1_12077215967"}
30
31 ctx := context.Background()
32 hooks, _, err := client.Repositories.ListHookDeliveries(ctx, "o", "r", 1, opt)
33 if err != nil {
34 t.Errorf("Repositories.ListHookDeliveries returned error: %v", err)
35 }
36
37 want := []*HookDelivery{{ID: Int64(1)}, {ID: Int64(2)}}
38 if d := cmp.Diff(hooks, want); d != "" {
39 t.Errorf("Repositories.ListHooks want (-), got (+):\n%s", d)
40 }
41
42 const methodName = "ListHookDeliveries"
43 testBadOptions(t, methodName, func() (err error) {
44 _, _, err = client.Repositories.ListHookDeliveries(ctx, "\n", "\n", -1, opt)
45 return err
46 })
47
48 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
49 got, resp, err := client.Repositories.ListHookDeliveries(ctx, "o", "r", 1, opt)
50 if got != nil {
51 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
52 }
53 return resp, err
54 })
55 }
56
57 func TestRepositoriesService_ListHookDeliveries_invalidOwner(t *testing.T) {
58 client, _, _, teardown := setup()
59 defer teardown()
60
61 ctx := context.Background()
62 _, _, err := client.Repositories.ListHookDeliveries(ctx, "%", "%", 1, nil)
63 testURLParseError(t, err)
64 }
65
66 func TestRepositoriesService_GetHookDelivery(t *testing.T) {
67 client, mux, _, teardown := setup()
68 defer teardown()
69
70 mux.HandleFunc("/repos/o/r/hooks/1/deliveries/1", func(w http.ResponseWriter, r *http.Request) {
71 testMethod(t, r, "GET")
72 fmt.Fprint(w, `{"id":1}`)
73 })
74
75 ctx := context.Background()
76 hook, _, err := client.Repositories.GetHookDelivery(ctx, "o", "r", 1, 1)
77 if err != nil {
78 t.Errorf("Repositories.GetHookDelivery returned error: %v", err)
79 }
80
81 want := &HookDelivery{ID: Int64(1)}
82 if !cmp.Equal(hook, want) {
83 t.Errorf("Repositories.GetHookDelivery returned %+v, want %+v", hook, want)
84 }
85
86 const methodName = "GetHookDelivery"
87 testBadOptions(t, methodName, func() (err error) {
88 _, _, err = client.Repositories.GetHookDelivery(ctx, "\n", "\n", -1, -1)
89 return err
90 })
91
92 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
93 got, resp, err := client.Repositories.GetHookDelivery(ctx, "o", "r", 1, 1)
94 if got != nil {
95 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
96 }
97 return resp, err
98 })
99 }
100
101 func TestRepositoriesService_GetHookDelivery_invalidOwner(t *testing.T) {
102 client, _, _, teardown := setup()
103 defer teardown()
104
105 ctx := context.Background()
106 _, _, err := client.Repositories.GetHookDelivery(ctx, "%", "%", 1, 1)
107 testURLParseError(t, err)
108 }
109
110 func TestRepositoriesService_RedeliverHookDelivery(t *testing.T) {
111 client, mux, _, teardown := setup()
112 defer teardown()
113
114 mux.HandleFunc("/repos/o/r/hooks/1/deliveries/1/attempts", func(w http.ResponseWriter, r *http.Request) {
115 testMethod(t, r, "POST")
116 fmt.Fprint(w, `{"id":1}`)
117 })
118
119 ctx := context.Background()
120 hook, _, err := client.Repositories.RedeliverHookDelivery(ctx, "o", "r", 1, 1)
121 if err != nil {
122 t.Errorf("Repositories.RedeliverHookDelivery returned error: %v", err)
123 }
124
125 want := &HookDelivery{ID: Int64(1)}
126 if !cmp.Equal(hook, want) {
127 t.Errorf("Repositories.RedeliverHookDelivery returned %+v, want %+v", hook, want)
128 }
129
130 const methodName = "RedeliverHookDelivery"
131 testBadOptions(t, methodName, func() (err error) {
132 _, _, err = client.Repositories.RedeliverHookDelivery(ctx, "\n", "\n", -1, -1)
133 return err
134 })
135
136 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
137 got, resp, err := client.Repositories.RedeliverHookDelivery(ctx, "o", "r", 1, 1)
138 if got != nil {
139 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
140 }
141 return resp, err
142 })
143 }
144
145 var hookDeliveryPayloadTypeToStruct = map[string]interface{}{
146 "check_run": &CheckRunEvent{},
147 "check_suite": &CheckSuiteEvent{},
148 "commit_comment": &CommitCommentEvent{},
149 "content_reference": &ContentReferenceEvent{},
150 "create": &CreateEvent{},
151 "delete": &DeleteEvent{},
152 "deploy_key": &DeployKeyEvent{},
153 "deployment": &DeploymentEvent{},
154 "deployment_status": &DeploymentStatusEvent{},
155 "discussion": &DiscussionEvent{},
156 "fork": &ForkEvent{},
157 "github_app_authorization": &GitHubAppAuthorizationEvent{},
158 "gollum": &GollumEvent{},
159 "installation": &InstallationEvent{},
160 "installation_repositories": &InstallationRepositoriesEvent{},
161 "issue_comment": &IssueCommentEvent{},
162 "issues": &IssuesEvent{},
163 "label": &LabelEvent{},
164 "marketplace_purchase": &MarketplacePurchaseEvent{},
165 "member": &MemberEvent{},
166 "membership": &MembershipEvent{},
167 "meta": &MetaEvent{},
168 "milestone": &MilestoneEvent{},
169 "organization": &OrganizationEvent{},
170 "org_block": &OrgBlockEvent{},
171 "package": &PackageEvent{},
172 "page_build": &PageBuildEvent{},
173 "ping": &PingEvent{},
174 "project": &ProjectEvent{},
175 "project_card": &ProjectCardEvent{},
176 "project_column": &ProjectColumnEvent{},
177 "public": &PublicEvent{},
178 "pull_request": &PullRequestEvent{},
179 "pull_request_review": &PullRequestReviewEvent{},
180 "pull_request_review_comment": &PullRequestReviewCommentEvent{},
181 "pull_request_review_thread": &PullRequestReviewThreadEvent{},
182 "pull_request_target": &PullRequestTargetEvent{},
183 "push": &PushEvent{},
184 "release": &ReleaseEvent{},
185 "repository": &RepositoryEvent{},
186 "repository_dispatch": &RepositoryDispatchEvent{},
187 "repository_import": &RepositoryImportEvent{},
188 "repository_vulnerability_alert": &RepositoryVulnerabilityAlertEvent{},
189 "secret_scanning_alert": &SecretScanningAlertEvent{},
190 "star": &StarEvent{},
191 "status": &StatusEvent{},
192 "team": &TeamEvent{},
193 "team_add": &TeamAddEvent{},
194 "user": &UserEvent{},
195 "watch": &WatchEvent{},
196 "workflow_dispatch": &WorkflowDispatchEvent{},
197 "workflow_job": &WorkflowJobEvent{},
198 "workflow_run": &WorkflowRunEvent{},
199 }
200
201 func TestHookDelivery_ParsePayload(t *testing.T) {
202 for evt, obj := range hookDeliveryPayloadTypeToStruct {
203 t.Run(evt, func(t *testing.T) {
204 bs, err := json.Marshal(obj)
205 if err != nil {
206 t.Fatal(err)
207 }
208
209 p := json.RawMessage(bs)
210
211 d := &HookDelivery{
212 Event: String(evt),
213 Request: &HookRequest{
214 RawPayload: &p,
215 },
216 }
217
218 got, err := d.ParseRequestPayload()
219 if err != nil {
220 t.Error(err)
221 }
222
223 if !reflect.DeepEqual(obj, got) {
224 t.Errorf("want %T %v, got %T %v", obj, obj, got, got)
225 }
226 })
227 }
228 }
229
230 func TestHookDelivery_ParsePayload_invalidEvent(t *testing.T) {
231 p := json.RawMessage(nil)
232
233 d := &HookDelivery{
234 Event: String("some_invalid_event"),
235 Request: &HookRequest{
236 RawPayload: &p,
237 },
238 }
239
240 _, err := d.ParseRequestPayload()
241 if err == nil || err.Error() != `unsupported event type "some_invalid_event"` {
242 t.Errorf("unexpected error: %v", err)
243 }
244 }
245
246 func TestHookDelivery_ParsePayload_invalidPayload(t *testing.T) {
247 p := json.RawMessage([]byte(`{"check_run":{"id":"invalid"}}`))
248
249 d := &HookDelivery{
250 Event: String("check_run"),
251 Request: &HookRequest{
252 RawPayload: &p,
253 },
254 }
255
256 _, err := d.ParseRequestPayload()
257 if err == nil || err.Error() != "json: cannot unmarshal string into Go struct field CheckRun.check_run.id of type int64" {
258 t.Errorf("unexpected error: %v", err)
259 }
260 }
261
262 func TestHookRequest_Marshal(t *testing.T) {
263 testJSONMarshal(t, &HookRequest{}, "{}")
264
265 header := make(map[string]string)
266 header["key"] = "value"
267
268 jsonMsg, _ := json.Marshal(&header)
269
270 r := &HookRequest{
271 Headers: header,
272 RawPayload: (*json.RawMessage)(&jsonMsg),
273 }
274
275 want := `{
276 "headers": {
277 "key": "value"
278 },
279 "payload": {
280 "key": "value"
281 }
282 }`
283
284 testJSONMarshal(t, r, want)
285 }
286
287 func TestHookResponse_Marshal(t *testing.T) {
288 testJSONMarshal(t, &HookResponse{}, "{}")
289
290 header := make(map[string]string)
291 header["key"] = "value"
292
293 jsonMsg, _ := json.Marshal(&header)
294
295 r := &HookResponse{
296 Headers: header,
297 RawPayload: (*json.RawMessage)(&jsonMsg),
298 }
299
300 want := `{
301 "headers": {
302 "key": "value"
303 },
304 "payload": {
305 "key": "value"
306 }
307 }`
308
309 testJSONMarshal(t, r, want)
310 }
311
312 func TestHookDelivery_Marshal(t *testing.T) {
313 testJSONMarshal(t, &HookDelivery{}, "{}")
314
315 header := make(map[string]string)
316 header["key"] = "value"
317
318 jsonMsg, _ := json.Marshal(&header)
319
320 r := &HookDelivery{
321 ID: Int64(1),
322 GUID: String("guid"),
323 DeliveredAt: &Timestamp{referenceTime},
324 Redelivery: Bool(true),
325 Duration: Float64(1),
326 Status: String("guid"),
327 StatusCode: Int(1),
328 Event: String("guid"),
329 Action: String("guid"),
330 InstallationID: Int64(1),
331 RepositoryID: Int64(1),
332 Request: &HookRequest{
333 Headers: header,
334 RawPayload: (*json.RawMessage)(&jsonMsg),
335 },
336 Response: &HookResponse{
337 Headers: header,
338 RawPayload: (*json.RawMessage)(&jsonMsg),
339 },
340 }
341
342 want := `{
343 "id": 1,
344 "guid": "guid",
345 "delivered_at": ` + referenceTimeStr + `,
346 "redelivery": true,
347 "duration": 1,
348 "status": "guid",
349 "status_code": 1,
350 "event": "guid",
351 "action": "guid",
352 "installation_id": 1,
353 "repository_id": 1,
354 "request": {
355 "headers": {
356 "key": "value"
357 },
358 "payload": {
359 "key": "value"
360 }
361 },
362 "response": {
363 "headers": {
364 "key": "value"
365 },
366 "payload": {
367 "key": "value"
368 }
369 }
370 }`
371
372 testJSONMarshal(t, r, want)
373 }
374
View as plain text