checkin.test.ts

apps/dashboard/test/checkin.test.ts

1. /**
2. * The end-of-day note as a reader sees it: who gets the card, which day it is
3. * about, and the four things that must never look like each other.
4. *
5. * The access tests are the point of this file. The tab the card sits on is
6. * visible to everyone who reads the Leadership Team's to-dos (which is what
7. * makes the onboarding plan visible to them), and the readers of the note
8. * itself are a separate, hand-written list. Two grants that overlap in most
9. * cases and differ in one are exactly the shape that gets widened by analogy
10. * later (rule 13), so the difference is pinned by name.
11. *
12. * What is not pinned: the wording of the three questions. It may be rewritten
13. * at any time, and tests assert properties, not wording.
14. */
16. import { describe, expect, it } from 'vitest'
17. import {
18. CHECKIN_END,
19. CHECKIN_START,
20. checkinBlock,
21. checkinDay,
22. checkinIsOpen,
23. checkinPlaceholder,
24. checkinWindow,
25. expectedDays,
26. isWeekday,
27. localHour,
28. parseOutcome,
29. previousDay,
30. stampCheckin,
31. type CheckinNote,
32. type CheckinRevision,
33. type CheckinStore,
34. } from '../src/checkin-view.js'
35. import {
36. CHECKIN_ASKED_FROM,
37. CHECKIN_AUTHORS,
38. CHECKIN_READERS,
39. canReadCheckinsOf,
40. canWriteCheckin,
41. hasCheckin,
42. readableCheckinAuthors,
43. } from '../../../config/checkin.js'
44. import { COMPANY_VIEWER, viewerFor } from '../src/viewer.js'
45. import { onboardingSurface } from '../src/surfaces.js'
46. import { render } from '../src/render.js'
47. import { FIXTURE_SNAPSHOT } from '../src/fixtures.js'
48. import { headline } from '../src/collect.js'
50. const ROSA = 'Rosa Galván'
51. const rosa = viewerFor('accounts@meridiandisplay.example')
52. const sam = viewerFor('hello@meridiandisplay.example')
53. const theo = viewerFor('frontdesk@meridiandisplay.example')
54. const nora = viewerFor('nora.l@meridiandisplay.example')
55. const ines = viewerFor('projects@meridiandisplay.example')
56. const marco = viewerFor('studio@meridiandisplay.example')
58. const EVENING = new Date('2026-09-15T23:40:00.000Z') // 6:40 PM Tue, Chicago
59. const AFTERNOON = new Date('2026-09-15T18:00:00.000Z') // 1:00 PM Tue, Chicago
60. const AFTER_MIDNIGHT = new Date('2026-09-16T05:30:00.000Z') // 12:30 AM Wed
62. const note = (over: Partial<CheckinNote> = {}): CheckinNote => ({
63. person: ROSA,
64. day: '2026-09-15',
65. did: 'Answered the new leads and sent two proofs.',
66. unsure: 'Whether a rush order needs a second proof.',
67. need: 'A walkthrough of the proof tool.',
68. submittedAt: EVENING.toISOString(),
69. updatedAt: EVENING.toISOString(),
70. revisions: 1,
71. authorEmail: 'accounts@meridiandisplay.example',
72. ...over,
73. })
75. const ok = (notes: CheckinNote[] = [], earlier: CheckinRevision[] = []): CheckinStore => ({
76. state: 'ok',
77. notes,
78. earlier,
79. truncated: false,
80. })
82. describe('who gets the card at all', () => {
83. it('Rosa writes one', () => {
84. expect(canWriteCheckin(rosa)).toBe(true)
85. expect(readableCheckinAuthors(rosa)).toEqual([ROSA])
86. })
88. it('Sam and Theo read hers, and write none of their own', () => {
89. for (const v of [sam, theo]) {
90. expect(canReadCheckinsOf(v, ROSA)).toBe(true)
91. expect(canWriteCheckin(v)).toBe(false)
92. }
93. })
95. it('Ines reads hers too, by Sam\u2019s grant of 2026-09-16', () => {
96. // Ines is on the reader list by name, not by way of `seesLeadership`.
97. expect(canReadCheckinsOf(ines, ROSA)).toBe(true)
98. expect(canWriteCheckin(ines)).toBe(false)
99. })
101. it('Nora does NOT, though she sees the same tab and holds the same role flag', () => {
102. // The whole point. Nora and Ines read Leadership to-dos alike, which is what makes Rosa's plan visible to
103. // both; only Ines was granted the note. A reader list derived from
104. // `seesLeadership` would have handed it to Nora without anybody deciding.
105. expect(nora.seesLeadership).toBe(true)
106. expect(ines.seesLeadership).toBe(true)
107. expect(hasCheckin(nora)).toBe(false)
108. expect(canReadCheckinsOf(nora, ROSA)).toBe(false)
109. })
111. it('nobody else on the roster, and no unidentified viewer', () => {
112. for (const v of [marco, COMPANY_VIEWER]) expect(hasCheckin(v)).toBe(false)
113. })
115. it('renders literally nothing for a viewer with no grant', () => {
116. // Not a hidden div. The per-person briefings were `hidden` in one shared
117. // document once, and anybody through the Access door could read all seven
118. // from view-source.
119. for (const v of [nora, marco, COMPANY_VIEWER]) {
120. expect(checkinBlock(v, { [ROSA]: ok([note()]) }, EVENING)).toBe('')
121. }
122. })
124. it('does not put the placeholder in a page it will not fill', () => {
125. const forNora = onboardingSurface(nora)
126. expect(forNora).toContain('Onboarding') // she still sees the plan
127. expect(forNora).not.toContain(CHECKIN_START)
128. expect(onboardingSurface(ines)).toContain(CHECKIN_START)
129. expect(onboardingSurface(sam)).toContain(CHECKIN_START)
130. expect(onboardingSurface(rosa)).toContain(CHECKIN_START)
131. })
133. it('the whole page carries the placeholder for a reader and not for a non-reader', () => {
134. const page = (v: typeof sam): string =>
135. render(FIXTURE_SNAPSHOT, headline(FIXTURE_SNAPSHOT), [], '2026-09-15', null, v)
136. expect(page(sam)).toContain(CHECKIN_START)
137. expect(page(theo)).toContain(CHECKIN_START)
138. expect(page(rosa)).toContain(CHECKIN_START)
139. expect(page(ines)).toContain(CHECKIN_START)
140. expect(page(nora)).not.toContain(CHECKIN_START)
141. expect(page(marco)).not.toContain(CHECKIN_START)
142. })
144. it('config keeps the author list and the reader list apart', () => {
145. // Two lists, both written by hand. Neither derives from the other, and the
146. // author is not on the reader list; she reads her own words through her
147. // own card, which is a different code path.
148. expect(Object.keys(CHECKIN_AUTHORS)).not.toEqual(expect.arrayContaining(CHECKIN_READERS))
149. })
150. })
152. describe('which day a note is about', () => {
153. it('an evening note is today', () => {
154. expect(checkinDay(EVENING)).toBe('2026-09-15')
155. })
157. it('a 12:30 AM note is still yesterday', () => {
158. // She finished at half past midnight. Filing it forward would show a missed
159. // day behind her and a note on a day she has not worked.
160. expect(checkinDay(AFTER_MIDNIGHT)).toBe('2026-09-15')
161. })
163. it('a 10 AM note is today again', () => {
164. expect(checkinDay(new Date('2026-09-16T15:00:00.000Z'))).toBe('2026-09-16')
165. })
167. it('reads the hour in Meridian time, not UTC', () => {
168. // 23:40 UTC is the next day in UTC and 6:40 PM in Chicago. Slicing an ISO
169. // string here would file every evening note against tomorrow.
170. expect(localHour(EVENING)).toBe(18)
171. expect(EVENING.toISOString().slice(0, 10)).toBe('2026-09-15')
172. expect(localHour(new Date('2026-09-16T02:00:00.000Z'))).toBe(21)
173. })
175. it('is open in the evening and through the small hours, folded during the day', () => {
176. expect(checkinIsOpen(EVENING)).toBe(true)
177. expect(checkinIsOpen(AFTER_MIDNIGHT)).toBe(true)
178. expect(checkinIsOpen(AFTERNOON)).toBe(false)
179. })
181. it('crosses a month and a year boundary without arithmetic of its own', () => {
182. expect(previousDay('2026-09-01')).toBe('2026-08-31')
183. expect(previousDay('2027-01-01')).toBe('2026-12-31')
184. expect(previousDay('2028-03-01')).toBe('2028-02-29')
185. })
186. })
188. describe('the days a log accounts for', () => {
189. it('lists weekdays back to the day the habit began, newest first', () => {
190. const days = expectedDays('2026-09-18', '2026-09-15')
191. expect(days).toEqual(['2026-09-18', '2026-09-17', '2026-09-16', '2026-09-15'])
192. })
194. it('leaves weekends out, so they are not reported as missed', () => {
195. expect(expectedDays('2026-09-21', '2026-09-18')).toEqual(['2026-09-21', '2026-09-18'])
196. expect(isWeekday('2026-09-19')).toBe(false)
197. expect(isWeekday('2026-09-21')).toBe(true)
198. })
200. it('never reaches back past the day a note was first asked for', () => {
201. // She started on the 14th; the habit started on the 15th. A log calling the
202. // 14th a missed day would be reporting a failure against a rule that did
203. // not exist yet.
204. const days = expectedDays('2026-09-16', CHECKIN_ASKED_FROM)
205. expect(days).not.toContain('2026-09-14')
206. expect(days[days.length - 1]).toBe(CHECKIN_ASKED_FROM)
207. })
209. it('accounts for nothing when nothing has been asked for', () => {
210. expect(expectedDays('2026-09-16', null)).toEqual([])
211. })
213. it('queries the same window it renders', () => {
214. // If the query reached back less far than the card lists, a day with a note
215. // would render as a day she missed, the one sentence this must never say.
216. const { from, limit } = checkinWindow(ROSA, '2026-09-30')
217. const days = expectedDays('2026-09-30', CHECKIN_ASKED_FROM)
218. expect(from).toBe(days[days.length - 1])
219. expect(limit).toBeGreaterThanOrEqual(days.length)
220. })
221. })
223. describe('the four things that must not look alike', () => {
224. const read = (store: CheckinStore): string => checkinBlock(sam, { [ROSA]: store }, EVENING)
226. it('a store nobody has set up says so, and does not say "no notes"', () => {
227. const html = read({ state: 'unconfigured' })
228. expect(html).toMatch(/not set up/i)
229. expect(html).not.toMatch(/no note</i)
230. })
232. it('a store that refused says so, in its own words', () => {
233. const html = read({ state: 'failed', error: 'D1_ERROR: no such table: checkin' })
234. expect(html).toContain('no such table')
235. expect(html).toMatch(/missing, not empty/i)
236. })
238. it('a day with no note says "no note" and is counted as missed', () => {
239. const html = read(ok([]))
240. expect(html).toMatch(/no note/i)
241. expect(html).toMatch(/missed/i)
242. })
244. it('a day with a note shows the note', () => {
245. const html = read(ok([note()]))
246. expect(html).toContain('Answered the new leads and sent two proofs.')
247. expect(html).toContain('Whether a rush order needs a second proof.')
248. })
250. it('a question left blank renders as blank, not as an empty line', () => {
251. const html = read(ok([note({ need: '' })]))
252. expect(html).toMatch(/left blank/i)
253. })
255. it('the count and the list under it account for each other', () => {
256. // Rule 9, which this board learned when My Day's header said 13 and its
257. // list said nothing was on the board.
258. const html = read(ok([note()]))
259. const written = /(\d+) written/.exec(html)?.[1]
260. expect(written).toBe('1')
261. })
263. it('a missing person entry is a failure, not an empty log', () => {
264. // A reader whose store read never returned must not be shown a clean slate.
265. const html = checkinBlock(sam, {}, EVENING)
266. expect(html).toMatch(/could not be read/i)
267. })
268. })
270. describe('the author’s own card', () => {
271. const mine = (store: CheckinStore, now = EVENING, outcome = null): string =>
272. checkinBlock(rosa, { [ROSA]: store }, now, outcome)
274. it('offers the form, and names exactly who will read it', () => {
275. const html = mine(ok([]))
276. expect(html).toContain('action="/checkin"')
277. for (const r of CHECKIN_READERS) expect(html).toContain(r)
278. })
280. it('carries the day it is writing, so a stale tab can be caught server-side', () => {
281. expect(mine(ok([]))).toContain('name="day" value="2026-09-15"')
282. })
284. it('is folded shut in the afternoon and open in the evening', () => {
285. expect(mine(ok([]), AFTERNOON)).toMatch(/opens at 4:00 PM/)
286. expect(mine(ok([]), EVENING)).toMatch(/not written yet/)
287. })
289. it('accepts an early submission anyway, since a form that refuses typed text loses it', () => {
290. expect(mine(ok([]), AFTERNOON)).toContain('action="/checkin"')
291. })
293. it('pre-fills tonight’s note for an edit, and says edits are kept', () => {
294. const html = mine(ok([note()]))
295. expect(html).toContain('Answered the new leads and sent two proofs.')
296. expect(html).toMatch(/Edits are kept/i)
297. })
299. it('says out loud when a note is being filed against yesterday', () => {
300. const html = mine(ok([]), AFTER_MIDNIGHT)
301. expect(html).toMatch(/past midnight/i)
302. expect(html).toContain('name="day" value="2026-09-15"')
303. })
305. it('still shows the boxes when the store could not be read', () => {
306. // A read failure is not a write failure, and hiding the form guarantees the
307. // loss that showing it only risks.
308. const html = mine({ state: 'failed', error: 'D1_ERROR: timeout' })
309. expect(html).toContain('action="/checkin"')
310. expect(html).toMatch(/may not\s+save/i)
311. })
313. it('shows her what she wrote on earlier days', () => {
314. const html = mine(ok([note({ day: '2026-09-14', did: 'day one' })]))
315. expect(html).toContain('day one')
316. })
317. })
319. describe('the outcome banner', () => {
320. it('only ever echoes one of our own words back into the page', () => {
321. expect(parseOutcome('saved')).toBe('saved')
322. expect(parseOutcome('<img src=x onerror=1>')).toBeNull()
323. expect(parseOutcome(null)).toBeNull()
324. })
326. it('says nothing was saved when nothing was', () => {
327. const html = checkinBlock(rosa, { [ROSA]: ok([]) }, EVENING, 'empty')
328. expect(html).toMatch(/nothing was saved/i)
329. const failed = checkinBlock(rosa, { [ROSA]: ok([]) }, EVENING, 'failed')
330. expect(failed).toMatch(/not<\/b> saved/i)
331. })
332. })
334. describe('user text cannot become markup', () => {
335. it('escapes a note that tries to close a tag', () => {
336. const nasty = note({ did: '</textarea><img src=x onerror=alert(1)>' })
337. for (const v of [sam, rosa]) {
338. const html = checkinBlock(v, { [ROSA]: ok([nasty]) }, EVENING)
339. expect(html).not.toContain('<img src=x')
340. expect(html).toContain('<img src=x')
341. }
342. })
344. it('escapes it inside the edit box too, which is the easier one to miss', () => {
345. const html = checkinBlock(rosa, { [ROSA]: ok([note({ did: '</textarea><b>x' })]) }, EVENING)
346. expect(html).not.toContain('</textarea><b>')
347. })
349. it('escapes a store error, which is a string from somewhere else entirely', () => {
350. const html = checkinBlock(sam, { [ROSA]: { state: 'failed', error: '<script>x</script>' } }, EVENING)
351. expect(html).not.toContain('<script>x')
352. })
353. })
355. describe('stamping the block into a pre-rendered page', () => {
356. const PAGE = `<html><body><div>before</div>${checkinPlaceholder()}<div>after</div></body></html>`
358. it('replaces the placeholder and everything inside it', () => {
359. const out = stampCheckin(PAGE, '<p>the card</p>')
360. expect(out).toContain('<p>the card</p>')
361. expect(out).not.toContain(CHECKIN_START)
362. expect(out).not.toContain(CHECKIN_END)
363. expect(out).not.toMatch(/lives on the live board/)
364. expect(out).toContain('before')
365. expect(out).toContain('after')
366. })
368. it('an empty block leaves nothing behind, not an empty shell', () => {
369. const out = stampCheckin(PAGE, '')
370. expect(out).toBe('<html><body><div>before</div><div>after</div></body></html>')
371. })
373. it('a page with no placeholder is returned untouched', () => {
374. const plain = '<html><body>nothing here</body></html>'
375. expect(stampCheckin(plain, '<p>card</p>')).toBe(plain)
376. })
378. it('the placeholder itself says why it is empty, rather than being empty', () => {
379. // A file render has no Worker behind it. Silence there is a feature that
380. // silently is not there (rule 8).
381. expect(checkinPlaceholder()).toMatch(/lives on the live board/i)
382. })
383. })