Skip to content

Commit 2a76eb3

Browse files
NerivecNerivec
committed
Fix & cleanup tests.
1 parent 2b980fd commit 2a76eb3

File tree

1 file changed

+37
-183
lines changed

1 file changed

+37
-183
lines changed

‎test/adapter/ember/requestQueue.test.ts

+37-183
Original file line numberDiff line numberDiff line change
@@ -64,13 +64,14 @@ describe('Ember Request Queue', () => {
6464

6565
beforeEach(() => {
6666
requestQueue = new EmberRequestQueue(60);
67-
// don't let defer (dispatching tick mgmt) interfere with "manual" flow of tests unless wanted
68-
deferSpy = jest.spyOn(requestQueue, 'defer').mockImplementation(jest.fn());
67+
//@ts-expect-error private
68+
deferSpy = jest.spyOn(requestQueue, 'defer');
6969
});
7070

7171
afterEach(() => {
7272
fakeWaitTime = 1000;
7373
varyingReturn = EmberStatus.SUCCESS;
74+
requestQueue.stopDispatching();
7475
});
7576

7677
it('Queues request and resolves it', async () => {
@@ -102,9 +103,9 @@ describe('Ember Request Queue', () => {
102103
//@ts-expect-error private
103104
expect(requestQueue.queue).toHaveLength(1);
104105

105-
requestQueue.dispatch();// don't await so we can advance timer
106+
requestQueue.startDispatching();
106107

107-
jest.advanceTimersByTime(fakeWaitTime + 100);
108+
await jest.advanceTimersByTimeAsync(fakeWaitTime + 20);
108109

109110
await expect(p).resolves.toBe(123);// gives result of resolve
110111

@@ -113,6 +114,7 @@ describe('Ember Request Queue', () => {
113114
//@ts-expect-error private
114115
expect(requestQueue.queue).toHaveLength(0);// no longer in queue
115116
});
117+
116118
it('Queues request, rejects it on error, and removes it from queue', async () => {
117119
const enqueueSpy = jest.spyOn(requestQueue, 'enqueue');
118120

@@ -142,9 +144,9 @@ describe('Ember Request Queue', () => {
142144
//@ts-expect-error private
143145
expect(requestQueue.queue).toHaveLength(1);
144146

145-
requestQueue.dispatch();// don't await so we can advance timer
147+
requestQueue.startDispatching();
146148

147-
jest.advanceTimersByTime(fakeWaitTime + 100);
149+
jest.advanceTimersByTime(fakeWaitTime + 20);
148150

149151
await expect(p).rejects.toStrictEqual(new Error(EmberStatus[varyingReturn]));
150152

@@ -153,6 +155,7 @@ describe('Ember Request Queue', () => {
153155
//@ts-expect-error private
154156
expect(requestQueue.queue).toHaveLength(0);// no longer in queue
155157
});
158+
156159
it('Queues request, rejects it on throw, and removes it from queue', async () => {
157160
const enqueueSpy = jest.spyOn(requestQueue, 'enqueue');
158161

@@ -181,17 +184,17 @@ describe('Ember Request Queue', () => {
181184
//@ts-expect-error private
182185
expect(requestQueue.queue).toHaveLength(1);
183186

184-
requestQueue.dispatch();// don't await so we can advance timer
185-
186-
jest.advanceTimersByTime(fakeWaitTime + 100);
187+
requestQueue.startDispatching();
187188

189+
jest.advanceTimersByTime(fakeWaitTime + 20);
188190
await expect(p).rejects.toStrictEqual(new Error(EzspStatus[EzspStatus.ASH_ACK_TIMEOUT]));
189191

190192
expect(funcSpy).toHaveBeenCalledTimes(1);
191193
expect(funcRejectSpy).toHaveBeenCalledTimes(1);
192194
//@ts-expect-error private
193195
expect(requestQueue.queue).toHaveLength(0);// no longer in queue
194196
});
197+
195198
it('Queues request, defers on NETWORK_BUSY and defers again on NETWORK_DOWN', async () => {
196199
const enqueueSpy = jest.spyOn(requestQueue, 'enqueue');
197200

@@ -220,30 +223,29 @@ describe('Ember Request Queue', () => {
220223
expect(requestQueue.queue).toHaveLength(1);// enqueued
221224

222225

223-
requestQueue.dispatch();// don't await so we can advance timer
226+
requestQueue.startDispatching();
224227

225-
await jest.advanceTimersByTimeAsync(fakeWaitTime + 100 + (NETWORK_BUSY_DEFER_MSEC * 0.25));
228+
await jest.advanceTimersByTimeAsync(fakeWaitTime + 20 + (NETWORK_BUSY_DEFER_MSEC * 0.25));
226229

227230
expect(deferSpy).toHaveBeenCalledTimes(1);
228231
expect(funcSpy).toHaveBeenCalledTimes(1);
229232
//@ts-expect-error private
230233
expect(requestQueue.queue).toHaveLength(1);// still in queue
231234

232-
await jest.advanceTimersByTimeAsync(NETWORK_BUSY_DEFER_MSEC + 100);
235+
await jest.advanceTimersByTimeAsync(NETWORK_BUSY_DEFER_MSEC + 20);
233236

234237
varyingReturn = EmberStatus.NETWORK_DOWN;
235238

236-
requestQueue.dispatch();// don't await so we can advance timer
237-
238-
await jest.advanceTimersByTimeAsync(fakeWaitTime + 100 + (NETWORK_DOWN_DEFER_MSEC * 0.25));
239+
await jest.advanceTimersByTimeAsync(fakeWaitTime + 20 + (NETWORK_DOWN_DEFER_MSEC * 0.25));
239240

240241
expect(deferSpy).toHaveBeenCalledTimes(2);
241242
expect(funcSpy).toHaveBeenCalledTimes(2);// dispatch x2, func called x2
242243
//@ts-expect-error private
243244
expect(requestQueue.queue).toHaveLength(1);// still in queue
244245

245-
await jest.advanceTimersByTimeAsync(NETWORK_DOWN_DEFER_MSEC + 100);
246+
await jest.advanceTimersByTimeAsync(NETWORK_DOWN_DEFER_MSEC + 20);
246247
});
248+
247249
it('Queues request, defers on NETWORK_BUSY and then resolves it', async () => {
248250
const enqueueSpy = jest.spyOn(requestQueue, 'enqueue');
249251

@@ -271,29 +273,28 @@ describe('Ember Request Queue', () => {
271273
//@ts-expect-error private
272274
expect(requestQueue.queue).toHaveLength(1);// enqueued
273275

274-
requestQueue.dispatch();// don't await so we can advance timer
276+
requestQueue.startDispatching();
275277

276-
await jest.advanceTimersByTimeAsync(fakeWaitTime + 100 + (NETWORK_BUSY_DEFER_MSEC * 0.25));
278+
await jest.advanceTimersByTimeAsync(fakeWaitTime + 20 + (NETWORK_BUSY_DEFER_MSEC * 0.25));
277279

278280
expect(deferSpy).toHaveBeenCalledTimes(1);
279281
expect(funcSpy).toHaveBeenCalledTimes(1);
280282
//@ts-expect-error private
281283
expect(requestQueue.queue).toHaveLength(1);// still in queue
282284

283-
await jest.advanceTimersByTimeAsync(NETWORK_BUSY_DEFER_MSEC + 100);
285+
await jest.advanceTimersByTimeAsync(NETWORK_BUSY_DEFER_MSEC + 20);
284286

285287
varyingReturn = EmberStatus.SUCCESS;
286288

287-
requestQueue.dispatch();// don't await so we can advance timer
288-
289-
await jest.advanceTimersByTimeAsync(fakeWaitTime + 100);
289+
await jest.advanceTimersByTimeAsync(fakeWaitTime + 20);
290290

291291
await expect(p).resolves.toBe(123);// gives result of resolve
292292

293293
expect(funcSpy).toHaveBeenCalledTimes(2);// enqueued func was called
294294
//@ts-expect-error private
295295
expect(requestQueue.queue).toHaveLength(0);// no longer in queue
296296
});
297+
297298
it('Queues request, defers on NETWORK_BUSY and only retries once after internal change', async () => {
298299
const enqueueSpy = jest.spyOn(requestQueue, 'enqueue');
299300

@@ -323,27 +324,26 @@ describe('Ember Request Queue', () => {
323324
//@ts-expect-error private
324325
expect(requestQueue.queue).toHaveLength(1);// enqueued
325326

326-
requestQueue.dispatch();// don't await so we can advance timer
327+
requestQueue.startDispatching();
327328

328-
await jest.advanceTimersByTimeAsync(fakeWaitTime + 100 + (NETWORK_BUSY_DEFER_MSEC * 0.25));
329+
await jest.advanceTimersByTimeAsync(fakeWaitTime + 20 + (NETWORK_BUSY_DEFER_MSEC * 0.25));
329330

330331
expect(deferSpy).toHaveBeenCalledTimes(1);
331332
expect(funcSpy).toHaveBeenCalledTimes(1);
332333
//@ts-expect-error private
333334
expect(requestQueue.queue).toHaveLength(1);// still in queue
334335

335-
await jest.advanceTimersByTimeAsync(NETWORK_BUSY_DEFER_MSEC + 100);
336-
337-
requestQueue.dispatch();// don't await so we can advance timer
336+
await jest.advanceTimersByTimeAsync(NETWORK_BUSY_DEFER_MSEC + 20);
338337

339-
await jest.advanceTimersByTimeAsync(fakeWaitTime + 100);
338+
await jest.advanceTimersByTimeAsync(fakeWaitTime + 20);
340339

341340
await expect(p).resolves.toBe(123);// gives result of resolve
342341

343342
expect(funcSpy).toHaveBeenCalledTimes(2);// enqueued func was called
344343
//@ts-expect-error private
345344
expect(requestQueue.queue).toHaveLength(0);// no longer in queue
346345
});
346+
347347
it('Queues request, defers on thrown NETWORK_BUSY', async () => {
348348
const enqueueSpy = jest.spyOn(requestQueue, 'enqueue');
349349

@@ -370,17 +370,18 @@ describe('Ember Request Queue', () => {
370370
//@ts-expect-error private
371371
expect(requestQueue.queue).toHaveLength(1);// enqueued
372372

373-
requestQueue.dispatch();// don't await so we can advance timer
373+
requestQueue.startDispatching();
374374

375-
await jest.advanceTimersByTimeAsync(fakeWaitTime + 100 + (NETWORK_BUSY_DEFER_MSEC * 0.25));
375+
await jest.advanceTimersByTimeAsync(fakeWaitTime + 20 + (NETWORK_BUSY_DEFER_MSEC * 0.25));
376376

377377
expect(deferSpy).toHaveBeenCalledTimes(1);
378378
expect(funcSpy).toHaveBeenCalledTimes(1);
379379
//@ts-expect-error private
380380
expect(requestQueue.queue).toHaveLength(1);// still in queue
381381

382-
await jest.advanceTimersByTimeAsync(NETWORK_BUSY_DEFER_MSEC + 100);
382+
await jest.advanceTimersByTimeAsync(NETWORK_BUSY_DEFER_MSEC + 20);
383383
});
384+
384385
it('Queues request and resolves by priority', async () => {
385386
const enqueueSpy = jest.spyOn(requestQueue, 'enqueue');
386387

@@ -429,9 +430,9 @@ describe('Ember Request Queue', () => {
429430
//@ts-expect-error private
430431
expect(requestQueue.priorityQueue).toHaveLength(1);
431432

432-
requestQueue.dispatch();// don't await so we can advance timer
433+
requestQueue.startDispatching();
433434

434-
jest.advanceTimersByTime(fakeWaitTime + 100);
435+
await jest.advanceTimersByTimeAsync(fakeWaitTime + 1);// before 2nd setTimeout triggers
435436

436437
await expect(pPrio).resolves.toBe(456);// gives result of resolve
437438

@@ -442,161 +443,14 @@ describe('Ember Request Queue', () => {
442443
//@ts-expect-error private
443444
expect(requestQueue.queue).toHaveLength(1);// still in queue
444445

445-
requestQueue.dispatch();// don't await so we can advance timer
446-
447-
jest.advanceTimersByTime(fakeWaitTime + 100);
446+
await jest.advanceTimersByTimeAsync(fakeWaitTime * 2 + 20);
448447

449448
await expect(p).resolves.toBe(123);// gives result of resolve
450449

451450
expect(funcSpy).toHaveBeenCalledTimes(1);// enqueued func was called
452451
//@ts-expect-error private
453452
expect(requestQueue.queue).toHaveLength(0);// no longer in queue
454453
});
455-
it('Queues request send & forget style', async () => {
456-
const enqueueSpy = jest.spyOn(requestQueue, 'enqueue');
457-
458-
varyingReturn = EmberStatus.SUCCESS;
459-
460-
requestQueue.enqueue(async (): Promise<EmberStatus> => {
461-
const status: EmberStatus = await getVaryingReturn();
462-
463-
if (status !== EmberStatus.SUCCESS) {
464-
return status;
465-
}
466-
467-
return status;
468-
}, () => {});
469-
470-
//@ts-expect-error private
471-
const funcSpy = jest.spyOn(requestQueue.queue[0], 'func');
472-
//@ts-expect-error private
473-
const funcRejectSpy = jest.spyOn(requestQueue.queue[0], 'reject');
474-
475-
expect(enqueueSpy).toHaveBeenCalledTimes(1);
476-
expect(funcSpy).toHaveBeenCalledTimes(0);
477-
//@ts-expect-error private
478-
expect(requestQueue.queue).toHaveLength(1);
479-
480-
requestQueue.dispatch();// don't await so we can advance timer
481-
482-
await jest.advanceTimersByTimeAsync(fakeWaitTime + 100);
483-
484-
expect(funcSpy).toHaveBeenCalledTimes(1);// enqueued func was called
485-
expect(funcRejectSpy).toHaveBeenCalledTimes(0);
486-
//@ts-expect-error private
487-
expect(requestQueue.queue).toHaveLength(0);// no longer in queue
488-
});
489-
it('Queues request send & forget style that errors out silently', async () => {
490-
const enqueueSpy = jest.spyOn(requestQueue, 'enqueue');
491-
492-
varyingReturn = EmberStatus.ERR_FATAL;
493-
494-
requestQueue.enqueue(async (): Promise<EmberStatus> => {
495-
const status: EmberStatus = await getVaryingReturn();
496-
497-
if (status !== EmberStatus.SUCCESS) {
498-
return status;
499-
}
500-
501-
return status;
502-
}, () => {});
503-
504-
//@ts-expect-error private
505-
const funcSpy = jest.spyOn(requestQueue.queue[0], 'func');
506-
//@ts-expect-error private
507-
const funcRejectSpy = jest.spyOn(requestQueue.queue[0], 'reject');
508-
509-
expect(enqueueSpy).toHaveBeenCalledTimes(1);
510-
expect(funcSpy).toHaveBeenCalledTimes(0);
511-
//@ts-expect-error private
512-
expect(requestQueue.queue).toHaveLength(1);
513-
514-
requestQueue.dispatch();// don't await so we can advance timer
515-
516-
await jest.advanceTimersByTimeAsync(fakeWaitTime + 100);
517-
518-
expect(funcSpy).toHaveBeenCalledTimes(1);// enqueued func was called
519-
expect(funcRejectSpy).toHaveBeenCalledTimes(1);
520-
//@ts-expect-error private
521-
expect(requestQueue.queue).toHaveLength(0);// no longer in queue
522-
});
523-
it('Queues request send & forget style that throws silently', async () => {
524-
const enqueueSpy = jest.spyOn(requestQueue, 'enqueue');
525-
526-
requestQueue.enqueue(async (): Promise<EmberStatus> => {
527-
const status: EmberStatus = await getThrownError();
528-
529-
if (status !== EmberStatus.SUCCESS) {
530-
return status;
531-
}
532-
533-
return status;
534-
}, () => {});
535-
536-
//@ts-expect-error private
537-
const funcSpy = jest.spyOn(requestQueue.queue[0], 'func');
538-
//@ts-expect-error private
539-
const funcRejectSpy = jest.spyOn(requestQueue.queue[0], 'reject');
540-
541-
expect(enqueueSpy).toHaveBeenCalledTimes(1);
542-
expect(funcSpy).toHaveBeenCalledTimes(0);
543-
//@ts-expect-error private
544-
expect(requestQueue.queue).toHaveLength(1);
545-
546-
requestQueue.dispatch();// don't await so we can advance timer
547-
548-
await jest.advanceTimersByTimeAsync(fakeWaitTime + 100);
549-
550-
expect(funcSpy).toHaveBeenCalledTimes(1);// enqueued func was called
551-
expect(funcRejectSpy).toHaveBeenCalledTimes(1);
552-
//@ts-expect-error private
553-
expect(requestQueue.queue).toHaveLength(0);// no longer in queue
554-
});
555-
it('Queues request send & forget style that throws NETWORK_DOWN silently and retries', async () => {
556-
const enqueueSpy = jest.spyOn(requestQueue, 'enqueue');
557-
558-
requestQueue.enqueue(async (): Promise<EmberStatus> => {
559-
const status: EmberStatus = await getThrowNetworkDown();
560-
561-
if (status !== EmberStatus.SUCCESS) {
562-
return status;
563-
}
564-
565-
return status;
566-
}, () => {});
567-
568-
//@ts-expect-error private
569-
const funcSpy = jest.spyOn(requestQueue.queue[0], 'func');
570-
//@ts-expect-error private
571-
const funcRejectSpy = jest.spyOn(requestQueue.queue[0], 'reject');
572-
573-
expect(enqueueSpy).toHaveBeenCalledTimes(1);
574-
expect(funcSpy).toHaveBeenCalledTimes(0);
575-
//@ts-expect-error private
576-
expect(requestQueue.queue).toHaveLength(1);
577-
578-
requestQueue.dispatch();// don't await so we can advance timer
579-
580-
await jest.advanceTimersByTimeAsync(fakeWaitTime + 100);
581-
582-
expect(funcSpy).toHaveBeenCalledTimes(1);// enqueued func was called
583-
expect(funcRejectSpy).toHaveBeenCalledTimes(0);
584-
//@ts-expect-error private
585-
expect(requestQueue.queue).toHaveLength(1);// still in queue
586-
587-
await jest.advanceTimersByTimeAsync(NETWORK_DOWN_DEFER_MSEC * 2);
588-
589-
requestQueue.dispatch();// don't await so we can advance timer
590-
591-
await jest.advanceTimersByTimeAsync(fakeWaitTime + 100);
592-
593-
expect(funcSpy).toHaveBeenCalledTimes(2);// enqueued func was called
594-
expect(funcRejectSpy).toHaveBeenCalledTimes(0);
595-
//@ts-expect-error private
596-
expect(requestQueue.queue).toHaveLength(1);// still in queue
597-
598-
await jest.advanceTimersByTimeAsync(NETWORK_DOWN_DEFER_MSEC * 2);
599-
});
600454

601455
it('In-class queues also work, just for kicks...', async () => {
602456
const t = new TestThis();
@@ -605,8 +459,8 @@ describe('Ember Request Queue', () => {
605459

606460
const tBS = t.getNewBS();
607461

608-
t.q.dispatch();// don't await so we can advance timer
609-
jest.advanceTimersByTime(fakeWaitTime + 100);
462+
t.q.startDispatching();
463+
jest.advanceTimersByTime(fakeWaitTime + 20);
610464

611465
await expect(tBS).resolves.toBeTruthy();
612466
})

0 commit comments

Comments
 (0)