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 "code_scanning_alert": &CodeScanningAlertEvent{},
149 "commit_comment": &CommitCommentEvent{},
150 "content_reference": &ContentReferenceEvent{},
151 "create": &CreateEvent{},
152 "delete": &DeleteEvent{},
153 "deploy_key": &DeployKeyEvent{},
154 "deployment": &DeploymentEvent{},
155 "deployment_status": &DeploymentStatusEvent{},
156 "discussion": &DiscussionEvent{},
157 "fork": &ForkEvent{},
158 "github_app_authorization": &GitHubAppAuthorizationEvent{},
159 "gollum": &GollumEvent{},
160 "installation": &InstallationEvent{},
161 "installation_repositories": &InstallationRepositoriesEvent{},
162 "issue_comment": &IssueCommentEvent{},
163 "issues": &IssuesEvent{},
164 "label": &LabelEvent{},
165 "marketplace_purchase": &MarketplacePurchaseEvent{},
166 "member": &MemberEvent{},
167 "membership": &MembershipEvent{},
168 "meta": &MetaEvent{},
169 "milestone": &MilestoneEvent{},
170 "organization": &OrganizationEvent{},
171 "org_block": &OrgBlockEvent{},
172 "package": &PackageEvent{},
173 "page_build": &PageBuildEvent{},
174 "ping": &PingEvent{},
175 "project": &ProjectEvent{},
176 "project_card": &ProjectCardEvent{},
177 "project_column": &ProjectColumnEvent{},
178 "public": &PublicEvent{},
179 "pull_request": &PullRequestEvent{},
180 "pull_request_review": &PullRequestReviewEvent{},
181 "pull_request_review_comment": &PullRequestReviewCommentEvent{},
182 "pull_request_review_thread": &PullRequestReviewThreadEvent{},
183 "pull_request_target": &PullRequestTargetEvent{},
184 "push": &PushEvent{},
185 "release": &ReleaseEvent{},
186 "repository": &RepositoryEvent{},
187 "repository_dispatch": &RepositoryDispatchEvent{},
188 "repository_import": &RepositoryImportEvent{},
189 "repository_vulnerability_alert": &RepositoryVulnerabilityAlertEvent{},
190 "secret_scanning_alert": &SecretScanningAlertEvent{},
191 "star": &StarEvent{},
192 "status": &StatusEvent{},
193 "team": &TeamEvent{},
194 "team_add": &TeamAddEvent{},
195 "user": &UserEvent{},
196 "watch": &WatchEvent{},
197 "workflow_dispatch": &WorkflowDispatchEvent{},
198 "workflow_job": &WorkflowJobEvent{},
199 "workflow_run": &WorkflowRunEvent{},
200 }
201
202 func TestHookDelivery_ParsePayload(t *testing.T) {
203 for evt, obj := range hookDeliveryPayloadTypeToStruct {
204 t.Run(evt, func(t *testing.T) {
205 bs, err := json.Marshal(obj)
206 if err != nil {
207 t.Fatal(err)
208 }
209
210 p := json.RawMessage(bs)
211
212 d := &HookDelivery{
213 Event: String(evt),
214 Request: &HookRequest{
215 RawPayload: &p,
216 },
217 }
218
219 got, err := d.ParseRequestPayload()
220 if err != nil {
221 t.Error(err)
222 }
223
224 if !reflect.DeepEqual(obj, got) {
225 t.Errorf("want %T %v, got %T %v", obj, obj, got, got)
226 }
227 })
228 }
229 }
230
231 func TestHookDelivery_ParsePayload_invalidEvent(t *testing.T) {
232 p := json.RawMessage(nil)
233
234 d := &HookDelivery{
235 Event: String("some_invalid_event"),
236 Request: &HookRequest{
237 RawPayload: &p,
238 },
239 }
240
241 _, err := d.ParseRequestPayload()
242 if err == nil || err.Error() != `unsupported event type "some_invalid_event"` {
243 t.Errorf("unexpected error: %v", err)
244 }
245 }
246
247 func TestHookDelivery_ParsePayload_invalidPayload(t *testing.T) {
248 p := json.RawMessage([]byte(`{"check_run":{"id":"invalid"}}`))
249
250 d := &HookDelivery{
251 Event: String("check_run"),
252 Request: &HookRequest{
253 RawPayload: &p,
254 },
255 }
256
257 _, err := d.ParseRequestPayload()
258 if err == nil || err.Error() != "json: cannot unmarshal string into Go struct field CheckRun.check_run.id of type int64" {
259 t.Errorf("unexpected error: %v", err)
260 }
261 }
262
263 func TestHookRequest_Marshal(t *testing.T) {
264 testJSONMarshal(t, &HookRequest{}, "{}")
265
266 header := make(map[string]string)
267 header["key"] = "value"
268
269 jsonMsg, _ := json.Marshal(&header)
270
271 r := &HookRequest{
272 Headers: header,
273 RawPayload: (*json.RawMessage)(&jsonMsg),
274 }
275
276 want := `{
277 "headers": {
278 "key": "value"
279 },
280 "payload": {
281 "key": "value"
282 }
283 }`
284
285 testJSONMarshal(t, r, want)
286 }
287
288 func TestHookResponse_Marshal(t *testing.T) {
289 testJSONMarshal(t, &HookResponse{}, "{}")
290
291 header := make(map[string]string)
292 header["key"] = "value"
293
294 jsonMsg, _ := json.Marshal(&header)
295
296 r := &HookResponse{
297 Headers: header,
298 RawPayload: (*json.RawMessage)(&jsonMsg),
299 }
300
301 want := `{
302 "headers": {
303 "key": "value"
304 },
305 "payload": {
306 "key": "value"
307 }
308 }`
309
310 testJSONMarshal(t, r, want)
311 }
312
313 func TestHookDelivery_Marshal(t *testing.T) {
314 testJSONMarshal(t, &HookDelivery{}, "{}")
315
316 header := make(map[string]string)
317 header["key"] = "value"
318
319 jsonMsg, _ := json.Marshal(&header)
320
321 r := &HookDelivery{
322 ID: Int64(1),
323 GUID: String("guid"),
324 DeliveredAt: &Timestamp{referenceTime},
325 Redelivery: Bool(true),
326 Duration: Float64(1),
327 Status: String("guid"),
328 StatusCode: Int(1),
329 Event: String("guid"),
330 Action: String("guid"),
331 InstallationID: Int64(1),
332 RepositoryID: Int64(1),
333 Request: &HookRequest{
334 Headers: header,
335 RawPayload: (*json.RawMessage)(&jsonMsg),
336 },
337 Response: &HookResponse{
338 Headers: header,
339 RawPayload: (*json.RawMessage)(&jsonMsg),
340 },
341 }
342
343 want := `{
344 "id": 1,
345 "guid": "guid",
346 "delivered_at": ` + referenceTimeStr + `,
347 "redelivery": true,
348 "duration": 1,
349 "status": "guid",
350 "status_code": 1,
351 "event": "guid",
352 "action": "guid",
353 "installation_id": 1,
354 "repository_id": 1,
355 "request": {
356 "headers": {
357 "key": "value"
358 },
359 "payload": {
360 "key": "value"
361 }
362 },
363 "response": {
364 "headers": {
365 "key": "value"
366 },
367 "payload": {
368 "key": "value"
369 }
370 }
371 }`
372
373 testJSONMarshal(t, r, want)
374 }
375
View as plain text