From b0c64600dfd65956f4b37f75f516ca70bb994060 Mon Sep 17 00:00:00 2001 From: Evis Drenova Date: Mon, 20 Nov 2023 21:02:51 -0800 Subject: [PATCH] refactoed and updated random float transformer and tests --- .../benthos/transformers/random_bool.go | 2 - .../benthos/transformers/random_bool_test.go | 4 +- .../benthos/transformers/random_float.go | 87 +++++++++++++------ .../benthos/transformers/random_float_test.go | 47 ++++++++-- .../benthos/transformers/utils/utils.go | 15 ++-- 5 files changed, 109 insertions(+), 46 deletions(-) diff --git a/worker/internal/benthos/transformers/random_bool.go b/worker/internal/benthos/transformers/random_bool.go index d62dcecb72..fe593e8bca 100644 --- a/worker/internal/benthos/transformers/random_bool.go +++ b/worker/internal/benthos/transformers/random_bool.go @@ -12,8 +12,6 @@ func init() { spec := bloblang.NewPluginSpec() - // register the function - err := bloblang.RegisterFunctionV2("randombooltransformer", spec, func(args *bloblang.ParsedParams) (bloblang.Function, error) { return func() (any, error) { diff --git a/worker/internal/benthos/transformers/random_bool_test.go b/worker/internal/benthos/transformers/random_bool_test.go index 27a832c6d4..f14a8045a0 100644 --- a/worker/internal/benthos/transformers/random_bool_test.go +++ b/worker/internal/benthos/transformers/random_bool_test.go @@ -7,7 +7,7 @@ import ( "github.com/stretchr/testify/assert" ) -func TestProcessRandomBool(t *testing.T) { +func Test_ProcessRandomBool(t *testing.T) { res, err := GenerateRandomBool() @@ -16,7 +16,7 @@ func TestProcessRandomBool(t *testing.T) { } -func TestRandomBoolTransformer(t *testing.T) { +func Test_RandomBoolTransformer(t *testing.T) { mapping := `root = randombooltransformer()` ex, err := bloblang.Parse(mapping) assert.NoError(t, err, "failed to parse the random bool transformer") diff --git a/worker/internal/benthos/transformers/random_float.go b/worker/internal/benthos/transformers/random_float.go index 5a94d550e8..6619ff9277 100644 --- a/worker/internal/benthos/transformers/random_float.go +++ b/worker/internal/benthos/transformers/random_float.go @@ -13,37 +13,59 @@ import ( func init() { spec := bloblang.NewPluginSpec(). - Param(bloblang.NewBoolParam("preserve_length")). - Param(bloblang.NewInt64Param("digits_before_decimal")). - Param(bloblang.NewInt64Param("digits_after_decimal")) + Param(bloblang.NewFloat64Param("value").Optional()). + Param(bloblang.NewBoolParam("preserve_length").Optional()). + Param(bloblang.NewInt64Param("digits_before_decimal").Optional()). + Param(bloblang.NewInt64Param("digits_after_decimal").Optional()) // register the plugin - err := bloblang.RegisterMethodV2("randomfloattransformer", spec, func(args *bloblang.ParsedParams) (bloblang.Method, error) { + err := bloblang.RegisterFunctionV2("randomfloattransformer", spec, func(args *bloblang.ParsedParams) (bloblang.Function, error) { - preserveLength, err := args.GetBool("preserve_length") + valuePtr, err := args.GetOptionalFloat64("value") if err != nil { return nil, err } - digitsBeforeDecimal, err := args.GetInt64("digits_before_decimal") + var value float64 + if valuePtr != nil { + value = *valuePtr + } + + preserveLengthPtr, err := args.GetOptionalBool("preserve_length") + if err != nil { + return nil, err + } + + var preserveLength bool + if preserveLengthPtr != nil { + preserveLength = *preserveLengthPtr + } + + digitsBeforeDecimalPtr, err := args.GetOptionalInt64("digits_before_decimal") if err != nil { return nil, err } - digitsAfterDecimal, err := args.GetInt64("digits_after_decimal") + var digitsBeforeDecimal int64 + if digitsBeforeDecimalPtr != nil { + digitsBeforeDecimal = *digitsBeforeDecimalPtr + } + + digitsAfterDecimalPtr, err := args.GetOptionalInt64("digits_after_decimal") if err != nil { return nil, err } - return bloblang.Float64Method(func(i float64) (any, error) { - if preserveLength { - res, err := GenerateRandomFloatPreserveLength(i, preserveLength) - return res, err - } else { - res, err := GenerateRandomFloatWithDefinedLength(digitsBeforeDecimal, digitsAfterDecimal) - return res, err - } - }), nil + var digitsAfterDecimal int64 + if digitsAfterDecimalPtr != nil { + digitsAfterDecimal = *digitsAfterDecimalPtr + } + + return func() (any, error) { + res, err := GenerateRandomFloat(value, preserveLength, digitsAfterDecimal, digitsBeforeDecimal) + return res, err + + }, nil }) if err != nil { @@ -52,24 +74,39 @@ func init() { } -func GenerateRandomFloatPreserveLength(i float64, preserveLength bool) (float64, error) { +func GenerateRandomFloat(value float64, preserveLength bool, digitsAfterDecimal, digitsBeforeDecimal int64) (float64, error) { - var returnValue float64 + if value != 0 { + if preserveLength { + fLen := GetFloatLength(value) + res, err := GenerateRandomFloatWithDefinedLength(int64(fLen.DigitsBeforeDecimalLength), int64(fLen.DigitsAfterDecimalLength)) + return res, err + } else { + res, err := GenerateRandomFloatWithDefinedLength(digitsBeforeDecimal, digitsAfterDecimal) + return res, err + } + } else { + res, err := GenerateRandomFloatWithRandomLength() + return res, err + } +} - fLen := GetFloatLength(i) +func GenerateRandomFloatWithRandomLength() (float64, error) { - bd, err := transformer_utils.GenerateRandomInt(int64(fLen.DigitsBeforeDecimalLength)) + var returnValue float64 + + bd, err := transformer_utils.GenerateRandomInt(int64(3)) if err != nil { return 0, fmt.Errorf("unable to generate a random before digits integer") } - ad, err := transformer_utils.GenerateRandomInt(int64(fLen.DigitsAfterDecimalLength)) + ad, err := transformer_utils.GenerateRandomInt(int64(3)) for { if !transformer_utils.IsLastDigitZero(ad) { - break // Exit the loop when i is greater than or equal to 5 + break } - ad, err = transformer_utils.GenerateRandomInt(int64(fLen.DigitsAfterDecimalLength)) + ad, err = transformer_utils.GenerateRandomInt(int64(3)) if err != nil { return 0, fmt.Errorf("unable to generate a random int64 to convert to a float") @@ -120,10 +157,6 @@ func GenerateRandomFloatWithDefinedLength(digitsBeforeDecimal, digitsAfterDecima return 0, fmt.Errorf("unable to generate a random after digits integer") } - if err != nil { - return 0, fmt.Errorf("unable to generate a random string with length") - } - combinedStr := fmt.Sprintf("%d.%d", bd, ad) result, err := strconv.ParseFloat(combinedStr, 64) diff --git a/worker/internal/benthos/transformers/random_float_test.go b/worker/internal/benthos/transformers/random_float_test.go index 09f3aa7926..b5ca9a6096 100644 --- a/worker/internal/benthos/transformers/random_float_test.go +++ b/worker/internal/benthos/transformers/random_float_test.go @@ -1,18 +1,20 @@ package neosync_transformers import ( + "fmt" "testing" "github.com/benthosdev/benthos/v4/public/bloblang" + transformer_utils "github.com/nucleuscloud/neosync/worker/internal/benthos/transformers/utils" "github.com/stretchr/testify/assert" ) -func TestProcessRandomFloatPreserveLength(t *testing.T) { +func Test_GenerateRandomFloat(t *testing.T) { val := float64(6754.3543) expectedLength := 8 - res, err := GenerateRandomFloatPreserveLength(val, true) + res, err := GenerateRandomFloat(val, true, 3, 4) actual := GetFloatLength(res).DigitsBeforeDecimalLength + GetFloatLength(res).DigitsAfterDecimalLength @@ -20,8 +22,7 @@ func TestProcessRandomFloatPreserveLength(t *testing.T) { assert.Equal(t, expectedLength, actual, "The output float needs to be the same length as the input Float") } - -func TestProcessRandomFloatPreserveLengthFalse(t *testing.T) { +func Test_GenerateRandomFloatPreserveLengthFalse(t *testing.T) { expectedLength := 6 @@ -32,12 +33,20 @@ func TestProcessRandomFloatPreserveLengthFalse(t *testing.T) { assert.Equal(t, actual, expectedLength, "The length of the output float needs to match the digits before + the digits after") } -func TestRandomFloatTransformer(t *testing.T) { - mapping := `root = this.randomfloattransformer(true, 2,3)` - ex, err := bloblang.Parse(mapping) - assert.NoError(t, err, "failed to parse the random float transformer") +func Test_GenerateRandomFloatWithRandomLength(t *testing.T) { + res, err := GenerateRandomFloatWithRandomLength() + + actual := GetFloatLength(res).DigitsAfterDecimalLength + GetFloatLength(res).DigitsBeforeDecimalLength + assert.NoError(t, err) + assert.Equal(t, 6, actual, "The length of the output float needs to match the digits before + the digits after") +} + +func TestRandomFloatTransformerWithValue(t *testing.T) { testVal := float64(397.34) + mapping := fmt.Sprintf(`root = randomfloattransformer(%f, true, 2,3)`, testVal) + ex, err := bloblang.Parse(mapping) + assert.NoError(t, err, "failed to parse the random float transformer") res, err := ex.Query(testVal) assert.NoError(t, err) @@ -45,3 +54,25 @@ func TestRandomFloatTransformer(t *testing.T) { assert.Equal(t, GetFloatLength(testVal), GetFloatLength(res.(float64))) // Generated Float must be the same length as the input Float" assert.IsType(t, res, testVal) } + +func TestRandomFloatTransformerWithNoValue(t *testing.T) { + mapping := `root = randomfloattransformer()` + ex, err := bloblang.Parse(mapping) + assert.NoError(t, err, "failed to parse the random float transformer") + + res, err := ex.Query(nil) + assert.NoError(t, err) + + actual := GetFloatLength(res.(float64)).DigitsAfterDecimalLength + GetFloatLength(res.(float64)).DigitsBeforeDecimalLength + assert.IsType(t, res, float64(1)) + assert.Equal(t, 6, actual, "The length of the output float needs to match the digits before + the digits after") +} + +func Test_GetFloatLength(t *testing.T) { + val := float64(3.14) + res := GetFloatLength(val) + + assert.Equal(t, int64(1), transformer_utils.GetIntLength(int64(res.DigitsBeforeDecimalLength))) + assert.Equal(t, int64(1), transformer_utils.GetIntLength(int64(res.DigitsAfterDecimalLength))) + +} diff --git a/worker/internal/benthos/transformers/utils/utils.go b/worker/internal/benthos/transformers/utils/utils.go index e9e1e1debf..df1cfbf82d 100644 --- a/worker/internal/benthos/transformers/utils/utils.go +++ b/worker/internal/benthos/transformers/utils/utils.go @@ -79,20 +79,21 @@ func IntSliceToStringSlice(ints []int64) []string { return str } -// generates a random integer of length l that is passed in as a int64 param -func GenerateRandomInt(digits int64) (int64, error) { - if digits <= 0 { +// generates a random integer of length l that is passed in as a int64 param i.e. an l of 3 will generate +// an int64 of 3 digits such as 123 or 789. +func GenerateRandomInt(l int64) (int64, error) { + if l <= 0 { return 0, fmt.Errorf("count is zero or not a positive integer") } // int64 only supports 18 digits, so if the count => 19, this will error out - if digits >= 19 { + if l >= 19 { return 0, fmt.Errorf("count has to be less than 18 digits since int64 only supports up to 18 digits") } // Calculate the min and max values for count - minValue := new(big.Int).Exp(big.NewInt(10), big.NewInt(digits-1), nil) - maxValue := new(big.Int).Exp(big.NewInt(10), big.NewInt(digits), nil) + minValue := new(big.Int).Exp(big.NewInt(10), big.NewInt(l-1), nil) + maxValue := new(big.Int).Exp(big.NewInt(10), big.NewInt(l), nil) // Generate a random integer within the specified range randInt, err := rand.Int(rand.Reader, maxValue) @@ -105,7 +106,7 @@ func GenerateRandomInt(digits int64) (int64, error) { */ - if FirstDigitIsNine(randInt.Int64()) && GetIntLength(randInt.Int64()) == digits { + if FirstDigitIsNine(randInt.Int64()) && GetIntLength(randInt.Int64()) == l { return randInt.Int64(), nil } else { randInt.Add(randInt, minValue)