1
2
3
4
5
6 package github
7
8 import (
9 "context"
10 "fmt"
11 "net/http"
12 "net/url"
13 "strings"
14 "testing"
15 "time"
16
17 "github.com/google/go-cmp/cmp"
18 "golang.org/x/crypto/openpgp"
19 )
20
21 func TestRepositoriesService_ListCommits(t *testing.T) {
22 client, mux, _, teardown := setup()
23 defer teardown()
24
25
26 mux.HandleFunc("/repos/o/r/commits", func(w http.ResponseWriter, r *http.Request) {
27 testMethod(t, r, "GET")
28 testFormValues(t, r,
29 values{
30 "sha": "s",
31 "path": "p",
32 "author": "a",
33 "since": "2013-08-01T00:00:00Z",
34 "until": "2013-09-03T00:00:00Z",
35 })
36 fmt.Fprintf(w, `[{"sha": "s"}]`)
37 })
38
39 opt := &CommitsListOptions{
40 SHA: "s",
41 Path: "p",
42 Author: "a",
43 Since: time.Date(2013, time.August, 1, 0, 0, 0, 0, time.UTC),
44 Until: time.Date(2013, time.September, 3, 0, 0, 0, 0, time.UTC),
45 }
46 ctx := context.Background()
47 commits, _, err := client.Repositories.ListCommits(ctx, "o", "r", opt)
48 if err != nil {
49 t.Errorf("Repositories.ListCommits returned error: %v", err)
50 }
51
52 want := []*RepositoryCommit{{SHA: String("s")}}
53 if !cmp.Equal(commits, want) {
54 t.Errorf("Repositories.ListCommits returned %+v, want %+v", commits, want)
55 }
56
57 const methodName = "ListCommits"
58 testBadOptions(t, methodName, func() (err error) {
59 _, _, err = client.Repositories.ListCommits(ctx, "\n", "\n", opt)
60 return err
61 })
62
63 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
64 got, resp, err := client.Repositories.ListCommits(ctx, "o", "r", opt)
65 if got != nil {
66 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
67 }
68 return resp, err
69 })
70 }
71
72 func TestRepositoriesService_GetCommit(t *testing.T) {
73 client, mux, _, teardown := setup()
74 defer teardown()
75
76 mux.HandleFunc("/repos/o/r/commits/s", func(w http.ResponseWriter, r *http.Request) {
77 testMethod(t, r, "GET")
78 testFormValues(t, r, values{"per_page": "2", "page": "2"})
79 fmt.Fprintf(w, `{
80 "sha": "s",
81 "commit": { "message": "m" },
82 "author": { "login": "l" },
83 "committer": { "login": "l" },
84 "parents": [ { "sha": "s" } ],
85 "stats": { "additions": 104, "deletions": 4, "total": 108 },
86 "files": [
87 {
88 "filename": "f",
89 "additions": 10,
90 "deletions": 2,
91 "changes": 12,
92 "status": "s",
93 "patch": "p",
94 "blob_url": "b",
95 "raw_url": "r",
96 "contents_url": "c"
97 }
98 ]
99 }`)
100 })
101
102 opts := &ListOptions{Page: 2, PerPage: 2}
103 ctx := context.Background()
104 commit, _, err := client.Repositories.GetCommit(ctx, "o", "r", "s", opts)
105 if err != nil {
106 t.Errorf("Repositories.GetCommit returned error: %v", err)
107 }
108
109 want := &RepositoryCommit{
110 SHA: String("s"),
111 Commit: &Commit{
112 Message: String("m"),
113 },
114 Author: &User{
115 Login: String("l"),
116 },
117 Committer: &User{
118 Login: String("l"),
119 },
120 Parents: []*Commit{
121 {
122 SHA: String("s"),
123 },
124 },
125 Stats: &CommitStats{
126 Additions: Int(104),
127 Deletions: Int(4),
128 Total: Int(108),
129 },
130 Files: []*CommitFile{
131 {
132 Filename: String("f"),
133 Additions: Int(10),
134 Deletions: Int(2),
135 Changes: Int(12),
136 Status: String("s"),
137 Patch: String("p"),
138 BlobURL: String("b"),
139 RawURL: String("r"),
140 ContentsURL: String("c"),
141 },
142 },
143 }
144 if !cmp.Equal(commit, want) {
145 t.Errorf("Repositories.GetCommit returned \n%+v, want \n%+v", commit, want)
146 }
147
148 const methodName = "GetCommit"
149 testBadOptions(t, methodName, func() (err error) {
150 _, _, err = client.Repositories.GetCommit(ctx, "\n", "\n", "\n", opts)
151 return err
152 })
153
154 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
155 got, resp, err := client.Repositories.GetCommit(ctx, "o", "r", "s", opts)
156 if got != nil {
157 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
158 }
159 return resp, err
160 })
161 }
162
163 func TestRepositoriesService_GetCommitRaw_diff(t *testing.T) {
164 client, mux, _, teardown := setup()
165 defer teardown()
166
167 const rawStr = "@@diff content"
168
169 mux.HandleFunc("/repos/o/r/commits/s", func(w http.ResponseWriter, r *http.Request) {
170 testMethod(t, r, "GET")
171 testHeader(t, r, "Accept", mediaTypeV3Diff)
172 fmt.Fprint(w, rawStr)
173 })
174
175 ctx := context.Background()
176 got, _, err := client.Repositories.GetCommitRaw(ctx, "o", "r", "s", RawOptions{Type: Diff})
177 if err != nil {
178 t.Fatalf("Repositories.GetCommitRaw returned error: %v", err)
179 }
180 want := rawStr
181 if got != want {
182 t.Errorf("Repositories.GetCommitRaw returned %s want %s", got, want)
183 }
184
185 const methodName = "GetCommitRaw"
186 testBadOptions(t, methodName, func() (err error) {
187 _, _, err = client.Repositories.GetCommitRaw(ctx, "\n", "\n", "\n", RawOptions{Type: Diff})
188 return err
189 })
190
191 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
192 got, resp, err := client.Repositories.GetCommitRaw(ctx, "o", "r", "s", RawOptions{Type: Diff})
193 if got != "" {
194 t.Errorf("testNewRequestAndDoFailure %v = %#v, want ''", methodName, got)
195 }
196 return resp, err
197 })
198 }
199
200 func TestRepositoriesService_GetCommitRaw_patch(t *testing.T) {
201 client, mux, _, teardown := setup()
202 defer teardown()
203
204 const rawStr = "@@patch content"
205
206 mux.HandleFunc("/repos/o/r/commits/s", func(w http.ResponseWriter, r *http.Request) {
207 testMethod(t, r, "GET")
208 testHeader(t, r, "Accept", mediaTypeV3Patch)
209 fmt.Fprint(w, rawStr)
210 })
211
212 ctx := context.Background()
213 got, _, err := client.Repositories.GetCommitRaw(ctx, "o", "r", "s", RawOptions{Type: Patch})
214 if err != nil {
215 t.Fatalf("Repositories.GetCommitRaw returned error: %v", err)
216 }
217 want := rawStr
218 if got != want {
219 t.Errorf("Repositories.GetCommitRaw returned %s want %s", got, want)
220 }
221 }
222
223 func TestRepositoriesService_GetCommitRaw_invalid(t *testing.T) {
224 client, _, _, teardown := setup()
225 defer teardown()
226
227 ctx := context.Background()
228 _, _, err := client.Repositories.GetCommitRaw(ctx, "o", "r", "s", RawOptions{100})
229 if err == nil {
230 t.Fatal("Repositories.GetCommitRaw should return error")
231 }
232 if !strings.Contains(err.Error(), "unsupported raw type") {
233 t.Error("Repositories.GetCommitRaw should return unsupported raw type error")
234 }
235 }
236
237 func TestRepositoriesService_GetCommitSHA1(t *testing.T) {
238 client, mux, _, teardown := setup()
239 defer teardown()
240 const sha1 = "01234abcde"
241
242 mux.HandleFunc("/repos/o/r/commits/master", func(w http.ResponseWriter, r *http.Request) {
243 testMethod(t, r, "GET")
244 testHeader(t, r, "Accept", mediaTypeV3SHA)
245
246 fmt.Fprintf(w, sha1)
247 })
248
249 ctx := context.Background()
250 got, _, err := client.Repositories.GetCommitSHA1(ctx, "o", "r", "master", "")
251 if err != nil {
252 t.Errorf("Repositories.GetCommitSHA1 returned error: %v", err)
253 }
254
255 want := sha1
256 if got != want {
257 t.Errorf("Repositories.GetCommitSHA1 = %v, want %v", got, want)
258 }
259
260 mux.HandleFunc("/repos/o/r/commits/tag", func(w http.ResponseWriter, r *http.Request) {
261 testMethod(t, r, "GET")
262 testHeader(t, r, "Accept", mediaTypeV3SHA)
263 testHeader(t, r, "If-None-Match", `"`+sha1+`"`)
264
265 w.WriteHeader(http.StatusNotModified)
266 })
267
268 got, _, err = client.Repositories.GetCommitSHA1(ctx, "o", "r", "tag", sha1)
269 if err == nil {
270 t.Errorf("Expected HTTP 304 response")
271 }
272
273 want = ""
274 if got != want {
275 t.Errorf("Repositories.GetCommitSHA1 = %v, want %v", got, want)
276 }
277
278 const methodName = "GetCommitSHA1"
279 testBadOptions(t, methodName, func() (err error) {
280 _, _, err = client.Repositories.GetCommitSHA1(ctx, "\n", "\n", "\n", "\n")
281 return err
282 })
283
284 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
285 got, resp, err := client.Repositories.GetCommitSHA1(ctx, "o", "r", "master", "")
286 if got != "" {
287 t.Errorf("testNewRequestAndDoFailure %v = %#v, want ''", methodName, got)
288 }
289 return resp, err
290 })
291 }
292
293 func TestRepositoriesService_NonAlphabetCharacter_GetCommitSHA1(t *testing.T) {
294 client, mux, _, teardown := setup()
295 defer teardown()
296 const sha1 = "01234abcde"
297
298 mux.HandleFunc("/repos/o/r/commits/master%20hash", func(w http.ResponseWriter, r *http.Request) {
299 testMethod(t, r, "GET")
300 testHeader(t, r, "Accept", mediaTypeV3SHA)
301
302 fmt.Fprintf(w, sha1)
303 })
304
305 ctx := context.Background()
306 got, _, err := client.Repositories.GetCommitSHA1(ctx, "o", "r", "master%20hash", "")
307 if err != nil {
308 t.Errorf("Repositories.GetCommitSHA1 returned error: %v", err)
309 }
310
311 if want := sha1; got != want {
312 t.Errorf("Repositories.GetCommitSHA1 = %v, want %v", got, want)
313 }
314
315 mux.HandleFunc("/repos/o/r/commits/tag", func(w http.ResponseWriter, r *http.Request) {
316 testMethod(t, r, "GET")
317 testHeader(t, r, "Accept", mediaTypeV3SHA)
318 testHeader(t, r, "If-None-Match", `"`+sha1+`"`)
319
320 w.WriteHeader(http.StatusNotModified)
321 })
322
323 got, _, err = client.Repositories.GetCommitSHA1(ctx, "o", "r", "tag", sha1)
324 if err == nil {
325 t.Errorf("Expected HTTP 304 response")
326 }
327
328 if want := ""; got != want {
329 t.Errorf("Repositories.GetCommitSHA1 = %v, want %v", got, want)
330 }
331 }
332
333 func TestRepositoriesService_TrailingPercent_GetCommitSHA1(t *testing.T) {
334 client, mux, _, teardown := setup()
335 defer teardown()
336 const sha1 = "01234abcde"
337
338 mux.HandleFunc("/repos/o/r/commits/comm%", func(w http.ResponseWriter, r *http.Request) {
339 testMethod(t, r, "GET")
340 testHeader(t, r, "Accept", mediaTypeV3SHA)
341
342 fmt.Fprintf(w, sha1)
343 })
344
345 ctx := context.Background()
346 got, _, err := client.Repositories.GetCommitSHA1(ctx, "o", "r", "comm%", "")
347 if err != nil {
348 t.Errorf("Repositories.GetCommitSHA1 returned error: %v", err)
349 }
350
351 if want := sha1; got != want {
352 t.Errorf("Repositories.GetCommitSHA1 = %v, want %v", got, want)
353 }
354
355 mux.HandleFunc("/repos/o/r/commits/tag", func(w http.ResponseWriter, r *http.Request) {
356 testMethod(t, r, "GET")
357 testHeader(t, r, "Accept", mediaTypeV3SHA)
358 testHeader(t, r, "If-None-Match", `"`+sha1+`"`)
359
360 w.WriteHeader(http.StatusNotModified)
361 })
362
363 got, _, err = client.Repositories.GetCommitSHA1(ctx, "o", "r", "tag", sha1)
364 if err == nil {
365 t.Errorf("Expected HTTP 304 response")
366 }
367
368 if want := ""; got != want {
369 t.Errorf("Repositories.GetCommitSHA1 = %v, want %v", got, want)
370 }
371 }
372
373 func TestRepositoriesService_CompareCommits(t *testing.T) {
374 testCases := []struct {
375 base string
376 head string
377 }{
378 {base: "b", head: "h"},
379 {base: "123base", head: "head123"},
380 {base: "`~!@#$%^&*()_+-=[]\\{}|;':\",./<>?/*-+123base", head: "head123`~!@#$%^&*()_+-=[]\\{}|;':\",./<>?/*-+"},
381 }
382
383 for _, sample := range testCases {
384 client, mux, _, teardown := setup()
385
386 base := sample.base
387 head := sample.head
388 escapedBase := url.QueryEscape(base)
389 escapedHead := url.QueryEscape(head)
390
391 pattern := fmt.Sprintf("/repos/o/r/compare/%v...%v", base, head)
392
393 mux.HandleFunc(pattern, func(w http.ResponseWriter, r *http.Request) {
394 testMethod(t, r, "GET")
395 testFormValues(t, r, values{"per_page": "2", "page": "2"})
396 fmt.Fprintf(w, `{
397 "base_commit": {
398 "sha": "s",
399 "commit": {
400 "author": { "name": "n" },
401 "committer": { "name": "n" },
402 "message": "m",
403 "tree": { "sha": "t" }
404 },
405 "author": { "login": "l" },
406 "committer": { "login": "l" },
407 "parents": [ { "sha": "s" } ]
408 },
409 "status": "s",
410 "ahead_by": 1,
411 "behind_by": 2,
412 "total_commits": 1,
413 "commits": [
414 {
415 "sha": "s",
416 "commit": { "author": { "name": "n" } },
417 "author": { "login": "l" },
418 "committer": { "login": "l" },
419 "parents": [ { "sha": "s" } ]
420 }
421 ],
422 "files": [ { "filename": "f" } ],
423 "html_url": "https://github.com/o/r/compare/%[1]v...%[2]v",
424 "permalink_url": "https://github.com/o/r/compare/o:bbcd538c8e72b8c175046e27cc8f907076331401...o:0328041d1152db8ae77652d1618a02e57f745f17",
425 "diff_url": "https://github.com/o/r/compare/%[1]v...%[2]v.diff",
426 "patch_url": "https://github.com/o/r/compare/%[1]v...%[2]v.patch",
427 "url": "https://api.github.com/repos/o/r/compare/%[1]v...%[2]v"
428 }`, escapedBase, escapedHead)
429 })
430
431 opts := &ListOptions{Page: 2, PerPage: 2}
432 ctx := context.Background()
433 got, _, err := client.Repositories.CompareCommits(ctx, "o", "r", base, head, opts)
434 if err != nil {
435 t.Errorf("Repositories.CompareCommits returned error: %v", err)
436 }
437
438 want := &CommitsComparison{
439 BaseCommit: &RepositoryCommit{
440 SHA: String("s"),
441 Commit: &Commit{
442 Author: &CommitAuthor{Name: String("n")},
443 Committer: &CommitAuthor{Name: String("n")},
444 Message: String("m"),
445 Tree: &Tree{SHA: String("t")},
446 },
447 Author: &User{Login: String("l")},
448 Committer: &User{Login: String("l")},
449 Parents: []*Commit{
450 {
451 SHA: String("s"),
452 },
453 },
454 },
455 Status: String("s"),
456 AheadBy: Int(1),
457 BehindBy: Int(2),
458 TotalCommits: Int(1),
459 Commits: []*RepositoryCommit{
460 {
461 SHA: String("s"),
462 Commit: &Commit{
463 Author: &CommitAuthor{Name: String("n")},
464 },
465 Author: &User{Login: String("l")},
466 Committer: &User{Login: String("l")},
467 Parents: []*Commit{
468 {
469 SHA: String("s"),
470 },
471 },
472 },
473 },
474 Files: []*CommitFile{
475 {
476 Filename: String("f"),
477 },
478 },
479 HTMLURL: String(fmt.Sprintf("https://github.com/o/r/compare/%v...%v", escapedBase, escapedHead)),
480 PermalinkURL: String("https://github.com/o/r/compare/o:bbcd538c8e72b8c175046e27cc8f907076331401...o:0328041d1152db8ae77652d1618a02e57f745f17"),
481 DiffURL: String(fmt.Sprintf("https://github.com/o/r/compare/%v...%v.diff", escapedBase, escapedHead)),
482 PatchURL: String(fmt.Sprintf("https://github.com/o/r/compare/%v...%v.patch", escapedBase, escapedHead)),
483 URL: String(fmt.Sprintf("https://api.github.com/repos/o/r/compare/%v...%v", escapedBase, escapedHead)),
484 }
485
486 if !cmp.Equal(got, want) {
487 t.Errorf("Repositories.CompareCommits returned \n%+v, want \n%+v", got, want)
488 }
489
490 const methodName = "CompareCommits"
491 testBadOptions(t, methodName, func() (err error) {
492 _, _, err = client.Repositories.CompareCommits(ctx, "\n", "\n", "\n", "\n", opts)
493 return err
494 })
495
496 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
497 got, resp, err := client.Repositories.CompareCommits(ctx, "o", "r", base, head, opts)
498 if got != nil {
499 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
500 }
501 return resp, err
502 })
503
504 teardown()
505 }
506 }
507
508 func TestRepositoriesService_CompareCommitsRaw_diff(t *testing.T) {
509 testCases := []struct {
510 base string
511 head string
512 }{
513 {base: "b", head: "h"},
514 {base: "123base", head: "head123"},
515 {base: "`~!@#$%^&*()_+-=[]\\{}|;':\",./<>?/*-+123base", head: "head123`~!@#$%^&*()_+-=[]\\{}|;':\",./<>?/*-+"},
516 }
517
518 for _, sample := range testCases {
519 client, mux, _, teardown := setup()
520
521 base := sample.base
522 head := sample.head
523 pattern := fmt.Sprintf("/repos/o/r/compare/%v...%v", base, head)
524 const rawStr = "@@diff content"
525
526 mux.HandleFunc(pattern, func(w http.ResponseWriter, r *http.Request) {
527 testMethod(t, r, "GET")
528 testHeader(t, r, "Accept", mediaTypeV3Diff)
529 fmt.Fprint(w, rawStr)
530 })
531
532 ctx := context.Background()
533 got, _, err := client.Repositories.CompareCommitsRaw(ctx, "o", "r", base, head, RawOptions{Type: Diff})
534 if err != nil {
535 t.Fatalf("Repositories.GetCommitRaw returned error: %v", err)
536 }
537 want := rawStr
538 if got != want {
539 t.Errorf("Repositories.GetCommitRaw returned %s want %s", got, want)
540 }
541
542 const methodName = "CompareCommitsRaw"
543 testBadOptions(t, methodName, func() (err error) {
544 _, _, err = client.Repositories.CompareCommitsRaw(ctx, "\n", "\n", "\n", "\n", RawOptions{Type: Diff})
545 return err
546 })
547
548 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
549 got, resp, err := client.Repositories.CompareCommitsRaw(ctx, "o", "r", base, head, RawOptions{Type: Diff})
550 if got != "" {
551 t.Errorf("testNewRequestAndDoFailure %v = %#v, want ''", methodName, got)
552 }
553 return resp, err
554 })
555
556 teardown()
557 }
558 }
559
560 func TestRepositoriesService_CompareCommitsRaw_patch(t *testing.T) {
561 testCases := []struct {
562 base string
563 head string
564 }{
565 {base: "b", head: "h"},
566 {base: "123base", head: "head123"},
567 {base: "`~!@#$%^&*()_+-=[]\\{}|;':\",./<>?/*-+123base", head: "head123`~!@#$%^&*()_+-=[]\\{}|;':\",./<>?/*-+"},
568 }
569
570 for _, sample := range testCases {
571 client, mux, _, teardown := setup()
572
573 base := sample.base
574 head := sample.head
575 pattern := fmt.Sprintf("/repos/o/r/compare/%v...%v", base, head)
576 const rawStr = "@@patch content"
577
578 mux.HandleFunc(pattern, func(w http.ResponseWriter, r *http.Request) {
579 testMethod(t, r, "GET")
580 testHeader(t, r, "Accept", mediaTypeV3Patch)
581 fmt.Fprint(w, rawStr)
582 })
583
584 ctx := context.Background()
585 got, _, err := client.Repositories.CompareCommitsRaw(ctx, "o", "r", base, head, RawOptions{Type: Patch})
586 if err != nil {
587 t.Fatalf("Repositories.GetCommitRaw returned error: %v", err)
588 }
589 want := rawStr
590 if got != want {
591 t.Errorf("Repositories.GetCommitRaw returned %s want %s", got, want)
592 }
593
594 teardown()
595 }
596 }
597
598 func TestRepositoriesService_CompareCommitsRaw_invalid(t *testing.T) {
599 ctx := context.Background()
600
601 testCases := []struct {
602 base string
603 head string
604 }{
605 {base: "b", head: "h"},
606 {base: "123base", head: "head123"},
607 {base: "`~!@#$%^&*()_+-=[]\\{}|;':\",./<>?/*-+123base", head: "head123`~!@#$%^&*()_+-=[]\\{}|;':\",./<>?/*-+"},
608 }
609
610 for _, sample := range testCases {
611 client, _, _, teardown := setup()
612 _, _, err := client.Repositories.CompareCommitsRaw(ctx, "o", "r", sample.base, sample.head, RawOptions{100})
613 if err == nil {
614 t.Fatal("Repositories.GetCommitRaw should return error")
615 }
616 if !strings.Contains(err.Error(), "unsupported raw type") {
617 t.Error("Repositories.GetCommitRaw should return unsupported raw type error")
618 }
619 teardown()
620 }
621 }
622
623 func TestRepositoriesService_ListBranchesHeadCommit(t *testing.T) {
624 client, mux, _, teardown := setup()
625 defer teardown()
626
627 mux.HandleFunc("/repos/o/r/commits/s/branches-where-head", func(w http.ResponseWriter, r *http.Request) {
628 testMethod(t, r, "GET")
629 fmt.Fprintf(w, `[{"name": "b","commit":{"sha":"2e90302801c870f17b6152327d9b9a03c8eca0e2","url":"https://api.github.com/repos/google/go-github/commits/2e90302801c870f17b6152327d9b9a03c8eca0e2"},"protected":true}]`)
630 })
631
632 ctx := context.Background()
633 branches, _, err := client.Repositories.ListBranchesHeadCommit(ctx, "o", "r", "s")
634 if err != nil {
635 t.Errorf("Repositories.ListBranchesHeadCommit returned error: %v", err)
636 }
637
638 want := []*BranchCommit{
639 {
640 Name: String("b"),
641 Commit: &Commit{
642 SHA: String("2e90302801c870f17b6152327d9b9a03c8eca0e2"),
643 URL: String("https://api.github.com/repos/google/go-github/commits/2e90302801c870f17b6152327d9b9a03c8eca0e2"),
644 },
645 Protected: Bool(true),
646 },
647 }
648 if !cmp.Equal(branches, want) {
649 t.Errorf("Repositories.ListBranchesHeadCommit returned %+v, want %+v", branches, want)
650 }
651
652 const methodName = "ListBranchesHeadCommit"
653 testBadOptions(t, methodName, func() (err error) {
654 _, _, err = client.Repositories.ListBranchesHeadCommit(ctx, "\n", "\n", "\n")
655 return err
656 })
657
658 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
659 got, resp, err := client.Repositories.ListBranchesHeadCommit(ctx, "o", "r", "s")
660 if got != nil {
661 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
662 }
663 return resp, err
664 })
665 }
666
667 func TestBranchCommit_Marshal(t *testing.T) {
668 testJSONMarshal(t, &BranchCommit{}, "{}")
669
670 r := &BranchCommit{
671 Name: String("n"),
672 Commit: &Commit{
673 SHA: String("s"),
674 Author: &CommitAuthor{
675 Date: &referenceTime,
676 Name: String("n"),
677 Email: String("e"),
678 Login: String("u"),
679 },
680 Committer: &CommitAuthor{
681 Date: &referenceTime,
682 Name: String("n"),
683 Email: String("e"),
684 Login: String("u"),
685 },
686 Message: String("m"),
687 Tree: &Tree{
688 SHA: String("s"),
689 Entries: []*TreeEntry{{
690 SHA: String("s"),
691 Path: String("p"),
692 Mode: String("m"),
693 Type: String("t"),
694 Size: Int(1),
695 Content: String("c"),
696 URL: String("u"),
697 }},
698 Truncated: Bool(false),
699 },
700 Parents: nil,
701 Stats: &CommitStats{
702 Additions: Int(1),
703 Deletions: Int(1),
704 Total: Int(1),
705 },
706 HTMLURL: String("h"),
707 URL: String("u"),
708 Verification: &SignatureVerification{
709 Verified: Bool(false),
710 Reason: String("r"),
711 Signature: String("s"),
712 Payload: String("p"),
713 },
714 NodeID: String("n"),
715 CommentCount: Int(1),
716 SigningKey: &openpgp.Entity{},
717 },
718 Protected: Bool(false),
719 }
720
721 want := `{
722 "name": "n",
723 "commit": {
724 "sha": "s",
725 "author": {
726 "date": ` + referenceTimeStr + `,
727 "name": "n",
728 "email": "e",
729 "username": "u"
730 },
731 "committer": {
732 "date": ` + referenceTimeStr + `,
733 "name": "n",
734 "email": "e",
735 "username": "u"
736 },
737 "message": "m",
738 "tree": {
739 "sha": "s",
740 "tree": [
741 {
742 "sha": "s",
743 "path": "p",
744 "mode": "m",
745 "type": "t",
746 "size": 1,
747 "content": "c",
748 "url": "u"
749 }
750 ],
751 "truncated": false
752 },
753 "stats": {
754 "additions": 1,
755 "deletions": 1,
756 "total": 1
757 },
758 "html_url": "h",
759 "url": "u",
760 "verification": {
761 "verified": false,
762 "reason": "r",
763 "signature": "s",
764 "payload": "p"
765 },
766 "node_id": "n",
767 "comment_count": 1
768 },
769 "protected": false
770 }`
771
772 testJSONMarshal(t, r, want)
773 }
774
775 func TestCommitsComparison_Marshal(t *testing.T) {
776 testJSONMarshal(t, &CommitsComparison{}, "{}")
777
778 r := &CommitsComparison{
779 BaseCommit: &RepositoryCommit{NodeID: String("nid")},
780 MergeBaseCommit: &RepositoryCommit{NodeID: String("nid")},
781 Status: String("status"),
782 AheadBy: Int(1),
783 BehindBy: Int(1),
784 TotalCommits: Int(1),
785 Commits: []*RepositoryCommit{
786 {
787 NodeID: String("nid"),
788 },
789 },
790 Files: []*CommitFile{
791 {
792 SHA: String("sha"),
793 },
794 },
795 HTMLURL: String("hurl"),
796 PermalinkURL: String("purl"),
797 DiffURL: String("durl"),
798 PatchURL: String("purl"),
799 URL: String("url"),
800 }
801
802 want := `{
803 "base_commit": {
804 "node_id": "nid"
805 },
806 "merge_base_commit": {
807 "node_id": "nid"
808 },
809 "status": "status",
810 "ahead_by": 1,
811 "behind_by": 1,
812 "total_commits": 1,
813 "commits": [
814 {
815 "node_id": "nid"
816 }
817 ],
818 "files": [
819 {
820 "sha": "sha"
821 }
822 ],
823 "html_url": "hurl",
824 "permalink_url": "purl",
825 "diff_url": "durl",
826 "patch_url": "purl",
827 "url": "url"
828 }`
829
830 testJSONMarshal(t, r, want)
831 }
832
833 func TestCommitFile_Marshal(t *testing.T) {
834 testJSONMarshal(t, &CommitFile{}, "{}")
835
836 r := &CommitFile{
837 SHA: String("sha"),
838 Filename: String("fn"),
839 Additions: Int(1),
840 Deletions: Int(1),
841 Changes: Int(1),
842 Status: String("status"),
843 Patch: String("patch"),
844 BlobURL: String("burl"),
845 RawURL: String("rurl"),
846 ContentsURL: String("curl"),
847 PreviousFilename: String("pf"),
848 }
849
850 want := `{
851 "sha": "sha",
852 "filename": "fn",
853 "additions": 1,
854 "deletions": 1,
855 "changes": 1,
856 "status": "status",
857 "patch": "patch",
858 "blob_url": "burl",
859 "raw_url": "rurl",
860 "contents_url": "curl",
861 "previous_filename": "pf"
862 }`
863
864 testJSONMarshal(t, r, want)
865 }
866
867 func TestCommitStats_Marshal(t *testing.T) {
868 testJSONMarshal(t, &CommitStats{}, "{}")
869
870 r := &CommitStats{
871 Additions: Int(1),
872 Deletions: Int(1),
873 Total: Int(1),
874 }
875
876 want := `{
877 "additions": 1,
878 "deletions": 1,
879 "total": 1
880 }`
881
882 testJSONMarshal(t, r, want)
883 }
884
885 func TestRepositoryCommit_Marshal(t *testing.T) {
886 testJSONMarshal(t, &RepositoryCommit{}, "{}")
887
888 r := &RepositoryCommit{
889 NodeID: String("nid"),
890 SHA: String("sha"),
891 Commit: &Commit{
892 Message: String("m"),
893 },
894 Author: &User{
895 Login: String("l"),
896 },
897 Committer: &User{
898 Login: String("l"),
899 },
900 Parents: []*Commit{
901 {
902 SHA: String("s"),
903 },
904 },
905 HTMLURL: String("hurl"),
906 URL: String("url"),
907 CommentsURL: String("curl"),
908 Stats: &CommitStats{
909 Additions: Int(104),
910 Deletions: Int(4),
911 Total: Int(108),
912 },
913 Files: []*CommitFile{
914 {
915 Filename: String("f"),
916 Additions: Int(10),
917 Deletions: Int(2),
918 Changes: Int(12),
919 Status: String("s"),
920 Patch: String("p"),
921 BlobURL: String("b"),
922 RawURL: String("r"),
923 ContentsURL: String("c"),
924 },
925 },
926 }
927
928 want := `{
929 "node_id": "nid",
930 "sha": "sha",
931 "commit": {
932 "message": "m"
933 },
934 "author": {
935 "login": "l"
936 },
937 "committer": {
938 "login": "l"
939 },
940 "parents": [
941 {
942 "sha": "s"
943 }
944 ],
945 "html_url": "hurl",
946 "url": "url",
947 "comments_url": "curl",
948 "stats": {
949 "additions": 104,
950 "deletions": 4,
951 "total": 108
952 },
953 "files": [
954 {
955 "filename": "f",
956 "additions": 10,
957 "deletions": 2,
958 "changes": 12,
959 "status": "s",
960 "patch": "p",
961 "blob_url": "b",
962 "raw_url": "r",
963 "contents_url": "c"
964 }
965 ]
966 }`
967
968 testJSONMarshal(t, r, want)
969 }
970
View as plain text