[fix] eliminate select race in checkUpdateHint (#301 regression) + test isolation (#303)

* [fix] eliminate select race in checkUpdateHint that drops update hints (#301 regression)

The two-goroutine design introduced in #301 has a scheduler race: the
fetch goroutine's defer cancel() fires the instant it sends its result,
making both the result case and tctx.Done() ready simultaneously in the
collector's select. Go picks pseudo-randomly, dropping the result ~50%
of the time on linux CI.

Fix: collapse to a single goroutine that writes to a buffered out channel
directly. With no select between "result" and "cancellation", the result
is un-droppable by construction. Adds a 500-iteration stress test
(TestCheckUpdateHintNeverDropsResult) as a regression guard.

* [test] restore global rootCmd in TestExecute to fix order-dependent TestExamplePresent

Execute() triggers cobra's InitDefaultHelpCmd(), permanently grafting a
"help" subcommand onto the global rootCmd. Any later test iterating
rootCmd.Commands() (e.g. TestExamplePresent) saw a runnable "help" with
no Example and failed. Failure was order-dependent: ~80% of -shuffle
seeds triggered it.

Clean up by removing the cobra-added "help" command in TestExecute's
t.Cleanup, restoring the pre-Execute command set for subsequent tests.

Author: lugassawan

cmd/root_test.go

@@ -222,6 +222,14 @@ func TestExecute(t *testing.T) {
 		// cancelled when Execute returns (via defer stop()). Reset it so
 		// subsequent tests that call cmd.Context() get a live context.
 		rootCmd.SetContext(context.Background())
+		// Execute() makes cobra graft a default "help" command onto the global
+		// rootCmd; remove it so later tests that iterate rootCmd's children
+		// (e.g. TestExamplePresent) aren't polluted by execution order.
+		for _, c := range rootCmd.Commands() {
+			if c.Name() == "help" {
+				rootCmd.RemoveCommand(c)
+			}
+		}
 	})
 
 	if err := Execute(); err != nil {

cmd/update_hint.go

@@ -18,15 +18,17 @@ var newUpdater func(string) *updater.Updater = updater.New
 // Returns nil if the version is dev, the check fails, times out, or is up to date.
 // The check is cancelled when ctx is done or timeout elapses — whichever comes first.
 func checkUpdateHint(ctx context.Context, version string, timeout time.Duration) <-chan *updater.CheckResult {
-	ch := make(chan *updater.CheckResult, 1)
+	out := make(chan *updater.CheckResult, 1)
 
 	if updater.IsDevVersion(version) {
-		close(ch)
-		return ch
+		close(out)
+		return out
 	}
 
-	// Derive a timeout-scoped child so the HTTP request is actually cancelled
-	// when timeout elapses, not just when the caller stops waiting.
+	// Bound the check by timeout so the HTTP request is actually cancelled, not
+	// just abandoned. u.Check honours tctx, so the goroutine always terminates
+	// within timeout — no leak, and the result can never be lost to a racing
+	// cancellation (there is no select between "result" and "ctx done").
 	tctx, cancel := context.WithTimeout(ctx, timeout)
 
 	// Read newUpdater before spawning the goroutine: goroutine launch
@@ -37,26 +39,10 @@ func checkUpdateHint(ctx context.Context, version string, timeout time.Duration)
 		defer cancel()
 		result, err := u.Check(tctx)
 		if err != nil || result.UpToDate {
-			close(ch)
-			return
-		}
-		ch <- result
-	}()
-
-	// Return a channel that resolves with the result or nil when tctx expires.
-	out := make(chan *updater.CheckResult, 1)
-	go func() {
-		defer cancel()
-		select {
-		case r, ok := <-ch:
-			if ok {
-				out <- r
-			} else {
-				close(out)
-			}
-		case <-tctx.Done():
 			close(out)
+			return
 		}
+		out <- result // buffered (cap 1) — never blocks
 	}()
 
 	return out

cmd/update_hint_test.go

@@ -152,6 +152,26 @@ func TestCollectHintValue(t *testing.T) {
 	}
 }
 
+func TestCheckUpdateHintNeverDropsResult(t *testing.T) {
+	// Regression guard for the #301 select race: a successfully-fetched, newer
+	// version must never be dropped. The race is scheduler-biased (reliably lost
+	// on linux CI, won on macOS), so this asserts the invariant over many runs.
+	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, _ *http.Request) {
+		w.Header().Set(hdrContentType, mimeJSON)
+		_, _ = w.Write([]byte(`{"tag_name":"v99.0.0","assets":[
+			{"name":"rimba_99.0.0_linux_amd64.tar.gz","browser_download_url":"https://github.com/lugassawan/rimba/releases/download/v99.0.0/rimba_99.0.0_linux_amd64.tar.gz"},
+			{"name":"checksums.txt","browser_download_url":"https://github.com/lugassawan/rimba/releases/download/v99.0.0/checksums.txt"}]}`))
+	}))
+	t.Cleanup(srv.Close)
+	overrideNewUpdater(t, srv)
+
+	for i := range 500 {
+		if got := collectHint(checkUpdateHint(context.Background(), testVersionHint, 2*time.Second)); got == nil {
+			t.Fatalf("iteration %d: update hint dropped (nil result) for a newer version", i)
+		}
+	}
+}
+
 func TestCheckUpdateHintCancelledContext(t *testing.T) {
 	srv := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
 		// A pre-cancelled context should cause the HTTP client to fail before