From 61e08444a5d2eea31fce318e478d9916c24773b0 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tim=20H=C3=A4ring?= Date: Fri, 7 Nov 2025 09:47:00 +0100 Subject: [PATCH 1/8] fix!: correct cardinality --- github/orgs_codesecurity_configurations.go | 4 ++-- .../orgs_codesecurity_configurations_test.go | 20 +++++++++---------- 2 files changed, 12 insertions(+), 12 deletions(-) diff --git a/github/orgs_codesecurity_configurations.go b/github/orgs_codesecurity_configurations.go index b78bbbc28fc..5d329d0bcf8 100644 --- a/github/orgs_codesecurity_configurations.go +++ b/github/orgs_codesecurity_configurations.go @@ -204,12 +204,12 @@ func (s *OrganizationsService) DeleteCodeSecurityConfiguration(ctx context.Conte return resp, nil } -// AttachCodeSecurityConfigurationsToRepositories attaches code security configurations to repositories for an organization. +// AttachCodeSecurityConfigurationToRepositories attaches code security configurations to repositories for an organization. // // GitHub API docs: https://docs.github.com/rest/code-security/configurations#attach-a-configuration-to-repositories // //meta:operation POST /orgs/{org}/code-security/configurations/{configuration_id}/attach -func (s *OrganizationsService) AttachCodeSecurityConfigurationsToRepositories(ctx context.Context, org string, id int64, scope string, repoIDs []int64) (*Response, error) { +func (s *OrganizationsService) AttachCodeSecurityConfigurationToRepositories(ctx context.Context, org string, id int64, scope string, repoIDs []int64) (*Response, error) { u := fmt.Sprintf("orgs/%v/code-security/configurations/%v/attach", org, id) type selectedRepoIDs struct { Scope string `json:"scope"` diff --git a/github/orgs_codesecurity_configurations_test.go b/github/orgs_codesecurity_configurations_test.go index 38034a5982d..5c52c08d135 100644 --- a/github/orgs_codesecurity_configurations_test.go +++ b/github/orgs_codesecurity_configurations_test.go @@ -36,7 +36,7 @@ func TestOrganizationsService_GetCodeSecurityConfigurations(t *testing.T) { configurations, _, err := client.Organizations.GetCodeSecurityConfigurations(ctx, "o") if err != nil { - t.Errorf("Organizations.GetOrganizationCodeSecurityConfigurations returned error: %v", err) + t.Errorf("Organizations.GetCodeSecurityConfigurations returned error: %v", err) } want := []*CodeSecurityConfiguration{ @@ -318,7 +318,7 @@ func TestOrganizationsService_DeleteCodeSecurityConfiguration(t *testing.T) { }) } -func TestOrganizationsService_AttachCodeSecurityConfigurationsToRepositories(t *testing.T) { +func TestOrganizationsService_AttachCodeSecurityConfigurationToRepositories(t *testing.T) { t.Parallel() ctx := t.Context() client, mux, _ := setup(t) @@ -332,32 +332,32 @@ func TestOrganizationsService_AttachCodeSecurityConfigurationsToRepositories(t * v := new(request) assertNilError(t, json.NewDecoder(r.Body).Decode(v)) if v.Scope != "selected" { - t.Errorf("Organizations.AttachCodeSecurityConfigurationsToRepositories request body scope = %v, want selected", v.Scope) + t.Errorf("Organizations.AttachCodeSecurityConfigurationToRepositories request body scope = %v, want selected", v.Scope) } if !cmp.Equal(v.SelectedRepositoryIDs, []int64{5, 20}) { - t.Errorf("Organizations.AttachCodeSecurityConfigurationsToRepositories request body selected_repository_ids = %+v, want %+v", v.SelectedRepositoryIDs, []int64{5, 20}) + t.Errorf("Organizations.AttachCodeSecurityConfigurationToRepositories request body selected_repository_ids = %+v, want %+v", v.SelectedRepositoryIDs, []int64{5, 20}) } w.WriteHeader(http.StatusAccepted) }) - resp, err := client.Organizations.AttachCodeSecurityConfigurationsToRepositories(ctx, "o", int64(1), "selected", []int64{5, 20}) + resp, err := client.Organizations.AttachCodeSecurityConfigurationToRepositories(ctx, "o", int64(1), "selected", []int64{5, 20}) if err != nil { - t.Errorf("Organizations.AttachCodeSecurityConfigurationsToRepositories returned error: %v", err) + t.Errorf("Organizations.AttachCodeSecurityConfigurationToRepositories returned error: %v", err) } want := http.StatusAccepted if resp.StatusCode != want { - t.Errorf("Organizations.AttachCodeSecurityConfigurationsToRepositories returned status %v, want %v", resp.StatusCode, want) + t.Errorf("Organizations.AttachCodeSecurityConfigurationToRepositories returned status %v, want %v", resp.StatusCode, want) } - const methodName = "AttachCodeSecurityConfigurationsToRepositories" + const methodName = "AttachCodeSecurityConfigurationToRepositories" testBadOptions(t, methodName, func() (err error) { - _, err = client.Organizations.AttachCodeSecurityConfigurationsToRepositories(ctx, "\n", -1, "", nil) + _, err = client.Organizations.AttachCodeSecurityConfigurationToRepositories(ctx, "\n", -1, "", nil) return }) testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { - resp, err := client.Organizations.AttachCodeSecurityConfigurationsToRepositories(ctx, "o", 1, "selected", []int64{5, 20}) + resp, err := client.Organizations.AttachCodeSecurityConfigurationToRepositories(ctx, "o", 1, "selected", []int64{5, 20}) return resp, err }) } From a61728d843d06f9066cd8bd742585e811c562e67 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tim=20H=C3=A4ring?= Date: Fri, 7 Nov 2025 09:48:00 +0100 Subject: [PATCH 2/8] feat: enterprise code security configurations --- .../enterprise_codesecurity_configurations.go | 201 ++++++++ ...rprise_codesecurity_configurations_test.go | 430 ++++++++++++++++++ 2 files changed, 631 insertions(+) create mode 100644 github/enterprise_codesecurity_configurations.go create mode 100644 github/enterprise_codesecurity_configurations_test.go diff --git a/github/enterprise_codesecurity_configurations.go b/github/enterprise_codesecurity_configurations.go new file mode 100644 index 00000000000..83c9c5e603a --- /dev/null +++ b/github/enterprise_codesecurity_configurations.go @@ -0,0 +1,201 @@ +// Copyright 2025 The go-github AUTHORS. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package github + +import ( + "context" + "fmt" + "net/http" +) + +// GetCodeSecurityConfigurations lists all code security configurations available in an enterprise. +// +// GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-code-security-configurations-for-an-enterprise +// +//meta:operation GET /enterprises/{enterprise}/code-security/configurations +func (s *EnterpriseService) GetCodeSecurityConfigurations(ctx context.Context, enterprise string) ([]*CodeSecurityConfiguration, *Response, error) { + u := fmt.Sprintf("enterprises/%v/code-security/configurations", enterprise) + + req, err := s.client.NewRequest("GET", u, nil) + if err != nil { + return nil, nil, err + } + + var configurations []*CodeSecurityConfiguration + resp, err := s.client.Do(ctx, req, &configurations) + if err != nil { + return nil, resp, err + } + return configurations, resp, nil +} + +// CreateCodeSecurityConfiguration creates a code security configuration in an enterprise. +// +// GitHub API docs: https://docs.github.com/rest/code-security/configurations#create-a-code-security-configuration-for-an-enterprise +// +//meta:operation POST /enterprises/{enterprise}/code-security/configurations +func (s *EnterpriseService) CreateCodeSecurityConfiguration(ctx context.Context, enterprise string, c *CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) { + u := fmt.Sprintf("enterprises/%v/code-security/configurations", enterprise) + + req, err := s.client.NewRequest("POST", u, c) + if err != nil { + return nil, nil, err + } + + var configuration *CodeSecurityConfiguration + resp, err := s.client.Do(ctx, req, &configuration) + if err != nil { + return nil, resp, err + } + return configuration, resp, nil +} + +// GetDefaultCodeSecurityConfigurations lists the default code security configurations for an enterprise. +// +// GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-default-code-security-configurations-for-an-enterprise +// +//meta:operation GET /enterprises/{enterprise}/code-security/configurations/defaults +func (s *EnterpriseService) GetDefaultCodeSecurityConfigurations(ctx context.Context, enterprise string) ([]*CodeSecurityConfigurationWithDefaultForNewRepos, *Response, error) { + u := fmt.Sprintf("enterprises/%v/code-security/configurations/defaults", enterprise) + + req, err := s.client.NewRequest("GET", u, nil) + if err != nil { + return nil, nil, err + } + + var configurations []*CodeSecurityConfigurationWithDefaultForNewRepos + resp, err := s.client.Do(ctx, req, &configurations) + if err != nil { + return nil, resp, err + } + return configurations, resp, nil +} + +// GetCodeSecurityConfiguration gets a code security configuration available in an enterprise. +// +// GitHub API docs: https://docs.github.com/rest/code-security/configurations#retrieve-a-code-security-configuration-of-an-enterprise +// +//meta:operation GET /enterprises/{enterprise}/code-security/configurations/{configuration_id} +func (s *EnterpriseService) GetCodeSecurityConfiguration(ctx context.Context, enterprise string, id int64) (*CodeSecurityConfiguration, *Response, error) { + u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v", enterprise, id) + + req, err := s.client.NewRequest("GET", u, nil) + if err != nil { + return nil, nil, err + } + + var configuration *CodeSecurityConfiguration + resp, err := s.client.Do(ctx, req, &configuration) + if err != nil { + return nil, resp, err + } + return configuration, resp, nil +} + +// UpdateCodeSecurityConfiguration updates a code security configuration in an enterprise. +// +// GitHub API docs: https://docs.github.com/rest/code-security/configurations#update-a-custom-code-security-configuration-for-an-enterprise +// +//meta:operation PATCH /enterprises/{enterprise}/code-security/configurations/{configuration_id} +func (s *EnterpriseService) UpdateCodeSecurityConfiguration(ctx context.Context, enterprise string, id int64, c *CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) { + u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v", enterprise, id) + + req, err := s.client.NewRequest("PATCH", u, c) + if err != nil { + return nil, nil, err + } + + var configuration *CodeSecurityConfiguration + resp, err := s.client.Do(ctx, req, &configuration) + if err != nil { + return nil, resp, err + } + return configuration, resp, nil +} + +// DeleteCodeSecurityConfiguration deletes a code security configuration from an enterprise. +// +// GitHub API docs: https://docs.github.com/rest/code-security/configurations#delete-a-code-security-configuration-for-an-enterprise +// +//meta:operation DELETE /enterprises/{enterprise}/code-security/configurations/{configuration_id} +func (s *EnterpriseService) DeleteCodeSecurityConfiguration(ctx context.Context, enterprise string, id int64) (*Response, error) { + u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v", enterprise, id) + + req, err := s.client.NewRequest("DELETE", u, nil) + if err != nil { + return nil, err + } + resp, err := s.client.Do(ctx, req, nil) + if err != nil { + return resp, err + } + return resp, nil +} + +// AttachCodeSecurityConfigurationToRepositories attaches an enterprise code security configuration to repositories. +// +// GitHub API docs: https://docs.github.com/rest/code-security/configurations#attach-an-enterprise-configuration-to-repositories +// +//meta:operation POST /enterprises/{enterprise}/code-security/configurations/{configuration_id}/attach +func (s *EnterpriseService) AttachCodeSecurityConfigurationToRepositories(ctx context.Context, enterprise string, id int64, scope string) (*Response, error) { + u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v/attach", enterprise, id) + type scopeType struct { + Scope string `json:"scope"` + } + + req, err := s.client.NewRequest("POST", u, scopeType{Scope: scope}) + if err != nil { + return nil, err + } + resp, err := s.client.Do(ctx, req, nil) + if err != nil && resp.StatusCode != http.StatusAccepted { // StatusAccepted(202) is the expected status code as job is queued for processing + return resp, err + } + return resp, nil +} + +// SetDefaultCodeSecurityConfiguration sets a code security configuration as a default for an enterprise. +// +// GitHub API docs: https://docs.github.com/rest/code-security/configurations#set-a-code-security-configuration-as-a-default-for-an-enterprise +// +//meta:operation PUT /enterprises/{enterprise}/code-security/configurations/{configuration_id}/defaults +func (s *EnterpriseService) SetDefaultCodeSecurityConfiguration(ctx context.Context, enterprise string, id int64, newReposParam string) (*CodeSecurityConfigurationWithDefaultForNewRepos, *Response, error) { + u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v/defaults", enterprise, id) + type configParam struct { + DefaultForNewRepos string `json:"default_for_new_repos"` + } + + req, err := s.client.NewRequest("PUT", u, configParam{DefaultForNewRepos: newReposParam}) + if err != nil { + return nil, nil, err + } + var c *CodeSecurityConfigurationWithDefaultForNewRepos + resp, err := s.client.Do(ctx, req, &c) + if err != nil { + return nil, resp, err + } + return c, resp, nil +} + +// GetRepositoriesForCodeSecurityConfiguration lists the repositories associated with an enterprise code security configuration. +// +// GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-repositories-associated-with-an-enterprise-code-security-configuration +// +//meta:operation GET /enterprises/{enterprise}/code-security/configurations/{configuration_id}/repositories +func (s *EnterpriseService) GetRepositoriesForCodeSecurityConfiguration(ctx context.Context, enterprise string, id int64) ([]*RepositoryAttachment, *Response, error) { + u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v/repositories", enterprise, id) + + req, err := s.client.NewRequest("GET", u, nil) + if err != nil { + return nil, nil, err + } + var attachments []*RepositoryAttachment + resp, err := s.client.Do(ctx, req, &attachments) + if err != nil { + return nil, resp, err + } + return attachments, resp, nil +} diff --git a/github/enterprise_codesecurity_configurations_test.go b/github/enterprise_codesecurity_configurations_test.go new file mode 100644 index 00000000000..48535d67b13 --- /dev/null +++ b/github/enterprise_codesecurity_configurations_test.go @@ -0,0 +1,430 @@ +// Copyright 2024 The go-github AUTHORS. All rights reserved. +// +// Use of this source code is governed by a BSD-style +// license that can be found in the LICENSE file. + +package github + +import ( + "encoding/json" + "fmt" + "net/http" + "testing" + + "github.com/google/go-cmp/cmp" +) + +func TestEnterpriseService_GetCodeSecurityConfigurations(t *testing.T) { + t.Parallel() + ctx := t.Context() + client, mux, _ := setup(t) + + mux.HandleFunc("/enterprises/e/code-security/configurations", func(w http.ResponseWriter, r *http.Request) { + testMethod(t, r, "GET") + fmt.Fprint(w, `[ + { + "id":1, + "name":"config1", + "code_scanning_default_setup": "enabled" + }, + { + "id":2, + "name":"config2", + "private_vulnerability_reporting": "enabled" + }]`) + }) + + configurations, _, err := client.Enterprise.GetCodeSecurityConfigurations(ctx, "e") + if err != nil { + t.Errorf("Enterprise.GetCodeSecurityConfigurations returned error: %v", err) + } + + want := []*CodeSecurityConfiguration{ + {ID: Ptr(int64(1)), Name: Ptr("config1"), CodeScanningDefaultSetup: Ptr("enabled")}, + {ID: Ptr(int64(2)), Name: Ptr("config2"), PrivateVulnerabilityReporting: Ptr("enabled")}, + } + if !cmp.Equal(configurations, want) { + t.Errorf("Enterprise.GetCodeSecurityConfigurations returned %+v, want %+v", configurations, want) + } + const methodName = "GetCodeSecurityConfigurations" + testBadOptions(t, methodName, func() (err error) { + _, _, err = client.Enterprise.GetCodeSecurityConfigurations(ctx, "\n") + return err + }) + testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { + got, resp, err := client.Enterprise.GetCodeSecurityConfigurations(ctx, "e") + if got != nil { + t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) + } + return resp, err + }) +} + +func TestEnterpriseService_GetCodeSecurityConfiguration(t *testing.T) { + t.Parallel() + client, mux, _ := setup(t) + ctx := t.Context() + + mux.HandleFunc("/enterprises/e/code-security/configurations/1", func(w http.ResponseWriter, r *http.Request) { + testMethod(t, r, "GET") + fmt.Fprint(w, `{ + "id":1, + "name":"config1", + "code_scanning_default_setup": "enabled" + }`) + }) + + configuration, _, err := client.Enterprise.GetCodeSecurityConfiguration(ctx, "e", 1) + if err != nil { + t.Errorf("Enterprise.GetCodeSecurityConfiguration returned error: %v", err) + } + + want := &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: Ptr("config1"), CodeScanningDefaultSetup: Ptr("enabled")} + if !cmp.Equal(configuration, want) { + t.Errorf("Enterprise.GetCodeSecurityConfiguration returned %+v, want %+v", configuration, want) + } + + const methodName = "GetCodeSecurityConfiguration" + testBadOptions(t, methodName, func() (err error) { + _, _, err = client.Enterprise.GetCodeSecurityConfiguration(ctx, "\n", -1) + return err + }) + + testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { + got, resp, err := client.Enterprise.GetCodeSecurityConfiguration(ctx, "e", 1) + if got != nil { + t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) + } + return resp, err + }) +} + +func TestEnterpriseService_CreateCodeSecurityConfiguration(t *testing.T) { + t.Parallel() + client, mux, _ := setup(t) + ctx := t.Context() + + input := &CodeSecurityConfiguration{ + Name: Ptr("config1"), + CodeScanningDefaultSetup: Ptr("enabled"), + } + + mux.HandleFunc("/enterprises/e/code-security/configurations", func(w http.ResponseWriter, r *http.Request) { + v := new(CodeSecurityConfiguration) + assertNilError(t, json.NewDecoder(r.Body).Decode(v)) + + if !cmp.Equal(v, input) { + t.Errorf("Enterprise.CreateCodeSecurityConfiguration request body = %+v, want %+v", v, input) + } + + fmt.Fprint(w, `{ + "id":1, + "name":"config1", + "code_scanning_default_setup": "enabled" + }`) + }) + + configuration, _, err := client.Enterprise.CreateCodeSecurityConfiguration(ctx, "e", input) + if err != nil { + t.Errorf("Enterprise.CreateCodeSecurityConfiguration returned error: %v", err) + } + + want := &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: Ptr("config1"), CodeScanningDefaultSetup: Ptr("enabled")} + if !cmp.Equal(configuration, want) { + t.Errorf("Enterprise.CreateCodeSecurityConfiguration returned %+v, want %+v", configuration, want) + } + + const methodName = "CreateCodeSecurityConfiguration" + testBadOptions(t, methodName, func() (err error) { + _, _, err = client.Enterprise.CreateCodeSecurityConfiguration(ctx, "\n", input) + return err + }) + + testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { + got, resp, err := client.Enterprise.CreateCodeSecurityConfiguration(ctx, "e", input) + if got != nil { + t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) + } + return resp, err + }) +} + +func TestEnterpriseService_GetDefaultCodeSecurityConfigurations(t *testing.T) { + t.Parallel() + client, mux, _ := setup(t) + ctx := t.Context() + + mux.HandleFunc("/enterprises/e/code-security/configurations/defaults", func(w http.ResponseWriter, r *http.Request) { + testMethod(t, r, "GET") + fmt.Fprint(w, `[ + { + "default_for_new_repos": "public", + "configuration": { + "id":1, + "name":"config1", + "code_scanning_default_setup": "enabled" + } + }, + { + "default_for_new_repos": "private_and_internal", + "configuration": { + "id":2, + "name":"config2", + "private_vulnerability_reporting": "enabled" + } + } + ]`) + }) + + configurations, _, err := client.Enterprise.GetDefaultCodeSecurityConfigurations(ctx, "e") + if err != nil { + t.Errorf("Enterprise.GetDefaultCodeSecurityConfigurations returned error: %v", err) + } + + want := []*CodeSecurityConfigurationWithDefaultForNewRepos{ + {DefaultForNewRepos: Ptr("public"), Configuration: &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: Ptr("config1"), CodeScanningDefaultSetup: Ptr("enabled")}}, + {DefaultForNewRepos: Ptr("private_and_internal"), Configuration: &CodeSecurityConfiguration{ID: Ptr(int64(2)), Name: Ptr("config2"), PrivateVulnerabilityReporting: Ptr("enabled")}}, + } + if !cmp.Equal(configurations, want) { + t.Errorf("Enterprise.GetDefaultCodeSecurityConfigurations returned %+v, want %+v", configurations, want) + } + + const methodName = "GetDefaultCodeSecurityConfigurations" + testBadOptions(t, methodName, func() (err error) { + _, _, err = client.Enterprise.GetDefaultCodeSecurityConfigurations(ctx, "\n") + return err + }) + + testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { + got, resp, err := client.Enterprise.GetDefaultCodeSecurityConfigurations(ctx, "e") + if got != nil { + t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) + } + return resp, err + }) +} + +func TestEnterpriseService_UpdateCodeSecurityConfiguration(t *testing.T) { + t.Parallel() + ctx := t.Context() + client, mux, _ := setup(t) + + input := &CodeSecurityConfiguration{ + Name: Ptr("config1"), + CodeScanningDefaultSetup: Ptr("enabled"), + } + + mux.HandleFunc("/enterprises/e/code-security/configurations/1", func(w http.ResponseWriter, r *http.Request) { + v := new(CodeSecurityConfiguration) + assertNilError(t, json.NewDecoder(r.Body).Decode(v)) + + if !cmp.Equal(v, input) { + t.Errorf("Enterprise.UpdateCodeSecurityConfiguration request body = %+v, want %+v", v, input) + } + + fmt.Fprint(w, `{ + "id":1, + "name":"config1", + "code_scanning_default_setup": "enabled" + }`) + }) + + configuration, _, err := client.Enterprise.UpdateCodeSecurityConfiguration(ctx, "e", 1, input) + if err != nil { + t.Errorf("Enterprise.UpdateCodeSecurityConfiguration returned error: %v", err) + } + + want := &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: Ptr("config1"), CodeScanningDefaultSetup: Ptr("enabled")} + if !cmp.Equal(configuration, want) { + t.Errorf("Enterprise.UpdateCodeSecurityConfiguration returned %+v, want %+v", configuration, want) + } + + const methodName = "UpdateCodeSecurityConfiguration" + testBadOptions(t, methodName, func() (err error) { + _, _, err = client.Enterprise.UpdateCodeSecurityConfiguration(ctx, "\n", -1, input) + return + }) + + testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { + got, resp, err := client.Enterprise.UpdateCodeSecurityConfiguration(ctx, "e", 1, input) + if got != nil { + t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) + } + return resp, err + }) +} + +func TestEnterpriseService_DeleteCodeSecurityConfiguration(t *testing.T) { + t.Parallel() + ctx := t.Context() + client, mux, _ := setup(t) + + mux.HandleFunc("/enterprises/e/code-security/configurations/1", func(w http.ResponseWriter, r *http.Request) { + testMethod(t, r, "DELETE") + w.WriteHeader(http.StatusNoContent) + }) + + resp, err := client.Enterprise.DeleteCodeSecurityConfiguration(ctx, "e", 1) + if err != nil { + t.Errorf("Enterprise.DeleteCodeSecurityConfiguration returned error: %v", err) + } + + want := http.StatusNoContent + if resp.StatusCode != want { + t.Errorf("Enterprise.DeleteCodeSecurityConfiguration returned status %v, want %v", resp.StatusCode, want) + } + + const methodName = "DeleteCodeSecurityConfiguration" + testBadOptions(t, methodName, func() (err error) { + _, err = client.Enterprise.DeleteCodeSecurityConfiguration(ctx, "\n", -1) + return + }) + + testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { + resp, err := client.Enterprise.DeleteCodeSecurityConfiguration(ctx, "e", 1) + return resp, err + }) +} + +func TestEnterpriseService_AttachCodeSecurityConfigurationToRepositories(t *testing.T) { + t.Parallel() + ctx := t.Context() + client, mux, _ := setup(t) + + mux.HandleFunc("/enterprises/e/code-security/configurations/1/attach", func(w http.ResponseWriter, r *http.Request) { + testMethod(t, r, "POST") + type request struct { + Scope string `json:"scope"` + } + v := new(request) + assertNilError(t, json.NewDecoder(r.Body).Decode(v)) + if v.Scope != "all_without_configurations" { + t.Errorf("Enterprise.AttachCodeSecurityConfigurationToRepositories request body scope = %v, want selected", v.Scope) + } + w.WriteHeader(http.StatusAccepted) + }) + + resp, err := client.Enterprise.AttachCodeSecurityConfigurationToRepositories(ctx, "e", int64(1), "all_without_configurations") + if err != nil { + t.Errorf("Enterprise.AttachCodeSecurityConfigurationToRepositories returned error: %v", err) + } + + want := http.StatusAccepted + if resp.StatusCode != want { + t.Errorf("Enterprise.AttachCodeSecurityConfigurationToRepositories returned status %v, want %v", resp.StatusCode, want) + } + + const methodName = "AttachCodeSecurityConfigurationToRepositories" + testBadOptions(t, methodName, func() (err error) { + _, err = client.Enterprise.AttachCodeSecurityConfigurationToRepositories(ctx, "\n", -1, "") + return + }) + + testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { + resp, err := client.Enterprise.AttachCodeSecurityConfigurationToRepositories(ctx, "e", 1, "all_without_configurations") + return resp, err + }) +} + +func TestEnterpriseService_SetDefaultCodeSecurityConfiguration(t *testing.T) { + t.Parallel() + ctx := t.Context() + client, mux, _ := setup(t) + + mux.HandleFunc("/enterprises/e/code-security/configurations/1/defaults", func(w http.ResponseWriter, r *http.Request) { + testMethod(t, r, "PUT") + fmt.Fprint(w, ` + { + "default_for_new_repos": "all", + "configuration": + { + "id": 1, + "name": "config1", + "code_scanning_default_setup": "enabled" + } + }`) + }) + got, resp, err := client.Enterprise.SetDefaultCodeSecurityConfiguration(ctx, "e", 1, "all") + if err != nil { + t.Errorf("Enterprise.SetDefaultCodeSecurityConfiguration returned error: %v", err) + } + wantStatus := http.StatusOK + if resp.StatusCode != wantStatus { + t.Errorf("Enterprise.SetDefaultCodeSecurityConfiguration returned status %v, want %v", resp.StatusCode, wantStatus) + } + want := &CodeSecurityConfigurationWithDefaultForNewRepos{ + DefaultForNewRepos: Ptr("all"), + Configuration: &CodeSecurityConfiguration{ + ID: Ptr(int64(1)), Name: Ptr("config1"), CodeScanningDefaultSetup: Ptr("enabled"), + }, + } + if !cmp.Equal(got, want) { + t.Errorf("Enterprise.SetDefaultCodeSecurityConfiguration returned %+v, want %+v", got, want) + } + + const methodName = "SetDefaultCodeSecurityConfiguration" + testBadOptions(t, methodName, func() (err error) { + _, _, err = client.Enterprise.SetDefaultCodeSecurityConfiguration(ctx, "\n", -1, "") + return + }) + + testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { + got, resp, err := client.Enterprise.SetDefaultCodeSecurityConfiguration(ctx, "e", 1, "all") + if got != nil { + t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) + } + return resp, err + }) +} + +func TestEnterpriseService_GetRepositoriesForCodeSecurityConfiguration(t *testing.T) { + t.Parallel() + ctx := t.Context() + client, mux, _ := setup(t) + + mux.HandleFunc("/enterprises/e/code-security/configurations/1/repositories", func(w http.ResponseWriter, r *http.Request) { + testMethod(t, r, "GET") + fmt.Fprint(w, `[ + { + "status": "attached", + "repository": { + "id":8, + "name":"repo8" + } + }, + { + "status": "attached", + "repository": { + "id":42, + "name":"repo42" + } + } + ]`) + }) + + attachments, _, err := client.Enterprise.GetRepositoriesForCodeSecurityConfiguration(ctx, "e", 1) + if err != nil { + t.Errorf("Enterprise.GetRepositoriesForCodeSecurityConfiguration returned error: %v", err) + } + want := []*RepositoryAttachment{ + {Status: Ptr("attached"), Repository: &Repository{ID: Ptr(int64(8)), Name: Ptr("repo8")}}, + {Status: Ptr("attached"), Repository: &Repository{ID: Ptr(int64(42)), Name: Ptr("repo42")}}, + } + if !cmp.Equal(attachments, want) { + t.Errorf("Enterprise.GetRepositoriesForCodeSecurityConfiguration returned %+v, want %+v", attachments, want) + } + + const methodName = "GetRepositoriesForCodeSecurityConfiguration" + testBadOptions(t, methodName, func() (err error) { + _, _, err = client.Enterprise.GetRepositoriesForCodeSecurityConfiguration(ctx, "\n", -1) + return + }) + + testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { + got, resp, err := client.Enterprise.GetRepositoriesForCodeSecurityConfiguration(ctx, "e", 1) + if got != nil { + t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) + } + return resp, err + }) +} From a35e7aaf62911d98409c218e510f9dba1272e37d Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tim=20H=C3=A4ring?= Date: Fri, 7 Nov 2025 10:37:07 +0100 Subject: [PATCH 3/8] feat: add new api fields --- github/github-accessors.go | 72 +++++++++++++++++ github/github-accessors_test.go | 93 ++++++++++++++++++++++ github/orgs_codesecurity_configurations.go | 18 +++++ 3 files changed, 183 insertions(+) diff --git a/github/github-accessors.go b/github/github-accessors.go index 6a6ef9c9599..3cd404215f1 100644 --- a/github/github-accessors.go +++ b/github/github-accessors.go @@ -3230,6 +3230,22 @@ func (c *CodeScanningAlertState) GetDismissedReason() string { return *c.DismissedReason } +// GetRunnerLabel returns the RunnerLabel field if it's non-nil, zero value otherwise. +func (c *CodeScanningDefaultSetupOptions) GetRunnerLabel() string { + if c == nil || c.RunnerLabel == nil { + return "" + } + return *c.RunnerLabel +} + +// GetAllowAdvanced returns the AllowAdvanced field if it's non-nil, zero value otherwise. +func (c *CodeScanningOptions) GetAllowAdvanced() bool { + if c == nil || c.AllowAdvanced == nil { + return false + } + return *c.AllowAdvanced +} + // GetIncompleteResults returns the IncompleteResults field if it's non-nil, zero value otherwise. func (c *CodeSearchResult) GetIncompleteResults() bool { if c == nil || c.IncompleteResults == nil { @@ -3262,6 +3278,38 @@ func (c *CodeSecurityConfiguration) GetCodeScanningDefaultSetup() string { return *c.CodeScanningDefaultSetup } +// GetCodeScanningDefaultSetupOptions returns the CodeScanningDefaultSetupOptions field. +func (c *CodeSecurityConfiguration) GetCodeScanningDefaultSetupOptions() *CodeScanningDefaultSetupOptions { + if c == nil { + return nil + } + return c.CodeScanningDefaultSetupOptions +} + +// GetCodeScanningDelegatedAlertDismissal returns the CodeScanningDelegatedAlertDismissal field if it's non-nil, zero value otherwise. +func (c *CodeSecurityConfiguration) GetCodeScanningDelegatedAlertDismissal() string { + if c == nil || c.CodeScanningDelegatedAlertDismissal == nil { + return "" + } + return *c.CodeScanningDelegatedAlertDismissal +} + +// GetCodeScanningOptions returns the CodeScanningOptions field. +func (c *CodeSecurityConfiguration) GetCodeScanningOptions() *CodeScanningOptions { + if c == nil { + return nil + } + return c.CodeScanningOptions +} + +// GetCodeSecurity returns the CodeSecurity field if it's non-nil, zero value otherwise. +func (c *CodeSecurityConfiguration) GetCodeSecurity() string { + if c == nil || c.CodeSecurity == nil { + return "" + } + return *c.CodeSecurity +} + // GetCreatedAt returns the CreatedAt field if it's non-nil, zero value otherwise. func (c *CodeSecurityConfiguration) GetCreatedAt() Timestamp { if c == nil || c.CreatedAt == nil { @@ -3358,6 +3406,14 @@ func (c *CodeSecurityConfiguration) GetPrivateVulnerabilityReporting() string { return *c.PrivateVulnerabilityReporting } +// GetSecretProtection returns the SecretProtection field if it's non-nil, zero value otherwise. +func (c *CodeSecurityConfiguration) GetSecretProtection() string { + if c == nil || c.SecretProtection == nil { + return "" + } + return *c.SecretProtection +} + // GetSecretScanning returns the SecretScanning field if it's non-nil, zero value otherwise. func (c *CodeSecurityConfiguration) GetSecretScanning() string { if c == nil || c.SecretScanning == nil { @@ -3366,6 +3422,22 @@ func (c *CodeSecurityConfiguration) GetSecretScanning() string { return *c.SecretScanning } +// GetSecretScanningDelegatedAlertDismissal returns the SecretScanningDelegatedAlertDismissal field if it's non-nil, zero value otherwise. +func (c *CodeSecurityConfiguration) GetSecretScanningDelegatedAlertDismissal() string { + if c == nil || c.SecretScanningDelegatedAlertDismissal == nil { + return "" + } + return *c.SecretScanningDelegatedAlertDismissal +} + +// GetSecretScanningGenericSecrets returns the SecretScanningGenericSecrets field if it's non-nil, zero value otherwise. +func (c *CodeSecurityConfiguration) GetSecretScanningGenericSecrets() string { + if c == nil || c.SecretScanningGenericSecrets == nil { + return "" + } + return *c.SecretScanningGenericSecrets +} + // GetSecretScanningNonProviderPatterns returns the SecretScanningNonProviderPatterns field if it's non-nil, zero value otherwise. func (c *CodeSecurityConfiguration) GetSecretScanningNonProviderPatterns() string { if c == nil || c.SecretScanningNonProviderPatterns == nil { diff --git a/github/github-accessors_test.go b/github/github-accessors_test.go index 33f25e90ee3..bf53e3eff0c 100644 --- a/github/github-accessors_test.go +++ b/github/github-accessors_test.go @@ -4209,6 +4209,28 @@ func TestCodeScanningAlertState_GetDismissedReason(tt *testing.T) { c.GetDismissedReason() } +func TestCodeScanningDefaultSetupOptions_GetRunnerLabel(tt *testing.T) { + tt.Parallel() + var zeroValue string + c := &CodeScanningDefaultSetupOptions{RunnerLabel: &zeroValue} + c.GetRunnerLabel() + c = &CodeScanningDefaultSetupOptions{} + c.GetRunnerLabel() + c = nil + c.GetRunnerLabel() +} + +func TestCodeScanningOptions_GetAllowAdvanced(tt *testing.T) { + tt.Parallel() + var zeroValue bool + c := &CodeScanningOptions{AllowAdvanced: &zeroValue} + c.GetAllowAdvanced() + c = &CodeScanningOptions{} + c.GetAllowAdvanced() + c = nil + c.GetAllowAdvanced() +} + func TestCodeSearchResult_GetIncompleteResults(tt *testing.T) { tt.Parallel() var zeroValue bool @@ -4253,6 +4275,44 @@ func TestCodeSecurityConfiguration_GetCodeScanningDefaultSetup(tt *testing.T) { c.GetCodeScanningDefaultSetup() } +func TestCodeSecurityConfiguration_GetCodeScanningDefaultSetupOptions(tt *testing.T) { + tt.Parallel() + c := &CodeSecurityConfiguration{} + c.GetCodeScanningDefaultSetupOptions() + c = nil + c.GetCodeScanningDefaultSetupOptions() +} + +func TestCodeSecurityConfiguration_GetCodeScanningDelegatedAlertDismissal(tt *testing.T) { + tt.Parallel() + var zeroValue string + c := &CodeSecurityConfiguration{CodeScanningDelegatedAlertDismissal: &zeroValue} + c.GetCodeScanningDelegatedAlertDismissal() + c = &CodeSecurityConfiguration{} + c.GetCodeScanningDelegatedAlertDismissal() + c = nil + c.GetCodeScanningDelegatedAlertDismissal() +} + +func TestCodeSecurityConfiguration_GetCodeScanningOptions(tt *testing.T) { + tt.Parallel() + c := &CodeSecurityConfiguration{} + c.GetCodeScanningOptions() + c = nil + c.GetCodeScanningOptions() +} + +func TestCodeSecurityConfiguration_GetCodeSecurity(tt *testing.T) { + tt.Parallel() + var zeroValue string + c := &CodeSecurityConfiguration{CodeSecurity: &zeroValue} + c.GetCodeSecurity() + c = &CodeSecurityConfiguration{} + c.GetCodeSecurity() + c = nil + c.GetCodeSecurity() +} + func TestCodeSecurityConfiguration_GetCreatedAt(tt *testing.T) { tt.Parallel() var zeroValue Timestamp @@ -4382,6 +4442,17 @@ func TestCodeSecurityConfiguration_GetPrivateVulnerabilityReporting(tt *testing. c.GetPrivateVulnerabilityReporting() } +func TestCodeSecurityConfiguration_GetSecretProtection(tt *testing.T) { + tt.Parallel() + var zeroValue string + c := &CodeSecurityConfiguration{SecretProtection: &zeroValue} + c.GetSecretProtection() + c = &CodeSecurityConfiguration{} + c.GetSecretProtection() + c = nil + c.GetSecretProtection() +} + func TestCodeSecurityConfiguration_GetSecretScanning(tt *testing.T) { tt.Parallel() var zeroValue string @@ -4393,6 +4464,28 @@ func TestCodeSecurityConfiguration_GetSecretScanning(tt *testing.T) { c.GetSecretScanning() } +func TestCodeSecurityConfiguration_GetSecretScanningDelegatedAlertDismissal(tt *testing.T) { + tt.Parallel() + var zeroValue string + c := &CodeSecurityConfiguration{SecretScanningDelegatedAlertDismissal: &zeroValue} + c.GetSecretScanningDelegatedAlertDismissal() + c = &CodeSecurityConfiguration{} + c.GetSecretScanningDelegatedAlertDismissal() + c = nil + c.GetSecretScanningDelegatedAlertDismissal() +} + +func TestCodeSecurityConfiguration_GetSecretScanningGenericSecrets(tt *testing.T) { + tt.Parallel() + var zeroValue string + c := &CodeSecurityConfiguration{SecretScanningGenericSecrets: &zeroValue} + c.GetSecretScanningGenericSecrets() + c = &CodeSecurityConfiguration{} + c.GetSecretScanningGenericSecrets() + c = nil + c.GetSecretScanningGenericSecrets() +} + func TestCodeSecurityConfiguration_GetSecretScanningNonProviderPatterns(tt *testing.T) { tt.Parallel() var zeroValue string diff --git a/github/orgs_codesecurity_configurations.go b/github/orgs_codesecurity_configurations.go index 5d329d0bcf8..8032d0aecfb 100644 --- a/github/orgs_codesecurity_configurations.go +++ b/github/orgs_codesecurity_configurations.go @@ -16,6 +16,17 @@ type DependencyGraphAutosubmitActionOptions struct { LabeledRunners *bool `json:"labeled_runners,omitempty"` } +// CodeScanningOptions represents the options for the Security Configuration code scanning feature. +type CodeScanningOptions struct { + AllowAdvanced *bool `json:"allow_advanced,omitempty"` +} + +// CodeScanningDefaultSetupOptions represents the feature options for the code scanning default options. +type CodeScanningDefaultSetupOptions struct { + RunnerType string `json:"runner_type"` + RunnerLabel *string `json:"runner_label,omitempty"` +} + // RepositoryAttachment represents a repository attachment to a code security configuration. type RepositoryAttachment struct { Status *string `json:"status"` @@ -35,10 +46,17 @@ type CodeSecurityConfiguration struct { DependabotAlerts *string `json:"dependabot_alerts,omitempty"` DependabotSecurityUpdates *string `json:"dependabot_security_updates,omitempty"` CodeScanningDefaultSetup *string `json:"code_scanning_default_setup,omitempty"` + CodeScanningDefaultSetupOptions *CodeScanningDefaultSetupOptions `json:"code_scanning_default_setup_options,omitempty"` + CodeScanningDelegatedAlertDismissal *string `json:"code_scanning_delegated_alert_dismissal,omitempty"` + CodeScanningOptions *CodeScanningOptions `json:"code_scanning_options,omitempty"` + CodeSecurity *string `json:"code_security,omitempty"` SecretScanning *string `json:"secret_scanning,omitempty"` SecretScanningPushProtection *string `json:"secret_scanning_push_protection,omitempty"` SecretScanningValidityChecks *string `json:"secret_scanning_validity_checks,omitempty"` SecretScanningNonProviderPatterns *string `json:"secret_scanning_non_provider_patterns,omitempty"` + SecretScanningGenericSecrets *string `json:"secret_scanning_generic_secrets,omitempty"` + SecretScanningDelegatedAlertDismissal *string `json:"secret_scanning_delegated_alert_dismissal,omitempty"` + SecretProtection *string `json:"secret_protection,omitempty"` PrivateVulnerabilityReporting *string `json:"private_vulnerability_reporting,omitempty"` Enforcement *string `json:"enforcement,omitempty"` URL *string `json:"url,omitempty"` From 1db3645d09aaea6a32c67238ea2fb1ce91f9412f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tim=20H=C3=A4ring?= Date: Mon, 10 Nov 2025 09:11:11 +0100 Subject: [PATCH 4/8] fix: address pr reviews --- .../enterprise_codesecurity_configurations.go | 22 ++++++++----- ...rprise_codesecurity_configurations_test.go | 30 +++++++++++------ github/github-accessors.go | 16 --------- github/github-accessors_test.go | 22 ------------- github/orgs_codesecurity_configurations.go | 18 +++++----- .../orgs_codesecurity_configurations_test.go | 33 ++++++++++++------- 6 files changed, 64 insertions(+), 77 deletions(-) diff --git a/github/enterprise_codesecurity_configurations.go b/github/enterprise_codesecurity_configurations.go index 83c9c5e603a..23406555d20 100644 --- a/github/enterprise_codesecurity_configurations.go +++ b/github/enterprise_codesecurity_configurations.go @@ -37,10 +37,10 @@ func (s *EnterpriseService) GetCodeSecurityConfigurations(ctx context.Context, e // GitHub API docs: https://docs.github.com/rest/code-security/configurations#create-a-code-security-configuration-for-an-enterprise // //meta:operation POST /enterprises/{enterprise}/code-security/configurations -func (s *EnterpriseService) CreateCodeSecurityConfiguration(ctx context.Context, enterprise string, c *CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) { +func (s *EnterpriseService) CreateCodeSecurityConfiguration(ctx context.Context, enterprise string, config *CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) { u := fmt.Sprintf("enterprises/%v/code-security/configurations", enterprise) - req, err := s.client.NewRequest("POST", u, c) + req, err := s.client.NewRequest("POST", u, config) if err != nil { return nil, nil, err } @@ -100,10 +100,10 @@ func (s *EnterpriseService) GetCodeSecurityConfiguration(ctx context.Context, en // GitHub API docs: https://docs.github.com/rest/code-security/configurations#update-a-custom-code-security-configuration-for-an-enterprise // //meta:operation PATCH /enterprises/{enterprise}/code-security/configurations/{configuration_id} -func (s *EnterpriseService) UpdateCodeSecurityConfiguration(ctx context.Context, enterprise string, id int64, c *CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) { +func (s *EnterpriseService) UpdateCodeSecurityConfiguration(ctx context.Context, enterprise string, id int64, config *CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) { u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v", enterprise, id) - req, err := s.client.NewRequest("PATCH", u, c) + req, err := s.client.NewRequest("PATCH", u, config) if err != nil { return nil, nil, err } @@ -136,6 +136,8 @@ func (s *EnterpriseService) DeleteCodeSecurityConfiguration(ctx context.Context, } // AttachCodeSecurityConfigurationToRepositories attaches an enterprise code security configuration to repositories. +// `scope` is the type of repositories to attach the configuration to. +// Can be one of: `all`, `all_without_configurations`. // // GitHub API docs: https://docs.github.com/rest/code-security/configurations#attach-an-enterprise-configuration-to-repositories // @@ -158,26 +160,28 @@ func (s *EnterpriseService) AttachCodeSecurityConfigurationToRepositories(ctx co } // SetDefaultCodeSecurityConfiguration sets a code security configuration as a default for an enterprise. +// `defaultForNewRepos` specifies which types of repository this security configuration should be applied to by default. +// Can be one of: `all`, `none`, `private_and_internal, public`. // // GitHub API docs: https://docs.github.com/rest/code-security/configurations#set-a-code-security-configuration-as-a-default-for-an-enterprise // //meta:operation PUT /enterprises/{enterprise}/code-security/configurations/{configuration_id}/defaults -func (s *EnterpriseService) SetDefaultCodeSecurityConfiguration(ctx context.Context, enterprise string, id int64, newReposParam string) (*CodeSecurityConfigurationWithDefaultForNewRepos, *Response, error) { +func (s *EnterpriseService) SetDefaultCodeSecurityConfiguration(ctx context.Context, enterprise string, id int64, defaultForNewRepos string) (*CodeSecurityConfigurationWithDefaultForNewRepos, *Response, error) { u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v/defaults", enterprise, id) type configParam struct { DefaultForNewRepos string `json:"default_for_new_repos"` } - req, err := s.client.NewRequest("PUT", u, configParam{DefaultForNewRepos: newReposParam}) + req, err := s.client.NewRequest("PUT", u, configParam{DefaultForNewRepos: defaultForNewRepos}) if err != nil { return nil, nil, err } - var c *CodeSecurityConfigurationWithDefaultForNewRepos - resp, err := s.client.Do(ctx, req, &c) + var config *CodeSecurityConfigurationWithDefaultForNewRepos + resp, err := s.client.Do(ctx, req, &config) if err != nil { return nil, resp, err } - return c, resp, nil + return config, resp, nil } // GetRepositoriesForCodeSecurityConfiguration lists the repositories associated with an enterprise code security configuration. diff --git a/github/enterprise_codesecurity_configurations_test.go b/github/enterprise_codesecurity_configurations_test.go index 48535d67b13..0fd18120b69 100644 --- a/github/enterprise_codesecurity_configurations_test.go +++ b/github/enterprise_codesecurity_configurations_test.go @@ -25,11 +25,13 @@ func TestEnterpriseService_GetCodeSecurityConfigurations(t *testing.T) { { "id":1, "name":"config1", + "description":"desc1", "code_scanning_default_setup": "enabled" }, { "id":2, "name":"config2", + "description":"desc2", "private_vulnerability_reporting": "enabled" }]`) }) @@ -40,8 +42,8 @@ func TestEnterpriseService_GetCodeSecurityConfigurations(t *testing.T) { } want := []*CodeSecurityConfiguration{ - {ID: Ptr(int64(1)), Name: Ptr("config1"), CodeScanningDefaultSetup: Ptr("enabled")}, - {ID: Ptr(int64(2)), Name: Ptr("config2"), PrivateVulnerabilityReporting: Ptr("enabled")}, + {ID: Ptr(int64(1)), Name: "config1", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled")}, + {ID: Ptr(int64(2)), Name: "config2", Description: "desc2", PrivateVulnerabilityReporting: Ptr("enabled")}, } if !cmp.Equal(configurations, want) { t.Errorf("Enterprise.GetCodeSecurityConfigurations returned %+v, want %+v", configurations, want) @@ -70,6 +72,7 @@ func TestEnterpriseService_GetCodeSecurityConfiguration(t *testing.T) { fmt.Fprint(w, `{ "id":1, "name":"config1", + "description":"desc1", "code_scanning_default_setup": "enabled" }`) }) @@ -79,7 +82,7 @@ func TestEnterpriseService_GetCodeSecurityConfiguration(t *testing.T) { t.Errorf("Enterprise.GetCodeSecurityConfiguration returned error: %v", err) } - want := &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: Ptr("config1"), CodeScanningDefaultSetup: Ptr("enabled")} + want := &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: "config1", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled")} if !cmp.Equal(configuration, want) { t.Errorf("Enterprise.GetCodeSecurityConfiguration returned %+v, want %+v", configuration, want) } @@ -105,7 +108,8 @@ func TestEnterpriseService_CreateCodeSecurityConfiguration(t *testing.T) { ctx := t.Context() input := &CodeSecurityConfiguration{ - Name: Ptr("config1"), + Name: "config1", + Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled"), } @@ -120,6 +124,7 @@ func TestEnterpriseService_CreateCodeSecurityConfiguration(t *testing.T) { fmt.Fprint(w, `{ "id":1, "name":"config1", + "description":"desc1", "code_scanning_default_setup": "enabled" }`) }) @@ -129,7 +134,7 @@ func TestEnterpriseService_CreateCodeSecurityConfiguration(t *testing.T) { t.Errorf("Enterprise.CreateCodeSecurityConfiguration returned error: %v", err) } - want := &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: Ptr("config1"), CodeScanningDefaultSetup: Ptr("enabled")} + want := &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: "config1", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled")} if !cmp.Equal(configuration, want) { t.Errorf("Enterprise.CreateCodeSecurityConfiguration returned %+v, want %+v", configuration, want) } @@ -162,6 +167,7 @@ func TestEnterpriseService_GetDefaultCodeSecurityConfigurations(t *testing.T) { "configuration": { "id":1, "name":"config1", + "description":"desc1", "code_scanning_default_setup": "enabled" } }, @@ -170,6 +176,7 @@ func TestEnterpriseService_GetDefaultCodeSecurityConfigurations(t *testing.T) { "configuration": { "id":2, "name":"config2", + "description":"desc2", "private_vulnerability_reporting": "enabled" } } @@ -182,8 +189,8 @@ func TestEnterpriseService_GetDefaultCodeSecurityConfigurations(t *testing.T) { } want := []*CodeSecurityConfigurationWithDefaultForNewRepos{ - {DefaultForNewRepos: Ptr("public"), Configuration: &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: Ptr("config1"), CodeScanningDefaultSetup: Ptr("enabled")}}, - {DefaultForNewRepos: Ptr("private_and_internal"), Configuration: &CodeSecurityConfiguration{ID: Ptr(int64(2)), Name: Ptr("config2"), PrivateVulnerabilityReporting: Ptr("enabled")}}, + {DefaultForNewRepos: Ptr("public"), Configuration: &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: "config1", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled")}}, + {DefaultForNewRepos: Ptr("private_and_internal"), Configuration: &CodeSecurityConfiguration{ID: Ptr(int64(2)), Name: "config2", Description: "desc2", PrivateVulnerabilityReporting: Ptr("enabled")}}, } if !cmp.Equal(configurations, want) { t.Errorf("Enterprise.GetDefaultCodeSecurityConfigurations returned %+v, want %+v", configurations, want) @@ -210,7 +217,8 @@ func TestEnterpriseService_UpdateCodeSecurityConfiguration(t *testing.T) { client, mux, _ := setup(t) input := &CodeSecurityConfiguration{ - Name: Ptr("config1"), + Name: "config1", + Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled"), } @@ -225,6 +233,7 @@ func TestEnterpriseService_UpdateCodeSecurityConfiguration(t *testing.T) { fmt.Fprint(w, `{ "id":1, "name":"config1", + "description":"desc1", "code_scanning_default_setup": "enabled" }`) }) @@ -234,7 +243,7 @@ func TestEnterpriseService_UpdateCodeSecurityConfiguration(t *testing.T) { t.Errorf("Enterprise.UpdateCodeSecurityConfiguration returned error: %v", err) } - want := &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: Ptr("config1"), CodeScanningDefaultSetup: Ptr("enabled")} + want := &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: "config1", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled")} if !cmp.Equal(configuration, want) { t.Errorf("Enterprise.UpdateCodeSecurityConfiguration returned %+v, want %+v", configuration, want) } @@ -340,6 +349,7 @@ func TestEnterpriseService_SetDefaultCodeSecurityConfiguration(t *testing.T) { { "id": 1, "name": "config1", + "description": "desc1", "code_scanning_default_setup": "enabled" } }`) @@ -355,7 +365,7 @@ func TestEnterpriseService_SetDefaultCodeSecurityConfiguration(t *testing.T) { want := &CodeSecurityConfigurationWithDefaultForNewRepos{ DefaultForNewRepos: Ptr("all"), Configuration: &CodeSecurityConfiguration{ - ID: Ptr(int64(1)), Name: Ptr("config1"), CodeScanningDefaultSetup: Ptr("enabled"), + ID: Ptr(int64(1)), Name: "config1", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled"), }, } if !cmp.Equal(got, want) { diff --git a/github/github-accessors.go b/github/github-accessors.go index 3cd404215f1..23f0fe8994f 100644 --- a/github/github-accessors.go +++ b/github/github-accessors.go @@ -3358,14 +3358,6 @@ func (c *CodeSecurityConfiguration) GetDependencyGraphAutosubmitActionOptions() return c.DependencyGraphAutosubmitActionOptions } -// GetDescription returns the Description field if it's non-nil, zero value otherwise. -func (c *CodeSecurityConfiguration) GetDescription() string { - if c == nil || c.Description == nil { - return "" - } - return *c.Description -} - // GetEnforcement returns the Enforcement field if it's non-nil, zero value otherwise. func (c *CodeSecurityConfiguration) GetEnforcement() string { if c == nil || c.Enforcement == nil { @@ -3390,14 +3382,6 @@ func (c *CodeSecurityConfiguration) GetID() int64 { return *c.ID } -// GetName returns the Name field if it's non-nil, zero value otherwise. -func (c *CodeSecurityConfiguration) GetName() string { - if c == nil || c.Name == nil { - return "" - } - return *c.Name -} - // GetPrivateVulnerabilityReporting returns the PrivateVulnerabilityReporting field if it's non-nil, zero value otherwise. func (c *CodeSecurityConfiguration) GetPrivateVulnerabilityReporting() string { if c == nil || c.PrivateVulnerabilityReporting == nil { diff --git a/github/github-accessors_test.go b/github/github-accessors_test.go index bf53e3eff0c..94d21a06b9c 100644 --- a/github/github-accessors_test.go +++ b/github/github-accessors_test.go @@ -4376,17 +4376,6 @@ func TestCodeSecurityConfiguration_GetDependencyGraphAutosubmitActionOptions(tt c.GetDependencyGraphAutosubmitActionOptions() } -func TestCodeSecurityConfiguration_GetDescription(tt *testing.T) { - tt.Parallel() - var zeroValue string - c := &CodeSecurityConfiguration{Description: &zeroValue} - c.GetDescription() - c = &CodeSecurityConfiguration{} - c.GetDescription() - c = nil - c.GetDescription() -} - func TestCodeSecurityConfiguration_GetEnforcement(tt *testing.T) { tt.Parallel() var zeroValue string @@ -4420,17 +4409,6 @@ func TestCodeSecurityConfiguration_GetID(tt *testing.T) { c.GetID() } -func TestCodeSecurityConfiguration_GetName(tt *testing.T) { - tt.Parallel() - var zeroValue string - c := &CodeSecurityConfiguration{Name: &zeroValue} - c.GetName() - c = &CodeSecurityConfiguration{} - c.GetName() - c = nil - c.GetName() -} - func TestCodeSecurityConfiguration_GetPrivateVulnerabilityReporting(tt *testing.T) { tt.Parallel() var zeroValue string diff --git a/github/orgs_codesecurity_configurations.go b/github/orgs_codesecurity_configurations.go index 8032d0aecfb..2888f6f774a 100644 --- a/github/orgs_codesecurity_configurations.go +++ b/github/orgs_codesecurity_configurations.go @@ -37,8 +37,8 @@ type RepositoryAttachment struct { type CodeSecurityConfiguration struct { ID *int64 `json:"id,omitempty"` TargetType *string `json:"target_type,omitempty"` - Name *string `json:"name"` - Description *string `json:"description,omitempty"` + Name string `json:"name"` + Description string `json:"description"` AdvancedSecurity *string `json:"advanced_security,omitempty"` DependencyGraph *string `json:"dependency_graph,omitempty"` DependencyGraphAutosubmitAction *string `json:"dependency_graph_autosubmit_action,omitempty"` @@ -103,10 +103,10 @@ func (s *OrganizationsService) GetCodeSecurityConfigurations(ctx context.Context // GitHub API docs: https://docs.github.com/rest/code-security/configurations#create-a-code-security-configuration // //meta:operation POST /orgs/{org}/code-security/configurations -func (s *OrganizationsService) CreateCodeSecurityConfiguration(ctx context.Context, org string, c *CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) { +func (s *OrganizationsService) CreateCodeSecurityConfiguration(ctx context.Context, org string, config *CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) { u := fmt.Sprintf("orgs/%v/code-security/configurations", org) - req, err := s.client.NewRequest("POST", u, c) + req, err := s.client.NewRequest("POST", u, config) if err != nil { return nil, nil, err } @@ -187,10 +187,10 @@ func (s *OrganizationsService) GetCodeSecurityConfiguration(ctx context.Context, // GitHub API docs: https://docs.github.com/rest/code-security/configurations#update-a-code-security-configuration // //meta:operation PATCH /orgs/{org}/code-security/configurations/{configuration_id} -func (s *OrganizationsService) UpdateCodeSecurityConfiguration(ctx context.Context, org string, id int64, c *CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) { +func (s *OrganizationsService) UpdateCodeSecurityConfiguration(ctx context.Context, org string, id int64, config *CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) { u := fmt.Sprintf("orgs/%v/code-security/configurations/%v", org, id) - req, err := s.client.NewRequest("PATCH", u, c) + req, err := s.client.NewRequest("PATCH", u, config) if err != nil { return nil, nil, err } @@ -258,12 +258,12 @@ func (s *OrganizationsService) SetDefaultCodeSecurityConfiguration(ctx context.C if err != nil { return nil, nil, err } - var c *CodeSecurityConfigurationWithDefaultForNewRepos - resp, err := s.client.Do(ctx, req, &c) + var config *CodeSecurityConfigurationWithDefaultForNewRepos + resp, err := s.client.Do(ctx, req, &config) if err != nil { return nil, resp, err } - return c, resp, nil + return config, resp, nil } // GetRepositoriesForCodeSecurityConfiguration gets repositories associated with a code security configuration. diff --git a/github/orgs_codesecurity_configurations_test.go b/github/orgs_codesecurity_configurations_test.go index 5c52c08d135..32e35bb0df1 100644 --- a/github/orgs_codesecurity_configurations_test.go +++ b/github/orgs_codesecurity_configurations_test.go @@ -25,11 +25,13 @@ func TestOrganizationsService_GetCodeSecurityConfigurations(t *testing.T) { { "id":1, "name":"config1", + "description":"desc1", "code_scanning_default_setup": "enabled" }, { "id":2, "name":"config2", + "description":"desc2", "private_vulnerability_reporting": "enabled" }]`) }) @@ -40,8 +42,8 @@ func TestOrganizationsService_GetCodeSecurityConfigurations(t *testing.T) { } want := []*CodeSecurityConfiguration{ - {ID: Ptr(int64(1)), Name: Ptr("config1"), CodeScanningDefaultSetup: Ptr("enabled")}, - {ID: Ptr(int64(2)), Name: Ptr("config2"), PrivateVulnerabilityReporting: Ptr("enabled")}, + {ID: Ptr(int64(1)), Name: "config1", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled")}, + {ID: Ptr(int64(2)), Name: "config2", Description: "desc2", PrivateVulnerabilityReporting: Ptr("enabled")}, } if !cmp.Equal(configurations, want) { t.Errorf("Organizations.GetCodeSecurityConfigurations returned %+v, want %+v", configurations, want) @@ -70,6 +72,7 @@ func TestOrganizationsService_GetCodeSecurityConfiguration(t *testing.T) { fmt.Fprint(w, `{ "id":1, "name":"config1", + "description":"desc1", "code_scanning_default_setup": "enabled" }`) }) @@ -79,7 +82,7 @@ func TestOrganizationsService_GetCodeSecurityConfiguration(t *testing.T) { t.Errorf("Organizations.GetCodeSecurityConfiguration returned error: %v", err) } - want := &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: Ptr("config1"), CodeScanningDefaultSetup: Ptr("enabled")} + want := &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: "config1", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled")} if !cmp.Equal(configuration, want) { t.Errorf("Organizations.GetCodeSecurityConfiguration returned %+v, want %+v", configuration, want) } @@ -105,7 +108,8 @@ func TestOrganizationsService_CreateCodeSecurityConfiguration(t *testing.T) { ctx := t.Context() input := &CodeSecurityConfiguration{ - Name: Ptr("config1"), + Name: "config1", + Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled"), } @@ -120,6 +124,7 @@ func TestOrganizationsService_CreateCodeSecurityConfiguration(t *testing.T) { fmt.Fprint(w, `{ "id":1, "name":"config1", + "description":"desc1", "code_scanning_default_setup": "enabled" }`) }) @@ -129,7 +134,7 @@ func TestOrganizationsService_CreateCodeSecurityConfiguration(t *testing.T) { t.Errorf("Organizations.CreateCodeSecurityConfiguration returned error: %v", err) } - want := &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: Ptr("config1"), CodeScanningDefaultSetup: Ptr("enabled")} + want := &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: "config1", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled")} if !cmp.Equal(configuration, want) { t.Errorf("Organizations.CreateCodeSecurityConfiguration returned %+v, want %+v", configuration, want) } @@ -162,6 +167,7 @@ func TestOrganizationsService_GetDefaultCodeSecurityConfigurations(t *testing.T) "configuration": { "id":1, "name":"config1", + "description":"desc1", "code_scanning_default_setup": "enabled" } }, @@ -170,6 +176,7 @@ func TestOrganizationsService_GetDefaultCodeSecurityConfigurations(t *testing.T) "configuration": { "id":2, "name":"config2", + "description":"desc2", "private_vulnerability_reporting": "enabled" } } @@ -182,8 +189,8 @@ func TestOrganizationsService_GetDefaultCodeSecurityConfigurations(t *testing.T) } want := []*CodeSecurityConfigurationWithDefaultForNewRepos{ - {DefaultForNewRepos: Ptr("public"), Configuration: &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: Ptr("config1"), CodeScanningDefaultSetup: Ptr("enabled")}}, - {DefaultForNewRepos: Ptr("private_and_internal"), Configuration: &CodeSecurityConfiguration{ID: Ptr(int64(2)), Name: Ptr("config2"), PrivateVulnerabilityReporting: Ptr("enabled")}}, + {DefaultForNewRepos: Ptr("public"), Configuration: &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: "config1", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled")}}, + {DefaultForNewRepos: Ptr("private_and_internal"), Configuration: &CodeSecurityConfiguration{ID: Ptr(int64(2)), Name: "config2", Description: "desc2", PrivateVulnerabilityReporting: Ptr("enabled")}}, } if !cmp.Equal(configurations, want) { t.Errorf("Organizations.GetDefaultCodeSecurityConfigurations returned %+v, want %+v", configurations, want) @@ -242,7 +249,8 @@ func TestOrganizationsService_UpdateCodeSecurityConfiguration(t *testing.T) { client, mux, _ := setup(t) input := &CodeSecurityConfiguration{ - Name: Ptr("config1"), + Name: "config1", + Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled"), } @@ -257,6 +265,7 @@ func TestOrganizationsService_UpdateCodeSecurityConfiguration(t *testing.T) { fmt.Fprint(w, `{ "id":1, "name":"config1", + "description":"desc1", "code_scanning_default_setup": "enabled" }`) }) @@ -266,7 +275,7 @@ func TestOrganizationsService_UpdateCodeSecurityConfiguration(t *testing.T) { t.Errorf("Organizations.UpdateCodeSecurityConfiguration returned error: %v", err) } - want := &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: Ptr("config1"), CodeScanningDefaultSetup: Ptr("enabled")} + want := &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: "config1", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled")} if !cmp.Equal(configuration, want) { t.Errorf("Organizations.UpdateCodeSecurityConfiguration returned %+v, want %+v", configuration, want) } @@ -376,6 +385,7 @@ func TestOrganizationsService_SetDefaultCodeSecurityConfiguration(t *testing.T) { "id": 1, "name": "config1", + "description": "desc1", "code_scanning_default_setup": "enabled" } }`) @@ -391,7 +401,7 @@ func TestOrganizationsService_SetDefaultCodeSecurityConfiguration(t *testing.T) want := &CodeSecurityConfigurationWithDefaultForNewRepos{ DefaultForNewRepos: Ptr("all"), Configuration: &CodeSecurityConfiguration{ - ID: Ptr(int64(1)), Name: Ptr("config1"), CodeScanningDefaultSetup: Ptr("enabled"), + ID: Ptr(int64(1)), Name: "config1", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled"), }, } if !cmp.Equal(got, want) { @@ -477,6 +487,7 @@ func TestOrganizationsService_GetCodeSecurityConfigurationForRepository(t *testi "configuration": { "id":42, "name":"config42", + "description":"desc1", "code_scanning_default_setup": "enabled" } }`) @@ -486,7 +497,7 @@ func TestOrganizationsService_GetCodeSecurityConfigurationForRepository(t *testi if err != nil { t.Errorf("Organizations.GetCodeSecurityConfigurationForRepository returned error: %v", err) } - c := &CodeSecurityConfiguration{ID: Ptr(int64(42)), Name: Ptr("config42"), CodeScanningDefaultSetup: Ptr("enabled")} + c := &CodeSecurityConfiguration{ID: Ptr(int64(42)), Name: "config42", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled")} want := &RepositoryCodeSecurityConfiguration{ State: Ptr("attached"), Configuration: c, From 2a504ca6c0c30b64766546b66ad5176cec30527e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tim=20H=C3=A4ring?= Date: Mon, 10 Nov 2025 14:26:09 +0100 Subject: [PATCH 5/8] fix: include pagination --- .../enterprise_codesecurity_configurations.go | 6 ++- ...rprise_codesecurity_configurations_test.go | 8 ++-- github/github-accessors.go | 32 ++++++++++++++ github/github-accessors_test.go | 44 +++++++++++++++++++ github/orgs_codesecurity_configurations.go | 30 ++++++++++++- .../orgs_codesecurity_configurations_test.go | 8 ++-- 6 files changed, 120 insertions(+), 8 deletions(-) diff --git a/github/enterprise_codesecurity_configurations.go b/github/enterprise_codesecurity_configurations.go index 23406555d20..98b90c83d0a 100644 --- a/github/enterprise_codesecurity_configurations.go +++ b/github/enterprise_codesecurity_configurations.go @@ -16,8 +16,12 @@ import ( // GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-code-security-configurations-for-an-enterprise // //meta:operation GET /enterprises/{enterprise}/code-security/configurations -func (s *EnterpriseService) GetCodeSecurityConfigurations(ctx context.Context, enterprise string) ([]*CodeSecurityConfiguration, *Response, error) { +func (s *EnterpriseService) GetCodeSecurityConfigurations(ctx context.Context, enterprise string, opts *GetCodeSecurityConfigurationOptions) ([]*CodeSecurityConfiguration, *Response, error) { u := fmt.Sprintf("enterprises/%v/code-security/configurations", enterprise) + u, err := addOptions(u, opts) + if err != nil { + return nil, nil, err + } req, err := s.client.NewRequest("GET", u, nil) if err != nil { diff --git a/github/enterprise_codesecurity_configurations_test.go b/github/enterprise_codesecurity_configurations_test.go index 0fd18120b69..cb3d2644dcb 100644 --- a/github/enterprise_codesecurity_configurations_test.go +++ b/github/enterprise_codesecurity_configurations_test.go @@ -16,11 +16,13 @@ import ( func TestEnterpriseService_GetCodeSecurityConfigurations(t *testing.T) { t.Parallel() + opts := &GetCodeSecurityConfigurationOptions{Before: Ptr("1"), After: Ptr("2"), PerPage: Ptr(30)} ctx := t.Context() client, mux, _ := setup(t) mux.HandleFunc("/enterprises/e/code-security/configurations", func(w http.ResponseWriter, r *http.Request) { testMethod(t, r, "GET") + testFormValues(t, r, values{"before": "1", "after": "2", "per_page": "30"}) fmt.Fprint(w, `[ { "id":1, @@ -36,7 +38,7 @@ func TestEnterpriseService_GetCodeSecurityConfigurations(t *testing.T) { }]`) }) - configurations, _, err := client.Enterprise.GetCodeSecurityConfigurations(ctx, "e") + configurations, _, err := client.Enterprise.GetCodeSecurityConfigurations(ctx, "e", opts) if err != nil { t.Errorf("Enterprise.GetCodeSecurityConfigurations returned error: %v", err) } @@ -50,11 +52,11 @@ func TestEnterpriseService_GetCodeSecurityConfigurations(t *testing.T) { } const methodName = "GetCodeSecurityConfigurations" testBadOptions(t, methodName, func() (err error) { - _, _, err = client.Enterprise.GetCodeSecurityConfigurations(ctx, "\n") + _, _, err = client.Enterprise.GetCodeSecurityConfigurations(ctx, "\n", opts) return err }) testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { - got, resp, err := client.Enterprise.GetCodeSecurityConfigurations(ctx, "e") + got, resp, err := client.Enterprise.GetCodeSecurityConfigurations(ctx, "e", opts) if got != nil { t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) } diff --git a/github/github-accessors.go b/github/github-accessors.go index 23f0fe8994f..7540b661d30 100644 --- a/github/github-accessors.go +++ b/github/github-accessors.go @@ -9990,6 +9990,38 @@ func (g *GetAuditLogOptions) GetPhrase() string { return *g.Phrase } +// GetAfter returns the After field if it's non-nil, zero value otherwise. +func (g *GetCodeSecurityConfigurationOptions) GetAfter() string { + if g == nil || g.After == nil { + return "" + } + return *g.After +} + +// GetBefore returns the Before field if it's non-nil, zero value otherwise. +func (g *GetCodeSecurityConfigurationOptions) GetBefore() string { + if g == nil || g.Before == nil { + return "" + } + return *g.Before +} + +// GetPerPage returns the PerPage field if it's non-nil, zero value otherwise. +func (g *GetCodeSecurityConfigurationOptions) GetPerPage() int { + if g == nil || g.PerPage == nil { + return 0 + } + return *g.PerPage +} + +// GetTargetType returns the TargetType field if it's non-nil, zero value otherwise. +func (g *GetCodeSecurityConfigurationOptions) GetTargetType() string { + if g == nil || g.TargetType == nil { + return "" + } + return *g.TargetType +} + // GetComments returns the Comments field if it's non-nil, zero value otherwise. func (g *Gist) GetComments() int { if g == nil || g.Comments == nil { diff --git a/github/github-accessors_test.go b/github/github-accessors_test.go index 94d21a06b9c..bf859984dd5 100644 --- a/github/github-accessors_test.go +++ b/github/github-accessors_test.go @@ -12946,6 +12946,50 @@ func TestGetAuditLogOptions_GetPhrase(tt *testing.T) { g.GetPhrase() } +func TestGetCodeSecurityConfigurationOptions_GetAfter(tt *testing.T) { + tt.Parallel() + var zeroValue string + g := &GetCodeSecurityConfigurationOptions{After: &zeroValue} + g.GetAfter() + g = &GetCodeSecurityConfigurationOptions{} + g.GetAfter() + g = nil + g.GetAfter() +} + +func TestGetCodeSecurityConfigurationOptions_GetBefore(tt *testing.T) { + tt.Parallel() + var zeroValue string + g := &GetCodeSecurityConfigurationOptions{Before: &zeroValue} + g.GetBefore() + g = &GetCodeSecurityConfigurationOptions{} + g.GetBefore() + g = nil + g.GetBefore() +} + +func TestGetCodeSecurityConfigurationOptions_GetPerPage(tt *testing.T) { + tt.Parallel() + var zeroValue int + g := &GetCodeSecurityConfigurationOptions{PerPage: &zeroValue} + g.GetPerPage() + g = &GetCodeSecurityConfigurationOptions{} + g.GetPerPage() + g = nil + g.GetPerPage() +} + +func TestGetCodeSecurityConfigurationOptions_GetTargetType(tt *testing.T) { + tt.Parallel() + var zeroValue string + g := &GetCodeSecurityConfigurationOptions{TargetType: &zeroValue} + g.GetTargetType() + g = &GetCodeSecurityConfigurationOptions{} + g.GetTargetType() + g = nil + g.GetTargetType() +} + func TestGist_GetComments(tt *testing.T) { tt.Parallel() var zeroValue int diff --git a/github/orgs_codesecurity_configurations.go b/github/orgs_codesecurity_configurations.go index 2888f6f774a..a6389010eae 100644 --- a/github/orgs_codesecurity_configurations.go +++ b/github/orgs_codesecurity_configurations.go @@ -77,13 +77,41 @@ type RepositoryCodeSecurityConfiguration struct { Configuration *CodeSecurityConfiguration `json:"configuration,omitempty"` } +// GetCodeSecurityConfigurationOptions specifies optional parameters to get security configurations for orgs/enterprises +// +// Note: Pagination is powered by before/after cursor-style pagination. After the initial call, +// inspect the returned *Response. Use resp.After as the opts.After value to request +// the next page, and resp.Before as the opts.Before value to request the previous +// page. Set either Before or After for a request; if both are +// supplied GitHub API will return an error. PerPage controls the number of items +// per page (max 100 per GitHub API docs). +type GetCodeSecurityConfigurationOptions struct { + // A cursor, as given in the Link header. If specified, the query only searches for events before this cursor. + Before *string `url:"before,omitempty"` + + // A cursor, as given in the Link header. If specified, the query only searches for events after this cursor. + After *string `url:"after,omitempty"` + + // For paginated result sets, the number of results to include per page. + PerPage *int `url:"per_page,omitempty"` + + // The target type of the code security configurations to get, only valid for the organization endpoint. + // + // `target_type` defaults to all, can be one of global, all + TargetType *string `url:"target_type,omitempty"` +} + // GetCodeSecurityConfigurations gets code security configurations for an organization. // // GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-code-security-configurations-for-an-organization // //meta:operation GET /orgs/{org}/code-security/configurations -func (s *OrganizationsService) GetCodeSecurityConfigurations(ctx context.Context, org string) ([]*CodeSecurityConfiguration, *Response, error) { +func (s *OrganizationsService) GetCodeSecurityConfigurations(ctx context.Context, org string, opts *GetCodeSecurityConfigurationOptions) ([]*CodeSecurityConfiguration, *Response, error) { u := fmt.Sprintf("orgs/%v/code-security/configurations", org) + u, err := addOptions(u, opts) + if err != nil { + return nil, nil, err + } req, err := s.client.NewRequest("GET", u, nil) if err != nil { diff --git a/github/orgs_codesecurity_configurations_test.go b/github/orgs_codesecurity_configurations_test.go index 32e35bb0df1..23b410c0b44 100644 --- a/github/orgs_codesecurity_configurations_test.go +++ b/github/orgs_codesecurity_configurations_test.go @@ -16,11 +16,13 @@ import ( func TestOrganizationsService_GetCodeSecurityConfigurations(t *testing.T) { t.Parallel() + opts := &GetCodeSecurityConfigurationOptions{Before: Ptr("1"), After: Ptr("2"), PerPage: Ptr(30), TargetType: Ptr("all")} ctx := t.Context() client, mux, _ := setup(t) mux.HandleFunc("/orgs/o/code-security/configurations", func(w http.ResponseWriter, r *http.Request) { testMethod(t, r, "GET") + testFormValues(t, r, values{"before": "1", "after": "2", "per_page": "30", "target_type": "all"}) fmt.Fprint(w, `[ { "id":1, @@ -36,7 +38,7 @@ func TestOrganizationsService_GetCodeSecurityConfigurations(t *testing.T) { }]`) }) - configurations, _, err := client.Organizations.GetCodeSecurityConfigurations(ctx, "o") + configurations, _, err := client.Organizations.GetCodeSecurityConfigurations(ctx, "o", opts) if err != nil { t.Errorf("Organizations.GetCodeSecurityConfigurations returned error: %v", err) } @@ -50,11 +52,11 @@ func TestOrganizationsService_GetCodeSecurityConfigurations(t *testing.T) { } const methodName = "GetCodeSecurityConfigurations" testBadOptions(t, methodName, func() (err error) { - _, _, err = client.Organizations.GetCodeSecurityConfigurations(ctx, "\n") + _, _, err = client.Organizations.GetCodeSecurityConfigurations(ctx, "\n", opts) return err }) testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { - got, resp, err := client.Organizations.GetCodeSecurityConfigurations(ctx, "o") + got, resp, err := client.Organizations.GetCodeSecurityConfigurations(ctx, "o", opts) if got != nil { t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) } From 1fd16cde39cb815879093e0815e4fe287ff28456 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tim=20H=C3=A4ring?= Date: Tue, 11 Nov 2025 10:23:33 +0100 Subject: [PATCH 6/8] fix: pass required params by value, per org/enterprise pagination options, rename get to list --- .../enterprise_codesecurity_configurations.go | 31 ++++- ...rprise_codesecurity_configurations_test.go | 42 +++--- github/github-accessors.go | 88 ++++++++----- github/github-accessors_test.go | 121 +++++++++++------- github/orgs_codesecurity_configurations.go | 26 ++-- .../orgs_codesecurity_configurations_test.go | 56 ++++---- 6 files changed, 220 insertions(+), 144 deletions(-) diff --git a/github/enterprise_codesecurity_configurations.go b/github/enterprise_codesecurity_configurations.go index 98b90c83d0a..27e07583440 100644 --- a/github/enterprise_codesecurity_configurations.go +++ b/github/enterprise_codesecurity_configurations.go @@ -11,12 +11,31 @@ import ( "net/http" ) -// GetCodeSecurityConfigurations lists all code security configurations available in an enterprise. +// ListEnterpriseCodeSecurityConfigurationOptions specifies optional parameters to get security configurations for enterprises. +// +// Note: Pagination is powered by before/after cursor-style pagination. After the initial call, +// inspect the returned *Response. Use resp.After as the opts.After value to request +// the next page, and resp.Before as the opts.Before value to request the previous +// page. Set either Before or After for a request; if both are +// supplied GitHub API will return an error. PerPage controls the number of items +// per page (max 100 per GitHub API docs). +type ListEnterpriseCodeSecurityConfigurationOptions struct { + // A cursor, as given in the Link header. If specified, the query only searches for security configurations before this cursor. + Before *string `url:"before,omitempty"` + + // A cursor, as given in the Link header. If specified, the query only searches for security configurations after this cursor. + After *string `url:"after,omitempty"` + + // For paginated result sets, the number of results to include per page. + PerPage *int `url:"per_page,omitempty"` +} + +// ListCodeSecurityConfigurations lists all code security configurations available in an enterprise. // // GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-code-security-configurations-for-an-enterprise // //meta:operation GET /enterprises/{enterprise}/code-security/configurations -func (s *EnterpriseService) GetCodeSecurityConfigurations(ctx context.Context, enterprise string, opts *GetCodeSecurityConfigurationOptions) ([]*CodeSecurityConfiguration, *Response, error) { +func (s *EnterpriseService) ListCodeSecurityConfigurations(ctx context.Context, enterprise string, opts *ListEnterpriseCodeSecurityConfigurationOptions) ([]*CodeSecurityConfiguration, *Response, error) { u := fmt.Sprintf("enterprises/%v/code-security/configurations", enterprise) u, err := addOptions(u, opts) if err != nil { @@ -41,7 +60,7 @@ func (s *EnterpriseService) GetCodeSecurityConfigurations(ctx context.Context, e // GitHub API docs: https://docs.github.com/rest/code-security/configurations#create-a-code-security-configuration-for-an-enterprise // //meta:operation POST /enterprises/{enterprise}/code-security/configurations -func (s *EnterpriseService) CreateCodeSecurityConfiguration(ctx context.Context, enterprise string, config *CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) { +func (s *EnterpriseService) CreateCodeSecurityConfiguration(ctx context.Context, enterprise string, config CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) { u := fmt.Sprintf("enterprises/%v/code-security/configurations", enterprise) req, err := s.client.NewRequest("POST", u, config) @@ -78,12 +97,12 @@ func (s *EnterpriseService) GetDefaultCodeSecurityConfigurations(ctx context.Con return configurations, resp, nil } -// GetCodeSecurityConfiguration gets a code security configuration available in an enterprise. +// ListCodeSecurityConfiguration gets a code security configuration available in an enterprise. // // GitHub API docs: https://docs.github.com/rest/code-security/configurations#retrieve-a-code-security-configuration-of-an-enterprise // //meta:operation GET /enterprises/{enterprise}/code-security/configurations/{configuration_id} -func (s *EnterpriseService) GetCodeSecurityConfiguration(ctx context.Context, enterprise string, id int64) (*CodeSecurityConfiguration, *Response, error) { +func (s *EnterpriseService) ListCodeSecurityConfiguration(ctx context.Context, enterprise string, id int64) (*CodeSecurityConfiguration, *Response, error) { u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v", enterprise, id) req, err := s.client.NewRequest("GET", u, nil) @@ -104,7 +123,7 @@ func (s *EnterpriseService) GetCodeSecurityConfiguration(ctx context.Context, en // GitHub API docs: https://docs.github.com/rest/code-security/configurations#update-a-custom-code-security-configuration-for-an-enterprise // //meta:operation PATCH /enterprises/{enterprise}/code-security/configurations/{configuration_id} -func (s *EnterpriseService) UpdateCodeSecurityConfiguration(ctx context.Context, enterprise string, id int64, config *CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) { +func (s *EnterpriseService) UpdateCodeSecurityConfiguration(ctx context.Context, enterprise string, id int64, config CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) { u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v", enterprise, id) req, err := s.client.NewRequest("PATCH", u, config) diff --git a/github/enterprise_codesecurity_configurations_test.go b/github/enterprise_codesecurity_configurations_test.go index cb3d2644dcb..1f4ea1774e2 100644 --- a/github/enterprise_codesecurity_configurations_test.go +++ b/github/enterprise_codesecurity_configurations_test.go @@ -14,9 +14,9 @@ import ( "github.com/google/go-cmp/cmp" ) -func TestEnterpriseService_GetCodeSecurityConfigurations(t *testing.T) { +func TestEnterpriseService_ListCodeSecurityConfigurations(t *testing.T) { t.Parallel() - opts := &GetCodeSecurityConfigurationOptions{Before: Ptr("1"), After: Ptr("2"), PerPage: Ptr(30)} + opts := &ListEnterpriseCodeSecurityConfigurationOptions{Before: Ptr("1"), After: Ptr("2"), PerPage: Ptr(30)} ctx := t.Context() client, mux, _ := setup(t) @@ -38,9 +38,9 @@ func TestEnterpriseService_GetCodeSecurityConfigurations(t *testing.T) { }]`) }) - configurations, _, err := client.Enterprise.GetCodeSecurityConfigurations(ctx, "e", opts) + configurations, _, err := client.Enterprise.ListCodeSecurityConfigurations(ctx, "e", opts) if err != nil { - t.Errorf("Enterprise.GetCodeSecurityConfigurations returned error: %v", err) + t.Errorf("Enterprise.ListCodeSecurityConfigurations returned error: %v", err) } want := []*CodeSecurityConfiguration{ @@ -48,15 +48,15 @@ func TestEnterpriseService_GetCodeSecurityConfigurations(t *testing.T) { {ID: Ptr(int64(2)), Name: "config2", Description: "desc2", PrivateVulnerabilityReporting: Ptr("enabled")}, } if !cmp.Equal(configurations, want) { - t.Errorf("Enterprise.GetCodeSecurityConfigurations returned %+v, want %+v", configurations, want) + t.Errorf("Enterprise.ListCodeSecurityConfigurations returned %+v, want %+v", configurations, want) } - const methodName = "GetCodeSecurityConfigurations" + const methodName = "ListCodeSecurityConfigurations" testBadOptions(t, methodName, func() (err error) { - _, _, err = client.Enterprise.GetCodeSecurityConfigurations(ctx, "\n", opts) + _, _, err = client.Enterprise.ListCodeSecurityConfigurations(ctx, "\n", opts) return err }) testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { - got, resp, err := client.Enterprise.GetCodeSecurityConfigurations(ctx, "e", opts) + got, resp, err := client.Enterprise.ListCodeSecurityConfigurations(ctx, "e", opts) if got != nil { t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) } @@ -64,7 +64,7 @@ func TestEnterpriseService_GetCodeSecurityConfigurations(t *testing.T) { }) } -func TestEnterpriseService_GetCodeSecurityConfiguration(t *testing.T) { +func TestEnterpriseService_ListCodeSecurityConfiguration(t *testing.T) { t.Parallel() client, mux, _ := setup(t) ctx := t.Context() @@ -79,24 +79,24 @@ func TestEnterpriseService_GetCodeSecurityConfiguration(t *testing.T) { }`) }) - configuration, _, err := client.Enterprise.GetCodeSecurityConfiguration(ctx, "e", 1) + configuration, _, err := client.Enterprise.ListCodeSecurityConfiguration(ctx, "e", 1) if err != nil { - t.Errorf("Enterprise.GetCodeSecurityConfiguration returned error: %v", err) + t.Errorf("Enterprise.ListCodeSecurityConfiguration returned error: %v", err) } want := &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: "config1", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled")} if !cmp.Equal(configuration, want) { - t.Errorf("Enterprise.GetCodeSecurityConfiguration returned %+v, want %+v", configuration, want) + t.Errorf("Enterprise.ListCodeSecurityConfiguration returned %+v, want %+v", configuration, want) } - const methodName = "GetCodeSecurityConfiguration" + const methodName = "ListCodeSecurityConfiguration" testBadOptions(t, methodName, func() (err error) { - _, _, err = client.Enterprise.GetCodeSecurityConfiguration(ctx, "\n", -1) + _, _, err = client.Enterprise.ListCodeSecurityConfiguration(ctx, "\n", -1) return err }) testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { - got, resp, err := client.Enterprise.GetCodeSecurityConfiguration(ctx, "e", 1) + got, resp, err := client.Enterprise.ListCodeSecurityConfiguration(ctx, "e", 1) if got != nil { t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) } @@ -109,15 +109,15 @@ func TestEnterpriseService_CreateCodeSecurityConfiguration(t *testing.T) { client, mux, _ := setup(t) ctx := t.Context() - input := &CodeSecurityConfiguration{ + input := CodeSecurityConfiguration{ Name: "config1", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled"), } mux.HandleFunc("/enterprises/e/code-security/configurations", func(w http.ResponseWriter, r *http.Request) { - v := new(CodeSecurityConfiguration) - assertNilError(t, json.NewDecoder(r.Body).Decode(v)) + var v CodeSecurityConfiguration + assertNilError(t, json.NewDecoder(r.Body).Decode(&v)) if !cmp.Equal(v, input) { t.Errorf("Enterprise.CreateCodeSecurityConfiguration request body = %+v, want %+v", v, input) @@ -218,15 +218,15 @@ func TestEnterpriseService_UpdateCodeSecurityConfiguration(t *testing.T) { ctx := t.Context() client, mux, _ := setup(t) - input := &CodeSecurityConfiguration{ + input := CodeSecurityConfiguration{ Name: "config1", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled"), } mux.HandleFunc("/enterprises/e/code-security/configurations/1", func(w http.ResponseWriter, r *http.Request) { - v := new(CodeSecurityConfiguration) - assertNilError(t, json.NewDecoder(r.Body).Decode(v)) + var v CodeSecurityConfiguration + assertNilError(t, json.NewDecoder(r.Body).Decode(&v)) if !cmp.Equal(v, input) { t.Errorf("Enterprise.UpdateCodeSecurityConfiguration request body = %+v, want %+v", v, input) diff --git a/github/github-accessors.go b/github/github-accessors.go index 7540b661d30..5a5b79467d7 100644 --- a/github/github-accessors.go +++ b/github/github-accessors.go @@ -9990,38 +9990,6 @@ func (g *GetAuditLogOptions) GetPhrase() string { return *g.Phrase } -// GetAfter returns the After field if it's non-nil, zero value otherwise. -func (g *GetCodeSecurityConfigurationOptions) GetAfter() string { - if g == nil || g.After == nil { - return "" - } - return *g.After -} - -// GetBefore returns the Before field if it's non-nil, zero value otherwise. -func (g *GetCodeSecurityConfigurationOptions) GetBefore() string { - if g == nil || g.Before == nil { - return "" - } - return *g.Before -} - -// GetPerPage returns the PerPage field if it's non-nil, zero value otherwise. -func (g *GetCodeSecurityConfigurationOptions) GetPerPage() int { - if g == nil || g.PerPage == nil { - return 0 - } - return *g.PerPage -} - -// GetTargetType returns the TargetType field if it's non-nil, zero value otherwise. -func (g *GetCodeSecurityConfigurationOptions) GetTargetType() string { - if g == nil || g.TargetType == nil { - return "" - } - return *g.TargetType -} - // GetComments returns the Comments field if it's non-nil, zero value otherwise. func (g *Gist) GetComments() int { if g == nil || g.Comments == nil { @@ -14166,6 +14134,30 @@ func (l *ListDeploymentProtectionRuleResponse) GetTotalCount() int { return *l.TotalCount } +// GetAfter returns the After field if it's non-nil, zero value otherwise. +func (l *ListEnterpriseCodeSecurityConfigurationOptions) GetAfter() string { + if l == nil || l.After == nil { + return "" + } + return *l.After +} + +// GetBefore returns the Before field if it's non-nil, zero value otherwise. +func (l *ListEnterpriseCodeSecurityConfigurationOptions) GetBefore() string { + if l == nil || l.Before == nil { + return "" + } + return *l.Before +} + +// GetPerPage returns the PerPage field if it's non-nil, zero value otherwise. +func (l *ListEnterpriseCodeSecurityConfigurationOptions) GetPerPage() int { + if l == nil || l.PerPage == nil { + return 0 + } + return *l.PerPage +} + // GetDisplayName returns the DisplayName field if it's non-nil, zero value otherwise. func (l *ListExternalGroupsOptions) GetDisplayName() string { if l == nil || l.DisplayName == nil { @@ -14262,6 +14254,38 @@ func (l *ListOrganizations) GetTotalCount() int { return *l.TotalCount } +// GetAfter returns the After field if it's non-nil, zero value otherwise. +func (l *ListOrgCodeSecurityConfigurationOptions) GetAfter() string { + if l == nil || l.After == nil { + return "" + } + return *l.After +} + +// GetBefore returns the Before field if it's non-nil, zero value otherwise. +func (l *ListOrgCodeSecurityConfigurationOptions) GetBefore() string { + if l == nil || l.Before == nil { + return "" + } + return *l.Before +} + +// GetPerPage returns the PerPage field if it's non-nil, zero value otherwise. +func (l *ListOrgCodeSecurityConfigurationOptions) GetPerPage() int { + if l == nil || l.PerPage == nil { + return 0 + } + return *l.PerPage +} + +// GetTargetType returns the TargetType field if it's non-nil, zero value otherwise. +func (l *ListOrgCodeSecurityConfigurationOptions) GetTargetType() string { + if l == nil || l.TargetType == nil { + return "" + } + return *l.TargetType +} + // GetQuery returns the Query field if it's non-nil, zero value otherwise. func (l *ListProjectsOptions) GetQuery() string { if l == nil || l.Query == nil { diff --git a/github/github-accessors_test.go b/github/github-accessors_test.go index bf859984dd5..cd85326bfaf 100644 --- a/github/github-accessors_test.go +++ b/github/github-accessors_test.go @@ -12946,50 +12946,6 @@ func TestGetAuditLogOptions_GetPhrase(tt *testing.T) { g.GetPhrase() } -func TestGetCodeSecurityConfigurationOptions_GetAfter(tt *testing.T) { - tt.Parallel() - var zeroValue string - g := &GetCodeSecurityConfigurationOptions{After: &zeroValue} - g.GetAfter() - g = &GetCodeSecurityConfigurationOptions{} - g.GetAfter() - g = nil - g.GetAfter() -} - -func TestGetCodeSecurityConfigurationOptions_GetBefore(tt *testing.T) { - tt.Parallel() - var zeroValue string - g := &GetCodeSecurityConfigurationOptions{Before: &zeroValue} - g.GetBefore() - g = &GetCodeSecurityConfigurationOptions{} - g.GetBefore() - g = nil - g.GetBefore() -} - -func TestGetCodeSecurityConfigurationOptions_GetPerPage(tt *testing.T) { - tt.Parallel() - var zeroValue int - g := &GetCodeSecurityConfigurationOptions{PerPage: &zeroValue} - g.GetPerPage() - g = &GetCodeSecurityConfigurationOptions{} - g.GetPerPage() - g = nil - g.GetPerPage() -} - -func TestGetCodeSecurityConfigurationOptions_GetTargetType(tt *testing.T) { - tt.Parallel() - var zeroValue string - g := &GetCodeSecurityConfigurationOptions{TargetType: &zeroValue} - g.GetTargetType() - g = &GetCodeSecurityConfigurationOptions{} - g.GetTargetType() - g = nil - g.GetTargetType() -} - func TestGist_GetComments(tt *testing.T) { tt.Parallel() var zeroValue int @@ -18403,6 +18359,39 @@ func TestListDeploymentProtectionRuleResponse_GetTotalCount(tt *testing.T) { l.GetTotalCount() } +func TestListEnterpriseCodeSecurityConfigurationOptions_GetAfter(tt *testing.T) { + tt.Parallel() + var zeroValue string + l := &ListEnterpriseCodeSecurityConfigurationOptions{After: &zeroValue} + l.GetAfter() + l = &ListEnterpriseCodeSecurityConfigurationOptions{} + l.GetAfter() + l = nil + l.GetAfter() +} + +func TestListEnterpriseCodeSecurityConfigurationOptions_GetBefore(tt *testing.T) { + tt.Parallel() + var zeroValue string + l := &ListEnterpriseCodeSecurityConfigurationOptions{Before: &zeroValue} + l.GetBefore() + l = &ListEnterpriseCodeSecurityConfigurationOptions{} + l.GetBefore() + l = nil + l.GetBefore() +} + +func TestListEnterpriseCodeSecurityConfigurationOptions_GetPerPage(tt *testing.T) { + tt.Parallel() + var zeroValue int + l := &ListEnterpriseCodeSecurityConfigurationOptions{PerPage: &zeroValue} + l.GetPerPage() + l = &ListEnterpriseCodeSecurityConfigurationOptions{} + l.GetPerPage() + l = nil + l.GetPerPage() +} + func TestListExternalGroupsOptions_GetDisplayName(tt *testing.T) { tt.Parallel() var zeroValue string @@ -18535,6 +18524,50 @@ func TestListOrganizations_GetTotalCount(tt *testing.T) { l.GetTotalCount() } +func TestListOrgCodeSecurityConfigurationOptions_GetAfter(tt *testing.T) { + tt.Parallel() + var zeroValue string + l := &ListOrgCodeSecurityConfigurationOptions{After: &zeroValue} + l.GetAfter() + l = &ListOrgCodeSecurityConfigurationOptions{} + l.GetAfter() + l = nil + l.GetAfter() +} + +func TestListOrgCodeSecurityConfigurationOptions_GetBefore(tt *testing.T) { + tt.Parallel() + var zeroValue string + l := &ListOrgCodeSecurityConfigurationOptions{Before: &zeroValue} + l.GetBefore() + l = &ListOrgCodeSecurityConfigurationOptions{} + l.GetBefore() + l = nil + l.GetBefore() +} + +func TestListOrgCodeSecurityConfigurationOptions_GetPerPage(tt *testing.T) { + tt.Parallel() + var zeroValue int + l := &ListOrgCodeSecurityConfigurationOptions{PerPage: &zeroValue} + l.GetPerPage() + l = &ListOrgCodeSecurityConfigurationOptions{} + l.GetPerPage() + l = nil + l.GetPerPage() +} + +func TestListOrgCodeSecurityConfigurationOptions_GetTargetType(tt *testing.T) { + tt.Parallel() + var zeroValue string + l := &ListOrgCodeSecurityConfigurationOptions{TargetType: &zeroValue} + l.GetTargetType() + l = &ListOrgCodeSecurityConfigurationOptions{} + l.GetTargetType() + l = nil + l.GetTargetType() +} + func TestListProjectsOptions_GetQuery(tt *testing.T) { tt.Parallel() var zeroValue string diff --git a/github/orgs_codesecurity_configurations.go b/github/orgs_codesecurity_configurations.go index a6389010eae..177a7e001f4 100644 --- a/github/orgs_codesecurity_configurations.go +++ b/github/orgs_codesecurity_configurations.go @@ -77,7 +77,7 @@ type RepositoryCodeSecurityConfiguration struct { Configuration *CodeSecurityConfiguration `json:"configuration,omitempty"` } -// GetCodeSecurityConfigurationOptions specifies optional parameters to get security configurations for orgs/enterprises +// ListOrgCodeSecurityConfigurationOptions specifies optional parameters to get security configurations for orgs. // // Note: Pagination is powered by before/after cursor-style pagination. After the initial call, // inspect the returned *Response. Use resp.After as the opts.After value to request @@ -85,28 +85,28 @@ type RepositoryCodeSecurityConfiguration struct { // page. Set either Before or After for a request; if both are // supplied GitHub API will return an error. PerPage controls the number of items // per page (max 100 per GitHub API docs). -type GetCodeSecurityConfigurationOptions struct { - // A cursor, as given in the Link header. If specified, the query only searches for events before this cursor. +type ListOrgCodeSecurityConfigurationOptions struct { + // A cursor, as given in the Link header. If specified, the query only searches for security configurations before this cursor. Before *string `url:"before,omitempty"` - // A cursor, as given in the Link header. If specified, the query only searches for events after this cursor. + // A cursor, as given in the Link header. If specified, the query only searches for security configurations after this cursor. After *string `url:"after,omitempty"` // For paginated result sets, the number of results to include per page. PerPage *int `url:"per_page,omitempty"` - // The target type of the code security configurations to get, only valid for the organization endpoint. + // The target type of the code security configurations to get. // // `target_type` defaults to all, can be one of global, all TargetType *string `url:"target_type,omitempty"` } -// GetCodeSecurityConfigurations gets code security configurations for an organization. +// ListCodeSecurityConfigurations gets code security configurations for an organization. // // GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-code-security-configurations-for-an-organization // //meta:operation GET /orgs/{org}/code-security/configurations -func (s *OrganizationsService) GetCodeSecurityConfigurations(ctx context.Context, org string, opts *GetCodeSecurityConfigurationOptions) ([]*CodeSecurityConfiguration, *Response, error) { +func (s *OrganizationsService) ListCodeSecurityConfigurations(ctx context.Context, org string, opts *ListOrgCodeSecurityConfigurationOptions) ([]*CodeSecurityConfiguration, *Response, error) { u := fmt.Sprintf("orgs/%v/code-security/configurations", org) u, err := addOptions(u, opts) if err != nil { @@ -131,7 +131,7 @@ func (s *OrganizationsService) GetCodeSecurityConfigurations(ctx context.Context // GitHub API docs: https://docs.github.com/rest/code-security/configurations#create-a-code-security-configuration // //meta:operation POST /orgs/{org}/code-security/configurations -func (s *OrganizationsService) CreateCodeSecurityConfiguration(ctx context.Context, org string, config *CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) { +func (s *OrganizationsService) CreateCodeSecurityConfiguration(ctx context.Context, org string, config CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) { u := fmt.Sprintf("orgs/%v/code-security/configurations", org) req, err := s.client.NewRequest("POST", u, config) @@ -189,12 +189,12 @@ func (s *OrganizationsService) DetachCodeSecurityConfigurationsFromRepositories( return resp, nil } -// GetCodeSecurityConfiguration gets a code security configuration available in an organization. +// ListCodeSecurityConfiguration gets a code security configuration available in an organization. // // GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-a-code-security-configuration // //meta:operation GET /orgs/{org}/code-security/configurations/{configuration_id} -func (s *OrganizationsService) GetCodeSecurityConfiguration(ctx context.Context, org string, id int64) (*CodeSecurityConfiguration, *Response, error) { +func (s *OrganizationsService) ListCodeSecurityConfiguration(ctx context.Context, org string, id int64) (*CodeSecurityConfiguration, *Response, error) { u := fmt.Sprintf("orgs/%v/code-security/configurations/%v", org, id) req, err := s.client.NewRequest("GET", u, nil) @@ -215,7 +215,7 @@ func (s *OrganizationsService) GetCodeSecurityConfiguration(ctx context.Context, // GitHub API docs: https://docs.github.com/rest/code-security/configurations#update-a-code-security-configuration // //meta:operation PATCH /orgs/{org}/code-security/configurations/{configuration_id} -func (s *OrganizationsService) UpdateCodeSecurityConfiguration(ctx context.Context, org string, id int64, config *CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) { +func (s *OrganizationsService) UpdateCodeSecurityConfiguration(ctx context.Context, org string, id int64, config CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) { u := fmt.Sprintf("orgs/%v/code-security/configurations/%v", org, id) req, err := s.client.NewRequest("PATCH", u, config) @@ -316,12 +316,12 @@ func (s *OrganizationsService) GetRepositoriesForCodeSecurityConfiguration(ctx c return attachments, resp, nil } -// GetCodeSecurityConfigurationForRepository gets code security configuration that manages a repository's code security settings. +// ListCodeSecurityConfigurationForRepository gets code security configuration that manages a repository's code security settings. // // GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-the-code-security-configuration-associated-with-a-repository // //meta:operation GET /repos/{owner}/{repo}/code-security-configuration -func (s *OrganizationsService) GetCodeSecurityConfigurationForRepository(ctx context.Context, org, repo string) (*RepositoryCodeSecurityConfiguration, *Response, error) { +func (s *OrganizationsService) ListCodeSecurityConfigurationForRepository(ctx context.Context, org, repo string) (*RepositoryCodeSecurityConfiguration, *Response, error) { u := fmt.Sprintf("repos/%v/%v/code-security-configuration", org, repo) req, err := s.client.NewRequest("GET", u, nil) diff --git a/github/orgs_codesecurity_configurations_test.go b/github/orgs_codesecurity_configurations_test.go index 23b410c0b44..aa62d75ff79 100644 --- a/github/orgs_codesecurity_configurations_test.go +++ b/github/orgs_codesecurity_configurations_test.go @@ -14,9 +14,9 @@ import ( "github.com/google/go-cmp/cmp" ) -func TestOrganizationsService_GetCodeSecurityConfigurations(t *testing.T) { +func TestOrganizationsService_ListCodeSecurityConfigurations(t *testing.T) { t.Parallel() - opts := &GetCodeSecurityConfigurationOptions{Before: Ptr("1"), After: Ptr("2"), PerPage: Ptr(30), TargetType: Ptr("all")} + opts := &ListOrgCodeSecurityConfigurationOptions{Before: Ptr("1"), After: Ptr("2"), PerPage: Ptr(30), TargetType: Ptr("all")} ctx := t.Context() client, mux, _ := setup(t) @@ -38,9 +38,9 @@ func TestOrganizationsService_GetCodeSecurityConfigurations(t *testing.T) { }]`) }) - configurations, _, err := client.Organizations.GetCodeSecurityConfigurations(ctx, "o", opts) + configurations, _, err := client.Organizations.ListCodeSecurityConfigurations(ctx, "o", opts) if err != nil { - t.Errorf("Organizations.GetCodeSecurityConfigurations returned error: %v", err) + t.Errorf("Organizations.ListCodeSecurityConfigurations returned error: %v", err) } want := []*CodeSecurityConfiguration{ @@ -48,15 +48,15 @@ func TestOrganizationsService_GetCodeSecurityConfigurations(t *testing.T) { {ID: Ptr(int64(2)), Name: "config2", Description: "desc2", PrivateVulnerabilityReporting: Ptr("enabled")}, } if !cmp.Equal(configurations, want) { - t.Errorf("Organizations.GetCodeSecurityConfigurations returned %+v, want %+v", configurations, want) + t.Errorf("Organizations.ListCodeSecurityConfigurations returned %+v, want %+v", configurations, want) } - const methodName = "GetCodeSecurityConfigurations" + const methodName = "ListCodeSecurityConfigurations" testBadOptions(t, methodName, func() (err error) { - _, _, err = client.Organizations.GetCodeSecurityConfigurations(ctx, "\n", opts) + _, _, err = client.Organizations.ListCodeSecurityConfigurations(ctx, "\n", opts) return err }) testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { - got, resp, err := client.Organizations.GetCodeSecurityConfigurations(ctx, "o", opts) + got, resp, err := client.Organizations.ListCodeSecurityConfigurations(ctx, "o", opts) if got != nil { t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) } @@ -64,7 +64,7 @@ func TestOrganizationsService_GetCodeSecurityConfigurations(t *testing.T) { }) } -func TestOrganizationsService_GetCodeSecurityConfiguration(t *testing.T) { +func TestOrganizationsService_ListCodeSecurityConfiguration(t *testing.T) { t.Parallel() client, mux, _ := setup(t) ctx := t.Context() @@ -79,24 +79,24 @@ func TestOrganizationsService_GetCodeSecurityConfiguration(t *testing.T) { }`) }) - configuration, _, err := client.Organizations.GetCodeSecurityConfiguration(ctx, "o", 1) + configuration, _, err := client.Organizations.ListCodeSecurityConfiguration(ctx, "o", 1) if err != nil { - t.Errorf("Organizations.GetCodeSecurityConfiguration returned error: %v", err) + t.Errorf("Organizations.ListCodeSecurityConfiguration returned error: %v", err) } want := &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: "config1", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled")} if !cmp.Equal(configuration, want) { - t.Errorf("Organizations.GetCodeSecurityConfiguration returned %+v, want %+v", configuration, want) + t.Errorf("Organizations.ListCodeSecurityConfiguration returned %+v, want %+v", configuration, want) } - const methodName = "GetCodeSecurityConfiguration" + const methodName = "ListCodeSecurityConfiguration" testBadOptions(t, methodName, func() (err error) { - _, _, err = client.Organizations.GetCodeSecurityConfiguration(ctx, "\n", -1) + _, _, err = client.Organizations.ListCodeSecurityConfiguration(ctx, "\n", -1) return err }) testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { - got, resp, err := client.Organizations.GetCodeSecurityConfiguration(ctx, "o", 1) + got, resp, err := client.Organizations.ListCodeSecurityConfiguration(ctx, "o", 1) if got != nil { t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) } @@ -109,15 +109,15 @@ func TestOrganizationsService_CreateCodeSecurityConfiguration(t *testing.T) { client, mux, _ := setup(t) ctx := t.Context() - input := &CodeSecurityConfiguration{ + input := CodeSecurityConfiguration{ Name: "config1", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled"), } mux.HandleFunc("/orgs/o/code-security/configurations", func(w http.ResponseWriter, r *http.Request) { - v := new(CodeSecurityConfiguration) - assertNilError(t, json.NewDecoder(r.Body).Decode(v)) + var v CodeSecurityConfiguration + assertNilError(t, json.NewDecoder(r.Body).Decode(&v)) if !cmp.Equal(v, input) { t.Errorf("Organizations.CreateCodeSecurityConfiguration request body = %+v, want %+v", v, input) @@ -250,15 +250,15 @@ func TestOrganizationsService_UpdateCodeSecurityConfiguration(t *testing.T) { ctx := t.Context() client, mux, _ := setup(t) - input := &CodeSecurityConfiguration{ + input := CodeSecurityConfiguration{ Name: "config1", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled"), } mux.HandleFunc("/orgs/o/code-security/configurations/1", func(w http.ResponseWriter, r *http.Request) { - v := new(CodeSecurityConfiguration) - assertNilError(t, json.NewDecoder(r.Body).Decode(v)) + var v CodeSecurityConfiguration + assertNilError(t, json.NewDecoder(r.Body).Decode(&v)) if !cmp.Equal(v, input) { t.Errorf("Organizations.UpdateCodeSecurityConfiguration request body = %+v, want %+v", v, input) @@ -477,7 +477,7 @@ func TestOrganizationsService_GetRepositoriesForCodeSecurityConfiguration(t *tes }) } -func TestOrganizationsService_GetCodeSecurityConfigurationForRepository(t *testing.T) { +func TestOrganizationsService_ListCodeSecurityConfigurationForRepository(t *testing.T) { t.Parallel() ctx := t.Context() client, mux, _ := setup(t) @@ -495,9 +495,9 @@ func TestOrganizationsService_GetCodeSecurityConfigurationForRepository(t *testi }`) }) - rc, _, err := client.Organizations.GetCodeSecurityConfigurationForRepository(ctx, "o", "repo8") + rc, _, err := client.Organizations.ListCodeSecurityConfigurationForRepository(ctx, "o", "repo8") if err != nil { - t.Errorf("Organizations.GetCodeSecurityConfigurationForRepository returned error: %v", err) + t.Errorf("Organizations.ListCodeSecurityConfigurationForRepository returned error: %v", err) } c := &CodeSecurityConfiguration{ID: Ptr(int64(42)), Name: "config42", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled")} want := &RepositoryCodeSecurityConfiguration{ @@ -505,17 +505,17 @@ func TestOrganizationsService_GetCodeSecurityConfigurationForRepository(t *testi Configuration: c, } if !cmp.Equal(rc, want) { - t.Errorf("Organizations.GetCodeSecurityConfigurationForRepository returned %+v, want %+v", rc, want) + t.Errorf("Organizations.ListCodeSecurityConfigurationForRepository returned %+v, want %+v", rc, want) } - const methodName = "GetCodeSecurityConfigurationForRepository" + const methodName = "ListCodeSecurityConfigurationForRepository" testBadOptions(t, methodName, func() (err error) { - _, _, err = client.Organizations.GetCodeSecurityConfigurationForRepository(ctx, "\n", "\n") + _, _, err = client.Organizations.ListCodeSecurityConfigurationForRepository(ctx, "\n", "\n") return }) testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { - got, resp, err := client.Organizations.GetCodeSecurityConfigurationForRepository(ctx, "o", "repo8") + got, resp, err := client.Organizations.ListCodeSecurityConfigurationForRepository(ctx, "o", "repo8") if got != nil { t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) } From fe26ce7258b17837de11ad48f7a2e7118d09124e Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tim=20H=C3=A4ring?= Date: Thu, 13 Nov 2025 11:11:52 +0100 Subject: [PATCH 7/8] fix: consistent/explicit naming, pagination opts --- .../enterprise_codesecurity_configurations.go | 38 ++++++----- ...rprise_codesecurity_configurations_test.go | 44 ++++++------ github/github-accessors.go | 32 +++++++++ github/github-accessors_test.go | 44 ++++++++++++ github/orgs_codesecurity_configurations.go | 68 +++++++++++++------ .../orgs_codesecurity_configurations_test.go | 58 ++++++++-------- 6 files changed, 198 insertions(+), 86 deletions(-) diff --git a/github/enterprise_codesecurity_configurations.go b/github/enterprise_codesecurity_configurations.go index 27e07583440..9de729cae93 100644 --- a/github/enterprise_codesecurity_configurations.go +++ b/github/enterprise_codesecurity_configurations.go @@ -76,12 +76,12 @@ func (s *EnterpriseService) CreateCodeSecurityConfiguration(ctx context.Context, return configuration, resp, nil } -// GetDefaultCodeSecurityConfigurations lists the default code security configurations for an enterprise. +// ListDefaultCodeSecurityConfigurations lists the default code security configurations for an enterprise. // // GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-default-code-security-configurations-for-an-enterprise // //meta:operation GET /enterprises/{enterprise}/code-security/configurations/defaults -func (s *EnterpriseService) GetDefaultCodeSecurityConfigurations(ctx context.Context, enterprise string) ([]*CodeSecurityConfigurationWithDefaultForNewRepos, *Response, error) { +func (s *EnterpriseService) ListDefaultCodeSecurityConfigurations(ctx context.Context, enterprise string) ([]*CodeSecurityConfigurationWithDefaultForNewRepos, *Response, error) { u := fmt.Sprintf("enterprises/%v/code-security/configurations/defaults", enterprise) req, err := s.client.NewRequest("GET", u, nil) @@ -97,13 +97,13 @@ func (s *EnterpriseService) GetDefaultCodeSecurityConfigurations(ctx context.Con return configurations, resp, nil } -// ListCodeSecurityConfiguration gets a code security configuration available in an enterprise. +// GetCodeSecurityConfiguration gets a code security configuration available in an enterprise. // // GitHub API docs: https://docs.github.com/rest/code-security/configurations#retrieve-a-code-security-configuration-of-an-enterprise // //meta:operation GET /enterprises/{enterprise}/code-security/configurations/{configuration_id} -func (s *EnterpriseService) ListCodeSecurityConfiguration(ctx context.Context, enterprise string, id int64) (*CodeSecurityConfiguration, *Response, error) { - u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v", enterprise, id) +func (s *EnterpriseService) GetCodeSecurityConfiguration(ctx context.Context, enterprise string, configurationID int64) (*CodeSecurityConfiguration, *Response, error) { + u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v", enterprise, configurationID) req, err := s.client.NewRequest("GET", u, nil) if err != nil { @@ -123,8 +123,8 @@ func (s *EnterpriseService) ListCodeSecurityConfiguration(ctx context.Context, e // GitHub API docs: https://docs.github.com/rest/code-security/configurations#update-a-custom-code-security-configuration-for-an-enterprise // //meta:operation PATCH /enterprises/{enterprise}/code-security/configurations/{configuration_id} -func (s *EnterpriseService) UpdateCodeSecurityConfiguration(ctx context.Context, enterprise string, id int64, config CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) { - u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v", enterprise, id) +func (s *EnterpriseService) UpdateCodeSecurityConfiguration(ctx context.Context, enterprise string, configurationID int64, config CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) { + u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v", enterprise, configurationID) req, err := s.client.NewRequest("PATCH", u, config) if err != nil { @@ -144,8 +144,8 @@ func (s *EnterpriseService) UpdateCodeSecurityConfiguration(ctx context.Context, // GitHub API docs: https://docs.github.com/rest/code-security/configurations#delete-a-code-security-configuration-for-an-enterprise // //meta:operation DELETE /enterprises/{enterprise}/code-security/configurations/{configuration_id} -func (s *EnterpriseService) DeleteCodeSecurityConfiguration(ctx context.Context, enterprise string, id int64) (*Response, error) { - u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v", enterprise, id) +func (s *EnterpriseService) DeleteCodeSecurityConfiguration(ctx context.Context, enterprise string, configurationID int64) (*Response, error) { + u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v", enterprise, configurationID) req, err := s.client.NewRequest("DELETE", u, nil) if err != nil { @@ -165,8 +165,8 @@ func (s *EnterpriseService) DeleteCodeSecurityConfiguration(ctx context.Context, // GitHub API docs: https://docs.github.com/rest/code-security/configurations#attach-an-enterprise-configuration-to-repositories // //meta:operation POST /enterprises/{enterprise}/code-security/configurations/{configuration_id}/attach -func (s *EnterpriseService) AttachCodeSecurityConfigurationToRepositories(ctx context.Context, enterprise string, id int64, scope string) (*Response, error) { - u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v/attach", enterprise, id) +func (s *EnterpriseService) AttachCodeSecurityConfigurationToRepositories(ctx context.Context, enterprise string, configurationID int64, scope string) (*Response, error) { + u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v/attach", enterprise, configurationID) type scopeType struct { Scope string `json:"scope"` } @@ -184,13 +184,13 @@ func (s *EnterpriseService) AttachCodeSecurityConfigurationToRepositories(ctx co // SetDefaultCodeSecurityConfiguration sets a code security configuration as a default for an enterprise. // `defaultForNewRepos` specifies which types of repository this security configuration should be applied to by default. -// Can be one of: `all`, `none`, `private_and_internal, public`. +// Can be one of: `all`, `none`, `private_and_internal`, `public`. // // GitHub API docs: https://docs.github.com/rest/code-security/configurations#set-a-code-security-configuration-as-a-default-for-an-enterprise // //meta:operation PUT /enterprises/{enterprise}/code-security/configurations/{configuration_id}/defaults -func (s *EnterpriseService) SetDefaultCodeSecurityConfiguration(ctx context.Context, enterprise string, id int64, defaultForNewRepos string) (*CodeSecurityConfigurationWithDefaultForNewRepos, *Response, error) { - u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v/defaults", enterprise, id) +func (s *EnterpriseService) SetDefaultCodeSecurityConfiguration(ctx context.Context, enterprise string, configurationID int64, defaultForNewRepos string) (*CodeSecurityConfigurationWithDefaultForNewRepos, *Response, error) { + u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v/defaults", enterprise, configurationID) type configParam struct { DefaultForNewRepos string `json:"default_for_new_repos"` } @@ -207,13 +207,17 @@ func (s *EnterpriseService) SetDefaultCodeSecurityConfiguration(ctx context.Cont return config, resp, nil } -// GetRepositoriesForCodeSecurityConfiguration lists the repositories associated with an enterprise code security configuration. +// ListRepositoriesForCodeSecurityConfiguration lists the repositories associated with an enterprise code security configuration. // // GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-repositories-associated-with-an-enterprise-code-security-configuration // //meta:operation GET /enterprises/{enterprise}/code-security/configurations/{configuration_id}/repositories -func (s *EnterpriseService) GetRepositoriesForCodeSecurityConfiguration(ctx context.Context, enterprise string, id int64) ([]*RepositoryAttachment, *Response, error) { - u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v/repositories", enterprise, id) +func (s *EnterpriseService) ListRepositoriesForCodeSecurityConfiguration(ctx context.Context, enterprise string, configurationID int64, opts *ListRepositoriesForCodeSecurityConfigurationOptions) ([]*RepositoryAttachment, *Response, error) { + u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v/repositories", enterprise, configurationID) + u, err := addOptions(u, opts) + if err != nil { + return nil, nil, err + } req, err := s.client.NewRequest("GET", u, nil) if err != nil { diff --git a/github/enterprise_codesecurity_configurations_test.go b/github/enterprise_codesecurity_configurations_test.go index 1f4ea1774e2..fea7200db17 100644 --- a/github/enterprise_codesecurity_configurations_test.go +++ b/github/enterprise_codesecurity_configurations_test.go @@ -64,7 +64,7 @@ func TestEnterpriseService_ListCodeSecurityConfigurations(t *testing.T) { }) } -func TestEnterpriseService_ListCodeSecurityConfiguration(t *testing.T) { +func TestEnterpriseService_GetCodeSecurityConfiguration(t *testing.T) { t.Parallel() client, mux, _ := setup(t) ctx := t.Context() @@ -79,24 +79,24 @@ func TestEnterpriseService_ListCodeSecurityConfiguration(t *testing.T) { }`) }) - configuration, _, err := client.Enterprise.ListCodeSecurityConfiguration(ctx, "e", 1) + configuration, _, err := client.Enterprise.GetCodeSecurityConfiguration(ctx, "e", 1) if err != nil { - t.Errorf("Enterprise.ListCodeSecurityConfiguration returned error: %v", err) + t.Errorf("Enterprise.GetCodeSecurityConfiguration returned error: %v", err) } want := &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: "config1", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled")} if !cmp.Equal(configuration, want) { - t.Errorf("Enterprise.ListCodeSecurityConfiguration returned %+v, want %+v", configuration, want) + t.Errorf("Enterprise.GetCodeSecurityConfiguration returned %+v, want %+v", configuration, want) } - const methodName = "ListCodeSecurityConfiguration" + const methodName = "GetCodeSecurityConfiguration" testBadOptions(t, methodName, func() (err error) { - _, _, err = client.Enterprise.ListCodeSecurityConfiguration(ctx, "\n", -1) + _, _, err = client.Enterprise.GetCodeSecurityConfiguration(ctx, "\n", -1) return err }) testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { - got, resp, err := client.Enterprise.ListCodeSecurityConfiguration(ctx, "e", 1) + got, resp, err := client.Enterprise.GetCodeSecurityConfiguration(ctx, "e", 1) if got != nil { t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) } @@ -156,7 +156,7 @@ func TestEnterpriseService_CreateCodeSecurityConfiguration(t *testing.T) { }) } -func TestEnterpriseService_GetDefaultCodeSecurityConfigurations(t *testing.T) { +func TestEnterpriseService_ListDefaultCodeSecurityConfigurations(t *testing.T) { t.Parallel() client, mux, _ := setup(t) ctx := t.Context() @@ -185,9 +185,9 @@ func TestEnterpriseService_GetDefaultCodeSecurityConfigurations(t *testing.T) { ]`) }) - configurations, _, err := client.Enterprise.GetDefaultCodeSecurityConfigurations(ctx, "e") + configurations, _, err := client.Enterprise.ListDefaultCodeSecurityConfigurations(ctx, "e") if err != nil { - t.Errorf("Enterprise.GetDefaultCodeSecurityConfigurations returned error: %v", err) + t.Errorf("Enterprise.ListDefaultCodeSecurityConfigurations returned error: %v", err) } want := []*CodeSecurityConfigurationWithDefaultForNewRepos{ @@ -195,17 +195,17 @@ func TestEnterpriseService_GetDefaultCodeSecurityConfigurations(t *testing.T) { {DefaultForNewRepos: Ptr("private_and_internal"), Configuration: &CodeSecurityConfiguration{ID: Ptr(int64(2)), Name: "config2", Description: "desc2", PrivateVulnerabilityReporting: Ptr("enabled")}}, } if !cmp.Equal(configurations, want) { - t.Errorf("Enterprise.GetDefaultCodeSecurityConfigurations returned %+v, want %+v", configurations, want) + t.Errorf("Enterprise.ListDefaultCodeSecurityConfigurations returned %+v, want %+v", configurations, want) } - const methodName = "GetDefaultCodeSecurityConfigurations" + const methodName = "ListDefaultCodeSecurityConfigurations" testBadOptions(t, methodName, func() (err error) { - _, _, err = client.Enterprise.GetDefaultCodeSecurityConfigurations(ctx, "\n") + _, _, err = client.Enterprise.ListDefaultCodeSecurityConfigurations(ctx, "\n") return err }) testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { - got, resp, err := client.Enterprise.GetDefaultCodeSecurityConfigurations(ctx, "e") + got, resp, err := client.Enterprise.ListDefaultCodeSecurityConfigurations(ctx, "e") if got != nil { t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) } @@ -389,13 +389,15 @@ func TestEnterpriseService_SetDefaultCodeSecurityConfiguration(t *testing.T) { }) } -func TestEnterpriseService_GetRepositoriesForCodeSecurityConfiguration(t *testing.T) { +func TestEnterpriseService_ListRepositoriesForCodeSecurityConfiguration(t *testing.T) { t.Parallel() + opts := &ListRepositoriesForCodeSecurityConfigurationOptions{Before: Ptr("1"), After: Ptr("2"), PerPage: Ptr(30), Status: Ptr("attached")} ctx := t.Context() client, mux, _ := setup(t) mux.HandleFunc("/enterprises/e/code-security/configurations/1/repositories", func(w http.ResponseWriter, r *http.Request) { testMethod(t, r, "GET") + testFormValues(t, r, values{"before": "1", "after": "2", "per_page": "30", "status": "attached"}) fmt.Fprint(w, `[ { "status": "attached", @@ -414,26 +416,26 @@ func TestEnterpriseService_GetRepositoriesForCodeSecurityConfiguration(t *testin ]`) }) - attachments, _, err := client.Enterprise.GetRepositoriesForCodeSecurityConfiguration(ctx, "e", 1) + attachments, _, err := client.Enterprise.ListRepositoriesForCodeSecurityConfiguration(ctx, "e", 1, opts) if err != nil { - t.Errorf("Enterprise.GetRepositoriesForCodeSecurityConfiguration returned error: %v", err) + t.Errorf("Enterprise.ListRepositoriesForCodeSecurityConfiguration returned error: %v", err) } want := []*RepositoryAttachment{ {Status: Ptr("attached"), Repository: &Repository{ID: Ptr(int64(8)), Name: Ptr("repo8")}}, {Status: Ptr("attached"), Repository: &Repository{ID: Ptr(int64(42)), Name: Ptr("repo42")}}, } if !cmp.Equal(attachments, want) { - t.Errorf("Enterprise.GetRepositoriesForCodeSecurityConfiguration returned %+v, want %+v", attachments, want) + t.Errorf("Enterprise.ListRepositoriesForCodeSecurityConfiguration returned %+v, want %+v", attachments, want) } - const methodName = "GetRepositoriesForCodeSecurityConfiguration" + const methodName = "ListRepositoriesForCodeSecurityConfiguration" testBadOptions(t, methodName, func() (err error) { - _, _, err = client.Enterprise.GetRepositoriesForCodeSecurityConfiguration(ctx, "\n", -1) + _, _, err = client.Enterprise.ListRepositoriesForCodeSecurityConfiguration(ctx, "\n", -1, opts) return }) testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { - got, resp, err := client.Enterprise.GetRepositoriesForCodeSecurityConfiguration(ctx, "e", 1) + got, resp, err := client.Enterprise.ListRepositoriesForCodeSecurityConfiguration(ctx, "e", 1, opts) if got != nil { t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) } diff --git a/github/github-accessors.go b/github/github-accessors.go index 5a5b79467d7..f2a77b30f59 100644 --- a/github/github-accessors.go +++ b/github/github-accessors.go @@ -14326,6 +14326,38 @@ func (l *ListRepositories) GetTotalCount() int { return *l.TotalCount } +// GetAfter returns the After field if it's non-nil, zero value otherwise. +func (l *ListRepositoriesForCodeSecurityConfigurationOptions) GetAfter() string { + if l == nil || l.After == nil { + return "" + } + return *l.After +} + +// GetBefore returns the Before field if it's non-nil, zero value otherwise. +func (l *ListRepositoriesForCodeSecurityConfigurationOptions) GetBefore() string { + if l == nil || l.Before == nil { + return "" + } + return *l.Before +} + +// GetPerPage returns the PerPage field if it's non-nil, zero value otherwise. +func (l *ListRepositoriesForCodeSecurityConfigurationOptions) GetPerPage() int { + if l == nil || l.PerPage == nil { + return 0 + } + return *l.PerPage +} + +// GetStatus returns the Status field if it's non-nil, zero value otherwise. +func (l *ListRepositoriesForCodeSecurityConfigurationOptions) GetStatus() string { + if l == nil || l.Status == nil { + return "" + } + return *l.Status +} + // GetName returns the Name field if it's non-nil, zero value otherwise. func (l *ListRunnersOptions) GetName() string { if l == nil || l.Name == nil { diff --git a/github/github-accessors_test.go b/github/github-accessors_test.go index cd85326bfaf..6a2a7dc85e3 100644 --- a/github/github-accessors_test.go +++ b/github/github-accessors_test.go @@ -18623,6 +18623,50 @@ func TestListRepositories_GetTotalCount(tt *testing.T) { l.GetTotalCount() } +func TestListRepositoriesForCodeSecurityConfigurationOptions_GetAfter(tt *testing.T) { + tt.Parallel() + var zeroValue string + l := &ListRepositoriesForCodeSecurityConfigurationOptions{After: &zeroValue} + l.GetAfter() + l = &ListRepositoriesForCodeSecurityConfigurationOptions{} + l.GetAfter() + l = nil + l.GetAfter() +} + +func TestListRepositoriesForCodeSecurityConfigurationOptions_GetBefore(tt *testing.T) { + tt.Parallel() + var zeroValue string + l := &ListRepositoriesForCodeSecurityConfigurationOptions{Before: &zeroValue} + l.GetBefore() + l = &ListRepositoriesForCodeSecurityConfigurationOptions{} + l.GetBefore() + l = nil + l.GetBefore() +} + +func TestListRepositoriesForCodeSecurityConfigurationOptions_GetPerPage(tt *testing.T) { + tt.Parallel() + var zeroValue int + l := &ListRepositoriesForCodeSecurityConfigurationOptions{PerPage: &zeroValue} + l.GetPerPage() + l = &ListRepositoriesForCodeSecurityConfigurationOptions{} + l.GetPerPage() + l = nil + l.GetPerPage() +} + +func TestListRepositoriesForCodeSecurityConfigurationOptions_GetStatus(tt *testing.T) { + tt.Parallel() + var zeroValue string + l := &ListRepositoriesForCodeSecurityConfigurationOptions{Status: &zeroValue} + l.GetStatus() + l = &ListRepositoriesForCodeSecurityConfigurationOptions{} + l.GetStatus() + l = nil + l.GetStatus() +} + func TestListRunnersOptions_GetName(tt *testing.T) { tt.Parallel() var zeroValue string diff --git a/github/orgs_codesecurity_configurations.go b/github/orgs_codesecurity_configurations.go index 177a7e001f4..ff33100ebae 100644 --- a/github/orgs_codesecurity_configurations.go +++ b/github/orgs_codesecurity_configurations.go @@ -68,7 +68,7 @@ type CodeSecurityConfiguration struct { // CodeSecurityConfigurationWithDefaultForNewRepos represents a code security configuration with default for new repos param. type CodeSecurityConfigurationWithDefaultForNewRepos struct { Configuration *CodeSecurityConfiguration `json:"configuration"` - DefaultForNewRepos *string `json:"default_for_new_repos"` + DefaultForNewRepos *string `json:"default_for_new_repos,omitempty"` } // RepositoryCodeSecurityConfiguration represents a code security configuration for a repository. @@ -97,10 +97,34 @@ type ListOrgCodeSecurityConfigurationOptions struct { // The target type of the code security configurations to get. // - // `target_type` defaults to all, can be one of global, all + // `target_type` defaults to all, can be one of `global`, `all` TargetType *string `url:"target_type,omitempty"` } +// ListRepositoriesForCodeSecurityConfigurationOptions specifies optional parameters to list repositories for security configurations for orgs and enterprises. +// +// Note: Pagination is powered by before/after cursor-style pagination. After the initial call, +// inspect the returned *Response. Use resp.After as the opts.After value to request +// the next page, and resp.Before as the opts.Before value to request the previous +// page. Set either Before or After for a request; if both are +// supplied GitHub API will return an error. PerPage controls the number of items +// per page (max 100 per GitHub API docs). +type ListRepositoriesForCodeSecurityConfigurationOptions struct { + // A cursor, as given in the Link header. If specified, the query only searches for repositories before this cursor. + Before *string `url:"before,omitempty"` + + // A cursor, as given in the Link header. If specified, the query only searches for repositories after this cursor. + After *string `url:"after,omitempty"` + + // For paginated result sets, the number of results to include per page. + PerPage *int `url:"per_page,omitempty"` + + // A comma-separated list of statuses. If specified, only repositories with these attachment statuses will be returned. + // + // `status` defaults to all, can be one of `all`, `attached`, `attaching`, `removed`, `enforced`, `failed`, `updating`, `removed_by_enterprise` and also `detached` but only for the org endpoint. + Status *string `url:"status,omitempty"` +} + // ListCodeSecurityConfigurations gets code security configurations for an organization. // // GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-code-security-configurations-for-an-organization @@ -147,12 +171,12 @@ func (s *OrganizationsService) CreateCodeSecurityConfiguration(ctx context.Conte return configuration, resp, nil } -// GetDefaultCodeSecurityConfigurations gets default code security configurations for an organization. +// ListDefaultCodeSecurityConfigurations gets default code security configurations for an organization. // // GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-default-code-security-configurations // //meta:operation GET /orgs/{org}/code-security/configurations/defaults -func (s *OrganizationsService) GetDefaultCodeSecurityConfigurations(ctx context.Context, org string) ([]*CodeSecurityConfigurationWithDefaultForNewRepos, *Response, error) { +func (s *OrganizationsService) ListDefaultCodeSecurityConfigurations(ctx context.Context, org string) ([]*CodeSecurityConfigurationWithDefaultForNewRepos, *Response, error) { u := fmt.Sprintf("orgs/%v/code-security/configurations/defaults", org) req, err := s.client.NewRequest("GET", u, nil) @@ -189,13 +213,13 @@ func (s *OrganizationsService) DetachCodeSecurityConfigurationsFromRepositories( return resp, nil } -// ListCodeSecurityConfiguration gets a code security configuration available in an organization. +// GetCodeSecurityConfiguration gets a code security configuration available in an organization. // // GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-a-code-security-configuration // //meta:operation GET /orgs/{org}/code-security/configurations/{configuration_id} -func (s *OrganizationsService) ListCodeSecurityConfiguration(ctx context.Context, org string, id int64) (*CodeSecurityConfiguration, *Response, error) { - u := fmt.Sprintf("orgs/%v/code-security/configurations/%v", org, id) +func (s *OrganizationsService) GetCodeSecurityConfiguration(ctx context.Context, org string, configurationID int64) (*CodeSecurityConfiguration, *Response, error) { + u := fmt.Sprintf("orgs/%v/code-security/configurations/%v", org, configurationID) req, err := s.client.NewRequest("GET", u, nil) if err != nil { @@ -215,8 +239,8 @@ func (s *OrganizationsService) ListCodeSecurityConfiguration(ctx context.Context // GitHub API docs: https://docs.github.com/rest/code-security/configurations#update-a-code-security-configuration // //meta:operation PATCH /orgs/{org}/code-security/configurations/{configuration_id} -func (s *OrganizationsService) UpdateCodeSecurityConfiguration(ctx context.Context, org string, id int64, config CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) { - u := fmt.Sprintf("orgs/%v/code-security/configurations/%v", org, id) +func (s *OrganizationsService) UpdateCodeSecurityConfiguration(ctx context.Context, org string, configurationID int64, config CodeSecurityConfiguration) (*CodeSecurityConfiguration, *Response, error) { + u := fmt.Sprintf("orgs/%v/code-security/configurations/%v", org, configurationID) req, err := s.client.NewRequest("PATCH", u, config) if err != nil { @@ -236,8 +260,8 @@ func (s *OrganizationsService) UpdateCodeSecurityConfiguration(ctx context.Conte // GitHub API docs: https://docs.github.com/rest/code-security/configurations#delete-a-code-security-configuration // //meta:operation DELETE /orgs/{org}/code-security/configurations/{configuration_id} -func (s *OrganizationsService) DeleteCodeSecurityConfiguration(ctx context.Context, org string, id int64) (*Response, error) { - u := fmt.Sprintf("orgs/%v/code-security/configurations/%v", org, id) +func (s *OrganizationsService) DeleteCodeSecurityConfiguration(ctx context.Context, org string, configurationID int64) (*Response, error) { + u := fmt.Sprintf("orgs/%v/code-security/configurations/%v", org, configurationID) req, err := s.client.NewRequest("DELETE", u, nil) if err != nil { @@ -255,8 +279,8 @@ func (s *OrganizationsService) DeleteCodeSecurityConfiguration(ctx context.Conte // GitHub API docs: https://docs.github.com/rest/code-security/configurations#attach-a-configuration-to-repositories // //meta:operation POST /orgs/{org}/code-security/configurations/{configuration_id}/attach -func (s *OrganizationsService) AttachCodeSecurityConfigurationToRepositories(ctx context.Context, org string, id int64, scope string, repoIDs []int64) (*Response, error) { - u := fmt.Sprintf("orgs/%v/code-security/configurations/%v/attach", org, id) +func (s *OrganizationsService) AttachCodeSecurityConfigurationToRepositories(ctx context.Context, org string, configurationID int64, scope string, repoIDs []int64) (*Response, error) { + u := fmt.Sprintf("orgs/%v/code-security/configurations/%v/attach", org, configurationID) type selectedRepoIDs struct { Scope string `json:"scope"` SelectedIDs []int64 `json:"selected_repository_ids,omitempty"` @@ -277,8 +301,8 @@ func (s *OrganizationsService) AttachCodeSecurityConfigurationToRepositories(ctx // GitHub API docs: https://docs.github.com/rest/code-security/configurations#set-a-code-security-configuration-as-a-default-for-an-organization // //meta:operation PUT /orgs/{org}/code-security/configurations/{configuration_id}/defaults -func (s *OrganizationsService) SetDefaultCodeSecurityConfiguration(ctx context.Context, org string, id int64, newReposParam string) (*CodeSecurityConfigurationWithDefaultForNewRepos, *Response, error) { - u := fmt.Sprintf("orgs/%v/code-security/configurations/%v/defaults", org, id) +func (s *OrganizationsService) SetDefaultCodeSecurityConfiguration(ctx context.Context, org string, configurationID int64, newReposParam string) (*CodeSecurityConfigurationWithDefaultForNewRepos, *Response, error) { + u := fmt.Sprintf("orgs/%v/code-security/configurations/%v/defaults", org, configurationID) type configParam struct { DefaultForNewRepos string `json:"default_for_new_repos"` } @@ -294,13 +318,17 @@ func (s *OrganizationsService) SetDefaultCodeSecurityConfiguration(ctx context.C return config, resp, nil } -// GetRepositoriesForCodeSecurityConfiguration gets repositories associated with a code security configuration. +// ListRepositoriesForCodeSecurityConfiguration gets repositories associated with a code security configuration. // // GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-repositories-associated-with-a-code-security-configuration // //meta:operation GET /orgs/{org}/code-security/configurations/{configuration_id}/repositories -func (s *OrganizationsService) GetRepositoriesForCodeSecurityConfiguration(ctx context.Context, org string, id int64) ([]*RepositoryAttachment, *Response, error) { - u := fmt.Sprintf("orgs/%v/code-security/configurations/%v/repositories", org, id) +func (s *OrganizationsService) ListRepositoriesForCodeSecurityConfiguration(ctx context.Context, org string, configurationID int64, opts *ListRepositoriesForCodeSecurityConfigurationOptions) ([]*RepositoryAttachment, *Response, error) { + u := fmt.Sprintf("orgs/%v/code-security/configurations/%v/repositories", org, configurationID) + u, err := addOptions(u, opts) + if err != nil { + return nil, nil, err + } req, err := s.client.NewRequest("GET", u, nil) if err != nil { @@ -316,12 +344,12 @@ func (s *OrganizationsService) GetRepositoriesForCodeSecurityConfiguration(ctx c return attachments, resp, nil } -// ListCodeSecurityConfigurationForRepository gets code security configuration that manages a repository's code security settings. +// GetCodeSecurityConfigurationForRepository gets code security configuration that manages a repository's code security settings. // // GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-the-code-security-configuration-associated-with-a-repository // //meta:operation GET /repos/{owner}/{repo}/code-security-configuration -func (s *OrganizationsService) ListCodeSecurityConfigurationForRepository(ctx context.Context, org, repo string) (*RepositoryCodeSecurityConfiguration, *Response, error) { +func (s *OrganizationsService) GetCodeSecurityConfigurationForRepository(ctx context.Context, org, repo string) (*RepositoryCodeSecurityConfiguration, *Response, error) { u := fmt.Sprintf("repos/%v/%v/code-security-configuration", org, repo) req, err := s.client.NewRequest("GET", u, nil) diff --git a/github/orgs_codesecurity_configurations_test.go b/github/orgs_codesecurity_configurations_test.go index aa62d75ff79..ced81410948 100644 --- a/github/orgs_codesecurity_configurations_test.go +++ b/github/orgs_codesecurity_configurations_test.go @@ -64,7 +64,7 @@ func TestOrganizationsService_ListCodeSecurityConfigurations(t *testing.T) { }) } -func TestOrganizationsService_ListCodeSecurityConfiguration(t *testing.T) { +func TestOrganizationsService_GetCodeSecurityConfiguration(t *testing.T) { t.Parallel() client, mux, _ := setup(t) ctx := t.Context() @@ -79,24 +79,24 @@ func TestOrganizationsService_ListCodeSecurityConfiguration(t *testing.T) { }`) }) - configuration, _, err := client.Organizations.ListCodeSecurityConfiguration(ctx, "o", 1) + configuration, _, err := client.Organizations.GetCodeSecurityConfiguration(ctx, "o", 1) if err != nil { - t.Errorf("Organizations.ListCodeSecurityConfiguration returned error: %v", err) + t.Errorf("Organizations.GetCodeSecurityConfiguration returned error: %v", err) } want := &CodeSecurityConfiguration{ID: Ptr(int64(1)), Name: "config1", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled")} if !cmp.Equal(configuration, want) { - t.Errorf("Organizations.ListCodeSecurityConfiguration returned %+v, want %+v", configuration, want) + t.Errorf("Organizations.GetCodeSecurityConfiguration returned %+v, want %+v", configuration, want) } - const methodName = "ListCodeSecurityConfiguration" + const methodName = "GetCodeSecurityConfiguration" testBadOptions(t, methodName, func() (err error) { - _, _, err = client.Organizations.ListCodeSecurityConfiguration(ctx, "\n", -1) + _, _, err = client.Organizations.GetCodeSecurityConfiguration(ctx, "\n", -1) return err }) testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { - got, resp, err := client.Organizations.ListCodeSecurityConfiguration(ctx, "o", 1) + got, resp, err := client.Organizations.GetCodeSecurityConfiguration(ctx, "o", 1) if got != nil { t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) } @@ -156,7 +156,7 @@ func TestOrganizationsService_CreateCodeSecurityConfiguration(t *testing.T) { }) } -func TestOrganizationsService_GetDefaultCodeSecurityConfigurations(t *testing.T) { +func TestOrganizationsService_ListDefaultCodeSecurityConfigurations(t *testing.T) { t.Parallel() client, mux, _ := setup(t) ctx := t.Context() @@ -185,9 +185,9 @@ func TestOrganizationsService_GetDefaultCodeSecurityConfigurations(t *testing.T) ]`) }) - configurations, _, err := client.Organizations.GetDefaultCodeSecurityConfigurations(ctx, "o") + configurations, _, err := client.Organizations.ListDefaultCodeSecurityConfigurations(ctx, "o") if err != nil { - t.Errorf("Organizations.GetDefaultCodeSecurityConfigurations returned error: %v", err) + t.Errorf("Organizations.ListDefaultCodeSecurityConfigurations returned error: %v", err) } want := []*CodeSecurityConfigurationWithDefaultForNewRepos{ @@ -195,17 +195,17 @@ func TestOrganizationsService_GetDefaultCodeSecurityConfigurations(t *testing.T) {DefaultForNewRepos: Ptr("private_and_internal"), Configuration: &CodeSecurityConfiguration{ID: Ptr(int64(2)), Name: "config2", Description: "desc2", PrivateVulnerabilityReporting: Ptr("enabled")}}, } if !cmp.Equal(configurations, want) { - t.Errorf("Organizations.GetDefaultCodeSecurityConfigurations returned %+v, want %+v", configurations, want) + t.Errorf("Organizations.ListDefaultCodeSecurityConfigurations returned %+v, want %+v", configurations, want) } - const methodName = "GetDefaultCodeSecurityConfigurations" + const methodName = "ListDefaultCodeSecurityConfigurations" testBadOptions(t, methodName, func() (err error) { - _, _, err = client.Organizations.GetDefaultCodeSecurityConfigurations(ctx, "\n") + _, _, err = client.Organizations.ListDefaultCodeSecurityConfigurations(ctx, "\n") return err }) testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { - got, resp, err := client.Organizations.GetDefaultCodeSecurityConfigurations(ctx, "o") + got, resp, err := client.Organizations.ListDefaultCodeSecurityConfigurations(ctx, "o") if got != nil { t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) } @@ -425,13 +425,15 @@ func TestOrganizationsService_SetDefaultCodeSecurityConfiguration(t *testing.T) }) } -func TestOrganizationsService_GetRepositoriesForCodeSecurityConfiguration(t *testing.T) { +func TestOrganizationsService_ListRepositoriesForCodeSecurityConfiguration(t *testing.T) { t.Parallel() + opts := &ListRepositoriesForCodeSecurityConfigurationOptions{Before: Ptr("1"), After: Ptr("2"), PerPage: Ptr(30), Status: Ptr("attached")} ctx := t.Context() client, mux, _ := setup(t) mux.HandleFunc("/orgs/o/code-security/configurations/1/repositories", func(w http.ResponseWriter, r *http.Request) { testMethod(t, r, "GET") + testFormValues(t, r, values{"before": "1", "after": "2", "per_page": "30", "status": "attached"}) fmt.Fprint(w, `[ { "status": "attached", @@ -450,26 +452,26 @@ func TestOrganizationsService_GetRepositoriesForCodeSecurityConfiguration(t *tes ]`) }) - attachments, _, err := client.Organizations.GetRepositoriesForCodeSecurityConfiguration(ctx, "o", 1) + attachments, _, err := client.Organizations.ListRepositoriesForCodeSecurityConfiguration(ctx, "o", 1, opts) if err != nil { - t.Errorf("Organizations.GetRepositoriesForCodeSecurityConfiguration returned error: %v", err) + t.Errorf("Organizations.ListRepositoriesForCodeSecurityConfiguration returned error: %v", err) } want := []*RepositoryAttachment{ {Status: Ptr("attached"), Repository: &Repository{ID: Ptr(int64(8)), Name: Ptr("repo8")}}, {Status: Ptr("attached"), Repository: &Repository{ID: Ptr(int64(42)), Name: Ptr("repo42")}}, } if !cmp.Equal(attachments, want) { - t.Errorf("Organizations.GetRepositoriesForCodeSecurityConfiguration returned %+v, want %+v", attachments, want) + t.Errorf("Organizations.ListRepositoriesForCodeSecurityConfiguration returned %+v, want %+v", attachments, want) } - const methodName = "GetRepositoriesForCodeSecurityConfiguration" + const methodName = "ListRepositoriesForCodeSecurityConfiguration" testBadOptions(t, methodName, func() (err error) { - _, _, err = client.Organizations.GetRepositoriesForCodeSecurityConfiguration(ctx, "\n", -1) + _, _, err = client.Organizations.ListRepositoriesForCodeSecurityConfiguration(ctx, "\n", -1, opts) return }) testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { - got, resp, err := client.Organizations.GetRepositoriesForCodeSecurityConfiguration(ctx, "o", 1) + got, resp, err := client.Organizations.ListRepositoriesForCodeSecurityConfiguration(ctx, "o", 1, opts) if got != nil { t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) } @@ -477,7 +479,7 @@ func TestOrganizationsService_GetRepositoriesForCodeSecurityConfiguration(t *tes }) } -func TestOrganizationsService_ListCodeSecurityConfigurationForRepository(t *testing.T) { +func TestOrganizationsService_GetCodeSecurityConfigurationForRepository(t *testing.T) { t.Parallel() ctx := t.Context() client, mux, _ := setup(t) @@ -495,9 +497,9 @@ func TestOrganizationsService_ListCodeSecurityConfigurationForRepository(t *test }`) }) - rc, _, err := client.Organizations.ListCodeSecurityConfigurationForRepository(ctx, "o", "repo8") + rc, _, err := client.Organizations.GetCodeSecurityConfigurationForRepository(ctx, "o", "repo8") if err != nil { - t.Errorf("Organizations.ListCodeSecurityConfigurationForRepository returned error: %v", err) + t.Errorf("Organizations.GetCodeSecurityConfigurationForRepository returned error: %v", err) } c := &CodeSecurityConfiguration{ID: Ptr(int64(42)), Name: "config42", Description: "desc1", CodeScanningDefaultSetup: Ptr("enabled")} want := &RepositoryCodeSecurityConfiguration{ @@ -505,17 +507,17 @@ func TestOrganizationsService_ListCodeSecurityConfigurationForRepository(t *test Configuration: c, } if !cmp.Equal(rc, want) { - t.Errorf("Organizations.ListCodeSecurityConfigurationForRepository returned %+v, want %+v", rc, want) + t.Errorf("Organizations.GetCodeSecurityConfigurationForRepository returned %+v, want %+v", rc, want) } - const methodName = "ListCodeSecurityConfigurationForRepository" + const methodName = "GetCodeSecurityConfigurationForRepository" testBadOptions(t, methodName, func() (err error) { - _, _, err = client.Organizations.ListCodeSecurityConfigurationForRepository(ctx, "\n", "\n") + _, _, err = client.Organizations.GetCodeSecurityConfigurationForRepository(ctx, "\n", "\n") return }) testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { - got, resp, err := client.Organizations.ListCodeSecurityConfigurationForRepository(ctx, "o", "repo8") + got, resp, err := client.Organizations.GetCodeSecurityConfigurationForRepository(ctx, "o", "repo8") if got != nil { t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) } From 3a08aad79f9fea2631951ec2355a96ffc2776aa8 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Tim=20H=C3=A4ring?= Date: Thu, 13 Nov 2025 13:39:53 +0100 Subject: [PATCH 8/8] fix: consistent naming --- .../enterprise_codesecurity_configurations.go | 4 +- ...rprise_codesecurity_configurations_test.go | 16 ++-- github/github-accessors.go | 64 +++++++------- github/github-accessors_test.go | 88 +++++++++---------- github/orgs_codesecurity_configurations.go | 8 +- .../orgs_codesecurity_configurations_test.go | 16 ++-- 6 files changed, 98 insertions(+), 98 deletions(-) diff --git a/github/enterprise_codesecurity_configurations.go b/github/enterprise_codesecurity_configurations.go index 9de729cae93..687873dec42 100644 --- a/github/enterprise_codesecurity_configurations.go +++ b/github/enterprise_codesecurity_configurations.go @@ -207,12 +207,12 @@ func (s *EnterpriseService) SetDefaultCodeSecurityConfiguration(ctx context.Cont return config, resp, nil } -// ListRepositoriesForCodeSecurityConfiguration lists the repositories associated with an enterprise code security configuration. +// ListCodeSecurityConfigurationRepositories lists the repositories associated with an enterprise code security configuration. // // GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-repositories-associated-with-an-enterprise-code-security-configuration // //meta:operation GET /enterprises/{enterprise}/code-security/configurations/{configuration_id}/repositories -func (s *EnterpriseService) ListRepositoriesForCodeSecurityConfiguration(ctx context.Context, enterprise string, configurationID int64, opts *ListRepositoriesForCodeSecurityConfigurationOptions) ([]*RepositoryAttachment, *Response, error) { +func (s *EnterpriseService) ListCodeSecurityConfigurationRepositories(ctx context.Context, enterprise string, configurationID int64, opts *ListCodeSecurityConfigurationRepositoriesOptions) ([]*RepositoryAttachment, *Response, error) { u := fmt.Sprintf("enterprises/%v/code-security/configurations/%v/repositories", enterprise, configurationID) u, err := addOptions(u, opts) if err != nil { diff --git a/github/enterprise_codesecurity_configurations_test.go b/github/enterprise_codesecurity_configurations_test.go index fea7200db17..34c6fe052cf 100644 --- a/github/enterprise_codesecurity_configurations_test.go +++ b/github/enterprise_codesecurity_configurations_test.go @@ -389,9 +389,9 @@ func TestEnterpriseService_SetDefaultCodeSecurityConfiguration(t *testing.T) { }) } -func TestEnterpriseService_ListRepositoriesForCodeSecurityConfiguration(t *testing.T) { +func TestEnterpriseService_ListCodeSecurityConfigurationRepositories(t *testing.T) { t.Parallel() - opts := &ListRepositoriesForCodeSecurityConfigurationOptions{Before: Ptr("1"), After: Ptr("2"), PerPage: Ptr(30), Status: Ptr("attached")} + opts := &ListCodeSecurityConfigurationRepositoriesOptions{Before: Ptr("1"), After: Ptr("2"), PerPage: Ptr(30), Status: Ptr("attached")} ctx := t.Context() client, mux, _ := setup(t) @@ -416,26 +416,26 @@ func TestEnterpriseService_ListRepositoriesForCodeSecurityConfiguration(t *testi ]`) }) - attachments, _, err := client.Enterprise.ListRepositoriesForCodeSecurityConfiguration(ctx, "e", 1, opts) + attachments, _, err := client.Enterprise.ListCodeSecurityConfigurationRepositories(ctx, "e", 1, opts) if err != nil { - t.Errorf("Enterprise.ListRepositoriesForCodeSecurityConfiguration returned error: %v", err) + t.Errorf("Enterprise.ListCodeSecurityConfigurationRepositories returned error: %v", err) } want := []*RepositoryAttachment{ {Status: Ptr("attached"), Repository: &Repository{ID: Ptr(int64(8)), Name: Ptr("repo8")}}, {Status: Ptr("attached"), Repository: &Repository{ID: Ptr(int64(42)), Name: Ptr("repo42")}}, } if !cmp.Equal(attachments, want) { - t.Errorf("Enterprise.ListRepositoriesForCodeSecurityConfiguration returned %+v, want %+v", attachments, want) + t.Errorf("Enterprise.ListCodeSecurityConfigurationRepositories returned %+v, want %+v", attachments, want) } - const methodName = "ListRepositoriesForCodeSecurityConfiguration" + const methodName = "ListCodeSecurityConfigurationRepositories" testBadOptions(t, methodName, func() (err error) { - _, _, err = client.Enterprise.ListRepositoriesForCodeSecurityConfiguration(ctx, "\n", -1, opts) + _, _, err = client.Enterprise.ListCodeSecurityConfigurationRepositories(ctx, "\n", -1, opts) return }) testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { - got, resp, err := client.Enterprise.ListRepositoriesForCodeSecurityConfiguration(ctx, "e", 1, opts) + got, resp, err := client.Enterprise.ListCodeSecurityConfigurationRepositories(ctx, "e", 1, opts) if got != nil { t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) } diff --git a/github/github-accessors.go b/github/github-accessors.go index f2a77b30f59..daee3d9f252 100644 --- a/github/github-accessors.go +++ b/github/github-accessors.go @@ -14110,6 +14110,38 @@ func (l *ListCheckSuiteResults) GetTotal() int { return *l.Total } +// GetAfter returns the After field if it's non-nil, zero value otherwise. +func (l *ListCodeSecurityConfigurationRepositoriesOptions) GetAfter() string { + if l == nil || l.After == nil { + return "" + } + return *l.After +} + +// GetBefore returns the Before field if it's non-nil, zero value otherwise. +func (l *ListCodeSecurityConfigurationRepositoriesOptions) GetBefore() string { + if l == nil || l.Before == nil { + return "" + } + return *l.Before +} + +// GetPerPage returns the PerPage field if it's non-nil, zero value otherwise. +func (l *ListCodeSecurityConfigurationRepositoriesOptions) GetPerPage() int { + if l == nil || l.PerPage == nil { + return 0 + } + return *l.PerPage +} + +// GetStatus returns the Status field if it's non-nil, zero value otherwise. +func (l *ListCodeSecurityConfigurationRepositoriesOptions) GetStatus() string { + if l == nil || l.Status == nil { + return "" + } + return *l.Status +} + // GetTotalCount returns the TotalCount field if it's non-nil, zero value otherwise. func (l *ListCodespaces) GetTotalCount() int { if l == nil || l.TotalCount == nil { @@ -14326,38 +14358,6 @@ func (l *ListRepositories) GetTotalCount() int { return *l.TotalCount } -// GetAfter returns the After field if it's non-nil, zero value otherwise. -func (l *ListRepositoriesForCodeSecurityConfigurationOptions) GetAfter() string { - if l == nil || l.After == nil { - return "" - } - return *l.After -} - -// GetBefore returns the Before field if it's non-nil, zero value otherwise. -func (l *ListRepositoriesForCodeSecurityConfigurationOptions) GetBefore() string { - if l == nil || l.Before == nil { - return "" - } - return *l.Before -} - -// GetPerPage returns the PerPage field if it's non-nil, zero value otherwise. -func (l *ListRepositoriesForCodeSecurityConfigurationOptions) GetPerPage() int { - if l == nil || l.PerPage == nil { - return 0 - } - return *l.PerPage -} - -// GetStatus returns the Status field if it's non-nil, zero value otherwise. -func (l *ListRepositoriesForCodeSecurityConfigurationOptions) GetStatus() string { - if l == nil || l.Status == nil { - return "" - } - return *l.Status -} - // GetName returns the Name field if it's non-nil, zero value otherwise. func (l *ListRunnersOptions) GetName() string { if l == nil || l.Name == nil { diff --git a/github/github-accessors_test.go b/github/github-accessors_test.go index 6a2a7dc85e3..d548cc93cbc 100644 --- a/github/github-accessors_test.go +++ b/github/github-accessors_test.go @@ -18326,6 +18326,50 @@ func TestListCheckSuiteResults_GetTotal(tt *testing.T) { l.GetTotal() } +func TestListCodeSecurityConfigurationRepositoriesOptions_GetAfter(tt *testing.T) { + tt.Parallel() + var zeroValue string + l := &ListCodeSecurityConfigurationRepositoriesOptions{After: &zeroValue} + l.GetAfter() + l = &ListCodeSecurityConfigurationRepositoriesOptions{} + l.GetAfter() + l = nil + l.GetAfter() +} + +func TestListCodeSecurityConfigurationRepositoriesOptions_GetBefore(tt *testing.T) { + tt.Parallel() + var zeroValue string + l := &ListCodeSecurityConfigurationRepositoriesOptions{Before: &zeroValue} + l.GetBefore() + l = &ListCodeSecurityConfigurationRepositoriesOptions{} + l.GetBefore() + l = nil + l.GetBefore() +} + +func TestListCodeSecurityConfigurationRepositoriesOptions_GetPerPage(tt *testing.T) { + tt.Parallel() + var zeroValue int + l := &ListCodeSecurityConfigurationRepositoriesOptions{PerPage: &zeroValue} + l.GetPerPage() + l = &ListCodeSecurityConfigurationRepositoriesOptions{} + l.GetPerPage() + l = nil + l.GetPerPage() +} + +func TestListCodeSecurityConfigurationRepositoriesOptions_GetStatus(tt *testing.T) { + tt.Parallel() + var zeroValue string + l := &ListCodeSecurityConfigurationRepositoriesOptions{Status: &zeroValue} + l.GetStatus() + l = &ListCodeSecurityConfigurationRepositoriesOptions{} + l.GetStatus() + l = nil + l.GetStatus() +} + func TestListCodespaces_GetTotalCount(tt *testing.T) { tt.Parallel() var zeroValue int @@ -18623,50 +18667,6 @@ func TestListRepositories_GetTotalCount(tt *testing.T) { l.GetTotalCount() } -func TestListRepositoriesForCodeSecurityConfigurationOptions_GetAfter(tt *testing.T) { - tt.Parallel() - var zeroValue string - l := &ListRepositoriesForCodeSecurityConfigurationOptions{After: &zeroValue} - l.GetAfter() - l = &ListRepositoriesForCodeSecurityConfigurationOptions{} - l.GetAfter() - l = nil - l.GetAfter() -} - -func TestListRepositoriesForCodeSecurityConfigurationOptions_GetBefore(tt *testing.T) { - tt.Parallel() - var zeroValue string - l := &ListRepositoriesForCodeSecurityConfigurationOptions{Before: &zeroValue} - l.GetBefore() - l = &ListRepositoriesForCodeSecurityConfigurationOptions{} - l.GetBefore() - l = nil - l.GetBefore() -} - -func TestListRepositoriesForCodeSecurityConfigurationOptions_GetPerPage(tt *testing.T) { - tt.Parallel() - var zeroValue int - l := &ListRepositoriesForCodeSecurityConfigurationOptions{PerPage: &zeroValue} - l.GetPerPage() - l = &ListRepositoriesForCodeSecurityConfigurationOptions{} - l.GetPerPage() - l = nil - l.GetPerPage() -} - -func TestListRepositoriesForCodeSecurityConfigurationOptions_GetStatus(tt *testing.T) { - tt.Parallel() - var zeroValue string - l := &ListRepositoriesForCodeSecurityConfigurationOptions{Status: &zeroValue} - l.GetStatus() - l = &ListRepositoriesForCodeSecurityConfigurationOptions{} - l.GetStatus() - l = nil - l.GetStatus() -} - func TestListRunnersOptions_GetName(tt *testing.T) { tt.Parallel() var zeroValue string diff --git a/github/orgs_codesecurity_configurations.go b/github/orgs_codesecurity_configurations.go index ff33100ebae..788f52ed1b9 100644 --- a/github/orgs_codesecurity_configurations.go +++ b/github/orgs_codesecurity_configurations.go @@ -101,7 +101,7 @@ type ListOrgCodeSecurityConfigurationOptions struct { TargetType *string `url:"target_type,omitempty"` } -// ListRepositoriesForCodeSecurityConfigurationOptions specifies optional parameters to list repositories for security configurations for orgs and enterprises. +// ListCodeSecurityConfigurationRepositoriesOptions specifies optional parameters to list repositories for security configurations for orgs and enterprises. // // Note: Pagination is powered by before/after cursor-style pagination. After the initial call, // inspect the returned *Response. Use resp.After as the opts.After value to request @@ -109,7 +109,7 @@ type ListOrgCodeSecurityConfigurationOptions struct { // page. Set either Before or After for a request; if both are // supplied GitHub API will return an error. PerPage controls the number of items // per page (max 100 per GitHub API docs). -type ListRepositoriesForCodeSecurityConfigurationOptions struct { +type ListCodeSecurityConfigurationRepositoriesOptions struct { // A cursor, as given in the Link header. If specified, the query only searches for repositories before this cursor. Before *string `url:"before,omitempty"` @@ -318,12 +318,12 @@ func (s *OrganizationsService) SetDefaultCodeSecurityConfiguration(ctx context.C return config, resp, nil } -// ListRepositoriesForCodeSecurityConfiguration gets repositories associated with a code security configuration. +// ListCodeSecurityConfigurationRepositories gets repositories associated with a code security configuration. // // GitHub API docs: https://docs.github.com/rest/code-security/configurations#get-repositories-associated-with-a-code-security-configuration // //meta:operation GET /orgs/{org}/code-security/configurations/{configuration_id}/repositories -func (s *OrganizationsService) ListRepositoriesForCodeSecurityConfiguration(ctx context.Context, org string, configurationID int64, opts *ListRepositoriesForCodeSecurityConfigurationOptions) ([]*RepositoryAttachment, *Response, error) { +func (s *OrganizationsService) ListCodeSecurityConfigurationRepositories(ctx context.Context, org string, configurationID int64, opts *ListCodeSecurityConfigurationRepositoriesOptions) ([]*RepositoryAttachment, *Response, error) { u := fmt.Sprintf("orgs/%v/code-security/configurations/%v/repositories", org, configurationID) u, err := addOptions(u, opts) if err != nil { diff --git a/github/orgs_codesecurity_configurations_test.go b/github/orgs_codesecurity_configurations_test.go index ced81410948..7a9c2a969b2 100644 --- a/github/orgs_codesecurity_configurations_test.go +++ b/github/orgs_codesecurity_configurations_test.go @@ -425,9 +425,9 @@ func TestOrganizationsService_SetDefaultCodeSecurityConfiguration(t *testing.T) }) } -func TestOrganizationsService_ListRepositoriesForCodeSecurityConfiguration(t *testing.T) { +func TestOrganizationsService_ListCodeSecurityConfigurationRepositories(t *testing.T) { t.Parallel() - opts := &ListRepositoriesForCodeSecurityConfigurationOptions{Before: Ptr("1"), After: Ptr("2"), PerPage: Ptr(30), Status: Ptr("attached")} + opts := &ListCodeSecurityConfigurationRepositoriesOptions{Before: Ptr("1"), After: Ptr("2"), PerPage: Ptr(30), Status: Ptr("attached")} ctx := t.Context() client, mux, _ := setup(t) @@ -452,26 +452,26 @@ func TestOrganizationsService_ListRepositoriesForCodeSecurityConfiguration(t *te ]`) }) - attachments, _, err := client.Organizations.ListRepositoriesForCodeSecurityConfiguration(ctx, "o", 1, opts) + attachments, _, err := client.Organizations.ListCodeSecurityConfigurationRepositories(ctx, "o", 1, opts) if err != nil { - t.Errorf("Organizations.ListRepositoriesForCodeSecurityConfiguration returned error: %v", err) + t.Errorf("Organizations.ListCodeSecurityConfigurationRepositories returned error: %v", err) } want := []*RepositoryAttachment{ {Status: Ptr("attached"), Repository: &Repository{ID: Ptr(int64(8)), Name: Ptr("repo8")}}, {Status: Ptr("attached"), Repository: &Repository{ID: Ptr(int64(42)), Name: Ptr("repo42")}}, } if !cmp.Equal(attachments, want) { - t.Errorf("Organizations.ListRepositoriesForCodeSecurityConfiguration returned %+v, want %+v", attachments, want) + t.Errorf("Organizations.ListCodeSecurityConfigurationRepositories returned %+v, want %+v", attachments, want) } - const methodName = "ListRepositoriesForCodeSecurityConfiguration" + const methodName = "ListCodeSecurityConfigurationRepositories" testBadOptions(t, methodName, func() (err error) { - _, _, err = client.Organizations.ListRepositoriesForCodeSecurityConfiguration(ctx, "\n", -1, opts) + _, _, err = client.Organizations.ListCodeSecurityConfigurationRepositories(ctx, "\n", -1, opts) return }) testNewRequestAndDoFailure(t, methodName, client, func() (*Response, error) { - got, resp, err := client.Organizations.ListRepositoriesForCodeSecurityConfiguration(ctx, "o", 1, opts) + got, resp, err := client.Organizations.ListCodeSecurityConfigurationRepositories(ctx, "o", 1, opts) if got != nil { t.Errorf("testNewRequestAndDoFailure %v = %#v, want nil", methodName, got) }