company-todos.test.ts

packages/ninety-client/test/company-todos.test.ts

1. /**
2. * GET /todos/company: the company-wide sweep.
3. *
4. * Every assertion here is pinned to something measured against the live API,
5. * not to a spec document. The spec has been wrong (to-do sort casing, and a
6. * swagger several endpoints stale), so the fixture is the contract.
7. */
9. import { describe, expect, it, vi } from 'vitest'
10. import { HttpClient } from '../src/http.js'
11. import { Roster } from '../src/roster.js'
12. import { TodosResource } from '../src/resources/todos.js'
13. import { fromCursor, iterateCursor, collect, type CursorPage } from '../src/paginate.js'
14. import { NinetySchemaError } from '../src/errors.js'
15. import {
16. RawCompanyTodoSchema,
17. assignmentGroups,
18. assignmentSpread,
19. collapseSeries,
20. companyOwnerName,
21. companyTodoToRaw,
22. normalizeTodo,
23. sharedLinkAudit,
24. UNASSIGNED,
25. UNKNOWN_PERSON,
26. type Todo,
27. } from '../src/types.js'
28. import page1 from './fixtures/todos.company.json' with { type: 'json' }
29. import page2 from './fixtures/todos.company.page2.json' with { type: 'json' }
31. const CTX = { endpoint: 'GET /todos/company' }
33. const NAMES: Record<string, string> = {
34. 'a568c7b30679efe19e6ed3a1': 'Person One',
35. '4e77bc9877e856992de26b64': 'Person Two',
36. '3e894807d73d5a39b03fb411': 'Person Three',
37. 'e923a6ea5a28e32cb4cfa27e': 'Person Four',
38. }
39. const resolve = (id: string | null | undefined) =>
40. !id ? UNASSIGNED : NAMES[id] ? { id, name: NAMES[id]! } : UNKNOWN_PERSON(id)
42. /** Build a Todo from the thin fixture shape, the way company() does. */
43. function todosFrom(fixture: { data: unknown[] }): Todo[] {
44. return fixture.data
45. .map((r) => RawCompanyTodoSchema.parse(r))
46. .map((r) => normalizeTodo(companyTodoToRaw(r), resolve, { now: new Date('2026-08-24T12:00:00Z') }))
47. }
49. // --- the wire shape ---------------------------------------------------------
51. describe('RawCompanyTodoSchema against the captured shape', () => {
52. it('parses every row and keeps `id`, not `_id`', () => {
53. for (const row of [...page1.data, ...page2.data]) {
54. const parsed = RawCompanyTodoSchema.parse(row)
55. expect(parsed.id).toBeTruthy()
56. expect(parsed).not.toHaveProperty('_id')
57. }
58. })
60. it('confirms the fields that are ABSENT on an open company to-do', () => {
61. // This is why `completed=false` returns zero rows: the field does not exist,
62. // so equality against false matches nothing. Documented here so nobody
63. // "fixes" the missing filter by adding it back to the query.
64. for (const row of page1.data) {
65. for (const absent of ['completed', 'archived', 'deleted', 'isPersonal', 'seriesId', 'milestoneId']) {
66. expect(row).not.toHaveProperty(absent)
67. }
68. }
69. })
71. it('reads the owner name inline, with no roster join', () => {
72. const first = RawCompanyTodoSchema.parse(page1.data[0])
73. expect(companyOwnerName(first)).toBe('Person One')
74. })
75. })
77. describe('companyTodoToRaw', () => {
78. it('maps id -> _id so one normalizer serves both endpoints', () => {
79. const raw = companyTodoToRaw(RawCompanyTodoSchema.parse(page1.data[0]))
80. expect(raw._id).toBe('f3eeab9c18c2f9c02a4c7c7f')
81. })
83. it('asserts the four states the endpoint guarantees rather than guessing', () => {
84. const raw = companyTodoToRaw(RawCompanyTodoSchema.parse(page1.data[0]))
85. expect(raw.completed).toBe(false)
86. expect(raw.archived).toBe(false)
87. expect(raw.deleted).toBe(false)
88. expect(raw.isPersonal).toBe(false)
89. })
91. it('leaves genuinely unknowable fields undefined, not false', () => {
92. const raw = companyTodoToRaw(RawCompanyTodoSchema.parse(page1.data[0]))
93. expect(raw.seriesId).toBeUndefined()
94. expect(raw.milestoneId).toBeUndefined()
95. })
96. })
98. // --- cursor pagination ------------------------------------------------------
100. describe('fromCursor', () => {
101. it('reads {data, pagination.nextToken}', () => {
102. const page = fromCursor<unknown>(page1, CTX)
103. expect(page.items).toHaveLength(6)
104. expect(page.nextToken).toBe('NmE1MWViMzllZDlmZWVhYWYxNDkyNjI3')
105. })
107. it('treats a null nextToken as exhausted', () => {
108. expect(fromCursor<unknown>(page2, CTX).nextToken).toBeNull()
109. })
111. it('treats an empty-string token as exhausted, not as a valid cursor', () => {
112. const page = fromCursor<unknown>({ data: [], pagination: { nextToken: '' } }, CTX)
113. expect(page.nextToken).toBeNull()
114. })
116. it('rejects the bare-array shape rather than silently returning nothing', () => {
117. expect(() => fromCursor<unknown>([], CTX)).toThrow(NinetySchemaError)
118. })
120. it('rejects an envelope whose data is not an array', () => {
121. expect(() => fromCursor<unknown>({ data: { nope: true } }, CTX)).toThrow(NinetySchemaError)
122. })
123. })
125. describe('iterateCursor', () => {
126. it('threads nextToken back and stops on null', async () => {
127. const seen: (string | undefined)[] = []
128. const pages: Record<string, CursorPage<number>> = {
129. first: { items: [1, 2], nextToken: 'a' },
130. a: { items: [3], nextToken: null },
131. }
132. const out = await collect(
133. iterateCursor<number>(async (token) => {
134. seen.push(token)
135. return pages[token ?? 'first']!
136. }),
137. )
138. expect(out).toEqual([1, 2, 3])
139. expect(seen).toEqual([undefined, 'a'])
140. })
142. it('throws instead of looping forever when the cursor does not advance', async () => {
143. await expect(
144. collect(iterateCursor<number>(async () => ({ items: [1], nextToken: 'stuck' }))),
145. ).rejects.toThrow(/same nextToken twice/)
146. })
148. it('honours the page cap', async () => {
149. let n = 0
150. await expect(
151. collect(
152. iterateCursor<number>(async () => ({ items: [n], nextToken: `t${n++}` }), { maxPages: 3 }),
153. ),
154. ).rejects.toThrow(/safety cap/)
155. })
156. })
158. // --- the finding that changes a number on the page --------------------------
160. describe('shared assignments vs recurrence', () => {
161. const todos = [...todosFrom(page1), ...todosFrom(page2)]
163. it('groups one commitment carried by three people into a single commitment', () => {
164. const groups = assignmentGroups(todos)
165. const checklist = groups.find((g) => g.title.startsWith('Refresh the proof approval checklist'))
166. expect(checklist?.todos).toHaveLength(3)
167. expect(checklist?.owners.map((o) => o.name).sort()).toEqual(['Person One', 'Person Three', 'Person Two'])
168. expect(checklist?.shared).toBe(true)
169. })
171. it('normalizes whitespace and case so "Weekly Product " matches "Weekly Product"', () => {
172. const groups = assignmentGroups(todos)
173. const weekly = groups.filter((g) => g.title.toLowerCase().includes('weekly'))
174. expect(weekly).toHaveLength(1)
175. expect(weekly[0]!.owners).toHaveLength(2)
176. })
178. it('reports assignments and commitments as two different numbers', () => {
179. // The live shape of this was 31 assignments / 24 commitments.
180. const spread = assignmentSpread(todos)
181. expect(spread.assignments).toBe(9)
182. expect(spread.commitments).toBe(5)
183. expect(spread.sharedCommitments).toBe(3)
184. expect(spread.maxOwners).toBe(3)
185. })
187. it('marks the basis as heuristic so the UI can say so', () => {
188. expect(assignmentGroups(todos).every((g) => g.basis === 'title')).toBe(true)
189. })
191. it('keeps every row for per-person views', () => {
192. // Deduping here would erase two of the three people who owe the checklist work.
193. const mine = todos.filter((t) => t.owner.name === 'Person Two')
194. expect(mine.length).toBeGreaterThan(1)
195. })
196. })
198. describe('collapseSeries is keyed by series AND owner', () => {
199. const base = todosFrom(page1)[0]!
201. it('collapses repeat occurrences for one person', () => {
202. const a = { ...base, id: 'a', seriesId: 's1', dueDate: '2026-08-08T04:59:59Z' }
203. const b = { ...base, id: 'b', seriesId: 's1', dueDate: '2026-08-15T04:59:59Z' }
204. const out = collapseSeries([a, b])
205. expect(out).toHaveLength(1)
206. expect(out[0]!.id).toBe('a') // earliest, because that is the one actually late
207. })
209. it('NEVER merges a shared series across different owners', () => {
210. // The regression this guards: seven titles among the live rows were one commitment on
211. // two or three people. Collapsing them would erase who owes what.
212. const a = { ...base, id: 'a', seriesId: 's1', owner: { id: 'u1', name: 'Person One' } }
213. const b = { ...base, id: 'b', seriesId: 's1', owner: { id: 'u2', name: 'Person Two' } }
214. const out = collapseSeries([a, b])
215. expect(out).toHaveLength(2)
216. expect(out.map((t) => t.owner.name).sort()).toEqual(['Person One', 'Person Two'])
217. })
219. it('passes non-recurring to-dos straight through', () => {
220. expect(collapseSeries(todosFrom(page2))).toHaveLength(3)
221. })
222. })
224. describe('sharedLinkAudit', () => {
225. it('reports not-linkable when the copies share no series or milestone', () => {
226. const audit = sharedLinkAudit([...todosFrom(page1), ...todosFrom(page2)])
227. expect(audit.sharedGroups).toBe(3)
228. expect(audit.sharesSeriesId).toBe(0)
229. expect(audit.linkable).toBe(false)
230. })
232. it('reports linkable once every shared group agrees on a seriesId', () => {
233. const base = todosFrom(page1)[0]!
234. const a = { ...base, id: 'a', title: 'Shared thing', seriesId: 's9', owner: { id: 'u1', name: 'One' } }
235. const b = { ...base, id: 'b', title: 'Shared thing', seriesId: 's9', owner: { id: 'u2', name: 'Two' } }
236. const audit = sharedLinkAudit([a, b])
237. expect(audit.linkable).toBe(true)
238. expect(audit.detail[0]!.seriesId).toBe('s9')
239. })
240. })
242. // --- the resource, against a stubbed transport ------------------------------
244. describe('TodosResource.company', () => {
245. function resourceReturning(...responses: unknown[]) {
246. const fetchImpl = vi.fn()
247. for (const r of responses) {
248. fetchImpl.mockResolvedValueOnce(
249. new Response(JSON.stringify(r), { status: 200, headers: { 'Content-Type': 'application/json' } }),
250. )
251. }
252. const http = new HttpClient({ token: 't', fetchImpl: fetchImpl as unknown as typeof fetch, rps: 1000 })
253. return { resource: new TodosResource(http, new Roster(http), {}), fetchImpl }
254. }
256. it('walks both pages and returns every row', async () => {
257. const { resource } = resourceReturning(page1, page2)
258. const todos = await resource.company()
259. expect(todos).toHaveLength(9)
260. })
262. it('sends NO boolean filters, since they are broken on this endpoint', async () => {
263. // completed=false returns 0 rows; completed=false&archived=false returns MORE
264. // than unfiltered. Both measured live. The correct call sends neither.
265. const { resource, fetchImpl } = resourceReturning(page2)
266. await resource.company()
267. const url = new URL(fetchImpl.mock.calls[0]![0] as string)
268. expect(url.pathname).toBe('/v1/todos/company')
269. expect(url.searchParams.get('completed')).toBeNull()
270. expect(url.searchParams.get('archived')).toBeNull()
271. expect(url.searchParams.get('deleted')).toBeNull()
272. expect(url.searchParams.get('limit')).toBe('100')
273. })
275. it('threads the cursor into the second request', async () => {
276. const { resource, fetchImpl } = resourceReturning(page1, page2)
277. await resource.company()
278. const second = new URL(fetchImpl.mock.calls[1]![0] as string)
279. expect(second.searchParams.get('nextToken')).toBe('NmE1MWViMzllZDlmZWVhYWYxNDkyNjI3')
280. })
282. it('resolves owner names with zero GET /users traffic', async () => {
283. const { resource, fetchImpl } = resourceReturning(page2)
284. const todos = await resource.company()
285. expect(todos.map((t) => t.owner.name)).toContain('Person One')
286. for (const call of fetchImpl.mock.calls) {
287. expect(String(call[0])).not.toContain('/users/')
288. }
289. })
290. })