Merge pull request #13 from J7mbo/feature/#4-Use-anonymous-func-for-type-safety

[#4] - Added `ExecuteFuncWithRetry()` for userland type safety

Author: J7mbo

MethodCallRetrier.go

@@ -38,6 +38,41 @@ func New(waitTime int64, maxRetries int64, exponent *int64) *MethodCallRetrier {
 	return &MethodCallRetrier{waitTime: waitTime, maxRetries: maxRetries, exponent: *exponent}
 }
 
+/*
+Retries a function with a maximum number of retries and a wait time. Functionally equivalent to ExecuteWithRetry() but
+accepts a function to maintain type safety in userland instead and removes the requirement of a user type assertion.
+*/
+func (r *MethodCallRetrier) ExecuteFuncWithRetry(function func() error) []error {
+	defer func() {
+		r.resetCurrentRetries()
+		r.resetErrorList()
+	}()
+
+	if r.currentRetries >= r.maxRetries {
+		r.errorList = append(
+			r.errorList, &MaxRetriesError{
+				methodName: reflect.TypeOf(function).String(),
+				waitTime: r.waitTime,
+				maxRetries: r.maxRetries,
+			},
+		)
+
+		return r.errorList
+	}
+
+	err := function()
+
+	if err != nil {
+		r.errorList = append(r.errorList, err)
+
+		r.sleepAndIncrementRetries()
+
+		return r.ExecuteFuncWithRetry(function)
+	}
+
+	return r.errorList
+}
+
 /* Retries the call to object.methodName(...args) with a maximum number of retries and a wait time. */
 func (r *MethodCallRetrier) ExecuteWithRetry(
 	object interface{}, methodName string, args ...interface{},

README.md

@@ -30,7 +30,13 @@ Call `ExecuteWithRetry` with your object and method you want to retry:
 ```
 ExecuteWithRetry(
 	object interface{}, methodName string, args ...interface{},
-) ([]reflect.Value, []error) {
+) ([]reflect.Value, []error)
+```
+
+Alternatively, call `ExecuteFuncWithRetry` and pass in a function that returns `error` to retry.
+
+```
+ExecuteFuncWithRetry(func() error) []error
 ```
 
 You can use it as follows:
@@ -44,4 +50,31 @@ To use the results, you must typecast the result to the expected type. In the ca
 
 ```
 myInt := results[0].Interface().(int64)
-```
+```
+
+Or, to maintain type safety in userland, you can pass a function in instead and do all your retriable work in there:
+
+```
+var json string
+
+functionToRetry := func() error {
+    json, err = DoSomeFlakeyHttpCall()
+    
+    if err != nil {
+        return err
+    }
+    
+    return nil
+}
+
+if errs := retrier.ExecuteWithRetry(funcToRetry); len(errs) > 0 {
+    /* Do something because we failed 3 times */
+    return
+}
+
+fmt.Println(json)
+```
+
+Be aware that this choice now requires you to work within the function scope, and that if you want to use the results of
+the call outside of the scope of the function then you must declare it using `var result type` as shown above; but this
+does remove the requirement of a type assertion that you have to do with `ExecuteWithRetry`.

Retrier.go

@@ -7,4 +7,6 @@ type Retrier interface {
 	ExecuteWithRetry(
 		maxRetries int64, waitTime int64, object interface{}, methodName string, args ...interface{},
 	) ([]reflect.Value, error)
+
+	ExecuteFuncWithRetry(function func() error) []error
 }

Retrier_test.go

@@ -103,6 +103,35 @@ func (s *RetrierTestSuite) TestRetrierWorksWhenMultipleReturnParamsAreErrors() {
 	s.Assert().Len(errs, 11)
 }
 
+func (s *RetrierTestSuite) TestRetrierWorksWithUserFunction() {
+	var num int
+
+	errs := New(0, 3, nil).ExecuteFuncWithRetry(func() error {
+		num = 42
+
+		return nil
+	})
+
+	s.Assert().Equal(42, num)
+	s.Assert().Len(errs, 0)
+}
+
+func (s *RetrierTestSuite) TestRetrierWithUserFunctionReturnsCorrectNumberOfErrors() {
+	errs := New(0, 3, nil).ExecuteFuncWithRetry(func() error {
+		return errors.New("")
+	})
+
+	s.Assert().Equal(4, len(errs))
+}
+
+func (s *RetrierTestSuite) TestRetrierWorksWithUserFunctionCalledCorrectNumberOfTimes() {
+	testObj := RetryMockObject{}
+
+	New(0, 3, nil).ExecuteFuncWithRetry(testObj.MethodToBeCalledToReturnResultAndError)
+
+	s.Assert().Equal(3, testObj.timesCalled)
+}
+
 type RetryObject struct{}
 
 func (m *RetryObject) MethodReturningNoValues() {}
@@ -125,8 +154,16 @@ func (m *RetryObject) MethodReturningMultipleErrors() (string, error, error) {
 
 type RetryMockObject struct {
 	mock.Mock
+
+	timesCalled int
 }
 
 func (m *RetryMockObject) MethodReturningError(anArgument string) error {
 	return m.Called(anArgument).Error(0)
 }
+
+func (m *RetryMockObject) MethodToBeCalledToReturnResultAndError() error {
+	m.timesCalled += 1
+
+	return errors.New("")
+}