test(@angular-devkit/core): allow asynchronous jobs to start execution before expect

Author: clydin

packages/angular_devkit/core/src/experimental/jobs/simple-scheduler_spec.ts

@@ -8,11 +8,14 @@
 // tslint:disable:no-big-function no-non-null-assertion
 import { EMPTY, Observable, of, timer } from 'rxjs';
 import { map, take, toArray } from 'rxjs/operators';
+import { promisify } from 'util';
 import { JobHandlerContext, JobOutboundMessage, JobOutboundMessageKind, JobState } from './api';
 import { createJobHandler } from './create-job-handler';
 import { SimpleJobRegistry } from './simple-registry';
 import { SimpleScheduler } from './simple-scheduler';
 
+const flush = promisify(setImmediate);
+
 describe('SimpleScheduler', () => {
   let registry: SimpleJobRegistry;
   let scheduler: SimpleScheduler;
@@ -61,9 +64,11 @@ describe('SimpleScheduler', () => {
     expect(started).toBe(0);
 
     const p1 = job1.output.toPromise();
+    await flush();
     expect(started).toBe(1);
 
     const p2 = job2.output.toPromise();
+    await flush();
     expect(started).toBe(2);
     expect(finished).toBe(0);
 
@@ -186,10 +191,10 @@ describe('SimpleScheduler', () => {
       createJobHandler<number, number, number>((argument: number) => {
         started.push(argument);
 
-        return new Promise(resolve => setImmediate(() => {
+        return new Promise(resolve => setTimeout(() => {
           done.push(argument);
           resolve(argument);
-        }));
+        }, 10));
       }),
       { argument: true, output: true },
     );
@@ -204,29 +209,35 @@ describe('SimpleScheduler', () => {
 
     // Just subscribe to the last job in the lot.
     job6.outboundBus.subscribe();
+    await flush();
     // Expect the first one to start.
     expect(started).toEqual([1]);
     // Wait for the first one to finish.
     await job1.output.toPromise();
+    await flush();
     // Expect the second one to have started, and the first one to be done.
     expect(started).toEqual([1, 2]);
     expect(done).toEqual([1]);
 
     // Rinse and repeat.
     await job2.output.toPromise();
+    await flush();
     expect(started).toEqual([1, 2, 3]);
     expect(done).toEqual([1, 2]);
 
     await job3.output.toPromise();
+    await flush();
     expect(started).toEqual([1, 2, 3, 4]);
     expect(done).toEqual([1, 2, 3]);
 
     await job4.output.toPromise();
+    await flush();
     expect(started).toEqual([1, 2, 3, 4, 5]);
     expect(done).toEqual([1, 2, 3, 4]);
 
     // Just skip job 5.
     await job6.output.toPromise();
+    await flush();
     expect(done).toEqual(started);
   });
 
@@ -293,11 +304,11 @@ describe('SimpleScheduler', () => {
     const p10 = (scheduler.schedule('jobA', 10)).output.toPromise();
     const p11 = (scheduler.schedule('jobA', 11)).output.toPromise();
     const p12 = (scheduler.schedule('jobA', 12)).output.toPromise();
-    await Promise.resolve();
+    await flush();
 
     expect(done).toEqual([]);
     resume();
-    await Promise.resolve();
+    await flush();
     expect(done).not.toEqual([]);
     expect(await p10).toBe(10);
     expect(await p11).toBe(11);

packages/angular_devkit/core/src/experimental/jobs/strategy_spec.ts

@@ -5,12 +5,15 @@
  * Use of this source code is governed by an MIT-style license that can be
  * found in the LICENSE file at https://angular.io/license
  */
+import { promisify } from 'util';
 import { JobState } from './api';
 import { createJobHandler } from './create-job-handler';
 import { SimpleJobRegistry } from './simple-registry';
 import { SimpleScheduler } from './simple-scheduler';
 import { strategy } from './strategy';
 
+const flush = promisify(setImmediate);
+
 describe('strategy.serialize()', () => {
   let registry: SimpleJobRegistry;
   let scheduler: SimpleScheduler;
@@ -46,9 +49,11 @@ describe('strategy.serialize()', () => {
     expect(finished).toBe(0);
 
     job1.output.subscribe();
+    await flush();
     expect(started).toBe(1);
 
     job2.output.subscribe();
+    await flush();
     expect(started).toBe(1);  // Job2 starts when Job1 ends.
 
     expect(finished).toBe(0);
@@ -111,9 +116,11 @@ describe('strategy.serialize()', () => {
     expect(finished).toBe(0);
 
     job1.output.subscribe();
+    await flush();
     expect(started).toBe(1);
 
     job2.output.subscribe();
+    await flush();
     expect(started).toBe(1);  // Job2 starts when Job1 ends.
 
     expect(finished).toBe(0);
@@ -169,6 +176,7 @@ describe('strategy.reuse()', () => {
     expect(finished).toBe(0);
 
     job1.output.subscribe();
+    await flush();
     expect(started).toBe(1);
     expect(finished).toBe(0);
 
@@ -186,6 +194,7 @@ describe('strategy.reuse()', () => {
     const job3 = scheduler.schedule('add', [1, 2, 3, 4, 5]);
     const job4 = scheduler.schedule('add', []);
     job3.output.subscribe();
+    await flush();
     expect(started).toBe(2);
     expect(finished).toBe(1);
 
@@ -239,6 +248,7 @@ describe('strategy.memoize()', () => {
     expect(finished).toBe(0);
 
     job1.output.subscribe();
+    await flush();
     expect(started).toBe(1);
     expect(finished).toBe(0);
 
@@ -247,6 +257,7 @@ describe('strategy.memoize()', () => {
     expect(finished).toBe(0);
 
     job3.output.subscribe();
+    await flush();
     expect(started).toBe(2);
     expect(finished).toBe(0);