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 TestOrganizationsService_GetAllOrganizationRulesets(t *testing.T) {
18 client, mux, _, teardown := setup()
19 defer teardown()
20
21 mux.HandleFunc("/orgs/o/rulesets", func(w http.ResponseWriter, r *http.Request) {
22 testMethod(t, r, "GET")
23 fmt.Fprint(w, `[{
24 "id": 26110,
25 "name": "test ruleset",
26 "target": "branch",
27 "source_type": "Organization",
28 "source": "o",
29 "enforcement": "active",
30 "bypass_mode": "none",
31 "node_id": "nid",
32 "_links": {
33 "self": {
34 "href": "https://api.github.com/orgs/o/rulesets/26110"
35 }
36 }
37 }]`)
38 })
39
40 ctx := context.Background()
41 rulesets, _, err := client.Organizations.GetAllOrganizationRulesets(ctx, "o")
42 if err != nil {
43 t.Errorf("Organizations.GetAllOrganizationRulesets returned error: %v", err)
44 }
45
46 want := []*Ruleset{{
47 ID: Int64(26110),
48 Name: "test ruleset",
49 Target: String("branch"),
50 SourceType: String("Organization"),
51 Source: "o",
52 Enforcement: "active",
53 NodeID: String("nid"),
54 Links: &RulesetLinks{
55 Self: &RulesetLink{HRef: String("https://api.github.com/orgs/o/rulesets/26110")},
56 },
57 }}
58 if !cmp.Equal(rulesets, want) {
59 t.Errorf("Organizations.GetAllOrganizationRulesets returned %+v, want %+v", rulesets, want)
60 }
61
62 const methodName = "GetAllOrganizationRulesets"
63
64 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
65 got, resp, err := client.Organizations.GetAllOrganizationRulesets(ctx, "o")
66 if got != nil {
67 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
68 }
69 return resp, err
70 })
71 }
72
73 func TestOrganizationsService_CreateOrganizationRuleset_RepoNames(t *testing.T) {
74 client, mux, _, teardown := setup()
75 defer teardown()
76
77 mux.HandleFunc("/orgs/o/rulesets", func(w http.ResponseWriter, r *http.Request) {
78 testMethod(t, r, "POST")
79 fmt.Fprint(w, `{
80 "id": 21,
81 "name": "ruleset",
82 "target": "branch",
83 "source_type": "Organization",
84 "source": "o",
85 "enforcement": "active",
86 "bypass_actors": [
87 {
88 "actor_id": 234,
89 "actor_type": "Team"
90 }
91 ],
92 "conditions": {
93 "ref_name": {
94 "include": [
95 "refs/heads/main",
96 "refs/heads/master"
97 ],
98 "exclude": [
99 "refs/heads/dev*"
100 ]
101 },
102 "repository_name": {
103 "include": [
104 "important_repository",
105 "another_important_repository"
106 ],
107 "exclude": [
108 "unimportant_repository"
109 ],
110 "protected": true
111 }
112 },
113 "rules": [
114 {
115 "type": "creation"
116 },
117 {
118 "type": "update",
119 "parameters": {
120 "update_allows_fetch_and_merge": true
121 }
122 },
123 {
124 "type": "deletion"
125 },
126 {
127 "type": "required_linear_history"
128 },
129 {
130 "type": "required_deployments",
131 "parameters": {
132 "required_deployment_environments": ["test"]
133 }
134 },
135 {
136 "type": "required_signatures"
137 },
138 {
139 "type": "pull_request",
140 "parameters": {
141 "dismiss_stale_reviews_on_push": true,
142 "require_code_owner_review": true,
143 "require_last_push_approval": true,
144 "required_approving_review_count": 1,
145 "required_review_thread_resolution": true
146 }
147 },
148 {
149 "type": "required_status_checks",
150 "parameters": {
151 "required_status_checks": [
152 {
153 "context": "test",
154 "integration_id": 1
155 }
156 ],
157 "strict_required_status_checks_policy": true
158 }
159 },
160 {
161 "type": "non_fast_forward"
162 },
163 {
164 "type": "commit_message_pattern",
165 "parameters": {
166 "name": "avoid test commits",
167 "negate": true,
168 "operator": "starts_with",
169 "pattern": "[test]"
170 }
171 },
172 {
173 "type": "commit_author_email_pattern",
174 "parameters": {
175 "operator": "contains",
176 "pattern": "github"
177 }
178 },
179 {
180 "type": "committer_email_pattern",
181 "parameters": {
182 "name": "avoid commit emails",
183 "negate": true,
184 "operator": "ends_with",
185 "pattern": "abc"
186 }
187 },
188 {
189 "type": "branch_name_pattern",
190 "parameters": {
191 "name": "avoid branch names",
192 "negate": true,
193 "operator": "regex",
194 "pattern": "github$"
195 }
196 },
197 {
198 "type": "tag_name_pattern",
199 "parameters": {
200 "name": "avoid tag names",
201 "negate": true,
202 "operator": "contains",
203 "pattern": "github"
204 }
205 }
206 ]
207 }`)
208 })
209
210 ctx := context.Background()
211 ruleset, _, err := client.Organizations.CreateOrganizationRuleset(ctx, "o", &Ruleset{
212 ID: Int64(21),
213 Name: "ruleset",
214 Target: String("branch"),
215 SourceType: String("Organization"),
216 Source: "o",
217 Enforcement: "active",
218 BypassActors: []*BypassActor{
219 {
220 ActorID: Int64(234),
221 ActorType: String("Team"),
222 },
223 },
224 Conditions: &RulesetConditions{
225 RefName: &RulesetRefConditionParameters{
226 Include: []string{"refs/heads/main", "refs/heads/master"},
227 Exclude: []string{"refs/heads/dev*"},
228 },
229 RepositoryName: &RulesetRepositoryNamesConditionParameters{
230 Include: []string{"important_repository", "another_important_repository"},
231 Exclude: []string{"unimportant_repository"},
232 Protected: Bool(true),
233 },
234 },
235 Rules: []*RepositoryRule{
236 NewCreationRule(),
237 NewUpdateRule(&UpdateAllowsFetchAndMergeRuleParameters{
238 UpdateAllowsFetchAndMerge: true,
239 }),
240 NewDeletionRule(),
241 NewRequiredLinearHistoryRule(),
242 NewRequiredDeploymentsRule(&RequiredDeploymentEnvironmentsRuleParameters{
243 RequiredDeploymentEnvironments: []string{"test"},
244 }),
245 NewRequiredSignaturesRule(),
246 NewPullRequestRule(&PullRequestRuleParameters{
247 RequireCodeOwnerReview: true,
248 RequireLastPushApproval: true,
249 RequiredApprovingReviewCount: 1,
250 RequiredReviewThreadResolution: true,
251 DismissStaleReviewsOnPush: true,
252 }),
253 NewRequiredStatusChecksRule(&RequiredStatusChecksRuleParameters{
254 RequiredStatusChecks: []RuleRequiredStatusChecks{
255 {
256 Context: "test",
257 IntegrationID: Int64(1),
258 },
259 },
260 StrictRequiredStatusChecksPolicy: true,
261 }),
262 NewNonFastForwardRule(),
263 NewCommitMessagePatternRule(&RulePatternParameters{
264 Name: String("avoid test commits"),
265 Negate: Bool(true),
266 Operator: "starts_with",
267 Pattern: "[test]",
268 }),
269 NewCommitAuthorEmailPatternRule(&RulePatternParameters{
270 Operator: "contains",
271 Pattern: "github",
272 }),
273 NewCommitterEmailPatternRule(&RulePatternParameters{
274 Name: String("avoid commit emails"),
275 Negate: Bool(true),
276 Operator: "ends_with",
277 Pattern: "abc",
278 }),
279 NewBranchNamePatternRule(&RulePatternParameters{
280 Name: String("avoid branch names"),
281 Negate: Bool(true),
282 Operator: "regex",
283 Pattern: "github$",
284 }),
285 NewTagNamePatternRule(&RulePatternParameters{
286 Name: String("avoid tag names"),
287 Negate: Bool(true),
288 Operator: "contains",
289 Pattern: "github",
290 }),
291 },
292 })
293 if err != nil {
294 t.Errorf("Organizations.CreateOrganizationRuleset returned error: %v", err)
295 }
296
297 want := &Ruleset{
298 ID: Int64(21),
299 Name: "ruleset",
300 Target: String("branch"),
301 SourceType: String("Organization"),
302 Source: "o",
303 Enforcement: "active",
304 BypassActors: []*BypassActor{
305 {
306 ActorID: Int64(234),
307 ActorType: String("Team"),
308 },
309 },
310 Conditions: &RulesetConditions{
311 RefName: &RulesetRefConditionParameters{
312 Include: []string{"refs/heads/main", "refs/heads/master"},
313 Exclude: []string{"refs/heads/dev*"},
314 },
315 RepositoryName: &RulesetRepositoryNamesConditionParameters{
316 Include: []string{"important_repository", "another_important_repository"},
317 Exclude: []string{"unimportant_repository"},
318 Protected: Bool(true),
319 },
320 },
321 Rules: []*RepositoryRule{
322 NewCreationRule(),
323 NewUpdateRule(&UpdateAllowsFetchAndMergeRuleParameters{
324 UpdateAllowsFetchAndMerge: true,
325 }),
326 NewDeletionRule(),
327 NewRequiredLinearHistoryRule(),
328 NewRequiredDeploymentsRule(&RequiredDeploymentEnvironmentsRuleParameters{
329 RequiredDeploymentEnvironments: []string{"test"},
330 }),
331 NewRequiredSignaturesRule(),
332 NewPullRequestRule(&PullRequestRuleParameters{
333 RequireCodeOwnerReview: true,
334 RequireLastPushApproval: true,
335 RequiredApprovingReviewCount: 1,
336 RequiredReviewThreadResolution: true,
337 DismissStaleReviewsOnPush: true,
338 }),
339 NewRequiredStatusChecksRule(&RequiredStatusChecksRuleParameters{
340 RequiredStatusChecks: []RuleRequiredStatusChecks{
341 {
342 Context: "test",
343 IntegrationID: Int64(1),
344 },
345 },
346 StrictRequiredStatusChecksPolicy: true,
347 }),
348 NewNonFastForwardRule(),
349 NewCommitMessagePatternRule(&RulePatternParameters{
350 Name: String("avoid test commits"),
351 Negate: Bool(true),
352 Operator: "starts_with",
353 Pattern: "[test]",
354 }),
355 NewCommitAuthorEmailPatternRule(&RulePatternParameters{
356 Operator: "contains",
357 Pattern: "github",
358 }),
359 NewCommitterEmailPatternRule(&RulePatternParameters{
360 Name: String("avoid commit emails"),
361 Negate: Bool(true),
362 Operator: "ends_with",
363 Pattern: "abc",
364 }),
365 NewBranchNamePatternRule(&RulePatternParameters{
366 Name: String("avoid branch names"),
367 Negate: Bool(true),
368 Operator: "regex",
369 Pattern: "github$",
370 }),
371 NewTagNamePatternRule(&RulePatternParameters{
372 Name: String("avoid tag names"),
373 Negate: Bool(true),
374 Operator: "contains",
375 Pattern: "github",
376 }),
377 },
378 }
379 if !cmp.Equal(ruleset, want) {
380 t.Errorf("Organizations.CreateOrganizationRuleset returned %+v, want %+v", ruleset, want)
381 }
382
383 const methodName = "CreateOrganizationRuleset"
384
385 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
386 got, resp, err := client.Organizations.CreateOrganizationRuleset(ctx, "o", nil)
387 if got != nil {
388 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
389 }
390 return resp, err
391 })
392 }
393
394 func TestOrganizationsService_CreateOrganizationRuleset_RepoIDs(t *testing.T) {
395 client, mux, _, teardown := setup()
396 defer teardown()
397
398 mux.HandleFunc("/orgs/o/rulesets", func(w http.ResponseWriter, r *http.Request) {
399 testMethod(t, r, "POST")
400 fmt.Fprint(w, `{
401 "id": 21,
402 "name": "ruleset",
403 "target": "branch",
404 "source_type": "Organization",
405 "source": "o",
406 "enforcement": "active",
407 "bypass_actors": [
408 {
409 "actor_id": 234,
410 "actor_type": "Team"
411 }
412 ],
413 "conditions": {
414 "ref_name": {
415 "include": [
416 "refs/heads/main",
417 "refs/heads/master"
418 ],
419 "exclude": [
420 "refs/heads/dev*"
421 ]
422 },
423 "repository_id": {
424 "repository_ids": [ 123, 456 ]
425 }
426 },
427 "rules": [
428 {
429 "type": "creation"
430 },
431 {
432 "type": "update",
433 "parameters": {
434 "update_allows_fetch_and_merge": true
435 }
436 },
437 {
438 "type": "deletion"
439 },
440 {
441 "type": "required_linear_history"
442 },
443 {
444 "type": "required_deployments",
445 "parameters": {
446 "required_deployment_environments": ["test"]
447 }
448 },
449 {
450 "type": "required_signatures"
451 },
452 {
453 "type": "pull_request",
454 "parameters": {
455 "dismiss_stale_reviews_on_push": true,
456 "require_code_owner_review": true,
457 "require_last_push_approval": true,
458 "required_approving_review_count": 1,
459 "required_review_thread_resolution": true
460 }
461 },
462 {
463 "type": "required_status_checks",
464 "parameters": {
465 "required_status_checks": [
466 {
467 "context": "test",
468 "integration_id": 1
469 }
470 ],
471 "strict_required_status_checks_policy": true
472 }
473 },
474 {
475 "type": "non_fast_forward"
476 },
477 {
478 "type": "commit_message_pattern",
479 "parameters": {
480 "name": "avoid test commits",
481 "negate": true,
482 "operator": "starts_with",
483 "pattern": "[test]"
484 }
485 },
486 {
487 "type": "commit_author_email_pattern",
488 "parameters": {
489 "operator": "contains",
490 "pattern": "github"
491 }
492 },
493 {
494 "type": "committer_email_pattern",
495 "parameters": {
496 "name": "avoid commit emails",
497 "negate": true,
498 "operator": "ends_with",
499 "pattern": "abc"
500 }
501 },
502 {
503 "type": "branch_name_pattern",
504 "parameters": {
505 "name": "avoid branch names",
506 "negate": true,
507 "operator": "regex",
508 "pattern": "github$"
509 }
510 },
511 {
512 "type": "tag_name_pattern",
513 "parameters": {
514 "name": "avoid tag names",
515 "negate": true,
516 "operator": "contains",
517 "pattern": "github"
518 }
519 }
520 ]
521 }`)
522 })
523
524 ctx := context.Background()
525 ruleset, _, err := client.Organizations.CreateOrganizationRuleset(ctx, "o", &Ruleset{
526 ID: Int64(21),
527 Name: "ruleset",
528 Target: String("branch"),
529 SourceType: String("Organization"),
530 Source: "o",
531 Enforcement: "active",
532 BypassActors: []*BypassActor{
533 {
534 ActorID: Int64(234),
535 ActorType: String("Team"),
536 },
537 },
538 Conditions: &RulesetConditions{
539 RefName: &RulesetRefConditionParameters{
540 Include: []string{"refs/heads/main", "refs/heads/master"},
541 Exclude: []string{"refs/heads/dev*"},
542 },
543 RepositoryID: &RulesetRepositoryIDsConditionParameters{
544 RepositoryIDs: []int64{123, 456},
545 },
546 },
547 Rules: []*RepositoryRule{
548 NewCreationRule(),
549 NewUpdateRule(&UpdateAllowsFetchAndMergeRuleParameters{
550 UpdateAllowsFetchAndMerge: true,
551 }),
552 NewDeletionRule(),
553 NewRequiredLinearHistoryRule(),
554 NewRequiredDeploymentsRule(&RequiredDeploymentEnvironmentsRuleParameters{
555 RequiredDeploymentEnvironments: []string{"test"},
556 }),
557 NewRequiredSignaturesRule(),
558 NewPullRequestRule(&PullRequestRuleParameters{
559 RequireCodeOwnerReview: true,
560 RequireLastPushApproval: true,
561 RequiredApprovingReviewCount: 1,
562 RequiredReviewThreadResolution: true,
563 DismissStaleReviewsOnPush: true,
564 }),
565 NewRequiredStatusChecksRule(&RequiredStatusChecksRuleParameters{
566 RequiredStatusChecks: []RuleRequiredStatusChecks{
567 {
568 Context: "test",
569 IntegrationID: Int64(1),
570 },
571 },
572 StrictRequiredStatusChecksPolicy: true,
573 }),
574 NewNonFastForwardRule(),
575 NewCommitMessagePatternRule(&RulePatternParameters{
576 Name: String("avoid test commits"),
577 Negate: Bool(true),
578 Operator: "starts_with",
579 Pattern: "[test]",
580 }),
581 NewCommitAuthorEmailPatternRule(&RulePatternParameters{
582 Operator: "contains",
583 Pattern: "github",
584 }),
585 NewCommitterEmailPatternRule(&RulePatternParameters{
586 Name: String("avoid commit emails"),
587 Negate: Bool(true),
588 Operator: "ends_with",
589 Pattern: "abc",
590 }),
591 NewBranchNamePatternRule(&RulePatternParameters{
592 Name: String("avoid branch names"),
593 Negate: Bool(true),
594 Operator: "regex",
595 Pattern: "github$",
596 }),
597 NewTagNamePatternRule(&RulePatternParameters{
598 Name: String("avoid tag names"),
599 Negate: Bool(true),
600 Operator: "contains",
601 Pattern: "github",
602 }),
603 },
604 })
605 if err != nil {
606 t.Errorf("Organizations.CreateOrganizationRuleset returned error: %v", err)
607 }
608
609 want := &Ruleset{
610 ID: Int64(21),
611 Name: "ruleset",
612 Target: String("branch"),
613 SourceType: String("Organization"),
614 Source: "o",
615 Enforcement: "active",
616 BypassActors: []*BypassActor{
617 {
618 ActorID: Int64(234),
619 ActorType: String("Team"),
620 },
621 },
622 Conditions: &RulesetConditions{
623 RefName: &RulesetRefConditionParameters{
624 Include: []string{"refs/heads/main", "refs/heads/master"},
625 Exclude: []string{"refs/heads/dev*"},
626 },
627 RepositoryID: &RulesetRepositoryIDsConditionParameters{
628 RepositoryIDs: []int64{123, 456},
629 },
630 },
631 Rules: []*RepositoryRule{
632 NewCreationRule(),
633 NewUpdateRule(&UpdateAllowsFetchAndMergeRuleParameters{
634 UpdateAllowsFetchAndMerge: true,
635 }),
636 NewDeletionRule(),
637 NewRequiredLinearHistoryRule(),
638 NewRequiredDeploymentsRule(&RequiredDeploymentEnvironmentsRuleParameters{
639 RequiredDeploymentEnvironments: []string{"test"},
640 }),
641 NewRequiredSignaturesRule(),
642 NewPullRequestRule(&PullRequestRuleParameters{
643 RequireCodeOwnerReview: true,
644 RequireLastPushApproval: true,
645 RequiredApprovingReviewCount: 1,
646 RequiredReviewThreadResolution: true,
647 DismissStaleReviewsOnPush: true,
648 }),
649 NewRequiredStatusChecksRule(&RequiredStatusChecksRuleParameters{
650 RequiredStatusChecks: []RuleRequiredStatusChecks{
651 {
652 Context: "test",
653 IntegrationID: Int64(1),
654 },
655 },
656 StrictRequiredStatusChecksPolicy: true,
657 }),
658 NewNonFastForwardRule(),
659 NewCommitMessagePatternRule(&RulePatternParameters{
660 Name: String("avoid test commits"),
661 Negate: Bool(true),
662 Operator: "starts_with",
663 Pattern: "[test]",
664 }),
665 NewCommitAuthorEmailPatternRule(&RulePatternParameters{
666 Operator: "contains",
667 Pattern: "github",
668 }),
669 NewCommitterEmailPatternRule(&RulePatternParameters{
670 Name: String("avoid commit emails"),
671 Negate: Bool(true),
672 Operator: "ends_with",
673 Pattern: "abc",
674 }),
675 NewBranchNamePatternRule(&RulePatternParameters{
676 Name: String("avoid branch names"),
677 Negate: Bool(true),
678 Operator: "regex",
679 Pattern: "github$",
680 }),
681 NewTagNamePatternRule(&RulePatternParameters{
682 Name: String("avoid tag names"),
683 Negate: Bool(true),
684 Operator: "contains",
685 Pattern: "github",
686 }),
687 },
688 }
689 if !cmp.Equal(ruleset, want) {
690 t.Errorf("Organizations.CreateOrganizationRuleset returned %+v, want %+v", ruleset, want)
691 }
692
693 const methodName = "CreateOrganizationRuleset"
694
695 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
696 got, resp, err := client.Organizations.CreateOrganizationRuleset(ctx, "o", nil)
697 if got != nil {
698 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
699 }
700 return resp, err
701 })
702 }
703
704 func TestOrganizationsService_GetOrganizationRuleset(t *testing.T) {
705 client, mux, _, teardown := setup()
706 defer teardown()
707
708 mux.HandleFunc("/orgs/o/rulesets/26110", func(w http.ResponseWriter, r *http.Request) {
709 testMethod(t, r, "GET")
710 fmt.Fprint(w, `{
711 "id": 26110,
712 "name": "test ruleset",
713 "target": "branch",
714 "source_type": "Organization",
715 "source": "o",
716 "enforcement": "active",
717 "bypass_mode": "none",
718 "node_id": "nid",
719 "_links": {
720 "self": {
721 "href": "https://api.github.com/orgs/o/rulesets/26110"
722 }
723 },
724 "conditions": {
725 "ref_name": {
726 "include": [
727 "refs/heads/main",
728 "refs/heads/master"
729 ],
730 "exclude": [
731 "refs/heads/dev*"
732 ]
733 },
734 "repository_name": {
735 "include": [
736 "important_repository",
737 "another_important_repository"
738 ],
739 "exclude": [
740 "unimportant_repository"
741 ],
742 "protected": true
743 }
744 },
745 "rules": [
746 {
747 "type": "creation"
748 }
749 ]
750 }`)
751 })
752
753 ctx := context.Background()
754 rulesets, _, err := client.Organizations.GetOrganizationRuleset(ctx, "o", 26110)
755 if err != nil {
756 t.Errorf("Organizations.GetOrganizationRepositoryRuleset returned error: %v", err)
757 }
758
759 want := &Ruleset{
760 ID: Int64(26110),
761 Name: "test ruleset",
762 Target: String("branch"),
763 SourceType: String("Organization"),
764 Source: "o",
765 Enforcement: "active",
766 NodeID: String("nid"),
767 Links: &RulesetLinks{
768 Self: &RulesetLink{HRef: String("https://api.github.com/orgs/o/rulesets/26110")},
769 },
770 Conditions: &RulesetConditions{
771 RefName: &RulesetRefConditionParameters{
772 Include: []string{"refs/heads/main", "refs/heads/master"},
773 Exclude: []string{"refs/heads/dev*"},
774 },
775 RepositoryName: &RulesetRepositoryNamesConditionParameters{
776 Include: []string{"important_repository", "another_important_repository"},
777 Exclude: []string{"unimportant_repository"},
778 Protected: Bool(true),
779 },
780 },
781 Rules: []*RepositoryRule{
782 NewCreationRule(),
783 },
784 }
785 if !cmp.Equal(rulesets, want) {
786 t.Errorf("Organizations.GetOrganizationRuleset returned %+v, want %+v", rulesets, want)
787 }
788
789 const methodName = "GetOrganizationRuleset"
790
791 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
792 got, resp, err := client.Organizations.GetOrganizationRuleset(ctx, "o", 26110)
793 if got != nil {
794 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
795 }
796 return resp, err
797 })
798 }
799
800 func TestOrganizationsService_UpdateOrganizationRuleset(t *testing.T) {
801 client, mux, _, teardown := setup()
802 defer teardown()
803
804 mux.HandleFunc("/orgs/o/rulesets/26110", func(w http.ResponseWriter, r *http.Request) {
805 testMethod(t, r, "PUT")
806 fmt.Fprint(w, `{
807 "id": 26110,
808 "name": "test ruleset",
809 "target": "branch",
810 "source_type": "Organization",
811 "source": "o",
812 "enforcement": "active",
813 "bypass_mode": "none",
814 "node_id": "nid",
815 "_links": {
816 "self": {
817 "href": "https://api.github.com/orgs/o/rulesets/26110"
818 }
819 },
820 "conditions": {
821 "ref_name": {
822 "include": [
823 "refs/heads/main",
824 "refs/heads/master"
825 ],
826 "exclude": [
827 "refs/heads/dev*"
828 ]
829 },
830 "repository_name": {
831 "include": [
832 "important_repository",
833 "another_important_repository"
834 ],
835 "exclude": [
836 "unimportant_repository"
837 ],
838 "protected": true
839 }
840 },
841 "rules": [
842 {
843 "type": "creation"
844 }
845 ]
846 }`)
847 })
848
849 ctx := context.Background()
850 rulesets, _, err := client.Organizations.UpdateOrganizationRuleset(ctx, "o", 26110, &Ruleset{
851 Name: "test ruleset",
852 Target: String("branch"),
853 Enforcement: "active",
854 Conditions: &RulesetConditions{
855 RefName: &RulesetRefConditionParameters{
856 Include: []string{"refs/heads/main", "refs/heads/master"},
857 Exclude: []string{"refs/heads/dev*"},
858 },
859 RepositoryName: &RulesetRepositoryNamesConditionParameters{
860 Include: []string{"important_repository", "another_important_repository"},
861 Exclude: []string{"unimportant_repository"},
862 Protected: Bool(true),
863 },
864 },
865 Rules: []*RepositoryRule{
866 NewCreationRule(),
867 },
868 })
869
870 if err != nil {
871 t.Errorf("Organizations.UpdateOrganizationRuleset returned error: %v", err)
872 }
873
874 want := &Ruleset{
875 ID: Int64(26110),
876 Name: "test ruleset",
877 Target: String("branch"),
878 SourceType: String("Organization"),
879 Source: "o",
880 Enforcement: "active",
881 NodeID: String("nid"),
882 Links: &RulesetLinks{
883 Self: &RulesetLink{HRef: String("https://api.github.com/orgs/o/rulesets/26110")},
884 },
885 Conditions: &RulesetConditions{
886 RefName: &RulesetRefConditionParameters{
887 Include: []string{"refs/heads/main", "refs/heads/master"},
888 Exclude: []string{"refs/heads/dev*"},
889 },
890 RepositoryName: &RulesetRepositoryNamesConditionParameters{
891 Include: []string{"important_repository", "another_important_repository"},
892 Exclude: []string{"unimportant_repository"},
893 Protected: Bool(true),
894 },
895 },
896 Rules: []*RepositoryRule{
897 NewCreationRule(),
898 },
899 }
900 if !cmp.Equal(rulesets, want) {
901 t.Errorf("Organizations.UpdateOrganizationRuleset returned %+v, want %+v", rulesets, want)
902 }
903
904 const methodName = "UpdateOrganizationRuleset"
905
906 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
907 got, resp, err := client.Organizations.UpdateOrganizationRuleset(ctx, "o", 26110, nil)
908 if got != nil {
909 t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got)
910 }
911 return resp, err
912 })
913 }
914
915 func TestOrganizationsService_DeleteOrganizationRuleset(t *testing.T) {
916 client, mux, _, teardown := setup()
917 defer teardown()
918
919 mux.HandleFunc("/orgs/o/rulesets/26110", func(w http.ResponseWriter, r *http.Request) {
920 testMethod(t, r, "DELETE")
921 })
922
923 ctx := context.Background()
924 _, err := client.Organizations.DeleteOrganizationRuleset(ctx, "o", 26110)
925 if err != nil {
926 t.Errorf("Organizations.DeleteOrganizationRuleset returned error: %v", err)
927 }
928
929 const methodName = "DeleteOrganizationRuleset"
930
931 testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
932 return client.Organizations.DeleteOrganizationRuleset(ctx, "0", 26110)
933 })
934 }
935
View as plain text