processors_test.go

package gonymizer

import (
	"fmt"
	"math/rand"
	"regexp"
	"strings"
	"testing"

	"github.com/google/uuid"

	"github.com/stretchr/testify/require"
)

var proc = []ProcessorDefinition{
	{
		Name:     "",
		Max:      0,
		Min:      0,
		Variance: 0,
		Comment:  "",
	},
}

var cMap = ColumnMapper{
	TableSchema:     "",
	TableName:       "",
	ColumnName:      "",
	DataType:        "",
	ParentSchema:    "",
	ParentTable:     "",
	ParentColumn:    "",
	OrdinalPosition: 4,
	IsNullable:      false,
	Processors:      proc,
	Comment:         "",
}

// Pre-generated scrambled strings for the text "This is my unscrambled text" using a fixed rng seed
const rngSeed = 5336

var preGeneratedScrambledStrings = []string{
	"Hdva nn ef lujjclagwxv mdtj",
	"Wjpp vj nw idiicqtcaab yyoy",
	"Whcg fx cz qdtmlhiyyse bmnn",
	"Qneu ci nn uknqprmkygn oqic",
	"Awsf mm ga gbafitnmqnv uats",
	"Xvga jz fm ymbeyrhovce zfft",
	"Jcev we tx yozybzwejug wcor",
	"Pktc fh rg zblwnrixhel xddv",
	"Mmfl iu ai lkarkpjxrcm gihj",
	"Xatp qr ud jkwiapqpekp jvmy",
	"Gvom pt zh qngneelcwne bqyk",
	"Uegd el xu afeqhhkrrsg aocg",
	"Vcbu om az wphtejtptqu wmvq",
	"Vdto fu qx xvtchqlafpw vxcg",
	"Zhjf nh sg umiyxwlwobn nwuk",
	"Gnno uf if divtacntszp armf",
	"Gvth xk ma nqpvrdtmylr tqje",
	"Grqz ai tl amqkfzrhhca bjzh",
	"Abzk jp bq nbhbdhtypbl gvxf",
	"Xoxg sl uf dimoothtcqv iwtw",
	"Aiya kb zg ljctcijzuyj fqze",
}

func TestProcessorFunc(t *testing.T) {
}

func TestProcessorAlphaNumericScrambler(t *testing.T) {
	var alphaTest ColumnMapper

	output, err := ProcessorAlphaNumericScrambler(&cMap, "AsDfG10*&")
	require.Nil(t, err)
	require.NotEqual(t, output, "AsDfG0*&")

	alphaTest.ParentSchema = "test_schema"
	alphaTest.ParentTable = "test_table"
	alphaTest.ParentColumn = "test_column"

	outputA, err := ProcessorAlphaNumericScrambler(&alphaTest, "My name is Mud - Pr1mUs")
	require.Nil(t, err)
	outputB, err := ProcessorAlphaNumericScrambler(&alphaTest, "My name is Mud - 111111")
	require.Nil(t, err)
	outputC, err := ProcessorAlphaNumericScrambler(&alphaTest, "My name is Mud - Pr1mUs")
	require.Nil(t, err)

	// outputA != outputB
	require.NotEqual(t, outputA, outputB)
	// outputA === outputC
	require.Equal(t, outputA, outputC)

	escapeSequences := [...]string{"\\\\", "\\t", "\\n", "\\f", "\\b", "\\1", "\\21", "\\337", "\\x1", "\\xF2", "\\u4AE1", "\\UDEAFBEEF"}
	for i := 0; i < len(escapeSequences); i++ {
		outputEscaped, err := ProcessorAlphaNumericScrambler(&alphaTest, escapeSequences[i])
		require.Nil(t, err)
		require.Equal(t, escapeSequences[i], outputEscaped)
	}

	completeEscapeSequences := [...]string{"\\\\", "\\t", "\\n", "\\f", "\\b", "\\337", "\\xF2", "\\u4AE1", "\\UDEAFBEEF"}
	const suffix = "12345"
	for i := 0; i < len(completeEscapeSequences); i++ {
		input := completeEscapeSequences[i] + suffix
		outputEscaped, err := ProcessorAlphaNumericScrambler(&alphaTest, input)
		require.Nil(t, err)
		require.Equal(t, len(outputEscaped), len(input))
		require.True(t, strings.HasPrefix(outputEscaped, completeEscapeSequences[i]))
		require.False(t, strings.HasSuffix(outputEscaped, suffix))
	}
}

func TestProcessorUniqueAlphaNumericScramblerBehavesLikeProcessorAlphaNumericScrambler(t *testing.T) {
	var alphaTest ColumnMapper

	output, err := ProcessorUniqueAlphaNumericScrambler(&cMap, "AsDfG10*&")
	require.Nil(t, err)
	require.NotEqual(t, output, "AsDfG0*&")

	alphaTest.ParentSchema = "test_schema"
	alphaTest.ParentTable = "test_table"
	alphaTest.ParentColumn = "test_column"

	outputA, err := ProcessorUniqueAlphaNumericScrambler(&alphaTest, "My name is Mud - Pr1mUs")
	require.Nil(t, err)
	outputB, err := ProcessorUniqueAlphaNumericScrambler(&alphaTest, "My name is Mud - 111111")
	require.Nil(t, err)
	outputC, err := ProcessorUniqueAlphaNumericScrambler(&alphaTest, "My name is Mud - Pr1mUs")
	require.Nil(t, err)

	// outputA != outputB
	require.NotEqual(t, outputA, outputB)
	// outputA === outputC
	require.Equal(t, outputA, outputC)

	escapeSequences := [...]string{"\\\\", "\\t", "\\n", "\\f", "\\b", "\\1", "\\21", "\\337", "\\x1", "\\xF2", "\\u4AE1", "\\UDEAFBEEF"}
	for i := 0; i < len(escapeSequences); i++ {
		outputEscaped, err := ProcessorUniqueAlphaNumericScrambler(&alphaTest, escapeSequences[i])
		require.Nil(t, err)
		require.Equal(t, escapeSequences[i], outputEscaped)
	}

	completeEscapeSequences := [...]string{"\\\\", "\\t", "\\n", "\\f", "\\b", "\\337", "\\xF2", "\\u4AE1", "\\UDEAFBEEF"}
	const suffix = "12345"
	for i := 0; i < len(completeEscapeSequences); i++ {
		input := completeEscapeSequences[i] + suffix
		outputEscaped, err := ProcessorUniqueAlphaNumericScrambler(&alphaTest, input)
		require.Nil(t, err)
		require.Equal(t, len(outputEscaped), len(input))
		require.True(t, strings.HasPrefix(outputEscaped, completeEscapeSequences[i]))
		require.False(t, strings.HasSuffix(outputEscaped, suffix))
	}
}

func TestProcessorUniqueAlphaNumericScramblerEnsuresUniqueness(t *testing.T) {
	// Set a fixed rng seed
	rand.Seed(rngSeed)

	var found struct{}
	tableKey := fmt.Sprintf("%s.%s.%s", cMap.TableSchema, cMap.TableName, cMap.ColumnName)

	// Pre-populate the mapping to check that the scrambler only returns unique values
	UniqueScrambledColumnValueMap.uniqueMap[tableKey] = &safeStringMap{
		v: make(map[string]struct{}),
	}
	for _, scrambledString := range preGeneratedScrambledStrings {
		UniqueScrambledColumnValueMap.uniqueMap[tableKey].v[scrambledString] = found
	}

	output, err := ProcessorUniqueAlphaNumericScrambler(&cMap, "This is my unscrambled text")

	require.NotNil(t, err)
	require.Equal(t, output, "")
}

func TestProcessorUniqueAlphaNumericScramblerEnsuresUniquenessPerColumn(t *testing.T) {
	// Set a fixed rng seed
	rand.Seed(rngSeed)

	var found struct{}
	tableKey := fmt.Sprintf("%s.%s.%s", cMap.TableSchema, cMap.TableName, cMap.ColumnName)

	// Pre-populate the mapping to check that the scrambler only returns unique values
	UniqueScrambledColumnValueMap.uniqueMap[tableKey] = &safeStringMap{
		v: make(map[string]struct{}),
	}
	for _, scrambledString := range preGeneratedScrambledStrings {
		UniqueScrambledColumnValueMap.uniqueMap[tableKey].v[scrambledString] = found
	}

	// Use a different column than what was pre-populated
	var uniqueColumnTest ColumnMapper
	uniqueColumnTest.TableSchema = "test_schema"
	uniqueColumnTest.TableName = "test_table"
	uniqueColumnTest.ColumnName = "test_column"

	output, err := ProcessorUniqueAlphaNumericScrambler(&uniqueColumnTest, "This is my unscrambled text")

	require.Nil(t, err)
	require.Equal(t, output, "Hdva nn ef lujjclagwxv mdtj")
}

func TestProcessorAddress(t *testing.T) {
	output, err := ProcessorAddress(&cMap, "1234 Testing Lane")
	require.Nil(t, err)
	require.NotEqual(t, output, "1234 Testing Lane")

	output, err = ProcessorAddress(&cMap, "")
	require.Nil(t, err)
	require.NotEqual(t, output, "")
}

func TestProcessorLatitude(t *testing.T) {
	output, err := ProcessorLatitude(&cMap, "42.00")
	require.Nil(t, err)
	require.NotEqual(t, output, 42.00)
}

func TestProcessorLongitude(t *testing.T) {
	output, err := ProcessorLongitude(&cMap, "142.00")
	require.Nil(t, err)
	require.NotEqual(t, output, 142.00)
}

func TestProcessorCity(t *testing.T) {
	output, err := ProcessorCity(&cMap, "Rick and Morty Ville")
	require.Nil(t, err)
	require.NotEqual(t, output, "Rick and Morty Ville")

	output, err = ProcessorCity(&cMap, "")
	require.Nil(t, err)
	require.NotEqual(t, output, "")
}

func TestProcessorEmailAddress(t *testing.T) {
	output, err := ProcessorEmailAddress(&cMap, "rick@morty.example.com")
	require.Nil(t, err)
	require.NotEqual(t, output, "rick@morty.example.com")

	output, err = ProcessorEmailAddress(&cMap, "")
	require.Nil(t, err)
	require.NotEqual(t, output, "")
}

func TestProcessorFirstName(t *testing.T) {
	output, err := ProcessorFirstName(&cMap, "RickMortyRick")
	require.Nil(t, err)
	require.NotEqual(t, output, "RickMortyRick")

	output, err = ProcessorFirstName(&cMap, "")
	require.Nil(t, err)
	require.NotEqual(t, output, "")
}

func TestProcessorFullName(t *testing.T) {
	output, err := ProcessorFullName(&cMap, "Morty & Rick")
	require.Nil(t, err)
	require.NotEqual(t, output, "Morty & Rick")

	output, err = ProcessorFullName(&cMap, "")
	require.Nil(t, err)
	require.NotEqual(t, output, "")
}

func TestProcessorIdentity(t *testing.T) {
	output, err := ProcessorIdentity(&cMap, "Hi Rick!")
	require.Nil(t, err)
	require.Equal(t, output, "Hi Rick!")

	output, err = ProcessorIdentity(&cMap, "")
	require.Nil(t, err)
	require.Equal(t, output, "")
}

func TestProcessorIPv4(t *testing.T) {
	output, err := ProcessorIPv4(&cMap, "127.0.0.1")
	require.Nil(t, err)
	require.NotEqual(t, output, "127.0.0.1")
	re, _ := regexp.Compile(`(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)(\.(25[0-5]|2[0-4][0-9]|[01]?[0-9][0-9]?)){3}`)
	require.True(t, re.MatchString(output))

	output, err = ProcessorIPv4(&cMap, "")
	require.Nil(t, err)
	require.NotEqual(t, output, "")
	require.True(t, re.MatchString(output))
}

func TestProcessorLastName(t *testing.T) {
	output, err := ProcessorLastName(&cMap, "Bye Rick!")
	require.Nil(t, err)
	require.NotEqual(t, output, "Bye Rick!")

	output, err = ProcessorLastName(&cMap, "")
	require.Nil(t, err)
	require.NotEqual(t, output, "")
}

func TestProcessorPhoneNumber(t *testing.T) {
	output, err := ProcessorPhoneNumber(&cMap, "+18885551212")
	require.Nil(t, err)
	require.NotEqual(t, output, "+18885551212")

	output, err = ProcessorPhoneNumber(&cMap, "")
	require.Nil(t, err)
	require.NotEqual(t, output, "")
}

func TestProcessorState(t *testing.T) {
	output, err := ProcessorState(&cMap, "Antarctica")
	require.Nil(t, err)
	require.NotEqual(t, output, "Antarctica")

	output, err = ProcessorState(&cMap, "")
	require.Nil(t, err)
	require.NotEqual(t, output, "")
}

func TestProcessorStateAbbrev(t *testing.T) {
	output, err := ProcessorStateAbbrev(&cMap, "NY")
	require.Nil(t, err)
	require.NotEqual(t, output, "NY")

	output, err = ProcessorStateAbbrev(&cMap, "")
	require.Nil(t, err)
	require.NotEqual(t, output, "")
	require.Len(t, output, 2)
}

func TestProcessorUserName(t *testing.T) {
	output, err := ProcessorUserName(&cMap, "Ricky and Julian")
	require.Nil(t, err)
	require.NotEqual(t, output, "Ricky and Julian")

	output, err = ProcessorUserName(&cMap, "")
	require.Nil(t, err)
	require.NotEqual(t, output, "")
}

func TestProcessorZip(t *testing.T) {
	output, err := ProcessorZip(&cMap, "00000-00")
	require.Nil(t, err)
	require.NotEqual(t, output, "00000-00")

	output, err = ProcessorZip(&cMap, "")
	require.Nil(t, err)
	require.NotEqual(t, output, "")
}

func TestProcessorCompanyName(t *testing.T) {
	output, err := ProcessorCompanyName(&cMap, "RickMortyRick")
	require.Nil(t, err)
	require.NotEqual(t, output, "RickMortyRick")

	output, err = ProcessorCompanyName(&cMap, "")
	require.Nil(t, err)
	require.NotEqual(t, output, "")
}

func TestProcessorRandomBoolean(t *testing.T) {
	output, err := ProcessorRandomBoolean(&cMap, "FALSE")
	require.Nil(t, err)
	require.Contains(t, []string{"TRUE", "FALSE"}, output)
}

func TestProcessorRandomDate(t *testing.T) {
	var failBoats = []string{
		"I AM THE FAIL BOAT!",
		"01.01.1970",
		"01/01/1970",
		"1970.01.01",
		"1970/01/01",
		"",
	}

	output, err := ProcessorRandomDate(&cMap, "1970-01-01")
	require.Nil(t, err)
	require.NotEqual(t, output, "1970-01-01")

	for _, tst := range failBoats {
		output, err = ProcessorRandomDate(&cMap, tst)
		require.NotNil(t, err)
		require.NotEqual(t, output, nil)
	}
}

func TestProcessorRandomDigits(t *testing.T) {
	digits := []string{"12345", "123456", "1234567", "12345678"}
	for _, d := range digits {
		output, err := ProcessorRandomDigits(&cMap, d)
		require.Nil(t, err)
		require.NotEqual(t, d, output)
		require.Equal(t, len(d), len(output))
	}

	output, err := ProcessorRandomDigits(&cMap, "")
	require.Nil(t, err)
	require.Equal(t, "", output)
}

func TestProcessorRandomUUID(t *testing.T) {
	var testUUID uuid.UUID

	testUUID, err := uuid.NewUUID()
	require.Nil(t, err)

	output, err := ProcessorRandomUUID(&cMap, testUUID.String())
	require.Nil(t, err)
	require.NotEqual(t, output, testUUID)

	val, _ := UUIDMap.Get(testUUID)
	if val == testUUID {
		t.Fatalf("UUIDs match\t%s <=> %s", testUUID.String(), val)
	}
	output, err = ProcessorRandomUUID(&cMap, "")
	require.Nil(t, err)
	require.NotEqual(t, output, uuid.Nil.String())
}

func TestProcessorScrubString(t *testing.T) {
	output, err := ProcessorScrubString(&cMap, "Ricky and Julian")
	require.Nil(t, err)
	require.NotEqual(t, output, "Ricky and Julian")

	output, err = ProcessorScrubString(&cMap, "")
	require.Nil(t, err)
	require.Equal(t, output, "")
}

func TestProcessorEmptyJson(t *testing.T) {
	output, err := ProcessorEmptyJson(&cMap, "Pickle Rick!")
	require.Nil(t, err)
	require.Equal(t, output, "{}")

	output, err = ProcessorEmptyJson(&cMap, "{\"name\": \"Pickle Rick!\"}")
	require.Nil(t, err)
	require.Equal(t, output, "{}")
}

func TestRandomizeUUID(t *testing.T) {
	tempUUID := uuid.New().String()
	output, err := ProcessorRandomUUID(&cMap, tempUUID)
	require.Nil(t, err)
	require.NotEqual(t, output, tempUUID)

	output, err = ProcessorRandomUUID(&cMap, "")
	require.Nil(t, err)
	require.NotEqual(t, output, uuid.Nil.String())
}