mirror of
https://github.com/google/go-github.git
synced 2026-10-29 00:44:52 +08:00
kimjooyoon
c273cd8137
BREAKING CHANGE: `RepositoriesService.Create` now requires a `CreateRepositoryRequest` value instead of a `*Repository`.
2648 lines
95 KiB
Go
2648 lines
95 KiB
Go
// Code generated by gen-stringify-tests; DO NOT EDIT.
|
|
// Instead, please run "go generate ./..." as described here:
|
|
// https://github.com/google/go-github/blob/master/CONTRIBUTING.md#submitting-a-patch
|
|
|
|
// Copyright 2019 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 (
|
|
"testing"
|
|
)
|
|
|
|
func TestAcceptedAssignment_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := AcceptedAssignment{
|
|
ID: new(int64(0)),
|
|
Submitted: new(false),
|
|
Passing: new(false),
|
|
CommitCount: new(0),
|
|
Grade: new(""),
|
|
Repository: &Repository{},
|
|
Assignment: &ClassroomAssignment{},
|
|
}
|
|
want := `github.AcceptedAssignment{ID:0, Submitted:false, Passing:false, CommitCount:0, Grade:"", Repository:github.Repository{}, Assignment:github.ClassroomAssignment{}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("AcceptedAssignment.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestActionsAllowed_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := ActionsAllowed{
|
|
GithubOwnedAllowed: new(false),
|
|
VerifiedAllowed: new(false),
|
|
PatternsAllowed: []string{""},
|
|
}
|
|
want := `github.ActionsAllowed{GithubOwnedAllowed:false, VerifiedAllowed:false, PatternsAllowed:[""]}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("ActionsAllowed.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestActionsPermissions_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := ActionsPermissions{
|
|
EnabledRepositories: "",
|
|
AllowedActions: new(""),
|
|
SelectedActionsURL: new(""),
|
|
SHAPinningRequired: new(false),
|
|
}
|
|
want := `github.ActionsPermissions{EnabledRepositories:"", AllowedActions:"", SelectedActionsURL:"", SHAPinningRequired:false}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("ActionsPermissions.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestActionsPermissionsEnterprise_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := ActionsPermissionsEnterprise{
|
|
EnabledOrganizations: "",
|
|
AllowedActions: new(""),
|
|
SelectedActionsURL: new(""),
|
|
}
|
|
want := `github.ActionsPermissionsEnterprise{EnabledOrganizations:"", AllowedActions:"", SelectedActionsURL:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("ActionsPermissionsEnterprise.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestActionsPermissionsRepository_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := ActionsPermissionsRepository{
|
|
Enabled: false,
|
|
AllowedActions: new(""),
|
|
SelectedActionsURL: new(""),
|
|
SHAPinningRequired: new(false),
|
|
}
|
|
want := `github.ActionsPermissionsRepository{Enabled:false, AllowedActions:"", SelectedActionsURL:"", SHAPinningRequired:false}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("ActionsPermissionsRepository.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestAdminStats_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := AdminStats{
|
|
Issues: &IssueStats{},
|
|
Hooks: &HookStats{},
|
|
Milestones: &MilestoneStats{},
|
|
Orgs: &OrgStats{},
|
|
Comments: &CommentStats{},
|
|
Pages: &PageStats{},
|
|
Users: &UserStats{},
|
|
Gists: &GistStats{},
|
|
Pulls: &PullStats{},
|
|
Repos: &RepoStats{},
|
|
}
|
|
want := `github.AdminStats{Issues:github.IssueStats{}, Hooks:github.HookStats{}, Milestones:github.MilestoneStats{}, Orgs:github.OrgStats{}, Comments:github.CommentStats{}, Pages:github.PageStats{}, Users:github.UserStats{}, Gists:github.GistStats{}, Pulls:github.PullStats{}, Repos:github.RepoStats{}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("AdminStats.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestAdvancedSecurity_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := AdvancedSecurity{
|
|
Status: new(""),
|
|
}
|
|
want := `github.AdvancedSecurity{Status:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("AdvancedSecurity.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestArtifactPeriod_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := ArtifactPeriod{
|
|
Days: new(0),
|
|
MaximumAllowedDays: new(0),
|
|
}
|
|
want := `github.ArtifactPeriod{Days:0, MaximumAllowedDays:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("ArtifactPeriod.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestAssignmentGrade_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := AssignmentGrade{
|
|
AssignmentName: new(""),
|
|
AssignmentURL: new(""),
|
|
StarterCodeURL: new(""),
|
|
GithubUsername: new(""),
|
|
RosterIdentifier: new(""),
|
|
StudentRepositoryName: new(""),
|
|
StudentRepositoryURL: new(""),
|
|
SubmissionTimestamp: &Timestamp{},
|
|
PointsAwarded: new(0),
|
|
PointsAvailable: new(0),
|
|
GroupName: new(""),
|
|
}
|
|
want := `github.AssignmentGrade{AssignmentName:"", AssignmentURL:"", StarterCodeURL:"", GithubUsername:"", RosterIdentifier:"", StudentRepositoryName:"", StudentRepositoryURL:"", SubmissionTimestamp:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, PointsAwarded:0, PointsAvailable:0, GroupName:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("AssignmentGrade.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestAuthorization_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Authorization{
|
|
ID: new(int64(0)),
|
|
URL: new(""),
|
|
Scopes: []Scope{ScopeNone},
|
|
Token: new(""),
|
|
TokenLastEight: new(""),
|
|
HashedToken: new(""),
|
|
App: &AuthorizationApp{},
|
|
Note: new(""),
|
|
NoteURL: new(""),
|
|
UpdatedAt: &Timestamp{},
|
|
CreatedAt: &Timestamp{},
|
|
Fingerprint: new(""),
|
|
User: &User{},
|
|
}
|
|
want := `github.Authorization{ID:0, URL:"", Scopes:["(no scope)"], Token:"", TokenLastEight:"", HashedToken:"", App:github.AuthorizationApp{}, Note:"", NoteURL:"", UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Fingerprint:"", User:github.User{}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Authorization.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestAuthorizationApp_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := AuthorizationApp{
|
|
URL: new(""),
|
|
Name: new(""),
|
|
ClientID: new(""),
|
|
}
|
|
want := `github.AuthorizationApp{URL:"", Name:"", ClientID:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("AuthorizationApp.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestAuthorizationRequest_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := AuthorizationRequest{
|
|
Scopes: []Scope{ScopeNone},
|
|
Note: new(""),
|
|
NoteURL: new(""),
|
|
ClientID: new(""),
|
|
ClientSecret: new(""),
|
|
Fingerprint: new(""),
|
|
}
|
|
want := `github.AuthorizationRequest{Scopes:["(no scope)"], Note:"", NoteURL:"", ClientID:"", ClientSecret:"", Fingerprint:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("AuthorizationRequest.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestAuthorizationUpdateRequest_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := AuthorizationUpdateRequest{
|
|
Scopes: []string{""},
|
|
AddScopes: []string{""},
|
|
RemoveScopes: []string{""},
|
|
Note: new(""),
|
|
NoteURL: new(""),
|
|
Fingerprint: new(""),
|
|
}
|
|
want := `github.AuthorizationUpdateRequest{Scopes:[""], AddScopes:[""], RemoveScopes:[""], Note:"", NoteURL:"", Fingerprint:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("AuthorizationUpdateRequest.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestCheckRun_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := CheckRun{
|
|
ID: new(int64(0)),
|
|
NodeID: new(""),
|
|
HeadSHA: new(""),
|
|
ExternalID: new(""),
|
|
URL: new(""),
|
|
HTMLURL: new(""),
|
|
DetailsURL: new(""),
|
|
Status: new(""),
|
|
Conclusion: new(""),
|
|
StartedAt: &Timestamp{},
|
|
CompletedAt: &Timestamp{},
|
|
Output: &CheckRunOutput{},
|
|
Name: new(""),
|
|
CheckSuite: &CheckSuite{},
|
|
App: &App{},
|
|
}
|
|
want := `github.CheckRun{ID:0, NodeID:"", HeadSHA:"", ExternalID:"", URL:"", HTMLURL:"", DetailsURL:"", Status:"", Conclusion:"", StartedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, CompletedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Output:github.CheckRunOutput{}, Name:"", CheckSuite:github.CheckSuite{}, App:github.App{}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("CheckRun.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestCheckSuite_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := CheckSuite{
|
|
ID: new(int64(0)),
|
|
NodeID: new(""),
|
|
HeadBranch: new(""),
|
|
HeadSHA: new(""),
|
|
URL: new(""),
|
|
BeforeSHA: new(""),
|
|
AfterSHA: new(""),
|
|
Status: new(""),
|
|
Conclusion: new(""),
|
|
CreatedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
App: &App{},
|
|
Repository: &Repository{},
|
|
HeadCommit: &Commit{},
|
|
LatestCheckRunsCount: new(int64(0)),
|
|
Rerequestable: new(false),
|
|
RunsRerequestable: new(false),
|
|
}
|
|
want := `github.CheckSuite{ID:0, NodeID:"", HeadBranch:"", HeadSHA:"", URL:"", BeforeSHA:"", AfterSHA:"", Status:"", Conclusion:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, App:github.App{}, Repository:github.Repository{}, HeadCommit:github.Commit{}, LatestCheckRunsCount:0, Rerequestable:false, RunsRerequestable:false}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("CheckSuite.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClassroom_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Classroom{
|
|
ID: new(int64(0)),
|
|
Name: new(""),
|
|
Archived: new(false),
|
|
Organization: &Organization{},
|
|
URL: new(""),
|
|
}
|
|
want := `github.Classroom{ID:0, Name:"", Archived:false, Organization:github.Organization{}, URL:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Classroom.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClassroomAssignment_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := ClassroomAssignment{
|
|
ID: new(int64(0)),
|
|
PublicRepo: new(false),
|
|
Title: new(""),
|
|
Type: new(""),
|
|
InviteLink: new(""),
|
|
InvitationsEnabled: new(false),
|
|
Slug: new(""),
|
|
StudentsAreRepoAdmins: new(false),
|
|
FeedbackPullRequestsEnabled: new(false),
|
|
MaxTeams: new(0),
|
|
MaxMembers: new(0),
|
|
Editor: new(""),
|
|
Accepted: new(0),
|
|
Submitted: new(0),
|
|
Passing: new(0),
|
|
Language: new(""),
|
|
Deadline: &Timestamp{},
|
|
StarterCodeRepository: &Repository{},
|
|
Classroom: &Classroom{},
|
|
}
|
|
want := `github.ClassroomAssignment{ID:0, PublicRepo:false, Title:"", Type:"", InviteLink:"", InvitationsEnabled:false, Slug:"", StudentsAreRepoAdmins:false, FeedbackPullRequestsEnabled:false, MaxTeams:0, MaxMembers:0, Editor:"", Accepted:0, Submitted:0, Passing:0, Language:"", Deadline:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, StarterCodeRepository:github.Repository{}, Classroom:github.Classroom{}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("ClassroomAssignment.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestClassroomUser_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := ClassroomUser{
|
|
ID: new(int64(0)),
|
|
Login: new(""),
|
|
AvatarURL: new(""),
|
|
HTMLURL: new(""),
|
|
}
|
|
want := `github.ClassroomUser{ID:0, Login:"", AvatarURL:"", HTMLURL:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("ClassroomUser.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestCodeOfConduct_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := CodeOfConduct{
|
|
Name: new(""),
|
|
Key: new(""),
|
|
URL: new(""),
|
|
Body: new(""),
|
|
}
|
|
want := `github.CodeOfConduct{Name:"", Key:"", URL:"", Body:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("CodeOfConduct.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestCodeResult_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := CodeResult{
|
|
Name: new(""),
|
|
Path: new(""),
|
|
SHA: new(""),
|
|
HTMLURL: new(""),
|
|
Repository: &Repository{},
|
|
}
|
|
want := `github.CodeResult{Name:"", Path:"", SHA:"", HTMLURL:"", Repository:github.Repository{}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("CodeResult.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestCodeSecurity_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := CodeSecurity{
|
|
Status: new(""),
|
|
}
|
|
want := `github.CodeSecurity{Status:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("CodeSecurity.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestCombinedStatus_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := CombinedStatus{
|
|
State: new(""),
|
|
Name: new(""),
|
|
SHA: new(""),
|
|
TotalCount: new(0),
|
|
CommitURL: new(""),
|
|
RepositoryURL: new(""),
|
|
}
|
|
want := `github.CombinedStatus{State:"", Name:"", SHA:"", TotalCount:0, CommitURL:"", RepositoryURL:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("CombinedStatus.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestCommentStats_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := CommentStats{
|
|
TotalCommitComments: new(0),
|
|
TotalGistComments: new(0),
|
|
TotalIssueComments: new(0),
|
|
TotalPullRequestComments: new(0),
|
|
}
|
|
want := `github.CommentStats{TotalCommitComments:0, TotalGistComments:0, TotalIssueComments:0, TotalPullRequestComments:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("CommentStats.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestCommit_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Commit{
|
|
SHA: new(""),
|
|
Author: &CommitAuthor{},
|
|
Committer: &CommitAuthor{},
|
|
Message: new(""),
|
|
Tree: &Tree{},
|
|
HTMLURL: new(""),
|
|
URL: new(""),
|
|
Verification: &SignatureVerification{},
|
|
NodeID: new(""),
|
|
CommentCount: new(0),
|
|
}
|
|
want := `github.Commit{SHA:"", Author:github.CommitAuthor{}, Committer:github.CommitAuthor{}, Message:"", Tree:github.Tree{}, HTMLURL:"", URL:"", Verification:github.SignatureVerification{}, NodeID:"", CommentCount:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Commit.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestCommitAuthor_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := CommitAuthor{
|
|
Date: &Timestamp{},
|
|
Name: new(""),
|
|
Email: new(""),
|
|
Login: new(""),
|
|
}
|
|
want := `github.CommitAuthor{Date:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Name:"", Email:"", Login:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("CommitAuthor.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestCommitFile_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := CommitFile{
|
|
SHA: new(""),
|
|
Filename: new(""),
|
|
Additions: new(0),
|
|
Deletions: new(0),
|
|
Changes: new(0),
|
|
Status: new(""),
|
|
Patch: new(""),
|
|
BlobURL: new(""),
|
|
RawURL: new(""),
|
|
ContentsURL: new(""),
|
|
PreviousFilename: new(""),
|
|
}
|
|
want := `github.CommitFile{SHA:"", Filename:"", Additions:0, Deletions:0, Changes:0, Status:"", Patch:"", BlobURL:"", RawURL:"", ContentsURL:"", PreviousFilename:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("CommitFile.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestCommitStats_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := CommitStats{
|
|
Additions: new(0),
|
|
Deletions: new(0),
|
|
Total: new(0),
|
|
}
|
|
want := `github.CommitStats{Additions:0, Deletions:0, Total:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("CommitStats.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestCommitsComparison_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := CommitsComparison{
|
|
BaseCommit: &RepositoryCommit{},
|
|
MergeBaseCommit: &RepositoryCommit{},
|
|
Status: new(""),
|
|
AheadBy: new(0),
|
|
BehindBy: new(0),
|
|
TotalCommits: new(0),
|
|
HTMLURL: new(""),
|
|
PermalinkURL: new(""),
|
|
DiffURL: new(""),
|
|
PatchURL: new(""),
|
|
URL: new(""),
|
|
}
|
|
want := `github.CommitsComparison{BaseCommit:github.RepositoryCommit{}, MergeBaseCommit:github.RepositoryCommit{}, Status:"", AheadBy:0, BehindBy:0, TotalCommits:0, HTMLURL:"", PermalinkURL:"", DiffURL:"", PatchURL:"", URL:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("CommitsComparison.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestContributorApprovalPermissions_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := ContributorApprovalPermissions{
|
|
ApprovalPolicy: "",
|
|
}
|
|
want := `github.ContributorApprovalPermissions{ApprovalPolicy:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("ContributorApprovalPermissions.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestContributorStats_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := ContributorStats{
|
|
Author: &Contributor{},
|
|
Total: new(0),
|
|
}
|
|
want := `github.ContributorStats{Author:github.Contributor{}, Total:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("ContributorStats.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestCreateRepositoryRequest_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := CreateRepositoryRequest{
|
|
Name: "",
|
|
Description: new(""),
|
|
Homepage: new(""),
|
|
Private: new(false),
|
|
Visibility: new(""),
|
|
HasIssues: new(false),
|
|
HasProjects: new(false),
|
|
HasWiki: new(false),
|
|
HasDiscussions: new(false),
|
|
IsTemplate: new(false),
|
|
TeamID: new(int64(0)),
|
|
AutoInit: new(false),
|
|
GitignoreTemplate: new(""),
|
|
LicenseTemplate: new(""),
|
|
AllowSquashMerge: new(false),
|
|
AllowMergeCommit: new(false),
|
|
AllowRebaseMerge: new(false),
|
|
AllowUpdateBranch: new(false),
|
|
AllowAutoMerge: new(false),
|
|
AllowForking: new(false),
|
|
DeleteBranchOnMerge: new(false),
|
|
UseSquashPRTitleAsDefault: new(false),
|
|
SquashMergeCommitTitle: new(""),
|
|
SquashMergeCommitMessage: new(""),
|
|
MergeCommitTitle: new(""),
|
|
MergeCommitMessage: new(""),
|
|
}
|
|
want := `github.CreateRepositoryRequest{Name:"", Description:"", Homepage:"", Private:false, Visibility:"", HasIssues:false, HasProjects:false, HasWiki:false, HasDiscussions:false, IsTemplate:false, TeamID:0, AutoInit:false, GitignoreTemplate:"", LicenseTemplate:"", AllowSquashMerge:false, AllowMergeCommit:false, AllowRebaseMerge:false, AllowUpdateBranch:false, AllowAutoMerge:false, AllowForking:false, DeleteBranchOnMerge:false, UseSquashPRTitleAsDefault:false, SquashMergeCommitTitle:"", SquashMergeCommitMessage:"", MergeCommitTitle:"", MergeCommitMessage:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("CreateRepositoryRequest.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestCreateTeamRequest_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := CreateTeamRequest{
|
|
Name: "",
|
|
Description: new(""),
|
|
Maintainers: []string{""},
|
|
RepoNames: []string{""},
|
|
Privacy: new(""),
|
|
NotificationSetting: new(""),
|
|
Permission: new(""),
|
|
ParentTeamID: new(int64(0)),
|
|
ParentTeamSlug: new(""),
|
|
LDAPDN: new(""),
|
|
}
|
|
want := `github.CreateTeamRequest{Name:"", Description:"", Maintainers:[""], RepoNames:[""], Privacy:"", NotificationSetting:"", Permission:"", ParentTeamID:0, ParentTeamSlug:"", LDAPDN:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("CreateTeamRequest.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestDependabotSecurityUpdates_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := DependabotSecurityUpdates{
|
|
Status: new(""),
|
|
}
|
|
want := `github.DependabotSecurityUpdates{Status:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("DependabotSecurityUpdates.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestDiscussionComment_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := DiscussionComment{
|
|
Author: &User{},
|
|
Body: new(""),
|
|
BodyHTML: new(""),
|
|
BodyVersion: new(""),
|
|
CreatedAt: &Timestamp{},
|
|
LastEditedAt: &Timestamp{},
|
|
DiscussionURL: new(""),
|
|
HTMLURL: new(""),
|
|
NodeID: new(""),
|
|
Number: new(0),
|
|
UpdatedAt: &Timestamp{},
|
|
URL: new(""),
|
|
Reactions: &Reactions{},
|
|
}
|
|
want := `github.DiscussionComment{Author:github.User{}, Body:"", BodyHTML:"", BodyVersion:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, LastEditedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, DiscussionURL:"", HTMLURL:"", NodeID:"", Number:0, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, URL:"", Reactions:github.Reactions{}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("DiscussionComment.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestDraftReviewComment_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := DraftReviewComment{
|
|
Path: new(""),
|
|
Position: new(0),
|
|
Body: new(""),
|
|
StartSide: new(""),
|
|
Side: new(""),
|
|
StartLine: new(0),
|
|
Line: new(0),
|
|
}
|
|
want := `github.DraftReviewComment{Path:"", Position:0, Body:"", StartSide:"", Side:"", StartLine:0, Line:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("DraftReviewComment.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestEnterprise_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Enterprise{
|
|
ID: new(0),
|
|
Slug: new(""),
|
|
Name: new(""),
|
|
NodeID: new(""),
|
|
AvatarURL: new(""),
|
|
Description: new(""),
|
|
WebsiteURL: new(""),
|
|
HTMLURL: new(""),
|
|
CreatedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
}
|
|
want := `github.Enterprise{ID:0, Slug:"", Name:"", NodeID:"", AvatarURL:"", Description:"", WebsiteURL:"", HTMLURL:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Enterprise.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestEnterpriseBudget_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := EnterpriseBudget{
|
|
ID: new(""),
|
|
BudgetType: new(""),
|
|
BudgetProductSKU: new(""),
|
|
BudgetScope: new(""),
|
|
BudgetEntityName: new(""),
|
|
BudgetAmount: new(0),
|
|
PreventFurtherUsage: new(false),
|
|
BudgetAlerting: &EnterpriseBudgetAlerting{},
|
|
}
|
|
want := `github.EnterpriseBudget{ID:"", BudgetType:"", BudgetProductSKU:"", BudgetScope:"", BudgetEntityName:"", BudgetAmount:0, PreventFurtherUsage:false, BudgetAlerting:github.EnterpriseBudgetAlerting{}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("EnterpriseBudget.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestEnterpriseBudgetUserState_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := EnterpriseBudgetUserState{
|
|
User: new(""),
|
|
ConsumedAmount: 0.0,
|
|
TargetAmount: 0.0,
|
|
OverrideBudgetID: new(""),
|
|
}
|
|
want := `github.EnterpriseBudgetUserState{User:"", ConsumedAmount:0, TargetAmount:0, OverrideBudgetID:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("EnterpriseBudgetUserState.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestEnterpriseBudgetUserStates_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := EnterpriseBudgetUserStates{
|
|
HasNextPage: false,
|
|
TotalCount: 0,
|
|
}
|
|
want := `github.EnterpriseBudgetUserStates{HasNextPage:false, TotalCount:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("EnterpriseBudgetUserStates.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestEvent_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Event{
|
|
Type: new(""),
|
|
Public: new(false),
|
|
Repo: &Repository{},
|
|
Actor: &User{},
|
|
Org: &Organization{},
|
|
CreatedAt: &Timestamp{},
|
|
ID: new(""),
|
|
}
|
|
want := `github.Event{Type:"", Public:false, Repo:github.Repository{}, Actor:github.User{}, Org:github.Organization{}, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, ID:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Event.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestGPGKey_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := GPGKey{
|
|
ID: new(int64(0)),
|
|
PrimaryKeyID: new(int64(0)),
|
|
KeyID: new(""),
|
|
RawKey: new(""),
|
|
PublicKey: new(""),
|
|
CanSign: new(false),
|
|
CanEncryptComms: new(false),
|
|
CanEncryptStorage: new(false),
|
|
CanCertify: new(false),
|
|
CreatedAt: &Timestamp{},
|
|
ExpiresAt: &Timestamp{},
|
|
}
|
|
want := `github.GPGKey{ID:0, PrimaryKeyID:0, KeyID:"", RawKey:"", PublicKey:"", CanSign:false, CanEncryptComms:false, CanEncryptStorage:false, CanCertify:false, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, ExpiresAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("GPGKey.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestGist_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Gist{
|
|
ID: new(""),
|
|
Description: new(""),
|
|
Public: new(false),
|
|
Owner: &User{},
|
|
Comments: new(0),
|
|
HTMLURL: new(""),
|
|
GitPullURL: new(""),
|
|
GitPushURL: new(""),
|
|
CreatedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
NodeID: new(""),
|
|
}
|
|
want := `github.Gist{ID:"", Description:"", Public:false, Owner:github.User{}, Comments:0, HTMLURL:"", GitPullURL:"", GitPushURL:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, NodeID:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Gist.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestGistComment_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := GistComment{
|
|
ID: new(int64(0)),
|
|
URL: new(""),
|
|
Body: new(""),
|
|
User: &User{},
|
|
CreatedAt: &Timestamp{},
|
|
}
|
|
want := `github.GistComment{ID:0, URL:"", Body:"", User:github.User{}, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("GistComment.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestGistCommit_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := GistCommit{
|
|
URL: new(""),
|
|
Version: new(""),
|
|
User: &User{},
|
|
ChangeStatus: &CommitStats{},
|
|
CommittedAt: &Timestamp{},
|
|
NodeID: new(""),
|
|
}
|
|
want := `github.GistCommit{URL:"", Version:"", User:github.User{}, ChangeStatus:github.CommitStats{}, CommittedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, NodeID:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("GistCommit.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestGistFile_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := GistFile{
|
|
Size: new(0),
|
|
Filename: new(""),
|
|
Language: new(""),
|
|
Type: new(""),
|
|
RawURL: new(""),
|
|
Content: new(""),
|
|
}
|
|
want := `github.GistFile{Size:0, Filename:"", Language:"", Type:"", RawURL:"", Content:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("GistFile.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestGistFork_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := GistFork{
|
|
URL: new(""),
|
|
User: &User{},
|
|
ID: new(""),
|
|
CreatedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
NodeID: new(""),
|
|
}
|
|
want := `github.GistFork{URL:"", User:github.User{}, ID:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, NodeID:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("GistFork.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestGistStats_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := GistStats{
|
|
TotalGists: new(0),
|
|
PrivateGists: new(0),
|
|
PublicGists: new(0),
|
|
}
|
|
want := `github.GistStats{TotalGists:0, PrivateGists:0, PublicGists:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("GistStats.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestGitObject_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := GitObject{
|
|
Type: new(""),
|
|
SHA: new(""),
|
|
URL: new(""),
|
|
}
|
|
want := `github.GitObject{Type:"", SHA:"", URL:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("GitObject.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestGitignore_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Gitignore{
|
|
Name: new(""),
|
|
Source: new(""),
|
|
}
|
|
want := `github.Gitignore{Name:"", Source:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Gitignore.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestGrant_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Grant{
|
|
ID: new(int64(0)),
|
|
URL: new(""),
|
|
App: &AuthorizationApp{},
|
|
CreatedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
Scopes: []string{""},
|
|
}
|
|
want := `github.Grant{ID:0, URL:"", App:github.AuthorizationApp{}, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Scopes:[""]}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Grant.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestHeadCommit_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := HeadCommit{
|
|
Message: new(""),
|
|
Author: &CommitAuthor{},
|
|
URL: new(""),
|
|
Distinct: new(false),
|
|
SHA: new(""),
|
|
ID: new(""),
|
|
TreeID: new(""),
|
|
Timestamp: &Timestamp{},
|
|
Committer: &CommitAuthor{},
|
|
Added: []string{""},
|
|
Removed: []string{""},
|
|
Modified: []string{""},
|
|
}
|
|
want := `github.HeadCommit{Message:"", Author:github.CommitAuthor{}, URL:"", Distinct:false, SHA:"", ID:"", TreeID:"", Timestamp:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Committer:github.CommitAuthor{}, Added:[""], Removed:[""], Modified:[""]}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("HeadCommit.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestHook_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Hook{
|
|
CreatedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
URL: new(""),
|
|
ID: new(int64(0)),
|
|
Type: new(""),
|
|
Name: new(""),
|
|
TestURL: new(""),
|
|
PingURL: new(""),
|
|
Config: &HookConfig{},
|
|
Events: []string{""},
|
|
Active: new(false),
|
|
}
|
|
want := `github.Hook{CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, URL:"", ID:0, Type:"", Name:"", TestURL:"", PingURL:"", Config:github.HookConfig{}, Events:[""], Active:false}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Hook.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestHookDelivery_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := HookDelivery{
|
|
ID: new(int64(0)),
|
|
GUID: new(""),
|
|
DeliveredAt: &Timestamp{},
|
|
Redelivery: new(false),
|
|
Duration: new(0.0),
|
|
Status: new(""),
|
|
StatusCode: new(0),
|
|
Event: new(""),
|
|
Action: new(""),
|
|
InstallationID: new(int64(0)),
|
|
RepositoryID: new(int64(0)),
|
|
ThrottledAt: &Timestamp{},
|
|
Request: &HookRequest{},
|
|
Response: &HookResponse{},
|
|
}
|
|
want := `github.HookDelivery{ID:0, GUID:"", DeliveredAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Redelivery:false, Duration:0, Status:"", StatusCode:0, Event:"", Action:"", InstallationID:0, RepositoryID:0, ThrottledAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Request:github.HookRequest{}, Response:github.HookResponse{}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("HookDelivery.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestHookStats_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := HookStats{
|
|
TotalHooks: new(0),
|
|
ActiveHooks: new(0),
|
|
InactiveHooks: new(0),
|
|
}
|
|
want := `github.HookStats{TotalHooks:0, ActiveHooks:0, InactiveHooks:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("HookStats.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestImport_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Import{
|
|
VCSURL: new(""),
|
|
VCS: new(""),
|
|
VCSUsername: new(""),
|
|
VCSPassword: new(""),
|
|
TFVCProject: new(""),
|
|
UseLFS: new(""),
|
|
HasLargeFiles: new(false),
|
|
LargeFilesSize: new(0),
|
|
LargeFilesCount: new(0),
|
|
Status: new(""),
|
|
CommitCount: new(0),
|
|
StatusText: new(""),
|
|
AuthorsCount: new(0),
|
|
Percent: new(0),
|
|
PushPercent: new(0),
|
|
URL: new(""),
|
|
HTMLURL: new(""),
|
|
AuthorsURL: new(""),
|
|
RepositoryURL: new(""),
|
|
Message: new(""),
|
|
FailedStep: new(""),
|
|
HumanName: new(""),
|
|
}
|
|
want := `github.Import{VCSURL:"", VCS:"", VCSUsername:"", VCSPassword:"", TFVCProject:"", UseLFS:"", HasLargeFiles:false, LargeFilesSize:0, LargeFilesCount:0, Status:"", CommitCount:0, StatusText:"", AuthorsCount:0, Percent:0, PushPercent:0, URL:"", HTMLURL:"", AuthorsURL:"", RepositoryURL:"", Message:"", FailedStep:"", HumanName:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Import.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestInstallation_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Installation{
|
|
ID: new(int64(0)),
|
|
NodeID: new(""),
|
|
ClientID: new(""),
|
|
AppID: new(int64(0)),
|
|
AppSlug: new(""),
|
|
TargetID: new(int64(0)),
|
|
Account: &User{},
|
|
AccessTokensURL: new(""),
|
|
RepositoriesURL: new(""),
|
|
HTMLURL: new(""),
|
|
TargetType: new(""),
|
|
SingleFileName: new(""),
|
|
RepositorySelection: new(""),
|
|
Events: []string{""},
|
|
SingleFilePaths: []string{""},
|
|
Permissions: &InstallationPermissions{},
|
|
CreatedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
HasMultipleSingleFiles: new(false),
|
|
SuspendedBy: &User{},
|
|
SuspendedAt: &Timestamp{},
|
|
}
|
|
want := `github.Installation{ID:0, NodeID:"", ClientID:"", AppID:0, AppSlug:"", TargetID:0, Account:github.User{}, AccessTokensURL:"", RepositoriesURL:"", HTMLURL:"", TargetType:"", SingleFileName:"", RepositorySelection:"", Events:[""], SingleFilePaths:[""], Permissions:github.InstallationPermissions{}, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, HasMultipleSingleFiles:false, SuspendedBy:github.User{}, SuspendedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Installation.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestInvitation_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Invitation{
|
|
ID: new(int64(0)),
|
|
NodeID: new(""),
|
|
Login: new(""),
|
|
Email: new(""),
|
|
Role: new(""),
|
|
CreatedAt: &Timestamp{},
|
|
Inviter: &User{},
|
|
TeamCount: new(0),
|
|
InvitationTeamURL: new(""),
|
|
FailedAt: &Timestamp{},
|
|
FailedReason: new(""),
|
|
}
|
|
want := `github.Invitation{ID:0, NodeID:"", Login:"", Email:"", Role:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Inviter:github.User{}, TeamCount:0, InvitationTeamURL:"", FailedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, FailedReason:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Invitation.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestIssue_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Issue{
|
|
ID: new(int64(0)),
|
|
Number: new(0),
|
|
State: new(""),
|
|
StateReason: new(""),
|
|
Locked: new(false),
|
|
Title: new(""),
|
|
Body: new(""),
|
|
AuthorAssociation: new(""),
|
|
User: &User{},
|
|
Assignee: &User{},
|
|
Comments: new(0),
|
|
ClosedAt: &Timestamp{},
|
|
CreatedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
ClosedBy: &User{},
|
|
URL: new(""),
|
|
HTMLURL: new(""),
|
|
CommentsURL: new(""),
|
|
EventsURL: new(""),
|
|
LabelsURL: new(""),
|
|
RepositoryURL: new(""),
|
|
ParentIssueURL: new(""),
|
|
Milestone: &Milestone{},
|
|
PullRequestLinks: &PullRequestLinks{},
|
|
Repository: &Repository{},
|
|
Reactions: &Reactions{},
|
|
NodeID: new(""),
|
|
Draft: new(false),
|
|
Type: &IssueType{},
|
|
PinnedComment: &IssueComment{},
|
|
PerformedViaGithubApp: &App{},
|
|
IssueDependenciesSummary: &IssueDependenciesSummary{},
|
|
SubIssuesSummary: &SubIssuesSummary{},
|
|
ActiveLockReason: new(""),
|
|
}
|
|
want := `github.Issue{ID:0, Number:0, State:"", StateReason:"", Locked:false, Title:"", Body:"", AuthorAssociation:"", User:github.User{}, Assignee:github.User{}, Comments:0, ClosedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, ClosedBy:github.User{}, URL:"", HTMLURL:"", CommentsURL:"", EventsURL:"", LabelsURL:"", RepositoryURL:"", ParentIssueURL:"", Milestone:github.Milestone{}, PullRequestLinks:github.PullRequestLinks{}, Repository:github.Repository{}, Reactions:github.Reactions{}, NodeID:"", Draft:false, Type:github.IssueType{}, PinnedComment:github.IssueComment{}, PerformedViaGithubApp:github.App{}, IssueDependenciesSummary:github.IssueDependenciesSummary{}, SubIssuesSummary:github.SubIssuesSummary{}, ActiveLockReason:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Issue.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestIssueComment_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := IssueComment{
|
|
ID: new(int64(0)),
|
|
NodeID: new(""),
|
|
Body: new(""),
|
|
User: &User{},
|
|
Reactions: &Reactions{},
|
|
CreatedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
AuthorAssociation: new(""),
|
|
PerformedViaGithubApp: &App{},
|
|
Pin: &PinnedIssueComment{},
|
|
Minimized: &MinimizedIssueComment{},
|
|
URL: new(""),
|
|
HTMLURL: new(""),
|
|
IssueURL: new(""),
|
|
}
|
|
want := `github.IssueComment{ID:0, NodeID:"", Body:"", User:github.User{}, Reactions:github.Reactions{}, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, AuthorAssociation:"", PerformedViaGithubApp:github.App{}, Pin:github.PinnedIssueComment{}, Minimized:github.MinimizedIssueComment{}, URL:"", HTMLURL:"", IssueURL:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("IssueComment.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestIssueStats_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := IssueStats{
|
|
TotalIssues: new(0),
|
|
OpenIssues: new(0),
|
|
ClosedIssues: new(0),
|
|
}
|
|
want := `github.IssueStats{TotalIssues:0, OpenIssues:0, ClosedIssues:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("IssueStats.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestKey_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Key{
|
|
ID: new(int64(0)),
|
|
Key: new(""),
|
|
URL: new(""),
|
|
Title: new(""),
|
|
ReadOnly: new(false),
|
|
Enabled: new(false),
|
|
Verified: new(false),
|
|
CreatedAt: &Timestamp{},
|
|
AddedBy: new(""),
|
|
LastUsed: &Timestamp{},
|
|
}
|
|
want := `github.Key{ID:0, Key:"", URL:"", Title:"", ReadOnly:false, Enabled:false, Verified:false, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, AddedBy:"", LastUsed:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Key.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestLabel_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Label{
|
|
ID: 0,
|
|
URL: "",
|
|
Name: "",
|
|
Color: "",
|
|
Description: new(""),
|
|
Default: false,
|
|
NodeID: "",
|
|
}
|
|
want := `github.Label{ID:0, URL:"", Name:"", Color:"", Description:"", Default:false, NodeID:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Label.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestLabelResult_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := LabelResult{
|
|
ID: new(int64(0)),
|
|
URL: new(""),
|
|
Name: new(""),
|
|
Color: new(""),
|
|
Default: new(false),
|
|
Description: new(""),
|
|
Score: new(0.0),
|
|
}
|
|
want := `github.LabelResult{ID:0, URL:"", Name:"", Color:"", Default:false, Description:"", Score:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("LabelResult.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestLargeFile_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := LargeFile{
|
|
RefName: new(""),
|
|
Path: new(""),
|
|
OID: new(""),
|
|
Size: new(0),
|
|
}
|
|
want := `github.LargeFile{RefName:"", Path:"", OID:"", Size:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("LargeFile.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestLicense_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := License{
|
|
Key: new(""),
|
|
Name: new(""),
|
|
URL: new(""),
|
|
SPDXID: new(""),
|
|
HTMLURL: new(""),
|
|
Featured: new(false),
|
|
Description: new(""),
|
|
Implementation: new(""),
|
|
Body: new(""),
|
|
}
|
|
want := `github.License{Key:"", Name:"", URL:"", SPDXID:"", HTMLURL:"", Featured:false, Description:"", Implementation:"", Body:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("License.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestMembership_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Membership{
|
|
URL: new(""),
|
|
State: new(""),
|
|
Role: new(""),
|
|
OrganizationURL: new(""),
|
|
Organization: &Organization{},
|
|
User: &User{},
|
|
}
|
|
want := `github.Membership{URL:"", State:"", Role:"", OrganizationURL:"", Organization:github.Organization{}, User:github.User{}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Membership.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestMigration_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Migration{
|
|
ID: new(int64(0)),
|
|
GUID: new(""),
|
|
State: new(""),
|
|
LockRepositories: new(false),
|
|
ExcludeAttachments: new(false),
|
|
URL: new(""),
|
|
CreatedAt: new(""),
|
|
UpdatedAt: new(""),
|
|
}
|
|
want := `github.Migration{ID:0, GUID:"", State:"", LockRepositories:false, ExcludeAttachments:false, URL:"", CreatedAt:"", UpdatedAt:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Migration.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestMilestone_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Milestone{
|
|
URL: new(""),
|
|
HTMLURL: new(""),
|
|
LabelsURL: new(""),
|
|
ID: new(int64(0)),
|
|
Number: new(0),
|
|
State: new(""),
|
|
Title: new(""),
|
|
Description: new(""),
|
|
Creator: &User{},
|
|
OpenIssues: new(0),
|
|
ClosedIssues: new(0),
|
|
CreatedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
ClosedAt: &Timestamp{},
|
|
DueOn: &Timestamp{},
|
|
NodeID: new(""),
|
|
}
|
|
want := `github.Milestone{URL:"", HTMLURL:"", LabelsURL:"", ID:0, Number:0, State:"", Title:"", Description:"", Creator:github.User{}, OpenIssues:0, ClosedIssues:0, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, ClosedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, DueOn:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, NodeID:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Milestone.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestMilestoneStats_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := MilestoneStats{
|
|
TotalMilestones: new(0),
|
|
OpenMilestones: new(0),
|
|
ClosedMilestones: new(0),
|
|
}
|
|
want := `github.MilestoneStats{TotalMilestones:0, OpenMilestones:0, ClosedMilestones:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("MilestoneStats.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestOAuthAPP_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := OAuthAPP{
|
|
URL: new(""),
|
|
Name: new(""),
|
|
ClientID: new(""),
|
|
}
|
|
want := `github.OAuthAPP{URL:"", Name:"", ClientID:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("OAuthAPP.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestOrgStats_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := OrgStats{
|
|
TotalOrgs: new(0),
|
|
DisabledOrgs: new(0),
|
|
TotalTeams: new(0),
|
|
TotalTeamMembers: new(0),
|
|
}
|
|
want := `github.OrgStats{TotalOrgs:0, DisabledOrgs:0, TotalTeams:0, TotalTeamMembers:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("OrgStats.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestOrganization_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Organization{
|
|
Login: new(""),
|
|
ID: new(int64(0)),
|
|
NodeID: new(""),
|
|
AvatarURL: new(""),
|
|
HTMLURL: new(""),
|
|
Name: new(""),
|
|
Company: new(""),
|
|
Blog: new(""),
|
|
Location: new(""),
|
|
Email: new(""),
|
|
TwitterUsername: new(""),
|
|
Description: new(""),
|
|
PublicRepos: new(0),
|
|
PublicGists: new(0),
|
|
Followers: new(0),
|
|
Following: new(0),
|
|
CreatedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
ArchivedAt: &Timestamp{},
|
|
TotalPrivateRepos: new(int64(0)),
|
|
OwnedPrivateRepos: new(int64(0)),
|
|
PrivateGists: new(0),
|
|
DiskUsage: new(0),
|
|
Collaborators: new(0),
|
|
BillingEmail: new(""),
|
|
Type: new(""),
|
|
Plan: &Plan{},
|
|
TwoFactorRequirementEnabled: new(false),
|
|
IsVerified: new(false),
|
|
HasOrganizationProjects: new(false),
|
|
HasRepositoryProjects: new(false),
|
|
DefaultRepoPermission: new(""),
|
|
DefaultRepoSettings: new(""),
|
|
MembersCanCreateRepos: new(false),
|
|
MembersCanCreatePublicRepos: new(false),
|
|
MembersCanCreatePrivateRepos: new(false),
|
|
MembersCanCreateInternalRepos: new(false),
|
|
MembersCanForkPrivateRepos: new(false),
|
|
DeployKeysEnabledForRepositories: new(false),
|
|
MembersAllowedRepositoryCreationType: new(""),
|
|
MembersCanCreatePages: new(false),
|
|
MembersCanCreatePublicPages: new(false),
|
|
MembersCanCreatePrivatePages: new(false),
|
|
WebCommitSignoffRequired: new(false),
|
|
AdvancedSecurityEnabledForNewRepos: new(false),
|
|
DependabotAlertsEnabledForNewRepos: new(false),
|
|
DependabotSecurityUpdatesEnabledForNewRepos: new(false),
|
|
DependencyGraphEnabledForNewRepos: new(false),
|
|
SecretScanningEnabledForNewRepos: new(false),
|
|
SecretScanningPushProtectionEnabledForNewRepos: new(false),
|
|
SecretScanningValidityChecksEnabled: new(false),
|
|
SecretScanningPushProtectionCustomLinkEnabled: new(false),
|
|
SecretScanningPushProtectionCustomLink: new(""),
|
|
MembersCanDeleteRepositories: new(false),
|
|
MembersCanChangeRepoVisibility: new(false),
|
|
MembersCanInviteOutsideCollaborators: new(false),
|
|
MembersCanDeleteIssues: new(false),
|
|
DisplayCommenterFullNameSettingEnabled: new(false),
|
|
ReadersCanCreateDiscussions: new(false),
|
|
MembersCanCreateTeams: new(false),
|
|
MembersCanViewDependencyInsights: new(false),
|
|
DefaultRepositoryBranch: new(""),
|
|
URL: new(""),
|
|
EventsURL: new(""),
|
|
HooksURL: new(""),
|
|
IssuesURL: new(""),
|
|
MembersURL: new(""),
|
|
PublicMembersURL: new(""),
|
|
ReposURL: new(""),
|
|
}
|
|
want := `github.Organization{Login:"", ID:0, NodeID:"", AvatarURL:"", HTMLURL:"", Name:"", Company:"", Blog:"", Location:"", Email:"", TwitterUsername:"", Description:"", PublicRepos:0, PublicGists:0, Followers:0, Following:0, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, ArchivedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, TotalPrivateRepos:0, OwnedPrivateRepos:0, PrivateGists:0, DiskUsage:0, Collaborators:0, BillingEmail:"", Type:"", Plan:github.Plan{}, TwoFactorRequirementEnabled:false, IsVerified:false, HasOrganizationProjects:false, HasRepositoryProjects:false, DefaultRepoPermission:"", DefaultRepoSettings:"", MembersCanCreateRepos:false, MembersCanCreatePublicRepos:false, MembersCanCreatePrivateRepos:false, MembersCanCreateInternalRepos:false, MembersCanForkPrivateRepos:false, DeployKeysEnabledForRepositories:false, MembersAllowedRepositoryCreationType:"", MembersCanCreatePages:false, MembersCanCreatePublicPages:false, MembersCanCreatePrivatePages:false, WebCommitSignoffRequired:false, AdvancedSecurityEnabledForNewRepos:false, DependabotAlertsEnabledForNewRepos:false, DependabotSecurityUpdatesEnabledForNewRepos:false, DependencyGraphEnabledForNewRepos:false, SecretScanningEnabledForNewRepos:false, SecretScanningPushProtectionEnabledForNewRepos:false, SecretScanningValidityChecksEnabled:false, SecretScanningPushProtectionCustomLinkEnabled:false, SecretScanningPushProtectionCustomLink:"", MembersCanDeleteRepositories:false, MembersCanChangeRepoVisibility:false, MembersCanInviteOutsideCollaborators:false, MembersCanDeleteIssues:false, DisplayCommenterFullNameSettingEnabled:false, ReadersCanCreateDiscussions:false, MembersCanCreateTeams:false, MembersCanViewDependencyInsights:false, DefaultRepositoryBranch:"", URL:"", EventsURL:"", HooksURL:"", IssuesURL:"", MembersURL:"", PublicMembersURL:"", ReposURL:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Organization.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPackage_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Package{
|
|
ID: new(int64(0)),
|
|
Name: new(""),
|
|
PackageType: new(""),
|
|
HTMLURL: new(""),
|
|
Visibility: new(""),
|
|
Owner: &User{},
|
|
Repository: &Repository{},
|
|
CreatedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
Namespace: new(""),
|
|
Description: new(""),
|
|
Ecosystem: new(""),
|
|
PackageVersion: &PackageVersion{},
|
|
Registry: &PackageRegistry{},
|
|
URL: new(""),
|
|
VersionCount: new(int64(0)),
|
|
}
|
|
want := `github.Package{ID:0, Name:"", PackageType:"", HTMLURL:"", Visibility:"", Owner:github.User{}, Repository:github.Repository{}, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Namespace:"", Description:"", Ecosystem:"", PackageVersion:github.PackageVersion{}, Registry:github.PackageRegistry{}, URL:"", VersionCount:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Package.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPackageContainerMetadata_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := PackageContainerMetadata{
|
|
Tags: []string{""},
|
|
}
|
|
want := `github.PackageContainerMetadata{Tags:[""]}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("PackageContainerMetadata.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPackageEventContainerMetadata_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := PackageEventContainerMetadata{
|
|
Tag: &PackageEventContainerMetadataTag{},
|
|
}
|
|
want := `github.PackageEventContainerMetadata{Tag:github.PackageEventContainerMetadataTag{}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("PackageEventContainerMetadata.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPackageEventContainerMetadataTag_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := PackageEventContainerMetadataTag{
|
|
Name: new(""),
|
|
Digest: new(""),
|
|
}
|
|
want := `github.PackageEventContainerMetadataTag{Name:"", Digest:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("PackageEventContainerMetadataTag.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPackageFile_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := PackageFile{
|
|
DownloadURL: new(""),
|
|
ID: new(int64(0)),
|
|
Name: new(""),
|
|
SHA256: new(""),
|
|
SHA1: new(""),
|
|
MD5: new(""),
|
|
ContentType: new(""),
|
|
State: new(""),
|
|
Author: &User{},
|
|
Size: new(int64(0)),
|
|
CreatedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
}
|
|
want := `github.PackageFile{DownloadURL:"", ID:0, Name:"", SHA256:"", SHA1:"", MD5:"", ContentType:"", State:"", Author:github.User{}, Size:0, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("PackageFile.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPackageMetadata_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := PackageMetadata{
|
|
PackageType: new(""),
|
|
Container: &PackageContainerMetadata{},
|
|
}
|
|
want := `github.PackageMetadata{PackageType:"", Container:github.PackageContainerMetadata{}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("PackageMetadata.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPackageNPMMetadata_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := PackageNPMMetadata{
|
|
Name: new(""),
|
|
Version: new(""),
|
|
NPMUser: new(""),
|
|
Description: new(""),
|
|
GitHead: new(""),
|
|
Homepage: new(""),
|
|
License: new(""),
|
|
Main: new(""),
|
|
ID: new(""),
|
|
NodeVersion: new(""),
|
|
NPMVersion: new(""),
|
|
HasShrinkwrap: new(false),
|
|
Maintainers: []any{nil},
|
|
Contributors: []any{nil},
|
|
Keywords: []string{""},
|
|
Files: []string{""},
|
|
OS: []string{""},
|
|
CPU: []string{""},
|
|
Readme: new(""),
|
|
InstallationCommand: new(""),
|
|
ReleaseID: new(int64(0)),
|
|
CommitOID: new(""),
|
|
PublishedViaActions: new(false),
|
|
DeletedByID: new(int64(0)),
|
|
}
|
|
want := `github.PackageNPMMetadata{Name:"", Version:"", NPMUser:"", Description:"", GitHead:"", Homepage:"", License:"", Main:"", ID:"", NodeVersion:"", NPMVersion:"", HasShrinkwrap:false, Maintainers:[<nil>], Contributors:[<nil>], Keywords:[""], Files:[""], OS:[""], CPU:[""], Readme:"", InstallationCommand:"", ReleaseID:0, CommitOID:"", PublishedViaActions:false, DeletedByID:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("PackageNPMMetadata.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPackageNugetMetadata_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := PackageNugetMetadata{
|
|
Name: new(""),
|
|
}
|
|
want := `github.PackageNugetMetadata{Name:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("PackageNugetMetadata.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPackageRegistry_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := PackageRegistry{
|
|
AboutURL: new(""),
|
|
Name: new(""),
|
|
Type: new(""),
|
|
URL: new(""),
|
|
Vendor: new(""),
|
|
}
|
|
want := `github.PackageRegistry{AboutURL:"", Name:"", Type:"", URL:"", Vendor:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("PackageRegistry.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPackageRelease_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := PackageRelease{
|
|
URL: new(""),
|
|
HTMLURL: new(""),
|
|
ID: new(int64(0)),
|
|
TagName: new(""),
|
|
TargetCommitish: new(""),
|
|
Name: new(""),
|
|
Draft: new(false),
|
|
Author: &User{},
|
|
Prerelease: new(false),
|
|
CreatedAt: &Timestamp{},
|
|
PublishedAt: &Timestamp{},
|
|
}
|
|
want := `github.PackageRelease{URL:"", HTMLURL:"", ID:0, TagName:"", TargetCommitish:"", Name:"", Draft:false, Author:github.User{}, Prerelease:false, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, PublishedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("PackageRelease.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPackageVersion_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := PackageVersion{
|
|
ID: new(int64(0)),
|
|
Name: new(""),
|
|
URL: new(""),
|
|
PackageHTMLURL: new(""),
|
|
License: new(""),
|
|
Description: new(""),
|
|
CreatedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
Version: new(""),
|
|
Summary: new(""),
|
|
BodyHTML: new(""),
|
|
Release: &PackageRelease{},
|
|
Manifest: new(""),
|
|
HTMLURL: new(""),
|
|
TagName: new(""),
|
|
TargetCommitish: new(""),
|
|
TargetOID: new(""),
|
|
Draft: new(false),
|
|
Prerelease: new(false),
|
|
ContainerMetadata: &PackageEventContainerMetadata{},
|
|
DockerMetadata: []any{nil},
|
|
NPMMetadata: &PackageNPMMetadata{},
|
|
PackageURL: new(""),
|
|
Author: &User{},
|
|
SourceURL: new(""),
|
|
InstallationCommand: new(""),
|
|
DeletedAt: &Timestamp{},
|
|
}
|
|
want := `github.PackageVersion{ID:0, Name:"", URL:"", PackageHTMLURL:"", License:"", Description:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Version:"", Summary:"", BodyHTML:"", Release:github.PackageRelease{}, Manifest:"", HTMLURL:"", TagName:"", TargetCommitish:"", TargetOID:"", Draft:false, Prerelease:false, ContainerMetadata:github.PackageEventContainerMetadata{}, DockerMetadata:[<nil>], NPMMetadata:github.PackageNPMMetadata{}, PackageURL:"", Author:github.User{}, SourceURL:"", InstallationCommand:"", DeletedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("PackageVersion.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPackageVersionBody_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := PackageVersionBody{
|
|
Repo: &Repository{},
|
|
Info: &PackageVersionBodyInfo{},
|
|
}
|
|
want := `github.PackageVersionBody{Repo:github.Repository{}, Info:github.PackageVersionBodyInfo{}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("PackageVersionBody.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPackageVersionBodyInfo_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := PackageVersionBodyInfo{
|
|
Type: new(""),
|
|
OID: new(""),
|
|
Mode: new(int64(0)),
|
|
Name: new(""),
|
|
Path: new(""),
|
|
Size: new(int64(0)),
|
|
Collection: new(false),
|
|
}
|
|
want := `github.PackageVersionBodyInfo{Type:"", OID:"", Mode:0, Name:"", Path:"", Size:0, Collection:false}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("PackageVersionBodyInfo.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPageStats_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := PageStats{
|
|
TotalPages: new(0),
|
|
}
|
|
want := `github.PageStats{TotalPages:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("PageStats.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPlan_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Plan{
|
|
Name: new(""),
|
|
Space: new(0),
|
|
Collaborators: new(0),
|
|
PrivateRepos: new(int64(0)),
|
|
FilledSeats: new(0),
|
|
Seats: new(0),
|
|
}
|
|
want := `github.Plan{Name:"", Space:0, Collaborators:0, PrivateRepos:0, FilledSeats:0, Seats:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Plan.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPreReceiveHook_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := PreReceiveHook{
|
|
ID: new(int64(0)),
|
|
Name: new(""),
|
|
Enforcement: new(""),
|
|
ConfigURL: new(""),
|
|
}
|
|
want := `github.PreReceiveHook{ID:0, Name:"", Enforcement:"", ConfigURL:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("PreReceiveHook.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestProjectV2_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := ProjectV2{
|
|
ID: new(int64(0)),
|
|
NodeID: new(""),
|
|
Owner: &User{},
|
|
Creator: &User{},
|
|
Title: new(""),
|
|
Description: new(""),
|
|
Public: new(false),
|
|
ClosedAt: &Timestamp{},
|
|
CreatedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
DeletedAt: &Timestamp{},
|
|
Number: new(0),
|
|
ShortDescription: new(""),
|
|
DeletedBy: &User{},
|
|
State: new(""),
|
|
LatestStatusUpdate: &ProjectV2StatusUpdate{},
|
|
IsTemplate: new(false),
|
|
URL: new(""),
|
|
HTMLURL: new(""),
|
|
ColumnsURL: new(""),
|
|
OwnerURL: new(""),
|
|
Name: new(""),
|
|
Body: new(""),
|
|
OrganizationPermission: new(""),
|
|
Private: new(false),
|
|
}
|
|
want := `github.ProjectV2{ID:0, NodeID:"", Owner:github.User{}, Creator:github.User{}, Title:"", Description:"", Public:false, ClosedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, DeletedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Number:0, ShortDescription:"", DeletedBy:github.User{}, State:"", LatestStatusUpdate:github.ProjectV2StatusUpdate{}, IsTemplate:false, URL:"", HTMLURL:"", ColumnsURL:"", OwnerURL:"", Name:"", Body:"", OrganizationPermission:"", Private:false}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("ProjectV2.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPullRequest_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := PullRequest{
|
|
ID: new(int64(0)),
|
|
Number: new(0),
|
|
State: new(""),
|
|
Locked: new(false),
|
|
Title: new(""),
|
|
Body: new(""),
|
|
CreatedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
ClosedAt: &Timestamp{},
|
|
MergedAt: &Timestamp{},
|
|
User: &User{},
|
|
Draft: new(false),
|
|
URL: new(""),
|
|
HTMLURL: new(""),
|
|
IssueURL: new(""),
|
|
StatusesURL: new(""),
|
|
DiffURL: new(""),
|
|
PatchURL: new(""),
|
|
CommitsURL: new(""),
|
|
CommentsURL: new(""),
|
|
ReviewCommentsURL: new(""),
|
|
ReviewCommentURL: new(""),
|
|
Assignee: &User{},
|
|
Milestone: &Milestone{},
|
|
AuthorAssociation: new(""),
|
|
NodeID: new(""),
|
|
AutoMerge: &PullRequestAutoMerge{},
|
|
Merged: new(false),
|
|
Mergeable: new(false),
|
|
MergeableState: new(""),
|
|
Rebaseable: new(false),
|
|
MergedBy: &User{},
|
|
MergeCommitSHA: new(""),
|
|
Comments: new(0),
|
|
Commits: new(0),
|
|
Additions: new(0),
|
|
Deletions: new(0),
|
|
ChangedFiles: new(0),
|
|
MaintainerCanModify: new(false),
|
|
ReviewComments: new(0),
|
|
Links: &PRLinks{},
|
|
Head: &PullRequestBranch{},
|
|
Base: &PullRequestBranch{},
|
|
Stack: &PullRequestStack{},
|
|
ActiveLockReason: new(""),
|
|
}
|
|
want := `github.PullRequest{ID:0, Number:0, State:"", Locked:false, Title:"", Body:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, ClosedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, MergedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, User:github.User{}, Draft:false, URL:"", HTMLURL:"", IssueURL:"", StatusesURL:"", DiffURL:"", PatchURL:"", CommitsURL:"", CommentsURL:"", ReviewCommentsURL:"", ReviewCommentURL:"", Assignee:github.User{}, Milestone:github.Milestone{}, AuthorAssociation:"", NodeID:"", AutoMerge:github.PullRequestAutoMerge{}, Merged:false, Mergeable:false, MergeableState:"", Rebaseable:false, MergedBy:github.User{}, MergeCommitSHA:"", Comments:0, Commits:0, Additions:0, Deletions:0, ChangedFiles:0, MaintainerCanModify:false, ReviewComments:0, Links:github.PRLinks{}, Head:github.PullRequestBranch{}, Base:github.PullRequestBranch{}, Stack:github.PullRequestStack{}, ActiveLockReason:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("PullRequest.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPullRequestComment_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := PullRequestComment{
|
|
ID: new(int64(0)),
|
|
NodeID: new(""),
|
|
InReplyTo: new(int64(0)),
|
|
Body: new(""),
|
|
BodyHTML: new(""),
|
|
BodyText: new(""),
|
|
Path: new(""),
|
|
DiffHunk: new(""),
|
|
PullRequestReviewID: new(int64(0)),
|
|
Position: new(0),
|
|
OriginalPosition: new(0),
|
|
StartLine: new(0),
|
|
Line: new(0),
|
|
OriginalLine: new(0),
|
|
OriginalStartLine: new(0),
|
|
Side: new(""),
|
|
StartSide: new(""),
|
|
CommitID: new(""),
|
|
OriginalCommitID: new(""),
|
|
User: &User{},
|
|
Reactions: &Reactions{},
|
|
CreatedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
AuthorAssociation: new(""),
|
|
URL: new(""),
|
|
HTMLURL: new(""),
|
|
PullRequestURL: new(""),
|
|
Links: &PullRequestCommentLinks{},
|
|
SubjectType: new(""),
|
|
}
|
|
want := `github.PullRequestComment{ID:0, NodeID:"", InReplyTo:0, Body:"", BodyHTML:"", BodyText:"", Path:"", DiffHunk:"", PullRequestReviewID:0, Position:0, OriginalPosition:0, StartLine:0, Line:0, OriginalLine:0, OriginalStartLine:0, Side:"", StartSide:"", CommitID:"", OriginalCommitID:"", User:github.User{}, Reactions:github.Reactions{}, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, AuthorAssociation:"", URL:"", HTMLURL:"", PullRequestURL:"", Links:github.PullRequestCommentLinks{}, SubjectType:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("PullRequestComment.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPullRequestDismissReviewRequest_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := PullRequestDismissReviewRequest{
|
|
Message: "",
|
|
Event: new(""),
|
|
}
|
|
want := `github.PullRequestDismissReviewRequest{Message:"", Event:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("PullRequestDismissReviewRequest.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPullRequestReview_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := PullRequestReview{
|
|
ID: new(int64(0)),
|
|
NodeID: new(""),
|
|
User: &User{},
|
|
Body: new(""),
|
|
SubmittedAt: &Timestamp{},
|
|
CommitID: new(""),
|
|
HTMLURL: new(""),
|
|
PullRequestURL: new(""),
|
|
State: new(""),
|
|
AuthorAssociation: new(""),
|
|
}
|
|
want := `github.PullRequestReview{ID:0, NodeID:"", User:github.User{}, Body:"", SubmittedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, CommitID:"", HTMLURL:"", PullRequestURL:"", State:"", AuthorAssociation:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("PullRequestReview.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPullRequestReviewRequest_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := PullRequestReviewRequest{
|
|
NodeID: new(""),
|
|
CommitID: new(""),
|
|
Body: new(""),
|
|
Event: new(""),
|
|
}
|
|
want := `github.PullRequestReviewRequest{NodeID:"", CommitID:"", Body:"", Event:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("PullRequestReviewRequest.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPullRequestThread_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := PullRequestThread{
|
|
ID: new(int64(0)),
|
|
NodeID: new(""),
|
|
}
|
|
want := `github.PullRequestThread{ID:0, NodeID:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("PullRequestThread.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPullStats_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := PullStats{
|
|
TotalPulls: new(0),
|
|
MergedPulls: new(0),
|
|
MergeablePulls: new(0),
|
|
UnmergeablePulls: new(0),
|
|
}
|
|
want := `github.PullStats{TotalPulls:0, MergedPulls:0, MergeablePulls:0, UnmergeablePulls:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("PullStats.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestPushEvent_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := PushEvent{
|
|
PushID: new(int64(0)),
|
|
Head: new(""),
|
|
Ref: new(""),
|
|
Size: new(0),
|
|
Before: new(""),
|
|
DistinctSize: new(0),
|
|
Action: new(""),
|
|
After: new(""),
|
|
Created: new(false),
|
|
Deleted: new(false),
|
|
Forced: new(false),
|
|
BaseRef: new(""),
|
|
Compare: new(""),
|
|
Repo: &PushEventRepository{},
|
|
HeadCommit: &HeadCommit{},
|
|
Pusher: &CommitAuthor{},
|
|
Sender: &User{},
|
|
Installation: &Installation{},
|
|
Organization: &Organization{},
|
|
}
|
|
want := `github.PushEvent{PushID:0, Head:"", Ref:"", Size:0, Before:"", DistinctSize:0, Action:"", After:"", Created:false, Deleted:false, Forced:false, BaseRef:"", Compare:"", Repo:github.PushEventRepository{}, HeadCommit:github.HeadCommit{}, Pusher:github.CommitAuthor{}, Sender:github.User{}, Installation:github.Installation{}, Organization:github.Organization{}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("PushEvent.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestRate_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Rate{
|
|
Limit: 0,
|
|
Remaining: 0,
|
|
Used: 0,
|
|
Reset: Timestamp{},
|
|
Resource: "",
|
|
}
|
|
want := `github.Rate{Limit:0, Remaining:0, Used:0, Reset:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Resource:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Rate.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestReaction_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Reaction{
|
|
ID: new(int64(0)),
|
|
User: &User{},
|
|
NodeID: new(""),
|
|
Content: new(""),
|
|
CreatedAt: &Timestamp{},
|
|
}
|
|
want := `github.Reaction{ID:0, User:github.User{}, NodeID:"", Content:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Reaction.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestReference_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Reference{
|
|
Ref: new(""),
|
|
URL: new(""),
|
|
Object: &GitObject{},
|
|
NodeID: new(""),
|
|
}
|
|
want := `github.Reference{Ref:"", URL:"", Object:github.GitObject{}, NodeID:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Reference.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestReleaseAsset_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := ReleaseAsset{
|
|
ID: new(int64(0)),
|
|
URL: new(""),
|
|
Name: new(""),
|
|
Label: new(""),
|
|
State: new(""),
|
|
ContentType: new(""),
|
|
Size: new(0),
|
|
DownloadCount: new(0),
|
|
CreatedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
BrowserDownloadURL: new(""),
|
|
Uploader: &User{},
|
|
NodeID: new(""),
|
|
Digest: new(""),
|
|
}
|
|
want := `github.ReleaseAsset{ID:0, URL:"", Name:"", Label:"", State:"", ContentType:"", Size:0, DownloadCount:0, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, BrowserDownloadURL:"", Uploader:github.User{}, NodeID:"", Digest:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("ReleaseAsset.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestRename_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Rename{
|
|
From: new(""),
|
|
To: new(""),
|
|
}
|
|
want := `github.Rename{From:"", To:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Rename.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestRepoStats_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := RepoStats{
|
|
TotalRepos: new(0),
|
|
RootRepos: new(0),
|
|
ForkRepos: new(0),
|
|
OrgRepos: new(0),
|
|
TotalPushes: new(0),
|
|
TotalWikis: new(0),
|
|
}
|
|
want := `github.RepoStats{TotalRepos:0, RootRepos:0, ForkRepos:0, OrgRepos:0, TotalPushes:0, TotalWikis:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("RepoStats.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestRepoStatus_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := RepoStatus{
|
|
ID: new(int64(0)),
|
|
NodeID: new(""),
|
|
URL: new(""),
|
|
State: new(""),
|
|
TargetURL: new(""),
|
|
Description: new(""),
|
|
Context: new(""),
|
|
AvatarURL: new(""),
|
|
Creator: &User{},
|
|
CreatedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
Required: new(false),
|
|
}
|
|
want := `github.RepoStatus{ID:0, NodeID:"", URL:"", State:"", TargetURL:"", Description:"", Context:"", AvatarURL:"", Creator:github.User{}, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Required:false}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("RepoStatus.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestRepository_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Repository{
|
|
ID: new(int64(0)),
|
|
NodeID: new(""),
|
|
Owner: &User{},
|
|
Name: new(""),
|
|
FullName: new(""),
|
|
Description: new(""),
|
|
Homepage: new(""),
|
|
CodeOfConduct: &CodeOfConduct{},
|
|
DefaultBranch: new(""),
|
|
MasterBranch: new(""),
|
|
CreatedAt: &Timestamp{},
|
|
PushedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
HTMLURL: new(""),
|
|
CloneURL: new(""),
|
|
GitURL: new(""),
|
|
MirrorURL: new(""),
|
|
SSHURL: new(""),
|
|
SVNURL: new(""),
|
|
Language: new(""),
|
|
Fork: new(false),
|
|
ForksCount: new(0),
|
|
NetworkCount: new(0),
|
|
OpenIssuesCount: new(0),
|
|
OpenIssues: new(0),
|
|
StargazersCount: new(0),
|
|
SubscribersCount: new(0),
|
|
WatchersCount: new(0),
|
|
Watchers: new(0),
|
|
Size: new(0),
|
|
AutoInit: new(false),
|
|
Parent: &Repository{},
|
|
Source: &Repository{},
|
|
TemplateRepository: &Repository{},
|
|
Organization: &Organization{},
|
|
Permissions: &RepositoryPermissions{},
|
|
AllowRebaseMerge: new(false),
|
|
AllowUpdateBranch: new(false),
|
|
AllowSquashMerge: new(false),
|
|
AllowMergeCommit: new(false),
|
|
AllowAutoMerge: new(false),
|
|
AllowForking: new(false),
|
|
WebCommitSignoffRequired: new(false),
|
|
DeleteBranchOnMerge: new(false),
|
|
UseSquashPRTitleAsDefault: new(false),
|
|
SquashMergeCommitTitle: new(""),
|
|
SquashMergeCommitMessage: new(""),
|
|
MergeCommitTitle: new(""),
|
|
MergeCommitMessage: new(""),
|
|
Topics: []string{""},
|
|
Archived: new(false),
|
|
Disabled: new(false),
|
|
License: &License{},
|
|
Private: new(false),
|
|
HasIssues: new(false),
|
|
HasWiki: new(false),
|
|
HasPages: new(false),
|
|
HasProjects: new(false),
|
|
HasDownloads: new(false),
|
|
HasDiscussions: new(false),
|
|
HasPullRequests: new(false),
|
|
PullRequestCreationPolicy: new(""),
|
|
IsTemplate: new(false),
|
|
LicenseTemplate: new(""),
|
|
GitignoreTemplate: new(""),
|
|
SecurityAndAnalysis: &SecurityAndAnalysis{},
|
|
TeamID: new(int64(0)),
|
|
URL: new(""),
|
|
ArchiveURL: new(""),
|
|
AssigneesURL: new(""),
|
|
BlobsURL: new(""),
|
|
BranchesURL: new(""),
|
|
CollaboratorsURL: new(""),
|
|
CommentsURL: new(""),
|
|
CommitsURL: new(""),
|
|
CompareURL: new(""),
|
|
ContentsURL: new(""),
|
|
ContributorsURL: new(""),
|
|
DeploymentsURL: new(""),
|
|
DownloadsURL: new(""),
|
|
EventsURL: new(""),
|
|
ForksURL: new(""),
|
|
GitCommitsURL: new(""),
|
|
GitRefsURL: new(""),
|
|
GitTagsURL: new(""),
|
|
HooksURL: new(""),
|
|
IssueCommentURL: new(""),
|
|
IssueEventsURL: new(""),
|
|
IssuesURL: new(""),
|
|
KeysURL: new(""),
|
|
LabelsURL: new(""),
|
|
LanguagesURL: new(""),
|
|
MergesURL: new(""),
|
|
MilestonesURL: new(""),
|
|
NotificationsURL: new(""),
|
|
PullsURL: new(""),
|
|
ReleasesURL: new(""),
|
|
StargazersURL: new(""),
|
|
StatusesURL: new(""),
|
|
SubscribersURL: new(""),
|
|
SubscriptionURL: new(""),
|
|
TagsURL: new(""),
|
|
TreesURL: new(""),
|
|
TeamsURL: new(""),
|
|
Visibility: new(""),
|
|
RoleName: new(""),
|
|
}
|
|
want := `github.Repository{ID:0, NodeID:"", Owner:github.User{}, Name:"", FullName:"", Description:"", Homepage:"", CodeOfConduct:github.CodeOfConduct{}, DefaultBranch:"", MasterBranch:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, PushedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, HTMLURL:"", CloneURL:"", GitURL:"", MirrorURL:"", SSHURL:"", SVNURL:"", Language:"", Fork:false, ForksCount:0, NetworkCount:0, OpenIssuesCount:0, OpenIssues:0, StargazersCount:0, SubscribersCount:0, WatchersCount:0, Watchers:0, Size:0, AutoInit:false, Parent:github.Repository{}, Source:github.Repository{}, TemplateRepository:github.Repository{}, Organization:github.Organization{}, Permissions:github.RepositoryPermissions{}, AllowRebaseMerge:false, AllowUpdateBranch:false, AllowSquashMerge:false, AllowMergeCommit:false, AllowAutoMerge:false, AllowForking:false, WebCommitSignoffRequired:false, DeleteBranchOnMerge:false, UseSquashPRTitleAsDefault:false, SquashMergeCommitTitle:"", SquashMergeCommitMessage:"", MergeCommitTitle:"", MergeCommitMessage:"", Topics:[""], Archived:false, Disabled:false, License:github.License{}, Private:false, HasIssues:false, HasWiki:false, HasPages:false, HasProjects:false, HasDownloads:false, HasDiscussions:false, HasPullRequests:false, PullRequestCreationPolicy:"", IsTemplate:false, LicenseTemplate:"", GitignoreTemplate:"", SecurityAndAnalysis:github.SecurityAndAnalysis{}, TeamID:0, URL:"", ArchiveURL:"", AssigneesURL:"", BlobsURL:"", BranchesURL:"", CollaboratorsURL:"", CommentsURL:"", CommitsURL:"", CompareURL:"", ContentsURL:"", ContributorsURL:"", DeploymentsURL:"", DownloadsURL:"", EventsURL:"", ForksURL:"", GitCommitsURL:"", GitRefsURL:"", GitTagsURL:"", HooksURL:"", IssueCommentURL:"", IssueEventsURL:"", IssuesURL:"", KeysURL:"", LabelsURL:"", LanguagesURL:"", MergesURL:"", MilestonesURL:"", NotificationsURL:"", PullsURL:"", ReleasesURL:"", StargazersURL:"", StatusesURL:"", SubscribersURL:"", SubscriptionURL:"", TagsURL:"", TreesURL:"", TeamsURL:"", Visibility:"", RoleName:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Repository.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestRepositoryComment_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := RepositoryComment{
|
|
HTMLURL: new(""),
|
|
URL: new(""),
|
|
ID: new(int64(0)),
|
|
NodeID: new(""),
|
|
CommitID: new(""),
|
|
User: &User{},
|
|
AuthorAssociation: new(""),
|
|
Reactions: &Reactions{},
|
|
CreatedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
Body: new(""),
|
|
Path: new(""),
|
|
Position: new(0),
|
|
Line: new(0),
|
|
}
|
|
want := `github.RepositoryComment{HTMLURL:"", URL:"", ID:0, NodeID:"", CommitID:"", User:github.User{}, AuthorAssociation:"", Reactions:github.Reactions{}, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Body:"", Path:"", Position:0, Line:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("RepositoryComment.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestRepositoryCommit_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := RepositoryCommit{
|
|
NodeID: new(""),
|
|
SHA: new(""),
|
|
Commit: &Commit{},
|
|
Author: &User{},
|
|
Committer: &User{},
|
|
HTMLURL: new(""),
|
|
URL: new(""),
|
|
CommentsURL: new(""),
|
|
Stats: &CommitStats{},
|
|
}
|
|
want := `github.RepositoryCommit{NodeID:"", SHA:"", Commit:github.Commit{}, Author:github.User{}, Committer:github.User{}, HTMLURL:"", URL:"", CommentsURL:"", Stats:github.CommitStats{}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("RepositoryCommit.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestRepositoryContent_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := RepositoryContent{
|
|
Type: new(""),
|
|
Target: new(""),
|
|
Encoding: new(""),
|
|
Size: new(0),
|
|
Name: new(""),
|
|
Path: new(""),
|
|
Content: new(""),
|
|
SHA: new(""),
|
|
URL: new(""),
|
|
GitURL: new(""),
|
|
HTMLURL: new(""),
|
|
DownloadURL: new(""),
|
|
SubmoduleGitURL: new(""),
|
|
}
|
|
want := `github.RepositoryContent{Type:"", Target:"", Encoding:"", Size:0, Name:"", Path:"", Content:"", SHA:"", URL:"", GitURL:"", HTMLURL:"", DownloadURL:"", SubmoduleGitURL:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("RepositoryContent.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestRepositoryLicense_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := RepositoryLicense{
|
|
Name: new(""),
|
|
Path: new(""),
|
|
SHA: new(""),
|
|
Size: new(0),
|
|
URL: new(""),
|
|
HTMLURL: new(""),
|
|
GitURL: new(""),
|
|
DownloadURL: new(""),
|
|
Type: new(""),
|
|
Content: new(""),
|
|
Encoding: new(""),
|
|
License: &License{},
|
|
}
|
|
want := `github.RepositoryLicense{Name:"", Path:"", SHA:"", Size:0, URL:"", HTMLURL:"", GitURL:"", DownloadURL:"", Type:"", Content:"", Encoding:"", License:github.License{}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("RepositoryLicense.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestRepositoryParticipation_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := RepositoryParticipation{
|
|
All: []int{0},
|
|
Owner: []int{0},
|
|
}
|
|
want := `github.RepositoryParticipation{All:[0], Owner:[0]}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("RepositoryParticipation.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestRepositoryRelease_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := RepositoryRelease{
|
|
TagName: "",
|
|
TargetCommitish: "",
|
|
Name: new(""),
|
|
Body: new(""),
|
|
Draft: false,
|
|
Prerelease: false,
|
|
Immutable: new(false),
|
|
ID: 0,
|
|
CreatedAt: Timestamp{},
|
|
PublishedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
URL: "",
|
|
HTMLURL: "",
|
|
AssetsURL: "",
|
|
UploadURL: "",
|
|
ZipballURL: new(""),
|
|
TarballURL: new(""),
|
|
Author: &User{},
|
|
NodeID: "",
|
|
BodyHTML: new(""),
|
|
BodyText: new(""),
|
|
MentionsCount: new(0),
|
|
DiscussionURL: new(""),
|
|
Reactions: &Reactions{},
|
|
}
|
|
want := `github.RepositoryRelease{TagName:"", TargetCommitish:"", Name:"", Body:"", Draft:false, Prerelease:false, Immutable:false, ID:0, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, PublishedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, URL:"", HTMLURL:"", AssetsURL:"", UploadURL:"", ZipballURL:"", TarballURL:"", Author:github.User{}, NodeID:"", BodyHTML:"", BodyText:"", MentionsCount:0, DiscussionURL:"", Reactions:github.Reactions{}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("RepositoryRelease.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestSBOM_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := SBOM{
|
|
SBOM: &SBOMInfo{},
|
|
}
|
|
want := `github.SBOM{SBOM:github.SBOMInfo{}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("SBOM.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestSSHSigningKey_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := SSHSigningKey{
|
|
ID: new(int64(0)),
|
|
Key: new(""),
|
|
Title: new(""),
|
|
CreatedAt: &Timestamp{},
|
|
}
|
|
want := `github.SSHSigningKey{ID:0, Key:"", Title:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("SSHSigningKey.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestSecretScanning_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := SecretScanning{
|
|
Status: new(""),
|
|
}
|
|
want := `github.SecretScanning{Status:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("SecretScanning.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestSecretScanningPushProtection_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := SecretScanningPushProtection{
|
|
Status: new(""),
|
|
}
|
|
want := `github.SecretScanningPushProtection{Status:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("SecretScanningPushProtection.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestSecurityAndAnalysis_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := SecurityAndAnalysis{
|
|
AdvancedSecurity: &AdvancedSecurity{},
|
|
SecretScanning: &SecretScanning{},
|
|
SecretScanningPushProtection: &SecretScanningPushProtection{},
|
|
DependabotSecurityUpdates: &DependabotSecurityUpdates{},
|
|
SecretScanningValidityChecks: &SecretScanningValidityChecks{},
|
|
CodeSecurity: &CodeSecurity{},
|
|
}
|
|
want := `github.SecurityAndAnalysis{AdvancedSecurity:github.AdvancedSecurity{}, SecretScanning:github.SecretScanning{}, SecretScanningPushProtection:github.SecretScanningPushProtection{}, DependabotSecurityUpdates:github.DependabotSecurityUpdates{}, SecretScanningValidityChecks:github.SecretScanningValidityChecks{}, CodeSecurity:github.CodeSecurity{}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("SecurityAndAnalysis.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestSelfHostRunnerPermissionsEnterprise_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := SelfHostRunnerPermissionsEnterprise{
|
|
DisableSelfHostedRunnersForAllOrgs: false,
|
|
}
|
|
want := `github.SelfHostRunnerPermissionsEnterprise{DisableSelfHostedRunnersForAllOrgs:false}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("SelfHostRunnerPermissionsEnterprise.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestSelfHostedRunnersSettingsOrganization_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := SelfHostedRunnersSettingsOrganization{
|
|
EnabledRepositories: new(""),
|
|
SelectedRepositoriesURL: new(""),
|
|
}
|
|
want := `github.SelfHostedRunnersSettingsOrganization{EnabledRepositories:"", SelectedRepositoriesURL:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("SelfHostedRunnersSettingsOrganization.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestSourceImportAuthor_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := SourceImportAuthor{
|
|
ID: new(int64(0)),
|
|
RemoteID: new(""),
|
|
RemoteName: new(""),
|
|
Email: new(""),
|
|
Name: new(""),
|
|
URL: new(""),
|
|
ImportURL: new(""),
|
|
}
|
|
want := `github.SourceImportAuthor{ID:0, RemoteID:"", RemoteName:"", Email:"", Name:"", URL:"", ImportURL:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("SourceImportAuthor.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestTeam_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Team{
|
|
ID: new(int64(0)),
|
|
NodeID: new(""),
|
|
Name: new(""),
|
|
Description: new(""),
|
|
URL: new(""),
|
|
Slug: new(""),
|
|
Permission: new(""),
|
|
Privacy: new(""),
|
|
NotificationSetting: new(""),
|
|
MembersCount: new(0),
|
|
ReposCount: new(0),
|
|
Organization: &Organization{},
|
|
HTMLURL: new(""),
|
|
MembersURL: new(""),
|
|
RepositoriesURL: new(""),
|
|
Parent: &Team{},
|
|
LDAPDN: new(""),
|
|
Assignment: new(""),
|
|
Type: new(""),
|
|
AccessSource: new(""),
|
|
}
|
|
want := `github.Team{ID:0, NodeID:"", Name:"", Description:"", URL:"", Slug:"", Permission:"", Privacy:"", NotificationSetting:"", MembersCount:0, ReposCount:0, Organization:github.Organization{}, HTMLURL:"", MembersURL:"", RepositoriesURL:"", Parent:github.Team{}, LDAPDN:"", Assignment:"", Type:"", AccessSource:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Team.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestTeamDiscussion_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := TeamDiscussion{
|
|
Author: &User{},
|
|
Body: new(""),
|
|
BodyHTML: new(""),
|
|
BodyVersion: new(""),
|
|
CommentsCount: new(0),
|
|
CommentsURL: new(""),
|
|
CreatedAt: &Timestamp{},
|
|
LastEditedAt: &Timestamp{},
|
|
HTMLURL: new(""),
|
|
NodeID: new(""),
|
|
Number: new(0),
|
|
Pinned: new(false),
|
|
Private: new(false),
|
|
TeamURL: new(""),
|
|
Title: new(""),
|
|
UpdatedAt: &Timestamp{},
|
|
URL: new(""),
|
|
Reactions: &Reactions{},
|
|
}
|
|
want := `github.TeamDiscussion{Author:github.User{}, Body:"", BodyHTML:"", BodyVersion:"", CommentsCount:0, CommentsURL:"", CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, LastEditedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, HTMLURL:"", NodeID:"", Number:0, Pinned:false, Private:false, TeamURL:"", Title:"", UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, URL:"", Reactions:github.Reactions{}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("TeamDiscussion.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestTeamLDAPMapping_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := TeamLDAPMapping{
|
|
ID: new(int64(0)),
|
|
LDAPDN: new(""),
|
|
URL: new(""),
|
|
Name: new(""),
|
|
Slug: new(""),
|
|
Description: new(""),
|
|
Privacy: new(""),
|
|
Permission: new(""),
|
|
MembersURL: new(""),
|
|
RepositoriesURL: new(""),
|
|
}
|
|
want := `github.TeamLDAPMapping{ID:0, LDAPDN:"", URL:"", Name:"", Slug:"", Description:"", Privacy:"", Permission:"", MembersURL:"", RepositoriesURL:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("TeamLDAPMapping.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestTextMatch_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := TextMatch{
|
|
ObjectURL: new(""),
|
|
ObjectType: new(""),
|
|
Property: new(""),
|
|
Fragment: new(""),
|
|
}
|
|
want := `github.TextMatch{ObjectURL:"", ObjectType:"", Property:"", Fragment:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("TextMatch.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestTree_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := Tree{
|
|
SHA: new(""),
|
|
Truncated: new(false),
|
|
}
|
|
want := `github.Tree{SHA:"", Truncated:false}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("Tree.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestTreeEntry_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := TreeEntry{
|
|
SHA: new(""),
|
|
Path: new(""),
|
|
Mode: new(""),
|
|
Type: new(""),
|
|
Size: new(0),
|
|
Content: new(""),
|
|
URL: new(""),
|
|
}
|
|
want := `github.TreeEntry{SHA:"", Path:"", Mode:"", Type:"", Size:0, Content:"", URL:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("TreeEntry.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestUpdateTeamRequest_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := UpdateTeamRequest{
|
|
Name: new(""),
|
|
Description: new(""),
|
|
Privacy: new(""),
|
|
NotificationSetting: new(""),
|
|
Permission: new(""),
|
|
ParentTeamID: new(int64(0)),
|
|
ParentTeamSlug: new(""),
|
|
RemoveParentTeam: false,
|
|
}
|
|
want := `github.UpdateTeamRequest{Name:"", Description:"", Privacy:"", NotificationSetting:"", Permission:"", ParentTeamID:0, ParentTeamSlug:"", RemoveParentTeam:false}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("UpdateTeamRequest.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestUser_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := User{
|
|
Login: new(""),
|
|
ID: new(int64(0)),
|
|
UserViewType: new(""),
|
|
NodeID: new(""),
|
|
AvatarURL: new(""),
|
|
HTMLURL: new(""),
|
|
GravatarID: new(""),
|
|
Name: new(""),
|
|
Company: new(""),
|
|
Blog: new(""),
|
|
Location: new(""),
|
|
Email: new(""),
|
|
NotificationEmail: new(""),
|
|
Hireable: new(false),
|
|
Bio: new(""),
|
|
TwitterUsername: new(""),
|
|
PublicRepos: new(0),
|
|
PublicGists: new(0),
|
|
Followers: new(0),
|
|
Following: new(0),
|
|
CreatedAt: &Timestamp{},
|
|
UpdatedAt: &Timestamp{},
|
|
SuspendedAt: &Timestamp{},
|
|
Type: new(""),
|
|
SiteAdmin: new(false),
|
|
TotalPrivateRepos: new(int64(0)),
|
|
OwnedPrivateRepos: new(int64(0)),
|
|
PrivateGists: new(0),
|
|
DiskUsage: new(0),
|
|
Collaborators: new(0),
|
|
TwoFactorAuthentication: new(false),
|
|
Plan: &Plan{},
|
|
BusinessPlus: new(false),
|
|
LdapDn: new(""),
|
|
URL: new(""),
|
|
EventsURL: new(""),
|
|
FollowingURL: new(""),
|
|
FollowersURL: new(""),
|
|
GistsURL: new(""),
|
|
OrganizationsURL: new(""),
|
|
ReceivedEventsURL: new(""),
|
|
ReposURL: new(""),
|
|
StarredURL: new(""),
|
|
SubscriptionsURL: new(""),
|
|
Permissions: &RepositoryPermissions{},
|
|
RoleName: new(""),
|
|
Assignment: new(""),
|
|
Role: new(""),
|
|
Inherited: new(false),
|
|
}
|
|
want := `github.User{Login:"", ID:0, UserViewType:"", NodeID:"", AvatarURL:"", HTMLURL:"", GravatarID:"", Name:"", Company:"", Blog:"", Location:"", Email:"", NotificationEmail:"", Hireable:false, Bio:"", TwitterUsername:"", PublicRepos:0, PublicGists:0, Followers:0, Following:0, CreatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, UpdatedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, SuspendedAt:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Type:"", SiteAdmin:false, TotalPrivateRepos:0, OwnedPrivateRepos:0, PrivateGists:0, DiskUsage:0, Collaborators:0, TwoFactorAuthentication:false, Plan:github.Plan{}, BusinessPlus:false, LdapDn:"", URL:"", EventsURL:"", FollowingURL:"", FollowersURL:"", GistsURL:"", OrganizationsURL:"", ReceivedEventsURL:"", ReposURL:"", StarredURL:"", SubscriptionsURL:"", Permissions:github.RepositoryPermissions{}, RoleName:"", Assignment:"", Role:"", Inherited:false}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("User.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestUserLDAPMapping_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := UserLDAPMapping{
|
|
ID: new(int64(0)),
|
|
LDAPDN: new(""),
|
|
Login: new(""),
|
|
AvatarURL: new(""),
|
|
GravatarID: new(""),
|
|
Type: new(""),
|
|
SiteAdmin: new(false),
|
|
URL: new(""),
|
|
EventsURL: new(""),
|
|
FollowingURL: new(""),
|
|
FollowersURL: new(""),
|
|
GistsURL: new(""),
|
|
OrganizationsURL: new(""),
|
|
ReceivedEventsURL: new(""),
|
|
ReposURL: new(""),
|
|
StarredURL: new(""),
|
|
SubscriptionsURL: new(""),
|
|
}
|
|
want := `github.UserLDAPMapping{ID:0, LDAPDN:"", Login:"", AvatarURL:"", GravatarID:"", Type:"", SiteAdmin:false, URL:"", EventsURL:"", FollowingURL:"", FollowersURL:"", GistsURL:"", OrganizationsURL:"", ReceivedEventsURL:"", ReposURL:"", StarredURL:"", SubscriptionsURL:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("UserLDAPMapping.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestUserMigration_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := UserMigration{
|
|
ID: new(int64(0)),
|
|
GUID: new(""),
|
|
State: new(""),
|
|
LockRepositories: new(false),
|
|
ExcludeAttachments: new(false),
|
|
URL: new(""),
|
|
CreatedAt: new(""),
|
|
UpdatedAt: new(""),
|
|
}
|
|
want := `github.UserMigration{ID:0, GUID:"", State:"", LockRepositories:false, ExcludeAttachments:false, URL:"", CreatedAt:"", UpdatedAt:""}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("UserMigration.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestUserStats_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := UserStats{
|
|
TotalUsers: new(0),
|
|
AdminUsers: new(0),
|
|
SuspendedUsers: new(0),
|
|
}
|
|
want := `github.UserStats{TotalUsers:0, AdminUsers:0, SuspendedUsers:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("UserStats.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestWeeklyCommitActivity_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := WeeklyCommitActivity{
|
|
Days: []int{0},
|
|
Total: new(0),
|
|
Week: &Timestamp{},
|
|
}
|
|
want := `github.WeeklyCommitActivity{Days:[0], Total:0, Week:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("WeeklyCommitActivity.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestWeeklyStats_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := WeeklyStats{
|
|
Week: &Timestamp{},
|
|
Additions: new(0),
|
|
Deletions: new(0),
|
|
Commits: new(0),
|
|
}
|
|
want := `github.WeeklyStats{Week:github.Timestamp{0001-01-01 00:00:00 +0000 UTC}, Additions:0, Deletions:0, Commits:0}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("WeeklyStats.String = %v, want %v", got, want)
|
|
}
|
|
}
|
|
|
|
func TestWorkflowsPermissions_String(t *testing.T) {
|
|
t.Parallel()
|
|
v := WorkflowsPermissions{
|
|
RunWorkflowsFromForkPullRequests: new(false),
|
|
SendWriteTokensToWorkflows: new(false),
|
|
SendSecretsAndVariables: new(false),
|
|
RequireApprovalForForkPRWorkflows: new(false),
|
|
}
|
|
want := `github.WorkflowsPermissions{RunWorkflowsFromForkPullRequests:false, SendWriteTokensToWorkflows:false, SendSecretsAndVariables:false, RequireApprovalForForkPRWorkflows:false}`
|
|
if got := v.String(); got != want {
|
|
t.Errorf("WorkflowsPermissions.String = %v, want %v", got, want)
|
|
}
|
|
}
|