Actions status (#46)

Author: bivas

.rivi.rules.yaml

@@ -111,6 +111,14 @@ rules:
     labeler:
       label: area/actions/slack
 
+  action-status:
+    condition:
+      files:
+        patterns:
+          - "engine/actions/status/"
+    labeler:
+      label: area/actions/status
+
   action-trigger:
     condition:
       files:

README.md

@@ -93,6 +93,7 @@ Find out about available `condition` options [here](docs/condition.md)
 - [`trigger`](engine/actions/trigger/trigger.md) - Send HTTP triggers
 - [`locker`](engine/actions/locker/locker.md) - Lock an issue
 - [`slack`](engine/actions/slack/slack.md) - Send Slack messages
+- [`status`](engine/actions/status/status.md) - Update pull request commit status
 
 # Example Configuration
 

actions.go

@@ -8,5 +8,6 @@ import (
 	_ "github.com/bivas/rivi/engine/actions/locker"
 	_ "github.com/bivas/rivi/engine/actions/sizing"
 	_ "github.com/bivas/rivi/engine/actions/slack"
+	_ "github.com/bivas/rivi/engine/actions/status"
 	_ "github.com/bivas/rivi/engine/actions/trigger"
 )

connectors/github/client.go

@@ -36,6 +36,17 @@ func (c *ghClient) handleFileContentResponse(file *github.RepositoryContent, err
 	return content
 }
 
+func (c *ghClient) SetStatus(sha string, description string, state string) {
+	status := &github.RepoStatus{
+		Context:     github.String("rivi"),
+		Description: &description,
+		State:       &state,
+	}
+	if _, _, err := c.client.Repositories.CreateStatus(context.Background(), c.owner, c.repo, sha, status); err != nil {
+		c.logger.ErrorWith(log.MetaFields{log.E(err), log.F("repo", c.repo), log.F("sha", sha)}, "Unable to set status")
+	}
+}
+
 func (c *ghClient) GetFileContentFromRef(path, owner, repo, ref string) string {
 	opts := &github.RepositoryContentGetOptions{Ref: ref}
 	file, _, _, err := c.client.Repositories.GetContents(context.Background(), owner, repo, path, opts)

connectors/github/data.go

@@ -216,3 +216,14 @@ func (d *data) GetFileExtensions() []string {
 func (d *data) GetChanges() (int, int) {
 	return d.additions, d.deletions
 }
+
+func (d *data) SetStatus(description string, state types.State) {
+	set := "pending"
+	switch state {
+	case types.Failure:
+		set = "failure"
+	case types.Success:
+		set = "success"
+	}
+	d.client.SetStatus(d.origin.SHA, description, set)
+}

connectors/github/pullrequest_handler.go

@@ -37,6 +37,7 @@ func (h *pullRequestEventHandler) readFromJson(context *builderContext, payload
 		Repo:   head.Repo.Name,
 		Ref:    head.Ref,
 		Head:   head.Sha[0:6],
+		SHA:    head.Sha,
 		GitURL: head.Repo.GitURL,
 	}
 	context.data.state = pr.State

engine/actions/status/rule.go

@@ -0,0 +1,47 @@
+package status
+
+import (
+	"strings"
+)
+
+const (
+	defaultDescription = "Rivi completed processing rules"
+	defaultState       = "failure"
+	unknownState       = "error"
+)
+
+var (
+	states = []string{
+		"error",
+		"failure",
+		"pending",
+		"success",
+	}
+	searchState map[string]bool
+)
+
+type rule struct {
+	State       string `mapstructure:"state"`
+	Description string `mapstructure:"description"`
+}
+
+func (r *rule) Defaults() {
+	if r.State == "" {
+		r.State = defaultState
+	} else {
+		search := strings.ToLower(r.State)
+		if _, ok := searchState[search]; !ok {
+			r.State = unknownState
+		}
+	}
+	if r.Description == "" {
+		r.Description = defaultDescription
+	}
+}
+
+func init() {
+	searchState = make(map[string]bool)
+	for _, s := range states {
+		searchState[s] = true
+	}
+}

engine/actions/status/status.go

@@ -0,0 +1,56 @@
+package status
+
+import (
+	"errors"
+
+	"github.com/bivas/rivi/engine/actions"
+	"github.com/bivas/rivi/types"
+	"github.com/bivas/rivi/util/log"
+
+	"github.com/mitchellh/mapstructure"
+	"github.com/mitchellh/multistep"
+	"github.com/prometheus/client_golang/prometheus"
+)
+
+type action struct {
+	rule *rule
+	err  error
+
+	logger log.Logger
+}
+
+type HasSetStatusAPIData interface {
+	SetStatus(string, types.State)
+}
+
+func (a *action) Apply(state multistep.StateBag) {
+	meta := state.Get("data").(types.Data)
+	setStatus, ok := meta.(HasSetStatusAPIData)
+	if !ok {
+		a.logger.Warning("Event data does not support setting status. Check your configurations")
+		a.err = errors.New("event data does not support setting status")
+		return
+	}
+	setStatus.SetStatus(a.rule.Description, types.GetState(a.rule.State))
+}
+
+type factory struct {
+}
+
+func (*factory) BuildAction(config map[string]interface{}) actions.Action {
+	item := rule{}
+	logger := log.Get("status")
+	if e := mapstructure.Decode(config, &item); e != nil {
+		logger.ErrorWith(log.MetaFields{log.E(e)}, "Unable to build action")
+		return nil
+	}
+	item.Defaults()
+	return &action{rule: &item, logger: logger}
+}
+
+var counter = actions.NewCounter("status")
+
+func init() {
+	actions.RegisterAction("status", &factory{})
+	prometheus.Register(counter)
+}

engine/actions/status/status.md

@@ -0,0 +1,31 @@
+# Setting Commit Status
+
+## Goal
+
+Ability to set a status to pull request submitted commit
+
+## Requirements
+
+None
+
+## Options
+
+- `description` (required) - status description to set
+- `state` (optional) - which state to set. can be `failure`, `pending` or `success` (default: `failure`)
+
+## Example
+```yaml
+rules:
+    example:
+      status:
+        description: pull request doesn't follow guidelines
+        state: failure
+```
+or
+```yaml
+rules:
+    example:
+      status:
+        description: pull request is okay
+        state: success
+```

engine/actions/status/status_test.go

@@ -0,0 +1,81 @@
+package status
+
+import (
+	"testing"
+
+	"github.com/bivas/rivi/mocks"
+	"github.com/bivas/rivi/types"
+	"github.com/bivas/rivi/util/state"
+	"github.com/stretchr/testify/assert"
+)
+
+func TestSerialization(t *testing.T) {
+	input := map[string]interface{}{
+		"state":       "Success",
+		"description": "this is a test",
+	}
+
+	var f factory
+	result := f.BuildAction(input)
+	assert.NotNil(t, result, "should create action")
+	s, ok := result.(*action)
+	assert.True(t, ok, "should be of this package")
+	assert.Equal(t, "Success", s.rule.State, "state")
+	assert.Equal(t, "this is a test", s.rule.Description, "desc")
+}
+
+func TestSetDefaultStatus(t *testing.T) {
+	input := map[string]interface{}{
+		"description": "TestSetDefaultStatus",
+	}
+	var f factory
+	action := f.BuildAction(input)
+	assert.NotNil(t, action, "should create action")
+	meta := &mocks.MockData{}
+	config := &mocks.MockConfiguration{}
+	action.Apply(state.New(config, meta))
+	assert.Equal(t, types.GetState(defaultState), meta.StatusState, "state")
+	assert.Equal(t, "TestSetDefaultStatus", meta.StatusDescription, "desc")
+}
+
+func TestSetUnknownStatus(t *testing.T) {
+	input := map[string]interface{}{
+		"state":       "TestSetUnknownStatus",
+		"description": "TestSetUnknownStatus",
+	}
+	var f factory
+	action := f.BuildAction(input)
+	assert.NotNil(t, action, "should create action")
+	meta := &mocks.MockData{}
+	config := &mocks.MockConfiguration{}
+	action.Apply(state.New(config, meta))
+	assert.Equal(t, types.GetState(unknownState), meta.StatusState, "state")
+	assert.Equal(t, "TestSetUnknownStatus", meta.StatusDescription, "desc")
+}
+
+func TestSetSuccessStatus(t *testing.T) {
+	input := map[string]interface{}{
+		"state":       "Success",
+		"description": "TestSetSuccessStatus",
+	}
+	var f factory
+	action := f.BuildAction(input)
+	assert.NotNil(t, action, "should create action")
+	meta := &mocks.MockData{}
+	config := &mocks.MockConfiguration{}
+	action.Apply(state.New(config, meta))
+	assert.Equal(t, types.Success, meta.StatusState, "state")
+	assert.Equal(t, "TestSetSuccessStatus", meta.StatusDescription, "desc")
+}
+
+func TestDefault(t *testing.T) {
+	input := map[string]interface{}{}
+	var f factory
+	action := f.BuildAction(input)
+	assert.NotNil(t, action, "should create action")
+	meta := &mocks.MockData{}
+	config := &mocks.MockConfiguration{}
+	action.Apply(state.New(config, meta))
+	assert.Equal(t, types.GetState(defaultState), meta.StatusState, "state")
+	assert.Equal(t, defaultDescription, meta.StatusDescription, "desc")
+}