mirror of https://github.com/hashicorp/consul
132 lines
3.4 KiB
Go
132 lines
3.4 KiB
Go
package middleware
|
|
|
|
import (
|
|
"strings"
|
|
"sync"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/armon/go-metrics"
|
|
"github.com/hashicorp/go-hclog"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
// obs holds all the things we want to assert on that we recorded correctly in our tests.
|
|
type obs struct {
|
|
key []string
|
|
elapsed float32
|
|
labels []metrics.Label
|
|
}
|
|
|
|
// recorderStore acts as an in-mem mock storage for all the RequestRecorder.Record() RecorderFunc calls.
|
|
type recorderStore struct {
|
|
lock sync.Mutex
|
|
store map[string]obs
|
|
}
|
|
|
|
func (rs *recorderStore) put(key []string, o obs) {
|
|
rs.lock.Lock()
|
|
defer rs.lock.Unlock()
|
|
|
|
actualKey := strings.Join(append(key, o.labels[0].Value), "")
|
|
rs.store[actualKey] = o
|
|
}
|
|
|
|
func (rs *recorderStore) get(key []string) obs {
|
|
rs.lock.Lock()
|
|
defer rs.lock.Unlock()
|
|
|
|
actualKey := strings.Join(key, "")
|
|
return rs.store[actualKey]
|
|
}
|
|
|
|
var store = recorderStore{store: make(map[string]obs)}
|
|
var simpleRecorderFunc = func(key []string, val float32, labels []metrics.Label) {
|
|
o := obs{key: key, elapsed: val, labels: labels}
|
|
store.put(key, o)
|
|
}
|
|
|
|
type readRequest struct{}
|
|
type writeRequest struct{}
|
|
|
|
func (rr readRequest) IsRead() bool {
|
|
return true
|
|
}
|
|
|
|
func (wr writeRequest) IsRead() bool {
|
|
return false
|
|
}
|
|
|
|
// TestRequestRecorder_SimpleOK tests that the RequestRecorder can record a simple request.
|
|
func TestRequestRecorder_SimpleOK(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
r := RequestRecorder{
|
|
Logger: hclog.NewInterceptLogger(&hclog.LoggerOptions{}),
|
|
RecorderFunc: simpleRecorderFunc,
|
|
}
|
|
|
|
start := time.Now()
|
|
r.Record("A.B", RPCTypeInternal, start, struct{}{}, false)
|
|
|
|
expectedLabels := []metrics.Label{
|
|
{Name: "method", Value: "A.B"},
|
|
{Name: "errored", Value: "false"},
|
|
{Name: "request_type", Value: "unreported"},
|
|
{Name: "rpc_type", Value: RPCTypeInternal},
|
|
}
|
|
|
|
o := store.get(append(metricRPCRequest, expectedLabels[0].Value))
|
|
require.Equal(t, o.key, metricRPCRequest)
|
|
require.LessOrEqual(t, o.elapsed, float32(start.Sub(time.Now()).Milliseconds()))
|
|
require.Equal(t, o.labels, expectedLabels)
|
|
}
|
|
|
|
// TestRequestRecorder_ReadRequest tests that RequestRecorder can record a read request AND a responseErrored arg.
|
|
func TestRequestRecorder_ReadRequest(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
r := RequestRecorder{
|
|
Logger: hclog.NewInterceptLogger(&hclog.LoggerOptions{}),
|
|
RecorderFunc: simpleRecorderFunc,
|
|
}
|
|
|
|
start := time.Now()
|
|
|
|
r.Record("B.A", RPCTypeNetRPC, start, readRequest{}, true)
|
|
|
|
expectedLabels := []metrics.Label{
|
|
{Name: "method", Value: "B.A"},
|
|
{Name: "errored", Value: "true"},
|
|
{Name: "request_type", Value: "read"},
|
|
{Name: "rpc_type", Value: RPCTypeNetRPC},
|
|
}
|
|
|
|
o := store.get(append(metricRPCRequest, expectedLabels[0].Value))
|
|
require.Equal(t, o.labels, expectedLabels)
|
|
}
|
|
|
|
// TestRequestRecorder_WriteRequest tests that RequestRecorder can record a write request.
|
|
func TestRequestRecorder_WriteRequest(t *testing.T) {
|
|
t.Parallel()
|
|
|
|
r := RequestRecorder{
|
|
Logger: hclog.NewInterceptLogger(&hclog.LoggerOptions{}),
|
|
RecorderFunc: simpleRecorderFunc,
|
|
}
|
|
|
|
start := time.Now()
|
|
|
|
r.Record("B.C", RPCTypeNetRPC, start, writeRequest{}, true)
|
|
|
|
expectedLabels := []metrics.Label{
|
|
{Name: "method", Value: "B.C"},
|
|
{Name: "errored", Value: "true"},
|
|
{Name: "request_type", Value: "write"},
|
|
{Name: "rpc_type", Value: RPCTypeNetRPC},
|
|
}
|
|
|
|
o := store.get(append(metricRPCRequest, expectedLabels[0].Value))
|
|
require.Equal(t, o.labels, expectedLabels)
|
|
}
|