bitrix-join.test.ts

apps/dashboard/test/bitrix-join.test.ts

1. /**
2. * The Bitrix task join.
3. *
4. * `Task.responsibleId` is Bitrix's numeric user id, stringified. Looking it up
5. * as a roster display name (`personByName('1924')`) matches nothing and reads
6. * "+ 0 tasks" on every row. A fixture that passed display names as
7. * `responsibleId` would reproduce the shape that bug expects instead of the
8. * shape Bitrix sends, and would pass: a fixture that agrees with a bug cannot
9. * catch it.
10. *
11. * These tests pin the contract at both ends: ids are numeric, and the join
12. * attributes a real number of them.
13. */
15. import { describe, expect, it } from 'vitest'
16. import { FIXTURE_SNAPSHOT } from '../src/fixtures.js'
17. import { headline, peopleBoard, type Snapshot } from '../src/collect.js'
18. import { buildViewModel } from '../src/view-model.js'
19. import { viewerFor } from '../src/viewer.js'
20. import {
21. MERIDIAN_PEOPLE,
22. offRosterBitrixIds,
23. personFromBitrix,
24. uncoveredByBitrix,
25. unpinnedBitrixPeople,
26. type Person,
27. } from '../../../config/meridian-people.js'
28. import { partitionTasks } from '@meridian/bitrix-client'
30. describe('responsibleId is an id, and the fixture must say so', () => {
31. it('carries only numeric responsibleIds, never a display name', () => {
32. // Ids in the fixture are numeric, as Bitrix sends them.
33. for (const t of FIXTURE_SNAPSHOT.tasks.data) {
34. if (t.responsibleId === null) continue
35. expect(t.responsibleId, `task ${t.id} "${t.title}"`).toMatch(/^\d+$/)
36. }
37. })
39. it('never resolves a roster display name as a responsibleId', () => {
40. for (const p of MERIDIAN_PEOPLE) expect(personFromBitrix(p.name)).toBeNull()
41. })
43. it('has a Bitrix id pinned for every roster person', () => {
44. // An unpinned id silently zeroes that person's tasks, which is how this
45. // started. unpinnedBitrixPeople() exists so it cannot go unnoticed again.
46. expect(unpinnedBitrixPeople()).toEqual([])
47. })
48. })
50. describe('the join actually attributes tasks', () => {
51. const board = peopleBoard(FIXTURE_SNAPSHOT)
53. it('attributes a non-zero number of real tasks', () => {
54. // The bug was not a wrong count, it was zero. Assert the floor.
55. expect(board.taskJoin.attributed).toBeGreaterThan(0)
56. expect(board.taskJoin.real).toBeGreaterThan(board.taskJoin.attributed)
57. })
59. it('puts tasks on the specific people who hold them', () => {
60. const by = new Map(board.rows.map((r) => [r.name, r.taskCount]))
61. expect(by.get('Ines Carvalho')).toBe(2)
62. expect(by.get('Theo Bassett')).toBe(1)
63. expect(by.get('Marco Ibáñez')).toBe(1)
64. expect(by.get('Sam Whitaker')).toBe(1)
65. })
67. it('gives her a measured zero now that her id is pinned, not Hazel’s task', () => {
68. // With her own id pinned, Rosa's count is a real zero against this
69. // fixture: she holds no open tasks in it, which is a fact rather than an
70. // absence. Hazel's one task stays off her row, because the id did not
71. // transfer (see the test below).
72. const by = new Map(board.rows.map((r) => [r.name, r.taskCount]))
73. expect(by.get('Rosa Galván')).toBe(0)
74. })
76. it('reports Hazel’s old Bitrix id as an off-roster holder rather than losing it', () => {
77. // Her id was deliberately not moved to Rosa; it is an account, not a
78. // seat. The task held by it does not vanish: it lands in offRoster, which
79. // is "held by someone not on this roster" and is reported as such.
80. expect(board.taskJoin.offRoster.map((o) => o.id)).toContain('2736')
81. })
83. it('reaches My Day, not just the board', () => {
84. // peopleBoard and myDay resolved the join independently, so both had to be
85. // fixed. Counting a task and showing it are different steps.
86. const ines = MERIDIAN_PEOPLE.find((p) => p.name === 'Ines Carvalho')!
87. const vm = buildViewModel(FIXTURE_SNAPSHOT, headline(FIXTURE_SNAPSHOT), [], '2026-08-12', viewerFor(ines.email))
88. const card = vm.myDays.find((d) => d.person.name === 'Ines Carvalho')!
89. expect(card.tasks).toBe(2)
90. expect(card.items.filter((i) => i.meta.startsWith('Bitrix task'))).toHaveLength(2)
91. })
93. it('accounts for every real task: attributed + off-roster + unowned', () => {
94. const { real } = partitionTasks(FIXTURE_SNAPSHOT.tasks.data)
95. const unowned = real.filter((t) => !t.responsibleId).length
96. const offRoster = board.taskJoin.offRoster.reduce((n, o) => n + o.tasks, 0)
97. expect(board.taskJoin.attributed + offRoster + unowned).toBe(real.length)
98. })
99. })
101. describe('an off-roster holder is reported, not chased and not hidden', () => {
102. const board = peopleBoard(FIXTURE_SNAPSHOT)
104. it('counts off-roster real tasks rather than absorbing them', () => {
105. // Almost every Bitrix account is out of scope, so this is expected and is
106. // not a coverage gap. But it is stated, because most of the
107. // live real tasks sit here and the board deliberately shows none of them.
108. expect(board.taskJoin.offRoster.length).toBeGreaterThan(0)
109. for (const o of board.taskJoin.offRoster) expect(o.id).toMatch(/^\d+$/)
110. })
112. it('puts an off-roster task on nobody', () => {
113. const vm = buildViewModel(FIXTURE_SNAPSHOT, headline(FIXTURE_SNAPSHOT), [], '2026-08-12')
114. for (const d of vm.myDays) {
115. expect(d.items.map((i) => i.what)).not.toContain('Fix the old quote form (April, 2024)')
116. }
117. })
119. it('separates "held by someone off the roster" from "held by nobody"', () => {
120. // Different facts. One is out of scope by decision; the other means nobody
121. // has been asked to do it. Merging them loses the second entirely.
122. const ids = board.taskJoin.offRoster.map((o) => o.id)
123. expect(ids).not.toContain('')
124. expect(ids.every(Boolean)).toBe(true)
125. })
127. it('does not count junk as off-roster', () => {
128. // 20 junk rows are held by a departed person and a meeting room. Counting
129. // them here would make an expected number look alarming.
130. const offRoster = board.taskJoin.offRoster.reduce((n, o) => n + o.tasks, 0)
131. expect(offRoster).toBeLessThan(board.taskJoin.junk)
132. expect(board.taskJoin.offRoster.map((o) => o.id)).not.toContain('26')
133. expect(board.taskJoin.offRoster.map((o) => o.id)).not.toContain('196')
134. })
135. })
137. describe('two ways Bitrix can fail to see a person, and they are different', () => {
138. // Synthetic rosters on purpose. Both states are transient (whoever is
139. // mid-onboarding today is pinned tomorrow), so testing them against the live
140. // roster means the test asserts nothing the moment the gap closes.
141. const person = (over: Partial<Person>): Person => ({
142. name: 'Test Person',
143. role: 'Client Success',
144. plinthAccounts: [],
145. coveredBy: [],
146. ...over,
147. })
149. it('separates "claims Bitrix, has no id" from "Bitrix does not cover them"', () => {
150. // The first is a bug: the board says Bitrix covers them, so their tasks
151. // render as a number, and the number is silently zero. The second is a
152. // coverage fact: nothing claims to see them, so their count reads as not
153. // tracked. Collapsing the two loses the bug.
154. const claims = person({ name: 'Claims Coverage', coveredBy: ['bitrix-tasks'] })
155. const uncovered = person({ name: 'Nobody Covers' })
156. const pinned = person({ name: 'Pinned', bitrixUserId: 42, coveredBy: ['bitrix-tasks'] })
157. expect(uncoveredByBitrix([claims, uncovered, pinned])).toEqual(['Nobody Covers'])
158. })
160. it('reports nobody as uncovered once their id is pinned', () => {
161. const pinned = person({ name: 'Pinned', bitrixUserId: 42, coveredBy: ['bitrix-tasks'] })
162. expect(uncoveredByBitrix([pinned])).toEqual([])
163. })
165. it('every roster person is now on one side or the other, with nobody in limbo', () => {
166. // A person with an id who does not claim coverage would be an id nothing
167. // uses; a person with neither is reported by uncoveredByBitrix. Both are
168. // visible states; this asserts nobody is in the third, silent one.
169. for (const p of MERIDIAN_PEOPLE) {
170. const covered = p.coveredBy.includes('bitrix-tasks')
171. expect(covered ? Boolean(p.bitrixUserId) : true, `${p.name}`).toBe(true)
172. }
173. })
174. })
176. describe('Data health states the count, not the method', () => {
177. // Mode matters here. sourceStatuses() rewrites every pill on a fixture run, so
178. // a sample board cannot claim live join numbers. That rewrite is deliberate
179. // and is asserted elsewhere. The join note only exists on a live snapshot, so
180. // these tests use one.
181. const LIVE: Snapshot = { ...FIXTURE_SNAPSHOT, mode: 'live', fixtureCapturedAt: null }
183. const noteFor = (snap: Snapshot): string => {
184. const vm = buildViewModel(snap, headline(snap), [], '2026-08-12')
185. return vm.sources.find((s) => s.name === 'Bitrix tasks')!.note
186. }
188. it('reports how many attributed, out of how many', () => {
189. const board = peopleBoard(LIVE)
190. const note = noteFor(LIVE)
191. expect(note).toContain(`${board.taskJoin.attributed} of ${board.taskJoin.real}`)
192. expect(note).toContain(String(board.taskJoin.junk))
193. })
195. it('counts the pinned ids rather than claiming a number', () => {
196. // Counted, not asserted: "all roster ids are pinned" as a fixed sentence
197. // would make a claim about somebody the page had never looked up.
198. expect(noteFor(LIVE)).toMatch(/\d+ of \d+ roster ids are pinned/)
199. expect(noteFor(LIVE)).not.toContain('All seven')
200. })
202. it('says off-roster holders are expected rather than a gap', () => {
203. // The wording is not the assertion; the presence of the count is. An
204. // off-roster number reported as a warning would be a permanent false alarm
205. // about dozens of accounts nobody intends to show.
206. expect(noteFor(LIVE)).toMatch(/outside the roster/i)
207. })
209. it('no longer claims the join works by describing how it matches', () => {
210. // Numbers, not a description of the method: a description can read as
211. // "fine" on a join that attributed nothing.
212. expect(noteFor(LIVE)).not.toMatch(/by display name/i)
213. })
215. it('reports a dead source as dead rather than as a zero join', () => {
216. const down: Snapshot = { ...LIVE, tasks: { ok: false, data: [], error: 'HTTP 401' } }
217. const note = noteFor(down)
218. expect(note).toContain('401')
219. expect(note).not.toMatch(/0 of 0/)
220. })
221. })
223. describe('offRosterBitrixIds', () => {
224. it('groups by id and sorts by volume', () => {
225. expect(offRosterBitrixIds(['26', '4', '26', '26', '4'])).toEqual([
226. { id: '26', tasks: 3 },
227. { id: '4', tasks: 2 },
228. ])
229. })
231. it('ignores roster ids, nulls and blanks', () => {
232. expect(offRosterBitrixIds(['1924', null, undefined, ' ', '7108'])).toEqual([])
233. })
234. })