1
2
3
4
5
6 package github
7
8 import (
9 "context"
10 "fmt"
11 "net/http"
12 "testing"
13
14 "github.com/google/go-cmp/cmp"
15 )
16
17 func TestUsersService_Authenticated_ListPackages(t *testing.T) {
18 client, mux, _, teardown := setup()
19 defer teardown()
20
21 mux.HandleFunc("/user/packages", func(w http.ResponseWriter, r *http.Request) {
22 testMethod(t, r, "GET")
23 testFormValues(t, r, values{"package_type": "container", "visibility": "private"})
24 fmt.Fprint(w, `[{
25 "id": 197,
26 "name": "hello_docker",
27 "package_type": "container",
28 "version_count": 1,
29 "visibility": "private",
30 "url": "https://api.github.com/orgs/github/packages/container/hello_docker",
31 "created_at": `+referenceTimeStr+`,
32 "updated_at": `+referenceTimeStr+`,
33 "html_url": "https://github.com/orgs/github/packages/container/package/hello_docker"
34 }]`)
35 })
36
37 ctx := context.Background()
38 packages, _, err := client.Users.ListPackages(ctx, "", &PackageListOptions{PackageType: String("container"), Visibility: String("private")})
39 if err != nil {
40 t.Errorf("Users.Authenticated_ListPackages returned error: %v", err)
41 }
42
43 want := []*Package{{
44 ID: Int64(197),
45 Name: String("hello_docker"),
46 PackageType: String("container"),
47 VersionCount: Int64(1),
48 Visibility: String("private"),
49 URL: String("https://api.github.com/orgs/github/packages/container/hello_docker"),
50 HTMLURL: String("https://github.com/orgs/github/packages/container/package/hello_docker"),
51 CreatedAt: &Timestamp{referenceTime},
52 UpdatedAt: &Timestamp{referenceTime},
53 }}
54 if !cmp.Equal(packages, want) {
55 t.Errorf("Users.Authenticated_ListPackages returned %+v, want %+v", packages, want)
56 }
57
58 const methodName = "ListPackages"
59 testBadOptions(t, methodName, func() (err error) {
60 _, _, err = client.Users.ListPackages(ctx, "\n", &PackageListOptions{})
61 return err
62 })
63
64 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
65 got, resp, err := client.Users.ListPackages(ctx, "", &PackageListOptions{})
66 if got != nil {
67 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
68 }
69 return resp, err
70 })
71 }
72
73 func TestUsersService_specifiedUser_ListPackages(t *testing.T) {
74 client, mux, _, teardown := setup()
75 defer teardown()
76
77 mux.HandleFunc("/users/u/packages", func(w http.ResponseWriter, r *http.Request) {
78 testMethod(t, r, "GET")
79 testFormValues(t, r, values{"package_type": "container", "visibility": "public"})
80 fmt.Fprint(w, `[{
81 "id": 197,
82 "name": "hello_docker",
83 "package_type": "container",
84 "version_count": 1,
85 "visibility": "public",
86 "url": "https://api.github.com/orgs/github/packages/container/hello_docker",
87 "created_at": `+referenceTimeStr+`,
88 "updated_at": `+referenceTimeStr+`,
89 "html_url": "https://github.com/orgs/github/packages/container/package/hello_docker"
90 }]`)
91 })
92
93 ctx := context.Background()
94 packages, _, err := client.Users.ListPackages(ctx, "u", &PackageListOptions{PackageType: String("container"), Visibility: String("public")})
95 if err != nil {
96 t.Errorf("Users.specifiedUser_ListPackages returned error: %v", err)
97 }
98
99 want := []*Package{{
100 ID: Int64(197),
101 Name: String("hello_docker"),
102 PackageType: String("container"),
103 VersionCount: Int64(1),
104 Visibility: String("public"),
105 URL: String("https://api.github.com/orgs/github/packages/container/hello_docker"),
106 HTMLURL: String("https://github.com/orgs/github/packages/container/package/hello_docker"),
107 CreatedAt: &Timestamp{referenceTime},
108 UpdatedAt: &Timestamp{referenceTime},
109 }}
110 if !cmp.Equal(packages, want) {
111 t.Errorf("Users.specifiedUser_ListPackages returned %+v, want %+v", packages, want)
112 }
113
114 const methodName = "ListPackages"
115 testBadOptions(t, methodName, func() (err error) {
116 _, _, err = client.Users.ListPackages(ctx, "\n", &PackageListOptions{})
117 return err
118 })
119
120 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
121 got, resp, err := client.Users.ListPackages(ctx, "", &PackageListOptions{})
122 if got != nil {
123 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
124 }
125 return resp, err
126 })
127 }
128
129 func TestUsersService_specifiedUser_GetPackage(t *testing.T) {
130 client, mux, _, teardown := setup()
131 defer teardown()
132
133 mux.HandleFunc("/users/u/packages/container/hello_docker", func(w http.ResponseWriter, r *http.Request) {
134 testMethod(t, r, "GET")
135 fmt.Fprint(w, `{
136 "id": 197,
137 "name": "hello_docker",
138 "package_type": "container",
139 "version_count": 1,
140 "visibility": "private",
141 "url": "https://api.github.com/orgs/github/packages/container/hello_docker",
142 "created_at": `+referenceTimeStr+`,
143 "updated_at": `+referenceTimeStr+`,
144 "html_url": "https://github.com/orgs/github/packages/container/package/hello_docker"
145 }`)
146 })
147
148 ctx := context.Background()
149 packages, _, err := client.Users.GetPackage(ctx, "u", "container", "hello_docker")
150 if err != nil {
151 t.Errorf("Users.GetPackage returned error: %v", err)
152 }
153
154 want := &Package{
155 ID: Int64(197),
156 Name: String("hello_docker"),
157 PackageType: String("container"),
158 VersionCount: Int64(1),
159 Visibility: String("private"),
160 URL: String("https://api.github.com/orgs/github/packages/container/hello_docker"),
161 HTMLURL: String("https://github.com/orgs/github/packages/container/package/hello_docker"),
162 CreatedAt: &Timestamp{referenceTime},
163 UpdatedAt: &Timestamp{referenceTime},
164 }
165 if !cmp.Equal(packages, want) {
166 t.Errorf("Users.specifiedUser_GetPackage returned %+v, want %+v", packages, want)
167 }
168
169 const methodName = "GetPackage"
170 testBadOptions(t, methodName, func() (err error) {
171 _, _, err = client.Users.GetPackage(ctx, "\n", "\n", "\n")
172 return err
173 })
174
175 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
176 got, resp, err := client.Users.GetPackage(ctx, "", "", "")
177 if got != nil {
178 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
179 }
180 return resp, err
181 })
182 }
183
184 func TestUsersService_Authenticated_GetPackage(t *testing.T) {
185 client, mux, _, teardown := setup()
186 defer teardown()
187
188 mux.HandleFunc("/user/packages/container/hello_docker", func(w http.ResponseWriter, r *http.Request) {
189 testMethod(t, r, "GET")
190 fmt.Fprint(w, `{
191 "id": 197,
192 "name": "hello_docker",
193 "package_type": "container",
194 "version_count": 1,
195 "visibility": "private",
196 "url": "https://api.github.com/orgs/github/packages/container/hello_docker",
197 "created_at": `+referenceTimeStr+`,
198 "updated_at": `+referenceTimeStr+`,
199 "html_url": "https://github.com/orgs/github/packages/container/package/hello_docker"
200 }`)
201 })
202
203 ctx := context.Background()
204 packages, _, err := client.Users.GetPackage(ctx, "", "container", "hello_docker")
205 if err != nil {
206 t.Errorf("Users.Authenticated_GetPackage returned error: %v", err)
207 }
208
209 want := &Package{
210 ID: Int64(197),
211 Name: String("hello_docker"),
212 PackageType: String("container"),
213 VersionCount: Int64(1),
214 Visibility: String("private"),
215 URL: String("https://api.github.com/orgs/github/packages/container/hello_docker"),
216 HTMLURL: String("https://github.com/orgs/github/packages/container/package/hello_docker"),
217 CreatedAt: &Timestamp{referenceTime},
218 UpdatedAt: &Timestamp{referenceTime},
219 }
220 if !cmp.Equal(packages, want) {
221 t.Errorf("Users.Authenticated_GetPackage returned %+v, want %+v", packages, want)
222 }
223
224 const methodName = "GetPackage"
225 testBadOptions(t, methodName, func() (err error) {
226 _, _, err = client.Users.GetPackage(ctx, "\n", "\n", "\n")
227 return err
228 })
229
230 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
231 got, resp, err := client.Users.GetPackage(ctx, "", "", "")
232 if got != nil {
233 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
234 }
235 return resp, err
236 })
237 }
238
239 func TestUsersService_Authenticated_DeletePackage(t *testing.T) {
240 client, mux, _, teardown := setup()
241 defer teardown()
242
243 mux.HandleFunc("/user/packages/container/hello_docker", func(w http.ResponseWriter, r *http.Request) {
244 testMethod(t, r, "DELETE")
245 })
246
247 ctx := context.Background()
248 _, err := client.Users.DeletePackage(ctx, "", "container", "hello_docker")
249 if err != nil {
250 t.Errorf("Users.Authenticated_DeletePackage returned error: %v", err)
251 }
252
253 const methodName = "DeletePackage"
254 testBadOptions(t, methodName, func() (err error) {
255 _, err = client.Users.DeletePackage(ctx, "\n", "\n", "\n")
256 return err
257 })
258
259 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
260 return client.Users.DeletePackage(ctx, "", "", "")
261 })
262 }
263
264 func TestUsersService_specifiedUser_DeletePackage(t *testing.T) {
265 client, mux, _, teardown := setup()
266 defer teardown()
267
268 mux.HandleFunc("/users/u/packages/container/hello_docker", func(w http.ResponseWriter, r *http.Request) {
269 testMethod(t, r, "DELETE")
270 })
271
272 ctx := context.Background()
273 _, err := client.Users.DeletePackage(ctx, "u", "container", "hello_docker")
274 if err != nil {
275 t.Errorf("Users.specifiedUser_DeletePackage returned error: %v", err)
276 }
277
278 const methodName = "DeletePackage"
279 testBadOptions(t, methodName, func() (err error) {
280 _, err = client.Users.DeletePackage(ctx, "\n", "\n", "\n")
281 return err
282 })
283
284 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
285 return client.Users.DeletePackage(ctx, "", "", "")
286 })
287 }
288
289 func TestUsersService_Authenticated_RestorePackage(t *testing.T) {
290 client, mux, _, teardown := setup()
291 defer teardown()
292
293 mux.HandleFunc("/user/packages/container/hello_docker/restore", func(w http.ResponseWriter, r *http.Request) {
294 testMethod(t, r, "POST")
295 })
296
297 ctx := context.Background()
298 _, err := client.Users.RestorePackage(ctx, "", "container", "hello_docker")
299 if err != nil {
300 t.Errorf("Users.Authenticated_RestorePackage returned error: %v", err)
301 }
302
303 const methodName = "RestorePackage"
304 testBadOptions(t, methodName, func() (err error) {
305 _, err = client.Users.RestorePackage(ctx, "\n", "", "")
306 return err
307 })
308
309 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
310 return client.Users.RestorePackage(ctx, "", "container", "hello_docker")
311 })
312 }
313
314 func TestUsersService_specifiedUser_RestorePackage(t *testing.T) {
315 client, mux, _, teardown := setup()
316 defer teardown()
317
318 mux.HandleFunc("/users/u/packages/container/hello_docker/restore", func(w http.ResponseWriter, r *http.Request) {
319 testMethod(t, r, "POST")
320 })
321
322 ctx := context.Background()
323 _, err := client.Users.RestorePackage(ctx, "u", "container", "hello_docker")
324 if err != nil {
325 t.Errorf("Users.specifiedUser_RestorePackage returned error: %v", err)
326 }
327
328 const methodName = "RestorePackage"
329 testBadOptions(t, methodName, func() (err error) {
330 _, err = client.Users.RestorePackage(ctx, "\n", "", "")
331 return err
332 })
333
334 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
335 return client.Users.RestorePackage(ctx, "", "container", "hello_docker")
336 })
337 }
338
339 func TestUsersService_Authenticated_ListPackagesVersions(t *testing.T) {
340 client, mux, _, teardown := setup()
341 defer teardown()
342
343 mux.HandleFunc("/user/packages/container/hello_docker/versions", func(w http.ResponseWriter, r *http.Request) {
344 testMethod(t, r, "GET")
345 fmt.Fprint(w, `[
346 {
347 "id": 45763,
348 "name": "sha256:08a44bab0bddaddd8837a8b381aebc2e4b933768b981685a9e088360af0d3dd9",
349 "url": "https://api.github.com/users/octocat/packages/container/hello_docker/versions/45763",
350 "package_html_url": "https://github.com/users/octocat/packages/container/package/hello_docker",
351 "created_at": `+referenceTimeStr+`,
352 "updated_at": `+referenceTimeStr+`,
353 "html_url": "https://github.com/users/octocat/packages/container/hello_docker/45763",
354 "metadata": {
355 "package_type": "container",
356 "container": {
357 "tags": [
358 "latest"
359 ]
360 }
361 }
362 }]`)
363 })
364
365 ctx := context.Background()
366 opts := &PackageListOptions{
367 String("internal"), String("container"), String("deleted"), ListOptions{Page: 1, PerPage: 2},
368 }
369 packages, _, err := client.Users.PackageGetAllVersions(ctx, "", "container", "hello_docker", opts)
370 if err != nil {
371 t.Errorf("Users.Authenticated_PackageGetAllVersions returned error: %v", err)
372 }
373
374 want := []*PackageVersion{{
375 ID: Int64(45763),
376 Name: String("sha256:08a44bab0bddaddd8837a8b381aebc2e4b933768b981685a9e088360af0d3dd9"),
377 URL: String("https://api.github.com/users/octocat/packages/container/hello_docker/versions/45763"),
378 PackageHTMLURL: String("https://github.com/users/octocat/packages/container/package/hello_docker"),
379 CreatedAt: &Timestamp{referenceTime},
380 UpdatedAt: &Timestamp{referenceTime},
381 HTMLURL: String("https://github.com/users/octocat/packages/container/hello_docker/45763"),
382 Metadata: &PackageMetadata{
383 PackageType: String("container"),
384 Container: &PackageContainerMetadata{
385 Tags: []string{"latest"},
386 },
387 },
388 }}
389 if !cmp.Equal(packages, want) {
390 t.Errorf("Users.PackageGetAllVersions returned %+v, want %+v", packages, want)
391 }
392
393 const methodName = "PackageGetAllVersions"
394 testBadOptions(t, methodName, func() (err error) {
395 _, _, err = client.Users.PackageGetAllVersions(ctx, "\n", "", "", &PackageListOptions{})
396 return err
397 })
398
399 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
400 got, resp, err := client.Users.PackageGetAllVersions(ctx, "", "", "", &PackageListOptions{})
401 if got != nil {
402 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
403 }
404 return resp, err
405 })
406 }
407
408 func TestUsersService_specifiedUser_ListPackagesVersions(t *testing.T) {
409 client, mux, _, teardown := setup()
410 defer teardown()
411
412 mux.HandleFunc("/users/u/packages/container/hello_docker/versions", func(w http.ResponseWriter, r *http.Request) {
413 testMethod(t, r, "GET")
414 fmt.Fprint(w, `[
415 {
416 "id": 45763,
417 "name": "sha256:08a44bab0bddaddd8837a8b381aebc2e4b933768b981685a9e088360af0d3dd9",
418 "url": "https://api.github.com/users/octocat/packages/container/hello_docker/versions/45763",
419 "package_html_url": "https://github.com/users/octocat/packages/container/package/hello_docker",
420 "created_at": `+referenceTimeStr+`,
421 "updated_at": `+referenceTimeStr+`,
422 "html_url": "https://github.com/users/octocat/packages/container/hello_docker/45763",
423 "metadata": {
424 "package_type": "container",
425 "container": {
426 "tags": [
427 "latest"
428 ]
429 }
430 }
431 }]`)
432 })
433
434 ctx := context.Background()
435 opts := &PackageListOptions{
436 String("internal"), String("container"), String("deleted"), ListOptions{Page: 1, PerPage: 2},
437 }
438 packages, _, err := client.Users.PackageGetAllVersions(ctx, "u", "container", "hello_docker", opts)
439 if err != nil {
440 t.Errorf("Users.specifiedUser_PackageGetAllVersions returned error: %v", err)
441 }
442
443 want := []*PackageVersion{{
444 ID: Int64(45763),
445 Name: String("sha256:08a44bab0bddaddd8837a8b381aebc2e4b933768b981685a9e088360af0d3dd9"),
446 URL: String("https://api.github.com/users/octocat/packages/container/hello_docker/versions/45763"),
447 PackageHTMLURL: String("https://github.com/users/octocat/packages/container/package/hello_docker"),
448 CreatedAt: &Timestamp{referenceTime},
449 UpdatedAt: &Timestamp{referenceTime},
450 HTMLURL: String("https://github.com/users/octocat/packages/container/hello_docker/45763"),
451 Metadata: &PackageMetadata{
452 PackageType: String("container"),
453 Container: &PackageContainerMetadata{
454 Tags: []string{"latest"},
455 },
456 },
457 }}
458 if !cmp.Equal(packages, want) {
459 t.Errorf("Users.specifiedUser_PackageGetAllVersions returned %+v, want %+v", packages, want)
460 }
461
462 const methodName = "PackageGetAllVersions"
463 testBadOptions(t, methodName, func() (err error) {
464 _, _, err = client.Users.PackageGetAllVersions(ctx, "\n", "", "", &PackageListOptions{})
465 return err
466 })
467
468 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
469 got, resp, err := client.Users.PackageGetAllVersions(ctx, "", "", "", &PackageListOptions{})
470 if got != nil {
471 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
472 }
473 return resp, err
474 })
475 }
476
477 func TestUsersService_Authenticated_PackageGetVersion(t *testing.T) {
478 client, mux, _, teardown := setup()
479 defer teardown()
480
481 mux.HandleFunc("/user/packages/container/hello_docker/versions/45763", func(w http.ResponseWriter, r *http.Request) {
482 testMethod(t, r, "GET")
483 fmt.Fprint(w, `
484 {
485 "id": 45763,
486 "name": "sha256:08a44bab0bddaddd8837a8b381aebc2e4b933768b981685a9e088360af0d3dd9",
487 "url": "https://api.github.com/users/octocat/packages/container/hello_docker/versions/45763",
488 "package_html_url": "https://github.com/users/octocat/packages/container/package/hello_docker",
489 "created_at": `+referenceTimeStr+`,
490 "updated_at": `+referenceTimeStr+`,
491 "html_url": "https://github.com/users/octocat/packages/container/hello_docker/45763",
492 "metadata": {
493 "package_type": "container",
494 "container": {
495 "tags": [
496 "latest"
497 ]
498 }
499 }
500 }`)
501 })
502
503 ctx := context.Background()
504 packages, _, err := client.Users.PackageGetVersion(ctx, "", "container", "hello_docker", 45763)
505 if err != nil {
506 t.Errorf("Users.PackageGetVersion returned error: %v", err)
507 }
508
509 want := &PackageVersion{
510 ID: Int64(45763),
511 Name: String("sha256:08a44bab0bddaddd8837a8b381aebc2e4b933768b981685a9e088360af0d3dd9"),
512 URL: String("https://api.github.com/users/octocat/packages/container/hello_docker/versions/45763"),
513 PackageHTMLURL: String("https://github.com/users/octocat/packages/container/package/hello_docker"),
514 CreatedAt: &Timestamp{referenceTime},
515 UpdatedAt: &Timestamp{referenceTime},
516 HTMLURL: String("https://github.com/users/octocat/packages/container/hello_docker/45763"),
517 Metadata: &PackageMetadata{
518 PackageType: String("container"),
519 Container: &PackageContainerMetadata{
520 Tags: []string{"latest"},
521 },
522 },
523 }
524 if !cmp.Equal(packages, want) {
525 t.Errorf("Users.Authenticated_PackageGetVersion returned %+v, want %+v", packages, want)
526 }
527
528 const methodName = "PackageGetVersion"
529 testBadOptions(t, methodName, func() (err error) {
530 _, _, err = client.Users.PackageGetVersion(ctx, "\n", "", "", 0)
531 return err
532 })
533
534 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
535 got, resp, err := client.Users.PackageGetVersion(ctx, "", "", "", 45763)
536 if got != nil {
537 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
538 }
539 return resp, err
540 })
541 }
542
543 func TestUsersService_specifiedUser_PackageGetVersion(t *testing.T) {
544 client, mux, _, teardown := setup()
545 defer teardown()
546
547 mux.HandleFunc("/users/u/packages/container/hello_docker/versions/45763", func(w http.ResponseWriter, r *http.Request) {
548 testMethod(t, r, "GET")
549 fmt.Fprint(w, `
550 {
551 "id": 45763,
552 "name": "sha256:08a44bab0bddaddd8837a8b381aebc2e4b933768b981685a9e088360af0d3dd9",
553 "url": "https://api.github.com/users/octocat/packages/container/hello_docker/versions/45763",
554 "package_html_url": "https://github.com/users/octocat/packages/container/package/hello_docker",
555 "created_at": `+referenceTimeStr+`,
556 "updated_at": `+referenceTimeStr+`,
557 "html_url": "https://github.com/users/octocat/packages/container/hello_docker/45763",
558 "metadata": {
559 "package_type": "container",
560 "container": {
561 "tags": [
562 "latest"
563 ]
564 }
565 }
566 }`)
567 })
568
569 ctx := context.Background()
570 packages, _, err := client.Users.PackageGetVersion(ctx, "u", "container", "hello_docker", 45763)
571 if err != nil {
572 t.Errorf("Users.specifiedUser_PackageGetVersion returned error: %v", err)
573 }
574
575 want := &PackageVersion{
576 ID: Int64(45763),
577 Name: String("sha256:08a44bab0bddaddd8837a8b381aebc2e4b933768b981685a9e088360af0d3dd9"),
578 URL: String("https://api.github.com/users/octocat/packages/container/hello_docker/versions/45763"),
579 PackageHTMLURL: String("https://github.com/users/octocat/packages/container/package/hello_docker"),
580 CreatedAt: &Timestamp{referenceTime},
581 UpdatedAt: &Timestamp{referenceTime},
582 HTMLURL: String("https://github.com/users/octocat/packages/container/hello_docker/45763"),
583 Metadata: &PackageMetadata{
584 PackageType: String("container"),
585 Container: &PackageContainerMetadata{
586 Tags: []string{"latest"},
587 },
588 },
589 }
590 if !cmp.Equal(packages, want) {
591 t.Errorf("Users.specifiedUser_PackageGetVersion returned %+v, want %+v", packages, want)
592 }
593
594 const methodName = "PackageGetVersion"
595 testBadOptions(t, methodName, func() (err error) {
596 _, _, err = client.Users.PackageGetVersion(ctx, "\n", "", "", 0)
597 return err
598 })
599
600 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
601 got, resp, err := client.Users.PackageGetVersion(ctx, "", "", "", 45763)
602 if got != nil {
603 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
604 }
605 return resp, err
606 })
607 }
608
609 func TestUsersService_Authenticated_PackageDeleteVersion(t *testing.T) {
610 client, mux, _, teardown := setup()
611 defer teardown()
612
613 mux.HandleFunc("/user/packages/container/hello_docker/versions/45763", func(w http.ResponseWriter, r *http.Request) {
614 testMethod(t, r, "DELETE")
615 })
616
617 ctx := context.Background()
618 _, err := client.Users.PackageDeleteVersion(ctx, "", "container", "hello_docker", 45763)
619 if err != nil {
620 t.Errorf("Users.Authenticated_PackageDeleteVersion returned error: %v", err)
621 }
622
623 const methodName = "PackageDeleteVersion"
624 testBadOptions(t, methodName, func() (err error) {
625 _, err = client.Users.PackageDeleteVersion(ctx, "\n", "", "", 0)
626 return err
627 })
628
629 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
630 return client.Users.PackageDeleteVersion(ctx, "", "", "", 45763)
631 })
632 }
633
634 func TestUsersService_specifiedUser_PackageDeleteVersion(t *testing.T) {
635 client, mux, _, teardown := setup()
636 defer teardown()
637
638 mux.HandleFunc("/users/u/packages/container/hello_docker/versions/45763", func(w http.ResponseWriter, r *http.Request) {
639 testMethod(t, r, "DELETE")
640 })
641
642 ctx := context.Background()
643 _, err := client.Users.PackageDeleteVersion(ctx, "u", "container", "hello_docker", 45763)
644 if err != nil {
645 t.Errorf("Users.specifiedUser_PackageDeleteVersion returned error: %v", err)
646 }
647
648 const methodName = "PackageDeleteVersion"
649 testBadOptions(t, methodName, func() (err error) {
650 _, err = client.Users.PackageDeleteVersion(ctx, "\n", "", "", 0)
651 return err
652 })
653
654 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
655 return client.Users.PackageDeleteVersion(ctx, "", "", "", 45763)
656 })
657 }
658
659 func TestUsersService_Authenticated_PackageRestoreVersion(t *testing.T) {
660 client, mux, _, teardown := setup()
661 defer teardown()
662
663 mux.HandleFunc("/user/packages/container/hello_docker/versions/45763/restore", func(w http.ResponseWriter, r *http.Request) {
664 testMethod(t, r, "POST")
665 })
666
667 ctx := context.Background()
668 _, err := client.Users.PackageRestoreVersion(ctx, "", "container", "hello_docker", 45763)
669 if err != nil {
670 t.Errorf("Users.Authenticated_PackageRestoreVersion returned error: %v", err)
671 }
672
673 const methodName = "PackageRestoreVersion"
674 testBadOptions(t, methodName, func() (err error) {
675 _, err = client.Users.PackageRestoreVersion(ctx, "\n", "", "", 0)
676 return err
677 })
678
679 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
680 return client.Users.PackageRestoreVersion(ctx, "", "", "", 45763)
681 })
682 }
683
684 func TestUsersService_specifiedUser_PackageRestoreVersion(t *testing.T) {
685 client, mux, _, teardown := setup()
686 defer teardown()
687
688 mux.HandleFunc("/users/u/packages/container/hello_docker/versions/45763/restore", func(w http.ResponseWriter, r *http.Request) {
689 testMethod(t, r, "POST")
690 })
691
692 ctx := context.Background()
693 _, err := client.Users.PackageRestoreVersion(ctx, "u", "container", "hello_docker", 45763)
694 if err != nil {
695 t.Errorf("Users.specifiedUser_PackageRestoreVersion returned error: %v", err)
696 }
697
698 const methodName = "PackageRestoreVersion"
699 testBadOptions(t, methodName, func() (err error) {
700 _, err = client.Users.PackageRestoreVersion(ctx, "\n", "", "", 0)
701 return err
702 })
703
704 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
705 return client.Users.PackageRestoreVersion(ctx, "", "", "", 45763)
706 })
707 }
708
View as plain text