github.com/google/go-github/v69@v69.2.0/github/strings_test.go (about)

     1  // Copyright 2013 The go-github AUTHORS. All rights reserved.
     2  //
     3  // Use of this source code is governed by a BSD-style
     4  // license that can be found in the LICENSE file.
     5  
     6  package github
     7  
     8  import (
     9  	"fmt"
    10  	"testing"
    11  	"time"
    12  )
    13  
    14  func TestStringify(t *testing.T) {
    15  	t.Parallel()
    16  	var nilPointer *string
    17  
    18  	var tests = []struct {
    19  		in  interface{}
    20  		out string
    21  	}{
    22  		// basic types
    23  		{"foo", `"foo"`},
    24  		{123, `123`},
    25  		{1.5, `1.5`},
    26  		{false, `false`},
    27  		{
    28  			[]string{"a", "b"},
    29  			`["a" "b"]`,
    30  		},
    31  		{
    32  			struct {
    33  				A []string
    34  			}{nil},
    35  			// nil slice is skipped
    36  			`{}`,
    37  		},
    38  		{
    39  			struct {
    40  				A string
    41  			}{"foo"},
    42  			// structs not of a named type get no prefix
    43  			`{A:"foo"}`,
    44  		},
    45  
    46  		// pointers
    47  		{nilPointer, `<nil>`},
    48  		{Ptr("foo"), `"foo"`},
    49  		{Ptr(123), `123`},
    50  		{Ptr(false), `false`},
    51  		{
    52  			//nolint:sliceofpointers
    53  			[]*string{Ptr("a"), Ptr("b")},
    54  			`["a" "b"]`,
    55  		},
    56  
    57  		// actual GitHub structs
    58  		{
    59  			Timestamp{time.Date(2006, time.January, 02, 15, 04, 05, 0, time.UTC)},
    60  			`github.Timestamp{2006-01-02 15:04:05 +0000 UTC}`,
    61  		},
    62  		{
    63  			&Timestamp{time.Date(2006, time.January, 02, 15, 04, 05, 0, time.UTC)},
    64  			`github.Timestamp{2006-01-02 15:04:05 +0000 UTC}`,
    65  		},
    66  		{
    67  			User{ID: Ptr(int64(123)), Name: Ptr("n")},
    68  			`github.User{ID:123, Name:"n"}`,
    69  		},
    70  		{
    71  			Repository{Owner: &User{ID: Ptr(int64(123))}},
    72  			`github.Repository{Owner:github.User{ID:123}}`,
    73  		},
    74  	}
    75  
    76  	for i, tt := range tests {
    77  		s := Stringify(tt.in)
    78  		if s != tt.out {
    79  			t.Errorf("%d. Stringify(%q) => %q, want %q", i, tt.in, s, tt.out)
    80  		}
    81  	}
    82  }
    83  
    84  // Directly test the String() methods on various GitHub types. We don't do an
    85  // exhaustive test of all the various field types, since TestStringify() above
    86  // takes care of that. Rather, we just make sure that Stringify() is being
    87  // used to build the strings, which we do by verifying that pointers are
    88  // stringified as their underlying value.
    89  func TestString(t *testing.T) {
    90  	t.Parallel()
    91  	var tests = []struct {
    92  		in  interface{}
    93  		out string
    94  	}{
    95  		{CodeResult{Name: Ptr("n")}, `github.CodeResult{Name:"n"}`},
    96  		{CommitAuthor{Name: Ptr("n")}, `github.CommitAuthor{Name:"n"}`},
    97  		{CommitFile{SHA: Ptr("s")}, `github.CommitFile{SHA:"s"}`},
    98  		{CommitStats{Total: Ptr(1)}, `github.CommitStats{Total:1}`},
    99  		{CommitsComparison{TotalCommits: Ptr(1)}, `github.CommitsComparison{TotalCommits:1}`},
   100  		{Commit{SHA: Ptr("s")}, `github.Commit{SHA:"s"}`},
   101  		{Event{ID: Ptr("1")}, `github.Event{ID:"1"}`},
   102  		{GistComment{ID: Ptr(int64(1))}, `github.GistComment{ID:1}`},
   103  		{GistFile{Size: Ptr(1)}, `github.GistFile{Size:1}`},
   104  		{Gist{ID: Ptr("1")}, `github.Gist{ID:"1"}`},
   105  		{GitObject{SHA: Ptr("s")}, `github.GitObject{SHA:"s"}`},
   106  		{Gitignore{Name: Ptr("n")}, `github.Gitignore{Name:"n"}`},
   107  		{Hook{ID: Ptr(int64(1))}, `github.Hook{ID:1}`},
   108  		{IssueComment{ID: Ptr(int64(1))}, `github.IssueComment{ID:1}`},
   109  		{Issue{Number: Ptr(1)}, `github.Issue{Number:1}`},
   110  		{Key{ID: Ptr(int64(1))}, `github.Key{ID:1}`},
   111  		{Label{ID: Ptr(int64(1)), Name: Ptr("l")}, `github.Label{ID:1, Name:"l"}`},
   112  		{Organization{ID: Ptr(int64(1))}, `github.Organization{ID:1}`},
   113  		{PullRequestComment{ID: Ptr(int64(1))}, `github.PullRequestComment{ID:1}`},
   114  		{PullRequest{Number: Ptr(1)}, `github.PullRequest{Number:1}`},
   115  		{PullRequestReview{ID: Ptr(int64(1))}, `github.PullRequestReview{ID:1}`},
   116  		{DraftReviewComment{Position: Ptr(1)}, `github.DraftReviewComment{Position:1}`},
   117  		{PullRequestReviewRequest{Body: Ptr("r")}, `github.PullRequestReviewRequest{Body:"r"}`},
   118  		{PullRequestReviewDismissalRequest{Message: Ptr("r")}, `github.PullRequestReviewDismissalRequest{Message:"r"}`},
   119  		{HeadCommit{SHA: Ptr("s")}, `github.HeadCommit{SHA:"s"}`},
   120  		{PushEvent{PushID: Ptr(int64(1))}, `github.PushEvent{PushID:1}`},
   121  		{Reference{Ref: Ptr("r")}, `github.Reference{Ref:"r"}`},
   122  		{ReleaseAsset{ID: Ptr(int64(1))}, `github.ReleaseAsset{ID:1}`},
   123  		{RepoStatus{ID: Ptr(int64(1))}, `github.RepoStatus{ID:1}`},
   124  		{RepositoryComment{ID: Ptr(int64(1))}, `github.RepositoryComment{ID:1}`},
   125  		{RepositoryCommit{SHA: Ptr("s")}, `github.RepositoryCommit{SHA:"s"}`},
   126  		{RepositoryContent{Name: Ptr("n")}, `github.RepositoryContent{Name:"n"}`},
   127  		{RepositoryRelease{ID: Ptr(int64(1))}, `github.RepositoryRelease{ID:1}`},
   128  		{Repository{ID: Ptr(int64(1))}, `github.Repository{ID:1}`},
   129  		{Team{ID: Ptr(int64(1))}, `github.Team{ID:1}`},
   130  		{TreeEntry{SHA: Ptr("s")}, `github.TreeEntry{SHA:"s"}`},
   131  		{Tree{SHA: Ptr("s")}, `github.Tree{SHA:"s"}`},
   132  		{User{ID: Ptr(int64(1))}, `github.User{ID:1}`},
   133  		{WebHookAuthor{Name: Ptr("n")}, `github.CommitAuthor{Name:"n"}`},
   134  		{WebHookCommit{ID: Ptr("1")}, `github.HeadCommit{ID:"1"}`},
   135  		{WebHookPayload{Ref: Ptr("r")}, `github.PushEvent{Ref:"r"}`},
   136  	}
   137  
   138  	for i, tt := range tests {
   139  		s := tt.in.(fmt.Stringer).String()
   140  		if s != tt.out {
   141  			t.Errorf("%d. String() => %q, want %q", i, tt.in, tt.out)
   142  		}
   143  	}
   144  }