1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
|
// Copyright 2020 New Relic Corporation. All rights reserved.
// SPDX-License-Identifier: Apache-2.0
package nrgin
import (
"context"
"errors"
"net/http"
"net/http/httptest"
"testing"
"github.com/gin-gonic/gin"
"github.com/newrelic/go-agent/v3/internal"
"github.com/newrelic/go-agent/v3/internal/integrationsupport"
newrelic "github.com/newrelic/go-agent/v3/newrelic"
)
func accessTransactionContextContext(c *gin.Context) {
var ctx context.Context = c
// Transaction is designed to take both a context.Context and a
// *gin.Context.
txn := Transaction(ctx)
txn.NoticeError(errors.New("problem"))
c.Writer.WriteString("accessTransactionContextContext")
}
func TestContextContextTransaction(t *testing.T) {
app := integrationsupport.NewBasicTestApp()
router := gin.Default()
router.Use(Middleware(app.Application))
router.GET("/txn", accessTransactionContextContext)
txnName := "GET " + pkg + ".accessTransactionContextContext"
if useFullPathVersion(gin.Version) {
txnName = "GET /txn"
}
response := httptest.NewRecorder()
req, err := http.NewRequest("GET", "/txn", nil)
if err != nil {
t.Fatal(err)
}
router.ServeHTTP(response, req)
if respBody := response.Body.String(); respBody != "accessTransactionContextContext" {
t.Error("wrong response body", respBody)
}
if response.Code != 200 {
t.Error("wrong response code", response.Code)
}
app.ExpectTxnMetrics(t, internal.WantTxn{
Name: txnName,
IsWeb: true,
NumErrors: 1,
})
}
func accessTransactionFromContext(c *gin.Context) {
// This tests that FromContext will find the transaction added to a
// *gin.Context and by nrgin.Middleware.
txn := newrelic.FromContext(c)
txn.NoticeError(errors.New("problem"))
c.Writer.WriteString("accessTransactionFromContext")
}
func TestFromContext(t *testing.T) {
app := integrationsupport.NewBasicTestApp()
router := gin.Default()
router.Use(Middleware(app.Application))
router.GET("/txn", accessTransactionFromContext)
txnName := "GET " + pkg + ".accessTransactionFromContext"
if useFullPathVersion(gin.Version) {
txnName = "GET /txn"
}
response := httptest.NewRecorder()
req, err := http.NewRequest("GET", "/txn", nil)
if err != nil {
t.Fatal(err)
}
router.ServeHTTP(response, req)
if respBody := response.Body.String(); respBody != "accessTransactionFromContext" {
t.Error("wrong response body", respBody)
}
if response.Code != 200 {
t.Error("wrong response code", response.Code)
}
app.ExpectTxnMetrics(t, internal.WantTxn{
Name: txnName,
IsWeb: true,
NumErrors: 1,
})
}
func TestContextWithoutTransaction(t *testing.T) {
txn := Transaction(context.Background())
if txn != nil {
t.Error("didn't expect a transaction", txn)
}
ctx := context.WithValue(context.Background(), internal.TransactionContextKey, 123)
txn = Transaction(ctx)
if txn != nil {
t.Error("didn't expect a transaction", txn)
}
}
func TestNewContextTransaction(t *testing.T) {
// This tests that nrgin.Transaction will find a transaction added to
// to a context using newrelic.NewContext.
app := integrationsupport.NewBasicTestApp()
txn := app.StartTransaction("name")
ctx := newrelic.NewContext(context.Background(), txn)
if tx := Transaction(ctx); nil != tx {
tx.NoticeError(errors.New("problem"))
}
txn.End()
app.ExpectTxnMetrics(t, internal.WantTxn{
Name: "name",
IsWeb: false,
NumErrors: 1,
})
}
|
