From 99d2512d6765ba43a071fe5747608b500f9964d1 Mon Sep 17 00:00:00 2001 From: Kevin McDonald Date: Sat, 17 Aug 2024 20:33:56 +0200 Subject: [PATCH] Cleanup --- gen_bool.go | 9 ++++ gen_bytes.go | 1 + gen_enum.go | 13 +++++ gen_fields.go | 118 ++++++++++++++++++++++++++------------------- gen_fixed32.go | 1 + gen_fixedint64.go | 1 + gen_float32.go | 1 + gen_float64.go | 1 + gen_int32.go | 1 + gen_int64.go | 1 + gen_msg.go | 1 + gen_sfixed64.go | 1 + gen_sfixedint32.go | 3 +- gen_sint32.go | 1 + gen_sint64.go | 1 + gen_strings.go | 1 + gen_uint32.go | 1 + gen_uint64.go | 1 + gen_wellknown.go | 3 ++ 19 files changed, 110 insertions(+), 50 deletions(-) create mode 100644 gen_bool.go create mode 100644 gen_enum.go diff --git a/gen_bool.go b/gen_bool.go new file mode 100644 index 0000000..45f0ec4 --- /dev/null +++ b/gen_bool.go @@ -0,0 +1,9 @@ +package fauxrpc + +import "google.golang.org/protobuf/reflect/protoreflect" + +// GenerateBool returns a fake boolean value given a field descriptor. +func GenerateBool(fd protoreflect.FieldDescriptor) bool { + // TODO: use protovalidate + return true +} diff --git a/gen_bytes.go b/gen_bytes.go index 4832a29..4a54c6f 100644 --- a/gen_bytes.go +++ b/gen_bytes.go @@ -9,6 +9,7 @@ func generateBytesSimple() []byte { return []byte(gofakeit.HipsterSentence(3)) } +// GenerateBytes returns a fake []byte value given a field descriptor. func GenerateBytes(fd protoreflect.FieldDescriptor) []byte { constraints := getResolver().ResolveFieldConstraints(fd) if constraints == nil { diff --git a/gen_enum.go b/gen_enum.go new file mode 100644 index 0000000..aa9d45b --- /dev/null +++ b/gen_enum.go @@ -0,0 +1,13 @@ +package fauxrpc + +import ( + "github.com/brianvoe/gofakeit/v7" + "google.golang.org/protobuf/reflect/protoreflect" +) + +// GenerateEnum returns a fake enum value given a field descriptor. +func GenerateEnum(fd protoreflect.FieldDescriptor) protoreflect.EnumNumber { + values := fd.Enum().Values() + idx := gofakeit.IntRange(0, values.Len()-1) + return protoreflect.EnumNumber(idx) +} diff --git a/gen_fields.go b/gen_fields.go index c19644c..0565598 100644 --- a/gen_fields.go +++ b/gen_fields.go @@ -1,89 +1,109 @@ package fauxrpc import ( - "github.com/brianvoe/gofakeit/v7" "google.golang.org/protobuf/reflect/protoreflect" "google.golang.org/protobuf/types/dynamicpb" ) -func getFieldValue(fd protoreflect.FieldDescriptor, st state) *protoreflect.Value { - switch fd.Kind() { - case protoreflect.MessageKind: - switch string(fd.Message().FullName()) { - case "google.protobuf.Duration": - // TODO: hints - return genGoogleDuration() - case "google.protobuf.Timestamp": - // TODO: hints - return genGoogleTimestamp() - case "google.protobuf.Any": - // TODO: hints - return nil - case "google.protobuf.Value": - // TODO: hints - return genGoogleValue() - default: - nested := dynamicpb.NewMessage(fd.Message()) - setDataOnMessage(nested, st.Inc()) - v := protoreflect.ValueOf(nested) - return &v - } - case protoreflect.GroupKind: - nested := dynamicpb.NewMessage(fd.Message()) - setDataOnMessage(nested, st.Inc()) - v := protoreflect.ValueOf(nested) - return &v - case protoreflect.BoolKind: +var kindToGenerator = map[protoreflect.Kind]func(fd protoreflect.FieldDescriptor) *protoreflect.Value{ + protoreflect.BoolKind: func(fd protoreflect.FieldDescriptor) *protoreflect.Value { v := protoreflect.ValueOfBool(true) return &v - case protoreflect.EnumKind: - values := fd.Enum().Values() - idx := gofakeit.IntRange(0, values.Len()-1) - v := protoreflect.ValueOfEnum(protoreflect.EnumNumber(idx)) + }, + protoreflect.EnumKind: func(fd protoreflect.FieldDescriptor) *protoreflect.Value { + v := protoreflect.ValueOfEnum(GenerateEnum(fd)) return &v - case protoreflect.StringKind: + }, + protoreflect.StringKind: func(fd protoreflect.FieldDescriptor) *protoreflect.Value { v := protoreflect.ValueOfString(GenerateString(fd)) return &v - case protoreflect.BytesKind: + }, + protoreflect.BytesKind: func(fd protoreflect.FieldDescriptor) *protoreflect.Value { v := protoreflect.ValueOfBytes(GenerateBytes(fd)) return &v - case protoreflect.Int32Kind: + }, + protoreflect.Int32Kind: func(fd protoreflect.FieldDescriptor) *protoreflect.Value { v := protoreflect.ValueOfInt32(GenerateInt32(fd)) return &v - case protoreflect.Sint32Kind: + }, + protoreflect.Sint32Kind: func(fd protoreflect.FieldDescriptor) *protoreflect.Value { v := protoreflect.ValueOfInt32(GenerateSInt32(fd)) return &v - case protoreflect.Sfixed32Kind: - v := protoreflect.ValueOfInt32(GenerateSFixedInt32(fd)) + }, + protoreflect.Sfixed32Kind: func(fd protoreflect.FieldDescriptor) *protoreflect.Value { + v := protoreflect.ValueOfInt32(GenerateSFixed32(fd)) return &v - case protoreflect.Uint32Kind: + }, + protoreflect.Uint32Kind: func(fd protoreflect.FieldDescriptor) *protoreflect.Value { v := protoreflect.ValueOfUint32(GenerateUInt32(fd)) return &v - case protoreflect.Fixed32Kind: + }, + protoreflect.Fixed32Kind: func(fd protoreflect.FieldDescriptor) *protoreflect.Value { v := protoreflect.ValueOfUint32(GenerateFixed32(fd)) return &v - case protoreflect.Int64Kind: + }, + protoreflect.Int64Kind: func(fd protoreflect.FieldDescriptor) *protoreflect.Value { v := protoreflect.ValueOfInt64(GenerateInt64(fd)) return &v - case protoreflect.Sint64Kind: + }, + protoreflect.Sint64Kind: func(fd protoreflect.FieldDescriptor) *protoreflect.Value { v := protoreflect.ValueOfInt64(GenerateSInt64(fd)) return &v - case protoreflect.Sfixed64Kind: + }, + protoreflect.Sfixed64Kind: func(fd protoreflect.FieldDescriptor) *protoreflect.Value { v := protoreflect.ValueOfInt64(GenerateSFixed64(fd)) return &v - case protoreflect.Uint64Kind: + }, + protoreflect.Uint64Kind: func(fd protoreflect.FieldDescriptor) *protoreflect.Value { v := protoreflect.ValueOfUint64(GenerateUInt64(fd)) return &v - case protoreflect.Fixed64Kind: + }, + protoreflect.Fixed64Kind: func(fd protoreflect.FieldDescriptor) *protoreflect.Value { v := protoreflect.ValueOfUint64(GenerateFixed64(fd)) return &v - case protoreflect.FloatKind: + }, + protoreflect.FloatKind: func(fd protoreflect.FieldDescriptor) *protoreflect.Value { v := protoreflect.ValueOfFloat32(GenerateFloat32(fd)) return &v - case protoreflect.DoubleKind: + }, + protoreflect.DoubleKind: func(fd protoreflect.FieldDescriptor) *protoreflect.Value { v := protoreflect.ValueOfFloat64(GenerateFloat64(fd)) return &v - default: + }, +} + +func getFieldValue(fd protoreflect.FieldDescriptor, st state) *protoreflect.Value { + switch fd.Kind() { + case protoreflect.MessageKind: + switch string(fd.Message().FullName()) { + case "google.protobuf.Duration": + // TODO: hints + return genGoogleDuration() + case "google.protobuf.Timestamp": + // TODO: hints + return genGoogleTimestamp() + case "google.protobuf.Any": + // TODO: hints + return nil + case "google.protobuf.Value": + // TODO: hints + return genGoogleValue() + } + + nested := dynamicpb.NewMessage(fd.Message()) + setDataOnMessage(nested, st.Inc()) + v := protoreflect.ValueOf(nested) + return &v + case protoreflect.GroupKind: + nested := dynamicpb.NewMessage(fd.Message()) + setDataOnMessage(nested, st.Inc()) + v := protoreflect.ValueOf(nested) + return &v + } + + fn, ok := kindToGenerator[fd.Kind()] + if !ok { return nil } + return fn(fd) } diff --git a/gen_fixed32.go b/gen_fixed32.go index 844eaea..1851ea7 100644 --- a/gen_fixed32.go +++ b/gen_fixed32.go @@ -8,6 +8,7 @@ import ( "google.golang.org/protobuf/reflect/protoreflect" ) +// GenerateFixed32 returns a fake fixed32 value given a field descriptor. func GenerateFixed32(fd protoreflect.FieldDescriptor) uint32 { constraints := getResolver().ResolveFieldConstraints(fd) if constraints == nil { diff --git a/gen_fixedint64.go b/gen_fixedint64.go index 0d0a675..b48adf6 100644 --- a/gen_fixedint64.go +++ b/gen_fixedint64.go @@ -8,6 +8,7 @@ import ( "google.golang.org/protobuf/reflect/protoreflect" ) +// GenerateFixed64 returns a fake fixed64 value given a field descriptor. func GenerateFixed64(fd protoreflect.FieldDescriptor) uint64 { constraints := getResolver().ResolveFieldConstraints(fd) if constraints == nil { diff --git a/gen_float32.go b/gen_float32.go index 0724c24..db941f7 100644 --- a/gen_float32.go +++ b/gen_float32.go @@ -8,6 +8,7 @@ import ( "google.golang.org/protobuf/reflect/protoreflect" ) +// GenerateFloat32 returns a fake float32 value given a field descriptor. func GenerateFloat32(fd protoreflect.FieldDescriptor) float32 { constraints := getResolver().ResolveFieldConstraints(fd) if constraints == nil { diff --git a/gen_float64.go b/gen_float64.go index 0b06255..59ebf8a 100644 --- a/gen_float64.go +++ b/gen_float64.go @@ -8,6 +8,7 @@ import ( "google.golang.org/protobuf/reflect/protoreflect" ) +// GenerateFloat64 returns a fake float64 value given a field descriptor. func GenerateFloat64(fd protoreflect.FieldDescriptor) float64 { constraints := getResolver().ResolveFieldConstraints(fd) if constraints == nil { diff --git a/gen_int32.go b/gen_int32.go index 2183f05..abca3fd 100644 --- a/gen_int32.go +++ b/gen_int32.go @@ -8,6 +8,7 @@ import ( "google.golang.org/protobuf/reflect/protoreflect" ) +// GenerateInt32 returns a fake int32 value given a field descriptor. func GenerateInt32(fd protoreflect.FieldDescriptor) int32 { constraints := getResolver().ResolveFieldConstraints(fd) if constraints == nil { diff --git a/gen_int64.go b/gen_int64.go index b2fbfd9..395fb64 100644 --- a/gen_int64.go +++ b/gen_int64.go @@ -8,6 +8,7 @@ import ( "google.golang.org/protobuf/reflect/protoreflect" ) +// GenerateInt64 returns a fake int64 value given a field descriptor. func GenerateInt64(fd protoreflect.FieldDescriptor) int64 { constraints := getResolver().ResolveFieldConstraints(fd) if constraints == nil { diff --git a/gen_msg.go b/gen_msg.go index 0b2c473..0cfec2c 100644 --- a/gen_msg.go +++ b/gen_msg.go @@ -8,6 +8,7 @@ import ( "google.golang.org/protobuf/types/dynamicpb" ) +// SetDataOnMessage generates fake data given a *dynamicpb.Message and sets the field values. func SetDataOnMessage(msg *dynamicpb.Message) { setDataOnMessage(msg, state{}) } diff --git a/gen_sfixed64.go b/gen_sfixed64.go index 9baa09d..20c285e 100644 --- a/gen_sfixed64.go +++ b/gen_sfixed64.go @@ -8,6 +8,7 @@ import ( "google.golang.org/protobuf/reflect/protoreflect" ) +// GenerateSFixed64 returns a fake sfixed64 value given a field descriptor. func GenerateSFixed64(fd protoreflect.FieldDescriptor) int64 { constraints := getResolver().ResolveFieldConstraints(fd) if constraints == nil { diff --git a/gen_sfixedint32.go b/gen_sfixedint32.go index 3a99450..f4815c5 100644 --- a/gen_sfixedint32.go +++ b/gen_sfixedint32.go @@ -8,7 +8,8 @@ import ( "google.golang.org/protobuf/reflect/protoreflect" ) -func GenerateSFixedInt32(fd protoreflect.FieldDescriptor) int32 { +// GenerateSFixed32 returns a fake sfixedint32 value given a field descriptor. +func GenerateSFixed32(fd protoreflect.FieldDescriptor) int32 { constraints := getResolver().ResolveFieldConstraints(fd) if constraints == nil { return gofakeit.Int32() diff --git a/gen_sint32.go b/gen_sint32.go index fe80ada..8760f74 100644 --- a/gen_sint32.go +++ b/gen_sint32.go @@ -8,6 +8,7 @@ import ( "google.golang.org/protobuf/reflect/protoreflect" ) +// GenerateSInt32 returns a fake sint32 value given a field descriptor. func GenerateSInt32(fd protoreflect.FieldDescriptor) int32 { constraints := getResolver().ResolveFieldConstraints(fd) if constraints == nil { diff --git a/gen_sint64.go b/gen_sint64.go index 5eda431..e4141e5 100644 --- a/gen_sint64.go +++ b/gen_sint64.go @@ -8,6 +8,7 @@ import ( "google.golang.org/protobuf/reflect/protoreflect" ) +// GenerateSInt64 returns a fake sint64 value given a field descriptor. func GenerateSInt64(fd protoreflect.FieldDescriptor) int64 { constraints := getResolver().ResolveFieldConstraints(fd) if constraints == nil { diff --git a/gen_strings.go b/gen_strings.go index ac90cde..7e67911 100644 --- a/gen_strings.go +++ b/gen_strings.go @@ -36,6 +36,7 @@ func generateStringSimple(fd protoreflect.FieldDescriptor) string { return gofakeit.HipsterSentence(int(randInt64GeometricDist(0.5) + 1)) } +// GenerateString returns a fake string value given a field descriptor. func GenerateString(fd protoreflect.FieldDescriptor) string { constraints := getResolver().ResolveFieldConstraints(fd) if constraints == nil { diff --git a/gen_uint32.go b/gen_uint32.go index c6cce13..7977e3a 100644 --- a/gen_uint32.go +++ b/gen_uint32.go @@ -8,6 +8,7 @@ import ( "google.golang.org/protobuf/reflect/protoreflect" ) +// GenerateUInt32 returns a fake uint32 value given a field descriptor. func GenerateUInt32(fd protoreflect.FieldDescriptor) uint32 { constraints := getResolver().ResolveFieldConstraints(fd) if constraints == nil { diff --git a/gen_uint64.go b/gen_uint64.go index e0b96aa..43fbcbf 100644 --- a/gen_uint64.go +++ b/gen_uint64.go @@ -8,6 +8,7 @@ import ( "google.golang.org/protobuf/reflect/protoreflect" ) +// GenerateUInt64 returns a fake uint64 value given a field descriptor. func GenerateUInt64(fd protoreflect.FieldDescriptor) uint64 { constraints := getResolver().ResolveFieldConstraints(fd) if constraints == nil { diff --git a/gen_wellknown.go b/gen_wellknown.go index af7d27f..6916ad1 100644 --- a/gen_wellknown.go +++ b/gen_wellknown.go @@ -11,17 +11,20 @@ import ( ) func genGoogleDuration() *protoreflect.Value { + // TODO: use protovalidate duration := time.Duration(gofakeit.Uint64() % uint64(30*time.Hour*24)) v := protoreflect.ValueOf(durationpb.New(duration).ProtoReflect()) return &v } func genGoogleTimestamp() *protoreflect.Value { + // TODO: use protovalidate v := protoreflect.ValueOf(timestamppb.New(gofakeit.Date()).ProtoReflect()) return &v } func genGoogleValue() *protoreflect.Value { + // TODO: use protovalidate scalarOptions := []func() *structpb.Value{ func() *structpb.Value { return structpb.NewNullValue() }, func() *structpb.Value { return structpb.NewBoolValue(gofakeit.Bool()) },