http.test.ts

packages/ninety-client/test/http.test.ts

1. import { describe, expect, it, vi } from 'vitest'
2. import { HttpClient } from '../src/http.js'
3. import { NinetyAuthError, NinetyForbiddenError, NinetyRateLimitError, NinetyError } from '../src/errors.js'
5. const json = (body: unknown, status = 200, headers: Record<string, string> = {}) =>
6. new Response(JSON.stringify(body), { status, headers: { 'Content-Type': 'application/json', ...headers } })
8. function make(fetchImpl: typeof fetch, opts: Partial<ConstructorParameters<typeof HttpClient>[0]> = {}) {
9. return new HttpClient({
10. token: 'test-token',
11. fetchImpl,
12. sleep: async () => {}, // no real waiting in tests
13. rps: 1000,
14. ...opts,
15. })
16. }
18. describe('HttpClient', () => {
19. it('sends the bearer token', async () => {
20. const fetchImpl = vi.fn(async (_url: string | URL | Request, init?: RequestInit) => {
21. expect((init?.headers as Record<string, string>).Authorization).toBe('Bearer test-token')
22. return json({ ok: true })
23. }) as unknown as typeof fetch
24. await make(fetchImpl).get('/teams')
25. expect(fetchImpl).toHaveBeenCalledOnce()
26. })
28. it('POSTs a JSON body to the query endpoints', async () => {
29. const fetchImpl = vi.fn(async (_u: string | URL | Request, init?: RequestInit) => {
30. expect(init?.method).toBe('POST')
31. expect(JSON.parse(String(init?.body))).toEqual({ page: 1 })
32. return json([])
33. }) as unknown as typeof fetch
34. await make(fetchImpl).post('/todos/query', { body: { page: 1 } })
35. })
37. it('retries a 429 and then succeeds', async () => {
38. let calls = 0
39. const fetchImpl = (async () => {
40. calls++
41. return calls < 3 ? json({ msg: 'slow down' }, 429) : json({ ok: true })
42. }) as unknown as typeof fetch
43. const out = await make(fetchImpl).get('/teams')
44. expect(out).toEqual({ ok: true })
45. expect(calls).toBe(3)
46. })
48. it('throws NinetyRateLimitError once retries are exhausted', async () => {
49. const fetchImpl = (async () => json({}, 429)) as unknown as typeof fetch
50. await expect(make(fetchImpl, { maxRetries: 1 }).get('/teams')).rejects.toBeInstanceOf(NinetyRateLimitError)
51. })
53. it('retries 5xx but not 400', async () => {
54. let calls = 0
55. const server = (async () => {
56. calls++
57. return json({}, 503)
58. }) as unknown as typeof fetch
59. await expect(make(server, { maxRetries: 2 }).get('/teams')).rejects.toBeInstanceOf(NinetyError)
60. expect(calls).toBe(3)
62. let badCalls = 0
63. const bad = (async () => {
64. badCalls++
65. return json({}, 400)
66. }) as unknown as typeof fetch
67. await expect(make(bad).get('/teams')).rejects.toBeInstanceOf(NinetyError)
68. expect(badCalls).toBe(1)
69. })
71. it('maps 401 to an actionable message that does NOT guess a cause', async () => {
72. // A 401 says rejected. The cause is not in the response, and asserting a
73. // diagnosis such as "expired" would write a guess down as a requirement;
74. // regenerating a token on that guess invalidates a working credential.
75. const fetchImpl = (async () => json({}, 401)) as unknown as typeof fetch
76. await expect(make(fetchImpl).get('/teams')).rejects.toBeInstanceOf(NinetyAuthError)
78. let message = ''
79. try {
80. await make(fetchImpl).get('/teams')
81. } catch (err) {
82. message = err instanceof Error ? err.message : String(err)
83. }
85. // Actionable: names the variable, and orders the checks.
86. expect(message).toContain('NINETY_TOKEN')
87. expect(message).toMatch(/does not say why/i)
88. // And it must not present any single cause as the likely one.
89. expect(message).not.toMatch(/most likely|probably|has expired\b/i)
90. })
92. it('maps 403 to a plan/Observer message', async () => {
93. const fetchImpl = (async () => json({}, 403)) as unknown as typeof fetch
94. await expect(make(fetchImpl).get('/teams')).rejects.toThrow(/Observer/)
95. })
97. it('names the endpoint and page in the error', async () => {
98. const fetchImpl = (async () => json({}, 400)) as unknown as typeof fetch
99. await expect(make(fetchImpl).post('/todos/query', { pageIndex: 7 })).rejects.toThrow(
100. /POST \/todos\/query \(page 7\)/,
101. )
102. })
104. it('refuses to construct without a token', () => {
105. expect(() => new HttpClient({ token: '' })).toThrow(/NINETY_TOKEN/)
106. })
107. })
109. /**
110. * A failure must not explain itself with a status it did not get.
111. *
112. * A 403's explanation ("/todos/company is restricted to company Owners and
113. * Admins") appended to every Ninety failure would sit beside a 429 and send
114. * somebody to check a role while a rate limit cleared itself (rule 1). The
115. * endpoint-specific note lives in the 403, where the status and the path are
116. * both known, and the callers append nothing.
117. */
118. describe('errors explain only what happened', () => {
119. const ctx = (endpoint: string) => ({ endpoint })
121. it('does not mention 403 or roles when the failure was a rate limit', () => {
122. const err = new NinetyRateLimitError(ctx('GET /todos/company'), 1000)
123. expect(err.status).toBe(429)
124. expect(err.message).not.toMatch(/403/)
125. expect(err.message).not.toMatch(/owner|admin|role/i)
126. })
128. it('carries the endpoint-specific role note on a 403 that hit that endpoint', () => {
129. const err = new NinetyForbiddenError(ctx('GET /todos/company'))
130. expect(err.status).toBe(403)
131. expect(err.message).toMatch(/owners and admins/i)
132. })
134. it('leaves it off a 403 that hit some other endpoint', () => {
135. // The restriction is a fact about /todos/company, not about Ninety.
136. const err = new NinetyForbiddenError(ctx('GET /teams'))
137. expect(err.message).not.toMatch(/owners and admins/i)
138. // The part that IS true of every 403 stays.
139. expect(err.message).toMatch(/observer/i)
140. })
142. it('an auth failure lists candidate causes rather than picking one', () => {
143. // The message must not assert which cause it is, and must leave retrying on
144. // the table.
145. const err = new NinetyAuthError(ctx('GET /todos/company'))
146. expect(err.message).not.toMatch(/most likely|probably|has expired\b/i)
147. expect(err.message).toMatch(/transient/i)
148. })
149. })