inbox-send.test.ts

apps/dashboard/test/inbox-send.test.ts

1. /**
2. * The reply surfaces: who may send, what each state renders as, and what the
3. * pages must never contain.
4. *
5. * The bug this file guards against is the one that would be easiest to write:
6. * reusing INBOX_READERS as the send check. The whole roster may read every
7. * mailbox, and none of that is permission to write to a client as somebody
8. * else. If `sendableMailboxes` ever starts returning what
9. * `readableMailboxes` returns, the first test below fails.
10. */
12. import { describe, expect, it } from 'vitest'
13. import {
14. INBOX_CSS,
15. composeForm,
16. confirmPage,
17. fileSize,
18. newMessageForm,
19. newMessagePage,
20. offerable,
21. sendStates,
22. sentPage,
23. signaturesPage,
24. type InboxData,
25. type MailboxSendState,
26. type SendRecord,
27. type SignatureStore,
28. } from '../src/inbox-view.js'
29. import {
30. ATTACHMENT_LIMITS,
31. INBOX_MAILBOXES,
32. INBOX_SENDERS,
33. RECIPIENT_CAP,
34. canSendFrom,
35. readableMailboxes,
36. sendableMailboxes,
37. } from '../../../config/inbox.js'
38. import { viewerFor } from '../src/viewer.js'
39. import { THEME_CSS } from '../src/theme.js'
40. import type { MessageBody } from '@meridian/gmail-client'
42. const viewer = (email: string) => viewerFor(email)
44. const SIGS_OK: SignatureStore = {
45. ok: true,
46. map: { 'hello@meridiandisplay.example': { html: '<p>Sam</p>', by: 'Sam Whitaker', at: '2026-09-04T00:00:00.000Z' } },
47. }
48. const SIGS_DEAD: SignatureStore = { ok: false, error: 'inbox:signatures holds something that is not an object' }
50. /** One mailbox read per state we want to exercise. */
51. const DATA: InboxData = {
52. syncedAt: '2026-09-04T12:00:00.000Z',
53. mailboxes: [
54. { mailbox: 'hello@meridiandisplay.example', ok: true, error: null, messages: [], canSend: true },
55. { mailbox: 'orderdesk@meridiandisplay.example', ok: true, error: null, messages: [], canSend: false },
56. { mailbox: 'studio@meridiandisplay.example', ok: true, error: null, messages: [], canSend: null },
57. { mailbox: 'accounts@meridiandisplay.example', ok: false, error: 'invalid_grant', messages: [], canSend: null },
58. { mailbox: 'help@meridiandisplay.example', ok: true, error: null, messages: [], canSend: true },
59. { mailbox: 'service@meridiandisplay.example', ok: true, error: null, messages: [], canSend: true },
60. { mailbox: 'exec@meridiandisplay.example', ok: true, error: null, messages: [], canSend: true },
61. ],
62. }
64. const ORIG: MessageBody = {
65. id: 'm1',
66. mailbox: 'hello@meridiandisplay.example',
67. sender: 'client@example.com',
68. senderName: 'A Client',
69. subject: 'Banner proof',
70. date: '2026-09-04T10:00:00.000Z',
71. to: 'hello@meridiandisplay.example',
72. text: 'Where is my proof?',
73. kind: 'plain',
74. truncated: false,
75. html: null,
76. htmlTruncated: false,
77. unread: true,
78. attachments: [],
79. threadId: 't1',
80. messageId: '<abc@example.com>',
81. references: null,
82. replyTo: '',
83. cc: 'accounts@example.com',
84. }
86. describe('sending is a separate grant from reading', () => {
87. it('a viewer who may read everything and holds no send line may send nothing', () => {
88. // Ines reads all seven (INBOX_READERS) and has no INBOX_SENDERS line: she
89. // does not work client mail.
90. const ines = viewer('projects@meridiandisplay.example')
91. expect(readableMailboxes(ines)).toHaveLength(INBOX_MAILBOXES.length)
92. expect(sendableMailboxes(ines)).toEqual([])
93. for (const m of INBOX_MAILBOXES) expect(canSendFrom(ines, m.email)).toBe(false)
94. })
96. it('honours Sam’s seven lines exactly', () => {
97. // Four of the five full grants are role mailboxes, so these assertions
98. // outlive whoever holds those desks today: anyone who can sign in as one of
99. // them can write to a client as any of the seven. Narrowing that is a
100. // decision, not a cleanup.
101. for (const full of [
102. 'hello@meridiandisplay.example',
103. 'frontdesk@meridiandisplay.example',
104. 'accounts@meridiandisplay.example',
105. 'help@meridiandisplay.example',
106. 'service@meridiandisplay.example',
107. ]) {
108. expect(sendableMailboxes(viewer(full)), full).toHaveLength(INBOX_MAILBOXES.length)
109. }
110. expect(sendableMailboxes(viewer('studio@meridiandisplay.example'))).toEqual(['studio@meridiandisplay.example'])
111. expect(sendableMailboxes(viewer('orderdesk@meridiandisplay.example'))).toEqual(['orderdesk@meridiandisplay.example'])
112. expect(sendableMailboxes(viewer('nora.l@meridiandisplay.example'))).toEqual([])
113. })
115. it('a send grant is useless without a read grant, so every sender has both', () => {
116. // The inert-grant trap: a send grant without a read grant does nothing,
117. // because /inbox refuses the whole block before a Reply button is ever
118. // rendered, while looking present in config. Both lists get the line, or
119. // neither should. This fails if a future send grant is added to only one of them.
120. for (const sender of Object.keys(INBOX_SENDERS)) {
121. expect(readableMailboxes(viewer(sender)).length, sender).toBeGreaterThan(0)
122. }
123. })
125. it('cannot be widened by a typo: a grant is intersected with the real list', () => {
126. // Same guard readableMailboxes has: a misspelt mailbox in a grant is
127. // dropped rather than inventing one.
128. const marco = sendableMailboxes(viewer('studio@meridiandisplay.example'))
129. for (const m of marco) expect(INBOX_MAILBOXES.map((x) => x.email)).toContain(m)
130. })
132. it('an unidentified viewer sends nothing', () => {
133. expect(sendableMailboxes({ ...viewer('hello@meridiandisplay.example'), email: null })).toEqual([])
134. })
135. })
137. describe('sendStates', () => {
138. const all = INBOX_MAILBOXES.map((m) => m.email)
140. it('produces five distinct states from one fixture, and no two are the same', () => {
141. const st = sendStates(DATA, INBOX_MAILBOXES, all.filter((e) => e !== 'exec@meridiandisplay.example'), SIGS_OK)
142. const by = (e: string) => st.find((x) => x.email === e)!
143. expect(by('hello@meridiandisplay.example').state).toBe('sendable')
144. expect(by('orderdesk@meridiandisplay.example').state).toBe('readonly-token')
145. expect(by('studio@meridiandisplay.example').state).toBe('scope-unknown')
146. expect(by('accounts@meridiandisplay.example').state).toBe('failed')
147. expect(by('exec@meridiandisplay.example').state).toBe('not-granted')
148. expect(new Set(st.map((x) => x.state)).size).toBe(5)
149. })
151. it('keeps read-only, unknown and failed apart; they need opposite fixes', () => {
152. // read-only -> re-mint the token
153. // unknown -> nothing to do, try it
154. // failed -> the credential is broken
155. // Collapsing any pair sends someone to the wrong page of the runbook.
156. const st = sendStates(DATA, INBOX_MAILBOXES, all, SIGS_OK)
157. const ro = st.find((x) => x.state === 'readonly-token')!
158. const unk = st.find((x) => x.state === 'scope-unknown')!
159. const failed = st.find((x) => x.state === 'failed')!
160. expect(ro.error).toBeNull()
161. expect(unk.error).toBeNull()
162. expect(failed.error).toBe('invalid_grant')
163. expect(offerable(st).map((x) => x.state).sort()).toEqual(['scope-unknown', 'sendable', 'sendable', 'sendable', 'sendable'])
164. })
166. it('not-granted wins over everything, even a perfect token', () => {
167. const st = sendStates(DATA, INBOX_MAILBOXES, [], SIGS_OK)
168. expect(st.every((x) => x.state === 'not-granted')).toBe(true)
169. })
171. it('distinguishes "no signature set" from "the store could not be read"', () => {
172. // Both mean the reply goes out unsigned; only one of them means something
173. // is broken, and a reader must be able to tell which.
174. const set = sendStates(DATA, INBOX_MAILBOXES, all, SIGS_OK)
175. expect(set.find((x) => x.email === 'hello@meridiandisplay.example')!.signature).toBe('set')
176. expect(set.find((x) => x.email === 'exec@meridiandisplay.example')!.signature).toBe('none')
177. const dead = sendStates(DATA, INBOX_MAILBOXES, all, SIGS_DEAD)
178. expect(dead.every((x) => x.signature === 'store-failed')).toBe(true)
179. })
180. })
182. /**
183. * Per-mailbox send states for a viewer granted exactly `sendable`.
184. *
185. * Module-scoped because the new-message form takes the same states as the
186. * reply form, and a second copy of this helper is a second definition
187. * of what "may send" means in a test file about who may send.
188. */
189. const states = (sendable: string[], sigs = SIGS_OK): MailboxSendState[] =>
190. sendStates(DATA, INBOX_MAILBOXES, sendable, sigs)
192. describe('composeForm', () => {
194. it('disables exactly the mailboxes that cannot send, and no others', () => {
195. const html = composeForm(ORIG, states(INBOX_MAILBOXES.map((m) => m.email)), 'n1', SIGS_OK)
196. const radios = [...html.matchAll(/<input type="radio" name="from" value="([^"]+)"([\s\S]*?)>/g)]
197. const disabled = radios.filter((r) => r[2]!.includes('disabled')).map((r) => r[1])
198. expect(disabled.sort()).toEqual(['accounts@meridiandisplay.example', 'orderdesk@meridiandisplay.example'])
199. })
201. it('says how many mailboxes are readable but not sendable, and where the grants live', () => {
202. // Rule 9: where a surface withholds a row, it says how many and why. The
203. // earlier version of this mistake counted thirteen and then showed nothing.
204. const html = composeForm(ORIG, states(['hello@meridiandisplay.example']), 'n1', SIGS_OK)
205. expect(html).toContain('6 more mailboxes')
206. expect(html).toContain('INBOX_SENDERS')
207. })
209. it('has no To, Subject or Cc input; a REPLY\'s recipient is still decided server-side', () => {
210. // A file input is allowed; To, Subject and Cc are not. An attachment cannot
211. // change who gets the mail; a To field can, and the reply path's guarantee
212. // is that nothing in the form steers that. Reply-all widens the recipients
213. // through a boolean: the addresses still come off the original.
214. const html = composeForm(ORIG, states(['hello@meridiandisplay.example']), 'n1', SIGS_OK)
215. expect(html).not.toMatch(/name="to"/i)
216. expect(html).not.toMatch(/name="subject"/i)
217. expect(html).not.toMatch(/name="cc"/i)
218. expect(html).toMatch(/type="file"[^>]*name="files"|name="files"[^>]*type="file"/i)
219. expect(html).toContain('enctype="multipart/form-data"')
220. // The reply-all control is a checkbox called `all`, and nothing else.
221. expect(html).toMatch(/name="all" value="1"/)
222. // The original's Cc is SHOWN, as text, with what including it would take.
223. expect(html).toContain('accounts@example.com')
224. expect(html).toContain('Reply to everyone')
225. })
227. it('offers no reply-all control when the original names nobody else', () => {
228. // Rule 9 from the other side: a control that cannot do anything is not
229. // shown. With no To and no Cc on the original there is nobody to add, and
230. // a ticked box would then send exactly the same message as an unticked one.
231. const alone = composeForm({ ...ORIG, to: '', cc: '' }, states(['hello@meridiandisplay.example']), 'n1', SIGS_OK)
232. expect(alone).not.toMatch(/name="all"/)
233. })
235. it('gives the caveats their own emphasis class, not the muted metadata style', () => {
236. // The caveats a sender must know about a shared mailbox must not look like
237. // the muted To/Subject metadata they already know. Asserts the class is
238. // applied and defined, not its wording. A caveat that has gone stale is
239. // worse in red than in grey, so the assertion is that the box carries the
240. // limits, not that it carries a sentence.
241. const html = composeForm(ORIG, states(['hello@meridiandisplay.example']), 'n1', SIGS_OK)
242. const para = html.match(/<p class="[^"]*compose-caveats[^"]*">([\s\S]*?)<\/p>/)
243. expect(para).not.toBeNull()
244. expect(para?.[1]).toContain('Reply to everyone')
245. expect(para?.[1]).toMatch(/\d+ files at most/)
246. expect(para?.[1]).not.toContain('cannot be added')
248. // .compose-caveats overrides .compose-meta by ORDER, so a stylesheet that
249. // defines it first silently restores the muted 12px it exists to replace.
250. expect(INBOX_CSS.indexOf('.compose-caveats{')).toBeGreaterThan(INBOX_CSS.indexOf('.compose-meta{'))
251. expect(INBOX_CSS).toContain('var(--caveat)')
252. })
254. it('defines --caveat in BOTH palettes', () => {
255. // A token defined only on light renders as inherited text on dark, and the
256. // caveats would silently go back to looking like everything else there,
257. // which is the exact failure this change fixes.
258. const dark = THEME_CSS.slice(THEME_CSS.indexOf(':root[data-theme="dark"]'))
259. expect(THEME_CSS.slice(0, THEME_CSS.indexOf(':root[data-theme="dark"]'))).toContain('--caveat:')
260. expect(dark).toContain('--caveat:')
261. })
263. it('carries the nonce, the message and the mailbox, and nothing that steers mail', () => {
264. const html = composeForm(ORIG, states(['hello@meridiandisplay.example']), 'nonce-123', SIGS_OK)
265. expect(html).toContain('name="nonce" value="nonce-123"')
266. expect(html).toContain('name="id" value="m1"')
267. expect(html).toContain('name="mailbox" value="hello@meridiandisplay.example"')
268. })
270. it('renders the two signature absences differently', () => {
271. const none = composeForm(ORIG, states(['exec@meridiandisplay.example']), 'n', SIGS_OK)
272. const dead = composeForm(ORIG, states(['exec@meridiandisplay.example'], SIGS_DEAD), 'n', SIGS_DEAD)
273. expect(none).toContain('No signature is set')
274. expect(dead).toContain('could not be read')
275. expect(dead).toContain('failed read, not an empty signature')
276. expect(none).not.toContain('could not be read')
277. })
279. it('names the read-only fix rather than saying only that it is unavailable', () => {
280. const html = composeForm(ORIG, states(INBOX_MAILBOXES.map((m) => m.email)), 'n', SIGS_OK)
281. expect(html).toContain('pnpm inbox:auth')
282. expect(html).toContain('rechecks every 15 minutes')
283. })
284. })
286. describe('the signatures page never renders a signature', () => {
287. it('keeps user-supplied markup out of the board document entirely', () => {
288. // Same rule, and the same reason, as a sender's message HTML: it reaches
289. // only the sandboxed frame route and the outgoing MIME. Anything that puts
290. // it in this page reintroduces the bug the frame exists to prevent.
291. const nasty = '<img src=x onerror=alert(1)><script>steal()</script>'
292. const page = signaturesPage(
293. INBOX_MAILBOXES,
294. { ok: true, map: { 'hello@meridiandisplay.example': { html: nasty, by: 'Sam', at: '2026-09-04T00:00:00.000Z' } } },
295. ['hello@meridiandisplay.example'],
296. null,
297. )
298. expect(page).not.toContain('onerror')
299. expect(page).not.toContain('steal()')
300. // It reports the facts about it instead, and frames it.
301. expect(page).toContain('/inbox/signatures/frame?mailbox=hello%40meridiandisplay.example')
302. expect(page).toContain(String(nasty.length))
303. })
305. it('offers an edit form only for mailboxes this viewer may send as', () => {
306. const page = signaturesPage(INBOX_MAILBOXES, { ok: true, map: {} }, ['studio@meridiandisplay.example'], null)
307. const forms = [...page.matchAll(/name="mailbox" value="([^"]+)"/g)].map((m) => m[1])
308. expect(new Set(forms)).toEqual(new Set(['studio@meridiandisplay.example']))
309. // Exactly one editable signature box on a page listing seven mailboxes.
310. expect(page.match(/<textarea/g)).toHaveLength(1)
311. })
313. it('says a rejected signature was not written, rather than that it was truncated', () => {
314. const page = signaturesPage(INBOX_MAILBOXES, { ok: true, map: {} }, ['hello@meridiandisplay.example'], {
315. mailbox: 'hello@meridiandisplay.example',
316. over: 41_000,
317. })
318. expect(page).toContain('Not saved')
319. expect(page).toContain('Nothing was written')
320. })
322. it('reports a failed store as failed, not as "none set" for everyone', () => {
323. // The distinction the prime invariant is about: a store nobody could read
324. // must not render as seven mailboxes that happen to have no signature.
325. const page = signaturesPage(INBOX_MAILBOXES, SIGS_DEAD, ['hello@meridiandisplay.example'], null)
326. expect(page).toContain(SIGS_DEAD.ok ? '' : SIGS_DEAD.error)
327. expect(page).not.toContain('Not set.')
328. })
329. })
331. describe('the new-message form', () => {
332. const st = states
334. it('HAS the To, Cc and Subject fields the reply form must not have', () => {
335. // The reply form's guarantee is that no form field steers where mail goes.
336. // A compose box cannot keep it (there is no original to read a recipient
337. // off), so the fields exist here and the guarantee is replaced by
338. // parseRecipients, the cap and the confirmation step.
339. const html = newMessageForm(st(['hello@meridiandisplay.example']), 'n1', SIGS_OK)
340. expect(html).toMatch(/name="to"/)
341. expect(html).toMatch(/name="cc"/)
342. expect(html).toMatch(/name="subject"/)
343. expect(html).toContain('name="mode" value="new"')
344. expect(html).toContain('enctype="multipart/form-data"')
345. })
347. it('says in the red box that the sender is choosing the recipients', () => {
348. const para = newMessageForm(st(['hello@meridiandisplay.example']), 'n1', SIGS_OK).match(
349. /<p class="[^"]*compose-caveats[^"]*">([\s\S]*?)<\/p>/,
350. )
351. expect(para).not.toBeNull()
352. expect(para?.[1]).toContain('choosing the recipients')
353. expect(para?.[1]).toContain(String(RECIPIENT_CAP))
354. })
356. it('carries no message id, mailbox or threading field at all', () => {
357. // A new message that carried an id would be a reply wearing a compose
358. // box's clothes, and would thread into somebody's unrelated conversation.
359. const html = newMessageForm(st(['hello@meridiandisplay.example']), 'n1', SIGS_OK)
360. expect(html).not.toMatch(/name="mailbox"/)
361. expect(html).not.toMatch(/name="id"/)
362. expect(html).not.toMatch(/name="all"/)
363. })
365. it('offers only mailboxes the viewer may send from, with the rest counted', () => {
366. const html = newMessageForm(st(['studio@meridiandisplay.example']), 'n1', SIGS_OK)
367. expect(html).toContain('value="studio@meridiandisplay.example"')
368. expect(html).toContain('6 more mailboxes')
369. expect(html).toContain('INBOX_SENDERS')
370. })
372. it('states the attachment limits where the files are chosen', () => {
373. const html = newMessageForm(st(['hello@meridiandisplay.example']), 'n1', SIGS_OK)
374. expect(html).toContain(fileSize(ATTACHMENT_LIMITS.perFile))
375. expect(html).toContain(fileSize(ATTACHMENT_LIMITS.total))
376. expect(html).toContain(String(ATTACHMENT_LIMITS.count))
377. })
379. it('shows no form and says why when the viewer may send from nothing', () => {
380. // Rule 9 again: not a dead button, and not silence either.
381. const html = newMessagePage(st([]), 'n1', SIGS_OK)
382. expect(html).not.toContain('<form')
383. expect(html).toContain('not send from any mailbox')
384. expect(html).toContain('INBOX_SENDERS')
385. })
387. it('distinguishes "no grant" from "the grant cannot send right now"', () => {
388. // Same three credential states the reply control separates, because they
389. // need three different fixes.
390. // orderdesk@ is the fixture mailbox whose token reports no gmail.send.
391. const readonly = newMessagePage(states(['orderdesk@meridiandisplay.example']), 'n', SIGS_OK)
392. expect(readonly).toContain('read-only token')
393. expect(readonly).not.toContain('not send from any mailbox')
394. })
395. })
397. describe('the confirmation page', () => {
398. const OUT = {
399. from: 'hello@meridiandisplay.example',
400. to: 'client@example.com',
401. cc: null as string | null,
402. subject: 'Re: Banner proof',
403. text: 'Here it is.',
404. inReplyTo: '<abc@example.com>',
405. threadId: 't1',
406. }
407. const ST: MailboxSendState = {
408. email: 'hello@meridiandisplay.example',
409. label: 'Sam Whitaker',
410. state: 'sendable',
411. error: null,
412. signature: 'none',
413. }
415. it('shows the Cc the SERVER settled on, and says it is after the exclusions', () => {
416. const html = confirmPage({ ...OUT, cc: 'a@x.com, b@y.com' }, ORIG, ST, 'n1', SIGS_OK)
417. expect(html).toContain('a@x.com, b@y.com')
418. expect(html).toContain('2 addresses')
419. expect(html).toContain('after taking out you and the sender')
420. })
422. it('carries the reply-all choice forward so the send re-derives the same list', () => {
423. // `all=1` rather than the addresses: the send recomputes the Cc from the
424. // original, so the confirmation cannot be edited into a different one.
425. const html = confirmPage({ ...OUT, cc: 'a@x.com' }, ORIG, ST, 'n1', SIGS_OK)
426. expect(html).toContain('name="all" value="1"')
427. expect(html).not.toMatch(/name="cc" value/)
428. })
430. it('reads as a new message, not a reply, when there is no original', () => {
431. const html = confirmPage({ ...OUT, inReplyTo: null, threadId: null }, null, ST, 'n1', SIGS_OK)
432. expect(html).toContain('Send this message?')
433. expect(html).toContain('name="mode" value="new"')
434. expect(html).toContain('start its own conversation')
435. // The typed recipients ride in the form, because there is no original to
436. // re-read them from, and they are re-parsed server-side on the send.
437. expect(html).toContain('name="to" value="client@example.com"')
438. })
440. it('lists every staged file with its size, and carries the bytes in the form', () => {
441. const staged = [{ name: 'proof.pdf', mimeType: 'application/pdf', b64: btoa('x'.repeat(3000)) }]
442. const html = confirmPage(OUT, ORIG, ST, 'n1', SIGS_OK, staged)
443. expect(html).toContain('proof.pdf')
444. expect(html).toContain('1 attachment')
445. expect(html).toContain('3 KB')
446. expect(html).toContain('name="staged"')
447. })
449. it('says "No attachments" rather than leaving the question open', () => {
450. const html = confirmPage(OUT, ORIG, ST, 'n1', SIGS_OK)
451. expect(html).toContain('No attachments')
452. expect(html).not.toContain('name="staged"')
453. })
454. })
456. describe('the sent record renders three states of Cc, not two', () => {
457. const ROW: SendRecord = {
458. nonce: 'n1',
459. at: '2026-09-09T15:00:00.000Z',
460. by: 'Sam Whitaker',
461. byEmail: 'hello@meridiandisplay.example',
462. from: 'hello@meridiandisplay.example',
463. to: 'client@example.com',
464. subject: 'Re: Banner proof',
465. originalMailbox: 'hello@meridiandisplay.example',
466. originalId: 'm1',
467. originalMessageId: '<abc@example.com>',
468. threadIdSent: 't1',
469. signatureApplied: true,
470. outcome: 'sent',
471. gmailId: 'gm1',
472. gmailThreadId: 'gt1',
473. error: null,
474. candidates: [],
475. }
477. it('says "not recorded" for a row written before reply-all existed', () => {
478. // An old row does not record "no Cc"; it records nothing. Reading absent
479. // as none would make this audit log claim something it never observed.
480. const html = sentPage([], false, ROW, false)
481. expect(html).toContain('not recorded')
482. })
484. it('says "none" when the send recorded that there was no Cc', () => {
485. const html = sentPage([], false, { ...ROW, cc: null, attachments: [] }, false)
486. expect(html).toContain('Cc none')
487. expect(html).not.toContain('not recorded')
488. })
490. it('names the files and their sizes when there were some', () => {
491. const html = sentPage(
492. [],
493. false,
494. { ...ROW, cc: null, attachments: [{ name: 'proof.pdf', size: 240_000 }] },
495. false,
496. )
497. expect(html).toContain('proof.pdf')
498. expect(html).toContain('234 KB')
499. })
501. it('marks a new message as one, so the record shows who chose the recipient', () => {
502. const html = sentPage([], false, { ...ROW, mode: 'new', originalMailbox: null, originalId: null }, false)
503. expect(html).toContain('new message')
504. })
506. it('shows the listing count from metadata, and nothing when it is absent', () => {
507. // The listing reads KV metadata, which carries a count rather than names
508. // (1,024-byte cap). Null is "not recorded" and must not print as zero.
509. const withCount = sentPage([{ ...ROW, attachmentCount: 2 }], false, null, false)
510. expect(withCount).toContain('2 files')
511. const without = sentPage([{ ...ROW, attachmentCount: null }], false, null, false)
512. expect(without).not.toContain('files')
513. })
514. })