fathom-attribution.test.ts

apps/dashboard/test/fathom-attribution.test.ts

1. /**
2. * Fathom attribution, pinned against the shapes the live API sends.
3. *
4. * Every label and address in this file has the shape of a real
5. * `GET /meetings?include_action_items=true` response. Each case below is one
6. * the frozen seed does not exercise:
7. *
8. * 1. A roster person must never sit in EXTERNAL_LABELS, or their own action
9. * items resolve to "external" and reach nobody's view.
10. * 2. `Marco Ibáñez Meridian Display` arrives with a null email. The
11. * leading-token fallback splits on | - @ and that string has none of them,
12. * so without a name-map entry it resolves to `unknown`.
13. * 3. Unowned has two shapes: the bare "Meridian Display" and a fully null
14. * `{name: null, email: null}`. Both mean nobody was named.
15. * 4. Two people arrive under a second address the roster does not carry:
16. * nora@ beside nora.l@, theo@ beside frontdesk@.
17. *
18. * The through-line: a display name is a guess and an email is a key.
19. */
21. import { describe, expect, it } from 'vitest'
22. import {
23. attributeFathomRef,
24. isUnownedRef,
25. participantsOf,
26. EXTERNAL_LABELS,
27. KNOWN_NON_PERSON_ADDRESSES,
28. ROUTED_ADDRESSES,
29. } from '../../../config/fathom-people.js'
31. describe('email beats the display name', () => {
32. it('resolves projects@ to Ines even though the name says "Lena K"', () => {
33. // The case that justifies the order. An invitee with name "Lena K Meridian
34. // Display" on projects@meridiandisplay.example, which the roster maps to Ines.
35. // Matching the address settles it; matching the name would mean deciding
36. // whether "Lena K" is Ines, which this code does not get to decide.
37. const got = attributeFathomRef({ name: 'Lena K Meridian Display', email: 'projects@meridiandisplay.example' })
38. expect(got.kind).toBe('roster')
39. if (got.kind === 'roster') expect(got.person.name).toBe('Ines Carvalho')
40. })
42. it('is case-insensitive about the address', () => {
43. const got = attributeFathomRef({ name: null, email: 'HELLO@MeridianDisplay.example' })
44. expect(got.kind).toBe('roster')
45. if (got.kind === 'roster') expect(got.person.name).toBe('Sam Whitaker')
46. })
47. })
49. describe('the owner is on the roster, not external', () => {
50. it.each([
51. ['nora.l@meridiandisplay.example', 'Nora Lindqvist @ Meridian Display'],
52. ['nora@meridiandisplay.example', 'Nora L'],
53. ])('resolves %s to the roster', (email, name) => {
54. // Both addresses appeared live on the same day. Only nora.l@ is on the
55. // roster, so nora@ has to come from the Fathom alias table.
56. const got = attributeFathomRef({ name, email })
57. expect(got.kind).toBe('roster')
58. if (got.kind === 'roster') expect(got.person.name).toBe('Nora Lindqvist')
59. })
61. it('resolves her by label alone when the email is null', () => {
62. const got = attributeFathomRef({ name: 'Nora L', email: null })
63. expect(got.kind).toBe('roster')
64. })
66. it('no longer lists her as an external label', () => {
67. for (const label of ['nora l', 'nora lindqvist', 'nora lindqvist @ meridian display']) {
68. expect(EXTERNAL_LABELS.has(label)).toBe(false)
69. }
70. })
71. })
73. describe('null-email labels still land on a person', () => {
74. it('attributes "Marco Ibáñez Meridian Display" with no email', () => {
75. // The exact live string. Before the fix this was `unknown`.
76. const got = attributeFathomRef({ name: 'Marco Ibáñez Meridian Display', email: null })
77. expect(got.kind).toBe('roster')
78. if (got.kind === 'roster') expect(got.person.name).toBe('Marco Ibáñez')
79. })
81. it.each([
82. ['Rosa Galván', 'Rosa Galván'],
83. ['Rosa', 'Rosa Galván'],
84. ['Theo | MeridianDisplay', 'Theo Bassett'],
85. ])('attributes %j with no email', (label, expected) => {
86. const got = attributeFathomRef({ name: label, email: null })
87. expect(got.kind).toBe('roster')
88. if (got.kind === 'roster') expect(got.person.name).toBe(expected)
89. })
91. it('still maps a departed person’s label, and lands off the roster', () => {
92. // Hazel has left and Rosa holds her seat. Her spellings stay in
93. // config/fathom-people.ts on purpose: her meetings are in Fathom forever,
94. // and a recording that resolved to a person yesterday must not resolve to
95. // a bare label today. The destination is a name the roster no longer
96. // carries, and that is the honest answer, not a bug to paper over.
97. const got = attributeFathomRef({ name: 'Hazel O', email: null })
98. expect(got.kind).not.toBe('roster')
99. })
101. it("keeps Theo's second address on the roster", () => {
102. const got = attributeFathomRef({ name: 'Office MeridianDisplay', email: 'theo@meridiandisplay.example' })
103. expect(got.kind).toBe('roster')
104. if (got.kind === 'roster') expect(got.person.name).toBe('Theo Bassett')
105. })
106. })
108. describe('unowned means nobody, in either shape', () => {
109. it('treats the bare company name as unowned', () => {
110. expect(isUnownedRef({ name: 'Meridian Display', email: null })).toBe(true)
111. expect(attributeFathomRef({ name: 'Meridian Display', email: null }).kind).toBe('unowned')
112. })
114. it('treats a fully null assignee as unowned', () => {
115. // Seen once live. A different shape, the same fact.
116. expect(isUnownedRef({ name: null, email: null })).toBe(true)
117. expect(isUnownedRef(null)).toBe(true)
118. })
120. it('does NOT treat a named person as unowned', () => {
121. expect(isUnownedRef({ name: 'Hazel O', email: 'accounts@meridiandisplay.example' })).toBe(false)
122. })
124. it('never turns the company name into a person', () => {
125. // "Meridian Display" as a designer would be the Plinth `--` bug in another costume.
126. const got = attributeFathomRef({ name: 'Meridian Display', email: null })
127. expect(got.kind).not.toBe('roster')
128. })
129. })
131. describe('an outsider holding an action item is recognised, not hand-listed', () => {
132. // A prospect held one action item in the live 14-day window and is in no
133. // map. Adding every client contact to EXTERNAL_LABELS by hand builds in the
134. // lag every hand-kept table has, so Fathom's own is_external flag on the
135. // meeting's invitee list settles it instead.
136. const invitees = [
137. { name: 'Peter Lang', email: 'peter@example.com', is_external: true },
138. { name: 'Sam Whitaker - Meridian Display', email: 'hello@meridiandisplay.example', is_external: false },
139. ]
141. it('classifies them external using the invitee flag', () => {
142. const got = attributeFathomRef({ name: 'Peter Lang', email: 'peter@example.com' }, invitees)
143. expect(got.kind).toBe('external')
144. })
146. it('matches on the display name when the assignee has no email', () => {
147. const got = attributeFathomRef({ name: 'Peter Lang', email: null }, invitees)
148. expect(got.kind).toBe('external')
149. })
151. it('stays unknown without the invitee list, rather than guessing', () => {
152. // No evidence, no verdict. Surfaced every run.
153. expect(attributeFathomRef({ name: 'Peter Lang', email: null }).kind).toBe('unknown')
154. })
156. it('never lets the flag override a roster match', () => {
157. // A roster person mis-flagged external must still be themselves; the email
158. // path returns before any of this.
159. const got = attributeFathomRef(
160. { name: 'Sam Whitaker - Meridian Display', email: 'hello@meridiandisplay.example' },
161. [{ name: 'Sam Whitaker - Meridian Display', email: 'hello@meridiandisplay.example', is_external: true }],
162. )
163. expect(got.kind).toBe('roster')
164. })
165. })
167. describe('a routed mailbox sends its tasks to a person without putting them in the room', () => {
168. // exec@meridiandisplay.example: the executive-assistant mailbox, with no
169. // owner at present. Its tasks route to Sam, as a holding decision.
170. const EA = { name: 'EA', email: 'exec@meridiandisplay.example' }
172. it('is declared as routed, not as a person', () => {
173. expect(ROUTED_ADDRESSES['exec@meridiandisplay.example']).toBe('Sam Whitaker')
174. })
176. it('attributes an action item assigned to the mailbox to Sam', () => {
177. const got = attributeFathomRef(EA)
178. expect(got.kind).toBe('roster')
179. if (got.kind === 'roster') expect(got.person.name).toBe('Sam Whitaker')
180. })
182. it('does NOT make Sam a participant of a meeting the mailbox attended', () => {
183. // The point: routing an item is not being in the room. If this fails, a
184. // routing decision has silently become a visibility grant.
185. const { roster, acknowledged, unmatched } = participantsOf([
186. { ...EA, is_external: false },
187. { name: 'Hazel O', email: 'accounts@meridiandisplay.example', is_external: false },
188. ])
189. // An invitee list from when accounts@ was Hazel's desk; Rosa holds it now,
190. // so the address resolves to her. Fathom records an address
191. // and nothing else, so a historical call cannot be told apart from a
192. // current one: a known imprecision, written down beside the mapping in
193. // config/fathom-people.ts rather than hidden by editing the fixture.
194. expect(roster.map((p) => p.name)).toEqual(['Rosa Galván'])
195. expect(roster.map((p) => p.name)).not.toContain('Sam Whitaker')
196. expect(acknowledged).toEqual(['EA'])
197. expect(unmatched).toEqual([])
198. })
200. it('never lets a routing entry override a real person\'s own address', () => {
201. // Defensive: routing is checked after the roster lookups, so even a
202. // mistaken entry for a real address could not re-route that person's items.
203. const got = attributeFathomRef({ name: 'Hazel O', email: 'accounts@meridiandisplay.example' })
204. expect(got.kind).toBe('roster')
205. // The address wins over the label, and the address is Rosa's now; see
206. // the note two tests above.
207. if (got.kind === 'roster') expect(got.person.name).toBe('Rosa Galván')
208. })
209. })
211. describe('participants decide who may see a meeting', () => {
212. // The live invitee list of an internal leadership call, verbatim.
213. const leadership = [
214. { name: 'Nora Lindqvist @ Meridian Display', email: 'nora.l@meridiandisplay.example', is_external: false },
215. { name: 'Office MeridianDisplay', email: 'frontdesk@meridiandisplay.example', is_external: false },
216. { name: 'Lena K Meridian Display', email: 'projects@meridiandisplay.example', is_external: false },
217. { name: 'Hazel O', email: 'accounts@meridiandisplay.example', is_external: false },
218. { name: 'Sam Whitaker - Meridian Display', email: 'hello@meridiandisplay.example', is_external: false },
219. ]
221. it('resolves every internal invitee on a real leadership call', () => {
222. const { roster, external, unmatched } = participantsOf(leadership)
223. expect(roster.map((p) => p.name).sort()).toEqual([
224. 'Ines Carvalho',
225. 'Nora Lindqvist',
226. // accounts@ on this call was Hazel; the seat is Rosa's now and the
227. // address is all Fathom gives us.
228. 'Rosa Galván',
229. 'Sam Whitaker',
230. 'Theo Bassett',
231. ])
232. expect(external).toEqual([])
233. expect(unmatched).toEqual([])
234. })
236. it('EXCLUDES people who were not in the room', () => {
237. // The whole point of the feature: Marco and Rafael were not on that call,
238. // so they must not appear as viewers of it.
239. const names = participantsOf(leadership).roster.map((p) => p.name)
240. expect(names).not.toContain('Marco Ibáñez')
241. expect(names).not.toContain('Rafael Montero')
242. })
244. it('surfaces an internal address that matches nobody instead of dropping it', () => {
245. // Guessing who one is would be a silent fallback; dropping it would hide someone who
246. // can see a meeting the board believes has no such viewer. `unmatched` is
247. // meant to be empty, so anything in it is a question for a human.
248. const { roster, unmatched } = participantsOf([
249. { name: 'Someone New', email: 'newhire@meridiandisplay.example', is_external: false },
250. ])
251. expect(roster).toEqual([])
252. expect(unmatched).toEqual(['Someone New'])
253. })
255. it('does NOT make a role alias a viewer', () => {
256. // director@ is in KNOWN_NON_PERSON_ADDRESSES: it never appears without a
257. // Nora address beside it, owns no action items, and
258. // carries a role-shaped display name. Mapping it to her would gain no
259. // visibility she lacks and would hand her access to whoever the alias covers
260. // next: a permission widening with nobody editing the access list.
261. const { roster, unmatched, acknowledged } = participantsOf([
262. { name: 'Director MeridianDisplay', email: 'director@meridiandisplay.example', is_external: false },
263. ])
264. expect(roster).toEqual([])
265. expect(acknowledged).toEqual(['Director MeridianDisplay'])
266. // Known, so it is not an open question.
267. expect(unmatched).toEqual([])
268. })
270. it('keeps the alias out of the roster even alongside real people', () => {
271. const { roster, acknowledged } = participantsOf([
272. { name: 'Director MeridianDisplay', email: 'director@meridiandisplay.example', is_external: false },
273. { name: 'Nora Lindqvist', email: 'nora@meridiandisplay.example', is_external: false },
274. ])
275. expect(roster.map((p) => p.name)).toEqual(['Nora Lindqvist'])
276. expect(acknowledged).toEqual(['Director MeridianDisplay'])
277. })
279. it('never resolves the alias to a person through attribution either', () => {
280. // Belt and braces: the alias must not sneak in via the email path.
281. expect(KNOWN_NON_PERSON_ADDRESSES.has('director@meridiandisplay.example')).toBe(true)
282. const got = attributeFathomRef({ name: 'Director MeridianDisplay', email: 'director@meridiandisplay.example' })
283. expect(got.kind).not.toBe('roster')
284. })
286. it('trusts is_external over any domain list', () => {
287. // Northgate arrives under two domains, so a hand-kept table would miss one.
288. const { roster, external } = participantsOf([
289. { name: 'Rohan Mehta', email: 'rohan.mehta@northgate.example', is_external: true },
290. { name: 'Priya Nair', email: 'priya.nair@northgate.example', is_external: true },
291. { name: 'kc@clientco.example', email: 'kc@clientco.example', is_external: true },
292. ])
293. expect(roster).toEqual([])
294. expect(external).toHaveLength(3)
295. })
297. it('does not double-count someone invited twice', () => {
298. const { roster } = participantsOf([...leadership, leadership[0]!])
299. expect(roster.filter((p) => p.name === 'Nora Lindqvist')).toHaveLength(1)
300. })
302. it('reports an empty invitee list as nobody, not as everybody', () => {
303. // Fail closed: a meeting with no resolvable participants must expose itself
304. // to no one rather than defaulting to the whole roster.
305. expect(participantsOf([]).roster).toEqual([])
306. expect(participantsOf(null).roster).toEqual([])
307. })
308. })