onboarding.test.ts

apps/dashboard/test/onboarding.test.ts

1. /**
2. * The onboarding tab: who sees it, what the toggle does, and what the surface
3. * refuses to imply.
4. *
5. * What is worth testing here is not the content. The material is a
6. * hand-edited config file; asserting its sentences would pin training notes in
7. * place as a requirement. What is
8. * asserted is the machinery around it: the gate, the switch, and the roster
9. * check that stops a typo becoming a tab nobody can open.
10. */
12. import { describe, expect, it } from 'vitest'
13. import {
14. ONBOARDING,
15. hasOnboarding,
16. onboardingFor,
17. visiblePlans,
18. type OnboardingPlan,
19. } from '../../../config/onboarding.js'
20. import { MERIDIAN_PEOPLE } from '../../../config/meridian-people.js'
21. import { COMPANY_VIEWER, viewerFor } from '../src/viewer.js'
22. import { calendarDate, onboardingSurface } from '../src/surfaces.js'
23. import { render } from '../src/render.js'
24. import { FIXTURE_SNAPSHOT } from '../src/fixtures.js'
25. import { headline } from '../src/collect.js'
27. const PLAN = (over: Partial<OnboardingPlan> = {}): OnboardingPlan => ({
28. person: 'Rosa Galván',
29. role: 'Client Success',
30. startedOn: '2026-09-14',
31. active: true,
32. summary: 'x',
33. days: [],
34. resources: [],
35. sources: [],
36. ...over,
37. })
39. const rosa = viewerFor('accounts@meridiandisplay.example')
40. const sam = viewerFor('hello@meridiandisplay.example')
41. const marco = viewerFor('studio@meridiandisplay.example')
43. describe('who the plan is visible to', () => {
44. it('shows a person their own plan', () => {
45. expect(visiblePlans([PLAN()], rosa).map((p) => p.person)).toEqual(['Rosa Galván'])
46. })
48. it('shows it to a leadership reader, so somebody can check what she is being told', () => {
49. // The audience is the new person plus leadership.
50. expect(sam.seesLeadership).toBe(true)
51. expect(visiblePlans([PLAN()], sam)).toHaveLength(1)
52. })
54. it('shows it to NOBODY else, not even an empty tab', () => {
55. // Marco reads the whole inbox and is not new. A tab that opens on somebody
56. // else's training is a tab about nothing.
57. expect(marco.seesLeadership).toBe(false)
58. expect(visiblePlans([PLAN()], marco)).toEqual([])
59. expect(visiblePlans([PLAN()], COMPANY_VIEWER)).toEqual([])
60. })
62. it('puts a leadership reader’s OWN plan first when they have one', () => {
63. const plans = [PLAN(), PLAN({ person: 'Sam Whitaker' })]
64. expect(visiblePlans(plans, sam).map((p) => p.person)).toEqual(['Sam Whitaker', 'Rosa Galván'])
65. })
66. })
68. describe('the toggle', () => {
69. it('hides the plan from everyone, including its own subject, when off', () => {
70. // The toggle is the feature: on while a person is new to the team. Off
71. // means off for her too: a tab that only the
72. // boss can still see is a different feature.
73. const off = [PLAN({ active: false })]
74. expect(visiblePlans(off, rosa)).toEqual([])
75. expect(visiblePlans(off, sam)).toEqual([])
76. })
78. it('keeps the material in the file rather than deleting it', () => {
79. const off = PLAN({
80. active: false,
81. days: [{ day: 1, date: '2026-09-14', title: 'kept', sections: [{ title: 'kept' }] }],
82. })
83. expect(visiblePlans([off], rosa)).toEqual([])
84. expect(off.days).toHaveLength(1)
85. })
86. })
88. describe('the committed plans', () => {
89. it('names only people who are on the roster', () => {
90. // The module throws at load on a mismatch; this asserts the same thing
91. // against the committed data, so the failure is a readable test rather
92. // than an import error somewhere else.
93. const names = new Set(MERIDIAN_PEOPLE.map((p) => p.name))
94. for (const plan of ONBOARDING) expect(names, plan.person).toContain(plan.person)
95. })
97. it('gives Rosa a live plan and gives Marco none', () => {
98. expect(hasOnboarding(rosa)).toBe(true)
99. expect(hasOnboarding(marco)).toBe(false)
100. expect(onboardingFor(rosa)[0]?.person).toBe('Rosa Galván')
101. })
103. it('carries its sources, because the material is somebody’s and not the board’s', () => {
104. for (const plan of ONBOARDING) expect(plan.sources.length).toBeGreaterThan(0)
105. })
106. })
108. /**
109. * The recap's shape. Same convention as the rest of this file: the module
110. * throws at load on a violation, and these assert the same properties against
111. * the committed data so a breach reads as a named test rather than as an import
112. * error in whichever suite happened to load the config first.
113. */
114. describe('the recap on the committed plan', () => {
115. const plan = ONBOARDING[0]!
117. it('sits only on training days, never on standing material', () => {
118. // A recap is the write-up of a session that happened on a date. Standing
119. // material has no date, and would print under a heading with nothing to
120. // place it in time.
121. for (const d of plan.days) {
122. if (d.day === null) expect(d.recap, d.title).toBeUndefined()
123. }
124. })
126. it('never has a heading over nothing', () => {
127. for (const d of plan.days) {
128. if (!d.recap) continue
129. expect(d.recap.sessions.length, d.title).toBeGreaterThan(0)
130. expect(d.recap.label.trim(), d.title).not.toBe('')
131. for (const s of d.recap.sessions) expect(s.points.length, s.title ?? d.title).toBeGreaterThan(0)
132. }
133. })
135. it('titles all of a day’s sessions or none of them', () => {
136. // A nameless run of points sitting beside named ones cannot be read.
137. for (const d of plan.days) {
138. if (!d.recap) continue
139. const titled = d.recap.sessions.filter((x) => x.title !== undefined).length
140. expect([0, d.recap.sessions.length], d.title).toContain(titled)
141. }
142. })
144. it('says "not recorded" with null, never with an empty string', () => {
145. // '' prints as "Accomplished:" and then nothing, which reads as a verdict
146. // rather than an absence.
147. for (const d of plan.days) {
148. if (!d.recap) continue
149. if (d.recap.accomplished !== null) expect(d.recap.accomplished.trim(), d.title).not.toBe('')
150. }
151. })
153. it('has a document to head the bullets whenever any day carries them', () => {
154. if (plan.days.some((d) => d.recap)) {
155. expect(plan.recapDoc?.title.trim()).toBeTruthy()
156. expect(plan.recapDoc?.preparedBy.trim()).toBeTruthy()
157. }
158. })
159. })
161. describe('the surface', () => {
162. it('renders the plan with its attribution and the SOP precedence', () => {
163. const html = onboardingSurface(rosa)
164. expect(html).toContain('Client Success Field Guide')
165. // The guide's own rule, carried onto the page: it is not the source of truth.
166. expect(html).toContain('follow the SOP')
167. expect(html).toContain('config/onboarding.ts')
168. })
170. it('tells a leadership reader they are looking at somebody else’s', () => {
171. const html = onboardingSurface(sam)
172. expect(html).toContain('Rosa Galván')
173. expect(html).toContain("Leadership Team's to-dos")
174. })
176. it('prints the start date as the day it was typed, not the day before', () => {
177. // A 2026-09-14 start must not render as "Sep 13". `shortDate` asks what day
178. // an instant was in Chicago, and a bare date
179. // parses as UTC midnight, 7 PM the previous evening here. A date a person
180. // typed has no time of day to convert.
181. expect(calendarDate('2026-09-14')).toBe('Sep 14')
182. expect(calendarDate('2026-01-01')).toBe('Jan 1')
183. // Anything that is not a bare calendar date comes back untouched rather
184. // than being turned into a wrong-but-plausible one.
185. expect(calendarDate('not a date')).toBe('not a date')
186. expect(onboardingSurface(rosa)).toContain('Sep 14')
187. })
189. it('escapes the material rather than trusting it as markup', () => {
190. // It is a config file, so this is not a threat model; it is the same
191. // discipline every other surface applies to every other string.
192. expect(onboardingSurface(rosa)).not.toContain('<script>')
193. })
194. })
196. /**
197. * The day/topic split: collapsible by day and by topic, with one master
198. * resources list at the bottom.
199. *
200. * Asserted here: the machinery, not the material. Whether day 03 covers client
201. * tiers can change at any time; that both levels actually fold, that a
202. * folded heading's count matches what is under it, and that the master list is
203. * genuinely master are the things a later edit can silently break.
204. */
205. describe('days and topics', () => {
206. const plan = ONBOARDING[0]!
207. const html = onboardingSurface(rosa)
209. it('renders every group and every topic as a real disclosure, not a styled div', () => {
210. // <details> and not a script: the board also ships as one self-contained
211. // dashboard.html that gets opened from disk, where nothing else would fold.
212. const topics = plan.days.reduce((n, d) => n + d.sections.length, 0)
213. expect((html.match(/<details class="ob-day"/g) ?? []).length).toBe(plan.days.length)
214. expect((html.match(/<details class="ob-topic"/g) ?? []).length).toBe(topics)
215. })
217. it('starts with something open, so the tab is not a wall of shut rows', () => {
218. expect(plan.days.some((d) => d.open)).toBe(true)
219. expect(html).toContain('<details class="ob-day" open>')
220. })
222. it('numbers the training days and does NOT number the standing groups', () => {
223. // A rhythm she runs every morning filed under the date it was mentioned
224. // would read as something that stopped being true afterwards.
225. expect(plan.days.some((d) => d.day !== null)).toBe(true)
226. expect(plan.days.some((d) => d.day === null)).toBe(true)
227. expect(html).toContain('Day 03')
228. // Standing groups are labelled "Ongoing" and carry no date at all: a
229. // rhythm filed under the day it was mentioned reads as having stopped.
230. expect(html).toContain('>Ongoing</span>')
231. })
233. it('makes a folded heading account for what it is hiding', () => {
234. // RULE 9, at the smallest scale the board has. A count taken from anywhere
235. // but the items rendered underneath is the "13 things / nothing here" bug.
236. for (const day of plan.days) {
237. const n = day.sections.length
238. expect(html, day.title).toContain(`${n} ${n === 1 ? 'topic' : 'topics'}</span>`)
239. }
240. for (const sec of plan.days.flatMap((d) => d.sections)) {
241. const points = (sec.bullets?.length ?? 0) + (sec.rows?.length ?? 0)
242. // Every topic carries something; an empty one would say so instead.
243. expect(points, sec.title).toBeGreaterThan(0)
244. }
245. })
247. it('puts a master list at the bottom that is actually master', () => {
248. // A "master" list you have to go hunting outside of is not one. The config
249. // throws at load on a missing recording; this asserts the same on the page.
250. expect(html).toContain('ob-resources')
251. expect(plan.resources.length).toBeGreaterThan(0)
252. for (const rec of plan.days.flatMap((d) => d.recordings ?? [])) {
253. expect(html, rec.href).toContain(rec.href)
254. expect(plan.resources.flatMap((g) => g.links.map((l) => l.href))).toContain(rec.href)
255. }
256. // Bottom means bottom: after the last day on the page.
257. expect(html.indexOf('ob-resources')).toBeGreaterThan(html.lastIndexOf('<details class="ob-day"'))
258. })
260. it('links every training session it claims as a source', () => {
261. // A day can be more than one call (day 03 is two), so this counts the
262. // recordings rather than the days, and DERIVES the number rather than
263. // pinning it. A hardcoded count here failed the first time a fourth
264. // recording landed, which is a test that only measures its own staleness.
265. const recordings = plan.days.flatMap((d) => d.recordings ?? [])
266. const hrefs = plan.resources.flatMap((g) => g.links.map((l) => l.href))
267. expect(recordings.length).toBeGreaterThan(0)
268. expect(hrefs.filter((h) => h.includes('fathom.video'))).toHaveLength(recordings.length)
269. })
270. })
272. describe('the tab', () => {
273. const page = (email: string | null) =>
274. render(FIXTURE_SNAPSHOT, headline(FIXTURE_SNAPSHOT), [], '2026-08-12', null, viewerFor(email))
276. it('is second, right after Open work, per Sam’s instruction', () => {
277. const html = page('accounts@meridiandisplay.example')
278. const tabs = [...html.matchAll(/data-tab="([a-z-]+)"/g)].map((m) => m[1])
279. expect(tabs.slice(0, 2)).toEqual(['board', 'onboarding'])
280. })
282. it('is OMITTED for a viewer with no plan, not rendered and hidden', () => {
283. // Hidden markup is not privacy: this file learned that once already with
284. // the per-person briefings, which were all in one document behind `hidden`.
285. const html = page('studio@meridiandisplay.example')
286. expect(html).not.toContain('data-tab="onboarding"')
287. expect(html).not.toContain('surface-onboarding')
288. })
290. it('keeps the Inbox link after The queue for both, whatever the tab count', () => {
291. // The Inbox must not sit at a hard-coded index: Onboarding is conditional,
292. // so a fixed index would put the Inbox in a different place depending on
293. // who was looking.
294. for (const email of ['accounts@meridiandisplay.example', 'studio@meridiandisplay.example']) {
295. const html = page(email)
296. const bar = html.slice(html.indexOf('<div class="tabs"'), html.indexOf('</div>\n\n<main'))
297. const order = [...bar.matchAll(/data-tab="([a-z-]+)"|href="(\/inbox)"/g)].map(
298. (m) => m[1] ?? 'inbox',
299. )
300. expect(order.indexOf('inbox'), email).toBe(order.indexOf('queue') + 1)
301. }
302. })
303. })