fixes logic in fullname transformer with tests (#3537)

Author: nickzelei

worker/pkg/benthos/transformers/transform_full_name.go

@@ -119,7 +119,28 @@ func transformFullName(
 	maxValue := maxLength
 
 	if preserveLength {
+		if strings.TrimSpace(name) == "" {
+			// If the input is all spaces, return a string of spaces of the same length
+			output := strings.Repeat(" ", len(name))
+			return &output, nil
+		}
+
 		firstname, lastname := splitEvenly(name)
+		if lastname == "" {
+			// Single name: generate two names, join with space, pad/truncate
+			minFirst := int64(1)
+			minLast := int64(1)
+			newfirstname, _ := generateRandomFirstName(randomizer, &minFirst, minFirst)
+			newlastname, _ := generateRandomLastName(randomizer, &minLast, minLast)
+			fullname := fmt.Sprintf("%s %s", newfirstname, newlastname)
+			if len(fullname) < len(name) {
+				fullname += transformer_utils.GetRandomCharacterString(randomizer, int64(len(name)-len(fullname)))
+			} else if len(fullname) > len(name) {
+				fullname = fullname[:len(name)]
+			}
+			return &fullname, nil
+		}
+
 		minFirst := int64(len(firstname))
 		newfirstname, _ := generateRandomFirstName(randomizer, &minFirst, minFirst)
 		if newfirstname == "" {
@@ -131,19 +152,37 @@ func transformFullName(
 				)
 			}
 		}
+		// Calculate remaining length for last name (accounting for space)
+		remainingLength := int64(len(name)) - int64(len(newfirstname)) - 1 // -1 for space
+		if remainingLength < 0 {
+			remainingLength = 0
+		}
 		minLast := int64(len(lastname))
+		if minLast == 0 {
+			minLast = remainingLength
+		}
 		newlastname, _ := generateRandomLastName(randomizer, &minLast, minLast)
 		if newlastname == "" {
-			newfirstname, _ = generateRandomLastName(randomizer, nil, minLast)
+			newlastname, _ = generateRandomLastName(randomizer, nil, minLast)
 			if int64(len(newlastname)) != minLast {
 				newlastname += transformer_utils.GetRandomCharacterString(
 					randomizer,
-					minFirst-int64(len(newlastname)),
+					minLast-int64(len(newlastname)),
 				)
 			}
 		}
 		if newfirstname != "" && newlastname != "" {
 			fullname := fmt.Sprintf("%s %s", newfirstname, newlastname)
+			if int64(len(fullname)) != int64(len(name)) {
+				if int64(len(fullname)) < int64(len(name)) {
+					fullname += transformer_utils.GetRandomCharacterString(
+						randomizer,
+						int64(len(name))-int64(len(fullname)),
+					)
+				} else {
+					fullname = fullname[:len(name)]
+				}
+			}
 			return &fullname, nil
 		}
 	}

worker/pkg/benthos/transformers/transform_full_name_test.go

@@ -2,6 +2,7 @@ package transformers
 
 import (
 	"fmt"
+	"strings"
 	"testing"
 
 	"github.com/nucleuscloud/neosync/worker/pkg/rng"
@@ -85,3 +86,177 @@ func Test_TransformFullNamelTransformer_NoOptions(t *testing.T) {
 	assert.NoError(t, err)
 	assert.NotEmpty(t, res)
 }
+
+func Test_TransformFullNamePreserveLengthSingleName(t *testing.T) {
+	t.Run("single name with preserve length", func(t *testing.T) {
+		randomizer := rng.New(1)
+		singleName := "John"
+		expectedLength := int64(len(singleName))
+
+		// Debug: Let's see what splitEvenly returns
+		firstname, lastname := splitEvenly(singleName)
+		t.Logf("splitEvenly('%s') = firstname: '%s' (len: %d), lastname: '%s' (len: %d)",
+			singleName, firstname, len(firstname), lastname, len(lastname))
+
+		res, err := transformFullName(randomizer, singleName, true, maxCharacterLimit)
+
+		assert.NoError(t, err)
+		assert.NotNil(t, res)
+		t.Logf("Input: '%s' (len: %d), Output: '%s' (len: %d)",
+			singleName, len(singleName), *res, len(*res))
+		assert.Equal(t, expectedLength, int64(len(*res)), "The output should be the same length as the input")
+		assert.Contains(t, *res, " ", "Should contain a space between first and last name")
+	})
+
+	t.Run("single name with preserve length via bloblang", func(t *testing.T) {
+		singleName := "John"
+		mapping := fmt.Sprintf(`root = transform_full_name(value:%q,preserve_length:true,max_length:%d)`, singleName, maxCharacterLimit)
+		ex, err := bloblang.Parse(mapping)
+		assert.NoError(t, err, "failed to parse the full name transformer")
+
+		res, err := ex.Query(singleName)
+		assert.NoError(t, err)
+
+		resStr, ok := res.(*string)
+		if !ok {
+			t.Errorf("Expected *string, got %T", res)
+			return
+		}
+
+		assert.NotNil(t, resStr)
+		t.Logf("Bloblang Input: '%s' (len: %d), Output: '%s' (len: %d)",
+			singleName, len(singleName), *resStr, len(*resStr))
+		assert.Equal(t, len(singleName), len(*resStr), "Generated full name must be as long as input name")
+		assert.Contains(t, *resStr, " ", "Should contain a space between first and last name")
+	})
+}
+
+func Test_TransformFullNamePreserveLengthShortLastName(t *testing.T) {
+	t.Run("name with short last name", func(t *testing.T) {
+		randomizer := rng.New(1)
+		nameWithShortLastName := "John A"
+		expectedLength := int64(len(nameWithShortLastName))
+
+		res, err := transformFullName(randomizer, nameWithShortLastName, true, maxCharacterLimit)
+
+		assert.NoError(t, err)
+		assert.NotNil(t, res)
+		assert.Equal(t, expectedLength, int64(len(*res)), "The output should be the same length as the input")
+		assert.Contains(t, *res, " ", "Should contain a space between first and last name")
+	})
+}
+
+func Test_TransformFullNamePreserveLengthMultipleWords(t *testing.T) {
+	t.Run("name with multiple words", func(t *testing.T) {
+		randomizer := rng.New(1)
+		multiWordName := "John van der Berg"
+		expectedLength := int64(len(multiWordName))
+
+		res, err := transformFullName(randomizer, multiWordName, true, maxCharacterLimit)
+
+		assert.NoError(t, err)
+		assert.NotNil(t, res)
+		assert.Equal(t, expectedLength, int64(len(*res)), "The output should be the same length as the input")
+		assert.Contains(t, *res, " ", "Should contain spaces between name parts")
+	})
+}
+
+func Test_TransformFullNamePreserveLengthEdgeCases(t *testing.T) {
+	t.Run("very short name", func(t *testing.T) {
+		randomizer := rng.New(1)
+		shortName := "A"
+		expectedLength := int64(len(shortName))
+
+		res, err := transformFullName(randomizer, shortName, true, maxCharacterLimit)
+
+		assert.NoError(t, err)
+		assert.NotNil(t, res)
+		assert.Equal(t, expectedLength, int64(len(*res)), "The output should be the same length as the input")
+	})
+
+	t.Run("name with only spaces", func(t *testing.T) {
+		randomizer := rng.New(1)
+		spaceName := "   "
+
+		res, err := transformFullName(randomizer, spaceName, true, maxCharacterLimit)
+
+		assert.NoError(t, err)
+		assert.NotNil(t, res)
+		assert.Equal(t, int64(len(spaceName)), int64(len(*res)), "The output should be the same length as the input")
+	})
+}
+
+func Test_SplitEvenly(t *testing.T) {
+	t.Run("even number of words", func(t *testing.T) {
+		first, last := splitEvenly("John Smith")
+		assert.Equal(t, "John", first)
+		assert.Equal(t, "Smith", last)
+	})
+
+	t.Run("odd number of words", func(t *testing.T) {
+		first, last := splitEvenly("John van der Berg")
+		assert.Equal(t, "John van", first)
+		assert.Equal(t, "der Berg", last)
+	})
+
+	t.Run("single word", func(t *testing.T) {
+		first, last := splitEvenly("John")
+		assert.Equal(t, "John", first)
+		assert.Equal(t, "", last)
+	})
+
+	t.Run("empty string", func(t *testing.T) {
+		first, last := splitEvenly("")
+		assert.Equal(t, "", first)
+		assert.Equal(t, "", last)
+	})
+
+	t.Run("multiple spaces", func(t *testing.T) {
+		first, last := splitEvenly("John  Smith")
+		assert.Equal(t, "John", first)
+		assert.Equal(t, "Smith", last)
+	})
+}
+
+func Test_TransformFullNamePreserveLength_FirstNameFallback(t *testing.T) {
+	t.Run("first name fallback to random string padding", func(t *testing.T) {
+		randomizer := rng.New(1)
+		// Use a name with a length that is unlikely to exist in the corpus (e.g., 1 character)
+		name := "A B"
+		res, err := transformFullName(randomizer, name, true, maxCharacterLimit)
+		assert.NoError(t, err)
+		assert.NotNil(t, res)
+		assert.Equal(t, len(name), len(*res), "Output should match input length")
+		assert.Contains(t, *res, " ", "Should contain a space")
+		// The first and last name parts should each be 1 character (plus the space)
+		parts := strings.SplitN(*res, " ", 2)
+		if len(parts) == 2 {
+			assert.Len(t, parts[0], 1, "First name part should be 1 char (padded if needed)")
+			assert.Len(t, parts[1], 1, "Last name part should be 1 char (padded if needed)")
+		}
+	})
+}
+
+func Test_TransformFullNamePreserveLength_PadAndTruncate(t *testing.T) {
+	t.Run("padding when generated name is shorter than input", func(t *testing.T) {
+		randomizer := rng.New(1)
+		// Use a name with a length that is longer than typical generated names
+		name := "John Smith ExtraLongName"
+		res, err := transformFullName(randomizer, name, true, maxCharacterLimit)
+		assert.NoError(t, err)
+		assert.NotNil(t, res)
+		assert.Equal(t, len(name), len(*res), "Output should match input length")
+		assert.Contains(t, *res, " ", "Should contain a space")
+	})
+
+	t.Run("truncation when generated name is longer than input", func(t *testing.T) {
+		randomizer := rng.New(1)
+		// Use a very short name so the generated name will be truncated
+		name := "Jo Sm"
+		res, err := transformFullName(randomizer, name, true, maxCharacterLimit)
+		assert.NoError(t, err)
+		assert.NotNil(t, res)
+		assert.Equal(t, len(name), len(*res), "Output should match input length")
+		assert.Contains(t, *res, " ", "Should contain a space")
+	})
+}