Reimplement translation prs

config/config-mattermod.default.json

@@ -58,6 +58,7 @@
             "ExpectedArtifacts": 0
         }
     ],
+
     "EnterpriseReponame": "",
     "EnterpriseTriggerReponame": "",
     "EnterpriseWebappReponame": "",
@@ -66,6 +67,11 @@
     "EnterpriseGithubStatusEETests": "",
     "EnterpriseGithubStatusTETests": "",
     "EnterpriseWorkflowName": "",
+
+    "TranslationsMattermostWebhookURL": "",
+    "TranslationsMattermostMessage": "",
+    "TranslationsBot": "",
+
     "StartLoadtestTag": "",
     "StartLoadtestMessage": "",
     "CLAExclusionsList": [],

server/cla.go

@@ -51,7 +51,7 @@ func (s *Server) checkCLA(pr *model.PullRequest) {
 		mlog.Int("pr n", pr.Number),
 	)
 
-	if contains(s.Config.CLAExclusionsList, username) {
+	if s.IsTrustedUser(username) {
 		status := &github.RepoStatus{
 			State:       github.String(stateSuccess),
 			Description: github.String(fmt.Sprintf("%s excluded", username)),

server/config.go

@@ -99,6 +99,10 @@ type Config struct {
 	EnterpriseGithubStatusEETests string
 	EnterpriseWorkflowName        string
 
+	TranslationsMattermostWebhookURL string
+	TranslationsMattermostMessage    string
+	TranslationsBot                  string
+
 	StartLoadtestTag     string
 	StartLoadtestMessage string
 

server/enterprise.go

@@ -14,7 +14,7 @@ import (
 )
 
 func (s *Server) triggerEETestsForOrgMembers(pr *model.PullRequest) {
-	if s.IsOrgMember(pr.Username) {
+	if s.IsOrgMember(pr.Username) || s.IsTrustedUser(pr.Username) {
 		s.triggerEnterpriseTests(pr)
 	}
 }

server/github.go

@@ -212,6 +212,15 @@ func (s *Server) IsOrgMember(user string) bool {
 	return false
 }
 
+func (s *Server) IsTrustedUser(user string) bool {
+	for _, knownUser := range s.Config.CLAExclusionsList {
+		if user == knownUser {
+			return true
+		}
+	}
+	return false
+}
+
 func (s *Server) checkIfRefExists(pr *model.PullRequest, org string, ref string) (bool, error) {
 	_, r, err := s.GithubClient.Git.GetRef(context.Background(), org, pr.RepoName, ref)
 	if err != nil {

server/pull_request.go

@@ -28,6 +28,7 @@ func (s *Server) handlePullRequestEvent(event *PullRequestEvent) {
 		s.checkCLA(pr)
 		s.triggerCircleCiIfNeeded(pr)
 		s.addHacktoberfestLabel(pr)
+		s.handleTranslationPr(pr)
 
 		if pr.RepoName == s.Config.EnterpriseTriggerReponame {
 			s.createEnterpriseTestsPendingStatus(context.TODO(), pr)
@@ -43,6 +44,7 @@ func (s *Server) handlePullRequestEvent(event *PullRequestEvent) {
 		mlog.Info("PR reopened", mlog.String("repo", pr.RepoName), mlog.Int("pr", pr.Number))
 		s.checkCLA(pr)
 		s.triggerCircleCiIfNeeded(pr)
+		s.handleTranslationPr(pr)
 
 		if pr.RepoName == s.Config.EnterpriseTriggerReponame {
 			s.createEnterpriseTestsPendingStatus(context.TODO(), pr)

server/server_test.go

@@ -39,15 +39,12 @@ func TestMain(m *testing.M) {
 		panic(err)
 	}
 	s.Start()
-
+	defer s.Stop()
 	exitVal := m.Run()
-
 	os.Exit(exitVal)
 }
 
 func TestPing(t *testing.T) {
-	defer s.Stop()
-
 	split := strings.Split(config.ListenAddress, ":")
 	require.Len(t, split, 2)
 
@@ -68,7 +65,7 @@ func TestPing(t *testing.T) {
 	if err != nil {
 		mlog.Error("unable to find project path")
 	}
-	jsonLoader := gojsonschema.NewReferenceLoader("file://" + dir + "/schema/ping.schema.json")
+	jsonLoader := gojsonschema.NewReferenceLoader("file://" + dir + "/testdata/schema/ping.schema.json")
 
 	result, err := gojsonschema.Validate(jsonLoader, bytesLoader)
 	if err != nil {

server/translations.go

@@ -0,0 +1,27 @@
+package server
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/mattermost/mattermost-mattermod/model"
+	"github.com/mattermost/mattermost-server/v5/mlog"
+)
+
+func (s *Server) handleTranslationPr(pr *model.PullRequest) {
+	if pr.Username != s.Config.Username {
+		return
+	}
+
+	dataMsg := fmt.Sprintf("####[%v translations PR %v](%v)\n", pr.RepoName, time.Now().UTC().Format(time.RFC3339), pr.URL)
+	msg := dataMsg + s.Config.TranslationsMattermostMessage
+	mlog.Debug("Sending Mattermost message", mlog.String("message", msg))
+
+	webhookRequest := &Payload{Username: "Weblate", Text: msg}
+	r, err := s.sendToWebhook(s.Config.TranslationsMattermostWebhookURL, webhookRequest)
+	if err != nil {
+		mlog.Error("Unable to post to Mattermost webhook", mlog.Err(err))
+		return
+	}
+	defer r.Body.Close()
+}

server/utils.go

@@ -7,11 +7,6 @@ import (
 )
 
 func (s *Server) logToMattermost(msg string, args ...interface{}) {
-	if s.Config.MattermostWebhookURL == "" {
-		mlog.Warn("No Mattermost webhook URL set: unable to send message")
-		return
-	}
-
 	webhookMessage := fmt.Sprintf(msg, args...)
 	mlog.Debug("Sending Mattermost message", mlog.String("message", webhookMessage))
 
@@ -21,9 +16,12 @@ func (s *Server) logToMattermost(msg string, args ...interface{}) {
 
 	webhookRequest := &Payload{Username: "Mattermod", Text: webhookMessage}
 
-	if err := s.sendToWebhook(webhookRequest); err != nil {
+	r, err := s.sendToWebhook(s.Config.MattermostWebhookURL, webhookRequest)
+	if err != nil {
 		mlog.Error("Unable to post to Mattermost webhook", mlog.Err(err))
+		return
 	}
+	defer r.Body.Close()
 }
 
 func NewBool(b bool) *bool       { return &b }

server/webhook.go

@@ -6,7 +6,6 @@ package server
 import (
 	"bytes"
 	"encoding/json"
-	"io"
 	"io/ioutil"
 	"net/http"
 
@@ -18,31 +17,55 @@ type Payload struct {
 	Text     string `json:"text"`
 }
 
-func (s *Server) sendToWebhook(payload *Payload) error {
+func (s *Server) sendToWebhook(webhookURL string, payload *Payload) (*http.Response, error) {
+	err := validateSendToWebhookRequest(webhookURL, payload)
+	if err != nil {
+		badRequestR := &http.Response{
+			StatusCode: http.StatusBadRequest,
+			Body:       ioutil.NopCloser(bytes.NewBufferString(err.Error())),
+		}
+		return badRequestR, err
+	}
+
 	payloadBytes, err := json.Marshal(payload)
 	if err != nil {
-		return err
+		internalServerErrorR := &http.Response{
+			StatusCode: http.StatusInternalServerError,
+			Body:       ioutil.NopCloser(bytes.NewBufferString(err.Error())),
+		}
+		return internalServerErrorR, err
 	}
 	body := bytes.NewReader(payloadBytes)
 
-	req, err := http.NewRequest(http.MethodPost, s.Config.MattermostWebhookURL, body)
+	req, err := http.NewRequest(http.MethodPost, webhookURL, body)
 	if err != nil {
-		return err
+		internalServerErrorR := &http.Response{
+			StatusCode: http.StatusInternalServerError,
+			Body:       ioutil.NopCloser(bytes.NewBufferString(err.Error())),
+		}
+		return internalServerErrorR, err
 	}
 	req.Header.Set("Content-Type", "application/json")
 
 	r, err := http.DefaultClient.Do(req)
 	if err != nil {
-		return err
+		return r, err
+	}
+
+	return r, nil
+}
+
+func validateSendToWebhookRequest(webhookURL string, payload *Payload) error {
+	if webhookURL == "" {
+		return errors.New("no Mattermost webhook URL set: unable to send message")
 	}
-	defer func() {
-		_, _ = io.Copy(ioutil.Discard, r.Body)
-		r.Body.Close()
-	}()
 
-	if r.StatusCode != http.StatusOK {
-		return errors.Errorf("received non-200 status code posting to mattermost: %v, %v", r.StatusCode, r.Body)
+	if payload.Username == "" {
+		return errors.New("username not set in webhook payload")
 	}
 
+	if payload.Text == "" {
+		return errors.New("text not set in webhook payload")
+	}
 	return nil
 }

server/webhook_integration_test.go

@@ -0,0 +1,81 @@
+package server
+
+import (
+	"fmt"
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func TestSendToWebhook(t *testing.T) {
+	validPayload := &Payload{Username: "mattermod", Text: "test"}
+
+	mattermost := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		fmt.Fprintln(w, "ok")
+	}))
+	defer mattermost.Close()
+
+	r, err := s.sendToWebhook(mattermost.URL, validPayload)
+	if err != nil {
+		t.Fatal(err.Error())
+	}
+	got := r.StatusCode
+	if got != http.StatusOK {
+		t.Errorf("got: %v, want: %v", got, http.StatusOK)
+	}
+	defer r.Body.Close()
+}
+
+func TestSendToWebhookUsernameNotSet(t *testing.T) {
+	invalidPayload := &Payload{Text: "test"}
+	mattermost := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+	}))
+	defer mattermost.Close()
+
+	wantError := "username not set in webhook payload"
+	r, err := s.sendToWebhook(mattermost.URL, invalidPayload)
+	if err == nil {
+		t.Fatal("expected error")
+	}
+	if err.Error() != wantError {
+		t.Fatalf("got: %v, want: %v", err.Error(), wantError)
+	}
+
+	if r == nil {
+		t.Fatal("expected response")
+	}
+
+	wantStatusCode := http.StatusBadRequest
+	gotStatusCode := r.StatusCode
+	if gotStatusCode != wantStatusCode {
+		t.Errorf("got: %v, want: %v", gotStatusCode, wantStatusCode)
+	}
+	defer r.Body.Close()
+}
+
+func TestSendToWebhookWebhookURLNotSet(t *testing.T) {
+	validPayload := &Payload{Username: "mattermod", Text: "test"}
+	mattermost := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+	}))
+	defer mattermost.Close()
+
+	wantError := "no Mattermost webhook URL set: unable to send message"
+	r, err := s.sendToWebhook("", validPayload)
+	if err == nil {
+		t.Fatal("expected error")
+	}
+	if err.Error() != wantError {
+		t.Fatalf("got: %v, want: %v", err.Error(), wantError)
+	}
+
+	if r == nil {
+		t.Fatal("expected response")
+	}
+
+	wantStatusCode := http.StatusBadRequest
+	gotStatusCode := r.StatusCode
+	if gotStatusCode != wantStatusCode {
+		t.Errorf("got: %v, want: %v", gotStatusCode, wantStatusCode)
+	}
+	defer r.Body.Close()
+}