refactor(test): drive preventBadQueries spec off onSearchComplete

The previous version scheduled three actions via wall-clock setTimeout
(10/20/30 ms) and waited for `ajaxCount === 2` to resolve a Promise
seeded inside `beforeEach`. Under load — particularly the fork-pool
cold-start path on Windows — the timeouts bunched up or the resolver
never fired, hitting the 10-second hook timeout. We saw the flake
three times in one session.

Rewrite the test to drive off the plugin's own `onSearchComplete`
callback, which fires for every query attempt (ajax success, ajax
failure, and bad-query short-circuit alike). Each action awaits the
next `onSearchComplete` directly — no wall clock, no nested setTimeout
chain, no race window.

5/5 consecutive local runs pass in ~50ms (was ~11s when passing,
10000+ ms when flaking).

Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: tkirda-bison

test/autocomplete.test.js

@@ -314,50 +314,57 @@ describe("Autocomplete Async — cache key", () => {
 });
 
 describe("Autocomplete Async — preventBadQueries", () => {
-    let ajaxCount = 0;
+    it("blocks queries that share a no-results prefix, until the guard is disabled", async () => {
+        const input = $("<input />");
+        const serviceUrl = "/autocomplete/prevent/ajax";
+        let ajaxCount = 0;
 
-    beforeEach(async () => {
-        await new Promise((resolve) => {
-            const input = $("<input />");
-            let instance;
-            const serviceUrl = "/autocomplete/prevent/ajax";
+        // Drive the test off the plugin's own `onSearchComplete` callback
+        // instead of wall-clock setTimeouts. onSearchComplete fires for every
+        // query attempt — ajax-succeeded, ajax-failed, AND bad-query-short-
+        // circuit — so it's a single deterministic synchronisation point.
+        const searchResolvers = [];
+        const nextSearchComplete = () =>
+            new Promise((resolve) => searchResolvers.push(resolve));
 
-            input.autocomplete({ serviceUrl });
+        $.mockjax({
+            url: serviceUrl,
+            responseTime: 1,
+            response: function () {
+                ajaxCount += 1;
+                this.responseText = JSON.stringify({ suggestions: [] });
+            },
+        });
 
-            $.mockjax({
-                url: serviceUrl,
-                responseTime: 1,
-                response: function () {
-                    ajaxCount += 1;
-                    this.responseText = JSON.stringify({ suggestions: [] });
-                    if (ajaxCount === 2) {
-                        resolve();
-                    }
-                },
-            });
+        input.autocomplete({
+            serviceUrl,
+            onSearchComplete: () => {
+                const resolve = searchResolvers.shift();
+                if (resolve) resolve();
+            },
+        });
+        const instance = input.autocomplete();
 
-            setTimeout(() => {
-                input.val("Jam");
-                instance = input.autocomplete();
-                instance.onValueChange();
-            }, 10);
+        // 1. "Jam" → ajax fires, empty response → "Jam" added to badQueries.
+        const ack1 = nextSearchComplete();
+        input.val("Jam");
+        instance.onValueChange();
+        await ack1;
 
-            setTimeout(() => {
-                input.val("Jama");
-                instance.onValueChange();
-            }, 20);
+        // 2. "Jama" starts with "Jam" → blocked by isBadQuery, no ajax;
+        //    onSearchComplete still fires synchronously with `[]`.
+        const ack2 = nextSearchComplete();
+        input.val("Jama");
+        instance.onValueChange();
+        await ack2;
 
-            setTimeout(() => {
-                instance.setOptions({ preventBadQueries: false });
-                input.val("Jamai");
-                instance.onValueChange();
-            }, 30);
-        });
-    });
+        // 3. Disable the guard, type a fresh query → ajax fires again.
+        const ack3 = nextSearchComplete();
+        instance.setOptions({ preventBadQueries: false });
+        input.val("Jamai");
+        instance.onValueChange();
+        await ack3;
 
-    it("Should prevent Ajax requests if previous query with matching root failed.", () => {
-        // Ajax call should have been made twice (then short-circuited by the
-        // bad-query guard until preventBadQueries was disabled).
         expect(ajaxCount).toBe(2);
     });
 });