Skip to content

Commit ff4732e

Browse files
baelterbaelter
committed
style: format amqp-session tests
1 parent 018b93b commit ff4732e

1 file changed

Lines changed: 121 additions & 100 deletions

File tree

‎test/amqp-session.ts‎

Lines changed: 121 additions & 100 deletions
Original file line numberDiff line numberDiff line change
@@ -28,9 +28,12 @@ async function withSession(
2828
}
2929

3030
test("AMQPSession.connect() returns a session", () =>
31-
withSession(async (session) => {
32-
expect(session).toBeInstanceOf(AMQPSession)
33-
}, { reconnectInterval: 500 }))
31+
withSession(
32+
async (session) => {
33+
expect(session).toBeInstanceOf(AMQPSession)
34+
},
35+
{ reconnectInterval: 500 },
36+
))
3437

3538
test("session.subscribe delivers messages via callback", () =>
3639
withSession(async (session) => {
@@ -112,107 +115,122 @@ test("session.subscribe yields messages via async generator", () =>
112115
}))
113116

114117
test("session.onfailed fires when maxRetries exhausted", () =>
115-
withSession(async (session) => {
116-
const onfailed = vi.fn()
117-
session.onfailed = onfailed
118+
withSession(
119+
async (session) => {
120+
const onfailed = vi.fn()
121+
session.onfailed = onfailed
118122

119-
const client = testClient(session)
120-
const connectSpy = vi.spyOn(client, "connect").mockRejectedValue(new Error("forced failure"))
123+
const client = testClient(session)
124+
const connectSpy = vi.spyOn(client, "connect").mockRejectedValue(new Error("forced failure"))
121125

122-
;(client as AMQPClient).socket?.destroy()
126+
;(client as AMQPClient).socket?.destroy()
123127

124-
// Wait long enough for 2 retries + backoff (50ms + 100ms) with buffer
125-
await new Promise((resolve) => setTimeout(resolve, 500))
128+
// Wait long enough for 2 retries + backoff (50ms + 100ms) with buffer
129+
await new Promise((resolve) => setTimeout(resolve, 500))
126130

127-
expect(onfailed).toHaveBeenCalledTimes(1)
128-
expect(onfailed.mock.calls[0]?.[0]).toBeInstanceOf(Error)
129-
expect(connectSpy).toHaveBeenCalledTimes(2)
131+
expect(onfailed).toHaveBeenCalledTimes(1)
132+
expect(onfailed.mock.calls[0]?.[0]).toBeInstanceOf(Error)
133+
expect(connectSpy).toHaveBeenCalledTimes(2)
130134

131-
connectSpy.mockRestore()
132-
}, { reconnectInterval: 50, maxRetries: 2 }))
135+
connectSpy.mockRestore()
136+
},
137+
{ reconnectInterval: 50, maxRetries: 2 },
138+
))
133139

134140
test("session.onconnect fires after successful reconnection", () =>
135-
withSession(async (session) => {
136-
let reconnectCount = 0
137-
const reconnected = new Promise<void>((resolve, reject) => {
138-
const timeout = setTimeout(() => reject(new Error("onconnect did not fire within 5s")), 5_000)
139-
session.onconnect = () => {
140-
clearTimeout(timeout)
141-
reconnectCount++
142-
resolve()
143-
}
144-
})
141+
withSession(
142+
async (session) => {
143+
let reconnectCount = 0
144+
const reconnected = new Promise<void>((resolve, reject) => {
145+
const timeout = setTimeout(() => reject(new Error("onconnect did not fire within 5s")), 5_000)
146+
session.onconnect = () => {
147+
clearTimeout(timeout)
148+
reconnectCount++
149+
resolve()
150+
}
151+
})
145152

146-
;(testClient(session) as AMQPClient).socket?.destroy()
153+
;(testClient(session) as AMQPClient).socket?.destroy()
147154

148-
await reconnected
149-
expect(reconnectCount).toBe(1)
150-
}, { reconnectInterval: 50, maxRetries: 5 }))
155+
await reconnected
156+
expect(reconnectCount).toBe(1)
157+
},
158+
{ reconnectInterval: 50, maxRetries: 5 },
159+
))
151160

152161
test("subscription recovers and receives messages after reconnection", () =>
153-
withSession(async (session) => {
154-
const q = await session.queue("test-recovery-" + Math.random(), { durable: false, autoDelete: false })
162+
withSession(
163+
async (session) => {
164+
const q = await session.queue("test-recovery-" + Math.random(), { durable: false, autoDelete: false })
155165

156-
const received: string[] = []
157-
const sub = await q.subscribe({ noAck: true }, (msg) => {
158-
received.push(msg.bodyString() || "")
159-
})
166+
const received: string[] = []
167+
const sub = await q.subscribe({ noAck: true }, (msg) => {
168+
received.push(msg.bodyString() || "")
169+
})
160170

161-
// Publish a message before disconnect
162-
await q.publish("before-disconnect", { confirm: false })
163-
await new Promise((resolve) => setTimeout(resolve, 100))
171+
// Publish a message before disconnect
172+
await q.publish("before-disconnect", { confirm: false })
173+
await new Promise((resolve) => setTimeout(resolve, 100))
164174

165-
const reconnected = new Promise<void>((resolve, reject) => {
166-
const timeout = setTimeout(() => reject(new Error("Reconnection timed out")), 10_000)
167-
session.onconnect = () => {
168-
clearTimeout(timeout)
169-
resolve()
170-
}
171-
})
175+
const reconnected = new Promise<void>((resolve, reject) => {
176+
const timeout = setTimeout(() => reject(new Error("Reconnection timed out")), 10_000)
177+
session.onconnect = () => {
178+
clearTimeout(timeout)
179+
resolve()
180+
}
181+
})
172182

173-
;(testClient(session) as AMQPClient).socket?.destroy()
183+
;(testClient(session) as AMQPClient).socket?.destroy()
174184

175-
await reconnected
185+
await reconnected
176186

177-
// Publish a message after reconnection
178-
await q.publish("after-reconnect", { confirm: false })
179-
await new Promise((resolve) => setTimeout(resolve, 200))
187+
// Publish a message after reconnection
188+
await q.publish("after-reconnect", { confirm: false })
189+
await new Promise((resolve) => setTimeout(resolve, 200))
180190

181-
expect(received).toContain("before-disconnect")
182-
expect(received).toContain("after-reconnect")
191+
expect(received).toContain("before-disconnect")
192+
expect(received).toContain("after-reconnect")
183193

184-
// Verify the subscription object is the same reference and channel is live
185-
expect(sub.channel.closed).toBe(false)
194+
// Verify the subscription object is the same reference and channel is live
195+
expect(sub.channel.closed).toBe(false)
186196

187-
await sub.cancel()
188-
await q.delete()
189-
}, { reconnectInterval: 50, maxRetries: 5 }))
197+
await sub.cancel()
198+
await q.delete()
199+
},
200+
{ reconnectInterval: 50, maxRetries: 5 },
201+
))
190202

191203
test("session.stop() during reconnection stops the loop", () =>
192-
withSession(async (session) => {
193-
const client = testClient(session)
194-
const connectSpy = vi.spyOn(client, "connect").mockRejectedValue(new Error("forced failure"))
204+
withSession(
205+
async (session) => {
206+
const client = testClient(session)
207+
const connectSpy = vi.spyOn(client, "connect").mockRejectedValue(new Error("forced failure"))
195208

196-
;(client as AMQPClient).socket?.destroy()
209+
;(client as AMQPClient).socket?.destroy()
197210

198-
// Stop before the first reconnection attempt fires
199-
await new Promise((resolve) => setTimeout(resolve, 50))
200-
await session.stop()
211+
// Stop before the first reconnection attempt fires
212+
await new Promise((resolve) => setTimeout(resolve, 50))
213+
await session.stop()
201214

202-
// Confirm no further reconnection attempts
203-
await new Promise((resolve) => setTimeout(resolve, 500))
215+
// Confirm no further reconnection attempts
216+
await new Promise((resolve) => setTimeout(resolve, 500))
204217

205-
expect(connectSpy.mock.calls.length).toBeLessThanOrEqual(1)
206-
connectSpy.mockRestore()
207-
}, { reconnectInterval: 200, maxRetries: 10 }))
218+
expect(connectSpy.mock.calls.length).toBeLessThanOrEqual(1)
219+
connectSpy.mockRestore()
220+
},
221+
{ reconnectInterval: 200, maxRetries: 10 },
222+
))
208223

209224
test("session.stop() when already disconnected does not throw", () =>
210-
withSession(async (session) => {
211-
;(testClient(session) as AMQPClient).socket?.destroy()
212-
await new Promise((resolve) => setTimeout(resolve, 50))
225+
withSession(
226+
async (session) => {
227+
;(testClient(session) as AMQPClient).socket?.destroy()
228+
await new Promise((resolve) => setTimeout(resolve, 50))
213229

214-
await expect(session.stop()).resolves.toBeUndefined()
215-
}, { maxRetries: 1 }))
230+
await expect(session.stop()).resolves.toBeUndefined()
231+
},
232+
{ maxRetries: 1 },
233+
))
216234

217235
test("session.queue() declares a queue and returns AMQPQueue", () =>
218236
withSession(async (session) => {
@@ -231,38 +249,41 @@ test("AMQPQueue (session-backed).publish() and get() round-trip", () =>
231249
}))
232250

233251
test("AMQPQueue (session-backed).subscribe() recovers after reconnect", () =>
234-
withSession(async (session) => {
235-
const qName = "test-sq-recovery-" + Math.random()
252+
withSession(
253+
async (session) => {
254+
const qName = "test-sq-recovery-" + Math.random()
236255

237-
const q = await session.queue(qName, { durable: false, autoDelete: false })
256+
const q = await session.queue(qName, { durable: false, autoDelete: false })
238257

239-
const received: string[] = []
240-
const sub = await q.subscribe({ noAck: true }, (msg) => {
241-
received.push(msg.bodyString() ?? "")
242-
})
258+
const received: string[] = []
259+
const sub = await q.subscribe({ noAck: true }, (msg) => {
260+
received.push(msg.bodyString() ?? "")
261+
})
243262

244-
await q.publish("before-disconnect")
245-
await new Promise((resolve) => setTimeout(resolve, 100))
263+
await q.publish("before-disconnect")
264+
await new Promise((resolve) => setTimeout(resolve, 100))
246265

247-
const reconnected = new Promise<void>((resolve, reject) => {
248-
const t = setTimeout(() => reject(new Error("reconnect timed out")), 10_000)
249-
session.onconnect = () => {
250-
clearTimeout(t)
251-
resolve()
252-
}
253-
})
254-
;(testClient(session) as AMQPClient).socket?.destroy()
255-
await reconnected
266+
const reconnected = new Promise<void>((resolve, reject) => {
267+
const t = setTimeout(() => reject(new Error("reconnect timed out")), 10_000)
268+
session.onconnect = () => {
269+
clearTimeout(t)
270+
resolve()
271+
}
272+
})
273+
;(testClient(session) as AMQPClient).socket?.destroy()
274+
await reconnected
256275

257-
await q.publish("after-reconnect")
258-
await new Promise((resolve) => setTimeout(resolve, 200))
276+
await q.publish("after-reconnect")
277+
await new Promise((resolve) => setTimeout(resolve, 200))
259278

260-
expect(received).toContain("before-disconnect")
261-
expect(received).toContain("after-reconnect")
279+
expect(received).toContain("before-disconnect")
280+
expect(received).toContain("after-reconnect")
262281

263-
await sub.cancel()
264-
await q.delete()
265-
}, { reconnectInterval: 50, maxRetries: 5 }))
282+
await sub.cancel()
283+
await q.delete()
284+
},
285+
{ reconnectInterval: 50, maxRetries: 5 },
286+
))
266287

267288
test("session.exchange() declares an exchange and returns AMQPExchange", () =>
268289
withSession(async (session) => {

0 commit comments

Comments
 (0)