From 087459c3135dc5a9dad2cdec48911383bff6b1ff Mon Sep 17 00:00:00 2001
From: Spike Curtis <spike@coder.com>
Date: Tue, 4 Jun 2024 16:37:00 +0400
Subject: [PATCH] chore: add example test case for clock package

---
 clock/example_test.go | 84 +++++++++++++++++++++++++++++++++++++++++++
 1 file changed, 84 insertions(+)
 create mode 100644 clock/example_test.go

diff --git a/clock/example_test.go b/clock/example_test.go
new file mode 100644
index 0000000000000..69d6ba4a318ae
--- /dev/null
+++ b/clock/example_test.go
@@ -0,0 +1,84 @@
+package clock_test
+
+import (
+	"context"
+	"sync"
+	"testing"
+	"time"
+
+	"github.com/coder/coder/v2/clock"
+)
+
+type exampleTickCounter struct {
+	ctx   context.Context
+	mu    sync.Mutex
+	ticks int
+	clock clock.Clock
+}
+
+func (c *exampleTickCounter) Ticks() int {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+	return c.ticks
+}
+
+func (c *exampleTickCounter) count() {
+	_ = c.clock.TickerFunc(c.ctx, time.Hour, func() error {
+		c.mu.Lock()
+		defer c.mu.Unlock()
+		c.ticks++
+		return nil
+	}, "mytag")
+}
+
+func newExampleTickCounter(ctx context.Context, clk clock.Clock) *exampleTickCounter {
+	tc := &exampleTickCounter{ctx: ctx, clock: clk}
+	go tc.count()
+	return tc
+}
+
+// TestExampleTickerFunc demonstrates how to test the use of TickerFunc.
+func TestExampleTickerFunc(t *testing.T) {
+	t.Parallel()
+	// nolint:gocritic // trying to avoid Coder-specific stuff with an eye toward spinning this out
+	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+	defer cancel()
+
+	mClock := clock.NewMock()
+
+	// Because the ticker is started on a goroutine, we can't immediately start
+	// advancing the clock, or we will race with the start of the ticker. If we
+	// win that race, the clock gets advanced _before_ the ticker starts, and
+	// our ticker will not get a tick.
+	//
+	// To handle this, we set a trap for the call to TickerFunc(), so that we
+	// can assert it has been called before advancing the clock.
+	trap := mClock.Trap().TickerFunc("mytag")
+	defer trap.Close()
+
+	tc := newExampleTickCounter(ctx, mClock)
+
+	// Here, we wait for our trap to be triggered.
+	call, err := trap.Wait(ctx)
+	if err != nil {
+		t.Fatal("ticker never started")
+	}
+	// it's good practice to release calls before any possible t.Fatal() calls
+	// so that we don't leave dangling goroutines waiting for the call to be
+	// released.
+	call.Release()
+	if call.Duration != time.Hour {
+		t.Fatal("unexpected duration")
+	}
+
+	if tks := tc.Ticks(); tks != 0 {
+		t.Fatalf("expected 0 got %d ticks", tks)
+	}
+
+	// Now that we know the ticker is started, we can advance the time.
+	mClock.Advance(time.Hour).MustWait(ctx, t)
+
+	if tks := tc.Ticks(); tks != 1 {
+		t.Fatalf("expected 1 got %d ticks", tks)
+	}
+}