Initial cloud-services repo - gateway service + pkg modules

pkg/utils/randomvalues/randomvalues_test.go

@@ -0,0 +1,200 @@
+package randomvalues_test
+
+import (
+	b64 "encoding/base64"
+	"fmt"
+	"testing"
+
+	"fiskerinc.com/modules/testhelper"
+	"fiskerinc.com/modules/utils/randomvalues"
+)
+
+func TestRandomString(t *testing.T) {
+	instance := randomvalues.NewGenerator("")
+
+	type TestCase struct {
+		Length int
+	}
+
+	tests := []TestCase{
+		{
+			Length: 12,
+		},
+		{
+			Length: 32,
+		},
+		{
+			Length: 10,
+		},
+		{
+			Length: 100,
+		},
+	}
+
+	for _, test := range tests {
+		name := fmt.Sprintf("%v Length", test.Length)
+		result, err := instance.GetString(test.Length)
+		if err != nil {
+			t.Errorf(testhelper.TestErrorTemplate, name, nil, err)
+		}
+		if len(result) != test.Length {
+			t.Errorf(testhelper.TestErrorTemplate, name, test.Length, len(result))
+		}
+	}
+}
+
+func TestRandomUInt64(t *testing.T) {
+	generated := map[uint64]int{}
+	instance := randomvalues.NewGenerator("")
+
+	for i := 0; i < 1000; i++ {
+		value, err := instance.GetUInt64()
+		if err != nil {
+			t.Errorf(testhelper.TestErrorTemplate, "RandomeUInt64", nil, err)
+		}
+
+		if result, ok := generated[value]; ok {
+			generated[value] = result + 1
+		} else {
+			generated[value] = 1
+		}
+	}
+
+	for key, value := range generated {
+		if value > 1 {
+			t.Errorf(testhelper.TestErrorTemplate, fmt.Sprintf("%v occurance", key), 1, value)
+		}
+	}
+}
+
+func TestRandomHex(t *testing.T) {
+	generated := map[string]int{}
+	instance := randomvalues.NewGenerator("")
+
+	for i := 0; i < 1000; i++ {
+		value, err := instance.GetHex()
+		if err != nil {
+			t.Errorf(testhelper.TestErrorTemplate, "RandomeHex", nil, err)
+		}
+
+		if result, ok := generated[value]; ok {
+			generated[value] = result + 1
+		} else {
+			generated[value] = 1
+		}
+	}
+
+	for key, value := range generated {
+		if value > 1 {
+			t.Errorf(testhelper.TestErrorTemplate, fmt.Sprintf("%v occurance", key), 1, value)
+		}
+	}
+}
+
+func TestUniformHex(t *testing.T) {
+	repeats := 0
+
+	generated := map[string]int{}
+	instance := randomvalues.NewGenerator("")
+
+	for i := 0; i < 1000000; i++ {
+		value, err := instance.GetUniformDistHex()
+		if err != nil {
+			t.Errorf(testhelper.TestErrorTemplate, "UniformHex", nil, err)
+		}
+
+		if result, ok := generated[value]; ok {
+			generated[value] = result + 1
+			repeats += 1
+		} else {
+			generated[value] = 1
+		}
+	}
+
+	for key, value := range generated {
+		if value > 1 {
+			t.Errorf(testhelper.TestErrorTemplate, fmt.Sprintf("%v occurance", key), 1, value)
+		}
+	}
+
+	if repeats > 0 {
+		t.Errorf(testhelper.TestErrorTemplate, "Repeated", 0, repeats)
+	}
+}
+
+func TestRandomBytes(t *testing.T) {
+	keysize := 16
+	generated := map[string]int{}
+	instance := randomvalues.NewGenerator("")
+
+	for i := 0; i < 1000; i++ {
+		value, err := instance.GetBytes(keysize)
+		if err != nil {
+			t.Errorf(testhelper.TestErrorTemplate, "RandomBytes", nil, err)
+		}
+
+		val := b64.StdEncoding.EncodeToString(value)
+		if result, ok := generated[val]; ok {
+			generated[val] = result + 1
+		} else {
+			generated[val] = 1
+		}
+	}
+
+	for key, value := range generated {
+		if value > 1 {
+			t.Errorf(testhelper.TestErrorTemplate, fmt.Sprintf("%v occurance", key), 1, value)
+		}
+		decoded, err := b64.StdEncoding.DecodeString(key)
+		if err != nil {
+			t.Errorf(testhelper.TestErrorTemplate, "Decode string error", nil, err)
+		}
+		if len(decoded) != keysize {
+			t.Errorf(testhelper.TestErrorTemplate, "Decoded string length", keysize, len(decoded))
+		}
+	}
+}
+
+func BenchmarkRandomString(b *testing.B) {
+	instance := randomvalues.NewGenerator("")
+
+	for i := 0; i < b.N; i++ {
+		_, err := instance.GetString(32)
+		if err != nil {
+			b.Error(err)
+		}
+	}
+}
+
+func BenchmarkRandomUInt64(b *testing.B) {
+	instance := randomvalues.NewGenerator("")
+
+	for i := 0; i < b.N; i++ {
+		_, err := instance.GetUInt64()
+		if err != nil {
+			b.Error(err)
+		}
+	}
+}
+
+func BenchmarkRandomHex(b *testing.B) {
+	instance := randomvalues.NewGenerator("")
+
+	for i := 0; i < b.N; i++ {
+		_, err := instance.GetHex()
+		if err != nil {
+			b.Error(err)
+		}
+	}
+}
+
+func BenchmarkUniformDistHex(b *testing.B) {
+	instance := randomvalues.NewGenerator("")
+
+	for i := 0; i < b.N; i++ {
+		_, err := instance.GetUniformDistHex()
+		if err != nil {
+			b.Error(err)
+		}
+	}
+}