mirror of
https://github.com/pomerium/pomerium.git
synced 2025-04-29 10:26:29 +02:00
c7c2087483
In split service mode, and during periods of inactivity, the gRPC connections to the databroker may fall idle. Some network firewalls may eventually time out an idle TCP connection and even start dropping subsequent packets once connection traffic resumes. Combined with Linux default TCP retransmission settings, this could cause a broken connection to persist for over 15 minutes. In an attempt to avoid this scenario, enable TCP keepalive for outbound gRPC connections, matching the Go standard library default settings for time & interval: 15 seconds for both. (The probe count does not appear to be set, so it will remain at the OS default.) Add a test case exercising the BuildClusters() method with the default configuration options, comparing the results with a reference "golden" file in the testdata directory. Also add an '-update' flag to make it easier to update the reference golden when needed: go test ./config/envoyconfig -update
106 lines
3.1 KiB
Go
106 lines
3.1 KiB
Go
// Package testutil contains helper functions for unit tests.
|
|
package testutil
|
|
|
|
import (
|
|
"encoding/json"
|
|
"flag"
|
|
"os"
|
|
"path/filepath"
|
|
"reflect"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/google/go-cmp/cmp"
|
|
"github.com/stretchr/testify/assert"
|
|
"github.com/stretchr/testify/require"
|
|
"google.golang.org/protobuf/encoding/protojson"
|
|
"google.golang.org/protobuf/reflect/protoreflect"
|
|
"google.golang.org/protobuf/testing/protocmp"
|
|
)
|
|
|
|
const maxWait = time.Minute * 20
|
|
|
|
// AssertProtoEqual asserts that two protobuf messages equal. Slices of messages are also supported.
|
|
func AssertProtoEqual(t *testing.T, expected, actual interface{}, msgAndArgs ...interface{}) bool {
|
|
t.Helper()
|
|
return assert.True(t, cmp.Equal(expected, actual, protocmp.Transform()),
|
|
append(msgAndArgs, cmp.Diff(expected, actual, protocmp.Transform()))...)
|
|
}
|
|
|
|
// AssertProtoJSONEqual asserts that a protobuf message matches the given JSON. The protoMsg can also be a slice
|
|
// of protobuf messages.
|
|
func AssertProtoJSONEqual(t *testing.T, expected string, protoMsg interface{}, msgAndArgs ...interface{}) bool {
|
|
t.Helper()
|
|
formattedJSON := formattedProtoJSON(protoMsg)
|
|
return assert.Equal(t, reformatJSON(json.RawMessage(expected)), formattedJSON, msgAndArgs...)
|
|
}
|
|
|
|
func formattedProtoJSON(protoMsg interface{}) string {
|
|
protoMsgVal := reflect.ValueOf(protoMsg)
|
|
if protoMsgVal.Kind() == reflect.Slice {
|
|
var protoMsgs []json.RawMessage
|
|
for i := 0; i < protoMsgVal.Len(); i++ {
|
|
protoMsgs = append(protoMsgs, toProtoJSON(protoMsgVal.Index(i).Interface()))
|
|
}
|
|
bs, _ := json.Marshal(protoMsgs)
|
|
return reformatJSON(bs)
|
|
}
|
|
return reformatJSON(toProtoJSON(protoMsg))
|
|
}
|
|
|
|
func reformatJSON(raw json.RawMessage) string {
|
|
var obj interface{}
|
|
_ = json.Unmarshal(raw, &obj)
|
|
bs, _ := json.MarshalIndent(obj, "", " ")
|
|
return string(bs)
|
|
}
|
|
|
|
func toProtoJSON(protoMsg interface{}) json.RawMessage {
|
|
bs, _ := protojson.Marshal(protoMsg.(protoreflect.ProtoMessage))
|
|
return bs
|
|
}
|
|
|
|
var updateFlag = flag.Bool("update", false,
|
|
"when enabled, reference files will be updated to match current behavior")
|
|
|
|
// AssertProtoJSONFileEqual asserts that a protobuf message (or slice of
|
|
// messages) matches the given reference JSON file.
|
|
//
|
|
// To update a reference JSON file, pass the test argument '-update'. This will
|
|
// overwrite the reference output to match the current behavior.
|
|
func AssertProtoJSONFileEqual(
|
|
t *testing.T, file string, protoMsg interface{}, msgAndArgs ...interface{},
|
|
) bool {
|
|
t.Helper()
|
|
|
|
if *updateFlag {
|
|
updatedJSON := formattedProtoJSON(protoMsg) + "\n"
|
|
err := os.WriteFile(file, []byte(updatedJSON), 0o644)
|
|
return assert.NoError(t, err)
|
|
}
|
|
|
|
expected, err := os.ReadFile(file)
|
|
require.NoError(t, err)
|
|
|
|
return AssertProtoJSONEqual(t, string(expected), protoMsg, msgAndArgs...)
|
|
}
|
|
|
|
// ModRoot returns the directory containing the go.mod file.
|
|
func ModRoot() string {
|
|
dir, err := os.Getwd()
|
|
if err != nil {
|
|
panic("error getting working directory")
|
|
}
|
|
|
|
for {
|
|
if fi, err := os.Stat(filepath.Join(dir, "go.mod")); err == nil && !fi.IsDir() {
|
|
return dir
|
|
}
|
|
d := filepath.Dir(dir)
|
|
if d == dir {
|
|
break
|
|
}
|
|
dir = d
|
|
}
|
|
return ""
|
|
}
|