own-list.test.ts

apps/dashboard/test/own-list.test.ts

1. /**
2. * The private list, rendered.
3. *
4. * Not the prose, which may be rewritten freely. What is pinned is the set of things that would be a bug rather than a rewrite: that a
5. * viewer with no list gets nothing rather than an empty card; that a store
6. * belonging to somebody else refuses to render; that the four facts a read can
7. * report stay four different sentences; that "overdue" is decided from the clock
8. * the page was served with; and that the numbers in the header can be accounted
9. * for by the rows under them (rule 9).
10. */
12. import { describe, expect, it } from 'vitest'
13. import {
14. OWN_END,
15. OWN_START,
16. dueState,
17. ownListBlock,
18. ownListPlaceholder,
19. parseOwnOutcome,
20. sortOpen,
21. stampOwnList,
22. type OwnItem,
23. type OwnStore,
24. } from '../src/own-list-view.js'
25. import { COMPANY_VIEWER, viewerFor } from '../src/viewer.js'
27. /**
28. * Collapse runs of whitespace before asserting on prose.
29. *
30. * The sentences below are written across several source lines, and a browser
31. * collapses that run to one space, so a raw substring match would be asserting
32. * the shape of the template literal rather than what the reader sees, and would
33. * fail the next time somebody rewrapped a paragraph.
34. */
35. const flat = (html: string): string => html.replace(/\s+/g, ' ')
37. const SAM = viewerFor('hello@meridiandisplay.example')
38. const MARCO = viewerFor('studio@meridiandisplay.example')
39. /** A real address on the inbox lists that is NOT a roster person. */
40. const SUPPORT = viewerFor('help@meridiandisplay.example')
42. /** 10:00 AM Chicago on Wednesday 23 September 2026. */
43. const NOW = new Date('2026-09-23T15:00:00.000Z')
45. let nextId = 1
46. const item = (over: Partial<OwnItem> = {}): OwnItem => ({
47. id: nextId++,
48. text: 'Call the gym back about the backdrop proof',
49. due: null,
50. priority: 'normal',
51. linkKey: null,
52. createdAt: '2026-09-20T12:00:00.000Z',
53. updatedAt: '2026-09-20T12:00:00.000Z',
54. edits: 0,
55. doneAt: null,
56. ...over,
57. })
59. const ok = (open: OwnItem[] = [], done: OwnItem[] = [], person = 'Sam Whitaker'): OwnStore => ({
60. state: 'ok',
61. person,
62. open,
63. done,
64. truncated: false,
65. doneHidden: 0,
66. })
68. describe('who gets a list at all', () => {
69. it('a roster person does', () => {
70. expect(ownListBlock(SAM, ok(), NOW)).toContain('My own list')
71. })
73. it('every one of the seven does, with no config line written for any of them', () => {
74. // No grant map. config/own-list.ts has the argument: rule 13 guards
75. // permission over other people's things, and there is nobody to over-grant
76. // to on a store with one reader. A hand-written list here invites the
77. // failure where correct, reviewed, obviously-intended lines do nothing.
78. for (const email of [
79. 'hello@meridiandisplay.example',
80. 'accounts@meridiandisplay.example',
81. 'studio@meridiandisplay.example',
82. 'orderdesk@meridiandisplay.example',
83. 'projects@meridiandisplay.example',
84. 'frontdesk@meridiandisplay.example',
85. 'nora.l@meridiandisplay.example',
86. ]) {
87. expect(ownListBlock(viewerFor(email), ok(), NOW)).toContain('My own list')
88. }
89. })
91. it('an off-roster shared mailbox gets NOTHING: not an empty card, not a hidden div', () => {
92. // help@ and service@ are real addresses with real inbox grants and no
93. // roster person. A private list on a shared mailbox is a list everyone who
94. // signs into it can read.
95. expect(SUPPORT.person).toBeNull()
96. expect(ownListBlock(SUPPORT, ok(), NOW)).toBe('')
97. expect(ownListBlock(COMPANY_VIEWER, ok(), NOW)).toBe('')
98. })
100. it('refuses to render a store that belongs to somebody else', () => {
101. // Unreachable through any current call path, and checked anyway: the cost
102. // of the refactor that breaks it is one person reading another's private
103. // list, and the cost of the check is a string comparison.
104. const out = ownListBlock(SAM, ok([item({ text: 'Marco’s line' })], [], 'Marco Ibáñez'), NOW)
105. expect(out).not.toContain('Marco’s line')
106. expect(flat(out)).toContain('refused to render')
107. })
109. it('never puts one person’s text in another person’s block', () => {
110. const mine = ownListBlock(SAM, ok([item({ text: 'SAM-SENTINEL' })]), NOW)
111. const theirs = ownListBlock(MARCO, ok([item({ text: 'MARCO-SENTINEL' })], [], 'Marco Ibáñez'), NOW)
112. expect(mine).toContain('SAM-SENTINEL')
113. expect(mine).not.toContain('MARCO-SENTINEL')
114. expect(theirs).toContain('MARCO-SENTINEL')
115. expect(theirs).not.toContain('SAM-SENTINEL')
116. })
117. })
119. describe('the four facts a read can report', () => {
120. const states: Record<string, OwnStore> = {
121. unconfigured: { state: 'unconfigured' },
122. failed: { state: 'failed', error: 'D1_ERROR: no such table: own_item' },
123. empty: ok(),
124. full: ok([item()]),
125. }
127. it('renders four different things, and none of them is silence', () => {
128. const rendered = Object.values(states).map((s) => ownListBlock(SAM, s, NOW))
129. for (const r of rendered) expect(r.length).toBeGreaterThan(0)
130. expect(new Set(rendered).size).toBe(4)
131. })
133. it('an unconfigured store says it is a deploy step and offers no form', () => {
134. // A form that could only lose what was typed into it is worse than none.
135. // It is the same call bootNotes makes when the notes tag is absent.
136. const out = ownListBlock(SAM, states.unconfigured!, NOW)
137. expect(flat(out)).toContain('not set up')
138. expect(out).toContain('CHECKINS')
139. expect(out).not.toContain('<form')
140. })
142. it('a failed store says missing, not empty, and still offers the form', () => {
143. // A read failure is not a write failure. Hiding the box guarantees the loss
144. // that showing it only risks.
145. const out = ownListBlock(SAM, states.failed!, NOW)
146. expect(out).toContain('no such table: own_item')
147. expect(flat(out)).toContain('missing, not empty')
148. expect(out).toContain('<form')
149. })
151. it('neither absence prints a count', () => {
152. // A store that could not be read has no number. "0 open" here would be the
153. // prime invariant broken on the one surface where the reader is the only
154. // person who could notice.
155. for (const s of [states.unconfigured!, states.failed!]) {
156. const out = ownListBlock(SAM, s, NOW)
157. expect(out).toContain('not read')
158. expect(out).not.toMatch(/\d+ open/)
159. }
160. })
162. it('an empty list says it is empty BECAUSE NOTHING WAS WRITTEN, which is a true zero', () => {
163. // Everywhere else on this board an empty list is a claim about the world
164. // and must be kept apart from "not tracked". Here it is a claim about the
165. // owner, and saying so is what stops it reading like every other absence.
166. const out = ownListBlock(SAM, states.empty!, NOW)
167. expect(flat(out)).toContain('Nothing on your own list')
168. expect(flat(out)).toContain('have not added anything')
169. expect(out).toContain('<form')
170. })
171. })
173. describe('dates, decided from the clock the page was served with', () => {
174. it('no date is never overdue', () => {
175. expect(dueState(null, '2026-09-23')).toBe('none')
176. })
178. it('tells overdue, today and later apart', () => {
179. expect(dueState('2026-09-22', '2026-09-23')).toBe('overdue')
180. expect(dueState('2026-09-23', '2026-09-23')).toBe('today')
181. expect(dueState('2026-09-24', '2026-09-23')).toBe('later')
182. })
184. it('the same store renders differently on two days', () => {
185. // This is why the block is stamped at serve time rather than pre-rendered:
186. // an overdue flag decided by the 6 a.m. cron would be wrong by lunchtime,
187. // and silently wrong, which is the worst kind.
188. const store = ok([item({ due: '2026-09-23' })])
189. const onTheDay = ownListBlock(SAM, store, NOW)
190. const theNextWeek = ownListBlock(SAM, store, new Date('2026-09-30T15:00:00.000Z'))
191. expect(onTheDay).toContain('Due today')
192. expect(onTheDay).not.toContain('1 overdue')
193. expect(theNextWeek).toContain('Overdue')
194. expect(theNextWeek).toContain('1 overdue')
195. })
197. it('crosses midnight in Meridian time, not UTC', () => {
198. // 00:30 UTC on the 24th is still 7:30 PM Chicago on the 23rd, so a line due
199. // on the 23rd is due TODAY and not yet late.
200. const store = ok([item({ due: '2026-09-23' })])
201. expect(ownListBlock(SAM, store, new Date('2026-09-24T00:30:00.000Z'))).toContain('Due today')
202. })
204. it('sorts dated before undated, soonest first, priority breaking ties', () => {
205. const a = item({ due: '2026-09-25', priority: 'low' })
206. const b = item({ due: null, priority: 'high' })
207. const c = item({ due: '2026-09-24', priority: 'normal' })
208. const d = item({ due: '2026-09-25', priority: 'high' })
209. expect(sortOpen([a, b, c, d]).map((x) => x.id)).toEqual([c.id, d.id, a.id, b.id])
210. })
211. })
213. describe('the number and the list under it account for each other (rule 9)', () => {
214. const countRows = (html: string): number => (html.match(/class="own-row own-row-(?!done)/g) ?? []).length
216. it('the open count equals the rows rendered', () => {
217. const store = ok([
218. item({ due: '2026-09-20' }),
219. item({ due: '2026-09-23' }),
220. item({ due: '2026-09-30' }),
221. item({ due: null }),
222. ])
223. const out = ownListBlock(SAM, store, NOW)
224. expect(out).toContain('4 open')
225. expect(countRows(out)).toBe(4)
226. expect(flat(out)).toContain('4 open, and all of them are listed above')
227. })
229. it('overdue is a labelled subset, never a fourth addend', () => {
230. const store = ok([item({ due: '2026-09-20' }), item({ due: '2026-09-30' })])
231. const out = ownListBlock(SAM, store, NOW)
232. expect(out).toContain('2 open')
233. expect(out).toContain('1 overdue')
234. expect(flat(out)).toContain('past its date and counted in both numbers')
235. expect(countRows(out)).toBe(2)
236. })
238. it('says this list is NOT inside "on my board" at the top of the card', () => {
239. // The risk here is not a number above an empty list. It is a reader seeing
240. // "on my board 4" and "3 open" and having no way to know whether the 3 is
241. // inside the 4.
242. const out = ownListBlock(SAM, ok([item()]), NOW)
243. expect(out).toContain('on my board')
244. expect(flat(out)).toContain('is not a source')
245. })
247. it('says the right thing when "on my board" is a dash rather than a count', () => {
248. // Theo and Ines hold no Plinth assignment, so their load is null and the
249. // tile reads "–". A sentence claiming this list is excluded from a number
250. // that is not there would be nonsense.
251. const out = ownListBlock(SAM, ok([item()]), NOW, null, true)
252. expect(flat(out)).toContain('no source covers your work individually')
253. expect(flat(out)).toContain('adding to it does not change that')
254. })
256. it('completed lines are folded, counted, and said to be in neither number', () => {
257. const out = ownListBlock(SAM, ok([item()], [item({ doneAt: '2026-09-22T12:00:00.000Z' })]), NOW)
258. expect(out).toContain('Done (1)')
259. expect(flat(out)).toContain('folded below and in neither')
260. })
262. it('states how many completed lines are kept but not listed', () => {
263. // Where a surface deliberately withholds a row it says how many and why:
264. // the todosWithheld idiom, which rule 9 is written from.
265. const store: OwnStore = {
266. ...ok([], [item({ doneAt: '2026-09-22T12:00:00.000Z' })]),
267. doneHidden: 12,
268. }
269. const out = ownListBlock(SAM, store, NOW)
270. expect(flat(out)).toContain('12 older completed')
271. expect(flat(out)).toContain('Nothing was deleted')
272. })
274. it('a truncated read says so rather than passing a short list off as whole', () => {
275. const store: OwnStore = { ...ok([item()]), truncated: true }
276. expect(ownListBlock(SAM, store, NOW)).toContain('should not be possible')
277. })
278. })
280. describe('outcomes', () => {
281. it('narrows against an allow-list, so only our own words reach the page', () => {
282. expect(parseOwnOutcome('added')).toBe('added')
283. expect(parseOwnOutcome('<img src=x onerror=1>')).toBeNull()
284. expect(parseOwnOutcome('')).toBeNull()
285. expect(parseOwnOutcome(null)).toBeNull()
286. expect(parseOwnOutcome('nope')).toBeNull()
287. })
289. it('says loudly when a write did not land', () => {
290. // A banner that is merely absent reads as success, on the one action whose
291. // failure costs somebody the thing they just typed.
292. const out = ownListBlock(SAM, ok(), NOW, 'failed')
293. expect(flat(out)).toContain('<b>not</b> saved')
294. expect(flat(out)).toContain('Copy what you typed')
295. })
297. it('says completing does not throw anything away', () => {
298. expect(ownListBlock(SAM, ok(), NOW, 'completed')).toContain('never throws it away')
299. })
301. it('says a refused add was not trimmed to fit', () => {
302. expect(ownListBlock(SAM, ok(), NOW, 'full')).toContain('nothing was trimmed')
303. expect(ownListBlock(SAM, ok(), NOW, 'toolong')).toContain('rather than saving part of it')
304. })
305. })
307. describe('user text cannot become markup', () => {
308. const nasty = '</textarea><script>alert(1)</script>"><b>x'
310. it('not in a row', () => {
311. const out = ownListBlock(SAM, ok([item({ text: nasty })]), NOW)
312. expect(out).not.toContain('<script>')
313. expect(out).toContain('<script>')
314. })
316. it('not in the edit box', () => {
317. const out = ownListBlock(SAM, ok([item({ text: nasty })]), NOW)
318. expect(out).not.toContain('</textarea><script>')
319. })
321. it('not in the store’s error message', () => {
322. const out = ownListBlock(SAM, { state: 'failed', error: '<script>alert(1)</script>' }, NOW)
323. expect(out).not.toContain('<script>alert(1)</script>')
324. })
326. it('and a malformed link renders as nothing rather than as a chip of garbage', () => {
327. const out = ownListBlock(SAM, ok([item({ linkKey: 'javascript:alert(1)' })]), NOW)
328. expect(out).not.toContain('javascript:')
329. expect(out).not.toContain('own-link')
330. })
332. it('a well-formed link renders as a label, not a link', () => {
333. const out = ownListBlock(SAM, ok([item({ linkKey: 'order:MD2639582' })]), NOW)
334. expect(out).toContain('Order MD2639582')
335. expect(out).not.toContain('<a ')
336. })
337. })
339. describe('the placeholder and the stamp', () => {
340. it('the placeholder is not empty, and says nothing private is in the file', () => {
341. // Rule 8. An empty div here is a feature that silently is not there, and
342. // whoever is looking at a dumped variant needs to know at a glance that no
343. // private text is in it.
344. const p = ownListPlaceholder()
345. expect(p.startsWith(OWN_START)).toBe(true)
346. expect(p.endsWith(OWN_END)).toBe(true)
347. expect(flat(p)).toContain('lives on the live board')
348. expect(flat(p)).toContain('Nothing of yours is in this file')
349. })
351. it('stamping swaps the placeholder for the block', () => {
352. const page = `<main>before${ownListPlaceholder()}after</main>`
353. const out = stampOwnList(page, ownListBlock(SAM, ok([item({ text: 'SENTINEL' })]), NOW))
354. expect(out).toContain('SENTINEL')
355. expect(out).not.toContain(OWN_START)
356. expect(out).toContain('before')
357. expect(out).toContain('after')
358. })
360. it('a page with no markers comes back byte-identical', () => {
361. const page = '<main>nothing to stamp</main>'
362. expect(stampOwnList(page, 'anything')).toBe(page)
363. })
365. it('a viewer with no list stamps an empty string over the markers', () => {
366. const page = `<main>${ownListPlaceholder()}</main>`
367. expect(stampOwnList(page, ownListBlock(COMPANY_VIEWER, ok(), NOW))).toBe(
368. '<main></main>',
369. )
370. })
371. })