Skip to content

Commit

Permalink
add tests
Browse files Browse the repository at this point in the history
  • Loading branch information
@zetaab
zetaab committed Jun 7, 2023
1 parent 1d4b344 commit 111932a
Show file tree
Hide file tree
Showing 3 changed files with 412 additions and 1 deletion.
5 changes: 4 additions & 1 deletion gin/sentrygin.go
View file
Original file line number Diff line number Diff line change
Expand Up @@ -64,7 +64,10 @@ func (h *handler) handle(c *gin.Context) {
fmt.Sprintf("%s %s", c.Request.Method, c.Request.URL.Path),
options...,
)
defer transaction.Finish()
defer func() {
transaction.Status = sentry.HTTPtoSpanStatus(c.Writer.Status())
transaction.Finish()
}()

c.Request = c.Request.WithContext(transaction.Context())
hub.Scope().SetRequest(c.Request)
Expand Down
371 changes: 371 additions & 0 deletions gin/sentrygin_test.go
View file
Original file line number Diff line number Diff line change
@@ -0,0 +1,371 @@
package sentrygin_test

import (
"fmt"
"io"
"net/http"
"net/http/httptest"
"strconv"
"strings"
"testing"
"time"

"github.com/getsentry/sentry-go"
sentrygin "github.com/getsentry/sentry-go/gin"
"github.com/gin-gonic/gin"
"github.com/google/go-cmp/cmp"
"github.com/google/go-cmp/cmp/cmpopts"
)

func TestIntegration(t *testing.T) {
largePayload := strings.Repeat("Large", 3*1024) // 15 KB

tests := []struct {
Path string
Method string
WantStatus int
Body string
Handler gin.HandlerFunc

WantEvent *sentry.Event
WantTransaction *sentry.Event
}{
{
Path: "/panic",
Method: "GET",
WantStatus: 200,
Handler: func(c *gin.Context) {
panic("test")
},
WantTransaction: &sentry.Event{
Level: sentry.LevelInfo,
Type: "transaction",
Transaction: "GET /panic",
Request: &sentry.Request{
URL: "/panic",
Method: "GET",
Headers: map[string]string{
"Accept-Encoding": "gzip",
"User-Agent": "Go-http-client/1.1",
},
},
TransactionInfo: &sentry.TransactionInfo{Source: "url"},
},
WantEvent: &sentry.Event{
Level: sentry.LevelFatal,
Message: "test",
Request: &sentry.Request{
URL: "/panic",
Method: "GET",
Headers: map[string]string{
"Accept-Encoding": "gzip",
"User-Agent": "Go-http-client/1.1",
},
},
},
},
{
Path: "/post",
Method: "POST",
WantStatus: 200,
Body: "payload",
Handler: func(c *gin.Context) {
hub := sentry.GetHubFromContext(c.Request.Context())
body, err := io.ReadAll(c.Request.Body)
if err != nil {
t.Error(err)
}
hub.CaptureMessage("post: " + string(body))
c.JSON(http.StatusOK, gin.H{"status": "ok"})
},
WantTransaction: &sentry.Event{
Level: sentry.LevelInfo,
Type: "transaction",
Transaction: "POST /post",
Request: &sentry.Request{
URL: "/post",
Method: "POST",
Data: "payload",
Headers: map[string]string{
"Content-Length": "7",
"Accept-Encoding": "gzip",
"User-Agent": "Go-http-client/1.1",
},
},
TransactionInfo: &sentry.TransactionInfo{Source: "url"},
},
WantEvent: &sentry.Event{
Level: sentry.LevelInfo,
Message: "post: payload",
Request: &sentry.Request{
URL: "/post",
Method: "POST",
Data: "payload",
Headers: map[string]string{
"Accept-Encoding": "gzip",
"Content-Length": "7",
"User-Agent": "Go-http-client/1.1",
},
},
},
},
{
Path: "/get",
Method: "GET",
WantStatus: 200,
Handler: func(c *gin.Context) {
hub := sentry.GetHubFromContext(c.Request.Context())
hub.CaptureMessage("get")
c.JSON(http.StatusOK, gin.H{"status": "get"})
},
WantTransaction: &sentry.Event{
Level: sentry.LevelInfo,
Type: "transaction",
Transaction: "GET /get",
Request: &sentry.Request{
URL: "/get",
Method: "GET",
Headers: map[string]string{
"Accept-Encoding": "gzip",
"User-Agent": "Go-http-client/1.1",
},
},
TransactionInfo: &sentry.TransactionInfo{Source: "url"},
},
WantEvent: &sentry.Event{
Level: sentry.LevelInfo,
Message: "get",
Request: &sentry.Request{
URL: "/get",
Method: "GET",
Headers: map[string]string{
"Accept-Encoding": "gzip",
"User-Agent": "Go-http-client/1.1",
},
},
},
},
{
Path: "/post/large",
Method: "POST",
WantStatus: 200,
Body: largePayload,
Handler: func(c *gin.Context) {
hub := sentry.GetHubFromContext(c.Request.Context())
body, err := io.ReadAll(c.Request.Body)
if err != nil {
t.Error(err)
}
hub.CaptureMessage(fmt.Sprintf("post: %d KB", len(body)/1024))
},
WantTransaction: &sentry.Event{
Level: sentry.LevelInfo,
Type: "transaction",
Transaction: "POST /post/large",
Request: &sentry.Request{
URL: "/post/large",
Method: "POST",
Headers: map[string]string{
"Accept-Encoding": "gzip",
"Content-Length": strconv.Itoa(len(largePayload)),
"User-Agent": "Go-http-client/1.1",
},
},
TransactionInfo: &sentry.TransactionInfo{Source: "url"},
},
WantEvent: &sentry.Event{
Level: sentry.LevelInfo,
Message: "post: 15 KB",
Request: &sentry.Request{
URL: "/post/large",
Method: "POST",
// Actual request body omitted because too large.
Data: "",
Headers: map[string]string{
"Accept-Encoding": "gzip",
"Content-Length": "15360",
"User-Agent": "Go-http-client/1.1",
},
},
},
},
{
Path: "/post/body-ignored",
Method: "POST",
WantStatus: 200,
Body: "client sends, server ignores, SDK doesn't read",
Handler: func(c *gin.Context) {
hub := sentry.GetHubFromContext(c.Request.Context())
hub.CaptureMessage("body ignored")
},
WantTransaction: &sentry.Event{
Level: sentry.LevelInfo,
Type: "transaction",
Transaction: "POST /post/body-ignored",
Request: &sentry.Request{
URL: "/post/body-ignored",
Method: "POST",
// Actual request body omitted because not read.
Data: "",
Headers: map[string]string{
"Accept-Encoding": "gzip",
"Content-Length": strconv.Itoa(len("client sends, server ignores, SDK doesn't read")),
"User-Agent": "Go-http-client/1.1",
},
},
TransactionInfo: &sentry.TransactionInfo{Source: "url"},
},
WantEvent: &sentry.Event{
Level: sentry.LevelInfo,
Message: "body ignored",
Request: &sentry.Request{
URL: "/post/body-ignored",
Method: "POST",
// Actual request body omitted because not read.
Data: "",
Headers: map[string]string{
"Accept-Encoding": "gzip",
"Content-Length": "46",
"User-Agent": "Go-http-client/1.1",
},
},
},
},
{
Path: "/badreq",
Method: "GET",
WantStatus: 400,
Handler: func(c *gin.Context) {
c.JSON(http.StatusBadRequest, gin.H{"status": "bad_request"})
},
WantTransaction: &sentry.Event{
Level: sentry.LevelInfo,
Type: "transaction",
Transaction: "GET /badreq",
Request: &sentry.Request{
URL: "/badreq",
Method: "GET",
Headers: map[string]string{
"Accept-Encoding": "gzip",
"User-Agent": "Go-http-client/1.1",
},
},
TransactionInfo: &sentry.TransactionInfo{Source: "url"},
},
WantEvent: nil,
},
}

eventsCh := make(chan *sentry.Event, len(tests))
transactionsCh := make(chan *sentry.Event, len(tests))
err := sentry.Init(sentry.ClientOptions{
EnableTracing: true,
TracesSampleRate: 1.0,
BeforeSend: func(event *sentry.Event, hint *sentry.EventHint) *sentry.Event {
eventsCh <- event
return event
},
BeforeSendTransaction: func(tx *sentry.Event, hint *sentry.EventHint) *sentry.Event {
transactionsCh <- tx
return tx
},
})
if err != nil {
t.Fatal(err)
}

router := gin.New()
router.Use(sentrygin.New(sentrygin.Options{}))

for _, tt := range tests {
router.Handle(tt.Method, tt.Path, tt.Handler)
}

srv := httptest.NewServer(router)
defer srv.Close()

c := srv.Client()
c.Timeout = time.Second

var want []*sentry.Event
var wanttrans []*sentry.Event
var wantCodes []sentry.SpanStatus
for _, tt := range tests {
if tt.WantEvent != nil && tt.WantEvent.Request != nil {
wantRequest := tt.WantEvent.Request
wantRequest.URL = srv.URL + wantRequest.URL
wantRequest.Headers["Host"] = srv.Listener.Addr().String()
want = append(want, tt.WantEvent)
}
wantTransaction := tt.WantTransaction.Request
wantTransaction.URL = srv.URL + wantTransaction.URL
wantTransaction.Headers["Host"] = srv.Listener.Addr().String()
wanttrans = append(wanttrans, tt.WantTransaction)
wantCodes = append(wantCodes, sentry.HTTPtoSpanStatus(tt.WantStatus))

req, err := http.NewRequest(tt.Method, srv.URL+tt.Path, strings.NewReader(tt.Body))
if err != nil {
t.Fatal(err)
}
res, err := c.Do(req)
if err != nil {
t.Fatal(err)
}
if res.StatusCode != tt.WantStatus {
t.Errorf("Status code = %d expected: %d", res.StatusCode, tt.WantStatus)
}
res.Body.Close()
}

if ok := sentry.Flush(time.Second); !ok {
t.Fatal("sentry.Flush timed out")
}
close(eventsCh)
var got []*sentry.Event
for e := range eventsCh {
got = append(got, e)
}
opts := cmp.Options{
cmpopts.IgnoreFields(
sentry.Event{},
"Contexts", "EventID", "Extra", "Platform", "Modules",
"Release", "Sdk", "ServerName", "Tags", "Timestamp",
"sdkMetaData",
),
cmpopts.IgnoreFields(
sentry.Request{},
"Env",
),
}
if diff := cmp.Diff(want, got, opts); diff != "" {
t.Fatalf("Events mismatch (-want +got):\n%s", diff)
}

close(transactionsCh)
var gott []*sentry.Event
var statusCodes []sentry.SpanStatus
for e := range transactionsCh {
gott = append(gott, e)
statusCodes = append(statusCodes, e.Contexts["trace"]["status"].(sentry.SpanStatus))
}

optstrans := cmp.Options{
cmpopts.IgnoreFields(
sentry.Event{},
"Contexts", "EventID", "Platform", "Modules",
"Release", "Sdk", "ServerName", "Timestamp",
"sdkMetaData", "StartTime", "Spans",
),
cmpopts.IgnoreFields(
sentry.Request{},
"Env",
),
}
if diff := cmp.Diff(wanttrans, gott, optstrans); diff != "" {
t.Fatalf("Transaction mismatch (-want +got):\n%s", diff)
}

if diff := cmp.Diff(wantCodes, statusCodes, cmp.Options{}); diff != "" {
t.Fatalf("Transaction status codes mismatch (-want +got):\n%s", diff)
}
}
Loading

0 comments on commit 111932a

Please sign in to comment.