1
2
3
4
5
6 package github
7
8 import (
9 "context"
10 "encoding/json"
11 "fmt"
12 "net/http"
13 "testing"
14 "time"
15
16 "github.com/google/go-cmp/cmp"
17 )
18
19 func TestPublicKey_UnmarshalJSON(t *testing.T) {
20 var testCases = map[string]struct {
21 data []byte
22 wantPublicKey PublicKey
23 wantErr bool
24 }{
25 "Empty": {
26 data: []byte("{}"),
27 wantPublicKey: PublicKey{},
28 wantErr: false,
29 },
30 "Invalid JSON": {
31 data: []byte("{"),
32 wantPublicKey: PublicKey{},
33 wantErr: true,
34 },
35 "Numeric KeyID": {
36 data: []byte(`{"key_id":1234,"key":"2Sg8iYjAxxmI2LvUXpJjkYrMxURPc8r+dB7TJyvv1234"}`),
37 wantPublicKey: PublicKey{KeyID: String("1234"), Key: String("2Sg8iYjAxxmI2LvUXpJjkYrMxURPc8r+dB7TJyvv1234")},
38 wantErr: false,
39 },
40 "String KeyID": {
41 data: []byte(`{"key_id":"1234","key":"2Sg8iYjAxxmI2LvUXpJjkYrMxURPc8r+dB7TJyvv1234"}`),
42 wantPublicKey: PublicKey{KeyID: String("1234"), Key: String("2Sg8iYjAxxmI2LvUXpJjkYrMxURPc8r+dB7TJyvv1234")},
43 wantErr: false,
44 },
45 "Invalid KeyID": {
46 data: []byte(`{"key_id":["1234"],"key":"2Sg8iYjAxxmI2LvUXpJjkYrMxURPc8r+dB7TJyvv1234"}`),
47 wantPublicKey: PublicKey{KeyID: nil, Key: String("2Sg8iYjAxxmI2LvUXpJjkYrMxURPc8r+dB7TJyvv1234")},
48 wantErr: true,
49 },
50 "Invalid Key": {
51 data: []byte(`{"key":123}`),
52 wantPublicKey: PublicKey{KeyID: nil, Key: nil},
53 wantErr: true,
54 },
55 "Nil": {
56 data: nil,
57 wantPublicKey: PublicKey{KeyID: nil, Key: nil},
58 wantErr: true,
59 },
60 "Empty String": {
61 data: []byte(""),
62 wantPublicKey: PublicKey{KeyID: nil, Key: nil},
63 wantErr: true,
64 },
65 "Missing Key": {
66 data: []byte(`{"key_id":"1234"}`),
67 wantPublicKey: PublicKey{KeyID: String("1234")},
68 wantErr: false,
69 },
70 "Missing KeyID": {
71 data: []byte(`{"key":"2Sg8iYjAxxmI2LvUXpJjkYrMxURPc8r+dB7TJyvv1234"}`),
72 wantPublicKey: PublicKey{Key: String("2Sg8iYjAxxmI2LvUXpJjkYrMxURPc8r+dB7TJyvv1234")},
73 wantErr: false,
74 },
75 }
76
77 for name, tt := range testCases {
78 tt := tt
79 t.Run(name, func(t *testing.T) {
80 pk := PublicKey{}
81 err := json.Unmarshal(tt.data, &pk)
82 if err == nil && tt.wantErr {
83 t.Errorf("PublicKey.UnmarshalJSON returned nil instead of an error")
84 }
85 if err != nil && !tt.wantErr {
86 t.Errorf("PublicKey.UnmarshalJSON returned an unexpected error: %+v", err)
87 }
88 if !cmp.Equal(tt.wantPublicKey, pk) {
89 t.Errorf("PublicKey.UnmarshalJSON expected public key %+v, got %+v", tt.wantPublicKey, pk)
90 }
91 })
92 }
93 }
94
95 func TestActionsService_GetRepoPublicKey(t *testing.T) {
96 client, mux, _, teardown := setup()
97 defer teardown()
98
99 mux.HandleFunc("/repos/o/r/actions/secrets/public-key", func(w http.ResponseWriter, r *http.Request) {
100 testMethod(t, r, "GET")
101 fmt.Fprint(w, `{"key_id":"1234","key":"2Sg8iYjAxxmI2LvUXpJjkYrMxURPc8r+dB7TJyvv1234"}`)
102 })
103
104 ctx := context.Background()
105 key, _, err := client.Actions.GetRepoPublicKey(ctx, "o", "r")
106 if err != nil {
107 t.Errorf("Actions.GetRepoPublicKey returned error: %v", err)
108 }
109
110 want := &PublicKey{KeyID: String("1234"), Key: String("2Sg8iYjAxxmI2LvUXpJjkYrMxURPc8r+dB7TJyvv1234")}
111 if !cmp.Equal(key, want) {
112 t.Errorf("Actions.GetRepoPublicKey returned %+v, want %+v", key, want)
113 }
114
115 const methodName = "GetRepoPublicKey"
116 testBadOptions(t, methodName, func() (err error) {
117 _, _, err = client.Actions.GetRepoPublicKey(ctx, "\n", "\n")
118 return err
119 })
120
121 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
122 got, resp, err := client.Actions.GetRepoPublicKey(ctx, "o", "r")
123 if got != nil {
124 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
125 }
126 return resp, err
127 })
128 }
129
130 func TestActionsService_GetRepoPublicKeyNumeric(t *testing.T) {
131 client, mux, _, teardown := setup()
132 defer teardown()
133
134 mux.HandleFunc("/repos/o/r/actions/secrets/public-key", func(w http.ResponseWriter, r *http.Request) {
135 testMethod(t, r, "GET")
136 fmt.Fprint(w, `{"key_id":1234,"key":"2Sg8iYjAxxmI2LvUXpJjkYrMxURPc8r+dB7TJyvv1234"}`)
137 })
138
139 ctx := context.Background()
140 key, _, err := client.Actions.GetRepoPublicKey(ctx, "o", "r")
141 if err != nil {
142 t.Errorf("Actions.GetRepoPublicKey returned error: %v", err)
143 }
144
145 want := &PublicKey{KeyID: String("1234"), Key: String("2Sg8iYjAxxmI2LvUXpJjkYrMxURPc8r+dB7TJyvv1234")}
146 if !cmp.Equal(key, want) {
147 t.Errorf("Actions.GetRepoPublicKey returned %+v, want %+v", key, want)
148 }
149
150 const methodName = "GetRepoPublicKey"
151 testBadOptions(t, methodName, func() (err error) {
152 _, _, err = client.Actions.GetRepoPublicKey(ctx, "\n", "\n")
153 return err
154 })
155
156 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
157 got, resp, err := client.Actions.GetRepoPublicKey(ctx, "o", "r")
158 if got != nil {
159 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
160 }
161 return resp, err
162 })
163 }
164
165 func TestActionsService_ListRepoSecrets(t *testing.T) {
166 client, mux, _, teardown := setup()
167 defer teardown()
168
169 mux.HandleFunc("/repos/o/r/actions/secrets", func(w http.ResponseWriter, r *http.Request) {
170 testMethod(t, r, "GET")
171 testFormValues(t, r, values{"per_page": "2", "page": "2"})
172 fmt.Fprint(w, `{"total_count":4,"secrets":[{"name":"A","created_at":"2019-01-02T15:04:05Z","updated_at":"2020-01-02T15:04:05Z"},{"name":"B","created_at":"2019-01-02T15:04:05Z","updated_at":"2020-01-02T15:04:05Z"}]}`)
173 })
174
175 opts := &ListOptions{Page: 2, PerPage: 2}
176 ctx := context.Background()
177 secrets, _, err := client.Actions.ListRepoSecrets(ctx, "o", "r", opts)
178 if err != nil {
179 t.Errorf("Actions.ListRepoSecrets returned error: %v", err)
180 }
181
182 want := &Secrets{
183 TotalCount: 4,
184 Secrets: []*Secret{
185 {Name: "A", CreatedAt: Timestamp{time.Date(2019, time.January, 02, 15, 04, 05, 0, time.UTC)}, UpdatedAt: Timestamp{time.Date(2020, time.January, 02, 15, 04, 05, 0, time.UTC)}},
186 {Name: "B", CreatedAt: Timestamp{time.Date(2019, time.January, 02, 15, 04, 05, 0, time.UTC)}, UpdatedAt: Timestamp{time.Date(2020, time.January, 02, 15, 04, 05, 0, time.UTC)}},
187 },
188 }
189 if !cmp.Equal(secrets, want) {
190 t.Errorf("Actions.ListRepoSecrets returned %+v, want %+v", secrets, want)
191 }
192
193 const methodName = "ListRepoSecrets"
194 testBadOptions(t, methodName, func() (err error) {
195 _, _, err = client.Actions.ListRepoSecrets(ctx, "\n", "\n", opts)
196 return err
197 })
198
199 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
200 got, resp, err := client.Actions.ListRepoSecrets(ctx, "o", "r", opts)
201 if got != nil {
202 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
203 }
204 return resp, err
205 })
206 }
207
208 func TestActionsService_GetRepoSecret(t *testing.T) {
209 client, mux, _, teardown := setup()
210 defer teardown()
211
212 mux.HandleFunc("/repos/o/r/actions/secrets/NAME", func(w http.ResponseWriter, r *http.Request) {
213 testMethod(t, r, "GET")
214 fmt.Fprint(w, `{"name":"NAME","created_at":"2019-01-02T15:04:05Z","updated_at":"2020-01-02T15:04:05Z"}`)
215 })
216
217 ctx := context.Background()
218 secret, _, err := client.Actions.GetRepoSecret(ctx, "o", "r", "NAME")
219 if err != nil {
220 t.Errorf("Actions.GetRepoSecret returned error: %v", err)
221 }
222
223 want := &Secret{
224 Name: "NAME",
225 CreatedAt: Timestamp{time.Date(2019, time.January, 02, 15, 04, 05, 0, time.UTC)},
226 UpdatedAt: Timestamp{time.Date(2020, time.January, 02, 15, 04, 05, 0, time.UTC)},
227 }
228 if !cmp.Equal(secret, want) {
229 t.Errorf("Actions.GetRepoSecret returned %+v, want %+v", secret, want)
230 }
231
232 const methodName = "GetRepoSecret"
233 testBadOptions(t, methodName, func() (err error) {
234 _, _, err = client.Actions.GetRepoSecret(ctx, "\n", "\n", "\n")
235 return err
236 })
237
238 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
239 got, resp, err := client.Actions.GetRepoSecret(ctx, "o", "r", "NAME")
240 if got != nil {
241 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
242 }
243 return resp, err
244 })
245 }
246
247 func TestActionsService_CreateOrUpdateRepoSecret(t *testing.T) {
248 client, mux, _, teardown := setup()
249 defer teardown()
250
251 mux.HandleFunc("/repos/o/r/actions/secrets/NAME", func(w http.ResponseWriter, r *http.Request) {
252 testMethod(t, r, "PUT")
253 testHeader(t, r, "Content-Type", "application/json")
254 testBody(t, r, `{"key_id":"1234","encrypted_value":"QIv="}`+"\n")
255 w.WriteHeader(http.StatusCreated)
256 })
257
258 input := &EncryptedSecret{
259 Name: "NAME",
260 EncryptedValue: "QIv=",
261 KeyID: "1234",
262 }
263 ctx := context.Background()
264 _, err := client.Actions.CreateOrUpdateRepoSecret(ctx, "o", "r", input)
265 if err != nil {
266 t.Errorf("Actions.CreateOrUpdateRepoSecret returned error: %v", err)
267 }
268
269 const methodName = "CreateOrUpdateRepoSecret"
270 testBadOptions(t, methodName, func() (err error) {
271 _, err = client.Actions.CreateOrUpdateRepoSecret(ctx, "\n", "\n", input)
272 return err
273 })
274
275 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
276 return client.Actions.CreateOrUpdateRepoSecret(ctx, "o", "r", input)
277 })
278 }
279
280 func TestActionsService_DeleteRepoSecret(t *testing.T) {
281 client, mux, _, teardown := setup()
282 defer teardown()
283
284 mux.HandleFunc("/repos/o/r/actions/secrets/NAME", func(w http.ResponseWriter, r *http.Request) {
285 testMethod(t, r, "DELETE")
286 })
287
288 ctx := context.Background()
289 _, err := client.Actions.DeleteRepoSecret(ctx, "o", "r", "NAME")
290 if err != nil {
291 t.Errorf("Actions.DeleteRepoSecret returned error: %v", err)
292 }
293
294 const methodName = "DeleteRepoSecret"
295 testBadOptions(t, methodName, func() (err error) {
296 _, err = client.Actions.DeleteRepoSecret(ctx, "\n", "\n", "\n")
297 return err
298 })
299
300 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
301 return client.Actions.DeleteRepoSecret(ctx, "o", "r", "NAME")
302 })
303 }
304
305 func TestActionsService_GetOrgPublicKey(t *testing.T) {
306 client, mux, _, teardown := setup()
307 defer teardown()
308
309 mux.HandleFunc("/orgs/o/actions/secrets/public-key", func(w http.ResponseWriter, r *http.Request) {
310 testMethod(t, r, "GET")
311 fmt.Fprint(w, `{"key_id":"012345678","key":"2Sg8iYjAxxmI2LvUXpJjkYrMxURPc8r+dB7TJyvv1234"}`)
312 })
313
314 ctx := context.Background()
315 key, _, err := client.Actions.GetOrgPublicKey(ctx, "o")
316 if err != nil {
317 t.Errorf("Actions.GetOrgPublicKey returned error: %v", err)
318 }
319
320 want := &PublicKey{KeyID: String("012345678"), Key: String("2Sg8iYjAxxmI2LvUXpJjkYrMxURPc8r+dB7TJyvv1234")}
321 if !cmp.Equal(key, want) {
322 t.Errorf("Actions.GetOrgPublicKey returned %+v, want %+v", key, want)
323 }
324
325 const methodName = "GetOrgPublicKey"
326 testBadOptions(t, methodName, func() (err error) {
327 _, _, err = client.Actions.GetOrgPublicKey(ctx, "\n")
328 return err
329 })
330
331 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
332 got, resp, err := client.Actions.GetOrgPublicKey(ctx, "o")
333 if got != nil {
334 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
335 }
336 return resp, err
337 })
338 }
339
340 func TestActionsService_ListOrgSecrets(t *testing.T) {
341 client, mux, _, teardown := setup()
342 defer teardown()
343
344 mux.HandleFunc("/orgs/o/actions/secrets", func(w http.ResponseWriter, r *http.Request) {
345 testMethod(t, r, "GET")
346 testFormValues(t, r, values{"per_page": "2", "page": "2"})
347 fmt.Fprint(w, `{"total_count":3,"secrets":[{"name":"GIST_ID","created_at":"2019-08-10T14:59:22Z","updated_at":"2020-01-10T14:59:22Z","visibility":"private"},{"name":"DEPLOY_TOKEN","created_at":"2019-08-10T14:59:22Z","updated_at":"2020-01-10T14:59:22Z","visibility":"all"},{"name":"GH_TOKEN","created_at":"2019-08-10T14:59:22Z","updated_at":"2020-01-10T14:59:22Z","visibility":"selected","selected_repositories_url":"https://api.github.com/orgs/octo-org/actions/secrets/SUPER_SECRET/repositories"}]}`)
348 })
349
350 opts := &ListOptions{Page: 2, PerPage: 2}
351 ctx := context.Background()
352 secrets, _, err := client.Actions.ListOrgSecrets(ctx, "o", opts)
353 if err != nil {
354 t.Errorf("Actions.ListOrgSecrets returned error: %v", err)
355 }
356
357 want := &Secrets{
358 TotalCount: 3,
359 Secrets: []*Secret{
360 {Name: "GIST_ID", CreatedAt: Timestamp{time.Date(2019, time.August, 10, 14, 59, 22, 0, time.UTC)}, UpdatedAt: Timestamp{time.Date(2020, time.January, 10, 14, 59, 22, 0, time.UTC)}, Visibility: "private"},
361 {Name: "DEPLOY_TOKEN", CreatedAt: Timestamp{time.Date(2019, time.August, 10, 14, 59, 22, 0, time.UTC)}, UpdatedAt: Timestamp{time.Date(2020, time.January, 10, 14, 59, 22, 0, time.UTC)}, Visibility: "all"},
362 {Name: "GH_TOKEN", CreatedAt: Timestamp{time.Date(2019, time.August, 10, 14, 59, 22, 0, time.UTC)}, UpdatedAt: Timestamp{time.Date(2020, time.January, 10, 14, 59, 22, 0, time.UTC)}, Visibility: "selected", SelectedRepositoriesURL: "https://api.github.com/orgs/octo-org/actions/secrets/SUPER_SECRET/repositories"},
363 },
364 }
365 if !cmp.Equal(secrets, want) {
366 t.Errorf("Actions.ListOrgSecrets returned %+v, want %+v", secrets, want)
367 }
368
369 const methodName = "ListOrgSecrets"
370 testBadOptions(t, methodName, func() (err error) {
371 _, _, err = client.Actions.ListOrgSecrets(ctx, "\n", opts)
372 return err
373 })
374
375 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
376 got, resp, err := client.Actions.ListOrgSecrets(ctx, "o", opts)
377 if got != nil {
378 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
379 }
380 return resp, err
381 })
382 }
383
384 func TestActionsService_GetOrgSecret(t *testing.T) {
385 client, mux, _, teardown := setup()
386 defer teardown()
387
388 mux.HandleFunc("/orgs/o/actions/secrets/NAME", func(w http.ResponseWriter, r *http.Request) {
389 testMethod(t, r, "GET")
390 fmt.Fprint(w, `{"name":"NAME","created_at":"2019-01-02T15:04:05Z","updated_at":"2020-01-02T15:04:05Z","visibility":"selected","selected_repositories_url":"https://api.github.com/orgs/octo-org/actions/secrets/SUPER_SECRET/repositories"}`)
391 })
392
393 ctx := context.Background()
394 secret, _, err := client.Actions.GetOrgSecret(ctx, "o", "NAME")
395 if err != nil {
396 t.Errorf("Actions.GetOrgSecret returned error: %v", err)
397 }
398
399 want := &Secret{
400 Name: "NAME",
401 CreatedAt: Timestamp{time.Date(2019, time.January, 02, 15, 04, 05, 0, time.UTC)},
402 UpdatedAt: Timestamp{time.Date(2020, time.January, 02, 15, 04, 05, 0, time.UTC)},
403 Visibility: "selected",
404 SelectedRepositoriesURL: "https://api.github.com/orgs/octo-org/actions/secrets/SUPER_SECRET/repositories",
405 }
406 if !cmp.Equal(secret, want) {
407 t.Errorf("Actions.GetOrgSecret returned %+v, want %+v", secret, want)
408 }
409
410 const methodName = "GetOrgSecret"
411 testBadOptions(t, methodName, func() (err error) {
412 _, _, err = client.Actions.GetOrgSecret(ctx, "\n", "\n")
413 return err
414 })
415
416 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
417 got, resp, err := client.Actions.GetOrgSecret(ctx, "o", "NAME")
418 if got != nil {
419 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
420 }
421 return resp, err
422 })
423 }
424
425 func TestActionsService_CreateOrUpdateOrgSecret(t *testing.T) {
426 client, mux, _, teardown := setup()
427 defer teardown()
428
429 mux.HandleFunc("/orgs/o/actions/secrets/NAME", func(w http.ResponseWriter, r *http.Request) {
430 testMethod(t, r, "PUT")
431 testHeader(t, r, "Content-Type", "application/json")
432 testBody(t, r, `{"key_id":"1234","encrypted_value":"QIv=","visibility":"selected","selected_repository_ids":[1296269,1269280]}`+"\n")
433 w.WriteHeader(http.StatusCreated)
434 })
435
436 input := &EncryptedSecret{
437 Name: "NAME",
438 EncryptedValue: "QIv=",
439 KeyID: "1234",
440 Visibility: "selected",
441 SelectedRepositoryIDs: SelectedRepoIDs{1296269, 1269280},
442 }
443 ctx := context.Background()
444 _, err := client.Actions.CreateOrUpdateOrgSecret(ctx, "o", input)
445 if err != nil {
446 t.Errorf("Actions.CreateOrUpdateOrgSecret returned error: %v", err)
447 }
448
449 const methodName = "CreateOrUpdateOrgSecret"
450 testBadOptions(t, methodName, func() (err error) {
451 _, err = client.Actions.CreateOrUpdateOrgSecret(ctx, "\n", input)
452 return err
453 })
454
455 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
456 return client.Actions.CreateOrUpdateOrgSecret(ctx, "o", input)
457 })
458 }
459
460 func TestActionsService_ListSelectedReposForOrgSecret(t *testing.T) {
461 client, mux, _, teardown := setup()
462 defer teardown()
463
464 mux.HandleFunc("/orgs/o/actions/secrets/NAME/repositories", func(w http.ResponseWriter, r *http.Request) {
465 testMethod(t, r, "GET")
466 fmt.Fprintf(w, `{"total_count":1,"repositories":[{"id":1}]}`)
467 })
468
469 opts := &ListOptions{Page: 2, PerPage: 2}
470 ctx := context.Background()
471 repos, _, err := client.Actions.ListSelectedReposForOrgSecret(ctx, "o", "NAME", opts)
472 if err != nil {
473 t.Errorf("Actions.ListSelectedReposForOrgSecret returned error: %v", err)
474 }
475
476 want := &SelectedReposList{
477 TotalCount: Int(1),
478 Repositories: []*Repository{
479 {ID: Int64(1)},
480 },
481 }
482 if !cmp.Equal(repos, want) {
483 t.Errorf("Actions.ListSelectedReposForOrgSecret returned %+v, want %+v", repos, want)
484 }
485
486 const methodName = "ListSelectedReposForOrgSecret"
487 testBadOptions(t, methodName, func() (err error) {
488 _, _, err = client.Actions.ListSelectedReposForOrgSecret(ctx, "\n", "\n", opts)
489 return err
490 })
491
492 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
493 got, resp, err := client.Actions.ListSelectedReposForOrgSecret(ctx, "o", "NAME", opts)
494 if got != nil {
495 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
496 }
497 return resp, err
498 })
499 }
500
501 func TestActionsService_SetSelectedReposForOrgSecret(t *testing.T) {
502 client, mux, _, teardown := setup()
503 defer teardown()
504
505 mux.HandleFunc("/orgs/o/actions/secrets/NAME/repositories", func(w http.ResponseWriter, r *http.Request) {
506 testMethod(t, r, "PUT")
507 testHeader(t, r, "Content-Type", "application/json")
508 testBody(t, r, `{"selected_repository_ids":[64780797]}`+"\n")
509 })
510
511 ctx := context.Background()
512 _, err := client.Actions.SetSelectedReposForOrgSecret(ctx, "o", "NAME", SelectedRepoIDs{64780797})
513 if err != nil {
514 t.Errorf("Actions.SetSelectedReposForOrgSecret returned error: %v", err)
515 }
516
517 const methodName = "SetSelectedReposForOrgSecret"
518 testBadOptions(t, methodName, func() (err error) {
519 _, err = client.Actions.SetSelectedReposForOrgSecret(ctx, "\n", "\n", SelectedRepoIDs{64780797})
520 return err
521 })
522
523 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
524 return client.Actions.SetSelectedReposForOrgSecret(ctx, "o", "NAME", SelectedRepoIDs{64780797})
525 })
526 }
527
528 func TestActionsService_AddSelectedRepoToOrgSecret(t *testing.T) {
529 client, mux, _, teardown := setup()
530 defer teardown()
531
532 mux.HandleFunc("/orgs/o/actions/secrets/NAME/repositories/1234", func(w http.ResponseWriter, r *http.Request) {
533 testMethod(t, r, "PUT")
534 })
535
536 repo := &Repository{ID: Int64(1234)}
537 ctx := context.Background()
538 _, err := client.Actions.AddSelectedRepoToOrgSecret(ctx, "o", "NAME", repo)
539 if err != nil {
540 t.Errorf("Actions.AddSelectedRepoToOrgSecret returned error: %v", err)
541 }
542
543 const methodName = "AddSelectedRepoToOrgSecret"
544 testBadOptions(t, methodName, func() (err error) {
545 _, err = client.Actions.AddSelectedRepoToOrgSecret(ctx, "\n", "\n", repo)
546 return err
547 })
548
549 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
550 return client.Actions.AddSelectedRepoToOrgSecret(ctx, "o", "NAME", repo)
551 })
552 }
553
554 func TestActionsService_RemoveSelectedRepoFromOrgSecret(t *testing.T) {
555 client, mux, _, teardown := setup()
556 defer teardown()
557
558 mux.HandleFunc("/orgs/o/actions/secrets/NAME/repositories/1234", func(w http.ResponseWriter, r *http.Request) {
559 testMethod(t, r, "DELETE")
560 })
561
562 repo := &Repository{ID: Int64(1234)}
563 ctx := context.Background()
564 _, err := client.Actions.RemoveSelectedRepoFromOrgSecret(ctx, "o", "NAME", repo)
565 if err != nil {
566 t.Errorf("Actions.RemoveSelectedRepoFromOrgSecret returned error: %v", err)
567 }
568
569 const methodName = "RemoveSelectedRepoFromOrgSecret"
570 testBadOptions(t, methodName, func() (err error) {
571 _, err = client.Actions.RemoveSelectedRepoFromOrgSecret(ctx, "\n", "\n", repo)
572 return err
573 })
574
575 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
576 return client.Actions.RemoveSelectedRepoFromOrgSecret(ctx, "o", "NAME", repo)
577 })
578 }
579
580 func TestActionsService_DeleteOrgSecret(t *testing.T) {
581 client, mux, _, teardown := setup()
582 defer teardown()
583
584 mux.HandleFunc("/orgs/o/actions/secrets/NAME", func(w http.ResponseWriter, r *http.Request) {
585 testMethod(t, r, "DELETE")
586 })
587
588 ctx := context.Background()
589 _, err := client.Actions.DeleteOrgSecret(ctx, "o", "NAME")
590 if err != nil {
591 t.Errorf("Actions.DeleteOrgSecret returned error: %v", err)
592 }
593
594 const methodName = "DeleteOrgSecret"
595 testBadOptions(t, methodName, func() (err error) {
596 _, err = client.Actions.DeleteOrgSecret(ctx, "\n", "\n")
597 return err
598 })
599
600 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
601 return client.Actions.DeleteOrgSecret(ctx, "o", "NAME")
602 })
603 }
604
605 func TestActionsService_GetEnvPublicKey(t *testing.T) {
606 client, mux, _, teardown := setup()
607 defer teardown()
608 mux.HandleFunc("/repositories/1/environments/e/secrets/public-key", func(w http.ResponseWriter, r *http.Request) {
609 testMethod(t, r, "GET")
610 fmt.Fprint(w, `{"key_id":"1234","key":"2Sg8iYjAxxmI2LvUXpJjkYrMxURPc8r+dB7TJyvv1234"}`)
611 })
612
613 ctx := context.Background()
614 key, _, err := client.Actions.GetEnvPublicKey(ctx, 1, "e")
615 if err != nil {
616 t.Errorf("Actions.GetEnvPublicKey returned error: %v", err)
617 }
618
619 want := &PublicKey{KeyID: String("1234"), Key: String("2Sg8iYjAxxmI2LvUXpJjkYrMxURPc8r+dB7TJyvv1234")}
620 if !cmp.Equal(key, want) {
621 t.Errorf("Actions.GetEnvPublicKey returned %+v, want %+v", key, want)
622 }
623
624 const methodName = "GetEnvPublicKey"
625 testBadOptions(t, methodName, func() (err error) {
626 _, _, err = client.Actions.GetEnvPublicKey(ctx, 0.0, "\n")
627 return err
628 })
629
630 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
631 got, resp, err := client.Actions.GetEnvPublicKey(ctx, 1, "e")
632 if got != nil {
633 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
634 }
635 return resp, err
636 })
637 }
638
639 func TestActionsService_GetEnvPublicKeyNumeric(t *testing.T) {
640 client, mux, _, teardown := setup()
641 defer teardown()
642
643 mux.HandleFunc("/repositories/1/environments/e/secrets/public-key", func(w http.ResponseWriter, r *http.Request) {
644 testMethod(t, r, "GET")
645 fmt.Fprint(w, `{"key_id":1234,"key":"2Sg8iYjAxxmI2LvUXpJjkYrMxURPc8r+dB7TJyvv1234"}`)
646 })
647
648 ctx := context.Background()
649 key, _, err := client.Actions.GetEnvPublicKey(ctx, 1, "e")
650 if err != nil {
651 t.Errorf("Actions.GetEnvPublicKey returned error: %v", err)
652 }
653
654 want := &PublicKey{KeyID: String("1234"), Key: String("2Sg8iYjAxxmI2LvUXpJjkYrMxURPc8r+dB7TJyvv1234")}
655 if !cmp.Equal(key, want) {
656 t.Errorf("Actions.GetEnvPublicKey returned %+v, want %+v", key, want)
657 }
658
659 const methodName = "GetEnvPublicKey"
660 testBadOptions(t, methodName, func() (err error) {
661 _, _, err = client.Actions.GetEnvPublicKey(ctx, 0.0, "\n")
662 return err
663 })
664
665 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
666 got, resp, err := client.Actions.GetEnvPublicKey(ctx, 1, "e")
667 if got != nil {
668 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
669 }
670 return resp, err
671 })
672 }
673
674 func TestActionsService_ListEnvSecrets(t *testing.T) {
675 client, mux, _, teardown := setup()
676 defer teardown()
677
678 mux.HandleFunc("/repositories/1/environments/e/secrets", func(w http.ResponseWriter, r *http.Request) {
679 testMethod(t, r, "GET")
680 testFormValues(t, r, values{"per_page": "2", "page": "2"})
681 fmt.Fprint(w, `{"total_count":4,"secrets":[{"name":"A","created_at":"2019-01-02T15:04:05Z","updated_at":"2020-01-02T15:04:05Z"},{"name":"B","created_at":"2019-01-02T15:04:05Z","updated_at":"2020-01-02T15:04:05Z"}]}`)
682 })
683
684 opts := &ListOptions{Page: 2, PerPage: 2}
685 ctx := context.Background()
686 secrets, _, err := client.Actions.ListEnvSecrets(ctx, 1, "e", opts)
687 if err != nil {
688 t.Errorf("Actions.ListEnvSecrets returned error: %v", err)
689 }
690
691 want := &Secrets{
692 TotalCount: 4,
693 Secrets: []*Secret{
694 {Name: "A", CreatedAt: Timestamp{time.Date(2019, time.January, 02, 15, 04, 05, 0, time.UTC)}, UpdatedAt: Timestamp{time.Date(2020, time.January, 02, 15, 04, 05, 0, time.UTC)}},
695 {Name: "B", CreatedAt: Timestamp{time.Date(2019, time.January, 02, 15, 04, 05, 0, time.UTC)}, UpdatedAt: Timestamp{time.Date(2020, time.January, 02, 15, 04, 05, 0, time.UTC)}},
696 },
697 }
698 if !cmp.Equal(secrets, want) {
699 t.Errorf("Actions.ListEnvSecrets returned %+v, want %+v", secrets, want)
700 }
701
702 const methodName = "ListEnvSecrets"
703 testBadOptions(t, methodName, func() (err error) {
704 _, _, err = client.Actions.ListEnvSecrets(ctx, 0.0, "\n", opts)
705 return err
706 })
707
708 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
709 got, resp, err := client.Actions.ListEnvSecrets(ctx, 1, "e", opts)
710 if got != nil {
711 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
712 }
713 return resp, err
714 })
715 }
716
717 func TestActionsService_GetEnvSecret(t *testing.T) {
718 client, mux, _, teardown := setup()
719 defer teardown()
720
721 mux.HandleFunc("/repositories/1/environments/e/secrets/secret", func(w http.ResponseWriter, r *http.Request) {
722 testMethod(t, r, "GET")
723 fmt.Fprint(w, `{"name":"secret","created_at":"2019-01-02T15:04:05Z","updated_at":"2020-01-02T15:04:05Z"}`)
724 })
725
726 ctx := context.Background()
727 secret, _, err := client.Actions.GetEnvSecret(ctx, 1, "e", "secret")
728 if err != nil {
729 t.Errorf("Actions.GetEnvSecret returned error: %v", err)
730 }
731
732 want := &Secret{
733 Name: "secret",
734 CreatedAt: Timestamp{time.Date(2019, time.January, 02, 15, 04, 05, 0, time.UTC)},
735 UpdatedAt: Timestamp{time.Date(2020, time.January, 02, 15, 04, 05, 0, time.UTC)},
736 }
737 if !cmp.Equal(secret, want) {
738 t.Errorf("Actions.GetEnvSecret returned %+v, want %+v", secret, want)
739 }
740
741 const methodName = "GetEnvSecret"
742 testBadOptions(t, methodName, func() (err error) {
743 _, _, err = client.Actions.GetEnvSecret(ctx, 0.0, "\n", "\n")
744 return err
745 })
746
747 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
748 got, resp, err := client.Actions.GetEnvSecret(ctx, 1, "e", "secret")
749 if got != nil {
750 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
751 }
752 return resp, err
753 })
754 }
755
756 func TestActionsService_CreateOrUpdateEnvSecret(t *testing.T) {
757 client, mux, _, teardown := setup()
758 defer teardown()
759
760 mux.HandleFunc("/repositories/1/environments/e/secrets/secret", func(w http.ResponseWriter, r *http.Request) {
761 testMethod(t, r, "PUT")
762 testHeader(t, r, "Content-Type", "application/json")
763 testBody(t, r, `{"key_id":"1234","encrypted_value":"QIv="}`+"\n")
764 w.WriteHeader(http.StatusCreated)
765 })
766
767 input := &EncryptedSecret{
768 Name: "secret",
769 EncryptedValue: "QIv=",
770 KeyID: "1234",
771 }
772 ctx := context.Background()
773 _, err := client.Actions.CreateOrUpdateEnvSecret(ctx, 1, "e", input)
774 if err != nil {
775 t.Errorf("Actions.CreateOrUpdateEnvSecret returned error: %v", err)
776 }
777
778 const methodName = "CreateOrUpdateEnvSecret"
779 testBadOptions(t, methodName, func() (err error) {
780 _, err = client.Actions.CreateOrUpdateEnvSecret(ctx, 0.0, "\n", input)
781 return err
782 })
783
784 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
785 return client.Actions.CreateOrUpdateEnvSecret(ctx, 1, "e", input)
786 })
787 }
788
789 func TestActionsService_DeleteEnvSecret(t *testing.T) {
790 client, mux, _, teardown := setup()
791 defer teardown()
792
793 mux.HandleFunc("/repositories/1/environments/e/secrets/secret", func(w http.ResponseWriter, r *http.Request) {
794 testMethod(t, r, "DELETE")
795 })
796
797 ctx := context.Background()
798 _, err := client.Actions.DeleteEnvSecret(ctx, 1, "e", "secret")
799 if err != nil {
800 t.Errorf("Actions.DeleteEnvSecret returned error: %v", err)
801 }
802
803 const methodName = "DeleteEnvSecret"
804 testBadOptions(t, methodName, func() (err error) {
805 _, err = client.Actions.DeleteEnvSecret(ctx, 0.0, "\n", "\n")
806 return err
807 })
808
809 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
810 return client.Actions.DeleteEnvSecret(ctx, 1, "r", "secret")
811 })
812 }
813
814 func TestPublicKey_Marshal(t *testing.T) {
815 testJSONMarshal(t, &PublicKey{}, "{}")
816
817 u := &PublicKey{
818 KeyID: String("kid"),
819 Key: String("k"),
820 }
821
822 want := `{
823 "key_id": "kid",
824 "key": "k"
825 }`
826
827 testJSONMarshal(t, u, want)
828 }
829
830 func TestSecret_Marshal(t *testing.T) {
831 testJSONMarshal(t, &Secret{}, "{}")
832
833 u := &Secret{
834 Name: "n",
835 CreatedAt: Timestamp{referenceTime},
836 UpdatedAt: Timestamp{referenceTime},
837 Visibility: "v",
838 SelectedRepositoriesURL: "s",
839 }
840
841 want := `{
842 "name": "n",
843 "created_at": ` + referenceTimeStr + `,
844 "updated_at": ` + referenceTimeStr + `,
845 "visibility": "v",
846 "selected_repositories_url": "s"
847 }`
848
849 testJSONMarshal(t, u, want)
850 }
851
852 func TestSecrets_Marshal(t *testing.T) {
853 testJSONMarshal(t, &Secrets{}, "{}")
854
855 u := &Secrets{
856 TotalCount: 1,
857 Secrets: []*Secret{
858 {
859 Name: "n",
860 CreatedAt: Timestamp{referenceTime},
861 UpdatedAt: Timestamp{referenceTime},
862 Visibility: "v",
863 SelectedRepositoriesURL: "s"},
864 },
865 }
866
867 want := `{
868 "total_count": 1,
869 "secrets": [
870 {
871 "name": "n",
872 "created_at": ` + referenceTimeStr + `,
873 "updated_at": ` + referenceTimeStr + `,
874 "visibility": "v",
875 "selected_repositories_url": "s"
876 }
877 ]
878 }`
879
880 testJSONMarshal(t, u, want)
881 }
882
883 func TestEncryptedSecret_Marshal(t *testing.T) {
884 testJSONMarshal(t, &EncryptedSecret{}, "{}")
885
886 u := &EncryptedSecret{
887 Name: "n",
888 KeyID: "kid",
889 EncryptedValue: "e",
890 Visibility: "v",
891 SelectedRepositoryIDs: []int64{1},
892 }
893
894 want := `{
895 "key_id": "kid",
896 "encrypted_value": "e",
897 "visibility": "v",
898 "selected_repository_ids": [1]
899 }`
900
901 testJSONMarshal(t, u, want)
902 }
903
904 func TestSelectedReposList_Marshal(t *testing.T) {
905 testJSONMarshal(t, &SelectedReposList{}, "{}")
906
907 u := &SelectedReposList{
908 TotalCount: Int(1),
909 Repositories: []*Repository{
910 {
911 ID: Int64(1),
912 URL: String("u"),
913 Name: String("n"),
914 },
915 },
916 }
917
918 want := `{
919 "total_count": 1,
920 "repositories": [
921 {
922 "id": 1,
923 "url": "u",
924 "name": "n"
925 }
926 ]
927 }`
928
929 testJSONMarshal(t, u, want)
930 }
931
View as plain text