Merge pull request #10 from ninedraft/dev

Custom error factory support

Author: storozhukBM

go.mod

@@ -0,0 +1,3 @@
+module github.com/storozhukBM/verifier
+
+go 1.12

verifier.go

@@ -18,11 +18,19 @@ import (
 func New() *Verify {
 	v := &Verify{
 		creationStack: captureCreationStack(),
+		errFactory:    fmt.Errorf,
 	}
 	runtime.SetFinalizer(v, printWarningOnUncheckedVerification)
 	return v
 }
 
+// WithErrFactory sets error construction function (default: fmt.Errorf).
+// Use it to set custom error type of error, returned by Verify.GetError().
+func (v *Verify) WithErrFactory(factory func(string, ...interface{}) error) *Verify {
+	v.errFactory = factory
+	return v
+}
+
 // Offensive creates verification instance (not-recommended).
 // It tracks verification state and stops application process when founds unchecked verification.
 // If you forget to check internal error, using `GetError` or `PanicOnError` methods,
@@ -45,6 +53,7 @@ func Offensive() *Verify {
 type Verify struct {
 	creationStack []uintptr
 	err           error
+	errFactory    func(string, ...interface{}) error
 	checked       bool
 }
 
@@ -72,29 +81,28 @@ func (v *Verify) WithError(positiveCondition bool, err error) *Verify {
 // That verifies condition passed as first argument.
 // If `positiveCondition == true`, verification will proceed for other checks.
 // If `positiveCondition == false`, internal state will be filled with error,
-// using message argument as format in fmt.Errorf(message, args...).
+// using message argument as format in error factory func(message, args...) (default: fmt.Errorf).
 // After the first failed verification all others won't count and predicates won't be evaluated.
 func (v *Verify) That(positiveCondition bool, message string, args ...interface{}) *Verify {
 	vObj := v
 	if v == nil {
 		vObj = &Verify{}
 	}
-
 	vObj.checked = false
 	if vObj.err != nil {
 		return vObj
 	}
 	if positiveCondition {
 		return vObj
 	}
-	vObj.err = fmt.Errorf(message, args...)
+	vObj.err = vObj.errorf(message, args...)
 	return vObj
 }
 
 // That evaluates predicate passed as first argument.
 // If `predicate() == true`, verification will proceed for other checks.
 // If `predicate() == false`, internal state will be filled with error,
-// using message argument as format in fmt.Errorf(message, args...).
+// using message argument as format in error factory func(message, args...) (default: fmt.Errorf).
 // After the first failed verification all others won't count and predicates won't be evaluated.
 func (v *Verify) Predicate(predicate func() bool, message string, args ...interface{}) *Verify {
 	vObj := v
@@ -108,7 +116,7 @@ func (v *Verify) Predicate(predicate func() bool, message string, args ...interf
 	if predicate() {
 		return vObj
 	}
-	vObj.err = fmt.Errorf(message, args...)
+	vObj.err = vObj.errorf(message, args...)
 	return vObj
 }
 
@@ -144,6 +152,13 @@ func (v *Verify) String() string {
 	return "verification failure: " + v.err.Error()
 }
 
+func (v *Verify) errorf(message string, args ...interface{}) error {
+	if v.errFactory == nil {
+		v.errFactory = fmt.Errorf
+	}
+	return v.errFactory(message, args...)
+}
+
 func (v *Verify) printCreationStack(writer io.Writer) {
 	frames := runtime.CallersFrames(v.creationStack)
 	for {

verifier_test.go

@@ -3,14 +3,18 @@ package verifier_test
 import (
 	"bytes"
 	"errors"
-	"github.com/storozhukBM/verifier"
+	"fmt"
 	"math/rand"
 	"os"
+	"os/exec"
+	"reflect"
 	"runtime"
 	"strings"
 	"sync"
 	"testing"
 	"time"
+
+	"github.com/storozhukBM/verifier"
 )
 
 func TestVerifier_positive_conditions(t *testing.T) {
@@ -203,6 +207,61 @@ func TestVerifier_negative_nil_panic(t *testing.T) {
 	verify.PanicOnError()
 }
 
+type TestError struct {
+	message string
+}
+
+func NewTestError(msg string, args ...interface{}) error {
+	return TestError{
+		message: fmt.Sprintf(msg, args...),
+	}
+}
+
+func (err TestError) Error() string {
+	return err.message
+}
+
+func TestVerifies_WithErrorFactory(test *testing.T) {
+
+	var tf = func(name string, ver *verifier.Verify, err error) {
+		test.Run(name, func(test *testing.T) {
+			var got = ver.That(false, "test error message").GetError()
+			if reflect.TypeOf(err) != reflect.TypeOf(got) {
+				test.Fatalf("got error of invalid type %T", got)
+			}
+		})
+	}
+
+	tf("empty Verifier", &verifier.Verify{}, fmt.Errorf(""))
+	tf("verifier created with New factory", verifier.New(), fmt.Errorf(""))
+	tf("verifier with TestError factory", verifier.New().WithErrFactory(NewTestError), TestError{})
+}
+
+// Testing Offensive verifier, which crashes programm if GCed unchecked.
+// Idea: https://talks.golang.org/2014/testing.slide
+func TestOffensive(test *testing.T) {
+	if os.Getenv("BE_CRASHER") == "1" {
+		var verifiers = make([]*verifier.Verify, 10000)
+		for i := range verifiers {
+			verifiers[i] = verifier.
+				Offensive().
+				That(false, "test error message %d", i)
+		}
+		for i := range verifiers {
+			verifiers[i] = nil
+		}
+		runtime.GC()
+		return
+	}
+	cmd := exec.Command(os.Args[0], "-test.run=TestCrasher", "-race")
+	cmd.Env = append(os.Environ(), "BE_CRASHER=1")
+	err := cmd.Run()
+	if e, ok := err.(*exec.ExitError); ok && !e.Success() {
+		return
+	}
+	test.Fatalf("process ran with err %v, want exit status 1", err)
+}
+
 type safeBuffer struct {
 	b bytes.Buffer
 	m sync.Mutex