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
+176 −345
Merged

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

Show file tree
Hide file tree
Changes from all commits
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
27 changes: 0 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,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
Expand Down
123 changes: 56 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 @@ -6,6 +6,7 @@
package github

import (
"encoding/json"
"fmt"
"net/http"
"testing"
Expand Down Expand Up @@ -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)
Expand Down Expand Up @@ -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)
Expand Down
27 changes: 0 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,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
Expand Down
85 changes: 49 additions & 36 deletions github/orgs_rules_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -6,6 +6,7 @@
package github

import (
"encoding/json"
"fmt"
"net/http"
"testing"
Expand Down Expand Up @@ -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) {
Expand Down
Loading
Loading