cron-split.test.ts

apps/worker/test/cron-split.test.ts

1. /**
2. * Two crons, one sync, one difference.
3. *
4. * Both the morning and the 15-minute cron run the full sync: statuses move all
5. * day, and a board showing the 6am numbers at 3pm is one people learn to
6. * distrust.
7. *
8. * The thing that must not come along with that is history. `history.ts` keeps
9. * one row per America/Chicago day, and its header is explicit that re-running
10. * "does not make yesterday mean an hour ago". Ninety-six rows a day would turn
11. * the day-over-day arrows from "since yesterday morning" into "since the last
12. * quarter hour": a change in what a number means, invisible on the page,
13. * arriving without a DEFS_VERSION bump. So the morning run owns the baseline and
14. * every other sync leaves it alone.
15. *
16. * These tests pin the branch by watching which KV keys each cron writes, since
17. * that is the observable difference and the one a future edit could quietly
18. * undo. They do not assert wording.
19. */
21. import { afterAll, beforeAll, describe, expect, it, vi } from 'vitest'
22. import worker, { decideSync, runRequestedSync, stampSyncState, sync, syncStateHtml } from '../src/index.js'
24. const HISTORY_KEY = 'dashboard:history'
26. // Every upstream call is stubbed, for two reasons. Speed is the small one. The
27. // real one: without this, a run on a shell that has credentials exported would fire live Bitrix, Plinth, Ninety, Gmail
28. // and Sheets requests from a unit test. `pnpm test` is offline and needs no
29. // credentials, and a test suite that quietly stops being either is a trap.
30. beforeAll(() => {
31. vi.stubGlobal('fetch', vi.fn(async () => new Response('unavailable', { status: 503 })))
32. })
33. afterAll(() => {
34. vi.unstubAllGlobals()
35. })
37. /** Records every put so a test can ask which keys a run touched. */
38. function recordingKv(store: Record<string, string> = {}) {
39. const puts: string[] = []
40. return {
41. puts,
42. kv: {
43. get: async (k: string) => store[k] ?? null,
44. put: async (k: string, v: string) => {
45. puts.push(k)
46. store[k] = v
47. },
48. },
49. }
50. }
52. /**
53. * Runs the scheduled handler for one cron and waits for the work it deferred.
54. *
55. * The handler hands everything to ctx.waitUntil, so a test that does not collect
56. * those promises sees an empty KV and passes for the wrong reason.
57. */
58. async function fire(cron: string, store: Record<string, string> = {}) {
59. const { kv, puts } = recordingKv(store)
60. const pending: Promise<unknown>[] = []
61. const ctx = { waitUntil: (p: Promise<unknown>) => void pending.push(p) }
62. // Every source fails, by way of the stubbed fetch above. That is the point for
63. // this test: even an all-sources-down run reveals which branch it took by what
64. // it writes, and a failing run must still not corrupt history.
65. const env = { DASHBOARD: kv, PLINTH_WINDOW_DAYS: '60' } as never
67. await worker.scheduled({ cron } as never, env, ctx as never)
68. await Promise.all(pending)
69. return { puts, store }
70. }
72. describe('both crons run the full sync', () => {
73. it('the 15-minute cron renders the board, not just the inbox', async () => {
74. // The regression this guards: reverting to inbox-only would leave the board
75. // frozen at the morning numbers while looking perfectly healthy.
76. const { puts } = await fire('*/15 * * * *')
77. expect(puts.some((k) => k.startsWith('dashboard:html'))).toBe(true)
78. expect(puts).toContain('dashboard:payload')
79. })
81. it('the morning cron renders the board too', async () => {
82. const { puts } = await fire('0 11 * * 1-5')
83. expect(puts.some((k) => k.startsWith('dashboard:html'))).toBe(true)
84. expect(puts).toContain('dashboard:payload')
85. })
87. it('both refresh the inbox', async () => {
88. for (const cron of ['*/15 * * * *', '0 11 * * 1-5']) {
89. const { puts } = await fire(cron)
90. expect(puts, cron).toContain('inbox:messages')
91. }
92. })
93. })
95. describe('only the morning cron owns the history row', () => {
96. it('the 15-minute cron never writes history', async () => {
97. // The whole point of the split. If this fails, the "vs yesterday" arrows
98. // silently start describing the last quarter hour.
99. const { puts } = await fire('*/15 * * * *')
100. expect(puts).not.toContain(HISTORY_KEY)
101. })
103. it('leaves an existing history row untouched', async () => {
104. const row = JSON.stringify([
105. { day: '2026-09-01', at: '2026-09-01T11:00:00.000Z', defs: 3, ourMove: 27,
106. designQueue: 8, waitingOnClient: 19, atVendor: 5, needsReply: 3, openLeads: 44 },
107. ])
108. const { store } = await fire('*/15 * * * *', { [HISTORY_KEY]: row })
109. expect(store[HISTORY_KEY]).toBe(row)
110. })
112. it('an unrecognised cron is treated as a non-morning run', async () => {
113. // Fail safe: a trigger added later must not start writing baselines just by
114. // existing. Getting fewer history rows than intended is a visible gap;
115. // getting extra ones corrupts the deltas retroactively.
116. const { puts } = await fire('*/5 * * * *')
117. expect(puts).not.toContain(HISTORY_KEY)
118. })
120. it('does not write history on the morning run either when a source failed', async () => {
121. // Pre-existing rule, re-pinned here because the branch above now sits next
122. // to it: a run where a source died reports zeros, and a zero recorded today
123. // becomes tomorrow's "yesterday". No credentials here, so everything fails.
124. const { puts } = await fire('0 11 * * 1-5')
125. expect(puts).not.toContain(HISTORY_KEY)
126. })
127. })
129. describe('a failing sync is recorded, not thrown', () => {
130. it('writes the error key rather than rejecting', async () => {
131. const { store } = await fire('*/15 * * * *')
132. expect(store['sync:lastError']).toBeTruthy()
133. })
134. })
136. /**
137. * The button is the third caller of sync(), and it belongs in this file for
138. * exactly the reason the file exists: what separates the callers is which KV
139. * keys they write, and history is the one that must not move.
140. *
141. * A manual sync refreshes the whole dashboard and runs no model, with no flag
142. * needed: sync() never calls a model; the written briefings are authored on a
143. * laptop and only read from KV here. What
144. * the button does need is writeHistory:false, or any click would overwrite the
145. * morning baseline and silently redefine every day-over-day arrow.
146. *
147. * These test sync() and decideSync() directly rather than the route. /sync sits
148. * behind Cloudflare Access and this suite cannot mint an assertion for it, which
149. * is why the decision is a pure function in the first place. The one thing
150. * asserted through the route is that it refuses an unidentified request.
151. */
152. describe('the Sync now button', () => {
153. /** What the button actually calls. */
154. async function manualSync(store: Record<string, string> = {}) {
155. const { kv, puts } = recordingKv(store)
156. const env = { DASHBOARD: kv, PLINTH_WINDOW_DAYS: '60' } as never
157. await sync(env, { writeHistory: false })
158. return { puts, store }
159. }
161. it('runs a full sync: the board, the payload and the inbox', async () => {
162. const { puts } = await manualSync()
163. expect(puts.some((k) => k.startsWith('dashboard:html'))).toBe(true)
164. expect(puts).toContain('dashboard:payload')
165. expect(puts).toContain('inbox:messages')
166. })
168. it('NEVER writes the history row', async () => {
169. // If this fails, a button anyone can press has just redefined what "since
170. // yesterday" means on every arrow, with nothing on the page showing it.
171. const { puts } = await manualSync()
172. expect(puts).not.toContain(HISTORY_KEY)
173. })
175. it('does not touch the written briefings; there is no model in this path', async () => {
176. const { puts } = await manualSync()
177. expect(puts).not.toContain('dashboard:briefings')
178. })
180. it('writes the same keys the 15-minute cron does, and no others', async () => {
181. // The button is that cron, on demand. If the two ever diverge, one of them
182. // is doing something the other is not and nobody decided that.
183. const { puts: cron } = await fire('*/15 * * * *')
184. const { puts: manual } = await manualSync()
185. expect(new Set(manual)).toEqual(new Set(cron))
186. })
187. })
189. describe('decideSync: the cooldown', () => {
190. const NOW = Date.parse('2026-09-04T18:00:00.000Z')
191. const at = (msAgo: number) => ({ at: new Date(NOW - msAgo).toISOString(), by: 'Sam Whitaker' })
193. it('allows a press when nothing has run', () => {
194. const d = decideSync(null, 'Sam Whitaker', NOW)
195. expect(d.run).toBe(true)
196. })
198. it('refuses a second press inside the window', () => {
199. // Two people clicking ten seconds apart each burn the Plinth and Bitrix rate
200. // limits; Bitrix answers with QUERY_LIMIT_EXCEEDED, which lands in
201. // sync:lastError and reads as a broken source rather than as two clicks.
202. const d = decideSync(at(10_000), 'Marco Ibáñez', NOW)
203. expect(d.run).toBe(false)
204. })
206. it('allows one again once the window has passed', () => {
207. expect(decideSync(at(10 * 60_000), 'Sam Whitaker', NOW).run).toBe(true)
208. })
210. it('records who asked and when, so a second person can see a run is going', () => {
211. const d = decideSync(null, 'Theo Bassett', NOW)
212. expect(d.run && d.record.by).toBe('Theo Bassett')
213. expect(d.run && Date.parse(d.record.at)).toBe(NOW)
214. })
216. it('FAILS OPEN on a corrupt or impossible record', () => {
217. // The cooldown protects a rate limit; losing it costs one extra sync.
218. // Failing closed would let one bad byte permanently disable the only manual
219. // control on the board.
220. for (const bad of [
221. { at: 'not a date', by: 'x' },
222. { at: new Date(NOW + 3_600_000).toISOString(), by: 'x' }, // future: clock skew
223. ]) {
224. expect(decideSync(bad, 'Sam Whitaker', NOW).run, JSON.stringify(bad)).toBe(true)
225. }
226. })
227. })
229. describe('the masthead line about a manual sync', () => {
230. const NOW = Date.parse('2026-09-04T18:00:00.000Z')
232. it('says nothing when no sync has been asked for', () => {
233. // The placeholder must vanish entirely rather than render an empty chip.
234. expect(syncStateHtml(null, NOW)).toBe('')
235. expect(stampSyncState('<b>x</b><span id="sync-state"></span>', null, NOW)).toBe('<b>x</b>')
236. })
238. it('reports elapsed time, and never claims the sync finished', () => {
239. // This route hands the work to waitUntil and cannot observe the outcome. A
240. // "done" it did not see is exactly the unobserved claim the board must not
241. // make. The Synced timestamp beside it is what changes when the run actually lands.
242. const html = syncStateHtml({ at: new Date(NOW - 12_000).toISOString(), by: 'Sam Whitaker' }, NOW)
243. expect(html).toContain('12s ago')
244. expect(html).toContain('Sam Whitaker')
245. expect(html).not.toMatch(/complete|finished|done|success/i)
246. })
248. it('stops mentioning it once the run is long past', () => {
249. expect(syncStateHtml({ at: new Date(NOW - 600_000).toISOString(), by: 'Sam' }, NOW)).toBe('')
250. })
252. it('escapes the name, which is board-owned but still user data', () => {
253. const html = syncStateHtml({ at: new Date(NOW - 1000).toISOString(), by: '<img src=x>' }, NOW)
254. expect(html).not.toContain('<img')
255. expect(html).toContain('<img')
256. })
257. })
259. describe('/sync fails closed without an identity', () => {
260. it('refuses an unidentified request, like every other route here', async () => {
261. const { kv } = recordingKv()
262. const res = await worker.fetch(
263. new Request('http://x/sync', { method: 'post' }),
264. { DASHBOARD: kv } as never,
265. { waitUntil: () => {} } as never,
266. )
267. expect(res.status).toBe(403)
268. })
269. })
271. /**
272. * The footer's claim and the fetch limit must be the same number, or the board
273. * misstates its own coverage. The page and the Worker share one constant; this
274. * checks the sync actually holds that many from a window larger than it.
275. */
276. describe('the inbox depth the page claims is the depth the sync fetches', () => {
277. it('holds INBOX_MAX_PER_MAILBOX messages from a larger window and says it is truncated', async () => {
278. const { INBOX_MAX_PER_MAILBOX } = await import('../../dashboard/src/inbox-view.js')
279. const windowSize = INBOX_MAX_PER_MAILBOX + 50
280. const ids = Array.from({ length: windowSize }, (_, i) => `m${i}`)
281. const gmail = vi.fn(async (input: string | URL | Request, init?: RequestInit) => {
282. const url = String(input)
283. if (url.startsWith('https://oauth2.googleapis.com/token')) {
284. return Response.json({ access_token: 'test-token', expires_in: 3600 })
285. }
286. if (url.startsWith('https://gmail.googleapis.com/gmail/v1/users/me/messages?')) {
287. return Response.json({ messages: ids.map((id) => ({ id })) })
288. }
289. if (url.startsWith('https://gmail.googleapis.com/batch/')) {
290. const asked = [...String(init?.body).matchAll(/messages\/([^?]+)\?format=metadata/g)].map((m) => m[1])
291. const boundary = 'resp-boundary'
292. const parts = asked.map(
293. (id) =>
294. `--${boundary}\r\nContent-Type: application/http\r\n\r\nHTTP/1.1 200 OK\r\n` +
295. `Content-Type: application/json\r\n\r\n${JSON.stringify({ id, threadId: id, internalDate: '1' })}\r\n`,
296. )
297. return new Response(`${parts.join('')}--${boundary}--\r\n`, {
298. headers: { 'content-type': `multipart/mixed; boundary=${boundary}` },
299. })
300. }
301. return new Response('unavailable', { status: 503 })
302. })
303. vi.stubGlobal('fetch', gmail)
304. // The batch requests are paced in real time; fake timers skip the waits.
305. vi.useFakeTimers({ toFake: ['setTimeout'] })
306. try {
307. const { kv } = recordingKv()
308. const env = {
309. DASHBOARD: kv,
310. PLINTH_WINDOW_DAYS: '60',
311. GMAIL_CLIENT_ID: 'client',
312. GMAIL_CLIENT_SECRET: 'secret',
313. GMAIL_REFRESH_HELLO: 'refresh',
314. } as never
315. const run = sync(env, { writeHistory: false })
316. await vi.runAllTimersAsync()
317. await run
318. const inbox = JSON.parse((await kv.get('inbox:messages'))!) as {
319. mailboxes: { mailbox: string; ok: boolean; messages: unknown[]; windowTotal: number | null; truncated: boolean }[]
320. }
321. const hello = inbox.mailboxes.find((m) => m.ok)
322. expect(hello?.mailbox).toBe('hello@meridiandisplay.example')
323. expect(hello?.messages).toHaveLength(INBOX_MAX_PER_MAILBOX)
324. expect(hello?.windowTotal).toBe(windowSize)
325. expect(hello?.truncated).toBe(true)
326. } finally {
327. vi.useRealTimers()
328. vi.stubGlobal('fetch', vi.fn(async () => new Response('unavailable', { status: 503 })))
329. }
330. })
331. })
333. /**
334. * The button records; the minute cron runs.
335. *
336. * A fetch handler's waitUntil does not get the budget a scheduled one does, and
337. * a two-minute sync does not fit in it: started from the route, it is cut off
338. * with nothing written and nothing in sync:lastError. The same sync() completes
339. * from a cron.
340. *
341. * These pin the split, because the failure mode is silence: a button that
342. * records a request nobody runs looks exactly like a button that worked.
343. */
344. describe('the minute cron runs what the button asked for', () => {
345. const request = (over: Record<string, unknown> = {}) =>
346. JSON.stringify({ at: new Date().toISOString(), by: 'Sam Whitaker', ...over })
348. it('runs a full sync when a request is pending', async () => {
349. const { kv, puts } = recordingKv({ 'sync:request': request() })
350. await runRequestedSync({ DASHBOARD: kv } as never)
351. expect(puts.some((k) => k.startsWith('dashboard:html'))).toBe(true)
352. expect(puts).toContain('inbox:messages')
353. })
355. it('still never writes the history row', async () => {
356. const { kv, puts } = recordingKv({ 'sync:request': request() })
357. await runRequestedSync({ DASHBOARD: kv } as never)
358. expect(puts).not.toContain(HISTORY_KEY)
359. })
361. it('does nothing at all on a minute with no request', async () => {
362. // Which is almost every minute. A cron that synced regardless would be a
363. // fourth sync nobody asked for, at sixty times the intended rate.
364. const { kv, puts } = recordingKv()
365. expect(await runRequestedSync({ DASHBOARD: kv } as never)).toBe(false)
366. expect(puts).toEqual([])
367. })
369. it('claims the request BEFORE running, so the next minute does not duplicate it', async () => {
370. // The cron fires every minute and a sync takes two. Without the claim the
371. // second minute starts a duplicate mid-run, and the two compete for the
372. // rate limits the cooldown exists to protect.
373. const store: Record<string, string> = { 'sync:request': request() }
374. const { kv } = recordingKv(store)
375. const order: string[] = []
376. const watched = {
377. ...kv,
378. put: async (k: string, v: string) => {
379. order.push(k)
380. await kv.put(k, v)
381. },
382. }
383. await runRequestedSync({ DASHBOARD: watched } as never)
384. expect(order[0]).toBe('sync:request')
385. expect(JSON.parse(store['sync:request']!).claimed).toBe(true)
386. })
388. it('refuses a request it has already claimed', async () => {
389. const { kv, puts } = recordingKv({ 'sync:request': request({ claimed: true }) })
390. expect(await runRequestedSync({ DASHBOARD: kv } as never)).toBe(false)
391. expect(puts).toEqual([])
392. })
394. it('ignores a stale request rather than running a sync nobody is waiting for', async () => {
395. // A press from an hour ago is not a press now: the tab is closed and the
396. // quarter-hour cron has run four times since.
397. const old = new Date(Date.now() - 60 * 60_000).toISOString()
398. const { kv, puts } = recordingKv({ 'sync:request': JSON.stringify({ at: old, by: 'Sam Whitaker' }) })
399. expect(await runRequestedSync({ DASHBOARD: kv } as never)).toBe(false)
400. expect(puts).toEqual([])
401. })
403. it('the minute cron writes nothing when idle, through the real handler', async () => {
404. const { puts } = await fire('* * * * *')
405. expect(puts).toEqual([])
406. })
408. it('the minute cron is not a third full sync', async () => {
409. // If this ever starts writing dashboard:html on an idle minute, the board
410. // is syncing sixty times an hour and burning every upstream rate limit.
411. const { puts } = await fire('* * * * *')
412. expect(puts.some((k) => k.startsWith('dashboard:html'))).toBe(false)
413. })
414. })
416. describe('POST /sync records the request and does not try to run it', () => {
417. it('writes sync:request and nothing else', async () => {
418. // The route cannot finish the work; that is the whole finding. What it can
419. // do is record that somebody asked, which is what the minute cron reads.
420. const { kv, puts } = recordingKv()
421. const res = await worker.fetch(
422. new Request('http://x/sync', { method: 'post' }),
423. { DASHBOARD: kv } as never,
424. { waitUntil: () => {} } as never,
425. )
426. // Unidentified in this suite, so it is refused. The identity-free
427. // assertion below is the one that matters here.
428. expect(res.status).toBe(403)
429. expect(puts).toEqual([])
430. })
431. })