add min/max length validation, improve tests

email_test.go

@@ -2,26 +2,27 @@ package validate
 
 import "testing"
 
-func TestInvalidEmail(t *testing.T) {
-	valid := []string{
-		"testexample.com",
+func TestEmail(t *testing.T) {
+	type TestCase struct {
+		Input string
+		Err   bool
 	}
 
-	for _, email := range valid {
-		if err := Email(email); err == nil {
-			t.Errorf("%s is not a valid email", email)
-		}
-	}
+	testCases := []TestCase{
+		{Input: "test@example.com"},
+		{Input: "testexample.com", Err: true},
 	}
 
-func TestValidEmail(t *testing.T) {
-	valid := []string{
-		"test@example.com",
+	for _, testCase := range testCases {
+		err := Email(testCase.Input)
+		if testCase.Err {
+			if err == nil {
+				t.Errorf("Expected %q to be an invalid email; got nil", testCase.Input)
+			}
+		} else {
+			if err != nil {
+				t.Errorf("Expected %q to be a valid email; got %s", testCase.Input, err)
 			}
-
-	for _, email := range valid {
-		if err := Email(email); err != nil {
-			t.Errorf("%s is a valid email", email)
 		}
 	}
 }

length.go

@@ -0,0 +1,32 @@
+package validate
+
+import (
+	"errors"
+	"fmt"
+)
+
+// MaxLength validates the length of a string as being less than or equal to a given maximum.
+func MaxLength(l int) func(string) error {
+	return func(value string) error {
+		if len(value) > l {
+			if l != 1 {
+				return fmt.Errorf("Must not be longer than %d characters", l)
+			}
+			return errors.New("Must not be longer than 1 character")
+		}
+		return nil
+	}
+}
+
+// MinLength validates the length of a string as being greater than or equal to a given minimum.
+func MinLength(l int) func(string) error {
+	return func(value string) error {
+		if len(value) < l {
+			if l != 1 {
+				return fmt.Errorf("Must not be shorter than %d characters", l)
+			}
+			return errors.New("Must not be shorter than 1 character")
+		}
+		return nil
+	}
+}

length_test.go

@@ -0,0 +1,65 @@
+package validate
+
+import "testing"
+
+func TestMaxLength(t *testing.T) {
+	type TestCase struct {
+		L     int
+		Input string
+		Err   bool
+	}
+
+	testCases := []TestCase{
+		{L: 8, Input: "abcd"},
+		{L: 8, Input: "abcdefgh"},
+		{L: 8, Input: "abcd efg"},
+		{L: 8, Input: "abcdefghi", Err: true},
+	}
+
+	for _, testCase := range testCases {
+		t.Logf("Max length %d for %q", testCase.L, testCase.Input)
+
+		f := MaxLength(testCase.L)
+		err := f(testCase.Input)
+		if testCase.Err {
+			if err == nil {
+				t.Error("Expected an error; got nil")
+			}
+		} else {
+			if err != nil {
+				t.Errorf("Expected nil; got %s", err)
+			}
+		}
+	}
+}
+
+func TestMinLength(t *testing.T) {
+	type TestCase struct {
+		L     int
+		Input string
+		Err   bool
+	}
+
+	testCases := []TestCase{
+		{L: 8, Input: "abcd", Err: true},
+		{L: 8, Input: "abcdefgh"},
+		{L: 8, Input: "abcd efg"},
+		{L: 8, Input: "abcdefghi"},
+	}
+
+	for _, testCase := range testCases {
+		t.Logf("Min length %d for %q", testCase.L, testCase.Input)
+
+		f := MinLength(testCase.L)
+		err := f(testCase.Input)
+		if testCase.Err {
+			if err == nil {
+				t.Error("Expected an error; got nil")
+			}
+		} else {
+			if err != nil {
+				t.Errorf("Expected nil; got %s", err)
+			}
+		}
+	}
+}

uuid_test.go

@@ -2,31 +2,32 @@ package validate
 
 import "testing"
 
-func TestInvalidUUID(t *testing.T) {
-	invalid := []string{
-		"Not a UUID",
-		"00000000-00-0000-0000-00000000000000",
-		"00000000000000000000000000000000",
-		"01234567-89ab-cdef-ghij-klmnopqrstuv",
+func TestUUID(t *testing.T) {
+	type TestCase struct {
+		Input string
+		Err   bool
 	}
 
-	for _, uuid := range invalid {
-		if err := UUID(uuid); err == nil {
-			t.Errorf("%s is not a valid UUID", uuid)
-		}
-	}
+	testCases := []TestCase{
+		{Input: "00000000-0000-0000-0000-000000000000"},
+		{Input: "01234567-89ab-cdef-0123-456789abcdef"},
+		{Input: "abcdef01-2345-6789-abcd-ef0123456789"},
+		{Input: "Not a UUID", Err: true},
+		{Input: "00000000-00-0000-0000-00000000000000", Err: true},
+		{Input: "00000000000000000000000000000000", Err: true},
+		{Input: "01234567-89ab-cdef-ghij-klmnopqrstuv", Err: true},
 	}
 
-func TestValidUUID(t *testing.T) {
-	valid := []string{
-		"00000000-0000-0000-0000-000000000000",
-		"01234567-89ab-cdef-0123-456789abcdef",
-		"abcdef01-2345-6789-abcd-ef0123456789",
+	for _, testCase := range testCases {
+		err := UUID(testCase.Input)
+		if testCase.Err {
+			if err == nil {
+				t.Errorf("Expected %q to be an invalid UUID; got nil", testCase.Input)
+			}
+		} else {
+			if err != nil {
+				t.Errorf("Expected %q to be a valid UUID; got %s", testCase.Input, err)
 			}
-
-	for _, uuid := range valid {
-		if err := UUID(uuid); err != nil {
-			t.Errorf("%s is a valid UUID", uuid)
 		}
 	}
 }