@open-mercato/search 0.6.6-develop.5594.1.30cd738303 → 0.6.6-develop.5612.1.d382eb2f33

package/dist/modules/search/__integration__/TC-SEARCH-007.spec.js

@@ -20,14 +20,23 @@ test.describe("TC-SEARCH-007: concurrent fulltext reindex returns 409 with lock
       const settings = await apiRequest(request, "GET", "/api/search/settings", { token });
       expect(settings.ok(), "search settings should be readable after starting reindex").toBeTruthy();
       const settingsBody = await readJsonSafe(settings) ?? {};
-      expect(settingsBody.settings?.fulltextReindexLock?.type, "first reindex should leave an observable fulltext lock").toBe("fulltext");
-      const second = await apiRequest(request, "POST", "/api/search/reindex", { token, data: { useQueue: true } });
-      expect(second.status(), "a concurrent reindex must be rejected with 409").toBe(409);
-      const body = await readJsonSafe(second) ?? {};
-      expect(body.lock?.type, "the 409 lock descriptor identifies the fulltext lock").toBe("fulltext");
-      expect(typeof body.lock?.action, "the lock reports its action").toBe("string");
-      expect(typeof body.lock?.startedAt, "the lock reports when it started").toBe("string");
-      expect(typeof body.lock?.elapsedMinutes, "the lock reports elapsed minutes").toBe("number");
+      const heldLock = settingsBody.settings?.fulltextReindexLock ?? null;
+      if (heldLock) {
+        expect(heldLock.type, "a held reindex lock identifies the fulltext lock").toBe("fulltext");
+        const second = await apiRequest(request, "POST", "/api/search/reindex", { token, data: { useQueue: true } });
+        expect(second.status(), "a concurrent reindex must be rejected with 409").toBe(409);
+        const body = await readJsonSafe(second) ?? {};
+        expect(body.lock?.type, "the 409 lock descriptor identifies the fulltext lock").toBe("fulltext");
+        expect(typeof body.lock?.action, "the lock reports its action").toBe("string");
+        expect(typeof body.lock?.startedAt, "the lock reports when it started").toBe("string");
+        expect(typeof body.lock?.elapsedMinutes, "the lock reports elapsed minutes").toBe("number");
+      } else {
+        const second = await apiRequest(request, "POST", "/api/search/reindex", { token, data: { useQueue: true } });
+        expect(
+          [200, 503],
+          "with no held lock a concurrent reindex is not rejected with 409"
+        ).toContain(second.status());
+      }
     } finally {
       if (token) {
         await apiRequest(request, "POST", "/api/search/reindex/cancel", { token }).catch(() => void 0);

package/dist/modules/search/__integration__/TC-SEARCH-007.spec.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../../../src/modules/search/__integration__/TC-SEARCH-007.spec.ts"],
-  "sourcesContent": ["import { expect, test } from '@playwright/test'\nimport { apiRequest, getAuthToken } from '@open-mercato/core/helpers/integration/api'\nimport { readJsonSafe } from '@open-mercato/core/helpers/integration/generalFixtures'\n\ntype ReindexLock = {\n  type?: string\n  action?: string\n  startedAt?: string\n  elapsedMinutes?: number\n  processedCount?: number | null\n  totalCount?: number | null\n}\ntype ConflictBody = { error?: string; lock?: ReindexLock }\ntype SearchSettingsResponse = { settings?: { fulltextReindexLock?: ReindexLock | null } }\n\nconst DEFAULT_STRATEGIES = ['fulltext', 'vector', 'tokens']\n\n/**\n * TC-SEARCH-007: concurrent fulltext reindex returns 409 with lock info.\n * Source: issue #2483.\n *\n * Route: POST /api/search/reindex (requireFeatures ['search.reindex']). The route\n * acquires a per-tenant DB lock BEFORE any indexing work and, in queue mode\n * (useQueue:true \u2014 the default), does NOT release it in `finally` (workers and\n * the heartbeat own it). So a first call holds the lock and a second call returns\n * 409 with the lock descriptor \u2014 independent of whether a fulltext backend is\n * configured, because the lock is taken before the strategy-availability check.\n * Integration specs run serially (workers:1), so no other test contends for the\n * shared lock; it is released in `finally` via the cancel endpoint.\n */\ntest.describe('TC-SEARCH-007: concurrent fulltext reindex returns 409 with lock info', () => {\n  test('a second reindex while one is active is rejected with 409', async ({ request }) => {\n    test.slow()\n    test.setTimeout(120_000)\n\n    let token: string | null = null\n\n    try {\n      token = await getAuthToken(request, 'admin')\n\n      // Start from a clean lock state.\n      await apiRequest(request, 'POST', '/api/search/reindex/cancel', { token }).catch(() => undefined)\n      await apiRequest(request, 'POST', '/api/search/settings/global-search', {\n        token,\n        data: { enabledStrategies: DEFAULT_STRATEGIES },\n      }).catch(() => undefined)\n\n      // First reindex acquires (and, in queue mode, holds) the fulltext lock.\n      const first = await apiRequest(request, 'POST', '/api/search/reindex', { token, data: { useQueue: true } })\n      expect(first.status(), 'first reindex must not hit a pre-existing lock').not.toBe(409)\n      expect([200, 503], 'first reindex starts (200) or reports backend unavailable (503)').toContain(first.status())\n\n      const settings = await apiRequest(request, 'GET', '/api/search/settings', { token })\n      expect(settings.ok(), 'search settings should be readable after starting reindex').toBeTruthy()\n      const settingsBody = (await readJsonSafe<SearchSettingsResponse>(settings)) ?? {}\n      expect(settingsBody.settings?.fulltextReindexLock?.type, 'first reindex should leave an observable fulltext lock').toBe('fulltext')\n\n      // Second reindex is rejected while the first holds the lock.\n      const second = await apiRequest(request, 'POST', '/api/search/reindex', { token, data: { useQueue: true } })\n      expect(second.status(), 'a concurrent reindex must be rejected with 409').toBe(409)\n      const body = (await readJsonSafe<ConflictBody>(second)) ?? {}\n      expect(body.lock?.type, 'the 409 lock descriptor identifies the fulltext lock').toBe('fulltext')\n      expect(typeof body.lock?.action, 'the lock reports its action').toBe('string')\n      expect(typeof body.lock?.startedAt, 'the lock reports when it started').toBe('string')\n      expect(typeof body.lock?.elapsedMinutes, 'the lock reports elapsed minutes').toBe('number')\n    } finally {\n      if (token) {\n        await apiRequest(request, 'POST', '/api/search/reindex/cancel', { token }).catch(() => undefined)\n      }\n    }\n  })\n})\n"],
-  "mappings": "AAAA,SAAS,QAAQ,YAAY;AAC7B,SAAS,YAAY,oBAAoB;AACzC,SAAS,oBAAoB;AAa7B,MAAM,qBAAqB,CAAC,YAAY,UAAU,QAAQ;AAe1D,KAAK,SAAS,yEAAyE,MAAM;AAC3F,OAAK,6DAA6D,OAAO,EAAE,QAAQ,MAAM;AACvF,SAAK,KAAK;AACV,SAAK,WAAW,IAAO;AAEvB,QAAI,QAAuB;AAE3B,QAAI;AACF,cAAQ,MAAM,aAAa,SAAS,OAAO;AAG3C,YAAM,WAAW,SAAS,QAAQ,8BAA8B,EAAE,MAAM,CAAC,EAAE,MAAM,MAAM,MAAS;AAChG,YAAM,WAAW,SAAS,QAAQ,sCAAsC;AAAA,QACtE;AAAA,QACA,MAAM,EAAE,mBAAmB,mBAAmB;AAAA,MAChD,CAAC,EAAE,MAAM,MAAM,MAAS;AAGxB,YAAM,QAAQ,MAAM,WAAW,SAAS,QAAQ,uBAAuB,EAAE,OAAO,MAAM,EAAE,UAAU,KAAK,EAAE,CAAC;AAC1G,aAAO,MAAM,OAAO,GAAG,gDAAgD,EAAE,IAAI,KAAK,GAAG;AACrF,aAAO,CAAC,KAAK,GAAG,GAAG,iEAAiE,EAAE,UAAU,MAAM,OAAO,CAAC;AAE9G,YAAM,WAAW,MAAM,WAAW,SAAS,OAAO,wBAAwB,EAAE,MAAM,CAAC;AACnF,aAAO,SAAS,GAAG,GAAG,2DAA2D,EAAE,WAAW;AAC9F,YAAM,eAAgB,MAAM,aAAqC,QAAQ,KAAM,CAAC;AAChF,aAAO,aAAa,UAAU,qBAAqB,MAAM,wDAAwD,EAAE,KAAK,UAAU;AAGlI,YAAM,SAAS,MAAM,WAAW,SAAS,QAAQ,uBAAuB,EAAE,OAAO,MAAM,EAAE,UAAU,KAAK,EAAE,CAAC;AAC3G,aAAO,OAAO,OAAO,GAAG,gDAAgD,EAAE,KAAK,GAAG;AAClF,YAAM,OAAQ,MAAM,aAA2B,MAAM,KAAM,CAAC;AAC5D,aAAO,KAAK,MAAM,MAAM,sDAAsD,EAAE,KAAK,UAAU;AAC/F,aAAO,OAAO,KAAK,MAAM,QAAQ,6BAA6B,EAAE,KAAK,QAAQ;AAC7E,aAAO,OAAO,KAAK,MAAM,WAAW,kCAAkC,EAAE,KAAK,QAAQ;AACrF,aAAO,OAAO,KAAK,MAAM,gBAAgB,kCAAkC,EAAE,KAAK,QAAQ;AAAA,IAC5F,UAAE;AACA,UAAI,OAAO;AACT,cAAM,WAAW,SAAS,QAAQ,8BAA8B,EAAE,MAAM,CAAC,EAAE,MAAM,MAAM,MAAS;AAAA,MAClG;AAAA,IACF;AAAA,EACF,CAAC;AACH,CAAC;",
+  "sourcesContent": ["import { expect, test } from '@playwright/test'\nimport { apiRequest, getAuthToken } from '@open-mercato/core/helpers/integration/api'\nimport { readJsonSafe } from '@open-mercato/core/helpers/integration/generalFixtures'\n\ntype ReindexLock = {\n  type?: string\n  action?: string\n  startedAt?: string\n  elapsedMinutes?: number\n  processedCount?: number | null\n  totalCount?: number | null\n}\ntype ConflictBody = { error?: string; lock?: ReindexLock }\ntype SearchSettingsResponse = { settings?: { fulltextReindexLock?: ReindexLock | null } }\n\nconst DEFAULT_STRATEGIES = ['fulltext', 'vector', 'tokens']\n\n/**\n * TC-SEARCH-007: concurrent fulltext reindex returns 409 with lock info.\n * Source: issue #2483.\n *\n * Route: POST /api/search/reindex (requireFeatures ['search.reindex']). The route\n * acquires a per-tenant DB lock before starting the operation. In queue mode\n * (useQueue:true \u2014 the default) it only KEEPS the lock when there is queued work\n * for workers to own \u2014 i.e. the fulltext backend is available AND at least one\n * indexing job was enqueued. On the no-op paths (no indexable strategy / backend\n * unavailable \u2192 503, or zero jobs enqueued) the route deliberately releases the\n * lock in `finally` so it cannot get stuck with no worker to clear it (the\n * unit-level contract is pinned by `reindex.routes.test.ts`).\n *\n * Consequently the 409 \"already in progress\" guarantee is only observable while a\n * real reindex is actively holding the lock. This integration environment has no\n * Meilisearch backend, so the first reindex returns 503 and holds no lock; the\n * test asserts the held-lock \u2192 409 contract only when a lock is genuinely present,\n * and otherwise asserts that a backend-unavailable reindex neither leaves a lock\n * nor spuriously rejects a concurrent call. Integration specs run serially\n * (workers:1), so no other test contends for the shared lock; it is released in\n * `finally` via the cancel endpoint.\n */\ntest.describe('TC-SEARCH-007: concurrent fulltext reindex returns 409 with lock info', () => {\n  test('a second reindex while one is active is rejected with 409', async ({ request }) => {\n    test.slow()\n    test.setTimeout(120_000)\n\n    let token: string | null = null\n\n    try {\n      token = await getAuthToken(request, 'admin')\n\n      // Start from a clean lock state.\n      await apiRequest(request, 'POST', '/api/search/reindex/cancel', { token }).catch(() => undefined)\n      await apiRequest(request, 'POST', '/api/search/settings/global-search', {\n        token,\n        data: { enabledStrategies: DEFAULT_STRATEGIES },\n      }).catch(() => undefined)\n\n      // First reindex acquires the lock. It keeps the lock only when there is\n      // queued work (backend available + jobs enqueued); otherwise it returns\n      // 503/200 and releases the lock.\n      const first = await apiRequest(request, 'POST', '/api/search/reindex', { token, data: { useQueue: true } })\n      expect(first.status(), 'first reindex must not hit a pre-existing lock').not.toBe(409)\n      expect([200, 503], 'first reindex starts (200) or reports backend unavailable (503)').toContain(first.status())\n\n      const settings = await apiRequest(request, 'GET', '/api/search/settings', { token })\n      expect(settings.ok(), 'search settings should be readable after starting reindex').toBeTruthy()\n      const settingsBody = (await readJsonSafe<SearchSettingsResponse>(settings)) ?? {}\n      const heldLock = settingsBody.settings?.fulltextReindexLock ?? null\n\n      if (heldLock) {\n        // A real reindex is holding the lock: the concurrency contract applies.\n        expect(heldLock.type, 'a held reindex lock identifies the fulltext lock').toBe('fulltext')\n\n        const second = await apiRequest(request, 'POST', '/api/search/reindex', { token, data: { useQueue: true } })\n        expect(second.status(), 'a concurrent reindex must be rejected with 409').toBe(409)\n        const body = (await readJsonSafe<ConflictBody>(second)) ?? {}\n        expect(body.lock?.type, 'the 409 lock descriptor identifies the fulltext lock').toBe('fulltext')\n        expect(typeof body.lock?.action, 'the lock reports its action').toBe('string')\n        expect(typeof body.lock?.startedAt, 'the lock reports when it started').toBe('string')\n        expect(typeof body.lock?.elapsedMinutes, 'the lock reports elapsed minutes').toBe('number')\n      } else {\n        // No backend / no queued work: the route released the lock, so a\n        // concurrent reindex is NOT rejected with 409 \u2014 it behaves like the first.\n        const second = await apiRequest(request, 'POST', '/api/search/reindex', { token, data: { useQueue: true } })\n        expect(\n          [200, 503],\n          'with no held lock a concurrent reindex is not rejected with 409',\n        ).toContain(second.status())\n      }\n    } finally {\n      if (token) {\n        await apiRequest(request, 'POST', '/api/search/reindex/cancel', { token }).catch(() => undefined)\n      }\n    }\n  })\n})\n"],
+  "mappings": "AAAA,SAAS,QAAQ,YAAY;AAC7B,SAAS,YAAY,oBAAoB;AACzC,SAAS,oBAAoB;AAa7B,MAAM,qBAAqB,CAAC,YAAY,UAAU,QAAQ;AAwB1D,KAAK,SAAS,yEAAyE,MAAM;AAC3F,OAAK,6DAA6D,OAAO,EAAE,QAAQ,MAAM;AACvF,SAAK,KAAK;AACV,SAAK,WAAW,IAAO;AAEvB,QAAI,QAAuB;AAE3B,QAAI;AACF,cAAQ,MAAM,aAAa,SAAS,OAAO;AAG3C,YAAM,WAAW,SAAS,QAAQ,8BAA8B,EAAE,MAAM,CAAC,EAAE,MAAM,MAAM,MAAS;AAChG,YAAM,WAAW,SAAS,QAAQ,sCAAsC;AAAA,QACtE;AAAA,QACA,MAAM,EAAE,mBAAmB,mBAAmB;AAAA,MAChD,CAAC,EAAE,MAAM,MAAM,MAAS;AAKxB,YAAM,QAAQ,MAAM,WAAW,SAAS,QAAQ,uBAAuB,EAAE,OAAO,MAAM,EAAE,UAAU,KAAK,EAAE,CAAC;AAC1G,aAAO,MAAM,OAAO,GAAG,gDAAgD,EAAE,IAAI,KAAK,GAAG;AACrF,aAAO,CAAC,KAAK,GAAG,GAAG,iEAAiE,EAAE,UAAU,MAAM,OAAO,CAAC;AAE9G,YAAM,WAAW,MAAM,WAAW,SAAS,OAAO,wBAAwB,EAAE,MAAM,CAAC;AACnF,aAAO,SAAS,GAAG,GAAG,2DAA2D,EAAE,WAAW;AAC9F,YAAM,eAAgB,MAAM,aAAqC,QAAQ,KAAM,CAAC;AAChF,YAAM,WAAW,aAAa,UAAU,uBAAuB;AAE/D,UAAI,UAAU;AAEZ,eAAO,SAAS,MAAM,kDAAkD,EAAE,KAAK,UAAU;AAEzF,cAAM,SAAS,MAAM,WAAW,SAAS,QAAQ,uBAAuB,EAAE,OAAO,MAAM,EAAE,UAAU,KAAK,EAAE,CAAC;AAC3G,eAAO,OAAO,OAAO,GAAG,gDAAgD,EAAE,KAAK,GAAG;AAClF,cAAM,OAAQ,MAAM,aAA2B,MAAM,KAAM,CAAC;AAC5D,eAAO,KAAK,MAAM,MAAM,sDAAsD,EAAE,KAAK,UAAU;AAC/F,eAAO,OAAO,KAAK,MAAM,QAAQ,6BAA6B,EAAE,KAAK,QAAQ;AAC7E,eAAO,OAAO,KAAK,MAAM,WAAW,kCAAkC,EAAE,KAAK,QAAQ;AACrF,eAAO,OAAO,KAAK,MAAM,gBAAgB,kCAAkC,EAAE,KAAK,QAAQ;AAAA,MAC5F,OAAO;AAGL,cAAM,SAAS,MAAM,WAAW,SAAS,QAAQ,uBAAuB,EAAE,OAAO,MAAM,EAAE,UAAU,KAAK,EAAE,CAAC;AAC3G;AAAA,UACE,CAAC,KAAK,GAAG;AAAA,UACT;AAAA,QACF,EAAE,UAAU,OAAO,OAAO,CAAC;AAAA,MAC7B;AAAA,IACF,UAAE;AACA,UAAI,OAAO;AACT,cAAM,WAAW,SAAS,QAAQ,8BAA8B,EAAE,MAAM,CAAC,EAAE,MAAM,MAAM,MAAS;AAAA,MAClG;AAAA,IACF;AAAA,EACF,CAAC;AACH,CAAC;",
   "names": []
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@open-mercato/search",
-  "version": "0.6.6-develop.5594.1.30cd738303",
+  "version": "0.6.6-develop.5612.1.d382eb2f33",
   "type": "module",
   "main": "./dist/index.js",
   "exports": {
@@ -126,9 +126,9 @@
     "zod": "^4.4.3"
   },
   "peerDependencies": {
-    "@open-mercato/core": "0.6.6-develop.5594.1.30cd738303",
-    "@open-mercato/queue": "0.6.6-develop.5594.1.30cd738303",
-    "@open-mercato/shared": "0.6.6-develop.5594.1.30cd738303"
+    "@open-mercato/core": "0.6.6-develop.5612.1.d382eb2f33",
+    "@open-mercato/queue": "0.6.6-develop.5612.1.d382eb2f33",
+    "@open-mercato/shared": "0.6.6-develop.5612.1.d382eb2f33"
   },
   "devDependencies": {
     "@types/jest": "^30.0.0",

package/src/modules/search/__integration__/TC-SEARCH-007.spec.ts

@@ -20,13 +20,22 @@ const DEFAULT_STRATEGIES = ['fulltext', 'vector', 'tokens']
  * Source: issue #2483.
  *
  * Route: POST /api/search/reindex (requireFeatures ['search.reindex']). The route
- * acquires a per-tenant DB lock BEFORE any indexing work and, in queue mode
- * (useQueue:true — the default), does NOT release it in `finally` (workers and
- * the heartbeat own it). So a first call holds the lock and a second call returns
- * 409 with the lock descriptor — independent of whether a fulltext backend is
- * configured, because the lock is taken before the strategy-availability check.
- * Integration specs run serially (workers:1), so no other test contends for the
- * shared lock; it is released in `finally` via the cancel endpoint.
+ * acquires a per-tenant DB lock before starting the operation. In queue mode
+ * (useQueue:true — the default) it only KEEPS the lock when there is queued work
+ * for workers to own — i.e. the fulltext backend is available AND at least one
+ * indexing job was enqueued. On the no-op paths (no indexable strategy / backend
+ * unavailable → 503, or zero jobs enqueued) the route deliberately releases the
+ * lock in `finally` so it cannot get stuck with no worker to clear it (the
+ * unit-level contract is pinned by `reindex.routes.test.ts`).
+ *
+ * Consequently the 409 "already in progress" guarantee is only observable while a
+ * real reindex is actively holding the lock. This integration environment has no
+ * Meilisearch backend, so the first reindex returns 503 and holds no lock; the
+ * test asserts the held-lock → 409 contract only when a lock is genuinely present,
+ * and otherwise asserts that a backend-unavailable reindex neither leaves a lock
+ * nor spuriously rejects a concurrent call. Integration specs run serially
+ * (workers:1), so no other test contends for the shared lock; it is released in
+ * `finally` via the cancel endpoint.
  */
 test.describe('TC-SEARCH-007: concurrent fulltext reindex returns 409 with lock info', () => {
   test('a second reindex while one is active is rejected with 409', async ({ request }) => {
@@ -45,7 +54,9 @@ test.describe('TC-SEARCH-007: concurrent fulltext reindex returns 409 with lock
         data: { enabledStrategies: DEFAULT_STRATEGIES },
       }).catch(() => undefined)
 
-      // First reindex acquires (and, in queue mode, holds) the fulltext lock.
+      // First reindex acquires the lock. It keeps the lock only when there is
+      // queued work (backend available + jobs enqueued); otherwise it returns
+      // 503/200 and releases the lock.
       const first = await apiRequest(request, 'POST', '/api/search/reindex', { token, data: { useQueue: true } })
       expect(first.status(), 'first reindex must not hit a pre-existing lock').not.toBe(409)
       expect([200, 503], 'first reindex starts (200) or reports backend unavailable (503)').toContain(first.status())
@@ -53,16 +64,28 @@ test.describe('TC-SEARCH-007: concurrent fulltext reindex returns 409 with lock
       const settings = await apiRequest(request, 'GET', '/api/search/settings', { token })
       expect(settings.ok(), 'search settings should be readable after starting reindex').toBeTruthy()
       const settingsBody = (await readJsonSafe<SearchSettingsResponse>(settings)) ?? {}
-      expect(settingsBody.settings?.fulltextReindexLock?.type, 'first reindex should leave an observable fulltext lock').toBe('fulltext')
+      const heldLock = settingsBody.settings?.fulltextReindexLock ?? null
+
+      if (heldLock) {
+        // A real reindex is holding the lock: the concurrency contract applies.
+        expect(heldLock.type, 'a held reindex lock identifies the fulltext lock').toBe('fulltext')
 
-      // Second reindex is rejected while the first holds the lock.
-      const second = await apiRequest(request, 'POST', '/api/search/reindex', { token, data: { useQueue: true } })
-      expect(second.status(), 'a concurrent reindex must be rejected with 409').toBe(409)
-      const body = (await readJsonSafe<ConflictBody>(second)) ?? {}
-      expect(body.lock?.type, 'the 409 lock descriptor identifies the fulltext lock').toBe('fulltext')
-      expect(typeof body.lock?.action, 'the lock reports its action').toBe('string')
-      expect(typeof body.lock?.startedAt, 'the lock reports when it started').toBe('string')
-      expect(typeof body.lock?.elapsedMinutes, 'the lock reports elapsed minutes').toBe('number')
+        const second = await apiRequest(request, 'POST', '/api/search/reindex', { token, data: { useQueue: true } })
+        expect(second.status(), 'a concurrent reindex must be rejected with 409').toBe(409)
+        const body = (await readJsonSafe<ConflictBody>(second)) ?? {}
+        expect(body.lock?.type, 'the 409 lock descriptor identifies the fulltext lock').toBe('fulltext')
+        expect(typeof body.lock?.action, 'the lock reports its action').toBe('string')
+        expect(typeof body.lock?.startedAt, 'the lock reports when it started').toBe('string')
+        expect(typeof body.lock?.elapsedMinutes, 'the lock reports elapsed minutes').toBe('number')
+      } else {
+        // No backend / no queued work: the route released the lock, so a
+        // concurrent reindex is NOT rejected with 409 — it behaves like the first.
+        const second = await apiRequest(request, 'POST', '/api/search/reindex', { token, data: { useQueue: true } })
+        expect(
+          [200, 503],
+          'with no held lock a concurrent reindex is not rejected with 409',
+        ).toContain(second.status())
+      }
     } finally {
       if (token) {
         await apiRequest(request, 'POST', '/api/search/reindex/cancel', { token }).catch(() => undefined)