STACKITGit/cli
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Separate payload structs for REST vs GraphQL repo create

Browse source 
This enforces strict separation between serialization structs used for
repository creation payload with respect to whether GraphQL or REST was
used. Before, a field added to a GraphQL payload would leak to REST
payload (and vice versa).
This commit is contained in:
Mislav Marohnić 2021-07-12 16:49:55 +02:00
parent e600ce054a
commit 0ad153f696
5 changed files with 519 additions and 266 deletions
Download patch file Download diff file Expand all files Collapse all files

68
pkg/cmd/repo/create/create.go
View file

@ -255,44 +255,11 @@ func createRun(opts *CreateOptions) error {
repoToCreate = ghrepo.NewWithHost("", opts.Name, host)
}
var templateRepoMainBranch string
// Find template repo ID
if opts.Template != "" {
httpClient, err := opts.HttpClient()
if err != nil {
return err
}
var toClone ghrepo.Interface
apiClient := api.NewClientFromHTTP(httpClient)
cloneURL := opts.Template
if !strings.Contains(cloneURL, "/") {
currentUser, err := api.CurrentLoginName(apiClient, ghinstance.Default())
if err != nil {
return err
}
cloneURL = currentUser + "/" + cloneURL
}
toClone, err = ghrepo.FromFullName(cloneURL)
if err != nil {
return fmt.Errorf("argument error: %w", err)
}
repo, err := api.GitHubRepo(apiClient, toClone)
if err != nil {
return err
}
opts.Template = repo.ID
templateRepoMainBranch = repo.DefaultBranchRef.Name
}
input := repoCreateInput{
Name: repoToCreate.RepoName(),
Visibility: visibility,
OwnerID: repoToCreate.RepoOwner(),
TeamID: opts.Team,
OwnerLogin: repoToCreate.RepoOwner(),
TeamSlug: opts.Team,
Description: opts.Description,
HomepageURL: opts.Homepage,
HasIssuesEnabled: opts.EnableIssues,
@ -306,16 +273,43 @@ func createRun(opts *CreateOptions) error {
return err
}
var templateRepoMainBranch string
if opts.Template != "" {
var templateRepo ghrepo.Interface
apiClient := api.NewClientFromHTTP(httpClient)
cloneURL := opts.Template
if !strings.Contains(cloneURL, "/") {
currentUser, err := api.CurrentLoginName(apiClient, ghinstance.Default())
if err != nil {
return err
}
cloneURL = currentUser + "/" + cloneURL
}
templateRepo, err = ghrepo.FromFullName(cloneURL)
if err != nil {
return fmt.Errorf("argument error: %w", err)
}
repo, err := api.GitHubRepo(apiClient, templateRepo)
if err != nil {
return err
}
input.TemplateRepositoryID = repo.ID
templateRepoMainBranch = repo.DefaultBranchRef.Name
}
createLocalDirectory := opts.ConfirmSubmit
if !opts.ConfirmSubmit {
opts.ConfirmSubmit, err = confirmSubmission(input.Name, input.OwnerID, inLocalRepo)
opts.ConfirmSubmit, err = confirmSubmission(input.Name, input.OwnerLogin, inLocalRepo)
if err != nil {
return err
}
}
if opts.ConfirmSubmit {
repo, err := repoCreate(httpClient, repoToCreate.RepoHost(), input, opts.Template)
repo, err := repoCreate(httpClient, repoToCreate.RepoHost(), input)
if err != nil {
return err
}

139
pkg/cmd/repo/create/create_test.go
View file

@ -606,27 +606,19 @@ func TestRepoCreate_WithGitIgnore(t *testing.T) {
assert.Equal(t, "", output.String())
assert.Equal(t, "✓ Created repository OWNER/REPO on GitHub\n✓ Added remote https://github.com/OWNER/REPO.git\n", output.Stderr())
var reqBody struct {
Name string
Visibility string
OwnerId string
LicenseTemplate string
}
if len(reg.Requests) != 3 {
t.Fatalf("expected 3 HTTP request, got %d", len(reg.Requests))
}
bodyBytes, _ := ioutil.ReadAll(reg.Requests[2].Body)
_ = json.Unmarshal(bodyBytes, &reqBody)
if repoName := reqBody.Name; repoName != "REPO" {
t.Errorf("expected %q, got %q", "REPO", repoName)
reqBody := make(map[string]interface{})
dec := json.NewDecoder(reg.Requests[2].Body)
assert.NoError(t, dec.Decode(&reqBody))
if gitignore := reqBody["gitignore_template"]; gitignore != "Go" {
t.Errorf("expected %q, got %q", "Go", gitignore)
}
if repoVisibility := reqBody.Visibility; repoVisibility != "private" {
t.Errorf("expected %q, got %q", "private", repoVisibility)
}
if ownerId := reqBody.OwnerId; ownerId != "OWNERID" {
t.Errorf("expected %q, got %q", "OWNERID", ownerId)
if license := reqBody["license_template"]; license != nil {
t.Errorf("expected %v, got %v", nil, license)
}
}
@ -671,7 +663,7 @@ func TestRepoCreate_WithBothGitIgnoreLicense(t *testing.T) {
as.Stub([]*prompt.QuestionStub{
{
Name: "chooseLicense",
Value: "GNU Affero General Public License v3.0",
Value: "GNU Lesser General Public License v3.0",
},
})
@ -705,115 +697,18 @@ func TestRepoCreate_WithBothGitIgnoreLicense(t *testing.T) {
assert.Equal(t, "", output.String())
assert.Equal(t, "✓ Created repository OWNER/REPO on GitHub\n✓ Added remote https://github.com/OWNER/REPO.git\n", output.Stderr())
var reqBody struct {
Name string
Visibility string
OwnerId string
LicenseTemplate string
}
if len(reg.Requests) != 4 {
t.Fatalf("expected 4 HTTP request, got %d", len(reg.Requests))
}
bodyBytes, _ := ioutil.ReadAll(reg.Requests[3].Body)
_ = json.Unmarshal(bodyBytes, &reqBody)
if repoName := reqBody.Name; repoName != "REPO" {
t.Errorf("expected %q, got %q", "REPO", repoName)
reqBody := make(map[string]interface{})
dec := json.NewDecoder(reg.Requests[3].Body)
assert.NoError(t, dec.Decode(&reqBody))
if gitignore := reqBody["gitignore_template"]; gitignore != "Go" {
t.Errorf("expected %q, got %q", "Go", gitignore)
}
if repoVisibility := reqBody.Visibility; repoVisibility != "private" {
t.Errorf("expected %q, got %q", "private", repoVisibility)
}
if ownerId := reqBody.OwnerId; ownerId != "OWNERID" {
t.Errorf("expected %q, got %q", "OWNERID", ownerId)
}
}
func TestRepoCreate_WithGitIgnore_Org(t *testing.T) {
cs, cmdTeardown := run.Stub()
defer cmdTeardown(t)
cs.Register(`git remote add -f origin https://github\.com/OWNER/REPO\.git`, 0, "")
cs.Register(`git rev-parse --show-toplevel`, 0, "")
as, surveyTearDown := prompt.InitAskStubber()
defer surveyTearDown()
as.Stub([]*prompt.QuestionStub{
{
Name: "repoVisibility",
Value: "PRIVATE",
},
})
as.Stub([]*prompt.QuestionStub{
{
Name: "addGitIgnore",
Value: true,
},
})
as.Stub([]*prompt.QuestionStub{
{
Name: "chooseGitIgnore",
Value: "Go",
},
})
as.Stub([]*prompt.QuestionStub{
{
Name: "addLicense",
Value: false,
},
})
as.Stub([]*prompt.QuestionStub{
{
Name: "confirmSubmit",
Value: true,
},
})
reg := &httpmock.Registry{}
reg.Register(
httpmock.REST("GET", "users/OWNER"),
httpmock.StringResponse(`{ "node_id": "OWNERID", "type":"Organization" }`))
reg.Register(
httpmock.REST("GET", "gitignore/templates"),
httpmock.StringResponse(`["Actionscript","Android","AppceleratorTitanium","Autotools","Bancha","C","C++","Go"]`))
reg.Register(
httpmock.REST("POST", "orgs/OWNER/repos"),
httpmock.StringResponse(`{"name":"REPO", "owner":{"login": "OWNER"}, "html_url":"https://github.com/OWNER/REPO"}`))
httpClient := &http.Client{Transport: reg}
output, err := runCommand(httpClient, "OWNER/REPO", true)
if err != nil {
t.Errorf("error running command `repo create`: %v", err)
}
assert.Equal(t, "", output.String())
assert.Equal(t, "✓ Created repository OWNER/REPO on GitHub\n✓ Added remote https://github.com/OWNER/REPO.git\n", output.Stderr())
var reqBody struct {
Name string
Visibility string
OwnerId string
LicenseTemplate string
}
if len(reg.Requests) != 3 {
t.Fatalf("expected 3 HTTP request, got %d", len(reg.Requests))
}
bodyBytes, _ := ioutil.ReadAll(reg.Requests[2].Body)
_ = json.Unmarshal(bodyBytes, &reqBody)
if repoName := reqBody.Name; repoName != "REPO" {
t.Errorf("expected %q, got %q", "REPO", repoName)
}
if repoVisibility := reqBody.Visibility; repoVisibility != "private" {
t.Errorf("expected %q, got %q", "private", repoVisibility)
}
if ownerId := reqBody.OwnerId; ownerId != "OWNERID" {
t.Errorf("expected %q, got %q", "OWNERID", ownerId)
if license := reqBody["license_template"]; license != "lgpl-3.0" {
t.Errorf("expected %q, got %q", "lgpl-3.0", license)
}
}

209
pkg/cmd/repo/create/http.go
View file

@ -10,80 +10,102 @@ import (
"github.com/cli/cli/api"
)
// repoCreateInput represents input parameters for repoCreate
type repoCreateInput struct {
Name string `json:"name"`
Visibility string `json:"visibility"`
HomepageURL string `json:"homepageUrl,omitempty"`
Description string `json:"description,omitempty"`
Name string
HomepageURL string
Description string
Visibility string
OwnerLogin string
TeamSlug string
TemplateRepositoryID string
HasIssuesEnabled bool
HasWikiEnabled bool
GitIgnoreTemplate string
LicenseTemplate string
}
OwnerID string `json:"ownerId,omitempty"`
TeamID string `json:"teamId,omitempty"`
Private bool `json:"private,omitempty"`
HasIssuesEnabled bool `json:"hasIssuesEnabled"`
HasWikiEnabled bool `json:"hasWikiEnabled"`
type createRepositoryInputV3 struct {
Name string `json:"name"`
HomepageURL string `json:"homepage,omitempty"`
Description string `json:"description,omitempty"`
IsPrivate bool `json:"private"`
Visibility string `json:"visibility,omitempty"`
TeamID uint64 `json:"team_id,omitempty"`
HasIssuesEnabled bool `json:"has_issues"`
HasWikiEnabled bool `json:"has_wiki"`
GitIgnoreTemplate string `json:"gitignore_template,omitempty"`
LicenseTemplate string `json:"license_template,omitempty"`
}
type repoTemplateInput struct {
Name string `json:"name"`
Visibility string `json:"visibility"`
OwnerID string `json:"ownerId,omitempty"`
type createRepositoryInput struct {
Name string `json:"name"`
HomepageURL string `json:"homepageUrl,omitempty"`
Description string `json:"description,omitempty"`
Visibility string `json:"visibility"`
OwnerID string `json:"ownerId,omitempty"`
TeamID string `json:"teamId,omitempty"`
HasIssuesEnabled bool `json:"hasIssuesEnabled"`
HasWikiEnabled bool `json:"hasWikiEnabled"`
}
RepositoryID string `json:"repositoryId,omitempty"`
type cloneTemplateRepositoryInput struct {
Name string `json:"name"`
Visibility string `json:"visibility"`
Description string `json:"description,omitempty"`
OwnerID string `json:"ownerId"`
RepositoryID string `json:"repositoryId"`
}
// repoCreate creates a new GitHub repository
func repoCreate(client *http.Client, hostname string, input repoCreateInput, templateRepositoryID string) (*api.Repository, error) {
func repoCreate(client *http.Client, hostname string, input repoCreateInput) (*api.Repository, error) {
isOrg := false
var ownerID string
var teamID string
var teamIDv3 uint64
apiClient := api.NewClientFromHTTP(client)
ownerName := input.OwnerID
isOrg := false
if input.TeamID != "" {
orgID, teamID, err := resolveOrganizationTeam(apiClient, hostname, input.OwnerID, input.TeamID)
if input.TeamSlug != "" {
team, err := resolveOrganizationTeam(apiClient, hostname, input.OwnerLogin, input.TeamSlug)
if err != nil {
return nil, err
}
input.TeamID = teamID
input.OwnerID = orgID
} else if input.OwnerID != "" {
var orgID string
var err error
orgID, isOrg, err = resolveOrganization(apiClient, hostname, input.OwnerID)
teamIDv3 = team.ID
teamID = team.NodeID
ownerID = team.Organization.NodeID
isOrg = true
} else if input.OwnerLogin != "" {
owner, err := resolveOwner(apiClient, hostname, input.OwnerLogin)
if err != nil {
return nil, err
}
input.OwnerID = orgID
ownerID = owner.NodeID
isOrg = owner.IsOrganization()
}
if templateRepositoryID != "" {
if input.TemplateRepositoryID != "" {
var response struct {
CloneTemplateRepository struct {
Repository api.Repository
}
}
if input.OwnerID == "" {
if ownerID == "" {
var err error
input.OwnerID, err = api.CurrentUserID(apiClient, hostname)
ownerID, err = api.CurrentUserID(apiClient, hostname)
if err != nil {
return nil, err
}
}
templateInput := repoTemplateInput{
Name: input.Name,
Visibility: input.Visibility,
OwnerID: input.OwnerID,
RepositoryID: templateRepositoryID,
Description: input.Description,
}
variables := map[string]interface{}{
"input": templateInput,
"input": cloneTemplateRepositoryInput{
Name: input.Name,
Description: input.Description,
Visibility: strings.ToUpper(input.Visibility),
OwnerID: ownerID,
RepositoryID: input.TemplateRepositoryID,
},
}
err := apiClient.GraphQL(hostname, `
@ -105,6 +127,38 @@ func repoCreate(client *http.Client, hostname string, input repoCreateInput, tem
return api.InitRepoHostname(&response.CloneTemplateRepository.Repository, hostname), nil
}
if input.GitIgnoreTemplate != "" || input.LicenseTemplate != "" {
inputv3 := createRepositoryInputV3{
Name: input.Name,
HomepageURL: input.HomepageURL,
Description: input.Description,
IsPrivate: strings.EqualFold(input.Visibility, "PRIVATE"),
TeamID: teamIDv3,
HasIssuesEnabled: input.HasIssuesEnabled,
HasWikiEnabled: input.HasWikiEnabled,
GitIgnoreTemplate: input.GitIgnoreTemplate,
LicenseTemplate: input.LicenseTemplate,
}
path := "user/repos"
if isOrg {
path = fmt.Sprintf("orgs/%s/repos", input.OwnerLogin)
inputv3.Visibility = strings.ToLower(input.Visibility)
}
body := &bytes.Buffer{}
enc := json.NewEncoder(body)
if err := enc.Encode(inputv3); err != nil {
return nil, err
}
repo, err := api.CreateRepoTransformToV4(apiClient, hostname, "POST", path, body)
if err != nil {
return nil, err
}
return repo, nil
}
var response struct {
CreateRepository struct {
Repository api.Repository
@ -112,32 +166,16 @@ func repoCreate(client *http.Client, hostname string, input repoCreateInput, tem
}
variables := map[string]interface{}{
"input": input,
}
if input.GitIgnoreTemplate != "" || input.LicenseTemplate != "" {
input.Visibility = strings.ToLower(input.Visibility)
if input.Visibility == "private" {
input.Private = true
}
body := &bytes.Buffer{}
enc := json.NewEncoder(body)
if err := enc.Encode(input); err != nil {
return nil, err
}
path := "user/repos"
if isOrg {
path = fmt.Sprintf("orgs/%s/repos", ownerName)
}
repo, err := api.CreateRepoTransformToV4(apiClient, hostname, "POST", path, body)
if err != nil {
return nil, err
}
return api.InitRepoHostname(repo, hostname), nil
"input": createRepositoryInput{
Name: input.Name,
Description: input.Description,
HomepageURL: input.HomepageURL,
Visibility: strings.ToUpper(input.Visibility),
OwnerID: ownerID,
TeamID: teamID,
HasIssuesEnabled: input.HasIssuesEnabled,
HasWikiEnabled: input.HasWikiEnabled,
},
}
err := apiClient.GraphQL(hostname, `
@ -159,26 +197,33 @@ func repoCreate(client *http.Client, hostname string, input repoCreateInput, tem
return api.InitRepoHostname(&response.CreateRepository.Repository, hostname), nil
}
// using API v3 here because the equivalent in GraphQL needs `read:org` scope
func resolveOrganization(client *api.Client, hostname, orgName string) (string, bool, error) {
var response struct {
NodeID string `json:"node_id"`
Type string
}
err := client.REST(hostname, "GET", fmt.Sprintf("users/%s", orgName), nil, &response)
return response.NodeID, response.Type == "Organization", err
type ownerResponse struct {
NodeID string `json:"node_id"`
Type string `json:"type"`
}
// using API v3 here because the equivalent in GraphQL needs `read:org` scope
func resolveOrganizationTeam(client *api.Client, hostname, orgName, teamSlug string) (string, string, error) {
var response struct {
NodeID string `json:"node_id"`
Organization struct {
NodeID string `json:"node_id"`
}
func (r *ownerResponse) IsOrganization() bool {
return r.Type == "Organization"
}
func resolveOwner(client *api.Client, hostname, orgName string) (*ownerResponse, error) {
var response ownerResponse
err := client.REST(hostname, "GET", fmt.Sprintf("users/%s", orgName), nil, &response)
return &response, err
}
type teamResponse struct {
ID uint64 `json:"id"`
NodeID string `json:"node_id"`
Organization struct {
NodeID string `json:"node_id"`
}
}
func resolveOrganizationTeam(client *api.Client, hostname, orgName, teamSlug string) (*teamResponse, error) {
var response teamResponse
err := client.REST(hostname, "GET", fmt.Sprintf("orgs/%s/teams/%s", orgName, teamSlug), nil, &response)
return response.Organization.NodeID, response.NodeID, err
return &response, err
}
// ListGitIgnoreTemplates uses API v3 here because gitignore template isn't supported by GraphQL yet.

358
pkg/cmd/repo/create/http_test.go
View file

@ -1,37 +1,345 @@
package create
import (
"net/http"
"testing"
"github.com/cli/cli/api"
"github.com/cli/cli/internal/ghrepo"
"github.com/cli/cli/pkg/httpmock"
"github.com/stretchr/testify/assert"
)
func Test_RepoCreate(t *testing.T) {
reg := &httpmock.Registry{}
httpClient := api.NewHTTPClient(api.ReplaceTripper(reg))
reg.Register(
httpmock.GraphQL(`mutation RepositoryCreate\b`),
httpmock.GraphQLMutation(`{}`,
func(inputs map[string]interface{}) {
assert.Equal(t, inputs["description"], "roasted chestnuts")
assert.Equal(t, inputs["homepageUrl"], "http://example.com")
}),
)
input := repoCreateInput{
Description: "roasted chestnuts",
HomepageURL: "http://example.com",
func Test_repoCreate(t *testing.T) {
tests := []struct {
name string
hostname string
input repoCreateInput
stubs func(t *testing.T, r *httpmock.Registry)
wantErr bool
wantRepo string
}{
{
name: "create personal repository",
hostname: "github.com",
input: repoCreateInput{
Name: "winter-foods",
Description: "roasted chestnuts",
HomepageURL: "http://example.com",
Visibility: "public",
HasIssuesEnabled: true,
HasWikiEnabled: true,
},
stubs: func(t *testing.T, r *httpmock.Registry) {
r.Register(
httpmock.GraphQL(`mutation RepositoryCreate\b`),
httpmock.GraphQLMutation(
`{
"data": {
"createRepository": {
"repository": {
"id": "REPOID",
"name": "REPO",
"owner": {"login":"OWNER"},
"url": "the://URL"
}
}
}
}`,
func(inputs map[string]interface{}) {
assert.Equal(t, map[string]interface{}{
"name": "winter-foods",
"description": "roasted chestnuts",
"homepageUrl": "http://example.com",
"visibility": "PUBLIC",
"hasIssuesEnabled": true,
"hasWikiEnabled": true,
}, inputs)
}),
)
},
wantRepo: "https://github.com/OWNER/REPO",
},
{
name: "create in organization",
hostname: "github.com",
input: repoCreateInput{
Name: "crisps",
Visibility: "internal",
OwnerLogin: "snacks-inc",
HasIssuesEnabled: true,
HasWikiEnabled: true,
},
stubs: func(t *testing.T, r *httpmock.Registry) {
r.Register(
httpmock.REST("GET", "users/snacks-inc"),
httpmock.StringResponse(`{ "node_id": "ORGID", "type": "Organization" }`))
r.Register(
httpmock.GraphQL(`mutation RepositoryCreate\b`),
httpmock.GraphQLMutation(
`{
"data": {
"createRepository": {
"repository": {
"id": "REPOID",
"name": "REPO",
"owner": {"login":"OWNER"},
"url": "the://URL"
}
}
}
}`,
func(inputs map[string]interface{}) {
assert.Equal(t, map[string]interface{}{
"name": "crisps",
"visibility": "INTERNAL",
"ownerId": "ORGID",
"hasIssuesEnabled": true,
"hasWikiEnabled": true,
}, inputs)
}),
)
},
wantRepo: "https://github.com/OWNER/REPO",
},
{
name: "create for team",
hostname: "github.com",
input: repoCreateInput{
Name: "crisps",
Visibility: "internal",
OwnerLogin: "snacks-inc",
TeamSlug: "munchies",
HasIssuesEnabled: true,
HasWikiEnabled: true,
},
stubs: func(t *testing.T, r *httpmock.Registry) {
r.Register(
httpmock.REST("GET", "orgs/snacks-inc/teams/munchies"),
httpmock.StringResponse(`{ "node_id": "TEAMID", "id": 1234, "organization": {"node_id": "ORGID"} }`))
r.Register(
httpmock.GraphQL(`mutation RepositoryCreate\b`),
httpmock.GraphQLMutation(
`{
"data": {
"createRepository": {
"repository": {
"id": "REPOID",
"name": "REPO",
"owner": {"login":"OWNER"},
"url": "the://URL"
}
}
}
}`,
func(inputs map[string]interface{}) {
assert.Equal(t, map[string]interface{}{
"name": "crisps",
"visibility": "INTERNAL",
"ownerId": "ORGID",
"teamId": "TEAMID",
"hasIssuesEnabled": true,
"hasWikiEnabled": true,
}, inputs)
}),
)
},
wantRepo: "https://github.com/OWNER/REPO",
},
{
name: "create personal repo from template repo",
hostname: "github.com",
input: repoCreateInput{
Name: "gen-project",
Description: "my generated project",
Visibility: "private",
TemplateRepositoryID: "TPLID",
HasIssuesEnabled: true,
HasWikiEnabled: true,
},
stubs: func(t *testing.T, r *httpmock.Registry) {
r.Register(
httpmock.GraphQL(`query UserCurrent\b`),
httpmock.StringResponse(`{"data": {"viewer": {"id":"USERID"} } }`))
r.Register(
httpmock.GraphQL(`mutation CloneTemplateRepository\b`),
httpmock.GraphQLMutation(
`{
"data": {
"cloneTemplateRepository": {
"repository": {
"id": "REPOID",
"name": "REPO",
"owner": {"login":"OWNER"},
"url": "the://URL"
}
}
}
}`,
func(inputs map[string]interface{}) {
assert.Equal(t, map[string]interface{}{
"name": "gen-project",
"description": "my generated project",
"visibility": "PRIVATE",
"ownerId": "USERID",
"repositoryId": "TPLID",
}, inputs)
}),
)
},
wantRepo: "https://github.com/OWNER/REPO",
},
{
name: "create org repo from template repo",
hostname: "github.com",
input: repoCreateInput{
Name: "gen-project",
Description: "my generated project",
Visibility: "internal",
OwnerLogin: "myorg",
TemplateRepositoryID: "TPLID",
HasIssuesEnabled: true,
HasWikiEnabled: true,
},
stubs: func(t *testing.T, r *httpmock.Registry) {
r.Register(
httpmock.REST("GET", "users/myorg"),
httpmock.StringResponse(`{ "node_id": "ORGID", "type": "Organization" }`))
r.Register(
httpmock.GraphQL(`mutation CloneTemplateRepository\b`),
httpmock.GraphQLMutation(
`{
"data": {
"cloneTemplateRepository": {
"repository": {
"id": "REPOID",
"name": "REPO",
"owner": {"login":"OWNER"},
"url": "the://URL"
}
}
}
}`,
func(inputs map[string]interface{}) {
assert.Equal(t, map[string]interface{}{
"name": "gen-project",
"description": "my generated project",
"visibility": "INTERNAL",
"ownerId": "ORGID",
"repositoryId": "TPLID",
}, inputs)
}),
)
},
wantRepo: "https://github.com/OWNER/REPO",
},
{
name: "create with license and gitignore",
hostname: "github.com",
input: repoCreateInput{
Name: "crisps",
Visibility: "private",
LicenseTemplate: "lgpl-3.0",
GitIgnoreTemplate: "Go",
HasIssuesEnabled: true,
HasWikiEnabled: true,
},
stubs: func(t *testing.T, r *httpmock.Registry) {
r.Register(
httpmock.REST("POST", "user/repos"),
httpmock.RESTPayload(201, `{"name":"crisps", "owner":{"login": "snacks-inc"}, "html_url":"the://URL"}`, func(payload map[string]interface{}) {
assert.Equal(t, map[string]interface{}{
"name": "crisps",
"private": true,
"gitignore_template": "Go",
"license_template": "lgpl-3.0",
"has_issues": true,
"has_wiki": true,
}, payload)
}))
},
wantRepo: "https://github.com/snacks-inc/crisps",
},
{
name: "create with license and gitignore in org",
hostname: "github.com",
input: repoCreateInput{
Name: "crisps",
Visibility: "INTERNAL",
OwnerLogin: "snacks-inc",
LicenseTemplate: "lgpl-3.0",
GitIgnoreTemplate: "Go",
HasIssuesEnabled: true,
HasWikiEnabled: true,
},
stubs: func(t *testing.T, r *httpmock.Registry) {
r.Register(
httpmock.REST("GET", "users/snacks-inc"),
httpmock.StringResponse(`{ "node_id": "ORGID", "type": "Organization" }`))
r.Register(
httpmock.REST("POST", "orgs/snacks-inc/repos"),
httpmock.RESTPayload(201, `{"name":"crisps", "owner":{"login": "snacks-inc"}, "html_url":"the://URL"}`, func(payload map[string]interface{}) {
assert.Equal(t, map[string]interface{}{
"name": "crisps",
"private": false,
"visibility": "internal",
"gitignore_template": "Go",
"license_template": "lgpl-3.0",
"has_issues": true,
"has_wiki": true,
}, payload)
}))
},
wantRepo: "https://github.com/snacks-inc/crisps",
},
{
name: "create with license and gitignore for team",
hostname: "github.com",
input: repoCreateInput{
Name: "crisps",
Visibility: "internal",
OwnerLogin: "snacks-inc",
TeamSlug: "munchies",
LicenseTemplate: "lgpl-3.0",
GitIgnoreTemplate: "Go",
HasIssuesEnabled: true,
HasWikiEnabled: true,
},
stubs: func(t *testing.T, r *httpmock.Registry) {
r.Register(
httpmock.REST("GET", "orgs/snacks-inc/teams/munchies"),
httpmock.StringResponse(`{ "node_id": "TEAMID", "id": 1234, "organization": {"node_id": "ORGID"} }`))
r.Register(
httpmock.REST("POST", "orgs/snacks-inc/repos"),
httpmock.RESTPayload(201, `{"name":"crisps", "owner":{"login": "snacks-inc"}, "html_url":"the://URL"}`, func(payload map[string]interface{}) {
assert.Equal(t, map[string]interface{}{
"name": "crisps",
"private": false,
"visibility": "internal",
"gitignore_template": "Go",
"license_template": "lgpl-3.0",
"team_id": float64(1234),
"has_issues": true,
"has_wiki": true,
}, payload)
}))
},
wantRepo: "https://github.com/snacks-inc/crisps",
},
}
_, err := repoCreate(httpClient, "github.com", input, "")
if err != nil {
t.Fatalf("unexpected error: %v", err)
}
if len(reg.Requests) != 1 {
t.Fatalf("expected 1 HTTP request, seen %d", len(reg.Requests))
for _, tt := range tests {
t.Run(tt.name, func(t *testing.T) {
reg := &httpmock.Registry{}
defer reg.Verify(t)
tt.stubs(t, reg)
httpClient := &http.Client{Transport: reg}
r, err := repoCreate(httpClient, tt.hostname, tt.input)
if tt.wantErr {
assert.Error(t, err)
return
} else {
assert.NoError(t, err)
}
assert.Equal(t, tt.wantRepo, ghrepo.GenerateRepoURL(r, ""))
})
}
}

11
pkg/httpmock/stub.go
View file

@ -100,6 +100,17 @@ func FileResponse(filename string) Responder {
}
}
func RESTPayload(responseStatus int, responseBody string, cb func(payload map[string]interface{})) Responder {
return func(req *http.Request) (*http.Response, error) {
bodyData := make(map[string]interface{})
err := decodeJSONBody(req, &bodyData)
if err != nil {
return nil, err
}
cb(bodyData)
return httpResponse(responseStatus, req, bytes.NewBufferString(responseBody)), nil
}
}
func GraphQLMutation(body string, cb func(map[string]interface{})) Responder {
return func(req *http.Request) (*http.Response, error) {
var bodyData struct {