mattrguerra.comHouston area
Matt Guerra
  1. 01AI & Automation
  2. 02Photography
  3. 03Design
  4. 04About
  5. 05Notes
  6. 06Contact
Back to the systems

mattrguerra/meridian-ops-boardmainPrivate on GitHub, published here in full

timezone.test.ts

TypeScript7.0 KB159 lines

apps/dashboard/test/timezone.test.ts

  1. /**
  2. * No reader of this board is in UTC.
  3. *
  4. * Times rendered in UTC read as the wrong hour, and after 7 PM as the wrong
  5. * day; a raw ISO string on the page is worse. The correct helpers live in
  6. * `packages/ninety-client/src/dates.ts`. Using them is not the hard part;
  7. * noticing a site that does not is. So this asserts the property over whole
  8. * rendered documents rather than checking sites one at a time. A new
  9. * surface that slices an ISO string fails here without anyone remembering to
  10. * come back and add a case.
  11. */
  13. import { describe, expect, it } from 'vitest'
  14. import { localClock, localDay, localStamp, MERIDIAN_TZ } from '@meridian/ninety-client'
  15. import { render } from '../src/render.js'
  16. import { headline } from '../src/collect.js'
  17. import { FIXTURE_SNAPSHOT } from '../src/fixtures.js'
  18. import { inboxPage, messagePage, sentPage, type InboxData, type SendRecord } from '../src/inbox-view.js'
  19. import { INBOX_MAILBOXES } from '../../../config/inbox.js'
  20. import { viewerFor } from '../src/viewer.js'
  21. import type { InboxMessage, MessageBody } from '@meridian/gmail-client'
  23. /** An instant deliberately chosen to land on a different calendar day in UTC. */
  24. const EVENING = '2026-09-05T02:30:00.000Z' // 9:30 PM CT on Sep 4
  26. describe('localStamp / localClock', () => {
  27. it('renders an instant in Central, not UTC', () => {
  28. // 02:30 UTC on the 5th is 9:30 PM on the 4th in Chicago. A slice of the ISO
  29. // string gets both the day and the hour wrong.
  30. expect(localStamp(EVENING)).toContain('Sep 4')
  31. expect(localStamp(EVENING)).toContain('9:30')
  32. expect(localClock(EVENING)).toBe('9:30 PM')
  33. expect(localDay(EVENING)).toBe('2026-09-04')
  34. })
  36. it('accepts epoch milliseconds, which is what the replied marks store', () => {
  37. expect(localStamp(Date.parse(EVENING))).toBe(localStamp(EVENING))
  38. })
  40. it('renders an absence rather than "Invalid Date"', () => {
  41. // Callers render whatever the board stored, and stored values go missing.
  42. for (const bad of ['', 'not a date', 'undefined']) {
  43. expect(localStamp(bad)).toBe('–')
  44. expect(localClock(bad)).toBe('–')
  45. }
  46. })
  48. it('follows the DST change without a code edit', () => {
  49. // The offset changes twice a year. Intl handles it; the pages say "CT"
  50. // rather than CDT/CST so nothing needs editing.
  51. const summer = localClock('2026-07-01T17:00:00.000Z') // CDT, UTC-5
  52. const winter = localClock('2026-12-01T17:00:00.000Z') // CST, UTC-6
  53. expect(summer).toBe('12:00 PM')
  54. expect(winter).toBe('11:00 AM')
  55. expect(MERIDIAN_TZ).toBe('America/Chicago')
  56. })
  57. })
  59. /** Every ISO instant that should never survive to a rendered page. */
  60. const RAW_ISO = /\d{4}-\d{2}-\d{2}T\d{2}:\d{2}/
  62. /**
  63. * Strip everything that is not text a reader sees.
  64. *
  65. * Script and style BODIES go too. A code comment explaining the UTC bug is not
  66. * the UTC bug. That would be a hole if an inlined script formatted a date
  67. * wrongly, so the next test closes it directly rather than leaving it to this
  68. * one.
  69. */
  70. const scrub = (html: string): string =>
  71. html
  72. .replace(/<script\b[^>]*>[\s\S]*?<\/script>/g, '')
  73. .replace(/<style\b[^>]*>[\s\S]*?<\/style>/g, '')
  74. // datetime="" and machine-readable attributes are allowed to be ISO.
  75. .replace(/datetime="[^"]*"/g, '')
  76. // URLs may legitimately carry timestamps.
  77. .replace(/href="[^"]*"/g, '')
  78. .replace(/src="[^"]*"/g, '')
  80. /** The script bodies on their own, which scrub() removes. */
  81. const scriptsOf = (html: string): string =>
  82. (html.match(/<script\b[^>]*>[\s\S]*?<\/script>/g) ?? []).join('\n')
  84. describe('no rendered page shows a reader a UTC time', () => {
  85. const viewer = viewerFor('hello@meridiandisplay.example')
  87. it('the board carries no raw ISO timestamp and no "UTC" label', () => {
  88. const html = render(FIXTURE_SNAPSHOT, headline(FIXTURE_SNAPSHOT), [], '2026-08-12', null, viewer)
  89. const body = scrub(html)
  90. expect(body).not.toMatch(RAW_ISO)
  91. // The one that shipped: a meeting-commitment row printing the raw instant.
  92. expect(body).not.toContain('.670Z')
  93. expect(body).not.toMatch(/\bUTC\b/)
  94. })
  96. it('every date an inlined script formats passes a timeZone', () => {
  97. // scrub() drops script bodies, so this is where that hole is closed. The
  98. // notes bootstrap runs in the browser and cannot call localDay(); the
  99. // timeZone option is the same fix, and without it a note typed at 8 PM
  100. // showed tomorrow's date to the person who had just typed it.
  101. const js = scriptsOf(
  102. render(FIXTURE_SNAPSHOT, headline(FIXTURE_SNAPSHOT), [], '2026-08-12', null, viewer),
  103. )
  104. for (const call of js.match(/toLocale\w*\([^)]*\)/g) ?? []) {
  105. expect(call, `${call} formats a date with no timeZone`).toContain('timeZone')
  106. }
  107. // And nothing in a script may slice an ISO string into a displayed date.
  108. expect(js).not.toMatch(/\.at[^\n]*\.slice\(0,\s*10\)/)
  109. })
  111. it('the inbox list carries neither', () => {
  112. const data: InboxData = {
  113. syncedAt: EVENING,
  114. mailboxes: [{
  115. mailbox: 'hello@meridiandisplay.example', ok: true, error: null, canSend: true,
  116. messages: [{
  117. id: 'm1', threadId: 't1', mailbox: 'hello@meridiandisplay.example',
  118. sender: 'client@example.com', senderName: 'A Client',
  119. subject: 'Proof', snippet: 'hi', date: EVENING,
  120. labels: ['INBOX'], unread: true,
  121. } satisfies InboxMessage],
  122. }],
  123. }
  124. const html = scrub(inboxPage(data, [], INBOX_MAILBOXES, ['hello@meridiandisplay.example'], 'Sam Whitaker'))
  125. expect(html).not.toMatch(RAW_ISO)
  126. expect(html).not.toMatch(/\bUTC\b/)
  127. })
  129. it('an open message dates itself in Central', () => {
  130. const body: MessageBody = {
  131. id: 'm1', mailbox: 'hello@meridiandisplay.example', sender: 'client@example.com',
  132. senderName: 'A Client', subject: 'Proof', date: EVENING,
  133. to: 'hello@meridiandisplay.example', text: 'hello', kind: 'plain', truncated: false,
  134. html: null, htmlTruncated: false, unread: true, attachments: [],
  135. threadId: 't1', messageId: null, references: null, replyTo: '', cc: '',
  136. }
  137. const html = scrub(messagePage(body, 'Sam Whitaker'))
  138. expect(html).not.toMatch(RAW_ISO)
  139. expect(html).not.toMatch(/\bUTC\b/)
  140. expect(html).toContain('Sep 4')
  141. expect(html).toContain('CT')
  142. })
  144. it('the sent record dates itself in Central: Sam’s "email delivery times"', () => {
  145. const rec: SendRecord = {
  146. nonce: 'n1', at: EVENING, by: 'Sam Whitaker', byEmail: 'hello@meridiandisplay.example',
  147. from: 'hello@meridiandisplay.example', to: 'client@example.com', subject: 'Re: Proof',
  148. originalMailbox: 'hello@meridiandisplay.example', originalId: 'm1', originalMessageId: null,
  149. threadIdSent: null, signatureApplied: false, outcome: 'sent',
  150. gmailId: 'g1', gmailThreadId: 'gt1', error: null, candidates: [],
  151. }
  152. const html = scrub(sentPage([rec], false, rec, false))
  153. expect(html).not.toMatch(RAW_ISO)
  154. expect(html).not.toMatch(/\bUTC\b/)
  155. // The day column was a UTC calendar day, so an evening send showed tomorrow.
  156. expect(html).toContain('2026-09-04')
  157. expect(html).not.toContain('2026-09-05')
  158. })
  159. })