Dean Karn
1108 lines
31 KiB
Go
1108 lines
31 KiB
Go
package github
|
|
|
|
import (
|
|
"bytes"
|
|
"log"
|
|
"net/http"
|
|
"net/http/httptest"
|
|
"os"
|
|
"testing"
|
|
|
|
. "gopkg.in/go-playground/assert.v1"
|
|
)
|
|
|
|
// NOTES:
|
|
// - Run "go test" to run tests
|
|
// - Run "gocov test | gocov report" to report on test converage by file
|
|
// - Run "gocov test | gocov annotate -" to report on all code and functions, those ,marked with "MISS" were never called
|
|
//
|
|
// or
|
|
//
|
|
// -- may be a good idea to change to output path to somewherelike /tmp
|
|
// go test -coverprofile cover.out && go tool cover -html=cover.out -o cover.html
|
|
//
|
|
|
|
const (
|
|
path = "/webhooks"
|
|
)
|
|
|
|
var hook *Webhook
|
|
|
|
func TestMain(m *testing.M) {
|
|
|
|
// setup
|
|
var err error
|
|
hook, err = New(Options.Secret("IsWishesWereHorsesWedAllBeEatingSteak!"))
|
|
if err != nil {
|
|
log.Fatal(err)
|
|
}
|
|
os.Exit(m.Run())
|
|
// teardown
|
|
}
|
|
|
|
func newServer(handler http.HandlerFunc) *httptest.Server {
|
|
mux := http.NewServeMux()
|
|
mux.HandleFunc(path, handler)
|
|
return httptest.NewServer(mux)
|
|
}
|
|
|
|
func TestBadNoEventHeader(t *testing.T) {
|
|
payload := "{}"
|
|
|
|
var parseError error
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
_, parseError = hook.Parse(r, CreateEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
|
|
Equal(t, err, nil)
|
|
|
|
req.Header.Set("Content-Type", "application/json")
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, ErrMissingGithubEventHeader)
|
|
}
|
|
|
|
func TestUnsubscribedEvent(t *testing.T) {
|
|
payload := "{}"
|
|
|
|
var parseError error
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
_, parseError = hook.Parse(r, CreateEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
|
|
Equal(t, err, nil)
|
|
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "noneexistant_event")
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, ErrEventNotFound)
|
|
}
|
|
|
|
func TestBadBody(t *testing.T) {
|
|
payload := ""
|
|
var parseError error
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
_, parseError = hook.Parse(r, CommitCommentEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "commit_comment")
|
|
req.Header.Set("X-Hub-Signature", "sha1=156404ad5f721c53151147f3d3d302329f95a3ab")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, ErrParsingPayload)
|
|
}
|
|
|
|
func TestBadSignatureLength(t *testing.T) {
|
|
payload := "{}"
|
|
|
|
var parseError error
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
_, parseError = hook.Parse(r, CommitCommentEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "commit_comment")
|
|
req.Header.Set("X-Hub-Signature", "")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, ErrMissingHubSignatureHeader)
|
|
}
|
|
|
|
func TestBadSignatureMatch(t *testing.T) {
|
|
payload := "{}"
|
|
|
|
var parseError error
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
_, parseError = hook.Parse(r, CommitCommentEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, bytes.NewBuffer([]byte(payload)))
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "commit_comment")
|
|
req.Header.Set("X-Hub-Signature", "sha1=111")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, ErrHMACVerificationFailed)
|
|
}
|
|
|
|
func TestCommitCommentEvent(t *testing.T) {
|
|
payload, err := os.Open("../testdata/github/commit-comment.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, CommitCommentEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "commit_comment")
|
|
req.Header.Set("X-Hub-Signature", "sha1=156404ad5f721c53151147f3d3d302329f95a3ab")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(CommitCommentPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestCreateEvent(t *testing.T) {
|
|
|
|
payload, err := os.Open("../testdata/github/create.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, CreateEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "create")
|
|
req.Header.Set("X-Hub-Signature", "sha1=77ff16ca116034bbeed77ebfce83b36572a9cbaf")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(CreatePayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestDeleteEvent(t *testing.T) {
|
|
payload, err := os.Open("../testdata/github/delete.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, DeleteEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "delete")
|
|
req.Header.Set("X-Hub-Signature", "sha1=4ddef04fd05b504c7041e294fca3ad1804bc7be1")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(DeletePayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestDeploymentEvent(t *testing.T) {
|
|
payload, err := os.Open("../testdata/github/deployment.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, DeploymentEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "deployment")
|
|
req.Header.Set("X-Hub-Signature", "sha1=bb47dc63ceb764a6b1f14fe123e299e5b814c67c")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(DeploymentPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestDeploymentStatusEvent(t *testing.T) {
|
|
payload, err := os.Open("../testdata/github/deployment-status.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, DeploymentStatusEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "deployment_status")
|
|
req.Header.Set("X-Hub-Signature", "sha1=1b2ce08e0c3487fdf22bed12c63dc734cf6dc8a4")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(DeploymentStatusPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestForkEvent(t *testing.T) {
|
|
payload, err := os.Open("../testdata/github/fork.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, ForkEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "fork")
|
|
req.Header.Set("X-Hub-Signature", "sha1=cec5f8fb7c383514c622d3eb9e121891dfcca848")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(ForkPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestGollumEvent(t *testing.T) {
|
|
payload, err := os.Open("../testdata/github/gollum.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, GollumEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "gollum")
|
|
req.Header.Set("X-Hub-Signature", "sha1=a375a6dc8ceac7231ee022211f8eb85e2a84a5b9")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(GollumPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestInstallationEvent(t *testing.T) {
|
|
payload, err := os.Open("../testdata/github/installation.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, InstallationEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "installation")
|
|
req.Header.Set("X-Hub-Signature", "sha1=2058cf6cc28570710afbc638e669f5c67305a2db")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(InstallationPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestIntegrationInstallationEvent(t *testing.T) {
|
|
payload, err := os.Open("../testdata/github/integration-installation.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, IntegrationInstallationEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "integration_installation")
|
|
req.Header.Set("X-Hub-Signature", "sha1=bb2769f05f1a11af3a1edf8f9fac11bae7402a1e")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(InstallationPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestIssueCommentEvent(t *testing.T) {
|
|
payload, err := os.Open("../testdata/github/issue-comment.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, IssueCommentEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "issue_comment")
|
|
req.Header.Set("X-Hub-Signature", "sha1=e724c9f811fcf5f511aac32e4251b08ab1a0fd87")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(IssueCommentPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestIssuesEvent(t *testing.T) {
|
|
payload, err := os.Open("../testdata/github/issues.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, IssuesEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "issues")
|
|
req.Header.Set("X-Hub-Signature", "sha1=dfc9a3428f3df86e4ecd78e34b41c55bba5d0b21")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(IssuesPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestLabelEvent(t *testing.T) {
|
|
|
|
payload, err := os.Open("../testdata/github/label.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, LabelEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "label")
|
|
req.Header.Set("X-Hub-Signature", "sha1=efc13e7ad816235222e4a6b3f96d3fd1e162dbd4")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(LabelPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestMemberEvent(t *testing.T) {
|
|
payload, err := os.Open("../testdata/github/member.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, MemberEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "member")
|
|
req.Header.Set("X-Hub-Signature", "sha1=597e7d6627a6636d4c3283e36631983fbd57bdd0")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(MemberPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestMembershipEvent(t *testing.T) {
|
|
|
|
payload, err := os.Open("../testdata/github/membership.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, MembershipEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "membership")
|
|
req.Header.Set("X-Hub-Signature", "sha1=16928c947b3707b0efcf8ceb074a5d5dedc9c76e")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(MembershipPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestMilestoneEvent(t *testing.T) {
|
|
|
|
payload, err := os.Open("../testdata/github/milestone.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, MilestoneEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "milestone")
|
|
req.Header.Set("X-Hub-Signature", "sha1=8b63f58ea58e6a59dcfc5ecbaea0d1741a6bf9ec")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(MilestonePayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestOrganizationEvent(t *testing.T) {
|
|
|
|
payload, err := os.Open("../testdata/github/organization.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, OrganizationEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "organization")
|
|
req.Header.Set("X-Hub-Signature", "sha1=7e5ad88557be0a05fb89e86c7893d987386aa0d5")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(OrganizationPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestOrgBlockEvent(t *testing.T) {
|
|
|
|
payload, err := os.Open("../testdata/github/org-block.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, OrgBlockEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "org_block")
|
|
req.Header.Set("X-Hub-Signature", "sha1=21fe61da3f014c011edb60b0b9dfc9aa7059a24b")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(OrgBlockPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestPageBuildEvent(t *testing.T) {
|
|
|
|
payload, err := os.Open("../testdata/github/page-build.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, PageBuildEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "page_build")
|
|
req.Header.Set("X-Hub-Signature", "sha1=b3abad8f9c1b3fc0b01c4eb107447800bb5000f9")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(PageBuildPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestPingEvent(t *testing.T) {
|
|
|
|
payload, err := os.Open("../testdata/github/ping.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, PingEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "ping")
|
|
req.Header.Set("X-Hub-Signature", "sha1=f80e1cfc04245b65228b86612119ab5c894133c2")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(PingPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestProjectCardEvent(t *testing.T) {
|
|
|
|
payload, err := os.Open("../testdata/github/project-card.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, ProjectCardEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "project_card")
|
|
req.Header.Set("X-Hub-Signature", "sha1=495dec0d6449d16b71f2ddcd37d595cb9b04b1d8")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(ProjectCardPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestProjectColumnEvent(t *testing.T) {
|
|
|
|
payload, err := os.Open("../testdata/github/project-column.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, ProjectColumnEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "project_column")
|
|
req.Header.Set("X-Hub-Signature", "sha1=7d5dd49d9863e982a4f577170717ea8350a69db0")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(ProjectColumnPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestProjectEvent(t *testing.T) {
|
|
|
|
payload, err := os.Open("../testdata/github/project.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, ProjectEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "project")
|
|
req.Header.Set("X-Hub-Signature", "sha1=7295ab4f205434208f1b86edf2b55adae34c6c92")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(ProjectPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestPublicEvent(t *testing.T) {
|
|
|
|
payload, err := os.Open("../testdata/github/public.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, PublicEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "public")
|
|
req.Header.Set("X-Hub-Signature", "sha1=73edb2a8c69c1ac35efb797ede3dc2cde618c10c")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(PublicPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestPullRequestEvent(t *testing.T) {
|
|
|
|
payload, err := os.Open("../testdata/github/pull-request.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, PullRequestEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "pull_request")
|
|
req.Header.Set("X-Hub-Signature", "sha1=35712c8d2bc197b7d07621dcf20d2fb44620508f")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(PullRequestPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestPullRequestReviewEvent(t *testing.T) {
|
|
|
|
payload, err := os.Open("../testdata/github/pull-request-review.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, PullRequestReviewEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "pull_request_review")
|
|
req.Header.Set("X-Hub-Signature", "sha1=55345ce92be7849f97d39b9426b95261d4bd4465")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(PullRequestReviewPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestPullRequestReviewCommentEvent(t *testing.T) {
|
|
|
|
payload, err := os.Open("../testdata/github/pull-request-review-comment.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, PullRequestReviewCommentEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "pull_request_review_comment")
|
|
req.Header.Set("X-Hub-Signature", "sha1=a9ece15dbcbb85fa5f00a0bf409494af2cbc5b60")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(PullRequestReviewCommentPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestPushEvent(t *testing.T) {
|
|
|
|
payload, err := os.Open("../testdata/github/push.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, PushEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "push")
|
|
req.Header.Set("X-Hub-Signature", "sha1=0534736f52c2fc5896ef1bd5a043127b20d233ba")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(PushPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestReleaseEvent(t *testing.T) {
|
|
|
|
payload, err := os.Open("../testdata/github/release.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, ReleaseEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "release")
|
|
req.Header.Set("X-Hub-Signature", "sha1=e62bb4c51bc7dde195b9525971c2e3aecb394390")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(ReleasePayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestRepositoryEvent(t *testing.T) {
|
|
|
|
payload, err := os.Open("../testdata/github/repository.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, RepositoryEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "repository")
|
|
req.Header.Set("X-Hub-Signature", "sha1=df442a8af41edd2d42ccdd997938d1d111b0f94e")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(RepositoryPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestStatusEvent(t *testing.T) {
|
|
|
|
payload, err := os.Open("../testdata/github/status.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, StatusEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "status")
|
|
req.Header.Set("X-Hub-Signature", "sha1=3caa5f062a2deb7cce1482314bb9b4c99bf0ab45")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(StatusPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestTeamEvent(t *testing.T) {
|
|
|
|
payload, err := os.Open("../testdata/github/team.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, TeamEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "team")
|
|
req.Header.Set("X-Hub-Signature", "sha1=ff5b5d58faec10bd40fc96834148df408e7a4608")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(TeamPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestTeamAddEvent(t *testing.T) {
|
|
|
|
payload, err := os.Open("../testdata/github/team-add.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, TeamAddEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "team_add")
|
|
req.Header.Set("X-Hub-Signature", "sha1=5f3953476e270b79cc6763780346110da880609a")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(TeamAddPayload)
|
|
Equal(t, ok, true)
|
|
}
|
|
|
|
func TestWatchEvent(t *testing.T) {
|
|
|
|
payload, err := os.Open("../testdata/github/watch.json")
|
|
Equal(t, err, nil)
|
|
|
|
var parseError error
|
|
var results interface{}
|
|
server := newServer(func(w http.ResponseWriter, r *http.Request) {
|
|
results, parseError = hook.Parse(r, WatchEvent)
|
|
})
|
|
defer server.Close()
|
|
|
|
req, err := http.NewRequest(http.MethodPost, server.URL+path, payload)
|
|
Equal(t, err, nil)
|
|
req.Header.Set("Content-Type", "application/json")
|
|
req.Header.Set("X-Github-Event", "watch")
|
|
req.Header.Set("X-Hub-Signature", "sha1=a317bcfe69ccb8bece74c20c7378e5413c4772f1")
|
|
|
|
Equal(t, err, nil)
|
|
|
|
client := &http.Client{}
|
|
resp, err := client.Do(req)
|
|
Equal(t, err, nil)
|
|
Equal(t, resp.StatusCode, http.StatusOK)
|
|
Equal(t, parseError, nil)
|
|
_, ok := results.(WatchPayload)
|
|
Equal(t, ok, true)
|
|
}
|