From 1382ec23d6a1f0d7fbb547fb53cb042c6af558c5 Mon Sep 17 00:00:00 2001 From: Evis Drenova Date: Mon, 20 Nov 2023 21:36:22 -0800 Subject: [PATCH] updated random int transformer and tests --- .../benthos/transformers/random_int.go | 76 +++++++++++++------ .../benthos/transformers/random_int_test.go | 21 ++++- .../datasync/activities/activities.go | 6 +- 3 files changed, 74 insertions(+), 29 deletions(-) diff --git a/worker/internal/benthos/transformers/random_int.go b/worker/internal/benthos/transformers/random_int.go index 0cdd3bc8b3..5ee4496c50 100644 --- a/worker/internal/benthos/transformers/random_int.go +++ b/worker/internal/benthos/transformers/random_int.go @@ -13,26 +13,46 @@ const defaultIntLength = 4 func init() { spec := bloblang.NewPluginSpec(). - Param(bloblang.NewBoolParam("preserve_length")). - Param(bloblang.NewInt64Param("int_length")) + Param(bloblang.NewInt64Param("value").Optional()). + Param(bloblang.NewBoolParam("preserve_length").Optional()). + Param(bloblang.NewInt64Param("int_length").Optional()) // register the plugin - err := bloblang.RegisterMethodV2("randominttransformer", spec, func(args *bloblang.ParsedParams) (bloblang.Method, error) { + err := bloblang.RegisterFunctionV2("randominttransformer", spec, func(args *bloblang.ParsedParams) (bloblang.Function, error) { - preserveLength, err := args.GetBool("preserve_length") + valuePtr, err := args.GetOptionalInt64("value") if err != nil { return nil, err } - intLength, err := args.GetInt64("int_length") + var value int64 + 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 + } + + intLengthPtr, err := args.GetOptionalInt64("int_length") if err != nil { return nil, err } - return bloblang.Int64Method(func(i int64) (any, error) { - res, err := GenerateRandomInt(i, preserveLength, intLength) + var intLength int64 + if intLengthPtr != nil { + intLength = *intLengthPtr + } + + return func() (any, error) { + res, err := GenerateRandomInt(value, preserveLength, intLength) return res, err - }), nil + }, nil }) if err != nil { @@ -41,34 +61,46 @@ func init() { } -// main transformer logic goes here -func GenerateRandomInt(i int64, preserveLength bool, intLength int64) (int64, error) { +func GenerateRandomInt(value int64, preserveLength bool, intLength int64) (int64, error) { var returnValue int64 if preserveLength && intLength > 0 { return 0, fmt.Errorf("preserve length and int length params cannot both be true") } - if preserveLength { + if value != 0 { - val, err := transformer_utils.GenerateRandomInt(transformer_utils.GetIntLength(i)) + if preserveLength { - if err != nil { - return 0, fmt.Errorf("unable to generate a random string with length") - } + val, err := transformer_utils.GenerateRandomInt(transformer_utils.GetIntLength(value)) - returnValue = val + if err != nil { + return 0, fmt.Errorf("unable to generate a random string with length") + } - } else if intLength > 0 { + returnValue = val - val, err := transformer_utils.GenerateRandomInt(intLength) + } else if intLength > 0 { - if err != nil { - return 0, fmt.Errorf("unable to generate a random string with length") - } + val, err := transformer_utils.GenerateRandomInt(intLength) - returnValue = val + if err != nil { + return 0, fmt.Errorf("unable to generate a random string with length") + } + + returnValue = val + } else { + + val, err := transformer_utils.GenerateRandomInt(defaultIntLength) + + if err != nil { + return 0, fmt.Errorf("unable to generate a random string with length") + } + + returnValue = val + + } } else { val, err := transformer_utils.GenerateRandomInt(defaultIntLength) diff --git a/worker/internal/benthos/transformers/random_int_test.go b/worker/internal/benthos/transformers/random_int_test.go index d4ba797fa4..091a40db51 100644 --- a/worker/internal/benthos/transformers/random_int_test.go +++ b/worker/internal/benthos/transformers/random_int_test.go @@ -1,6 +1,7 @@ package neosync_transformers import ( + "fmt" "testing" "github.com/benthosdev/benthos/v4/public/bloblang" @@ -53,16 +54,28 @@ func TestGenerateandomIntPreserveLengthFalseIntLength(t *testing.T) { } -func TestRandomIntTransformer(t *testing.T) { - mapping := `root = this.randominttransformer(false, 6)` +func TestRandomIntTransformerWithValue(t *testing.T) { + testVal := int64(397283) + mapping := fmt.Sprintf(`root = randominttransformer(%d, false, 6)`, testVal) + fmt.Println("mapping", mapping) ex, err := bloblang.Parse(mapping) assert.NoError(t, err, "failed to parse the random int transformer") - testVal := int64(397283) - res, err := ex.Query(testVal) assert.NoError(t, err) assert.Equal(t, transformer_utils.GetIntLength(testVal), transformer_utils.GetIntLength(res.(int64))) // Generated int must be the same length as the input int" assert.IsType(t, res, testVal) } + +func TestRandomIntTransformerWithNoValue(t *testing.T) { + mapping := `root = randominttransformer()` + ex, err := bloblang.Parse(mapping) + assert.NoError(t, err, "failed to parse the random int transformer") + + res, err := ex.Query(nil) + assert.NoError(t, err) + + assert.Equal(t, int64(4), transformer_utils.GetIntLength(res.(int64))) // Generated int must be the same length as the input int" + assert.IsType(t, res, int64(2)) +} diff --git a/worker/pkg/workflows/datasync/activities/activities.go b/worker/pkg/workflows/datasync/activities/activities.go index d72b9f31f1..decb188566 100644 --- a/worker/pkg/workflows/datasync/activities/activities.go +++ b/worker/pkg/workflows/datasync/activities/activities.go @@ -584,7 +584,7 @@ func computeMutationFunction(col *mgmtv1alpha1.JobMapping) (string, error) { pl := col.Transformer.Config.GetPhoneNumberConfig().PreserveLength ef := col.Transformer.Config.GetPhoneNumberConfig().E164Format ih := col.Transformer.Config.GetPhoneNumberConfig().IncludeHyphens - return fmt.Sprintf("this.%s.phonetransformer(%t, %t, %t)", col.Column, pl, ef, ih), nil + return fmt.Sprintf("phonetransformer(this.%s,%t, %t, %t)", col.Column, pl, ef, ih), nil case "int_phone_number": pl := col.Transformer.Config.GetIntPhoneNumberConfig().PreserveLength return fmt.Sprintf("intphonetransformer(this.%s, %t)", col.Column, pl), nil @@ -602,12 +602,12 @@ func computeMutationFunction(col *mgmtv1alpha1.JobMapping) (string, error) { case "random_int": pl := col.Transformer.Config.GetRandomIntConfig().PreserveLength sl := col.Transformer.Config.GetRandomIntConfig().IntLength - return fmt.Sprintf(`this.%s.randominttransformer(%t, %d)`, col.Column, pl, sl), nil + return fmt.Sprintf(`randominttransformer(this.%s,%t, %d)`, col.Column, pl, sl), nil case "random_float": pl := col.Transformer.Config.GetRandomFloatConfig().PreserveLength bd := col.Transformer.Config.GetRandomFloatConfig().DigitsBeforeDecimal ad := col.Transformer.Config.GetRandomFloatConfig().DigitsAfterDecimal - return fmt.Sprintf(`this.%s.randomfloattransformer(%t, %d, %d)`, col.Column, pl, bd, ad), nil + return fmt.Sprintf(`randomfloattransformer(this.%s, %t, %d, %d)`, col.Column, pl, bd, ad), nil case "gender": ab := col.Transformer.Config.GetGenderConfig().Abbreviate return fmt.Sprintf(`gendertransformer(%t)`, ab), nil