snapshot-file.test.ts

apps/dashboard/test/snapshot-file.test.ts

1. /**
2. * `pnpm morning` renders, writes the briefings from that render's numbers, then
3. * renders again so the prose lands on the board. If the second render re-synced,
4. * `syncedAt` would move, the briefings would no longer match the numbers beside
5. * them, and every clean run would declare its own output stale.
6. *
7. * The staleness check is correct; the second render must reuse the same sync.
8. * These tests guard that, and guard against "fixing" it by loosening the check
9. * instead, which would remove the only thing telling a reader whether the two
10. * halves of the page agree.
11. */
13. import { mkdtemp, writeFile, rm } from 'node:fs/promises'
14. import { tmpdir } from 'node:os'
15. import { join } from 'node:path'
16. import { pathToFileURL } from 'node:url'
17. import { afterAll, beforeAll, describe, expect, it } from 'vitest'
18. import { FIXTURE_SNAPSHOT } from '../src/fixtures.js'
19. import { headline, type Snapshot } from '../src/collect.js'
20. import { render } from '../src/render.js'
21. import { readSnapshot, writeSnapshot } from '../src/snapshot-file.js'
22. import type { Briefings } from '../src/briefings.js'
24. let dir: string
25. const at = (name: string) => pathToFileURL(join(dir, name))
27. beforeAll(async () => {
28. dir = await mkdtemp(join(tmpdir(), 'meridian-snap-'))
29. })
30. afterAll(async () => {
31. await rm(dir, { recursive: true, force: true })
32. })
34. describe('the cached sync survives a round trip', () => {
35. it('reads back what it wrote', async () => {
36. const file = at('roundtrip.json')
37. await writeSnapshot(FIXTURE_SNAPSHOT, file)
38. const got = await readSnapshot(file)
39. expect(got.ok).toBe(true)
40. if (got.ok) expect(got.snap).toEqual(FIXTURE_SNAPSHOT)
41. })
43. it('preserves syncedAt exactly, which is the whole point', async () => {
44. // If this drifts by even a millisecond the staleness check fires and the
45. // page calls its own briefing stale, the bug this file is named for.
46. const file = at('synced.json')
47. await writeSnapshot(FIXTURE_SNAPSHOT, file)
48. const got = await readSnapshot(file)
49. expect(got.ok && got.snap.syncedAt).toBe(FIXTURE_SNAPSHOT.syncedAt)
50. })
52. it('keeps a failed source failed rather than turning it into an empty one', async () => {
53. // The prime invariant, applied to the cache: a source that was down when the
54. // sync ran must still read as down after a round trip, not as zero results.
55. const broken: Snapshot = {
56. ...FIXTURE_SNAPSHOT,
57. leads: { ok: false, data: [], error: 'Bitrix returned 503' },
58. }
59. const file = at('broken.json')
60. await writeSnapshot(broken, file)
61. const got = await readSnapshot(file)
62. expect(got.ok).toBe(true)
63. if (got.ok) {
64. expect(got.snap.leads.ok).toBe(false)
65. expect(got.snap.leads.error).toBe('Bitrix returned 503')
66. }
67. })
69. it('keeps a null apart from a zero', async () => {
70. const file = at('nulls.json')
71. await writeSnapshot({ ...FIXTURE_SNAPSHOT, ninetySpread: null }, file)
72. const got = await readSnapshot(file)
73. expect(got.ok && got.snap.ninetySpread).toBeNull()
74. })
76. it('carries fixture provenance across, so a cached demo cannot read as live', async () => {
77. const file = at('mode.json')
78. await writeSnapshot(FIXTURE_SNAPSHOT, file)
79. const got = await readSnapshot(file)
80. expect(got.ok && got.snap.mode).toBe('fixtures')
81. })
82. })
84. describe('an unusable cache is refused, not rendered around', () => {
85. it('says a missing file is missing', async () => {
86. const got = await readSnapshot(at('nope.json'))
87. expect(got).toMatchObject({ ok: false, missing: true })
88. })
90. it('distinguishes a bad file from an absent one', async () => {
91. // Different problems, different fixes: one means run a sync, the other means
92. // something wrote a bad file.
93. const file = at('truncated.json')
94. await writeFile(file, '{"syncedAt":"2026-', 'utf8')
95. const got = await readSnapshot(file)
96. expect(got).toMatchObject({ ok: false, missing: false })
97. })
99. it('refuses a snapshot with a source missing', async () => {
100. const file = at('partial.json')
101. const { leads, ...rest } = FIXTURE_SNAPSHOT
102. void leads
103. await writeFile(file, JSON.stringify(rest), 'utf8')
104. const got = await readSnapshot(file)
105. expect(got.ok).toBe(false)
106. if (!got.ok) expect(got.reason).toMatch(/leads/)
107. })
109. it('refuses a snapshot with no syncedAt, because nothing on it can be dated', async () => {
110. const file = at('undated.json')
111. const { syncedAt, ...rest } = FIXTURE_SNAPSHOT
112. void syncedAt
113. await writeFile(file, JSON.stringify(rest), 'utf8')
114. expect((await readSnapshot(file)).ok).toBe(false)
115. })
117. it('refuses a cache written before assignment coverage existed', async () => {
118. // Same precedent as orderWindow above. A cache without assignment coverage
119. // cannot say whether its per-person numbers were complete or blind, and
120. // --render-only would put them on the page as though it could.
121. const file = at('no-coverage.json')
122. const { assignmentFields, ...window } = FIXTURE_SNAPSHOT.orderWindow
123. void assignmentFields
124. await writeFile(
125. file,
126. JSON.stringify({ ...FIXTURE_SNAPSHOT, orderWindow: window }),
127. 'utf8',
128. )
129. const got = await readSnapshot(file)
130. expect(got.ok).toBe(false)
131. if (!got.ok) expect(got.reason).toMatch(/coverage|blind/)
132. })
134. it('refuses a cache written before per-key Fathom status existed', async () => {
135. // Same precedent again, for the Fathom key list: neither default is safe. `[]` would render as "live,
136. // from no keys", and leaving it undefined throws deep inside the view-model
137. // instead of here, where the reason is actually known.
138. const file = at('no-fathom-sources.json')
139. const { fathomSources, ...rest } = FIXTURE_SNAPSHOT
140. void fathomSources
141. await writeFile(file, JSON.stringify(rest), 'utf8')
142. const got = await readSnapshot(file)
143. expect(got.ok).toBe(false)
144. if (!got.ok) expect(got.reason).toMatch(/key|dark/i)
145. })
147. it('accepts a cache with no Fathom keys configured at all', async () => {
148. // `fathomConfigured: false` is a legitimate state, not an old cache; the
149. // guard above must not turn "nobody was asked" into an unreadable file.
150. const file = at('fathom-unconfigured.json')
151. const { fathomSources, ...rest } = FIXTURE_SNAPSHOT
152. void fathomSources
153. await writeFile(
154. file,
155. JSON.stringify({ ...rest, fathomConfigured: false, meetings: { ok: true, data: [], error: null } }),
156. 'utf8',
157. )
158. expect((await readSnapshot(file)).ok).toBe(true)
159. })
161. it('refuses an unrecognised mode rather than assuming live', async () => {
162. const file = at('mode-bad.json')
163. await writeFile(file, JSON.stringify({ ...FIXTURE_SNAPSHOT, mode: 'probably-live' }), 'utf8')
164. expect((await readSnapshot(file)).ok).toBe(false)
165. })
167. it('names a reason in every refusal', async () => {
168. const file = at('empty.json')
169. await writeFile(file, 'null', 'utf8')
170. const got = await readSnapshot(file)
171. expect(got.ok).toBe(false)
172. if (!got.ok) expect(got.reason.length).toBeGreaterThan(0)
173. })
174. })
176. describe('re-rendering the same sync clears the staleness warning honestly', () => {
177. const snap = FIXTURE_SNAPSHOT
178. const brief = (payloadGeneratedAt: string | null): Briefings => ({
179. generatedAt: '2026-08-25T18:40:14+00:00',
180. day: '2026-08-12',
181. model: 'claude-opus-5',
182. payloadGeneratedAt,
183. mode: 'fixtures',
184. // Both company variants: the default viewer is the company one, which reads
185. // `company-allhands`. These tests are about staleness, not about who sees what.
186. briefings: { company: 'The company brief.', 'company-allhands': 'The all-hands brief.' },
187. })
188. const page = (b: Briefings) => render(snap, headline(snap), [], '2026-08-12', b)
190. /**
191. * Either mode of the pairing caveat: same-day prose gets a note about scope and
192. * earlier-day prose gets the re-run ask. The two negative assertions below
193. * match either marker, because a negative assertion against a phrase no
194. * longer emitted goes on passing while checking nothing.
195. */
196. const PAIRING_CAVEAT = /refresh every 15 minutes|pnpm morning/
198. it('is silent when the prose and the numbers come from one sync', async () => {
199. // `buildBriefingPayload` sets generatedAt to snap.syncedAt, so a brief
200. // written from the cached sync matches it after a re-render.
201. expect(page(brief(snap.syncedAt))).not.toMatch(PAIRING_CAVEAT)
202. })
204. it('still warns when they do not: the check is intact', () => {
205. // The fix must not have worked by weakening this. If the sequence regresses,
206. // or someone loosens briefingAge(), one of these two tests fails. An earlier
207. // DAY is the mode that asks for something, because that one means the
208. // morning brief never ran.
209. expect(page(brief('2026-08-01T00:00:00.000Z'))).toMatch(/pnpm morning/)
210. })
212. it('says nothing either way when the briefing records no sync', () => {
213. // Null is "no claim", not "matches". Asserting a match here would be the
214. // check quietly passing on missing evidence.
215. expect(page(brief(null))).not.toMatch(PAIRING_CAVEAT)
216. })
218. it('a re-render from cache produces the same page as the sync that wrote it', async () => {
219. const file = at('rerender.json')
220. await writeSnapshot(snap, file)
221. const got = await readSnapshot(file)
222. expect(got.ok).toBe(true)
223. if (!got.ok) return
224. const first = render(snap, headline(snap), [], '2026-08-12', brief(snap.syncedAt))
225. const second = render(got.snap, headline(got.snap), [], '2026-08-12', brief(got.snap.syncedAt))
226. expect(second).toBe(first)
227. })
228. })