Add tests

plugins/inputs/ghwebhooks/ghwebhooks.go

@@ -4,11 +4,10 @@ import (
 	"encoding/json"
 	"fmt"
 	"io/ioutil"
+	"log"
 	"net/http"
 	"sync"
-	"time"
 
-	log "github.com/Sirupsen/logrus"
 	"github.com/gorilla/mux"
 	mod "github.com/influxdata/support-tools/ghWebhooks/models"
 	"github.com/influxdata/telegraf/plugins/inputs"
@@ -21,12 +20,14 @@ func init() {
 type GHWebhooks struct {
 	ServiceAddress  string
 	MeasurementName string
-
+	// Lock for the struct
 	sync.Mutex
+	// Events buffer to store events between Gather calls
+	events []mod.Event
+}
 
-	// Channel for all incoming events from github
-	in   chan mod.Event
-	done chan struct{}
+func NewGHWebhooks() *GHWebhooks {
+	return &GHWebhooks{}
 }
 
 func (gh *GHWebhooks) SampleConfig() string {
@@ -34,290 +35,261 @@ func (gh *GHWebhooks) SampleConfig() string {
   # Address and port to host Webhook listener on
   service_address = ":1618"
 	# Measurement name
-	measurement_name = "ghWebhooks"
+	measurement_name = "ghwebhooks"
 `
 }
 
 func (gh *GHWebhooks) Description() string {
-	return "Github Webhook Event collector"
+	return "A Github Webhook Event collector"
 }
 
 // Writes the points from <-gh.in to the Accumulator
 func (gh *GHWebhooks) Gather(acc inputs.Accumulator) error {
 	gh.Lock()
 	defer gh.Unlock()
-	for {
-		select {
-		case <-gh.done:
-			return nil
-		case e := <-gh.in:
-			p := e.NewPoint()
-			acc.Add(gh.MeasurementName, p.Fields(), p.Tags(), p.Time())
-		}
+	for _, event := range gh.events {
+		p := event.NewPoint()
+		acc.AddFields(gh.MeasurementName, p.Fields(), p.Tags(), p.Time())
 	}
+	gh.events = make([]mod.Event, 0)
 	return nil
 }
 
-func (gh *GHWebhooks) listen() error {
-	fmt.Println("in listen!")
+func (gh *GHWebhooks) Listen() {
 	r := mux.NewRouter()
-	r.HandleFunc("/", gh.webhookHandler).Methods("POST")
-	err := http.ListenAndServe(fmt.Sprintf(":%s", gh.ServiceAddress), r)
+	r.HandleFunc("/", gh.eventHandler).Methods("POST")
+	err := http.ListenAndServe(fmt.Sprintf("%s", gh.ServiceAddress), r)
 	if err != nil {
-		return err
+		log.Printf("Error starting server: %v", err)
 	}
-	fmt.Println("Exiting listen")
-	return nil
 }
 
 func (gh *GHWebhooks) Start() error {
-	fmt.Println("In start function")
-	gh.done = make(chan struct{})
-	gh.in = make(chan mod.Event)
-	// Start the UDP listener
-	go gh.listen()
-	// Start the line parser
+	go gh.Listen()
 	log.Printf("Started the ghwebhooks service on %s\n", gh.ServiceAddress)
 	return nil
 }
 
 func (gh *GHWebhooks) Stop() {
-	gh.Lock()
-	defer gh.Unlock()
 	log.Println("Stopping the ghWebhooks service")
-	close(gh.done)
-	close(gh.in)
 }
 
-// Handles the /webhooks route
-func (gh *GHWebhooks) webhookHandler(w http.ResponseWriter, r *http.Request) {
-	fmt.Println("In webhook handler")
+// Handles the / route
+func (gh *GHWebhooks) eventHandler(w http.ResponseWriter, r *http.Request) {
 	eventType := r.Header["X-Github-Event"][0]
 	data, err := ioutil.ReadAll(r.Body)
 	if err != nil {
-		fields := log.Fields{"time": time.Now(), "event": eventType, "error": err}
-		log.WithFields(fields).Fatal("Error reading Github payload")
+		w.WriteHeader(http.StatusBadRequest)
 	}
-
-	// Send event down chan to GHWebhooks
-	e := NewEvent(data, eventType)
-	gh.in <- e
-	fmt.Printf("%v\n", e.NewPoint())
+	e, err := NewEvent(data, eventType)
+	if err != nil {
+		w.WriteHeader(http.StatusBadRequest)
+	}
+	gh.Lock()
+	gh.events = append(gh.events, e)
+	gh.Unlock()
 	w.WriteHeader(http.StatusOK)
 }
 
-func newCommitComment(data []byte) mod.Event {
+func newCommitComment(data []byte) (mod.Event, error) {
 	commitCommentStruct := mod.CommitCommentEvent{}
 	err := json.Unmarshal(data, &commitCommentStruct)
 	if err != nil {
-		fields := log.Fields{"time": time.Now(), "event": "CommitCommentEvent", "error": err}
-		log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
+		return nil, err
 	}
-	return commitCommentStruct
+	return commitCommentStruct, nil
 }
 
-func newCreate(data []byte) mod.Event {
+func newCreate(data []byte) (mod.Event, error) {
 	createStruct := mod.CreateEvent{}
 	err := json.Unmarshal(data, &createStruct)
 	if err != nil {
-		fields := log.Fields{"time": time.Now(), "event": "CreateEvent", "error": err}
-		log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
+		return nil, err
 	}
-	return createStruct
+	return createStruct, nil
 }
 
-func newDelete(data []byte) mod.Event {
+func newDelete(data []byte) (mod.Event, error) {
 	deleteStruct := mod.DeleteEvent{}
 	err := json.Unmarshal(data, &deleteStruct)
 	if err != nil {
-		fields := log.Fields{"time": time.Now(), "event": "DeleteEvent", "error": err}
-		log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
+		return nil, err
 	}
-	return deleteStruct
+	return deleteStruct, nil
 }
 
-func newDeployment(data []byte) mod.Event {
+func newDeployment(data []byte) (mod.Event, error) {
 	deploymentStruct := mod.DeploymentEvent{}
 	err := json.Unmarshal(data, &deploymentStruct)
 	if err != nil {
-		fields := log.Fields{"time": time.Now(), "event": "DeploymentEvent", "error": err}
-		log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
+		return nil, err
 	}
-	return deploymentStruct
+	return deploymentStruct, nil
 }
 
-func newDeploymentStatus(data []byte) mod.Event {
+func newDeploymentStatus(data []byte) (mod.Event, error) {
 	deploymentStatusStruct := mod.DeploymentStatusEvent{}
 	err := json.Unmarshal(data, &deploymentStatusStruct)
 	if err != nil {
-		fields := log.Fields{"time": time.Now(), "event": "DeploymentStatusEvent", "error": err}
-		log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
+		return nil, err
 	}
-	return deploymentStatusStruct
+	return deploymentStatusStruct, nil
 }
 
-func newFork(data []byte) mod.Event {
+func newFork(data []byte) (mod.Event, error) {
 	forkStruct := mod.ForkEvent{}
 	err := json.Unmarshal(data, &forkStruct)
 	if err != nil {
-		fields := log.Fields{"time": time.Now(), "event": "ForkEvent", "error": err}
-		log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
+		return nil, err
 	}
-	return forkStruct
+	return forkStruct, nil
 }
 
-func newGollum(data []byte) mod.Event {
+func newGollum(data []byte) (mod.Event, error) {
 	gollumStruct := mod.GollumEvent{}
 	err := json.Unmarshal(data, &gollumStruct)
 	if err != nil {
-		fields := log.Fields{"time": time.Now(), "event": "GollumEvent", "error": err}
-		log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
+		return nil, err
 	}
-	return gollumStruct
+	return gollumStruct, nil
 }
 
-func newIssueComment(data []byte) mod.Event {
+func newIssueComment(data []byte) (mod.Event, error) {
 	issueCommentStruct := mod.IssueCommentEvent{}
 	err := json.Unmarshal(data, &issueCommentStruct)
 	if err != nil {
-		fields := log.Fields{"time": time.Now(), "event": "IssueCommentEvent", "error": err}
-		log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
+		return nil, err
 	}
-	return issueCommentStruct
+	return issueCommentStruct, nil
 }
 
-func newIssues(data []byte) mod.Event {
+func newIssues(data []byte) (mod.Event, error) {
 	issuesStruct := mod.IssuesEvent{}
 	err := json.Unmarshal(data, &issuesStruct)
 	if err != nil {
-		fields := log.Fields{"time": time.Now(), "event": "IssuesEvent", "error": err}
-		log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
+		return nil, err
 	}
-	return issuesStruct
+	return issuesStruct, nil
 }
 
-func newMember(data []byte) mod.Event {
+func newMember(data []byte) (mod.Event, error) {
 	memberStruct := mod.MemberEvent{}
 	err := json.Unmarshal(data, &memberStruct)
 	if err != nil {
-		fields := log.Fields{"time": time.Now(), "event": "MemberEvent", "error": err}
-		log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
+		return nil, err
 	}
-	return memberStruct
+	return memberStruct, nil
 }
 
-func newMembership(data []byte) mod.Event {
+func newMembership(data []byte) (mod.Event, error) {
 	membershipStruct := mod.MembershipEvent{}
 	err := json.Unmarshal(data, &membershipStruct)
 	if err != nil {
-		fields := log.Fields{"time": time.Now(), "event": "MembershipEvent", "error": err}
-		log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
+		return nil, err
 	}
-	return membershipStruct
+	return membershipStruct, nil
 }
 
-func newPageBuild(data []byte) mod.Event {
+func newPageBuild(data []byte) (mod.Event, error) {
 	pageBuildEvent := mod.PageBuildEvent{}
 	err := json.Unmarshal(data, &pageBuildEvent)
 	if err != nil {
-		fields := log.Fields{"time": time.Now(), "event": "PageBuildEvent", "error": err}
-		log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
+		return nil, err
 	}
-	return pageBuildEvent
+	return pageBuildEvent, nil
 }
 
-func newPublic(data []byte) mod.Event {
+func newPublic(data []byte) (mod.Event, error) {
 	publicEvent := mod.PublicEvent{}
 	err := json.Unmarshal(data, &publicEvent)
 	if err != nil {
-		fields := log.Fields{"time": time.Now(), "event": "PublicEvent", "error": err}
-		log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
+		return nil, err
 	}
-	return publicEvent
+	return publicEvent, nil
 }
 
-func newPullRequest(data []byte) mod.Event {
+func newPullRequest(data []byte) (mod.Event, error) {
 	pullRequestStruct := mod.PullRequestEvent{}
 	err := json.Unmarshal(data, &pullRequestStruct)
 	if err != nil {
-		fields := log.Fields{"time": time.Now(), "event": "PullRequestEvent", "error": err}
-		log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
+		return nil, err
 	}
-	return pullRequestStruct
+	return pullRequestStruct, nil
 }
 
-func newPullRequestReviewComment(data []byte) mod.Event {
+func newPullRequestReviewComment(data []byte) (mod.Event, error) {
 	pullRequestReviewCommentStruct := mod.PullRequestReviewCommentEvent{}
 	err := json.Unmarshal(data, &pullRequestReviewCommentStruct)
 	if err != nil {
-		fields := log.Fields{"time": time.Now(), "event": "PullRequestReviewCommentEvent", "error": err}
-		log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
+		return nil, err
 	}
-	return pullRequestReviewCommentStruct
+	return pullRequestReviewCommentStruct, nil
 }
 
-func newPush(data []byte) mod.Event {
+func newPush(data []byte) (mod.Event, error) {
 	pushStruct := mod.PushEvent{}
 	err := json.Unmarshal(data, &pushStruct)
 	if err != nil {
-		fields := log.Fields{"time": time.Now(), "event": "PushEvent", "error": err}
-		log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
+		return nil, err
 	}
-	return pushStruct
+	return pushStruct, nil
 }
 
-func newRelease(data []byte) mod.Event {
+func newRelease(data []byte) (mod.Event, error) {
 	releaseStruct := mod.ReleaseEvent{}
 	err := json.Unmarshal(data, &releaseStruct)
 	if err != nil {
-		fields := log.Fields{"time": time.Now(), "event": "ReleaseEvent", "error": err}
-		log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
+		return nil, err
 	}
-	return releaseStruct
+	return releaseStruct, nil
 }
 
-func newRepository(data []byte) mod.Event {
+func newRepository(data []byte) (mod.Event, error) {
 	repositoryStruct := mod.RepositoryEvent{}
 	err := json.Unmarshal(data, &repositoryStruct)
 	if err != nil {
-		fields := log.Fields{"time": time.Now(), "event": "RepositoryEvent", "error": err}
-		log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
+		return nil, err
 	}
-	return repositoryStruct
+	return repositoryStruct, nil
 }
 
-func newStatus(data []byte) mod.Event {
+func newStatus(data []byte) (mod.Event, error) {
 	statusStruct := mod.StatusEvent{}
 	err := json.Unmarshal(data, &statusStruct)
 	if err != nil {
-		fields := log.Fields{"time": time.Now(), "event": "StatusEvent", "error": err}
-		log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
+		return nil, err
 	}
-	return statusStruct
+	return statusStruct, nil
 }
 
-func newTeamAdd(data []byte) mod.Event {
+func newTeamAdd(data []byte) (mod.Event, error) {
 	teamAddStruct := mod.TeamAddEvent{}
 	err := json.Unmarshal(data, &teamAddStruct)
 	if err != nil {
-		fields := log.Fields{"time": time.Now(), "event": "TeamAddEvent", "error": err}
-		log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
+		return nil, err
 	}
-	return teamAddStruct
+	return teamAddStruct, nil
 }
 
-func newWatch(data []byte) mod.Event {
+func newWatch(data []byte) (mod.Event, error) {
 	watchStruct := mod.WatchEvent{}
 	err := json.Unmarshal(data, &watchStruct)
 	if err != nil {
-		fields := log.Fields{"time": time.Now(), "event": "WatchEvent", "error": err}
-		log.WithFields(fields).Fatalf("Error in unmarshaling JSON")
+		return nil, err
 	}
-	return watchStruct
+	return watchStruct, nil
 }
 
-func NewEvent(r []byte, t string) mod.Event {
-	log.WithFields(log.Fields{"event": t, "time": time.Now()}).Info("Event Recieved")
+type newEventError struct {
+	s string
+}
+
+func (e *newEventError) Error() string {
+	return e.s
+}
+
+func NewEvent(r []byte, t string) (mod.Event, error) {
+	log.Printf("New %v event recieved", t)
 	switch t {
 	case "commit_comment":
 		return newCommitComment(r)
@@ -362,5 +334,5 @@ func NewEvent(r []byte, t string) mod.Event {
 	case "watch":
 		return newWatch(r)
 	}
-	return nil
+	return nil, &newEventError{"Not a recgonized event type"}
 }

plugins/inputs/ghwebhooks/ghwebhooks_test.go

@@ -0,0 +1,238 @@
+package ghwebhooks
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"testing"
+
+	mod "github.com/influxdata/telegraf/plugins/inputs/ghwebhooks/models"
+)
+
+func TestCommitCommentEvent(t *testing.T) {
+	gh := NewGHWebhooks()
+	jsonString := mod.Mock{}.CommitCommentEventJSON()
+	req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
+	req.Header.Add("X-Github-Event", "commit_comment")
+	w := httptest.NewRecorder()
+	gh.eventHandler(w, req)
+	if w.Code != http.StatusOK {
+		t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
+	}
+}
+
+func TestDeleteEvent(t *testing.T) {
+	gh := NewGHWebhooks()
+	jsonString := mod.Mock{}.DeleteEventJSON()
+	req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
+	req.Header.Add("X-Github-Event", "delete")
+	w := httptest.NewRecorder()
+	gh.eventHandler(w, req)
+	if w.Code != http.StatusOK {
+		t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
+	}
+}
+
+func TestDeploymentEvent(t *testing.T) {
+	gh := NewGHWebhooks()
+	jsonString := mod.Mock{}.DeploymentEventJSON()
+	req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
+	req.Header.Add("X-Github-Event", "deployment")
+	w := httptest.NewRecorder()
+	gh.eventHandler(w, req)
+	if w.Code != http.StatusOK {
+		t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
+	}
+}
+
+func TestDeploymentStatusEvent(t *testing.T) {
+	gh := NewGHWebhooks()
+	jsonString := mod.Mock{}.DeploymentStatusEventJSON()
+	req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
+	req.Header.Add("X-Github-Event", "deployment_status")
+	w := httptest.NewRecorder()
+	gh.eventHandler(w, req)
+	if w.Code != http.StatusOK {
+		t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
+	}
+}
+
+func TestForkEvent(t *testing.T) {
+	gh := NewGHWebhooks()
+	jsonString := mod.Mock{}.ForkEventJSON()
+	req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
+	req.Header.Add("X-Github-Event", "fork")
+	w := httptest.NewRecorder()
+	gh.eventHandler(w, req)
+	if w.Code != http.StatusOK {
+		t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
+	}
+}
+
+func TestGollumEvent(t *testing.T) {
+	gh := NewGHWebhooks()
+	jsonString := mod.Mock{}.GollumEventJSON()
+	req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
+	req.Header.Add("X-Github-Event", "gollum")
+	w := httptest.NewRecorder()
+	gh.eventHandler(w, req)
+	if w.Code != http.StatusOK {
+		t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
+	}
+}
+
+func TestIssueCommentEvent(t *testing.T) {
+	gh := NewGHWebhooks()
+	jsonString := mod.Mock{}.IssueCommentEventJSON()
+	req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
+	req.Header.Add("X-Github-Event", "issue_comment")
+	w := httptest.NewRecorder()
+	gh.eventHandler(w, req)
+	if w.Code != http.StatusOK {
+		t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
+	}
+}
+
+func TestIssuesEvent(t *testing.T) {
+	gh := NewGHWebhooks()
+	jsonString := mod.Mock{}.IssuesEventJSON()
+	req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
+	req.Header.Add("X-Github-Event", "issues")
+	w := httptest.NewRecorder()
+	gh.eventHandler(w, req)
+	if w.Code != http.StatusOK {
+		t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
+	}
+}
+
+func TestMemberEvent(t *testing.T) {
+	gh := NewGHWebhooks()
+	jsonString := mod.Mock{}.MemberEventJSON()
+	req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
+	req.Header.Add("X-Github-Event", "member")
+	w := httptest.NewRecorder()
+	gh.eventHandler(w, req)
+	if w.Code != http.StatusOK {
+		t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
+	}
+}
+
+func TestMembershipEvent(t *testing.T) {
+	gh := NewGHWebhooks()
+	jsonString := mod.Mock{}.MembershipEventJSON()
+	req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
+	req.Header.Add("X-Github-Event", "membership")
+	w := httptest.NewRecorder()
+	gh.eventHandler(w, req)
+	if w.Code != http.StatusOK {
+		t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
+	}
+}
+
+func TestPageBuildEvent(t *testing.T) {
+	gh := NewGHWebhooks()
+	jsonString := mod.Mock{}.PageBuildEventJSON()
+	req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
+	req.Header.Add("X-Github-Event", "page_build")
+	w := httptest.NewRecorder()
+	gh.eventHandler(w, req)
+	if w.Code != http.StatusOK {
+		t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
+	}
+}
+
+func TestPublicEvent(t *testing.T) {
+	gh := NewGHWebhooks()
+	jsonString := mod.Mock{}.PublicEventJSON()
+	req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
+	req.Header.Add("X-Github-Event", "public")
+	w := httptest.NewRecorder()
+	gh.eventHandler(w, req)
+	if w.Code != http.StatusOK {
+		t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
+	}
+}
+
+func TestPullRequestReviewCommentEvent(t *testing.T) {
+	gh := NewGHWebhooks()
+	jsonString := mod.Mock{}.PullRequestReviewCommentEventJSON()
+	req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
+	req.Header.Add("X-Github-Event", "pull_request_review_comment")
+	w := httptest.NewRecorder()
+	gh.eventHandler(w, req)
+	if w.Code != http.StatusOK {
+		t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
+	}
+}
+
+func TestPushEvent(t *testing.T) {
+	gh := NewGHWebhooks()
+	jsonString := mod.Mock{}.PushEventJSON()
+	req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
+	req.Header.Add("X-Github-Event", "push")
+	w := httptest.NewRecorder()
+	gh.eventHandler(w, req)
+	if w.Code != http.StatusOK {
+		t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
+	}
+}
+
+func TestReleaseEvent(t *testing.T) {
+	gh := NewGHWebhooks()
+	jsonString := mod.Mock{}.ReleaseEventJSON()
+	req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
+	req.Header.Add("X-Github-Event", "release")
+	w := httptest.NewRecorder()
+	gh.eventHandler(w, req)
+	if w.Code != http.StatusOK {
+		t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
+	}
+}
+
+func TestRepositoryEvent(t *testing.T) {
+	gh := NewGHWebhooks()
+	jsonString := mod.Mock{}.RepositoryEventJSON()
+	req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
+	req.Header.Add("X-Github-Event", "repository")
+	w := httptest.NewRecorder()
+	gh.eventHandler(w, req)
+	if w.Code != http.StatusOK {
+		t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
+	}
+}
+
+func TestStatusEvent(t *testing.T) {
+	gh := NewGHWebhooks()
+	jsonString := mod.Mock{}.StatusEventJSON()
+	req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
+	req.Header.Add("X-Github-Event", "status")
+	w := httptest.NewRecorder()
+	gh.eventHandler(w, req)
+	if w.Code != http.StatusOK {
+		t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
+	}
+}
+
+func TestTeamAddEvent(t *testing.T) {
+	gh := NewGHWebhooks()
+	jsonString := mod.Mock{}.TeamAddEventJSON()
+	req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
+	req.Header.Add("X-Github-Event", "team_add")
+	w := httptest.NewRecorder()
+	gh.eventHandler(w, req)
+	if w.Code != http.StatusOK {
+		t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
+	}
+}
+
+func TestWatchEvent(t *testing.T) {
+	gh := NewGHWebhooks()
+	jsonString := mod.Mock{}.WatchEventJSON()
+	req, _ := http.NewRequest("POST", "/", strings.NewReader(jsonString))
+	req.Header.Add("X-Github-Event", "watch")
+	w := httptest.NewRecorder()
+	gh.eventHandler(w, req)
+	if w.Code != http.StatusOK {
+		t.Errorf("POST commit_comment returned HTTP status code %v.\nExpected %v", w.Code, http.StatusOK)
+	}
+}

plugins/inputs/ghwebhooks/models/models.go

@@ -2,16 +2,17 @@ package models
 
 import (
 	"fmt"
+	"log"
 	"time"
 
-	log "github.com/Sirupsen/logrus"
 	"github.com/influxdata/influxdb/client/v2"
 )
 
-const Measurement = "ghWebhooks"
+const meas = "ghWebhooks"
 
 type Event interface {
 	NewPoint() *client.Point
+	JSON() string
 }
 
 type Repository struct {
@@ -106,11 +107,9 @@ func (s CommitCommentEvent) NewPoint() *client.Point {
 		"commit":  s.Comment.Commit,
 		"comment": s.Comment.Body,
 	}
-	time := time.Now()
-	p, err := client.NewPoint(Measurement, t, f, time)
+	p, err := client.NewPoint(meas, t, f, time.Now())
 	if err != nil {
-		i := log.Fields{"event": event, "error": err}
-		log.WithFields(i).Fatal("Error creating new point...")
+		log.Fatalf("Failed to create %v event", event)
 	}
 	return p
 }
@@ -138,11 +137,9 @@ func (s CreateEvent) NewPoint() *client.Point {
 		"ref":     s.Ref,
 		"refType": s.RefType,
 	}
-	time := time.Now()
-	p, err := client.NewPoint(Measurement, t, f, time)
+	p, err := client.NewPoint(meas, t, f, time.Now())
 	if err != nil {
-		i := log.Fields{"event": event, "error": err}
-		log.WithFields(i).Fatal("Error creating new point...")
+		log.Fatalf("Failed to create %v event", event)
 	}
 	return p
 }
@@ -170,11 +167,9 @@ func (s DeleteEvent) NewPoint() *client.Point {
 		"ref":     s.Ref,
 		"refType": s.RefType,
 	}
-	time := time.Now()
-	p, err := client.NewPoint(Measurement, t, f, time)
+	p, err := client.NewPoint(meas, t, f, time.Now())
 	if err != nil {
-		i := log.Fields{"event": event, "error": err}
-		log.WithFields(i).Fatal("Error creating new point...")
+		log.Fatalf("Failed to create %v event", event)
 	}
 	return p
 }
@@ -203,11 +198,9 @@ func (s DeploymentEvent) NewPoint() *client.Point {
 		"environment": s.Deployment.Environment,
 		"description": s.Deployment.Description,
 	}
-	time := time.Now()
-	p, err := client.NewPoint(Measurement, t, f, time)
+	p, err := client.NewPoint(meas, t, f, time.Now())
 	if err != nil {
-		i := log.Fields{"event": event, "error": err}
-		log.WithFields(i).Fatal("Error creating new point...")
+		log.Fatalf("Failed to create %v event", event)
 	}
 	return p
 }
@@ -239,11 +232,9 @@ func (s DeploymentStatusEvent) NewPoint() *client.Point {
 		"depState":       s.DeploymentStatus.State,
 		"depDescription": s.DeploymentStatus.Description,
 	}
-	time := time.Now()
-	p, err := client.NewPoint(Measurement, t, f, time)
+	p, err := client.NewPoint(meas, t, f, time.Now())
 	if err != nil {
-		i := log.Fields{"event": event, "error": err}
-		log.WithFields(i).Fatal("Error creating new point...")
+		log.Fatalf("Failed to create %v event", event)
 	}
 	return p
 }
@@ -269,11 +260,9 @@ func (s ForkEvent) NewPoint() *client.Point {
 		"issues": s.Repository.Issues,
 		"fork":   s.Forkee.Repository,
 	}
-	time := time.Now()
-	p, err := client.NewPoint(Measurement, t, f, time)
+	p, err := client.NewPoint(meas, t, f, time.Now())
 	if err != nil {
-		i := log.Fields{"event": event, "error": err}
-		log.WithFields(i).Fatal("Error creating new point...")
+		log.Fatalf("Failed to create %v event", event)
 	}
 	return p
 }
@@ -299,11 +288,9 @@ func (s GollumEvent) NewPoint() *client.Point {
 		"forks":  s.Repository.Forks,
 		"issues": s.Repository.Issues,
 	}
-	time := time.Now()
-	p, err := client.NewPoint(Measurement, t, f, time)
+	p, err := client.NewPoint(meas, t, f, time.Now())
 	if err != nil {
-		i := log.Fields{"event": event, "error": err}
-		log.WithFields(i).Fatal("Error creating new point...")
+		log.Fatalf("Failed to create %v event", event)
 	}
 	return p
 }
@@ -333,11 +320,9 @@ func (s IssueCommentEvent) NewPoint() *client.Point {
 		"comments": s.Issue.Comments,
 		"body":     s.Comment.Body,
 	}
-	time := time.Now()
-	p, err := client.NewPoint(Measurement, t, f, time)
+	p, err := client.NewPoint(meas, t, f, time.Now())
 	if err != nil {
-		i := log.Fields{"event": event, "error": err}
-		log.WithFields(i).Fatal("Error creating new point...")
+		log.Fatalf("Failed to create %v event", event)
 	}
 	return p
 }
@@ -367,11 +352,9 @@ func (s IssuesEvent) NewPoint() *client.Point {
 		"title":    s.Issue.Title,
 		"comments": s.Issue.Comments,
 	}
-	time := time.Now()
-	p, err := client.NewPoint(Measurement, t, f, time)
+	p, err := client.NewPoint(meas, t, f, time.Now())
 	if err != nil {
-		i := log.Fields{"event": event, "error": err}
-		log.WithFields(i).Fatal("Error creating new point...")
+		log.Fatalf("Failed to create %v event", event)
 	}
 	return p
 }
@@ -398,11 +381,9 @@ func (s MemberEvent) NewPoint() *client.Point {
 		"newMember":       s.Member.User,
 		"newMemberStatus": s.Member.Admin,
 	}
-	time := time.Now()
-	p, err := client.NewPoint(Measurement, t, f, time)
+	p, err := client.NewPoint(meas, t, f, time.Now())
 	if err != nil {
-		i := log.Fields{"event": event, "error": err}
-		log.WithFields(i).Fatal("Error creating new point...")
+		log.Fatalf("Failed to create %v event", event)
 	}
 	return p
 }
@@ -426,11 +407,9 @@ func (s MembershipEvent) NewPoint() *client.Point {
 		"newMember":       s.Member.User,
 		"newMemberStatus": s.Member.Admin,
 	}
-	time := time.Now()
-	p, err := client.NewPoint(Measurement, t, f, time)
+	p, err := client.NewPoint(meas, t, f, time.Now())
 	if err != nil {
-		i := log.Fields{"event": event, "error": err}
-		log.WithFields(i).Fatal("Error creating new point...")
+		log.Fatalf("Failed to create %v event", event)
 	}
 	return p
 }
@@ -454,11 +433,9 @@ func (s PageBuildEvent) NewPoint() *client.Point {
 		"forks":  s.Repository.Forks,
 		"issues": s.Repository.Issues,
 	}
-	time := time.Now()
-	p, err := client.NewPoint(Measurement, t, f, time)
+	p, err := client.NewPoint(meas, t, f, time.Now())
 	if err != nil {
-		i := log.Fields{"event": event, "error": err}
-		log.WithFields(i).Fatal("Error creating new point...")
+		log.Fatalf("Failed to create %v event", event)
 	}
 	return p
 }
@@ -482,11 +459,9 @@ func (s PublicEvent) NewPoint() *client.Point {
 		"forks":  s.Repository.Forks,
 		"issues": s.Repository.Issues,
 	}
-	time := time.Now()
-	p, err := client.NewPoint(Measurement, t, f, time)
+	p, err := client.NewPoint(meas, t, f, time.Now())
 	if err != nil {
-		i := log.Fields{"event": event, "error": err}
-		log.WithFields(i).Fatal("Error creating new point...")
+		log.Fatalf("Failed to create %v event", event)
 	}
 	return p
 }
@@ -521,11 +496,9 @@ func (s PullRequestEvent) NewPoint() *client.Point {
 		"deletions":    s.PullRequest.Deletions,
 		"changedFiles": s.PullRequest.ChangedFiles,
 	}
-	time := time.Now()
-	p, err := client.NewPoint(Measurement, t, f, time)
+	p, err := client.NewPoint(meas, t, f, time.Now())
 	if err != nil {
-		i := log.Fields{"event": event, "error": err}
-		log.WithFields(i).Fatal("Error creating new point...")
+		log.Fatalf("Failed to create %v event", event)
 	}
 	return p
 }
@@ -561,11 +534,9 @@ func (s PullRequestReviewCommentEvent) NewPoint() *client.Point {
 		"commentFile":  s.Comment.File,
 		"comment":      s.Comment.Comment,
 	}
-	time := time.Now()
-	p, err := client.NewPoint(Measurement, t, f, time)
+	p, err := client.NewPoint(meas, t, f, time.Now())
 	if err != nil {
-		i := log.Fields{"event": event, "error": err}
-		log.WithFields(i).Fatal("Error creating new point...")
+		log.Fatalf("Failed to create %v event", event)
 	}
 	return p
 }
@@ -595,11 +566,9 @@ func (s PushEvent) NewPoint() *client.Point {
 		"Before": s.Before,
 		"After":  s.After,
 	}
-	time := time.Now()
-	p, err := client.NewPoint(Measurement, t, f, time)
+	p, err := client.NewPoint(meas, t, f, time.Now())
 	if err != nil {
-		i := log.Fields{"event": event, "error": err}
-		log.WithFields(i).Fatal("Error creating new point...")
+		log.Fatalf("Failed to create %v event", event)
 	}
 	return p
 }
@@ -625,11 +594,9 @@ func (s ReleaseEvent) NewPoint() *client.Point {
 		"issues":  s.Repository.Issues,
 		"tagName": s.Release.TagName,
 	}
-	time := time.Now()
-	p, err := client.NewPoint(Measurement, t, f, time)
+	p, err := client.NewPoint(meas, t, f, time.Now())
 	if err != nil {
-		i := log.Fields{"event": event, "error": err}
-		log.WithFields(i).Fatal("Error creating new point...")
+		log.Fatalf("Failed to create %v event", event)
 	}
 	return p
 }
@@ -653,11 +620,9 @@ func (s RepositoryEvent) NewPoint() *client.Point {
 		"forks":  s.Repository.Forks,
 		"issues": s.Repository.Issues,
 	}
-	time := time.Now()
-	p, err := client.NewPoint(Measurement, t, f, time)
+	p, err := client.NewPoint(meas, t, f, time.Now())
 	if err != nil {
-		i := log.Fields{"event": event, "error": err}
-		log.WithFields(i).Fatal("Error creating new point...")
+		log.Fatalf("Failed to create %v event", event)
 	}
 	return p
 }
@@ -685,11 +650,9 @@ func (s StatusEvent) NewPoint() *client.Point {
 		"commit": s.Commit,
 		"state":  s.State,
 	}
-	time := time.Now()
-	p, err := client.NewPoint(Measurement, t, f, time)
+	p, err := client.NewPoint(meas, t, f, time.Now())
 	if err != nil {
-		i := log.Fields{"event": event, "error": err}
-		log.WithFields(i).Fatal("Error creating new point...")
+		log.Fatalf("Failed to create %v event", event)
 	}
 	return p
 }
@@ -715,11 +678,9 @@ func (s TeamAddEvent) NewPoint() *client.Point {
 		"issues":   s.Repository.Issues,
 		"teamName": s.Team.Name,
 	}
-	time := time.Now()
-	p, err := client.NewPoint(Measurement, t, f, time)
+	p, err := client.NewPoint(meas, t, f, time.Now())
 	if err != nil {
-		i := log.Fields{"event": event, "error": err}
-		log.WithFields(i).Fatal("Error creating new point...")
+		log.Fatalf("Failed to create %v event", event)
 	}
 	return p
 }
@@ -743,11 +704,9 @@ func (s WatchEvent) NewPoint() *client.Point {
 		"forks":  s.Repository.Forks,
 		"issues": s.Repository.Issues,
 	}
-	time := time.Now()
-	p, err := client.NewPoint(Measurement, t, f, time)
+	p, err := client.NewPoint(meas, t, f, time.Now())
 	if err != nil {
-		i := log.Fields{"event": event, "error": err}
-		log.WithFields(i).Fatal("Error creating new point...")
+		log.Fatalf("Failed to create %v event", event)
 	}
 	return p
 }