assignment-fields.test.ts

packages/plinth-client/test/assignment-fields.test.ts

1. /**
2. * Plinth sends `production_owner` and `account_owner` on the orders.fetch
3. * response, at order level and per product line.
4. *
5. * These tests pin the three decisions that make that path safe:
6. *
7. * 1. `--` is not a person. Treated as one, the board grows "a designer named
8. * -- holding dozens of order lines".
9. * 2. A per-line value beats the order-level one, including when the per-line
10. * value is the sentinel. Assignment in Plinth is per product line; an order
11. * naming someone does not make each of its lines theirs.
12. * 3. Presence is counted, not assumed. A field that arrived by vendor change
13. * can leave the same way, and a vanished field makes every line read
14. * unassigned, indistinguishable from a team with nothing to do unless
15. * somebody counted.
16. */
18. import { describe, expect, it } from 'vitest'
19. import { OrdersResource } from '../src/resources/orders.js'
20. import type { PlinthClient } from '../src/http.js'
22. interface Assign {
23. /** Omit a key entirely to model Plinth not sending it; it does that per record. */
24. production_owner?: string
25. account_owner?: string
26. }
28. /** One order carrying `lines` product rows, with assignment fields where given. */
29. function order(id: number, lines: number, product: Assign = {}, orderLevel: Assign = {}) {
30. const products: Record<string, unknown> = {}
31. for (let i = 0; i < lines; i++) {
32. products[String(i)] = {
33. line_ref: id * 100 + i,
34. item_ref: 1,
35. item_name: 'Mesh Banner',
36. qty: 1,
37. unit_price: '10.00',
38. line_status: 'Delivered',
39. ...product,
40. }
41. }
42. return {
43. order_ref: id,
44. status_label: 'Delivered',
45. status_code: 189,
46. closed_on: '2026-07-01 10:00:00',
47. first_name: 'A',
48. last_name: 'B',
49. grand_total: '10.00',
50. lines: products,
51. ...orderLevel,
52. }
53. }
55. function page(orders: ReturnType<typeof order>[]) {
56. const order_map: Record<string, unknown> = {}
57. for (const o of orders) order_map[String(o.order_ref)] = o
58. return { order_map }
59. }
61. function fake(pages: unknown[]) {
62. const calls: Record<string, unknown>[] = []
63. const client = {
64. async call(_m: string, params: Record<string, unknown>) {
65. calls.push(params)
66. return pages[calls.length - 1] ?? { order_map: {} }
67. },
68. } as unknown as PlinthClient
69. return { client, calls }
70. }
72. const fetchLines = async (pages: unknown[]) => {
73. const { client } = fake(pages)
74. return new OrdersResource(client).linesInWindow('2026-07-01', '2026-07-31')
75. }
77. describe('the unassigned sentinel never becomes a person', () => {
78. // A truthiness check would turn `--` into a designer with dozens of order
79. // lines. "Nobody holds this" and
80. // "somebody called -- holds this" lead to opposite actions.
81. it.each(['--', '---', '-', '', ' ', 'N/A', 'none'])(
82. 'reads %j as nobody',
83. async (sentinel) => {
84. const w = await fetchLines([page([order(1, 1, { production_owner: sentinel })])])
85. expect(w.lines[0]!.productionOwner).toBeNull()
86. },
87. )
89. it('does the same for the client success field', async () => {
90. const w = await fetchLines([page([order(1, 1, { account_owner: '--' })])])
91. expect(w.lines[0]!.accountOwner).toBeNull()
92. })
93. })
95. describe('account labels pass through unmapped', () => {
96. it('leaves the raw Plinth label alone', async () => {
97. // Mapping label -> roster name is collect.ts's job, the same division of
98. // labour the CSV parser had. A client package has no roster.
99. const w = await fetchLines([
100. page([
101. order(1, 1, {
102. production_owner: 'Marco-Acct7-Desk',
103. account_owner: 'Hazel (Desk 2)',
104. }),
105. ]),
106. ])
107. expect(w.lines[0]!.productionOwner).toBe('Marco-Acct7-Desk')
108. expect(w.lines[0]!.accountOwner).toBe('Hazel (Desk 2)')
109. })
110. })
112. describe('per-line assignment beats the order level', () => {
113. it('falls back to the order value when the product record lacks the key', async () => {
114. const w = await fetchLines([
115. page([order(1, 2, {}, { production_owner: 'Sam-Accounts-Desk' })]),
116. ])
117. expect(w.lines.map((l) => l.productionOwner)).toEqual([
118. 'Sam-Accounts-Desk',
119. 'Sam-Accounts-Desk',
120. ])
121. })
123. it('keeps a per-line sentinel even when the order names somebody', async () => {
124. // The more specific source wins. An order assigned to Sam can still hold a
125. // line nobody has picked up, and crediting it to him would overstate his load
126. // and hide the line from whoever should claim it.
127. const w = await fetchLines([
128. page([order(1, 1, { production_owner: '--' }, { production_owner: 'Sam-Accounts-Desk' })]),
129. ])
130. expect(w.lines[0]!.productionOwner).toBeNull()
131. })
133. it('prefers the per-line name over a different order-level name', async () => {
134. const w = await fetchLines([
135. page([
136. order(
137. 1,
138. 1,
139. { production_owner: 'Marco-Acct7-Desk' },
140. { production_owner: 'Rafael-Prod-Desk' },
141. ),
142. ]),
143. ])
144. expect(w.lines[0]!.productionOwner).toBe('Marco-Acct7-Desk')
145. })
146. })
148. describe('field coverage is counted, not assumed', () => {
149. it('reports full coverage when every line carries both fields', async () => {
150. const w = await fetchLines([
151. page([
152. order(1, 2, { production_owner: 'Marco-Acct7-Desk', account_owner: '--' }),
153. order(2, 1, { production_owner: '--', account_owner: 'Sam-Accounts-Desk' }),
154. ]),
155. ])
156. // Presence, not value: `--` is a present field saying "nobody", which is a
157. // different fact from Plinth not sending the field at all.
158. expect(w.assignmentFields).toEqual({ production: 3, accountOwner: 3, total: 3 })
159. })
161. it('reports zero coverage with a non-zero total when the fields are absent', async () => {
162. // The regression that matters. Zero here must be distinguishable from "three
163. // lines, nobody assigned"; the caller turns it into MISSING, not free time.
164. const w = await fetchLines([page([order(1, 3)])])
165. expect(w.assignmentFields).toEqual({ production: 0, accountOwner: 0, total: 3 })
166. })
168. it('counts an order-level field as covering each of its lines', async () => {
169. const w = await fetchLines([
170. page([order(1, 3, {}, { production_owner: 'Sam-Accounts-Desk' })]),
171. ])
172. expect(w.assignmentFields.production).toBe(3)
173. expect(w.assignmentFields.accountOwner).toBe(0)
174. })
176. it('counts partial coverage across a mixed window', async () => {
177. const w = await fetchLines([
178. page([
179. order(1, 2, { production_owner: 'Marco-Acct7-Desk' }),
180. order(2, 2),
181. ]),
182. ])
183. expect(w.assignmentFields).toEqual({ production: 2, accountOwner: 0, total: 4 })
184. })
186. it('accumulates across pages rather than reporting only the last one', async () => {
187. // 5 lines per page is the short-page signal at this limit, so both pages are
188. // fetched; coverage has to survive the loop.
189. const wide = Array.from({ length: 100 }, (_, i) =>
190. order(i + 1, 5, { production_owner: 'Marco-Acct7-Desk' }),
191. )
192. const w = await fetchLines([page(wide), page([order(999, 2)])])
193. expect(w.assignmentFields.total).toBe(502)
194. expect(w.assignmentFields.production).toBe(500)
195. })
197. it('reports an empty window as zero of zero, which says nothing either way', async () => {
198. const w = await fetchLines([{ order_map: {} }])
199. expect(w.assignmentFields).toEqual({ production: 0, accountOwner: 0, total: 0 })
200. })
201. })