fix(fix): revert the 10-second ticker to 10m after forgetting to revert it after testing

api/main.go

@@ -25,25 +25,6 @@ import (
 
 const version = "v0.1.0"
 
-// everyTick runs fn on its own goroutine every d until ctx is cancelled.
-// Shared by the reconciler sweeps so the ticker + shutdown plumbing lives in
-// one place. ReconcileUnshipped intentionally does not use it, it needs a
-// staggered warm-up run before its first tick.
-func everyTick(ctx context.Context, d time.Duration, fn func(context.Context)) {
-	go func() {
-		ticker := time.NewTicker(d)
-		defer ticker.Stop()
-		for {
-			select {
-			case <-ticker.C:
-				fn(ctx)
-			case <-ctx.Done():
-				return
-			}
-		}
-	}()
-}
-
 func main() {
 	observability.InitLogger()
 	middleware.SetBuildInfo(version)
@@ -125,8 +106,20 @@ func main() {
 		}
 	}()
 
-	// Catch orders charged but not recorded due to a crash. Every 5 minutes
-	everyTick(ctx, 5*time.Minute, handlers.ReconcileOrders)
+	// Start reconciliation job. runs every 5 minutes to catch any orders
+	// that were charged but not recorded due to a crash.
+	go func() {
+		ticker := time.NewTicker(5 * time.Minute)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-ticker.C:
+				handlers.ReconcileOrders(ctx)
+			case <-ctx.Done():
+				return
+			}
+		}
+	}()
 
 	go func() {
 		select {
@@ -149,18 +142,46 @@ func main() {
 
 	// Sweep saved cards whose retention deadline elapsed. Read paths filter
 	// expired rows from query results, so this sweeper only drives the Stripe
-	// detach + audit + physical row delete asynchronously. Hourly.
-	everyTick(ctx, 1*time.Hour, handlers.ReconcileExpiredCards)
+	// detach + audit + physical row delete asynchronously.
+	go func() {
+		ticker := time.NewTicker(1 * time.Hour)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-ticker.C:
+				handlers.ReconcileExpiredCards(ctx)
+			case <-ctx.Done():
+				return
+			}
+		}
+	}()
 
-	// Flip abandoned 3DS orders to failed. Every 15 minutes.
-	threshold := time.Duration(cfg.Abandoned3DSThresholdMinutes) * time.Minute
-	everyTick(ctx, 15*time.Minute, func(ctx context.Context) {
-		handlers.ReconcileStale3DSOrders(ctx, threshold)
-	})
+	go func() {
+		ticker := time.NewTicker(15 * time.Minute)
+		defer ticker.Stop()
+		threshold := time.Duration(cfg.Abandoned3DSThresholdMinutes) * time.Minute
+		for {
+			select {
+			case <-ticker.C:
+				handlers.ReconcileStale3DSOrders(ctx, threshold)
+			case <-ctx.Done():
+				return
+			}
+		}
+	}()
 
-	// Sweep expired pay_redirects rows so the table stays bounded. Lazy delete
-	// on read is the primary path; this only reclaims tokens nobody follows.
-	everyTick(ctx, 10*time.Minute, handlers.ReconcilePayRedirects)
+	go func() {
+		ticker := time.NewTicker(10 * time.Minute)
+		defer ticker.Stop()
+		for {
+			select {
+			case <-ticker.C:
+				handlers.ReconcilePayRedirects(ctx)
+			case <-ctx.Done():
+				return
+			}
+		}
+	}()
 
 	log.Println("API server started. Press Ctrl+C to shutdown.")
 

api/main_test.go

@@ -1,92 +0,0 @@
-package main
-
-import (
-	"context"
-	"testing"
-	"time"
-)
-
-// TestEveryTick_CallsFnOnTick verifies the helper invokes fn repeatedly on its
-// interval. A non-blocking send keeps the spawned goroutine from ever blocking
-// on a full channel, and the 1s timeout per tick is generous vs the 1ms
-// interval so the test is not timing-flaky.
-func TestEveryTick_CallsFnOnTick(t *testing.T) {
-	ctx := t.Context()
-
-	fired := make(chan struct{}, 1)
-	everyTick(ctx, time.Millisecond, func(context.Context) {
-		select {
-		case fired <- struct{}{}:
-		default:
-		}
-	})
-
-	for i := range 3 {
-		select {
-		case <-fired:
-		case <-time.After(time.Second):
-			t.Fatalf("tick %d did not fire within 1s", i+1)
-		}
-	}
-}
-
-// TestEveryTick_StopsOnContextCancel verifies cancelling ctx stops the loop.
-// After the first tick we cancel inside the inter-tick gap, so everyTick's
-// select sees only ctx.Done ready (ticker.C is cold) and returns
-// deterministically — there is no random pick between two ready cases. We then
-// confirm no further tick arrives within a full interval, which a live loop
-// could not satisfy. This is the shutdown guarantee the reconcilers depend on.
-func TestEveryTick_StopsOnContextCancel(t *testing.T) {
-	ctx, cancel := context.WithCancel(context.Background())
-
-	const interval = 50 * time.Millisecond
-	ticks := make(chan struct{}) // unbuffered: fn blocks until the test receives
-	everyTick(ctx, interval, func(context.Context) {
-		ticks <- struct{}{}
-	})
-
-	// First tick proves the loop is running and leaves the goroutine back in
-	// select with ticker.C cold for the next ~interval.
-	select {
-	case <-ticks:
-	case <-time.After(time.Second):
-		t.Fatal("everyTick never called fn")
-	}
-
-	cancel()
-
-	// Cancel landed in the cold gap, so the loop must have taken ctx.Done and
-	// returned. A live loop would tick again at ~interval; a stopped one never
-	// will.
-	select {
-	case <-ticks:
-		t.Fatal("everyTick ticked again after cancel")
-	case <-time.After(interval + 50*time.Millisecond):
-		// good: silent past a full interval — the loop returned
-	}
-}
-
-func TestEveryTick_PassesContextToFn(t *testing.T) {
-	type ctxKey string
-	const marker ctxKey = "marker"
-	ctx, cancel := context.WithCancel(context.WithValue(context.Background(), marker, "present"))
-	defer cancel()
-
-	got := make(chan string, 1)
-	everyTick(ctx, time.Millisecond, func(c context.Context) {
-		v, _ := c.Value(marker).(string)
-		select {
-		case got <- v:
-		default:
-		}
-	})
-
-	select {
-	case v := <-got:
-		if v != "present" {
-			t.Fatalf("fn received wrong context: value = %q, want %q", v, "present")
-		}
-	case <-time.After(time.Second):
-		t.Fatalf("fn never ran")
-	}
-}