Get rid of nap with gopeek

glide.yaml

@@ -5,3 +5,4 @@ testImport:
   subpackages:
   - assert
 - package: github.com/uber-go/atomic
+- package: github.com/cat2neat/gopeek

internal/clock/clock.go

@@ -24,8 +24,12 @@ package clock
 
 import (
 	"container/heap"
+	"fmt"
+	"os"
 	"sync"
 	"time"
+
+	"github.com/cat2neat/gopeek"
 )
 
 // Mock represents a mock clock that only moves forward programmically.
@@ -44,12 +48,19 @@ func NewMock() *Mock {
 
 // Add moves the current time of the mock clock forward by the duration.
 // This should only be called from a single goroutine at a time.
-func (m *Mock) Add(d time.Duration) {
+func (m *Mock) Add(d time.Duration, condition *gopeek.Condition) {
 	m.Lock()
 	// Calculate the final time.
 	end := m.now.Add(d)
 
 	for len(m.timers) > 0 && m.now.Before(end) {
+		// Wait before popping from timers
+		m.Unlock()
+		_, err := condition.Wait(time.Second)
+		if err != nil {
+			fmt.Fprintf(os.Stderr, "error: %+v\n", err)
+		}
+		m.Lock()
 		t := heap.Pop(&m.timers).(*Timer)
 		m.now = t.next
 		m.Unlock()
@@ -58,8 +69,6 @@ func (m *Mock) Add(d time.Duration) {
 	}
 
 	m.Unlock()
-	// Give a small buffer to make sure the other goroutines get handled.
-	nap()
 }
 
 // Timer produces a timer that will emit a time some duration after now.
@@ -94,7 +103,6 @@ func (m *Mock) AfterFunc(d time.Duration, f func()) *Timer {
 		<-t.c
 		f()
 	}()
-	nap()
 	return t
 }
 
@@ -126,8 +134,4 @@ func (t *Timer) Tick() {
 	case t.c <- t.next:
 	default:
 	}
-	nap()
 }
-
-// Sleep momentarily so that other goroutines can process.
-func nap() { time.Sleep(1 * time.Millisecond) }

ratelimit_test.go

@@ -9,6 +9,7 @@ import (
 	"go.uber.org/ratelimit"
 	"go.uber.org/ratelimit/internal/clock"
 
+	"github.com/cat2neat/gopeek"
 	"github.com/stretchr/testify/assert"
 	"github.com/uber-go/atomic"
 )
@@ -79,9 +80,14 @@ func TestRateLimiter(t *testing.T) {
 		wg.Done()
 	})
 
-	clock.Add(4 * time.Second)
+	condition := gopeek.NewCondition().
+		CreatedBy("ratelimit_test.TestRateLimiter").
+		Is(gopeek.StateWaitingChannel).
+		// go ahead when there is only one waiting channel via Mock.Sleep
+		// as it's evidence that ratelimit occurred
+		EQ(1)
 
-	clock.Add(5 * time.Second)
+	clock.Add(4*time.Second, condition)
 }
 
 func TestDelayedRateLimiter(t *testing.T) {
@@ -123,11 +129,18 @@ func TestDelayedRateLimiter(t *testing.T) {
 	})
 
 	clock.AfterFunc(30*time.Second, func() {
-		assert.InDelta(t, 1200, count.Load(), 10, "count within rate limit")
+		// 11 is more accurate as a slow job also may count up before this func.
+		assert.InDelta(t, 1200, count.Load(), 11, "count within rate limit")
 		wg.Done()
 	})
 
-	clock.Add(40 * time.Second)
+	condition := gopeek.NewCondition().
+		CreatedBy("ratelimit_test.TestDelayedRateLimiter").
+		Is(gopeek.StateWaitingChannel).
+		// go ahead when there is >= 1 waiting channel via Mock.Sleep
+		// as it's evidence that ratelimit occurred
+		GT(0)
+	clock.Add(40*time.Second, condition)
 }
 
 func job(rl ratelimit.Limiter, count *atomic.Int32, done <-chan struct{}) {