Local code intelligence for developers and AI agents. Connect code, docs and infrastructure in a persistent graph, with CBM Lens, MCP tools, agent integrations and change-aware test selection.
C aiderastclaude-codecode-analysiscode-intelligencecodexcursorcypherdeveloper-toolsgemini-cligraph-visualizationkilocodeknowledge-graphmcpmcp-servermodel-context-protocolopencodesqlitetree-sitterwindsurf
test(watcher): poll-only-watched-projects waits for the watched reindex, not one poll
Martin Vogel23d48336d336
diff --git a/tests/test_watcher.c b/tests/test_watcher.cindex 3ff0c81b4..49f4d2990 100644--- a/tests/test_watcher.c+++ b/tests/test_watcher.c@@ -2905,10 +2905,41 @@ TEST(watcher_fallback_still_detects) {PASS();}+/* Reindex counts for watcher_poll_only_watched_projects, split by project:+ * the watched one, and anything else. */+static int ow_watched_calls = 0;+static int ow_other_calls = 0;+static int ow_index_callback(const char *name, const char *path, void *ud) {+ (void)path;+ (void)ud;+ if (name && strcmp(name, "projA-ow") == 0) {+ ow_watched_calls++;+ } else {+ ow_other_calls++;+ }+ return 0;+}+TEST(watcher_poll_only_watched_projects) {- /* Port of TestPollAllOnlyWatched:- * Two repos exist, only one is watched → only the watched one- * gets polled and can trigger reindex. */+ /* Port of TestPollAllOnlyWatched (#49: the watcher polls its explicit+ * watch list, never every project the store knows). Two repos exist and+ * BOTH are registered in the store, as in the Go original; only A is+ * watched. Contract: B never gets watcher state and is never reindexed,+ * and A's change is reindexed.+ *+ * No verdict depends on one git probe succeeding. The earlier version+ * asserted that ONE poll after the change reindexed exactly once, and it+ * never registered B anywhere the watcher could see, so its B half could+ * not fail. A poll whose git probe fails transiently (spawn refused under+ * runner load) is a fail-closed no-op by design (#937: the baseline stays+ * uncommitted and the next poll retries), so that assert read+ * `index_call_count == 0, expected 1` on a loaded macOS runner. Holding+ * one exhausted spawn with cbm_subprocess_force_spawn_eagain_for_testing+ * at that poll reproduces the CI line exactly. The test now polls until+ * A's reindex has happened, and after every poll asserts the states that+ * hold whatever git answers: B has no watcher state and no reindex. A+ * watcher that never reindexes A hangs here, which the runner reports as+ * a failure, never a pass. */char tmpdirA[256];snprintf(tmpdirA, sizeof(tmpdirA), "/tmp/cbm_watcher_owA_XXXXXX");char tmpdirB[256];@@ -2941,19 +2972,32 @@ TEST(watcher_poll_only_watched_projects) {wt_git(tmpdirB, "add b.txt");wt_git(tmpdirB, "commit -q -m init");+ /* Both projects are known to the store. A watcher that polled stored+ * projects instead of its watch list (the pre-#49 scan-all) adopts B. */cbm_store_t *store = cbm_store_open_memory();- cbm_watcher_t *w = cbm_watcher_new(store, index_callback, NULL);+ ASSERT_EQ(cbm_store_upsert_project(store, "projA-ow", tmpdirA), CBM_STORE_OK);+ ASSERT_EQ(cbm_store_upsert_project(store, "projB-ow", tmpdirB), CBM_STORE_OK);+ cbm_watcher_t *w = cbm_watcher_new(store, ow_index_callback, NULL);/* Only watch A — B is NOT watched */cbm_watcher_watch(w, "projA-ow", tmpdirA);ASSERT_EQ(cbm_watcher_watch_count(w), 1);- index_call_count = 0;+ ow_watched_calls = 0;+ ow_other_calls = 0;- /* Baseline */- cbm_watcher_poll_once(w);- ASSERT_EQ(index_call_count, 0);+ /* Baseline poll. Its git outcome is not asserted: if a probe fails here,+ * a later poll takes the baseline instead. A baseline poll never indexes,+ * whatever git answers, and it must not adopt B. */+ ASSERT_EQ(cbm_watcher_poll_once(w), 0);+ ASSERT_EQ(ow_watched_calls + ow_other_calls, 0);+ ASSERT_EQ(cbm_watcher_index_failure_count(w, "projB-ow"), -1);+ ASSERT_EQ(cbm_watcher_watch_count(w), 1);- /* Make BOTH repos dirty */+ /* Make BOTH repos dirty. A dirty worktree, not a commit: the baseline+ * keeps the dirty signature at "clean known", so A's change is seen+ * whenever the baseline lands, even if the baseline poll above failed. A+ * commit made before a late baseline would be adopted as the baseline+ * HEAD and never reindexed. */{char _p[1024];snprintf(_p, sizeof(_p), "%s/a.txt", tmpdirA);@@ -2965,10 +3009,18 @@ TEST(watcher_poll_only_watched_projects) {th_append_file(_p, "dirty\n");}- /* Poll — only A should trigger (B is not watched) */- cbm_watcher_touch(w, "projA-ow");- cbm_watcher_poll_once(w);- ASSERT_EQ(index_call_count, 1);+ /* Poll until A's reindex. touch clears the adaptive interval so every+ * poll checks A; each poll runs at most one attempt for A, so the loop+ * stops at exactly one. After EVERY poll, B has no watcher state and no+ * reindex, whether or not that poll's git probes succeeded. */+ while (ow_watched_calls == 0) {+ cbm_watcher_touch(w, "projA-ow");+ cbm_watcher_poll_once(w);+ ASSERT_EQ(ow_other_calls, 0);+ ASSERT_EQ(cbm_watcher_index_failure_count(w, "projB-ow"), -1);+ ASSERT_EQ(cbm_watcher_watch_count(w), 1);+ }+ ASSERT_EQ(ow_watched_calls, 1);cbm_watcher_free(w);cbm_store_close(store);