open-consul/proto/pbservice/convert_test.go

116 lines
3.2 KiB
Go

package pbservice
import (
"os"
"reflect"
"strconv"
"testing"
"time"
"github.com/google/go-cmp/cmp"
"github.com/google/go-cmp/cmp/cmpopts"
fuzz "github.com/google/gofuzz"
"github.com/hashicorp/consul/agent/structs"
)
func TestNewCheckServiceNodeFromStructs_RoundTrip(t *testing.T) {
repeat(t, func(t *testing.T, fuzzer *fuzz.Fuzzer) {
fuzzer.Funcs(randInt32, randUint32, randInterface, randStructsUpstream, randEnterpriseMeta)
var target structs.CheckServiceNode
fuzzer.Fuzz(&target)
result := CheckServiceNodeToStructs(NewCheckServiceNodeFromStructs(&target))
assertEqual(t, &target, result)
})
}
func repeat(t *testing.T, fn func(t *testing.T, fuzzer *fuzz.Fuzzer)) {
reps := getEnvIntWithDefault(t, "TEST_REPEAT_COUNT", 5)
seed := getEnvIntWithDefault(t, "TEST_RANDOM_SEED", time.Now().UnixNano())
t.Logf("using seed %d for %d repetitions", seed, reps)
fuzzer := fuzz.NewWithSeed(seed)
for i := 0; i < int(reps); i++ {
t.Run(strconv.Itoa(i), func(t *testing.T) {
fn(t, fuzzer)
})
}
}
func getEnvIntWithDefault(t *testing.T, key string, d int64) int64 {
t.Helper()
raw, ok := os.LookupEnv(key)
if !ok {
return d
}
v, err := strconv.Atoi(raw)
if err != nil {
t.Fatalf("invald value for %v: %v", key, err.Error())
}
return int64(v)
}
func assertEqual(t *testing.T, x, y interface{}) {
t.Helper()
if diff := cmp.Diff(x, y, cmpopts.EquateEmpty()); diff != "" {
t.Fatalf("assertion failed: values are not equal\n--- original\n+++ result\n\n%v", diff)
}
}
// randUint32 is a custom fuzzer function which limits all uints to 32 bits.
// This is necessary because the structs types use un-sized uints, however in
// practice they are constrained to 32 bits, and the protobuf types use (u)int32.
// The structs types use (u)int64 for any fields that require 64 bits.
func randUint32(i *uint, c fuzz.Continue) {
*i = uint(c.Rand.Uint32())
}
// see randUint32
func randInt32(i *int, c fuzz.Continue) {
*i = int(c.Rand.Int31())
}
// randStructsUpstream is a custom fuzzer function which skips generating values
// for fields enumerated in the ignore-fields annotation.
func randStructsUpstream(u *structs.Upstream, c fuzz.Continue) {
v := reflect.ValueOf(u).Elem()
for i := 0; i < v.NumField(); i++ {
switch v.Type().Field(i).Name {
case "IngressHosts":
continue
}
c.Fuzz(v.Field(i).Addr().Interface())
}
}
// randInterface is a custom fuzzer function which generates random data for
// interface{} (most likely used in a map[string]interface{}).
// The random data does not contain any ints (or float32) because protobuf
// converts them to float64, which will cause the test to fail.
func randInterface(m *interface{}, c fuzz.Continue) {
switch c.Rand.Intn(6) {
case 0:
*m = nil
case 1:
*m = c.RandBool()
case 2:
*m = c.Rand.Float64()
case 3:
*m = c.RandString()
case 4:
*m = []interface{}{c.RandString(), c.RandBool(), nil, c.Rand.Float64()}
case 5:
*m = map[string]interface{}{
c.RandString(): c.RandString(),
c.RandString(): c.Rand.Float64(),
c.RandString(): nil,
}
}
}
// TODO(streaming): this is a quick fix to get the tests passing in enterprise.
// This needs to use a real random value once enterprise support is complete.
func randEnterpriseMeta(_ *structs.EnterpriseMeta, _ fuzz.Continue) {
}