Merge 24a9223 into de8e6a1

bus/bus_test.go

@@ -13,11 +13,13 @@ type msg struct {
 	body string
 }
 
+var handlerError error = errors.New("handler error")
+
 func TestHandlerReturnsError(t *testing.T) {
 	b := bus.New()
 
 	err := b.AddHandler(func(m *msg) error {
-		return errors.New("handler error")
+		return handlerError
 	})
 	if err != nil {
 		t.Fatal(err)

cmd/xcode/main.go

@@ -15,15 +15,21 @@ func main() {
 	log.SetFlags(0)
 
 	fs := flag.NewFlagSet("xcode", flag.ExitOnError)
+
 	var (
 		in   = fs.String("in", "", "input file")
 		out  = fs.String("out", "", "output file")
 		pkg  = fs.String("pkg", "", "package name")
 		typ  = fs.String("type", "", "type")
 		mode = fs.String("mode", "", "activate mode")
 	)
+
 	fs.Usage = usageFor(fs, "xcode [flags]")
-	fs.Parse(os.Args[1:])
+
+	err := fs.Parse(os.Args[1:])
+	if err != nil {
+		log.Fatal(err)
+	}
 
 	if *in == "" {
 		log.Fatal("input file is missing")
@@ -61,11 +67,14 @@ func main() {
 
 func usageFor(fs *flag.FlagSet, short string) func() {
 	return func() {
+
 		fmt.Fprintf(os.Stdout, "USAGE\n")
 		fmt.Fprintf(os.Stdout, "  %s\n", short)
 		fmt.Fprintf(os.Stdout, "\n")
 		fmt.Fprintf(os.Stdout, "FLAGS\n")
+
 		tw := tabwriter.NewWriter(os.Stdout, 0, 2, 2, ' ', 0)
+
 		fs.VisitAll(func(f *flag.Flag) {
 			if f.Name == "debug" {
 				return
@@ -76,6 +85,7 @@ func usageFor(fs *flag.FlagSet, short string) func() {
 			}
 			fmt.Fprintf(tw, "  -%s %s\t%s\n", f.Name, f.DefValue, f.Usage)
 		})
+
 		tw.Flush()
 	}
 }

concurrent/runner_test.go

@@ -8,6 +8,8 @@ import (
 	"github.com/donutloop/toolkit/concurrent"
 )
 
+var StubErr error = errors.New("stub error")
+
 func TestRun(t *testing.T) {
 	counter := int32(0)
 	errs := concurrent.Run(
@@ -38,7 +40,7 @@ func TestRunFail(t *testing.T) {
 	counter := int32(0)
 	errs := concurrent.Run(
 		func() error {
-			return errors.New("stub error")
+			return StubErr
 		},
 		func() error {
 			panic("check isolation of goroutine")
@@ -64,7 +66,7 @@ func BenchmarkRun(b *testing.B) {
 	for n := 0; n < b.N; n++ {
 		concurrent.Run(
 			func() error {
-				return errors.New("stub error")
+				return StubErr
 			},
 			func() error {
 				panic("check isolation of goroutine")

debugutil/http_log_round_tripper_test.go

@@ -16,6 +16,7 @@ type logger struct{}
 func (l logger) Errorf(format string, v ...interface{}) {
 	log.Println(fmt.Sprintf(format, v...))
 }
+
 func (l logger) Infof(format string, v ...interface{}) {
 	log.Println(fmt.Sprintf(format, v...))
 }

debugutil/prettysprint_test.go

@@ -5,12 +5,11 @@
 package debugutil_test
 
 import (
-	"testing"
-
 	"github.com/donutloop/toolkit/debugutil"
+	"testing"
 )
 
-func Test(t *testing.T) {
+func TestDebugger(t *testing.T){
 
 	strings := "dummy"
 

event/hook.go

@@ -2,6 +2,7 @@ package event
 
 import (
 	"fmt"
+	"runtime/debug"
 	"sync"
 )
 
@@ -43,10 +44,17 @@ func (h *Hooks) Fire() []error {
 func hookWrapper(wg *sync.WaitGroup, hook func(), errc chan error) {
 	defer func() {
 		if v := recover(); v != nil {
-			errc <- fmt.Errorf("hook is panicked (%v)", v)
+			errc <- &RecoverError{Err: v, Stack: debug.Stack()}
 		}
 		wg.Done()
 	}()
 
 	hook()
 }
+
+type RecoverError struct {
+	Err   interface{}
+	Stack []byte
+}
+
+func (e *RecoverError) Error() string { return fmt.Sprintf("Do panicked: %v", e.Err) }

event/hook_test.go

@@ -48,7 +48,7 @@ func TestHooksPanic(t *testing.T) {
 		t.Fatalf("error count is bad (%d)", len(errs))
 	}
 
-	expectedMessage := "hook is panicked (check isolation of goroutine)"
+	expectedMessage := "Do panicked: check isolation of goroutine"
 	if errs[0].Error() != expectedMessage {
 		t.Fatalf(`unexpected error message (actual: "%s", expected: "%s")`, errs[0].Error(), expectedMessage)
 	}

internal/ast/ast.go

@@ -37,7 +37,7 @@ func ChangeType(typeName string, newType string, debugMode string) func(file *as
 				for i := 0; i < len(x.Args); i++ {
 					v, ok := x.Args[i].(*ast.Ident)
 					if ok {
-						if strings.ToLower(typeName) == strings.ToLower(v.Name) {
+						if strings.EqualFold(typeName, v.Name) {
 							x.Args[i] = &ast.Ident{Name: fmt.Sprintf("%s.(%s)", v.Name, newType)}
 						}
 					}
@@ -73,8 +73,16 @@ func ModifyAst(dest []byte, fns ...func(*ast.File) *ast.File) ([]byte, error) {
 
 	var buf bytes.Buffer
 	if err := format.Node(&buf, destFset, destF); err != nil {
-		return nil, fmt.Errorf("couldn't format package code (%v)", err)
+		return nil, &BadFormattedCode{Err: err}
 	}
 
 	return buf.Bytes(), nil
 }
+
+type BadFormattedCode struct {
+	Err error
+}
+
+func (e BadFormattedCode) Error() string {
+	return fmt.Sprintf("couldn't format package code (%v)", e.Err)
+}

lease/doc_test.go

@@ -10,7 +10,7 @@ import (
 func ExampleLeaser_Lease() {
 
 	leaser := lease.NewLeaser()
-	leaser.Lease("cleanup-cache", time.Duration(1*time.Second), func() {
+	leaser.Lease("cleanup-cache", 1*time.Second, func() {
 		fmt.Println("cleaned up cache")
 	})
 

loop/loop.go

@@ -6,6 +6,7 @@ package loop
 
 import (
 	"fmt"
+	"runtime/debug"
 	"time"
 )
 
@@ -41,7 +42,7 @@ func (l *looper) doLoop() {
 	defer ticker.Stop()
 	defer func() {
 		if v := recover(); v != nil {
-			l.err <- fmt.Errorf("event is panicked (%v)", v)
+			l.err <- &RecoverError{Err: v, Stack: debug.Stack()}
 		}
 	}()
 
@@ -57,3 +58,10 @@ func (l *looper) doLoop() {
 		}
 	}
 }
+
+type RecoverError struct {
+	Err   interface{}
+	Stack []byte
+}
+
+func (e *RecoverError) Error() string { return fmt.Sprintf("Do panicked: %v", e.Err) }

loop/loop_test.go

@@ -13,6 +13,8 @@ import (
 	"github.com/donutloop/toolkit/loop"
 )
 
+var StubErr error = errors.New("stub error")
+
 func TestLoop(t *testing.T) {
 	var counter int
 	l := loop.NewLooper(1*time.Millisecond, func() error {
@@ -28,22 +30,24 @@ func TestLoop(t *testing.T) {
 	}
 }
 
+var GoroutineError error = fmt.Errorf("check isolation of goroutine")
+
 func TestLoopFail(t *testing.T) {
 	l := loop.NewLooper(1*time.Millisecond, func() error {
-		panic(fmt.Errorf("check isolation of goroutine"))
+		panic(GoroutineError)
 	})
 
 	err := <-l.Error()
-	if err.Error() != "event is panicked (check isolation of goroutine)" {
+	if err.Error() != "Do panicked: check isolation of goroutine" {
 		t.Fatal(err)
 	}
 
 	l = loop.NewLooper(1*time.Millisecond, func() error {
-		return errors.New("stub error")
+		return StubErr
 	})
 
 	err = <-l.Error()
-	if err.Error() != "stub error" {
+	if !errors.Is(err, StubErr) {
 		t.Fatal(err)
 	}
 }

multierror/doc_test.go

@@ -3,16 +3,14 @@ package multierror_test
 import (
 	"fmt"
 
-	"errors"
-
 	"github.com/donutloop/toolkit/multierror"
 )
 
 func Example() {
 	errs := []error{
-		errors.New("error connect to db failed"),
-		errors.New("error marschaling json"),
+		connectionError,
+		marshalError,
 	}
 	fmt.Println(multierror.New(errs...))
-	// Output: multiple errors: error connect to db failed; error marschaling json
+	// Output: multiple errors: error connect to db failed; error marshal json
 }

promise/promise_test.go

@@ -29,7 +29,7 @@ func TestDoPanic(t *testing.T) {
 			t.Fatal("unexpected nil error")
 		}
 
-		if !strings.Contains(err.Error(), "Do panicked") {
+		if !strings.Contains(err.Error(), "Do panicked ") {
 			t.Fatalf(`unexpected error message (actual: "%s", expected: "promise is panicked (*)")`, err.Error())
 		}
 	}

retry/retry.go

@@ -23,18 +23,18 @@ type Retrier interface {
 
 type RetryableDo func() (bool, error)
 
-func NewRetrier(InitialIntervalInSeconds, maxIntervalInSeconds float64, tries uint, strategy Strategy) Retrier {
+func NewRetrier(initialIntervalInSeconds, maxIntervalInSeconds float64, tries uint, strategy Strategy) Retrier {
 
 	if strategy == nil {
 		panic("strategy is missing")
 	}
 
-	if InitialIntervalInSeconds > maxIntervalInSeconds {
-		panic(fmt.Sprintf("initial interval is greater than max (initial: %f, max: %f)", InitialIntervalInSeconds, maxIntervalInSeconds))
+	if initialIntervalInSeconds > maxIntervalInSeconds {
+		panic(fmt.Sprintf("initial interval is greater than max (initial: %f, max: %f)", initialIntervalInSeconds, maxIntervalInSeconds))
 	}
 
 	return &retrier{
-		InitialIntervalInSeconds: InitialIntervalInSeconds,
+		InitialIntervalInSeconds: initialIntervalInSeconds,
 		maxIntervalInSeconds:     maxIntervalInSeconds,
 		strategy:                 strategy,
 		tries:                    tries,
@@ -54,8 +54,11 @@ func (r *retrier) Retry(ctx context.Context, do RetryableDo) error {
 	}
 
 	var err error
+
 	var done bool
+
 	for i := uint(0); !done && i < r.tries; i++ {
+
 		done, err = do()
 
 		if ctx.Err() != nil {
@@ -74,6 +77,7 @@ func (r *retrier) Retry(ctx context.Context, do RetryableDo) error {
 	if !done {
 		return new(ExhaustedError)
 	}
+
 	return nil
 }
 

retry/retry_test.go

@@ -12,11 +12,14 @@ import (
 	"github.com/donutloop/toolkit/retry"
 )
 
+var StubErr error = errors.New("stub error")
+
 func TestRetrierRetryContextDeadlineFail(t *testing.T) {
 	r := retry.NewRetrier(0.125, 0.25, 2, new(retry.Exp))
 
 	ctx, cancel := context.WithCancel(context.Background())
 	cancel()
+
 	err := r.Retry(ctx, func() (bool, error) {
 		return true, nil
 	})
@@ -45,15 +48,14 @@ func TestRetrierRetry(t *testing.T) {
 func TestRetrierRetryTriggerError(t *testing.T) {
 	r := retry.NewRetrier(0.125, 0.25, 2, new(retry.Exp))
 	err := r.Retry(context.Background(), func() (bool, error) {
-		return false, errors.New("stub error")
+		return false, StubErr
 	})
 
 	if err == nil {
 		t.Fatal("unexpected nil error")
 	}
 
-	expectedErrorMessage := "stub error"
-	if err.Error() != expectedErrorMessage {
+	if !errors.Is(err, StubErr) {
 		t.Fatal(err)
 	}
 }

retry/roundtripper.go

@@ -13,7 +13,9 @@ type RoundTripper struct {
 
 // NewRoundTripper is constructing a new retry RoundTripper with given default values.
 func NewRoundTripper(next http.RoundTripper, maxInterval, initialInterval float64, tries uint, blacklistStatusCodes []int, strategy Strategy) *RoundTripper {
+
 	retrier := NewRetrier(initialInterval, maxInterval, tries, strategy)
+
 	return &RoundTripper{
 		retrier:              retrier,
 		next:                 next,
@@ -25,7 +27,9 @@ func NewRoundTripper(next http.RoundTripper, maxInterval, initialInterval float6
 // if rt.next.RoundTrip(req) is return an error then it will abort the process retrying a request.
 func (rt *RoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
 	var resp *http.Response
+
 	err := rt.retrier.Retry(context.Background(), func() (b bool, e error) {
+
 		var err error
 		resp, err = rt.next.RoundTrip(req)
 		if err != nil {
@@ -52,13 +56,17 @@ func (rt *RoundTripper) RoundTrip(req *http.Request) (*http.Response, error) {
 
 // isStatusCode iterates over list of black listed status code that it could abort the process of retrying a request
 func (rt *RoundTripper) isStatusCode(statusCode int) bool {
+
 	if rt.blacklistStatusCodes == nil {
 		return false
 	}
+
 	for _, sc := range rt.blacklistStatusCodes {
+
 		if statusCode == sc {
 			return true
 		}
 	}
+
 	return false
 }