added custom error to validator functions

tomi77 · tomi77 · commit e2bc4c28caf3 · 2018-08-09T21:10:36.000+02:00
diff --git a/README.md b/README.md
@@ -16,7 +16,19 @@ go get -u github.com/go-passwd/validator
 ~~~go
 import "github.com/go-passwd/validator"
 
-passwordValidator := validator.New(validator.MinLength(5), validator.MaxLength(10))
+passwordValidator := validator.New(validator.MinLength(5, nil), validator.MaxLength(10, nil))
+err := passwordValidator.Validate(form.Password)
+if err != nil {
+  panic(err)
+}
+~~~
+
+You can pass to every validator functions ``customError`` parameter witch will be returned on error instead of default error.
+
+~~~go
+import "github.com/go-passwd/validator"
+
+passwordValidator := validator.New(validator.MinLength(5, errors.New("too short")), validator.MaxLength(10, errors.New("too long")))
 err := passwordValidator.Validate(form.Password)
 if err != nil {
   panic(err)
@@ -30,23 +42,23 @@ if err != nil {
 Check if password length is not lower that defined length.
 
 ~~~go
-passwordValidator := validator.New(validator.MinLength(5))
+passwordValidator := validator.New(validator.MinLength(5, nil))
 ~~~
 
 ### MaxLength
 
 Check if password length is not greater that defined length.
 
 ~~~go
-passwordValidator := validator.New(validator.MaxLength(10))
+passwordValidator := validator.New(validator.MaxLength(10, nil))
 ~~~
 
 ### ContainsAtLeast
 
 Count occurrences of a chars and compares it with required value.
 
 ~~~go
-passwordValidator := validator.New(validator.ContainsAtLeast(5, "abcdefghijklmnopqrstuvwxyz"))
+passwordValidator := validator.New(validator.ContainsAtLeast(5, "abcdefghijklmnopqrstuvwxyz", nil))
 ~~~
 
 ### CommonPassword
@@ -56,13 +68,13 @@ Check if password is a common password.
 Common password list is based on list created by Mark Burnett: https://xato.net/passwords/more-top-worst-passwords/
 
 ~~~go
-passwordValidator := validator.New(validator.CommonPassword())
+passwordValidator := validator.New(validator.CommonPassword(nil))
 ~~~
 
 ### Regex
 
 Check if password match regexp pattern.
 
 ~~~go
-passwordValidator := validator.New(validator.Regex("^\\w+$"))
+passwordValidator := validator.New(validator.Regex("^\\w+$", nil))
 ~~~
diff --git a/common_password.go b/common_password.go
@@ -11,11 +11,14 @@ var commonPasswords = []string{"123456", "123456789", "qwerty", "password", "111
 //
 // The password is rejected if it occurs in a provided list created by Mark Burnett:
 // https://xato.net/passwords/more-top-worst-passwords/
-func CommonPassword() ValidateFunc {
+func CommonPassword(customError error) ValidateFunc {
 	return ValidateFunc(func(password string) error {
 		password = strings.ToLower(password)
 		for _, commonPassword := range commonPasswords {
 			if commonPassword == password {
+				if customError != nil {
+					return customError
+				}
 				return fmt.Errorf("Password can't be a commonly used password")
 			}
 		}
diff --git a/common_password_test.go b/common_password_test.go
@@ -1,9 +1,12 @@
 package validator
 
-import "fmt"
+import (
+	"errors"
+	"fmt"
+)
 
 func ExampleCommonPassword() {
-	passwordValidator := CommonPassword()
+	passwordValidator := CommonPassword(nil)
 	fmt.Println(passwordValidator("password"))
 	fmt.Println(passwordValidator("qaz123"))
 	fmt.Println(passwordValidator("pa$$w0rd@"))
@@ -12,3 +15,11 @@ func ExampleCommonPassword() {
 	// Password can't be a commonly used password
 	// <nil>
 }
+
+func ExampleCommonPassword_customError() {
+	err := errors.New("custom error message")
+	passwordValidator := CommonPassword(err)
+	fmt.Println(passwordValidator("password"))
+	// Output:
+	// custom error message
+}
diff --git a/contains_at_least.go b/contains_at_least.go
@@ -6,7 +6,7 @@ import (
 )
 
 // ContainsAtLeast returns a ValidateFunc that count occurrences of a chars and compares it with required value
-func ContainsAtLeast(chars string, occurrences int) ValidateFunc {
+func ContainsAtLeast(chars string, occurrences int, customError error) ValidateFunc {
 	return ValidateFunc(func(password string) error {
 		cnt := 0
 		aPassword := strings.Split(password, "")
@@ -18,6 +18,9 @@ func ContainsAtLeast(chars string, occurrences int) ValidateFunc {
 			}
 		}
 		if cnt < occurrences {
+			if customError != nil {
+				return customError
+			}
 			return fmt.Errorf("Password must contains at least %d chars from %s", occurrences, chars)
 		}
 		return nil
diff --git a/contains_at_least_test.go b/contains_at_least_test.go
@@ -1,9 +1,12 @@
 package validator
 
-import "fmt"
+import (
+	"errors"
+	"fmt"
+)
 
 func ExampleContainsAtLeast() {
-	passwordValidator := ContainsAtLeast("abcdefghijklmnopqrstuvwxyz", 4)
+	passwordValidator := ContainsAtLeast("abcdefghijklmnopqrstuvwxyz", 4, nil)
 	fmt.Println(passwordValidator("password"))
 	fmt.Println(passwordValidator("PASSWORD"))
 	fmt.Println(passwordValidator("passWORD"))
@@ -12,3 +15,11 @@ func ExampleContainsAtLeast() {
 	// Password must contains at least 4 chars from abcdefghijklmnopqrstuvwxyz
 	// <nil>
 }
+
+func ExampleContainsAtLeast_customError() {
+	err := errors.New("custom error message")
+	passwordValidator := ContainsAtLeast("abcdefghijklmnopqrstuvwxyz", 4, err)
+	fmt.Println(passwordValidator("PASSWORD"))
+	// Output:
+	// custom error message
+}
diff --git a/max_length.go b/max_length.go
@@ -3,9 +3,12 @@ package validator
 import "fmt"
 
 // MaxLength returns a ValidateFunc that check if password length is not greater that "length"
-func MaxLength(length int) ValidateFunc {
+func MaxLength(length int, customError error) ValidateFunc {
 	return ValidateFunc(func(password string) error {
 		if len(password) > length {
+			if customError != nil {
+				return customError
+			}
 			return fmt.Errorf("Password length must be not greater that %d chars", length)
 		}
 		return nil
diff --git a/max_length_test.go b/max_length_test.go
@@ -1,9 +1,12 @@
 package validator
 
-import "fmt"
+import (
+	"errors"
+	"fmt"
+)
 
 func ExampleMaxLength() {
-	passwordValidator := MaxLength(5)
+	passwordValidator := MaxLength(5, nil)
 	fmt.Println(passwordValidator("password"))
 	fmt.Println(passwordValidator("pass"))
 	fmt.Println(passwordValidator("passw"))
@@ -12,3 +15,11 @@ func ExampleMaxLength() {
 	// <nil>
 	// <nil>
 }
+
+func ExampleMaxLength_customError() {
+	err := errors.New("custom error message")
+	passwordValidator := MaxLength(5, err)
+	fmt.Println(passwordValidator("password"))
+	// Output:
+	// custom error message
+}
diff --git a/min_length.go b/min_length.go
@@ -3,9 +3,12 @@ package validator
 import "fmt"
 
 // MinLength returns a ValidateFunc that check if password length is not lower that "length"
-func MinLength(length int) ValidateFunc {
+func MinLength(length int, customError error) ValidateFunc {
 	return ValidateFunc(func(password string) error {
 		if len(password) < length {
+			if customError != nil {
+				return customError
+			}
 			return fmt.Errorf("Password length must be not lower that %d chars", length)
 		}
 		return nil
diff --git a/min_length_test.go b/min_length_test.go
@@ -1,9 +1,12 @@
 package validator
 
-import "fmt"
+import (
+	"errors"
+	"fmt"
+)
 
 func ExampleMinLength() {
-	passwordValidator := MinLength(5)
+	passwordValidator := MinLength(5, nil)
 	fmt.Println(passwordValidator("password"))
 	fmt.Println(passwordValidator("pass"))
 	fmt.Println(passwordValidator("passw"))
@@ -12,3 +15,11 @@ func ExampleMinLength() {
 	// Password length must be not lower that 5 chars
 	// <nil>
 }
+
+func ExampleMinLength_customError() {
+	err := errors.New("custom error message")
+	passwordValidator := MinLength(5, err)
+	fmt.Println(passwordValidator("pass"))
+	// Output:
+	// custom error message
+}
diff --git a/noop.go b/noop.go
@@ -1,8 +1,8 @@
 package validator
 
-// Noop returns a ValidateFunc that always truth
-func Noop() ValidateFunc {
+// Noop returns a ValidateFunc that always return custom error
+func Noop(customError error) ValidateFunc {
 	return ValidateFunc(func(password string) error {
-		return nil
+		return customError
 	})
 }
diff --git a/noop_test.go b/noop_test.go
@@ -1,10 +1,21 @@
 package validator
 
-import "fmt"
+import (
+	"errors"
+	"fmt"
+)
 
 func ExampleNoop() {
-	passwordValidator := Noop()
+	passwordValidator := Noop(nil)
 	fmt.Println(passwordValidator("password"))
 	// Output:
 	// <nil>
 }
+
+func ExampleNoop_customError() {
+	err := errors.New("custom error message")
+	passwordValidator := Noop(err)
+	fmt.Println(passwordValidator("password"))
+	// Output:
+	// custom error message
+}
diff --git a/regex.go b/regex.go
@@ -6,13 +6,16 @@ import (
 )
 
 // Regex returns ValidateFunc that check if password match regexp pattern
-func Regex(pattern string) ValidateFunc {
+func Regex(pattern string, customError error) ValidateFunc {
 	return ValidateFunc(func(password string) error {
 		matched, err := regexp.MatchString(pattern, password)
 		if err != nil {
 			return err
 		}
 		if matched {
+			if customError != nil {
+				return customError
+			}
 			return fmt.Errorf("Password shouldn't match \"%s\" pattern", pattern)
 		}
 		return nil
diff --git a/regex_test.go b/regex_test.go
@@ -1,14 +1,23 @@
 package validator
 
 import (
+	"errors"
 	"fmt"
 )
 
 func ExampleRegex() {
-	passwordValidator := Regex("^\\w+$")
+	passwordValidator := Regex("^\\w+$", nil)
 	fmt.Println(passwordValidator("password"))
 	fmt.Println(passwordValidator("pa$$w0rd"))
 	// Output:
 	// Password shouldn't match "^\w+$" pattern
 	// <nil>
 }
+
+func ExampleRegex_customError() {
+	err := errors.New("custom error message")
+	passwordValidator := Regex("^\\w+$", err)
+	fmt.Println(passwordValidator("password"))
+	// Output:
+	// custom error message
+}
diff --git a/validator_test.go b/validator_test.go
@@ -16,11 +16,11 @@ func TestValidator_empty(t *testing.T) {
 var password = "password"
 
 func ExampleNew() {
-	New(MinLength(5), MaxLength(10))
+	New(MinLength(5, nil), MaxLength(10, nil))
 }
 
 func TestNewValidator(t *testing.T) {
-	passwordValidator := New(MinLength(5), MaxLength(10))
+	passwordValidator := New(MinLength(5, nil), MaxLength(10, nil))
 	assert.Len(t, *passwordValidator, 2)
 	assert.Nil(t, passwordValidator.Validate("password"))
 	assert.Nil(t, passwordValidator.Validate("pass1"))
@@ -30,7 +30,7 @@ func TestNewValidator(t *testing.T) {
 }
 
 func ExampleValidator_Validate() {
-	passwordValidator := Validator{MinLength(5), MaxLength(10)}
+	passwordValidator := Validator{MinLength(5, nil), MaxLength(10, nil)}
 	fmt.Println(passwordValidator.Validate("password"))
 	fmt.Println(passwordValidator.Validate("pass1"))
 	fmt.Println(passwordValidator.Validate("password12"))

Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ import (`
`6`	`6`	`)`
`7`	`7`
`8`	`8`	`// ContainsAtLeast returns a ValidateFunc that count occurrences of a chars and compares it with required value`
`9`		`-func ContainsAtLeast(chars string, occurrences int) ValidateFunc {`
	`9`	`+func ContainsAtLeast(chars string, occurrences int, customError error) ValidateFunc {`
`10`	`10`	`return ValidateFunc(func(password string) error {`
`11`	`11`	`cnt := 0`
`12`	`12`	`aPassword := strings.Split(password, "")`
`@@ -18,6 +18,9 @@ func ContainsAtLeast(chars string, occurrences int) ValidateFunc {`
`18`	`18`	`}`
`19`	`19`	`}`
`20`	`20`	`if cnt < occurrences {`
	`21`	`+ if customError != nil {`
	`22`	`+ return customError`
	`23`	`+ }`
`21`	`24`	`return fmt.Errorf("Password must contains at least %d chars from %s", occurrences, chars)`
`22`	`25`	`}`
`23`	`26`	`return nil`