Status API support for checks and fixes to pullvet note checks (#7)

* test7

* Change CreateCheckRun experiment

* feat(checks): statuses

* feat(checks): add description to status

* feat(checks): add -status-context

* add event dump to dev.yml

* fix(pullvet): note detection

* fix(pullvet): always get pull request body from api

as it is `null` sometimes(maybe it is non-null only when `open` and `synchronize`? was null when pr reopen and label/unlabel)

Author: mumoshu

.github/workflows/dev.yml

@@ -34,6 +34,12 @@ jobs:
     runs-on: ubuntu-latest
     if: startsWith(github.repository, 'variantdev/')
     steps:
+    - run: |
+        echo GITHUB_ACTION: $GITHUB_ACTION
+        echo GITHUB_WORKFLOW: $GITHUB_WORKFLOW
+        echo GITHUB_EVENT_NAME: $GITHUB_EVENT_NAME
+        echo GITHUB_EVENT_PATH: $GITHUB_EVENT_PATH
+        cat $GITHUB_EVENT_PATH
     - uses: actions/checkout@master
     - uses: actions/setup-go@v1
       with:
@@ -60,3 +66,33 @@ jobs:
         bin/actions checks -run dev2 -- bin/actions pullvet -require-any -label dev2 -label dev3
       env:
         GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
+  ensure-dev3:
+    runs-on: ubuntu-latest
+    if: startsWith(github.repository, 'variantdev/')
+    steps:
+    - uses: actions/checkout@master
+    - uses: actions/setup-go@v1
+      with:
+        go-version: '1.12.7'
+    - run: |
+        make build
+    - name: dev3
+      run: |
+        bin/actions checks -status-context checks/dev3 -- bin/actions pullvet -require-any -label dev3
+      env:
+        GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}
+  ensure-changelog:
+    runs-on: ubuntu-latest
+    if: startsWith(github.repository, 'variantdev/')
+    steps:
+    - uses: actions/checkout@master
+    - uses: actions/setup-go@v1
+      with:
+        go-version: '1.12.7'
+    - run: |
+        make build
+    - name: changelog
+      run: |
+        bin/actions checks -status-context checks/changelog -- bin/actions pullvet -require-any -note changelog1 -note changelog2
+      env:
+        GITHUB_TOKEN: ${{secrets.GITHUB_TOKEN}}

client.go

@@ -0,0 +1,25 @@
+package actions
+
+import (
+	"context"
+	"os"
+
+	"github.com/google/go-github/v28/github"
+	"golang.org/x/oauth2"
+)
+
+// CreateInstallationTokenClient uses an installation token to authenticate to the Github API.
+func CreateInstallationTokenClient(instToken, baseURL, uploadURL string) (*github.Client, error) {
+	// For installation tokens, Github uses a different token type ("token" instead of "bearer")
+	tokenType := "token"
+	if os.Getenv("GITHUB_TOKEN_TYPE") != "" {
+		tokenType = os.Getenv("GITHUB_TOKEN_TYPE")
+	}
+	t := oauth2.StaticTokenSource(&oauth2.Token{AccessToken: instToken, TokenType: tokenType})
+	c := context.Background()
+	tc := oauth2.NewClient(c, t)
+	if baseURL != "" {
+		return github.NewEnterpriseClient(baseURL, uploadURL, tc)
+	}
+	return github.NewClient(tc), nil
+}

event.go

@@ -63,28 +63,35 @@ func CheckSuiteEvent() (*github.CheckSuiteEvent, error) {
 	return evt.(*github.CheckSuiteEvent), nil
 }
 
-func PullRequest() (*github.PullRequest, error) {
+func PullRequest() (*github.PullRequest, string, string, error) {
 	var pr *github.PullRequest
+	var owner, repo string
 	switch EventName() {
 	case "pull_request":
 		pull, err := PullRequestEvent()
 		if err != nil {
-			return nil, err
+			return nil, "", "", err
 		}
 		pr = pull.PullRequest
+		owner = pull.Repo.Owner.GetLogin()
+		repo = pull.Repo.GetName()
 	case "check_run":
 		checkRun, err := CheckRunEvent()
 		if err != nil {
-			return nil, err
+			return nil, "", "", err
 		} else {
 			pr = checkRun.CheckRun.PullRequests[0]
 		}
+		owner = checkRun.Repo.Owner.GetLogin()
+		repo = checkRun.Repo.GetName()
 	case "check_suite":
 		checkSuite, err := CheckSuiteEvent()
 		if err != nil {
-			return nil, err
+			return nil, "", "", err
 		}
 		pr = checkSuite.CheckSuite.PullRequests[0]
+		owner = checkSuite.Repo.Owner.GetLogin()
+		repo = checkSuite.Repo.GetName()
 	}
-	return pr, nil
+	return pr, owner, repo, nil
 }

pkg/checks/checks.go

@@ -16,16 +16,18 @@ import (
 	"github.com/google/go-github/v28/github"
 	"github.com/variantdev/go-actions"
 	"github.com/variantdev/go-actions/pkg/cmd"
-	"golang.org/x/oauth2"
 )
 
 type Command struct {
 	BaseURL, UploadURL string
 	createRuns         cmd.StringSlice
 
 	checkName string
-	cmd       string
-	args      []string
+
+	statusContext string
+
+	cmd  string
+	args []string
 }
 
 func New() *Command {
@@ -40,6 +42,7 @@ func (c *Command) AddFlags(fs *flag.FlagSet) {
 	fs.StringVar(&c.UploadURL, "github-upload-url", "", "")
 	fs.Var(&c.createRuns, "create-run", "Name of CheckRun to be created on CheckSuite `(re)requested` event. Specify multiple times to create two or more runs")
 	fs.StringVar(&c.checkName, "run", "", "CheckRun's name to be updated after the command in run")
+	fs.StringVar(&c.statusContext, "status-context", "", "Commit status' context. If not empty, `checks` creates a status with this contecxt")
 }
 
 func (c *Command) Run(args []string) error {
@@ -129,13 +132,13 @@ func (c *Command) createCheckRun(suite *github.CheckSuite, cr Run) (*github.Chec
 }
 
 type CreateCheckRunOptions struct {
-	Name         string                   `json:"name"`                  // The name of the check (e.g., "code-coverage"). (Required.)
-	HeadBranch   string                   `json:"head_branch"`           // The name of the branch to perform a check against. (Required.)
-	HeadSHA      string                   `json:"head_sha"`              // The SHA of the commit. (Required.)
-	DetailsURL   *string                  `json:"details_url,omitempty"` // The URL of the integrator's site that has the full details of the check. (Optional.)
-	ExternalID   *string                  `json:"external_id,omitempty"` // A reference for the run on the integrator's system. (Optional.)
-	Status       *string                  `json:"status,omitempty"`      // The current status. Can be one of "queued", "in_progress", or "completed". Default: "queued". (Optional.)
-	Conclusion   *string                  `json:"conclusion,omitempty"`  // Can be one of "success", "failure", "neutral", "cancelled", "timed_out", or "action_required". (Optional. Required if you provide a status of "completed".)
+	Name       string  `json:"name"`                  // The name of the check (e.g., "code-coverage"). (Required.)
+	HeadBranch string  `json:"head_branch"`           // The name of the branch to perform a check against. (Required.)
+	HeadSHA    string  `json:"head_sha"`              // The SHA of the commit. (Required.)
+	DetailsURL *string `json:"details_url,omitempty"` // The URL of the integrator's site that has the full details of the check. (Optional.)
+	ExternalID *string `json:"external_id,omitempty"` // A reference for the run on the integrator's system. (Optional.)
+	Status     *string `json:"status,omitempty"`      // The current status. Can be one of "queued", "in_progress", or "completed". Default: "queued". (Optional.)
+	Conclusion *string `json:"conclusion,omitempty"`  // Can be one of "success", "failure", "neutral", "cancelled", "timed_out", or "action_required". (Optional. Required if you provide a status of "completed".)
 	// Does this really work?
 	CheckSuiteID *int64                   `json:"check_suite_id,omitempty`
 	StartedAt    *github.Timestamp        `json:"started_at,omitempty"`   // The time that the check run began. (Optional.)
@@ -145,7 +148,7 @@ type CreateCheckRunOptions struct {
 }
 
 func (c *Command) CreateCheckRun(client *github.Client, ctx context.Context, owner, repo string, opt CreateCheckRunOptions) (*github.CheckRun, *github.Response, error) {
-	u := fmt.Sprintf("repos/%v/%v/check-runs", owner, repo)
+	u := fmt.Sprintf("repos/%v/%v/check-suites/%v/check-runs", owner, repo, *opt.CheckSuiteID)
 	req, err := client.NewRequest("POST", u, opt)
 	if err != nil {
 		return nil, nil, err
@@ -168,47 +171,84 @@ func (c *Command) EnsureCheckRun(pre *github.PullRequestEvent) error {
 		return err
 	}
 
-	suite, err := c.EnsureCheckSuite(pre)
-	if err != nil {
-		return err
-	}
+	log.Printf("Running command: %q", c.cmd)
 
-	cr := Run{
-		name:    c.checkName,
-		owner:   suite.Repository.Owner.GetLogin(),
-		repo:    suite.Repository.GetName(),
-		suiteId: suite.GetID(),
-	}
+	summary, text, runErr := c.runIt()
 
-	checkRunsList, _, err := client.Checks.ListCheckRunsCheckSuite(context.Background(), cr.owner, cr.repo, cr.suiteId, &github.ListCheckRunsOptions{
-		CheckName: github.String(c.checkName),
-		// TODO
-		//ListOptions: github.ListOptions{},
-	})
+	owner := pre.Repo.Owner.GetLogin()
+	repo := pre.Repo.GetName()
+
+	if c.checkName != "" {
+		suite, err := c.EnsureCheckSuite(pre)
+		if err != nil {
+			return err
+		}
 
-	var checkRun *github.CheckRun
-	for _, existing := range checkRunsList.CheckRuns {
-		if existing.GetName() == cr.name {
-			checkRun = existing
+		cr := Run{
+			name:    c.checkName,
+			owner:   owner,
+			repo:    repo,
+			suiteId: suite.GetID(),
 		}
-	}
 
-	if checkRun == nil {
-		log.Printf("Creating CheckRun %q", cr.name)
-		created, err := c.createCheckRun(suite, cr)
-		if err != nil {
+		checkRunsList, _, err := client.Checks.ListCheckRunsCheckSuite(context.Background(), cr.owner, cr.repo, cr.suiteId, &github.ListCheckRunsOptions{
+			CheckName: github.String(c.checkName),
+			// TODO
+			//ListOptions: github.ListOptions{},
+		})
+
+		var checkRun *github.CheckRun
+		for _, existing := range checkRunsList.CheckRuns {
+			if existing.GetName() == cr.name {
+				checkRun = existing
+			}
+		}
+
+		if checkRun == nil {
+			log.Printf("Creating CheckRun %q", cr.name)
+			created, err := c.createCheckRun(suite, cr)
+			if err != nil {
+				return err
+			}
+			checkRun = created
+		}
+
+		c.logCheckRun(checkRun)
+
+		log.Printf("Updating CheckRun")
+		if err := c.UpdateCheckRun(owner, repo, checkRun, summary, text, runErr); err != nil {
 			return err
 		}
-		checkRun = created
 	}
 
-	c.logCheckRun(checkRun)
-
-	log.Printf("Running the commmand for CheckRun %q", cr.name)
-	summary, text, runErr := c.runIt()
+	if c.statusContext != "" {
+		sha := pre.PullRequest.Head.GetSHA()
+		var state string
+		if runErr != nil {
+			state = "failure"
+		} else {
+			state = "success"
+		}
+		status := &github.RepoStatus{
+			State:       github.String(state),
+			Context:     github.String(c.statusContext),
+			Description: github.String(text),
+		}
+		repoStatus, _, err := client.Repositories.CreateStatus(context.Background(), owner, repo, sha, status)
+		if err != nil {
+			log.Printf("Failed creating status: %v", err)
+		} else {
+			buf := bytes.Buffer{}
+			enc := json.NewEncoder(&buf)
+			enc.SetIndent("", "  ")
+			if err := enc.Encode(repoStatus); err != nil {
+				return err
+			}
+			log.Printf("Created repo status:\n%s", buf.String())
+		}
+	}
 
-	log.Printf("Updating CheckRun")
-	return c.UpdateCheckRun(cr.owner, cr.repo, checkRun, summary, text, runErr)
+	return nil
 }
 
 func (c *Command) logCheckRun(checkRun *github.CheckRun) {
@@ -421,21 +461,6 @@ func (c *Command) CreateCheckSuite(pre *github.PullRequestEvent) (*github.CheckS
 }
 
 func (c *Command) instTokenClient() (*github.Client, error) {
-	return instTokenClient(os.Getenv("GITHUB_TOKEN"), c.BaseURL, c.UploadURL)
+	return actions.CreateInstallationTokenClient(os.Getenv("GITHUB_TOKEN"), c.BaseURL, c.UploadURL)
 }
 
-// instTokenClient uses an installation token to authenticate to the Github API.
-func instTokenClient(instToken, baseURL, uploadURL string) (*github.Client, error) {
-	// For installation tokens, Github uses a different token type ("token" instead of "bearer")
-	tokenType := "token"
-	if os.Getenv("GITHUB_TOKEN_TYPE") != "" {
-		tokenType = os.Getenv("GITHUB_TOKEN_TYPE")
-	}
-	t := oauth2.StaticTokenSource(&oauth2.Token{AccessToken: instToken, TokenType: tokenType})
-	c := context.Background()
-	tc := oauth2.NewClient(c, t)
-	if baseURL != "" {
-		return github.NewEnterpriseClient(baseURL, uploadURL, tc)
-	}
-	return github.NewClient(tc), nil
-}

pkg/pullvet/pullvet.go

@@ -1,18 +1,24 @@
 package pullvet
 
 import (
+	"bytes"
+	"context"
+	"encoding/json"
 	"flag"
 	"fmt"
 	"github.com/google/go-github/v28/github"
 	"github.com/variantdev/go-actions"
 	"github.com/variantdev/go-actions/pkg/cmd"
+	"log"
 	"os"
 	"regexp"
 	"strings"
 )
 
 const defaultNoteRegex = "[\\*]*([^\\*:]+)[\\*]*:\\s```\n([^`]+)\n```"
 
+var newlineRegex = regexp.MustCompile(`\r\n|\r|\n`)
+
 type Command struct {
 	labels     cmd.StringSlice
 	noteTitles cmd.StringSlice
@@ -26,6 +32,10 @@ type Command struct {
 	requireAll   bool
 }
 
+func normalizeNewlines(str string) string {
+	return newlineRegex.Copy().ReplaceAllString(str, "\n")
+}
+
 func New() *Command {
 	return &Command{
 	}
@@ -42,14 +52,14 @@ func (c *Command) AddFlags(fs *flag.FlagSet) {
 }
 
 func (c *Command) Run() error {
-	pr, err := actions.PullRequest()
+	pr, owner, repo, err := actions.PullRequest()
 	if err != nil {
 		return err
 	}
-	return c.HandlePullRequest(pr)
+	return c.HandlePullRequest(owner, repo, pr)
 }
 
-func (c *Command) HandlePullRequest(pullRequest *github.PullRequest) error {
+func (c *Command) HandlePullRequest(owner, repo string, pullRequest *github.PullRequest) error {
 	var labels []string
 	labelSet := map[string]struct{}{}
 
@@ -99,11 +109,29 @@ func (c *Command) HandlePullRequest(pullRequest *github.PullRequest) error {
 
 	noteTitles := map[string]struct{}{}
 
-	body := pullRequest.GetBody()
+	client, err := actions.CreateInstallationTokenClient(os.Getenv("GITHUB_TOKEN"), "", "")
+	if err != nil {
+		return err
+	}
+
+	pr, _, err :=client.PullRequests.Get(context.Background(), owner, repo, pullRequest.GetNumber())
+	if err != nil {
+		return err
+	}
+
+	buf := bytes.Buffer{}
+	enc := json.NewEncoder(&buf)
+	enc.SetIndent("", "  ")
+	if err := enc.Encode(pr); err != nil {
+		return err
+	}
+	log.Printf("Pull request:\n%s", buf.String())
+
+	body := pr.GetBody()
 
 	regex := regexp.MustCompile(c.noteRegex)
 
-	allNoteMatches := regex.FindAllStringSubmatch(body, -1)
+	allNoteMatches := regex.FindAllStringSubmatch(normalizeNewlines(body), -1)
 	for _, m := range allNoteMatches {
 		noteTitles[m[0]] = struct{}{}
 	}