mirrors/go-github
0
0 Fork 0
mirror of https://github.com/google/go-github.git synced 2026-10-28 16:34:37 +08:00
Code Activity
Files
9a9d77c0070cd9bbe101012236c835bc8b760d6e
go-github/github/github-stringify_test.go
T

2612 lines
93 KiB
Go
Raw Blame History

// 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 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)
}
}
View Git Blame Copy Permalink