feat!: Use omitzero for BypassActors to support handling empty arrays (#3891)

BREAKING CHANGE: `UpdateRepositoryRulesetClearBypassActor`, `UpdateRepositoryRulesetClearBypassActor`, `UpdateRulesetClearBypassActor`, and `UpdateRulesetNoBypassActor` have been removed as they are no longer needed.

Author: maishivamhoo123

github/enterprise_rules.go

@@ -76,33 +76,6 @@ func (s *EnterpriseService) UpdateRepositoryRuleset(ctx context.Context, enterpr
 	return rs, resp, nil
 }
 
-// UpdateRepositoryRulesetClearBypassActor clears the bypass actors for a repository ruleset for the specified enterprise.
-//
-// This function is necessary as the UpdateRepositoryRuleset function does not marshal ByPassActor if passed as an empty array.
-//
-// GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/enterprise-admin/rules#update-an-enterprise-repository-ruleset
-//
-//meta:operation PUT /enterprises/{enterprise}/rulesets/{ruleset_id}
-func (s *EnterpriseService) UpdateRepositoryRulesetClearBypassActor(ctx context.Context, enterprise string, rulesetID int64) (*Response, error) {
-	u := fmt.Sprintf("enterprises/%v/rulesets/%v", enterprise, rulesetID)
-
-	rsClearBypassActor := rulesetClearBypassActors{
-		BypassActors: []*BypassActor{},
-	}
-
-	req, err := s.client.NewRequest("PUT", u, rsClearBypassActor)
-	if err != nil {
-		return nil, err
-	}
-
-	resp, err := s.client.Do(ctx, req, nil)
-	if err != nil {
-		return resp, err
-	}
-
-	return resp, nil
-}
-
 // DeleteRepositoryRuleset deletes a repository ruleset from the specified enterprise.
 //
 // GitHub API docs: https://docs.github.com/enterprise-cloud@latest/rest/enterprise-admin/rules#delete-an-enterprise-repository-ruleset

github/enterprise_rules_test.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"encoding/json"
 	"fmt"
 	"net/http"
 	"testing"
@@ -384,6 +385,61 @@ func TestEnterpriseService_CreateRepositoryRuleset_OrgNameRepoName(t *testing.T)
 	})
 }
 
+func TestEnterpriseService_UpdateRepositoryRuleset_OmitZero_Nil(t *testing.T) {
+	t.Parallel()
+	client, mux, _ := setup(t)
+
+	mux.HandleFunc("/enterprises/e/rulesets/84", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "PUT")
+
+		var v map[string]any
+		if err := json.NewDecoder(r.Body).Decode(&v); err != nil {
+			t.Errorf("could not decode body: %v", err)
+		}
+
+		if _, ok := v["bypass_actors"]; ok {
+			t.Error("Request body contained 'bypass_actors', expected it to be omitted")
+		}
+
+		fmt.Fprint(w, `{"id": 84, "name": "test ruleset"}`)
+	})
+
+	ctx := t.Context()
+	input := RepositoryRuleset{
+		Name:         "test ruleset",
+		BypassActors: nil,
+	}
+
+	_, _, err := client.Enterprise.UpdateRepositoryRuleset(ctx, "e", 84, input)
+	if err != nil {
+		t.Errorf("Enterprise.UpdateRepositoryRuleset returned error: %v", err)
+	}
+}
+
+func TestEnterpriseService_UpdateRepositoryRuleset_OmitZero_EmptySlice(t *testing.T) {
+	t.Parallel()
+	client, mux, _ := setup(t)
+
+	mux.HandleFunc("/enterprises/e/rulesets/84", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "PUT")
+
+		testBody(t, r, `{"name":"test ruleset","source":"","enforcement":"","bypass_actors":[]}`+"\n")
+
+		fmt.Fprint(w, `{"id": 84, "name": "test ruleset", "bypass_actors": []}`)
+	})
+
+	ctx := t.Context()
+	input := RepositoryRuleset{
+		Name:         "test ruleset",
+		BypassActors: []*BypassActor{},
+	}
+
+	_, _, err := client.Enterprise.UpdateRepositoryRuleset(ctx, "e", 84, input)
+	if err != nil {
+		t.Errorf("Enterprise.UpdateRepositoryRuleset returned error: %v", err)
+	}
+}
+
 func TestEnterpriseService_CreateRepositoryRuleset_OrgNameRepoProperty(t *testing.T) {
 	t.Parallel()
 	client, mux, _ := setup(t)
@@ -1769,73 +1825,6 @@ func TestEnterpriseService_UpdateRepositoryRuleset(t *testing.T) {
 	})
 }
 
-func TestEnterpriseService_UpdateRepositoryRulesetClearBypassActor(t *testing.T) {
-	t.Parallel()
-	client, mux, _ := setup(t)
-
-	mux.HandleFunc("/enterprises/e/rulesets/84", func(w http.ResponseWriter, r *http.Request) {
-		testMethod(t, r, "PUT")
-		testBody(t, r, `{"bypass_actors":[]}`+"\n")
-		fmt.Fprint(w, `{
-			"id": 84,
-			"name": "test ruleset",
-			"target": "branch",
-			"source_type": "Enterprise",
-			"source": "e",
-			"enforcement": "active",
-			"bypass_mode": "none",
-			"conditions": {
-				"organization_name": {
-					"include": [
-						"important_organization",
-						"another_important_organization"
-					],
-					"exclude": [
-						"unimportant_organization"
-					]
-				},
-			  "repository_name": {
-					"include": [
-						"important_repository",
-						"another_important_repository"
-					],
-					"exclude": [
-						"unimportant_repository"
-					],
-					"protected": true
-				},
-			  "ref_name": {
-					"include": [
-						"refs/heads/main",
-						"refs/heads/master"
-					],
-					"exclude": [
-						"refs/heads/dev*"
-					]
-				}
-			},
-			"rules": [
-			  {
-					"type": "creation"
-			  }
-			]
-		}`)
-	})
-
-	ctx := t.Context()
-
-	_, err := client.Enterprise.UpdateRepositoryRulesetClearBypassActor(ctx, "e", 84)
-	if err != nil {
-		t.Errorf("Enterprise.UpdateRepositoryRulesetClearBypassActor returned error: %v \n", err)
-	}
-
-	const methodName = "UpdateRepositoryRulesetClearBypassActor"
-
-	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
-		return client.Enterprise.UpdateRepositoryRulesetClearBypassActor(ctx, "e", 84)
-	})
-}
-
 func TestEnterpriseService_DeleteRepositoryRuleset(t *testing.T) {
 	t.Parallel()
 	client, mux, _ := setup(t)

github/orgs_rules.go

@@ -103,33 +103,6 @@ func (s *OrganizationsService) UpdateRepositoryRuleset(ctx context.Context, org
 	return rs, resp, nil
 }
 
-// UpdateRepositoryRulesetClearBypassActor clears the bypass actors for a repository ruleset for the specified organization.
-//
-// This function is necessary as the UpdateRepositoryRuleset function does not marshal ByPassActor if passed as an empty array.
-//
-// GitHub API docs: https://docs.github.com/rest/orgs/rules#update-an-organization-repository-ruleset
-//
-//meta:operation PUT /orgs/{org}/rulesets/{ruleset_id}
-func (s *OrganizationsService) UpdateRepositoryRulesetClearBypassActor(ctx context.Context, org string, rulesetID int64) (*Response, error) {
-	u := fmt.Sprintf("orgs/%v/rulesets/%v", org, rulesetID)
-
-	rsClearBypassActor := rulesetClearBypassActors{
-		BypassActors: []*BypassActor{},
-	}
-
-	req, err := s.client.NewRequest("PUT", u, rsClearBypassActor)
-	if err != nil {
-		return nil, err
-	}
-
-	resp, err := s.client.Do(ctx, req, nil)
-	if err != nil {
-		return resp, err
-	}
-
-	return resp, nil
-}
-
 // DeleteRepositoryRuleset deletes a repository ruleset from the specified organization.
 //
 // GitHub API docs: https://docs.github.com/rest/orgs/rules#delete-an-organization-repository-ruleset

github/orgs_rules_test.go

@@ -6,6 +6,7 @@
 package github
 
 import (
+	"encoding/json"
 	"fmt"
 	"net/http"
 	"testing"
@@ -1587,62 +1588,74 @@ func TestOrganizationsService_UpdateRepositoryRulesetWithRepoProp(t *testing.T)
 	})
 }
 
-func TestOrganizationsService_UpdateRepositoryRulesetClearBypassActor(t *testing.T) {
+func TestOrganizationsService_UpdateRepositoryRuleset_OmitZero_Nil(t *testing.T) {
 	t.Parallel()
 	client, mux, _ := setup(t)
 
 	mux.HandleFunc("/orgs/o/rulesets/21", func(w http.ResponseWriter, r *http.Request) {
 		testMethod(t, r, "PUT")
-		testBody(t, r, `{"bypass_actors":[]}`+"\n")
+
+		var v map[string]any
+		if err := json.NewDecoder(r.Body).Decode(&v); err != nil {
+			t.Errorf("could not decode body: %v", err)
+		}
+
+		if _, ok := v["bypass_actors"]; ok {
+			t.Error("Request body contained 'bypass_actors', expected it to be omitted for nil input")
+		}
+
 		fmt.Fprint(w, `{
 			"id": 21,
 			"name": "test ruleset",
-			"target": "branch",
 			"source_type": "Organization",
 			"source": "o",
-			"enforcement": "active",
-			"bypass_mode": "none",
-			"conditions": {
-				"repository_name": {
-					"include": [
-						"important_repository",
-						"another_important_repository"
-					],
-					"exclude": [
-						"unimportant_repository"
-					],
-					"protected": true
-				},
-			  "ref_name": {
-					"include": [
-						"refs/heads/main",
-						"refs/heads/master"
-					],
-					"exclude": [
-						"refs/heads/dev*"
-					]
-				}
-			},
-			"rules": [
-			  {
-					"type": "creation"
-			  }
-			]
+			"enforcement": "active"
 		}`)
 	})
 
 	ctx := t.Context()
+	input := RepositoryRuleset{
+		Name:         "test ruleset",
+		Enforcement:  RulesetEnforcementActive,
+		BypassActors: nil,
+	}
 
-	_, err := client.Organizations.UpdateRepositoryRulesetClearBypassActor(ctx, "o", 21)
+	_, _, err := client.Organizations.UpdateRepositoryRuleset(ctx, "o", 21, input)
 	if err != nil {
-		t.Errorf("Organizations.UpdateRepositoryRulesetClearBypassActor returned error: %v \n", err)
+		t.Errorf("Organizations.UpdateRepositoryRuleset returned error: %v", err)
 	}
+}
 
-	const methodName = "UpdateRepositoryRulesetClearBypassActor"
+func TestOrganizationsService_UpdateRepositoryRuleset_OmitZero_EmptySlice(t *testing.T) {
+	t.Parallel()
+	client, mux, _ := setup(t)
 
-	testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
-		return client.Organizations.UpdateRepositoryRulesetClearBypassActor(ctx, "o", 21)
+	mux.HandleFunc("/orgs/o/rulesets/21", func(w http.ResponseWriter, r *http.Request) {
+		testMethod(t, r, "PUT")
+
+		testBody(t, r, `{"name":"test ruleset","source":"","enforcement":"active","bypass_actors":[]}`+"\n")
+
+		fmt.Fprint(w, `{
+			"id": 21,
+			"name": "test ruleset",
+			"source_type": "Organization",
+			"source": "o",
+			"enforcement": "active",
+			"bypass_actors": []
+		}`)
 	})
+
+	ctx := t.Context()
+	input := RepositoryRuleset{
+		Name:         "test ruleset",
+		Enforcement:  RulesetEnforcementActive,
+		BypassActors: []*BypassActor{},
+	}
+
+	_, _, err := client.Organizations.UpdateRepositoryRuleset(ctx, "o", 21, input)
+	if err != nil {
+		t.Errorf("Organizations.UpdateRepositoryRuleset returned error: %v", err)
+	}
 }
 
 func TestOrganizationsService_DeleteRepositoryRuleset(t *testing.T) {