checkin-store.test.ts

apps/worker/test/checkin-store.test.ts

1. /**
2. * The end-of-day note's storage: the decision, the SQL, and the four states a
3. * read can be in.
4. *
5. * Not the wording of the questions, which may be rewritten freely. What is
6. * pinned is the machinery that
7. * keeps the page honest: that a store which is absent, a store which is broken,
8. * and a store which is empty produce three different answers; that the day a
9. * row lands on comes from the clock and never from the form; and that an
10. * all-blank note cannot be written, because a blank row and a day she never
11. * opened the form read identically to whoever is looking.
12. *
13. * The SQL runs. `0001_checkin.sql` is applied to a real SQLite engine rather
14. * than read, which is not ceremony: a table CHECK placed in the middle of the
15. * column list makes SQLite refuse the whole CREATE, and nothing short of
16. * executing it says so.
17. */
19. import { describe, expect, it } from 'vitest'
20. import {
21. decideCheckin,
22. readCheckins,
23. readCheckinsFor,
24. saveCheckin,
25. type CheckinEnv,
26. } from '../src/checkin.js'
27. import { makeBrokenD1, makeD1, migrationSql, sqliteAvailable } from './d1-sqlite.js'
28. import { CHECKIN_QUESTIONS } from '../../../config/checkin.js'
30. const PERSON = 'Rosa Galván'
31. const EMAIL = 'accounts@meridiandisplay.example'
33. /** 6:40 PM Chicago on Tuesday 15 September 2026, after the form opens. */
34. const EVENING = new Date('2026-09-15T23:40:00.000Z')
35. /** 12:30 AM Chicago on the 16th, which is still the 15th's note. */
36. const AFTER_MIDNIGHT = new Date('2026-09-16T05:30:00.000Z')
37. /** 10:00 AM Chicago on the 16th: a new day, and the form is folded shut. */
38. const MORNING = new Date('2026-09-16T15:00:00.000Z')
40. const input = (over: Partial<Parameters<typeof saveCheckin>[1]> = {}) => ({
41. person: PERSON,
42. authorEmail: EMAIL,
43. claimedDay: '2026-09-15',
44. did: 'Answered the new leads and sent two proofs.',
45. unsure: 'Whether a rush order needs a second proof.',
46. need: 'A walkthrough of the proof tool.',
47. ...over,
48. })
50. describe('decideCheckin: what may be written, and to which day', () => {
51. it('files an evening note against today', () => {
52. const d = decideCheckin(input(), EVENING)
53. expect(d).toMatchObject({ write: true, day: '2026-09-15' })
54. })
56. it('files a 12:30 AM note against the day that just ended, not the one starting', () => {
57. // Without the grace window she files two wrong facts at once: a missed day
58. // behind her, and a note on a day she has not worked.
59. const d = decideCheckin(input({ claimedDay: '2026-09-15' }), AFTER_MIDNIGHT)
60. expect(d).toMatchObject({ write: true, day: '2026-09-15' })
61. })
63. it('refuses a form that claims a different day rather than writing it somewhere', () => {
64. // A tab left open overnight. Writing it into today's row would overwrite a
65. // note with text about another day; refusing costs a reload.
66. const d = decideCheckin(input({ claimedDay: '2026-09-14' }), EVENING)
67. expect(d).toEqual({ write: false, outcome: 'stale', day: '2026-09-15' })
68. })
70. it('refuses an all-blank note, whitespace included', () => {
71. const d = decideCheckin(input({ did: '', unsure: ' ', need: '\n' }), EVENING)
72. expect(d).toEqual({ write: false, outcome: 'empty', day: '2026-09-15' })
73. })
75. it('accepts a note with two of three blank, since one honest answer is an answer', () => {
76. const d = decideCheckin(input({ did: '', unsure: '', need: 'nothing today' }), EVENING)
77. expect(d).toMatchObject({ write: true })
78. })
80. it('takes the day from the clock even when the form sends nothing', () => {
81. expect(decideCheckin(input({ claimedDay: '' }), MORNING)).toMatchObject({
82. write: true,
83. day: '2026-09-16',
84. })
85. })
86. })
88. describe('an absent binding is not an empty store', () => {
89. const none: CheckinEnv = {}
91. it('reads as unconfigured, never as ok-with-no-notes', async () => {
92. // The whole feature rests on this distinction. "No rows" means she has not
93. // written one; "no binding" means nobody could have.
94. expect(await readCheckins(none, PERSON, EVENING)).toEqual({ state: 'unconfigured' })
95. })
97. it('refuses the write and says so, rather than reporting a save that never happened', async () => {
98. expect(await saveCheckin(none, input(), EVENING)).toEqual({
99. outcome: 'failed',
100. day: '2026-09-15',
101. })
102. })
104. it('still refuses a stale or empty submission before it looks for a store', async () => {
105. // The refusal is about the submission, not about the plumbing, so it must
106. // not be reported as a store failure; those send the author looking in the
107. // wrong place.
108. expect(await saveCheckin(none, input({ did: '', unsure: '', need: '' }), EVENING)).toMatchObject(
109. { outcome: 'empty' },
110. )
111. })
112. })
114. describe('a store that refuses is reported as failed, with what it said', () => {
115. it('carries the store’s own message and no diagnosis of its own', async () => {
116. const env = { CHECKINS: makeBrokenD1('D1_ERROR: no such table: checkin') } as CheckinEnv
117. const out = await readCheckins(env, PERSON, EVENING)
118. expect(out.state).toBe('failed')
119. // Rule 1: report what happened, do not pick a cause. The 401 handler once
120. // told somebody a token with eleven months left had expired.
121. if (out.state === 'failed') {
122. expect(out.error).toContain('no such table')
123. expect(out.error).not.toMatch(/probably|most likely|forgot|you should/i)
124. }
125. })
127. it('a failed write is reported as failed, not as saved', async () => {
128. const env = { CHECKINS: makeBrokenD1() } as CheckinEnv
129. expect(await saveCheckin(env, input(), EVENING)).toMatchObject({ outcome: 'failed' })
130. })
131. })
133. const describeSql = sqliteAvailable() ? describe : describe.skip
134. if (!sqliteAvailable()) {
135. // Loud, not silent. A suite that quietly shrinks on an older runtime is rule
136. // 8 with the volume down: the tests below would stop running and nothing
137. // would say so.
138. console.warn(
139. 'checkin-store.test.ts: node:sqlite is unavailable on this runtime, so the SQL tests were ' +
140. 'SKIPPED. The migration and the queries were not exercised. Node 22.5+ runs them.',
141. )
142. }
144. describeSql('the migration and the queries, against a real engine', () => {
145. const env = (): CheckinEnv => ({ CHECKINS: makeD1() })
147. it('applies as written', () => {
148. expect(() => makeD1()).not.toThrow()
149. })
151. it('has a column for every question, under the question’s own id', () => {
152. // The INSERT names these columns and the form names the same strings.
153. // Renaming a question id without a migration would fail at runtime, on the
154. // one action whose failure costs somebody the text they just typed.
155. // Named, now that there is more than one migration: this asserts something
156. // about 0001 and would start passing for the wrong reason if a later file
157. // happened to contain a matching column.
158. const sql = migrationSql('0001_checkin.sql')
159. for (const q of CHECKIN_QUESTIONS) expect(sql).toMatch(new RegExp(`\\b${q.id}\\s+TEXT NOT NULL`))
160. })
162. it('saves a note and reads it back', async () => {
163. const e = env()
164. expect(await saveCheckin(e, input(), EVENING)).toEqual({ outcome: 'saved', day: '2026-09-15' })
165. const out = await readCheckins(e, PERSON, EVENING)
166. expect(out.state).toBe('ok')
167. if (out.state !== 'ok') return
168. expect(out.notes).toHaveLength(1)
169. expect(out.notes[0]).toMatchObject({
170. person: PERSON,
171. day: '2026-09-15',
172. unsure: 'Whether a rush order needs a second proof.',
173. revisions: 1,
174. authorEmail: EMAIL,
175. })
176. })
178. it('a second submission the same day updates the row instead of adding one', async () => {
179. const e = env()
180. await saveCheckin(e, input(), EVENING)
181. const second = await saveCheckin(e, input({ need: 'The proof tool walkthrough, still.' }), AFTER_MIDNIGHT)
182. expect(second.outcome).toBe('updated')
183. const out = await readCheckins(e, PERSON, EVENING)
184. if (out.state !== 'ok') throw new Error('expected ok')
185. expect(out.notes).toHaveLength(1)
186. expect(out.notes[0]?.revisions).toBe(2)
187. expect(out.notes[0]?.need).toBe('The proof tool walkthrough, still.')
188. })
190. it('keeps the earlier version, so an edit cannot quietly rewrite what was read', async () => {
191. const e = env()
192. await saveCheckin(e, input({ unsure: 'Everything, honestly.' }), EVENING)
193. await saveCheckin(e, input({ unsure: 'Nothing much.' }), AFTER_MIDNIGHT)
194. const out = await readCheckins(e, PERSON, EVENING)
195. if (out.state !== 'ok') throw new Error('expected ok')
196. expect(out.earlier.map((r) => r.revision)).toEqual([2, 1])
197. expect(out.earlier.find((r) => r.revision === 1)?.unsure).toBe('Everything, honestly.')
198. })
200. it('an identical resubmit writes nothing at all', async () => {
201. // A double-click would otherwise leave the reader's card saying "edited"
202. // about text that never changed.
203. const e = env()
204. await saveCheckin(e, input(), EVENING)
205. expect(await saveCheckin(e, input(), EVENING)).toMatchObject({ outcome: 'unchanged' })
206. const out = await readCheckins(e, PERSON, EVENING)
207. if (out.state !== 'ok') throw new Error('expected ok')
208. expect(out.notes[0]?.revisions).toBe(1)
209. expect(out.earlier).toHaveLength(1)
210. })
212. it('keeps the first submission time across an edit', async () => {
213. const e = env()
214. await saveCheckin(e, input(), EVENING)
215. await saveCheckin(e, input({ did: 'changed' }), AFTER_MIDNIGHT)
216. const out = await readCheckins(e, PERSON, EVENING)
217. if (out.state !== 'ok') throw new Error('expected ok')
218. // "written at 6:40 PM" has to mean when she wrote it, not when she fixed a
219. // typo in it.
220. expect(out.notes[0]?.submittedAt).toBe(EVENING.toISOString())
221. expect(out.notes[0]?.updatedAt).toBe(AFTER_MIDNIGHT.toISOString())
222. })
224. it('the storage layer refuses an all-blank row even if something routes around the handler', async () => {
225. const db = makeD1()
226. expect(() =>
227. db
228. .prepare(
229. `INSERT INTO checkin (person, author_email, day, day_tz, did, unsure, need,
230. submitted_at, updated_at, revisions)
231. VALUES (?1, ?2, ?3, ?4, '', ' ', '', ?5, ?5, 1)`,
232. )
233. .bind(PERSON, EMAIL, '2026-09-15', 'America/Chicago', EVENING.toISOString())
234. .__run(),
235. ).toThrow(/CHECK constraint failed/)
236. })
238. it('refuses a malformed day, which would sort into the wrong place forever', async () => {
239. const db = makeD1()
240. expect(() =>
241. db
242. .prepare(
243. `INSERT INTO checkin (person, author_email, day, day_tz, did, unsure, need,
244. submitted_at, updated_at, revisions)
245. VALUES (?1, ?2, '15/09/2026', 'America/Chicago', 'x', '', '', ?3, ?3, 1)`,
246. )
247. .bind(PERSON, EMAIL, EVENING.toISOString())
248. .__run(),
249. ).toThrow(/CHECK constraint failed/)
250. })
252. it('files a different person’s notes separately, which is the seat-change case', async () => {
253. // accounts@ changes hands. The next holder signs in as the same address and
254. // must start empty rather than inheriting weeks of "what I'm unsure about"
255. // written by somebody else.
256. const e = env()
257. await saveCheckin(e, input(), EVENING)
258. await saveCheckin(e, input({ person: 'Someone Else', did: 'their day' }), EVENING)
259. const mine = await readCheckins(e, PERSON, EVENING)
260. const theirs = await readCheckins(e, 'Someone Else', EVENING)
261. if (mine.state !== 'ok' || theirs.state !== 'ok') throw new Error('expected ok')
262. expect(mine.notes).toHaveLength(1)
263. expect(theirs.notes).toHaveLength(1)
264. expect(theirs.notes[0]?.did).toBe('their day')
265. })
267. it('an empty store reads as ok-and-empty, which is a different thing from both failures', async () => {
268. const out = await readCheckins(env(), PERSON, EVENING)
269. expect(out).toMatchObject({ state: 'ok', notes: [], earlier: [], truncated: false })
270. })
272. it('reads several people in one call, each with its own state', async () => {
273. const e = env()
274. await saveCheckin(e, input(), EVENING)
275. const all = await readCheckinsFor(e, [PERSON, 'Nobody At All'], EVENING)
276. expect(Object.keys(all).sort()).toEqual(['Nobody At All', 'Rosa Galván'])
277. expect(all[PERSON]?.state).toBe('ok')
278. // A person with no rows is ok-and-empty, never absent from the map, since a
279. // missing key would render as nothing at all.
280. expect(all['Nobody At All']).toMatchObject({ state: 'ok', notes: [] })
281. })
283. it('does not reach back past the window the card will render', async () => {
284. // The query window and the rendered day list come from one function. If
285. // this ever returns a day the card does not list, that note is invisible.
286. const e = env()
287. await saveCheckin(e, input({ claimedDay: '' }), new Date('2026-08-01T23:40:00.000Z'))
288. const out = await readCheckins(e, PERSON, EVENING)
289. if (out.state !== 'ok') throw new Error('expected ok')
290. expect(out.notes.map((n) => n.day)).not.toContain('2026-08-01')
291. })
292. })