fix issue #73: convert tests to blackbox tests

backoff/backoff_test.go

@@ -1,16 +1,18 @@
-package backoff
+package backoff_test
 
 import (
 	"math"
 	"testing"
 	"time"
+
+	"github.com/kamilsk/retry/backoff"
 )
 
 func TestIncremental(t *testing.T) {
 	const duration = time.Millisecond
 	const increment = time.Nanosecond
 
-	algorithm := Incremental(duration, increment)
+	algorithm := backoff.Incremental(duration, increment)
 
 	for i := uint(0); i < 10; i++ {
 		result := algorithm(i)
@@ -25,7 +27,7 @@ func TestIncremental(t *testing.T) {
 func TestLinear(t *testing.T) {
 	const duration = time.Millisecond
 
-	algorithm := Linear(duration)
+	algorithm := backoff.Linear(duration)
 
 	for i := uint(0); i < 10; i++ {
 		result := algorithm(i)
@@ -41,7 +43,7 @@ func TestExponential(t *testing.T) {
 	const duration = time.Second
 	const base = 3
 
-	algorithm := Exponential(duration, base)
+	algorithm := backoff.Exponential(duration, base)
 
 	for i := uint(0); i < 10; i++ {
 		result := algorithm(i)
@@ -56,7 +58,7 @@ func TestExponential(t *testing.T) {
 func TestBinaryExponential(t *testing.T) {
 	const duration = time.Second
 
-	algorithm := BinaryExponential(duration)
+	algorithm := backoff.BinaryExponential(duration)
 
 	for i := uint(0); i < 10; i++ {
 		result := algorithm(i)
@@ -70,28 +72,16 @@ func TestBinaryExponential(t *testing.T) {
 
 func TestFibonacci(t *testing.T) {
 	const duration = time.Millisecond
+	sequence := []uint{0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233}
 
-	algorithm := Fibonacci(duration)
+	algorithm := backoff.Fibonacci(duration)
 
 	for i := uint(0); i < 10; i++ {
 		result := algorithm(i)
-		expected := duration * time.Duration(fibonacciNumber(i))
+		expected := duration * time.Duration(sequence[i])
 
 		if result != expected {
 			t.Errorf("algorithm expected to return a %s duration, but received %s instead", expected, result)
 		}
 	}
 }
-
-func TestFibonacciNumber(t *testing.T) {
-	// Fibonacci sequence
-	expectedSequence := []uint{0, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55, 89, 144, 233}
-
-	for i, expected := range expectedSequence {
-		result := fibonacciNumber(uint(i))
-
-		if result != expected {
-			t.Errorf("fibonacci %d number expected %d, but got %d", i, expected, result)
-		}
-	}
-}

classifier/blacklist_test.go

@@ -1,26 +1,28 @@
-package classifier
+package classifier_test
 
 import (
 	"errors"
 	"testing"
+
+	"github.com/kamilsk/retry/classifier"
 )
 
 func TestBlacklistClassifier_Classify(t *testing.T) {
 	var (
 		errInBlacklist    = errors.New("is in blacklist")
 		errNotInBlacklist = errors.New("is not in blacklist")
 	)
-	list := BlacklistClassifier([]error{errInBlacklist})
+	list := classifier.BlacklistClassifier([]error{errInBlacklist})
 
-	if list.Classify(nil) != Succeed {
+	if list.Classify(nil) != classifier.Succeed {
 		t.Error("succeed is expected")
 	}
 
-	if list.Classify(errNotInBlacklist) != Retry {
+	if list.Classify(errNotInBlacklist) != classifier.Retry {
 		t.Error("retry is expected")
 	}
 
-	if list.Classify(errInBlacklist) != Fail {
+	if list.Classify(errInBlacklist) != classifier.Fail {
 		t.Error("fail is expected")
 	}
 }

classifier/classifier_test.go

@@ -1,18 +1,20 @@
-package classifier
+package classifier_test
 
 import (
 	"errors"
 	"testing"
+
+	"github.com/kamilsk/retry/classifier"
 )
 
 func TestDefaultClassifier_Classify(t *testing.T) {
-	defaultClassifier := DefaultClassifier{}
+	defaultClassifier := classifier.DefaultClassifier{}
 
-	if defaultClassifier.Classify(nil) != Succeed {
+	if defaultClassifier.Classify(nil) != classifier.Succeed {
 		t.Error("succeed is expected")
 	}
 
-	if defaultClassifier.Classify(errors.New("error")) != Retry {
+	if defaultClassifier.Classify(errors.New("error")) != classifier.Retry {
 		t.Error("retry is expected")
 	}
 }

classifier/functional_test.go

@@ -1,38 +1,40 @@
-package classifier
+package classifier_test
 
 import (
 	"encoding/json"
 	"errors"
 	"net"
 	"testing"
+
+	"github.com/kamilsk/retry/classifier"
 )
 
 func TestFunctionalClassifier_Classify(t *testing.T) {
 	var (
 		errClassified       = &json.SyntaxError{}
 		errNotClassified    = errors.New("is unknown error")
-		jsonErrorClassifier = FunctionalClassifier(func(err error) Action {
+		jsonErrorClassifier = classifier.FunctionalClassifier(func(err error) classifier.Action {
 			if err == nil {
-				return Succeed
+				return classifier.Succeed
 			}
 
 			if _, is := err.(*json.SyntaxError); is {
-				return Retry
+				return classifier.Retry
 			}
 
-			return Unknown
+			return classifier.Unknown
 		})
 	)
 
-	if jsonErrorClassifier.Classify(nil) != Succeed {
+	if jsonErrorClassifier.Classify(nil) != classifier.Succeed {
 		t.Error("succeed is expected")
 	}
 
-	if jsonErrorClassifier.Classify(errClassified) != Retry {
+	if jsonErrorClassifier.Classify(errClassified) != classifier.Retry {
 		t.Error("retry is expected")
 	}
 
-	if jsonErrorClassifier.Classify(errNotClassified) != Unknown {
+	if jsonErrorClassifier.Classify(errNotClassified) != classifier.Unknown {
 		t.Error("unknown is expected")
 	}
 }
@@ -44,19 +46,19 @@ func TestFunctionalClassifier_NetworkErrorClassifier_Classify(t *testing.T) {
 		errOther          = errors.New("is not network error")
 	)
 
-	if NetworkErrorClassifier.Classify(nil) != Succeed {
+	if classifier.NetworkErrorClassifier.Classify(nil) != classifier.Succeed {
 		t.Error("succeed is expected")
 	}
 
-	if NetworkErrorClassifier.Classify(errNetworkTimeout) != Retry {
+	if classifier.NetworkErrorClassifier.Classify(errNetworkTimeout) != classifier.Retry {
 		t.Error("retry is expected")
 	}
 
-	if NetworkErrorClassifier.Classify(errNetworkOther) != Fail {
+	if classifier.NetworkErrorClassifier.Classify(errNetworkOther) != classifier.Fail {
 		t.Error("fail is expected")
 	}
 
-	if NetworkErrorClassifier.Classify(errOther) != Unknown {
+	if classifier.NetworkErrorClassifier.Classify(errOther) != classifier.Unknown {
 		t.Error("unknown is expected")
 	}
 }

classifier/whitelist_test.go

@@ -1,26 +1,28 @@
-package classifier
+package classifier_test
 
 import (
 	"errors"
 	"testing"
+
+	"github.com/kamilsk/retry/classifier"
 )
 
 func TestWhitelistClassifier_Classify(t *testing.T) {
 	var (
 		errInWhitelist    = errors.New("is in blacklist")
 		errNotInWhitelist = errors.New("is not in blacklist")
 	)
-	list := WhitelistClassifier([]error{errInWhitelist})
+	list := classifier.WhitelistClassifier([]error{errInWhitelist})
 
-	if list.Classify(nil) != Succeed {
+	if list.Classify(nil) != classifier.Succeed {
 		t.Error("succeed is expected")
 	}
 
-	if list.Classify(errNotInWhitelist) != Fail {
+	if list.Classify(errNotInWhitelist) != classifier.Fail {
 		t.Error("fail is expected")
 	}
 
-	if list.Classify(errInWhitelist) != Retry {
+	if list.Classify(errInWhitelist) != classifier.Retry {
 		t.Error("retry is expected")
 	}
 }

jitter/jitter.go

@@ -87,7 +87,5 @@ func fallbackNewRandom(random *rand.Rand) *rand.Rand {
 		return random
 	}
 
-	seed := time.Now().UnixNano()
-
-	return rand.New(rand.NewSource(seed))
+	return rand.New(rand.NewSource(time.Now().UnixNano()))
 }