Skip to content

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

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
gmlewis merged 4 commits into from
Dec 23, 2025
Merged

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

Show file tree
Hide file tree
Changes from 1 commit
Commits
Show all changes
4 commits
Select commit Hold shift + click to select a range
896a9d8
github: use omitzero for RepositoryRuleset.BypassActors
maishivamhoo123 Dec 22, 2025
b554c5a
test: add tests for omitzero behavior on BypassActors
maishivamhoo123 Dec 23, 2025
5775ee8
Address review comments: remove artifact comments and fix meta tags
maishivamhoo123 Dec 23, 2025
1493c7d
Update github/repos_rules_test.go
maishivamhoo123 Dec 23, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
30 changes: 3 additions & 27 deletions github/enterprise_rules.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -76,38 +76,14 @@ 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 API docs: https://docs.github.com/enterprise-cloud@latest/rest/enterprise-admin/rules#update-an-enterprise-repository-ruleset
//
//meta:operation DELETE /enterprises/{enterprise}/rulesets/{ruleset_id}
//meta:operation PUT /enterprises/{enterprise}/rulesets/{ruleset_id}
Comment thread
maishivamhoo123 marked this conversation as resolved.
Outdated
func (s *EnterpriseService) DeleteRepositoryRuleset(ctx context.Context, enterprise string, rulesetID int64) (*Response, error) {
u := fmt.Sprintf("enterprises/%v/rulesets/%v", enterprise, rulesetID)

Expand Down
67 changes: 0 additions & 67 deletions github/enterprise_rules_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1769,73 +1769,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)
Expand Down
30 changes: 3 additions & 27 deletions github/orgs_rules.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -103,38 +103,14 @@ 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 API docs: https://docs.github.com/rest/orgs/rules#update-an-organization-repository-ruleset
//
//meta:operation DELETE /orgs/{org}/rulesets/{ruleset_id}
//meta:operation PUT /orgs/{org}/rulesets/{ruleset_id}
func (s *OrganizationsService) DeleteRepositoryRuleset(ctx context.Context, org string, rulesetID int64) (*Response, error) {
u := fmt.Sprintf("orgs/%v/rulesets/%v", org, rulesetID)

Expand Down
58 changes: 0 additions & 58 deletions github/orgs_rules_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -1587,64 +1587,6 @@ func TestOrganizationsService_UpdateRepositoryRulesetWithRepoProp(t *testing.T)
})
}

func TestOrganizationsService_UpdateRepositoryRulesetClearBypassActor(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")
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"
}
]
}`)
})

ctx := t.Context()

_, err := client.Organizations.UpdateRepositoryRulesetClearBypassActor(ctx, "o", 21)
if err != nil {
t.Errorf("Organizations.UpdateRepositoryRulesetClearBypassActor returned error: %v \n", err)
}

const methodName = "UpdateRepositoryRulesetClearBypassActor"

testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) {
return client.Organizations.UpdateRepositoryRulesetClearBypassActor(ctx, "o", 21)
})
}

func TestOrganizationsService_DeleteRepositoryRuleset(t *testing.T) {
t.Parallel()
client, mux, _ := setup(t)
Expand Down
90 changes: 0 additions & 90 deletions github/repos_rules.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -10,29 +10,6 @@ import (
"fmt"
)

// rulesetNoOmitBypassActors represents a GitHub ruleset object. The struct does not omit bypassActors if the field is nil or an empty array is passed.
type rulesetNoOmitBypassActors struct {
ID *int64 `json:"id,omitempty"`
Name string `json:"name"`
Target *RulesetTarget `json:"target,omitempty"`
SourceType *RulesetSourceType `json:"source_type,omitempty"`
Source string `json:"source"`
Enforcement RulesetEnforcement `json:"enforcement"`
BypassActors []*BypassActor `json:"bypass_actors"`
CurrentUserCanBypass *BypassMode `json:"current_user_can_bypass,omitempty"`
NodeID *string `json:"node_id,omitempty"`
Links *RepositoryRulesetLinks `json:"_links,omitempty"`
Conditions *RepositoryRulesetConditions `json:"conditions,omitempty"`
Rules *RepositoryRulesetRules `json:"rules,omitempty"`
UpdatedAt *Timestamp `json:"updated_at,omitempty"`
CreatedAt *Timestamp `json:"created_at,omitempty"`
}

// rulesetClearBypassActors is used to clear the bypass actors when modifying a GitHub ruleset object.
type rulesetClearBypassActors struct {
BypassActors []*BypassActor `json:"bypass_actors"`
}

// GetRulesForBranch gets all the repository rules that apply to the specified branch.
//
// GitHub API docs: https://docs.github.com/rest/repos/rules#get-rules-for-a-branch
Expand Down Expand Up @@ -164,73 +141,6 @@ func (s *RepositoriesService) UpdateRuleset(ctx context.Context, owner, repo str
return rs, resp, nil
}

// UpdateRulesetClearBypassActor clears the bypass actors for a repository ruleset for the specified repository.
//
// This function is necessary as the UpdateRuleset function does not marshal ByPassActor if passed as an empty array.
//
// GitHub API docs: https://docs.github.com/rest/repos/rules#update-a-repository-ruleset
//
//meta:operation PUT /repos/{owner}/{repo}/rulesets/{ruleset_id}
func (s *RepositoriesService) UpdateRulesetClearBypassActor(ctx context.Context, owner, repo string, rulesetID int64) (*Response, error) {
u := fmt.Sprintf("repos/%v/%v/rulesets/%v", owner, repo, 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
}

// UpdateRulesetNoBypassActor updates a repository ruleset for the specified repository.
//
// This function is necessary as the UpdateRuleset function does not marshal ByPassActor if passed as an empty array.
//
// Deprecated: Use UpdateRulesetClearBypassActor instead.
//
// GitHub API docs: https://docs.github.com/rest/repos/rules#update-a-repository-ruleset
//
//meta:operation PUT /repos/{owner}/{repo}/rulesets/{ruleset_id}
func (s *RepositoriesService) UpdateRulesetNoBypassActor(ctx context.Context, owner, repo string, rulesetID int64, ruleset RepositoryRuleset) (*RepositoryRuleset, *Response, error) {
u := fmt.Sprintf("repos/%v/%v/rulesets/%v", owner, repo, rulesetID)

rsNoBypassActor := rulesetNoOmitBypassActors{
ID: ruleset.ID,
Name: ruleset.Name,
Target: ruleset.Target,
SourceType: ruleset.SourceType,
Source: ruleset.Source,
Enforcement: ruleset.Enforcement,
BypassActors: ruleset.BypassActors,
NodeID: ruleset.NodeID,
Links: ruleset.Links,
Conditions: ruleset.Conditions,
Rules: ruleset.Rules,
}

req, err := s.client.NewRequest("PUT", u, rsNoBypassActor)
if err != nil {
return nil, nil, err
}

var rs *RepositoryRuleset
resp, err := s.client.Do(ctx, req, &rs)
if err != nil {
return nil, resp, err
}

return rs, resp, nil
}

// DeleteRuleset deletes a repository ruleset for the specified repository.
//
// GitHub API docs: https://docs.github.com/rest/repos/rules#delete-a-repository-ruleset
Expand Down
Loading
Loading