issue #171: working solution for Schrödinger's bug

Author: kamilsk

Makefile

@@ -1,6 +1,6 @@
 # sourced by https://github.com/octomation/makefiles
 
-.DEFAULT_GOAL = test-with-coverage
+.DEFAULT_GOAL = check
 GIT_HOOKS     = post-merge pre-commit pre-push
 GO_VERSIONS   = 1.11 1.12 1.13 1.14 1.15 1.16
 GO111MODULE   = on
@@ -291,10 +291,13 @@ endif
 
 export PATH := $(GOBIN):$(PATH)
 
-init: deps test lint hooks
+init: deps check hooks
 	$(AT) git config core.autocrlf input
 .PHONY: init
 
+check: test lint
+.PHONY: check
+
 clean: deps-clean test-clean
 .PHONY: clean
 
@@ -315,7 +318,7 @@ format: go-fmt
 generate: go-generate format
 .PHONY: generate
 
-refresh: deps-tidy update deps generate test
+refresh: deps-tidy update deps generate check
 .PHONY: refresh
 
 update: deps-update tools-update
@@ -324,5 +327,5 @@ update: deps-update tools-update
 verbose: make-verbose go-verbose
 .PHONY: verbose
 
-verify: deps-check generate test lint git-check
+verify: deps-check generate check git-check
 .PHONY: verify

context.go

@@ -0,0 +1,48 @@
+package retry
+
+import "context"
+
+type lite struct {
+	context.Context
+	signal <-chan struct{}
+}
+
+func (ctx lite) Done() <-chan struct{} {
+	return ctx.signal
+}
+
+func (ctx lite) Err() error {
+	select {
+	case <-ctx.signal:
+		return context.Canceled
+	default:
+		return nil
+	}
+}
+
+// equal to go.octolab.org/errors.Unwrap
+func unwrap(err error) error {
+	// compatible with github.com/pkg/errors
+	type causer interface {
+		Cause() error
+	}
+	// compatible with built-in errors since 1.13
+	type wrapper interface {
+		Unwrap() error
+	}
+
+	for err != nil {
+		layer, is := err.(wrapper)
+		if is {
+			err = layer.Unwrap()
+			continue
+		}
+		cause, is := err.(causer)
+		if is {
+			err = cause.Cause()
+			continue
+		}
+		break
+	}
+	return err
+}

context_test.go

@@ -0,0 +1,119 @@
+package retry
+
+import (
+	"context"
+	"runtime"
+	"testing"
+	"time"
+)
+
+func TestContext(t *testing.T) {
+	t.Run("with cancel", func(t *testing.T) {
+		t.Parallel()
+
+		var (
+			sig = make(chan struct{})
+			ctx = context.Context(lite{context.TODO(), sig})
+		)
+		if ctx.Err() != nil {
+			t.Error("invalid state")
+		}
+
+		ctx, cancel := context.WithCancel(ctx)
+		if ctx.Err() != nil {
+			t.Error("invalid state")
+		}
+
+		verify(t, ctx, cancel, sig)
+	})
+
+	t.Run("with deadline", func(t *testing.T) {
+		t.Parallel()
+
+		var (
+			sig = make(chan struct{})
+			ctx = context.Context(lite{context.TODO(), sig})
+		)
+		if ctx.Err() != nil {
+			t.Error("invalid state")
+		}
+
+		ctx, cancel := context.WithDeadline(ctx, time.Now().Add(time.Hour))
+		if ctx.Err() != nil {
+			t.Error("invalid state")
+		}
+
+		verify(t, ctx, cancel, sig)
+	})
+
+	t.Run("with timeout", func(t *testing.T) {
+		t.Parallel()
+
+		var (
+			sig = make(chan struct{})
+			ctx = context.Context(lite{context.TODO(), sig})
+		)
+		if ctx.Err() != nil {
+			t.Error("invalid state")
+		}
+
+		ctx, cancel := context.WithTimeout(ctx, time.Hour)
+		if ctx.Err() != nil {
+			t.Error("invalid state")
+		}
+
+		verify(t, ctx, cancel, sig)
+	})
+
+	t.Run("with value", func(t *testing.T) {
+		t.Parallel()
+
+		var (
+			sig = make(chan struct{})
+			ctx = context.Context(lite{context.TODO(), sig})
+		)
+		if ctx.Err() != nil {
+			t.Error("invalid state")
+		}
+
+		ctx = context.WithValue(ctx, key{}, "value")
+		if expected, obtained := "value", ctx.Value(key{}); obtained != expected {
+			t.Errorf("expected: %q, obtained: %q", expected, obtained)
+		}
+
+		close(sig)
+	})
+}
+
+// helpers
+
+func stop(timer *time.Timer) {
+	if !timer.Stop() {
+		select {
+		case <-timer.C:
+		default:
+		}
+	}
+}
+
+func verify(t *testing.T, ctx context.Context, cancel context.CancelFunc, sig chan struct{}) {
+	t.Helper()
+
+	timer := time.NewTimer(schedule)
+	close(sig)
+	select {
+	case <-timer.C:
+		t.Error("invalid state")
+	case <-ctx.Done():
+		if ctx.Err() == nil {
+			t.Error("invalid state")
+		}
+	}
+
+	stop(timer)
+	cancel()
+}
+
+type key struct{}
+
+var schedule = 10 * time.Duration(runtime.NumCPU()) * time.Millisecond

retry.go

@@ -45,28 +45,30 @@ func Do(
 		err   error = Error("have no any try")
 		clean error
 	)
+
 	ctx, is := breaker.(context.Context)
 	if !is {
-		ctx = context.Background()
+		ctx = lite{context.Background(), breaker.Done()}
 	}
-	ctx, cancel := context.WithCancel(ctx)
+
 	for attempt, should := uint(0), true; should; attempt++ {
 		clean = unwrap(err)
 		for i, repeat := 0, len(strategies); should && i < repeat; i++ {
 			should = should && strategies[i](breaker, attempt, clean)
 		}
+
 		select {
 		case <-breaker.Done():
-			cancel()
 			return breaker.Err()
 		default:
 			if should {
 				err = action(ctx)
 			}
 		}
+
 		should = should && err != nil
 	}
-	cancel()
+
 	return err
 }
 
@@ -103,30 +105,3 @@ func Go(
 		return err
 	}
 }
-
-// equal to go.octolab.org/errors.Unwrap
-func unwrap(err error) error {
-	// compatible with github.com/pkg/errors
-	type causer interface {
-		Cause() error
-	}
-	// compatible with built-in errors since 1.13
-	type wrapper interface {
-		Unwrap() error
-	}
-
-	for err != nil {
-		layer, is := err.(wrapper)
-		if is {
-			err = layer.Unwrap()
-			continue
-		}
-		cause, is := err.(causer)
-		if is {
-			err = cause.Cause()
-			continue
-		}
-		break
-	}
-	return err
-}