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 TestActionsService_ListOrganizationRunnerGroups(t *testing.T) {
18 client, mux, _, teardown := setup()
19 defer teardown()
20
21 mux.HandleFunc("/orgs/o/actions/runner-groups", func(w http.ResponseWriter, r *http.Request) {
22 testMethod(t, r, "GET")
23 testFormValues(t, r, values{"per_page": "2", "page": "2"})
24 fmt.Fprint(w, `{"total_count":3,"runner_groups":[{"id":1,"name":"Default","visibility":"all","default":true,"runners_url":"https://api.github.com/orgs/octo-org/actions/runner_groups/1/runners","inherited":false,"allows_public_repositories":true},{"id":2,"name":"octo-runner-group","visibility":"selected","default":false,"selected_repositories_url":"https://api.github.com/orgs/octo-org/actions/runner_groups/2/repositories","runners_url":"https://api.github.com/orgs/octo-org/actions/runner_groups/2/runners","inherited":true,"allows_public_repositories":true},{"id":3,"name":"expensive-hardware","visibility":"private","default":false,"runners_url":"https://api.github.com/orgs/octo-org/actions/runner_groups/3/runners","inherited":false,"allows_public_repositories":true}]}`)
25 })
26
27 opts := &ListOrgRunnerGroupOptions{ListOptions: ListOptions{Page: 2, PerPage: 2}}
28 ctx := context.Background()
29 groups, _, err := client.Actions.ListOrganizationRunnerGroups(ctx, "o", opts)
30 if err != nil {
31 t.Errorf("Actions.ListOrganizationRunnerGroups returned error: %v", err)
32 }
33
34 want := &RunnerGroups{
35 TotalCount: 3,
36 RunnerGroups: []*RunnerGroup{
37 {ID: Int64(1), Name: String("Default"), Visibility: String("all"), Default: Bool(true), RunnersURL: String("https://api.github.com/orgs/octo-org/actions/runner_groups/1/runners"), Inherited: Bool(false), AllowsPublicRepositories: Bool(true)},
38 {ID: Int64(2), Name: String("octo-runner-group"), Visibility: String("selected"), Default: Bool(false), SelectedRepositoriesURL: String("https://api.github.com/orgs/octo-org/actions/runner_groups/2/repositories"), RunnersURL: String("https://api.github.com/orgs/octo-org/actions/runner_groups/2/runners"), Inherited: Bool(true), AllowsPublicRepositories: Bool(true)},
39 {ID: Int64(3), Name: String("expensive-hardware"), Visibility: String("private"), Default: Bool(false), RunnersURL: String("https://api.github.com/orgs/octo-org/actions/runner_groups/3/runners"), Inherited: Bool(false), AllowsPublicRepositories: Bool(true)},
40 },
41 }
42 if !cmp.Equal(groups, want) {
43 t.Errorf("Actions.ListOrganizationRunnerGroups returned %+v, want %+v", groups, want)
44 }
45
46 const methodName = "ListOrganizationRunnerGroups"
47 testBadOptions(t, methodName, func() (err error) {
48 _, _, err = client.Actions.ListOrganizationRunnerGroups(ctx, "\n", opts)
49 return err
50 })
51
52 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
53 got, resp, err := client.Actions.ListOrganizationRunnerGroups(ctx, "o", opts)
54 if got != nil {
55 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
56 }
57 return resp, err
58 })
59 }
60
61 func TestActionsService_ListOrganizationRunnerGroupsVisibleToRepo(t *testing.T) {
62 client, mux, _, teardown := setup()
63 defer teardown()
64
65 mux.HandleFunc("/orgs/o/actions/runner-groups", func(w http.ResponseWriter, r *http.Request) {
66 testMethod(t, r, "GET")
67 testFormValues(t, r, values{"per_page": "2", "page": "2", "visible_to_repository": "github"})
68 fmt.Fprint(w, `{"total_count":3,"runner_groups":[{"id":1,"name":"Default","visibility":"all","default":true,"runners_url":"https://api.github.com/orgs/octo-org/actions/runner_groups/1/runners","inherited":false,"allows_public_repositories":true},{"id":2,"name":"octo-runner-group","visibility":"selected","default":false,"selected_repositories_url":"https://api.github.com/orgs/octo-org/actions/runner_groups/2/repositories","runners_url":"https://api.github.com/orgs/octo-org/actions/runner_groups/2/runners","inherited":true,"allows_public_repositories":true},{"id":3,"name":"expensive-hardware","visibility":"private","default":false,"runners_url":"https://api.github.com/orgs/octo-org/actions/runner_groups/3/runners","inherited":false,"allows_public_repositories":true}]}`)
69 })
70
71 opts := &ListOrgRunnerGroupOptions{ListOptions: ListOptions{Page: 2, PerPage: 2}, VisibleToRepository: "github"}
72 ctx := context.Background()
73 groups, _, err := client.Actions.ListOrganizationRunnerGroups(ctx, "o", opts)
74 if err != nil {
75 t.Errorf("Actions.ListOrganizationRunnerGroups returned error: %v", err)
76 }
77
78 want := &RunnerGroups{
79 TotalCount: 3,
80 RunnerGroups: []*RunnerGroup{
81 {ID: Int64(1), Name: String("Default"), Visibility: String("all"), Default: Bool(true), RunnersURL: String("https://api.github.com/orgs/octo-org/actions/runner_groups/1/runners"), Inherited: Bool(false), AllowsPublicRepositories: Bool(true)},
82 {ID: Int64(2), Name: String("octo-runner-group"), Visibility: String("selected"), Default: Bool(false), SelectedRepositoriesURL: String("https://api.github.com/orgs/octo-org/actions/runner_groups/2/repositories"), RunnersURL: String("https://api.github.com/orgs/octo-org/actions/runner_groups/2/runners"), Inherited: Bool(true), AllowsPublicRepositories: Bool(true)},
83 {ID: Int64(3), Name: String("expensive-hardware"), Visibility: String("private"), Default: Bool(false), RunnersURL: String("https://api.github.com/orgs/octo-org/actions/runner_groups/3/runners"), Inherited: Bool(false), AllowsPublicRepositories: Bool(true)},
84 },
85 }
86 if !cmp.Equal(groups, want) {
87 t.Errorf("Actions.ListOrganizationRunnerGroups returned %+v, want %+v", groups, want)
88 }
89
90 const methodName = "ListOrganizationRunnerGroups"
91 testBadOptions(t, methodName, func() (err error) {
92 _, _, err = client.Actions.ListOrganizationRunnerGroups(ctx, "\n", opts)
93 return err
94 })
95
96 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
97 got, resp, err := client.Actions.ListOrganizationRunnerGroups(ctx, "o", opts)
98 if got != nil {
99 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
100 }
101 return resp, err
102 })
103 }
104
105 func TestActionsService_GetOrganizationRunnerGroup(t *testing.T) {
106 client, mux, _, teardown := setup()
107 defer teardown()
108
109 mux.HandleFunc("/orgs/o/actions/runner-groups/2", func(w http.ResponseWriter, r *http.Request) {
110 testMethod(t, r, "GET")
111 fmt.Fprint(w, `{"id":2,"name":"octo-runner-group","visibility":"selected","default":false,"selected_repositories_url":"https://api.github.com/orgs/octo-org/actions/runner_groups/2/repositories","runners_url":"https://api.github.com/orgs/octo-org/actions/runner_groups/2/runners","inherited":false,"allows_public_repositories":true}`)
112 })
113
114 ctx := context.Background()
115 group, _, err := client.Actions.GetOrganizationRunnerGroup(ctx, "o", 2)
116 if err != nil {
117 t.Errorf("Actions.ListOrganizationRunnerGroups returned error: %v", err)
118 }
119
120 want := &RunnerGroup{
121 ID: Int64(2),
122 Name: String("octo-runner-group"),
123 Visibility: String("selected"),
124 Default: Bool(false),
125 SelectedRepositoriesURL: String("https://api.github.com/orgs/octo-org/actions/runner_groups/2/repositories"),
126 RunnersURL: String("https://api.github.com/orgs/octo-org/actions/runner_groups/2/runners"),
127 Inherited: Bool(false),
128 AllowsPublicRepositories: Bool(true),
129 }
130
131 if !cmp.Equal(group, want) {
132 t.Errorf("Actions.GetOrganizationRunnerGroup returned %+v, want %+v", group, want)
133 }
134
135 const methodName = "GetOrganizationRunnerGroup"
136 testBadOptions(t, methodName, func() (err error) {
137 _, _, err = client.Actions.GetOrganizationRunnerGroup(ctx, "\n", 2)
138 return err
139 })
140
141 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
142 got, resp, err := client.Actions.GetOrganizationRunnerGroup(ctx, "o", 2)
143 if got != nil {
144 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
145 }
146 return resp, err
147 })
148 }
149
150 func TestActionsService_DeleteOrganizationRunnerGroup(t *testing.T) {
151 client, mux, _, teardown := setup()
152 defer teardown()
153
154 mux.HandleFunc("/orgs/o/actions/runner-groups/2", func(w http.ResponseWriter, r *http.Request) {
155 testMethod(t, r, "DELETE")
156 })
157
158 ctx := context.Background()
159 _, err := client.Actions.DeleteOrganizationRunnerGroup(ctx, "o", 2)
160 if err != nil {
161 t.Errorf("Actions.DeleteOrganizationRunnerGroup returned error: %v", err)
162 }
163
164 const methodName = "DeleteOrganizationRunnerGroup"
165 testBadOptions(t, methodName, func() (err error) {
166 _, err = client.Actions.DeleteOrganizationRunnerGroup(ctx, "\n", 2)
167 return err
168 })
169
170 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
171 return client.Actions.DeleteOrganizationRunnerGroup(ctx, "o", 2)
172 })
173 }
174
175 func TestActionsService_CreateOrganizationRunnerGroup(t *testing.T) {
176 client, mux, _, teardown := setup()
177 defer teardown()
178
179 mux.HandleFunc("/orgs/o/actions/runner-groups", func(w http.ResponseWriter, r *http.Request) {
180 testMethod(t, r, "POST")
181 fmt.Fprint(w, `{"id":2,"name":"octo-runner-group","visibility":"selected","default":false,"selected_repositories_url":"https://api.github.com/orgs/octo-org/actions/runner_groups/2/repositories","runners_url":"https://api.github.com/orgs/octo-org/actions/runner_groups/2/runners","inherited":false,"allows_public_repositories":true}`)
182 })
183
184 ctx := context.Background()
185 req := CreateRunnerGroupRequest{
186 Name: String("octo-runner-group"),
187 Visibility: String("selected"),
188 AllowsPublicRepositories: Bool(true),
189 }
190 group, _, err := client.Actions.CreateOrganizationRunnerGroup(ctx, "o", req)
191 if err != nil {
192 t.Errorf("Actions.CreateOrganizationRunnerGroup returned error: %v", err)
193 }
194
195 want := &RunnerGroup{
196 ID: Int64(2),
197 Name: String("octo-runner-group"),
198 Visibility: String("selected"),
199 Default: Bool(false),
200 SelectedRepositoriesURL: String("https://api.github.com/orgs/octo-org/actions/runner_groups/2/repositories"),
201 RunnersURL: String("https://api.github.com/orgs/octo-org/actions/runner_groups/2/runners"),
202 Inherited: Bool(false),
203 AllowsPublicRepositories: Bool(true),
204 }
205
206 if !cmp.Equal(group, want) {
207 t.Errorf("Actions.CreateOrganizationRunnerGroup returned %+v, want %+v", group, want)
208 }
209
210 const methodName = "CreateOrganizationRunnerGroup"
211 testBadOptions(t, methodName, func() (err error) {
212 _, _, err = client.Actions.CreateOrganizationRunnerGroup(ctx, "\n", req)
213 return err
214 })
215
216 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
217 got, resp, err := client.Actions.CreateOrganizationRunnerGroup(ctx, "o", req)
218 if got != nil {
219 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
220 }
221 return resp, err
222 })
223 }
224
225 func TestActionsService_UpdateOrganizationRunnerGroup(t *testing.T) {
226 client, mux, _, teardown := setup()
227 defer teardown()
228
229 mux.HandleFunc("/orgs/o/actions/runner-groups/2", func(w http.ResponseWriter, r *http.Request) {
230 testMethod(t, r, "PATCH")
231 fmt.Fprint(w, `{"id":2,"name":"octo-runner-group","visibility":"selected","default":false,"selected_repositories_url":"https://api.github.com/orgs/octo-org/actions/runner_groups/2/repositories","runners_url":"https://api.github.com/orgs/octo-org/actions/runner_groups/2/runners","inherited":false,"allows_public_repositories":true}`)
232 })
233
234 ctx := context.Background()
235 req := UpdateRunnerGroupRequest{
236 Name: String("octo-runner-group"),
237 Visibility: String("selected"),
238 AllowsPublicRepositories: Bool(true),
239 }
240 group, _, err := client.Actions.UpdateOrganizationRunnerGroup(ctx, "o", 2, req)
241 if err != nil {
242 t.Errorf("Actions.UpdateOrganizationRunnerGroup returned error: %v", err)
243 }
244
245 want := &RunnerGroup{
246 ID: Int64(2),
247 Name: String("octo-runner-group"),
248 Visibility: String("selected"),
249 Default: Bool(false),
250 SelectedRepositoriesURL: String("https://api.github.com/orgs/octo-org/actions/runner_groups/2/repositories"),
251 RunnersURL: String("https://api.github.com/orgs/octo-org/actions/runner_groups/2/runners"),
252 Inherited: Bool(false),
253 AllowsPublicRepositories: Bool(true),
254 }
255
256 if !cmp.Equal(group, want) {
257 t.Errorf("Actions.UpdateOrganizationRunnerGroup returned %+v, want %+v", group, want)
258 }
259
260 const methodName = "UpdateOrganizationRunnerGroup"
261 testBadOptions(t, methodName, func() (err error) {
262 _, _, err = client.Actions.UpdateOrganizationRunnerGroup(ctx, "\n", 2, req)
263 return err
264 })
265
266 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
267 got, resp, err := client.Actions.UpdateOrganizationRunnerGroup(ctx, "o", 2, req)
268 if got != nil {
269 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
270 }
271 return resp, err
272 })
273 }
274
275 func TestActionsService_ListRepositoryAccessRunnerGroup(t *testing.T) {
276 client, mux, _, teardown := setup()
277 defer teardown()
278
279 mux.HandleFunc("/orgs/o/actions/runner-groups/2/repositories", func(w http.ResponseWriter, r *http.Request) {
280 testMethod(t, r, "GET")
281 testFormValues(t, r, values{"per_page": "1", "page": "1"})
282 fmt.Fprint(w, `{"total_count": 1, "repositories": [{"id": 43, "node_id": "MDEwOlJlcG9zaXRvcnkxMjk2MjY5", "name": "Hello-World", "full_name": "octocat/Hello-World"}]}`)
283 })
284
285 ctx := context.Background()
286 opts := &ListOptions{Page: 1, PerPage: 1}
287 groups, _, err := client.Actions.ListRepositoryAccessRunnerGroup(ctx, "o", 2, opts)
288 if err != nil {
289 t.Errorf("Actions.ListRepositoryAccessRunnerGroup returned error: %v", err)
290 }
291
292 want := &ListRepositories{
293 TotalCount: Int(1),
294 Repositories: []*Repository{
295 {ID: Int64(43), NodeID: String("MDEwOlJlcG9zaXRvcnkxMjk2MjY5"), Name: String("Hello-World"), FullName: String("octocat/Hello-World")},
296 },
297 }
298 if !cmp.Equal(groups, want) {
299 t.Errorf("Actions.ListRepositoryAccessRunnerGroup returned %+v, want %+v", groups, want)
300 }
301
302 const methodName = "ListRepositoryAccessRunnerGroup"
303 testBadOptions(t, methodName, func() (err error) {
304 _, _, err = client.Actions.ListRepositoryAccessRunnerGroup(ctx, "\n", 2, opts)
305 return err
306 })
307
308 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
309 got, resp, err := client.Actions.ListRepositoryAccessRunnerGroup(ctx, "o", 2, opts)
310 if got != nil {
311 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
312 }
313 return resp, err
314 })
315 }
316
317 func TestActionsService_SetRepositoryAccessRunnerGroup(t *testing.T) {
318 client, mux, _, teardown := setup()
319 defer teardown()
320
321 mux.HandleFunc("/orgs/o/actions/runner-groups/2/repositories", func(w http.ResponseWriter, r *http.Request) {
322 testMethod(t, r, "PUT")
323 })
324
325 req := SetRepoAccessRunnerGroupRequest{
326 SelectedRepositoryIDs: []int64{
327 1,
328 2,
329 },
330 }
331
332 ctx := context.Background()
333 _, err := client.Actions.SetRepositoryAccessRunnerGroup(ctx, "o", 2, req)
334 if err != nil {
335 t.Errorf("Actions.SetRepositoryAccessRunnerGroup returned error: %v", err)
336 }
337
338 const methodName = "SetRepositoryAccessRunnerGroup"
339 testBadOptions(t, methodName, func() (err error) {
340 _, err = client.Actions.SetRepositoryAccessRunnerGroup(ctx, "\n", 2, req)
341 return err
342 })
343
344 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
345 return client.Actions.SetRepositoryAccessRunnerGroup(ctx, "o", 2, req)
346 })
347 }
348
349 func TestActionsService_AddRepositoryAccessRunnerGroup(t *testing.T) {
350 client, mux, _, teardown := setup()
351 defer teardown()
352
353 mux.HandleFunc("/orgs/o/actions/runner-groups/2/repositories/42", func(w http.ResponseWriter, r *http.Request) {
354 testMethod(t, r, "PUT")
355 })
356
357 ctx := context.Background()
358 _, err := client.Actions.AddRepositoryAccessRunnerGroup(ctx, "o", 2, 42)
359 if err != nil {
360 t.Errorf("Actions.AddRepositoryAccessRunnerGroup returned error: %v", err)
361 }
362
363 const methodName = "AddRepositoryAccessRunnerGroup"
364 testBadOptions(t, methodName, func() (err error) {
365 _, err = client.Actions.AddRepositoryAccessRunnerGroup(ctx, "\n", 2, 42)
366 return err
367 })
368
369 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
370 return client.Actions.AddRepositoryAccessRunnerGroup(ctx, "o", 2, 42)
371 })
372 }
373
374 func TestActionsService_RemoveRepositoryAccessRunnerGroup(t *testing.T) {
375 client, mux, _, teardown := setup()
376 defer teardown()
377
378 mux.HandleFunc("/orgs/o/actions/runner-groups/2/repositories/42", func(w http.ResponseWriter, r *http.Request) {
379 testMethod(t, r, "DELETE")
380 })
381
382 ctx := context.Background()
383 _, err := client.Actions.RemoveRepositoryAccessRunnerGroup(ctx, "o", 2, 42)
384 if err != nil {
385 t.Errorf("Actions.RemoveRepositoryAccessRunnerGroup returned error: %v", err)
386 }
387
388 const methodName = "RemoveRepositoryAccessRunnerGroup"
389 testBadOptions(t, methodName, func() (err error) {
390 _, err = client.Actions.RemoveRepositoryAccessRunnerGroup(ctx, "\n", 2, 42)
391 return err
392 })
393
394 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
395 return client.Actions.RemoveRepositoryAccessRunnerGroup(ctx, "o", 2, 42)
396 })
397 }
398
399 func TestActionsService_ListRunnerGroupRunners(t *testing.T) {
400 client, mux, _, teardown := setup()
401 defer teardown()
402
403 mux.HandleFunc("/orgs/o/actions/runner-groups/2/runners", func(w http.ResponseWriter, r *http.Request) {
404 testMethod(t, r, "GET")
405 testFormValues(t, r, values{"per_page": "2", "page": "2"})
406 fmt.Fprint(w, `{"total_count":2,"runners":[{"id":23,"name":"MBP","os":"macos","status":"online"},{"id":24,"name":"iMac","os":"macos","status":"offline"}]}`)
407 })
408
409 opts := &ListOptions{Page: 2, PerPage: 2}
410 ctx := context.Background()
411 runners, _, err := client.Actions.ListRunnerGroupRunners(ctx, "o", 2, opts)
412 if err != nil {
413 t.Errorf("Actions.ListRunnerGroupRunners returned error: %v", err)
414 }
415
416 want := &Runners{
417 TotalCount: 2,
418 Runners: []*Runner{
419 {ID: Int64(23), Name: String("MBP"), OS: String("macos"), Status: String("online")},
420 {ID: Int64(24), Name: String("iMac"), OS: String("macos"), Status: String("offline")},
421 },
422 }
423 if !cmp.Equal(runners, want) {
424 t.Errorf("Actions.ListRunnerGroupRunners returned %+v, want %+v", runners, want)
425 }
426
427 const methodName = "ListRunnerGroupRunners"
428 testBadOptions(t, methodName, func() (err error) {
429 _, _, err = client.Actions.ListRunnerGroupRunners(ctx, "\n", 2, opts)
430 return err
431 })
432
433 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
434 got, resp, err := client.Actions.ListRunnerGroupRunners(ctx, "o", 2, opts)
435 if got != nil {
436 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
437 }
438 return resp, err
439 })
440 }
441
442 func TestActionsService_SetRunnerGroupRunners(t *testing.T) {
443 client, mux, _, teardown := setup()
444 defer teardown()
445
446 mux.HandleFunc("/orgs/o/actions/runner-groups/2/runners", func(w http.ResponseWriter, r *http.Request) {
447 testMethod(t, r, "PUT")
448 })
449
450 req := SetRunnerGroupRunnersRequest{
451 Runners: []int64{
452 1,
453 2,
454 },
455 }
456
457 ctx := context.Background()
458 _, err := client.Actions.SetRunnerGroupRunners(ctx, "o", 2, req)
459 if err != nil {
460 t.Errorf("Actions.SetRunnerGroupRunners returned error: %v", err)
461 }
462
463 const methodName = "SetRunnerGroupRunners"
464 testBadOptions(t, methodName, func() (err error) {
465 _, err = client.Actions.SetRunnerGroupRunners(ctx, "\n", 2, req)
466 return err
467 })
468
469 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
470 return client.Actions.SetRunnerGroupRunners(ctx, "o", 2, req)
471 })
472 }
473
474 func TestActionsService_AddRunnerGroupRunners(t *testing.T) {
475 client, mux, _, teardown := setup()
476 defer teardown()
477
478 mux.HandleFunc("/orgs/o/actions/runner-groups/2/runners/42", func(w http.ResponseWriter, r *http.Request) {
479 testMethod(t, r, "PUT")
480 })
481
482 ctx := context.Background()
483 _, err := client.Actions.AddRunnerGroupRunners(ctx, "o", 2, 42)
484 if err != nil {
485 t.Errorf("Actions.AddRunnerGroupRunners returned error: %v", err)
486 }
487
488 const methodName = "AddRunnerGroupRunners"
489 testBadOptions(t, methodName, func() (err error) {
490 _, err = client.Actions.AddRunnerGroupRunners(ctx, "\n", 2, 42)
491 return err
492 })
493
494 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
495 return client.Actions.AddRunnerGroupRunners(ctx, "o", 2, 42)
496 })
497 }
498
499 func TestActionsService_RemoveRunnerGroupRunners(t *testing.T) {
500 client, mux, _, teardown := setup()
501 defer teardown()
502
503 mux.HandleFunc("/orgs/o/actions/runner-groups/2/runners/42", func(w http.ResponseWriter, r *http.Request) {
504 testMethod(t, r, "DELETE")
505 })
506
507 ctx := context.Background()
508 _, err := client.Actions.RemoveRunnerGroupRunners(ctx, "o", 2, 42)
509 if err != nil {
510 t.Errorf("Actions.RemoveRunnerGroupRunners returned error: %v", err)
511 }
512
513 const methodName = "RemoveRunnerGroupRunners"
514 testBadOptions(t, methodName, func() (err error) {
515 _, err = client.Actions.RemoveRunnerGroupRunners(ctx, "\n", 2, 42)
516 return err
517 })
518
519 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
520 return client.Actions.RemoveRunnerGroupRunners(ctx, "o", 2, 42)
521 })
522 }
523
524 func TestRunnerGroup_Marshal(t *testing.T) {
525 testJSONMarshal(t, &RunnerGroup{}, "{}")
526
527 u := &RunnerGroup{
528 ID: Int64(1),
529 Name: String("n"),
530 Visibility: String("v"),
531 Default: Bool(true),
532 SelectedRepositoriesURL: String("s"),
533 RunnersURL: String("r"),
534 Inherited: Bool(true),
535 AllowsPublicRepositories: Bool(true),
536 }
537
538 want := `{
539 "id": 1,
540 "name": "n",
541 "visibility": "v",
542 "default": true,
543 "selected_repositories_url": "s",
544 "runners_url": "r",
545 "inherited": true,
546 "allows_public_repositories": true
547 }`
548
549 testJSONMarshal(t, u, want)
550 }
551
552 func TestRunnerGroups_Marshal(t *testing.T) {
553 testJSONMarshal(t, &RunnerGroups{}, "{}")
554
555 u := &RunnerGroups{
556 TotalCount: int(1),
557 RunnerGroups: []*RunnerGroup{
558 {
559 ID: Int64(1),
560 Name: String("n"),
561 Visibility: String("v"),
562 Default: Bool(true),
563 SelectedRepositoriesURL: String("s"),
564 RunnersURL: String("r"),
565 Inherited: Bool(true),
566 AllowsPublicRepositories: Bool(true),
567 },
568 },
569 }
570
571 want := `{
572 "total_count": 1,
573 "runner_groups": [{
574 "id": 1,
575 "name": "n",
576 "visibility": "v",
577 "default": true,
578 "selected_repositories_url": "s",
579 "runners_url": "r",
580 "inherited": true,
581 "allows_public_repositories": true
582 }]
583 }`
584
585 testJSONMarshal(t, u, want)
586 }
587
588 func TestCreateRunnerGroupRequest_Marshal(t *testing.T) {
589 testJSONMarshal(t, &CreateRunnerGroupRequest{}, "{}")
590
591 u := &CreateRunnerGroupRequest{
592 Name: String("n"),
593 Visibility: String("v"),
594 SelectedRepositoryIDs: []int64{1},
595 Runners: []int64{1},
596 AllowsPublicRepositories: Bool(true),
597 }
598
599 want := `{
600 "name": "n",
601 "visibility": "v",
602 "selected_repository_ids": [1],
603 "runners": [1],
604 "allows_public_repositories": true
605 }`
606
607 testJSONMarshal(t, u, want)
608 }
609
610 func TestUpdateRunnerGroupRequest_Marshal(t *testing.T) {
611 testJSONMarshal(t, &UpdateRunnerGroupRequest{}, "{}")
612
613 u := &UpdateRunnerGroupRequest{
614 Name: String("n"),
615 Visibility: String("v"),
616 AllowsPublicRepositories: Bool(true),
617 }
618
619 want := `{
620 "name": "n",
621 "visibility": "v",
622 "allows_public_repositories": true
623 }`
624
625 testJSONMarshal(t, u, want)
626 }
627
628 func TestSetRepoAccessRunnerGroupRequest_Marshal(t *testing.T) {
629 testJSONMarshal(t, &SetRepoAccessRunnerGroupRequest{}, "{}")
630
631 u := &SetRepoAccessRunnerGroupRequest{
632 SelectedRepositoryIDs: []int64{1},
633 }
634
635 want := `{
636 "selected_repository_ids": [1]
637 }`
638
639 testJSONMarshal(t, u, want)
640 }
641
642 func TestSetRunnerGroupRunnersRequest_Marshal(t *testing.T) {
643 testJSONMarshal(t, &SetRunnerGroupRunnersRequest{}, "{}")
644
645 u := &SetRunnerGroupRunnersRequest{
646 Runners: []int64{1},
647 }
648
649 want := `{
650 "runners": [1]
651 }`
652
653 testJSONMarshal(t, u, want)
654 }
655
View as plain text