tracker.test.ts

packages/sheets-client/test/tracker.test.ts

1. /**
2. * The Content Creation tracker reader.
3. *
4. * This source is different in kind from the other four: it is a spreadsheet a
5. * person types into, not a system of record. So the failures worth testing are
6. * not API failures; they are the things humans do to spreadsheets. Every case
7. * below was observed in the live sheet. The cell contents here
8. * are invented stand-ins with the same shape.
9. */
11. import { describe, expect, it } from 'vitest'
12. import { parseCsv, parseTab, splitOwners, tabCsvUrl, fetchTracker } from '../src/index.js'
14. describe('parseCsv survives what people put in cells', () => {
15. it('keeps a newline inside a quoted cell as one cell', () => {
16. // A row shaped like "Refresh the vinyl banner gallery images\nRecrop the
17. // hero image...". Splitting on \n first makes that two rows, the second
18. // with no owner, so it lands in unowned work and somebody goes hunting for
19. // who dropped it.
20. const rows = parseCsv('"a\nb","c"\n"d","e"\n')
21. expect(rows).toEqual([
22. ['a\nb', 'c'],
23. ['d', 'e'],
24. ])
25. })
27. it('keeps a comma inside a quoted cell', () => {
28. // "Refresh the vinyl banner gallery images, recrop the hero image..."
29. expect(parseCsv('"x, y","z"')).toEqual([['x, y', 'z']])
30. })
32. it('unescapes a doubled quote', () => {
33. // A title like 'New wall art - "Built to Last"' carries quotes of its own.
34. expect(parseCsv('"he said ""hi""",b')).toEqual([['he said "hi"', 'b']])
35. })
37. it('treats CRLF as one row break, not two', () => {
38. expect(parseCsv('a,b\r\nc,d')).toEqual([
39. ['a', 'b'],
40. ['c', 'd'],
41. ])
42. })
44. it('keeps a last row with no trailing newline', () => {
45. expect(parseCsv('a,b\nc,d')).toHaveLength(2)
46. })
48. it('strips a BOM rather than corrupting the first header', () => {
49. expect(parseCsv('Owner,Task')[0]![0]).toBe('Owner')
50. })
51. })
53. describe('splitOwners', () => {
54. it('splits a shared row into both people', () => {
55. // "Nora & Sam": one photoshoot, two people who have to show up.
56. expect(splitOwners('Nora & Sam')).toEqual(['Nora', 'Sam'])
57. })
59. it('handles the other separators a human might type', () => {
60. expect(splitOwners('Marco and Ines')).toEqual(['Marco', 'Ines'])
61. expect(splitOwners('Marco, Ines')).toEqual(['Marco', 'Ines'])
62. expect(splitOwners('Marco / Ines')).toEqual(['Marco', 'Ines'])
63. })
65. it('returns nothing for an empty cell rather than one blank owner', () => {
66. expect(splitOwners(' ')).toEqual([])
67. })
68. })
70. const TAB = [
71. 'Release Date,Deadline,Complete Date,Priority,Owner,Priority,sku,Task,Notes/Links/Resources,Location to Upload Files,Points,Status,Completed',
72. ',,,,Rafael,,TT10,10x10 canopy tent photos,see supplier page,,12,In Progress,FALSE',
73. ',,,,Nora & Sam,,,Studio photoshoot,,,,In Progress,FALSE',
74. ',,,,Marco,,,Blank status row,,,,,FALSE',
75. ',,,,,,,,,,,,FALSE',
76. ',,,,,,,,,,,,FALSE',
77. ].join('\n')
79. describe('parseTab', () => {
80. it('reads the rows that are work and skips the padding', () => {
81. // The tabs are padded with dozens of blank rows carrying only a trailing
82. // FALSE, which is what a spreadsheet looks like after someone dragged a
83. // checkbox down a column. Counting those would put phantom rows on the board.
84. const out = parseTab(TAB, 'Images', '0')
85. expect(out).toHaveLength(3)
86. expect(out.map((t) => t.title)).toEqual([
87. '10x10 canopy tent photos',
88. 'Studio photoshoot',
89. 'Blank status row',
90. ])
91. })
93. it('carries a blank Status through as blank rather than inventing one', () => {
94. // The classifier decides what blank MEANS. The reader's job is not to guess
95. // on its behalf.
96. expect(parseTab(TAB, 'Images', '0')[2]!.status).toBe('')
97. })
99. it('marks a two-owner row shared and keeps both names', () => {
100. const shared = parseTab(TAB, 'Images', '0')[1]!
101. expect(shared.owners).toEqual(['Nora', 'Sam'])
102. expect(shared.shared).toBe(true)
103. })
105. it('finds the header even when Google drops leading empty header cells', () => {
106. // gviz omits blank leading header cells, so a tab whose first columns are
107. // dated arrives with '' where 'Release Date' should be. Trusting row 0
108. // position would read the whole tab off by several columns.
109. const shifted = TAB.replace(
110. 'Release Date,Deadline,Complete Date,Priority,Owner',
111. ',,,,Owner',
112. )
113. expect(parseTab(shifted, 'Images', '0')).toHaveLength(3)
114. })
116. it('returns nothing for a tab with no Owner/Task columns', () => {
117. // The Resources tab is image dimensions; the product matrix is per-SKU
118. // checkboxes. Neither is assignable work, and inventing rows from whatever
119. // the first columns happened to be would attribute them to nobody.
120. expect(parseTab('Image,Sizes,Sizes 2\nCategory header,756x376,', 'Resources', '1')).toEqual([])
121. })
123. it('keeps a deadline as typed instead of parsing it', () => {
124. // The live sheet mixes 08/19/26, 08/19/2026 and 8/21/2026. Guessing a year
125. // from a two-digit one is how you report something overdue that is not.
126. const csv = 'Owner,Task,Deadline,Status\nMarco,A thing,8/21/26,In Progress'
127. expect(parseTab(csv, 'Images', '0')[0]!.deadline).toBe('8/21/26')
128. })
130. it('gives every row an id stable within a sync', () => {
131. // The sheet has no ids of its own, so tab+row is the only handle there is.
132. const out = parseTab(TAB, 'Images', '0')
133. expect(new Set(out.map((t) => t.id)).size).toBe(out.length)
134. })
135. })
137. describe('fetchTracker', () => {
138. const ok = (body: string) => new Response(body, { status: 200 })
140. it('reports a failed tab instead of losing the whole read', () => {
141. // Three tabs of four is most of the picture. Throwing away all of it because
142. // one tab was renamed is the worse outcome; the caller says "partial".
143. return fetchTracker(
144. 'sheet1',
145. [
146. { gid: '0', label: 'Images' },
147. { gid: '9', label: 'Gone' },
148. ],
149. (async (url: string) =>
150. String(url).includes('gid=9') ? new Response('nope', { status: 404 }) : ok(TAB)) as typeof fetch,
151. ).then((r) => {
152. expect(r.tasks).toHaveLength(3)
153. expect(r.tabs.map((t) => t.label)).toEqual(['Images'])
154. expect(r.failedTabs).toEqual([{ gid: '9', label: 'Gone', reason: 'HTTP 404' }])
155. })
156. })
158. it('names link-sharing as the cause of a 403, because that is observable', () => {
159. // The source is read from a PUBLIC csv export. A 403 means that sharing was
160. // tightened, which is the one cause a reader can act on, and it comes from
161. // the status code rather than from a guess (rule 1 in docs/ARCHITECTURE.md).
162. return fetchTracker(
163. 'sheet1',
164. [{ gid: '0', label: 'Images' }],
165. (async () => new Response('', { status: 403 })) as typeof fetch,
166. ).then((r) => {
167. expect(r.failedTabs[0]!.reason).toContain('403')
168. expect(r.failedTabs[0]!.reason).toMatch(/readable by link/i)
169. expect(r.tasks).toEqual([])
170. })
171. })
173. it('survives a thrown fetch the same way as a bad status', () => {
174. return fetchTracker(
175. 'sheet1',
176. [{ gid: '0', label: 'Images' }],
177. (async () => {
178. throw new Error('network down')
179. }) as typeof fetch,
180. ).then((r) => {
181. expect(r.failedTabs[0]!.reason).toBe('network down')
182. })
183. })
185. it('builds a URL that needs no credential', () => {
186. const url = tabCsvUrl('abc', '123')
187. expect(url).toContain('/gviz/tq')
188. expect(url).toContain('gid=123')
189. expect(url).not.toMatch(/key=|token=|access/i)
190. })
191. })