example_gh_test.go

Documentation: github.com/cli/go-gh/v2

     1  package gh_test
     2  
     3  import (
     4  	"encoding/json"
     5  	"fmt"
     6  	"io"
     7  	"log"
     8  	"net/http"
     9  	"os"
    10  	"regexp"
    11  	"time"
    12  
    13  	gh "github.com/cli/go-gh/v2"
    14  	"github.com/cli/go-gh/v2/pkg/api"
    15  	"github.com/cli/go-gh/v2/pkg/repository"
    16  	"github.com/cli/go-gh/v2/pkg/tableprinter"
    17  	"github.com/cli/go-gh/v2/pkg/term"
    18  	graphql "github.com/cli/shurcooL-graphql"
    19  )
    20  
    21  // Execute 'gh issue list -R cli/cli', and print the output.
    22  func ExampleExec() {
    23  	args := []string{"issue", "list", "-R", "cli/cli"}
    24  	stdOut, stdErr, err := gh.Exec(args...)
    25  	if err != nil {
    26  		log.Fatal(err)
    27  	}
    28  	fmt.Println(stdOut.String())
    29  	fmt.Println(stdErr.String())
    30  }
    31  
    32  // Get tags from cli/cli repository using REST API.
    33  func ExampleDefaultRESTClient() {
    34  	client, err := api.DefaultRESTClient()
    35  	if err != nil {
    36  		log.Fatal(err)
    37  	}
    38  	response := []struct{ Name string }{}
    39  	err = client.Get("repos/cli/cli/tags", &response)
    40  	if err != nil {
    41  		log.Fatal(err)
    42  	}
    43  	fmt.Println(response)
    44  }
    45  
    46  // Get tags from cli/cli repository using REST API.
    47  // Specifying host, auth token, headers and logging to stdout.
    48  func ExampleRESTClient() {
    49  	opts := api.ClientOptions{
    50  		Host:      "github.com",
    51  		AuthToken: "xxxxxxxxxx", // Replace with valid auth token.
    52  		Headers:   map[string]string{"Time-Zone": "America/Los_Angeles"},
    53  		Log:       os.Stdout,
    54  	}
    55  	client, err := api.NewRESTClient(opts)
    56  	if err != nil {
    57  		log.Fatal(err)
    58  	}
    59  	response := []struct{ Name string }{}
    60  	err = client.Get("repos/cli/cli/tags", &response)
    61  	if err != nil {
    62  		log.Fatal(err)
    63  	}
    64  	fmt.Println(response)
    65  }
    66  
    67  // Get release asset from cli/cli repository using REST API.
    68  func ExampleRESTClient_request() {
    69  	opts := api.ClientOptions{
    70  		Headers: map[string]string{"Accept": "application/octet-stream"},
    71  	}
    72  	client, err := api.NewRESTClient(opts)
    73  	if err != nil {
    74  		log.Fatal(err)
    75  	}
    76  	// URL to cli/cli release v2.14.2 checksums.txt
    77  	assetURL := "repos/cli/cli/releases/assets/71589494"
    78  	response, err := client.Request(http.MethodGet, assetURL, nil)
    79  	if err != nil {
    80  		log.Fatal(err)
    81  	}
    82  	defer response.Body.Close()
    83  	f, err := os.CreateTemp("", "*_checksums.txt")
    84  	if err != nil {
    85  		log.Fatal(err)
    86  	}
    87  	defer f.Close()
    88  	_, err = io.Copy(f, response.Body)
    89  	if err != nil {
    90  		log.Fatal(err)
    91  	}
    92  	fmt.Printf("Asset downloaded to %s\n", f.Name())
    93  }
    94  
    95  // Get releases from cli/cli repository using REST API with paginated results.
    96  func ExampleRESTClient_pagination() {
    97  	var linkRE = regexp.MustCompile(`<([^>]+)>;\s*rel="([^"]+)"`)
    98  	findNextPage := func(response *http.Response) (string, bool) {
    99  		for _, m := range linkRE.FindAllStringSubmatch(response.Header.Get("Link"), -1) {
   100  			if len(m) > 2 && m[2] == "next" {
   101  				return m[1], true
   102  			}
   103  		}
   104  		return "", false
   105  	}
   106  	client, err := api.DefaultRESTClient()
   107  	if err != nil {
   108  		log.Fatal(err)
   109  	}
   110  	requestPath := "repos/cli/cli/releases"
   111  	page := 1
   112  	for {
   113  		response, err := client.Request(http.MethodGet, requestPath, nil)
   114  		if err != nil {
   115  			log.Fatal(err)
   116  		}
   117  		data := []struct{ Name string }{}
   118  		decoder := json.NewDecoder(response.Body)
   119  		err = decoder.Decode(&data)
   120  		if err != nil {
   121  			log.Fatal(err)
   122  		}
   123  		if err := response.Body.Close(); err != nil {
   124  			log.Fatal(err)
   125  		}
   126  		fmt.Printf("Page: %d\n", page)
   127  		fmt.Println(data)
   128  		var hasNextPage bool
   129  		if requestPath, hasNextPage = findNextPage(response); !hasNextPage {
   130  			break
   131  		}
   132  		page++
   133  	}
   134  }
   135  
   136  // Query tags from cli/cli repository using GraphQL API.
   137  func ExampleDefaultGraphQLClient() {
   138  	client, err := api.DefaultGraphQLClient()
   139  	if err != nil {
   140  		log.Fatal(err)
   141  	}
   142  	var query struct {
   143  		Repository struct {
   144  			Refs struct {
   145  				Nodes []struct {
   146  					Name string
   147  				}
   148  			} `graphql:"refs(refPrefix: $refPrefix, last: $last)"`
   149  		} `graphql:"repository(owner: $owner, name: $name)"`
   150  	}
   151  	variables := map[string]interface{}{
   152  		"refPrefix": graphql.String("refs/tags/"),
   153  		"last":      graphql.Int(30),
   154  		"owner":     graphql.String("cli"),
   155  		"name":      graphql.String("cli"),
   156  	}
   157  	err = client.Query("RepositoryTags", &query, variables)
   158  	if err != nil {
   159  		log.Fatal(err)
   160  	}
   161  	fmt.Println(query)
   162  }
   163  
   164  // Query tags from cli/cli repository using GraphQL API.
   165  // Enable caching and request timeout.
   166  func ExampleGraphQLClient() {
   167  	opts := api.ClientOptions{
   168  		EnableCache: true,
   169  		Timeout:     5 * time.Second,
   170  	}
   171  	client, err := api.NewGraphQLClient(opts)
   172  	if err != nil {
   173  		log.Fatal(err)
   174  	}
   175  	var query struct {
   176  		Repository struct {
   177  			Refs struct {
   178  				Nodes []struct {
   179  					Name string
   180  				}
   181  			} `graphql:"refs(refPrefix: $refPrefix, last: $last)"`
   182  		} `graphql:"repository(owner: $owner, name: $name)"`
   183  	}
   184  	variables := map[string]interface{}{
   185  		"refPrefix": graphql.String("refs/tags/"),
   186  		"last":      graphql.Int(30),
   187  		"owner":     graphql.String("cli"),
   188  		"name":      graphql.String("cli"),
   189  	}
   190  	err = client.Query("RepositoryTags", &query, variables)
   191  	if err != nil {
   192  		log.Fatal(err)
   193  	}
   194  	fmt.Println(query)
   195  }
   196  
   197  // Add a star to the cli/go-gh repository using the GraphQL API.
   198  func ExampleGraphQLClient_mutate() {
   199  	client, err := api.DefaultGraphQLClient()
   200  	if err != nil {
   201  		log.Fatal(err)
   202  	}
   203  	var mutation struct {
   204  		AddStar struct {
   205  			Starrable struct {
   206  				Repository struct {
   207  					StargazerCount int
   208  				} `graphql:"... on Repository"`
   209  				Gist struct {
   210  					StargazerCount int
   211  				} `graphql:"... on Gist"`
   212  			}
   213  		} `graphql:"addStar(input: $input)"`
   214  	}
   215  	// Note that the shurcooL/githubv4 package has defined input structs generated from the
   216  	// GraphQL schema that can be used instead of writing your own.
   217  	type AddStarInput struct {
   218  		StarrableID string `json:"starrableId"`
   219  	}
   220  	variables := map[string]interface{}{
   221  		"input": AddStarInput{
   222  			StarrableID: "R_kgDOF_MgQQ",
   223  		},
   224  	}
   225  	err = client.Mutate("AddStar", &mutation, variables)
   226  	if err != nil {
   227  		log.Fatal(err)
   228  	}
   229  	fmt.Println(mutation.AddStar.Starrable.Repository.StargazerCount)
   230  }
   231  
   232  // Query releases from cli/cli repository using GraphQL API with paginated results.
   233  func ExampleGraphQLClient_pagination() {
   234  	client, err := api.DefaultGraphQLClient()
   235  	if err != nil {
   236  		log.Fatal(err)
   237  	}
   238  	var query struct {
   239  		Repository struct {
   240  			Releases struct {
   241  				Nodes []struct {
   242  					Name string
   243  				}
   244  				PageInfo struct {
   245  					HasNextPage bool
   246  					EndCursor   string
   247  				}
   248  			} `graphql:"releases(first: 30, after: $endCursor)"`
   249  		} `graphql:"repository(owner: $owner, name: $name)"`
   250  	}
   251  	variables := map[string]interface{}{
   252  		"owner":     graphql.String("cli"),
   253  		"name":      graphql.String("cli"),
   254  		"endCursor": (*graphql.String)(nil),
   255  	}
   256  	page := 1
   257  	for {
   258  		if err := client.Query("RepositoryReleases", &query, variables); err != nil {
   259  			log.Fatal(err)
   260  		}
   261  		fmt.Printf("Page: %d\n", page)
   262  		fmt.Println(query.Repository.Releases.Nodes)
   263  		if !query.Repository.Releases.PageInfo.HasNextPage {
   264  			break
   265  		}
   266  		variables["endCursor"] = graphql.String(query.Repository.Releases.PageInfo.EndCursor)
   267  		page++
   268  	}
   269  }
   270  
   271  // Get repository for the current directory.
   272  func ExampleCurrent() {
   273  	repo, err := repository.Current()
   274  	if err != nil {
   275  		log.Fatal(err)
   276  	}
   277  	fmt.Printf("%s/%s/%s\n", repo.Host, repo.Owner, repo.Name)
   278  }
   279  
   280  // Print tabular data to a terminal or in machine-readable format for scripts.
   281  func ExampleTablePrinter() {
   282  	terminal := term.FromEnv()
   283  	termWidth, _, _ := terminal.Size()
   284  	t := tableprinter.New(terminal.Out(), terminal.IsTerminalOutput(), termWidth)
   285  
   286  	red := func(s string) string {
   287  		return "\x1b[31m" + s + "\x1b[m"
   288  	}
   289  
   290  	// add a field that will render with color and will not be auto-truncated
   291  	t.AddField("1", tableprinter.WithColor(red), tableprinter.WithTruncate(nil))
   292  	t.AddField("hello")
   293  	t.EndRow()
   294  	t.AddField("2")
   295  	t.AddField("world")
   296  	t.EndRow()
   297  	if err := t.Render(); err != nil {
   298  		log.Fatal(err)
   299  	}
   300  }
   301
View as plain text