my-day.test.ts

apps/dashboard/test/my-day.test.ts

1. /**
2. * My Day, and the number above the list.
3. *
4. * The header counts Ninety to-dos into the load, so the list must include them
5. * too; a card built from order lines and Bitrix tasks alone prints a number and
6. * then says "Nothing on this board right now." Several people hold no order
7. * lines at all, so for them it would always be a number above an empty list
8. * (rule 9).
9. *
10. * These tests assert the reconciliation rather than any wording: whatever the
11. * header counts, the card must be able to account for, either by listing it or
12. * by saying out loud that it did not.
13. */
15. import { describe, expect, it } from 'vitest'
16. import { FIXTURE_SNAPSHOT } from '../src/fixtures.js'
17. import { headline, type Snapshot } from '../src/collect.js'
18. import { buildViewModel, todoItem } from '../src/view-model.js'
19. import { render } from '../src/render.js'
20. import { COMPANY_VIEWER, viewerFor } from '../src/viewer.js'
21. import { esc } from '../src/html.js'
22. import { OWN_END, OWN_START } from '../src/own-list-view.js'
23. import { MERIDIAN_PEOPLE } from '../../../config/meridian-people.js'
24. import type { Todo } from '@meridian/ninety-client'
26. const DAY = '2026-08-12'
28. const emailOf = (name: string): string => {
29. const p = MERIDIAN_PEOPLE.find((x) => x.name === name)
30. if (!p?.email) throw new Error(`no email for ${name}`)
31. return p.email
32. }
34. const vmFor = (name: string, snap: Snapshot = FIXTURE_SNAPSHOT) =>
35. buildViewModel(snap, headline(snap), [], DAY, viewerFor(emailOf(name)))
37. const cardFor = (name: string, snap: Snapshot = FIXTURE_SNAPSHOT) => {
38. const card = vmFor(name, snap).myDays.find((d) => d.person.name === name)
39. if (!card) throw new Error(`no My Day card for ${name}`)
40. return card
41. }
43. /** A to-do shaped like a live one, so the roster join is exercised for real. */
44. const todoOf = (over: Partial<Todo>): Todo => ({
45. id: 't-x',
46. title: 'A to-do',
47. description: '',
48. descriptionHtml: '',
49. dueDate: null,
50. dueDateLocal: null,
51. dueLabel: '',
52. completed: false,
53. completedDate: null,
54. archived: false,
55. deleted: false,
56. owner: { id: 'u-x', name: 'Someone' },
57. createdBy: { id: 'u-x', name: 'Someone' },
58. teamId: null,
59. teamName: null,
60. isPersonal: false,
61. repeat: null,
62. seriesId: null,
63. milestoneId: null,
64. followers: [],
65. createdAt: null,
66. raw: { _id: 't-x' } as Todo['raw'],
67. ...over,
68. })
70. const withTodos = (todos: Todo[]): Snapshot => ({
71. ...FIXTURE_SNAPSHOT,
72. ninety: { ok: true, data: todos, error: null },
73. })
75. describe('the header number and the list agree', () => {
76. it('accounts for every to-do it counts, on every card', () => {
77. // The bug, stated as arithmetic. `load` counts orders + tasks + to-dos; the
78. // card must either list a to-do or declare it withheld.
79. for (const p of MERIDIAN_PEOPLE) {
80. const d = cardFor(p.name)
81. expect(d.todos + d.todosWithheld).toBe(d.person.todos ?? 0)
82. }
83. })
85. it('gives Ines, Theo and Nora a list instead of a number over nothing', () => {
86. // These three hold no Plinth assignment, so without to-dos their card could
87. // never show a row, whatever they were carrying.
88. for (const name of ['Ines Carvalho', 'Theo Bassett', 'Nora Lindqvist']) {
89. const d = cardFor(name)
90. expect(d.person.plinthOurMove).toBeNull()
91. expect(d.todos).toBeGreaterThan(0)
92. expect(d.items.length).toBeGreaterThanOrEqual(d.todos)
93. }
94. })
96. it('puts the to-do titles in the bytes of the page that person is served', () => {
97. // The view model agreeing is not the same as the page showing it.
98. const out = render(
99. FIXTURE_SNAPSHOT,
100. headline(FIXTURE_SNAPSHOT),
101. [],
102. DAY,
103. null,
104. viewerFor(emailOf('Nora Lindqvist')),
105. )
106. for (const t of cardFor('Nora Lindqvist').items) expect(out).toContain(esc(t.what))
107. })
108. })
110. describe('to-dos are attributed through the roster, not by spelling', () => {
111. it('matches on the pinned Ninety id when the display name has drifted', () => {
112. // Ninety says "Samuel Whitaker" where the roster says "Sam Whitaker". An
113. // equality join on the name would drop them to zero, silently.
114. const sam = MERIDIAN_PEOPLE.find((p) => p.name === 'Sam Whitaker')!
115. const snap = withTodos([
116. todoOf({
117. id: 'drifted',
118. title: 'Owned by a drifted spelling',
119. owner: { id: sam.ninetyId!, name: 'Samuel Whitaker' },
120. }),
121. ])
122. expect(cardFor('Sam Whitaker', snap).items.map((i) => i.what)).toContain(
123. 'Owned by a drifted spelling',
124. )
125. })
127. it('leaves an unmapped owner off every card rather than guessing one', () => {
128. const snap = withTodos([
129. todoOf({ id: 'orphan', title: 'Nobody owns this', owner: { id: 'u-ghost', name: 'A Ghost' } }),
130. ])
131. for (const p of MERIDIAN_PEOPLE) {
132. expect(cardFor(p.name, snap).items.map((i) => i.what)).not.toContain('Nobody owns this')
133. }
134. })
135. })
137. describe("another person's card carries no to-do titles", () => {
138. it('withholds them and says how many, rather than dropping them', () => {
139. // My Day renders only the viewer's own card today. This is the guard for the
140. // day someone adds a surface that renders another person's. The previous
141. // design of this page shipped every person's card in one document.
142. const vm = vmFor('Nora Lindqvist')
143. const other = vm.myDays.find((d) => d.person.name === 'Marco Ibáñez')!
144. expect(other.todos).toBe(0)
145. expect(other.todosWithheld).toBe(other.person.todos ?? 0)
146. expect(other.todosWithheld).toBeGreaterThan(0)
147. })
149. it('discloses nothing to a caller that forgets the viewer argument', () => {
150. const vm = buildViewModel(FIXTURE_SNAPSHOT, headline(FIXTURE_SNAPSHOT), [], DAY)
151. for (const d of vm.myDays) expect(d.todos).toBe(0)
152. })
154. it('does not put another person’s to-do title in the page bytes', () => {
155. const noraTitles = cardFor('Nora Lindqvist').items.map((i) => i.what)
156. const out = render(
157. FIXTURE_SNAPSHOT,
158. headline(FIXTURE_SNAPSHOT),
159. [],
160. DAY,
161. null,
162. viewerFor(emailOf('Marco Ibáñez')),
163. )
164. const marcoTitles = new Set(cardFor('Marco Ibáñez').items.map((i) => i.what))
165. for (const title of noraTitles) {
166. if (marcoTitles.has(title)) continue // genuinely shared work, both own it
167. expect(out).not.toContain(esc(title))
168. }
169. })
170. })
172. describe('a dead source is not a clear desk', () => {
173. it('names the failed source instead of reporting an empty board', () => {
174. // A 403 from /todos/company is a role problem, and Nora's whole load comes
175. // through it. Rendering that as "nothing to do" is the prime invariant
176. // inverted.
177. // Both of Nora's sources are cut, not just Ninety: she holds a tracker row
178. // too, so a Ninety-only outage would not empty her card. The property under test is that an
179. // empty list caused by a dead source never reads as a clear desk.
180. const down: Snapshot = {
181. ...FIXTURE_SNAPSHOT,
182. ninety: { ok: false, data: [], error: 'HTTP 403' },
183. sheet: { ok: false, data: [], error: 'HTTP 403' },
184. }
185. const d = cardFor('Nora Lindqvist', down)
186. expect(d.items).toHaveLength(0)
187. expect(d.sourcesDown).toContain('Ninety to-dos')
189. const out = render(down, headline(down), [], DAY, null, viewerFor(emailOf('Nora Lindqvist')))
190. expect(out).not.toContain('Nothing on this board right now.')
191. })
193. it('reports a clear desk as a clear desk when every source is up', () => {
194. const quiet: Snapshot = {
195. ...FIXTURE_SNAPSHOT,
196. ninety: { ok: true, data: [], error: null },
197. tasks: { ok: true, data: [], error: null },
198. orderLines: { ok: true, data: [], error: null },
199. sheet: { ok: true, data: [], error: null },
200. }
201. expect(cardFor('Nora Lindqvist', quiet).sourcesDown).toHaveLength(0)
202. })
203. })
205. describe('late means past a review gate, not overdue by the calendar', () => {
206. it('does not call a to-do late before its first Monday', () => {
207. // Nothing at Meridian closes outside a Monday review, so raw overdue counts
208. // inflate every weekend and reset every Monday, which trains people to
209. // ignore the number. Due Saturday 2026-08-08, read Sunday the 9th: overdue
210. // by the calendar, but no review has passed, so it is not late.
211. const t = todoOf({ dueDate: '2026-08-09T04:59:59.999Z', dueDateLocal: '2026-08-08' })
212. const sunday = todoItem(t, new Date('2026-08-09T18:00:00Z'))
213. expect(sunday.late).toBe(false)
214. expect(sunday.age).toBe('1d over')
216. // Same to-do, read after the Monday review it survived.
217. const tuesday = todoItem(t, new Date('2026-08-11T18:00:00Z'))
218. expect(tuesday.late).toBe(true)
219. expect(tuesday.meta).toContain('past 1 review gate')
220. })
222. it('says "no due date" rather than inventing one', () => {
223. const undated = todoItem(todoOf({}), new Date('2026-08-11T18:00:00Z'))
224. expect(undated.age).toBe('–')
225. expect(undated.late).toBe(false)
226. expect(undated.meta).toContain('no due date')
227. })
229. it('counts late to-dos in the review-gate total under the list', () => {
230. // lateCount drove a footer sentence built from Bitrix tasks only, so a card
231. // could print "nothing is past a review gate" above an overdue to-do.
232. const d = cardFor('Sam Whitaker')
233. const lateItems = d.items.filter((i) => i.late)
234. expect(d.lateCount).toBe(lateItems.length)
235. expect(lateItems.some((i) => i.meta.includes('Ninety to-do'))).toBe(true)
236. })
237. })
239. describe('recurrence is not collapsed away', () => {
240. it('lists both instances of a series, because the header counts both', () => {
241. // One of Ines's live to-dos appears twice, due a week apart. todoLoad()
242. // counts every instance; collapsing only the LIST would put the number and
243. // the list back out of agreement, which is the bug this file is about.
244. const nora = MERIDIAN_PEOPLE.find((p) => p.name === 'Nora Lindqvist')!
245. const snap = withTodos([
246. todoOf({
247. id: 'r1',
248. title: 'Weekly image review',
249. owner: { id: nora.ninetyId!, name: 'Nora Lindqvist' },
250. seriesId: 's-1',
251. repeat: 'Weekly',
252. dueDate: '2026-08-08T04:59:59.999Z',
253. dueDateLocal: '2026-08-07',
254. }),
255. todoOf({
256. id: 'r2',
257. title: 'Weekly image review',
258. owner: { id: nora.ninetyId!, name: 'Nora Lindqvist' },
259. seriesId: 's-1',
260. repeat: 'Weekly',
261. dueDate: '2026-08-15T04:59:59.999Z',
262. dueDateLocal: '2026-08-14',
263. }),
264. ])
265. const d = cardFor('Nora Lindqvist', snap)
266. expect(d.items.filter((i) => i.what === 'Weekly image review')).toHaveLength(2)
267. expect(d.todos).toBe(d.person.todos)
268. // And the repeat is stated, so a title appearing twice explains itself.
269. // Scoped to the to-do rows: the card also carries tracker and order rows,
270. // and asserting over all of them tested the fixture rather than the rule.
271. for (const i of d.items.filter((x) => x.meta.startsWith('Ninety to-do'))) {
272. expect(i.meta).toContain('Weekly')
273. }
274. })
275. })
277. describe('an order and a to-do are not the same measurement', () => {
278. it('labels a to-do row by its due date, never as a bare age', () => {
279. // The age column shows "34d" for an order line, meaning days waiting. A
280. // to-do showing a bare "9d" in the same column invites a comparison between
281. // two different things.
282. const d = cardFor('Sam Whitaker')
283. for (const i of d.items.filter((x) => x.meta.includes('Ninety to-do'))) {
284. expect(i.age).toMatch(/over$|^due in |^–$/)
285. }
286. })
287. })
289. describe('COMPANY_VIEWER has no card of its own', () => {
290. it('builds no My Day for an address the roster does not know', () => {
291. const vm = buildViewModel(FIXTURE_SNAPSHOT, headline(FIXTURE_SNAPSHOT), [], DAY, COMPANY_VIEWER)
292. expect(COMPANY_VIEWER.ownBriefing).toBeNull()
293. for (const d of vm.myDays) expect(d.todos).toBe(0)
294. })
295. })
297. describe('the private list sits in this card, and only in its owner’s copy', () => {
298. const pageFor = (email: string | null): string => {
299. const viewer = email ? viewerFor(email) : COMPANY_VIEWER
300. return render(FIXTURE_SNAPSHOT, headline(FIXTURE_SNAPSHOT), [], DAY, null, viewer)
301. }
303. it('every roster viewer’s page carries the markers exactly once', () => {
304. for (const p of MERIDIAN_PEOPLE) {
305. if (!p.email) continue
306. const html = pageFor(p.email)
307. expect(html.split(OWN_START)).toHaveLength(2)
308. expect(html.split(OWN_END)).toHaveLength(2)
309. }
310. })
312. it('an address the roster does not know carries them zero times', () => {
313. // Not a hidden div and not an empty one: nothing at all. A private list on
314. // a shared mailbox is a list everyone who signs into it can read.
315. const html = pageFor(null)
316. expect(html).not.toContain(OWN_START)
317. expect(html).not.toContain(OWN_END)
318. })
320. it('the markers sit inside the VIEWER’S OWN card and no other', () => {
321. // The guard that looks redundant. myDaySurface renders only the viewer's
322. // own card, so today this cannot go wrong, and there is one marker pair
323. // per page, into which the Worker stamps the viewer's lines. If anything
324. // ever renders a second person's card, a placeholder sitting in it would
325. // put the viewer's private list under somebody else's name. Asserted
326. // against the rendered page rather than the private function, so it holds
327. // however the card gets built.
328. for (const p of MERIDIAN_PEOPLE) {
329. if (!p.email) continue
330. const html = pageFor(p.email)
331. const at = html.indexOf(OWN_START)
332. expect(at).toBeGreaterThan(-1)
333. const panelsBefore = [...html.slice(0, at).matchAll(/data-person-panel="([^"]*)"/g)]
334. // The last card opened before the markers is the one they are inside.
335. expect(panelsBefore.at(-1)?.[1]).toBe(esc(p.name))
336. }
337. })
339. it('no private text is in the pre-rendered page, only the placeholder is', () => {
340. // The pages this board serves are written to KV by a cron with no viewer
341. // session, so whatever ever leaks out of KV cannot be somebody's list.
342. const html = pageFor('hello@meridiandisplay.example')
343. const between = html.slice(html.indexOf(OWN_START), html.indexOf(OWN_END))
344. expect(between).toContain('live')
345. expect(between).not.toContain('<form')
346. })
348. it('“on my board” is unchanged by the existence of a private list', () => {
349. // The decision this pins: a private count folded into `load` would leak
350. // into the workload panel and the company narration, which both read
351. // `load`, and it would render a person no source covers as a number
352. // instead of a dash, the prime invariant broken on the tile it was written
353. // for. `load` must keep coming from the sources and nowhere else.
354. const viewer = viewerFor('frontdesk@meridiandisplay.example')
355. const vm = buildViewModel(FIXTURE_SNAPSHOT, headline(FIXTURE_SNAPSHOT), [], DAY, viewer)
356. for (const d of vm.myDays) {
357. expect(d.person.load).toBe(vm.people.find((p) => p.name === d.person.name)?.load)
358. }
359. })
360. })