feat(testing): testScheduler.run() supports time progression syntax

spec/schedulers/TestScheduler-spec.ts

@@ -1,8 +1,8 @@
 import { expect } from 'chai';
 import { hot, cold, expectObservable, expectSubscriptions, time } from '../helpers/marble-testing';
 import { TestScheduler } from 'rxjs/testing';
-import { Observable, NEVER, EMPTY, Subject, of, merge, Notification } from 'rxjs';
-import { delay, debounceTime } from 'rxjs/operators';
+import { Observable, NEVER, EMPTY, Subject, of, concat, merge, Notification } from 'rxjs';
+import { delay, debounceTime, concatMap } from 'rxjs/operators';
 
 declare const rxTestScheduler: TestScheduler;
 
@@ -67,6 +67,28 @@ describe('TestScheduler', () => {
         { frame: 30, notification: Notification.createNext('c') }
       ]);
     });
+
+    it('should ignore whitespace when runMode=true', () => {
+      const runMode = true;
+      const result = TestScheduler.parseMarbles('  -a - b -    c |       ', { a: 'A', b: 'B', c: 'C' }, undefined, undefined, runMode);
+      expect(result).deep.equal([
+        { frame: 10, notification: Notification.createNext('A') },
+        { frame: 30, notification: Notification.createNext('B') },
+        { frame: 50, notification: Notification.createNext('C') },
+        { frame: 60, notification: Notification.createComplete() }
+      ]);
+    });
+
+    it('should suppport time progression syntax when runMode=true', () => {
+      const runMode = true;
+      const result = TestScheduler.parseMarbles('10.2ms a 1.2s b 1m c|', { a: 'A', b: 'B', c: 'C' }, undefined, undefined, runMode);
+      expect(result).deep.equal([
+        { frame: 10.2, notification: Notification.createNext('A') },
+        { frame: 10.2 + 10 + (1.2 * 1000), notification: Notification.createNext('B') },
+        { frame: 10.2 + 10 + (1.2 * 1000) + 10 + (1000 * 60), notification: Notification.createNext('C') },
+        { frame: 10.2 + 10 + (1.2 * 1000) + 10 + (1000 * 60) + 10, notification: Notification.createComplete() }
+      ]);
+    });
   });
 
   describe('parseMarblesAsSubscriptions()', () => {
@@ -87,6 +109,20 @@ describe('TestScheduler', () => {
       expect(result.subscribedFrame).to.equal(30);
       expect(result.unsubscribedFrame).to.equal(30);
     });
+
+    it('should ignore whitespace when runMode=true', () => {
+      const runMode = true;
+      const result = TestScheduler.parseMarblesAsSubscriptions('  - -  - -  ^ -   - !  -- -      ', runMode);
+      expect(result.subscribedFrame).to.equal(40);
+      expect(result.unsubscribedFrame).to.equal(70);
+    });
+
+    it('should suppport time progression syntax when runMode=true', () => {
+      const runMode = true;
+      const result = TestScheduler.parseMarblesAsSubscriptions('10.2ms ^ 1.2s - 1m !', runMode);
+      expect(result.subscribedFrame).to.equal(10.2);
+      expect(result.unsubscribedFrame).to.equal(10.2 + 10 + (1.2 * 1000) + 10 + (1000 * 60));
+    });
   });
 
   describe('createTime()', () => {
@@ -262,6 +298,36 @@ describe('TestScheduler', () => {
       expect(actual).deep.equal(expected);
     };
 
+    describe('marble diagrams', () => {
+      it('should ignore whitespace', () => {
+        const testScheduler = new TestScheduler(assertDeepEquals);
+
+        testScheduler.run(({ cold, expectObservable, expectSubscriptions }) => {
+          const input = cold('  -a - b -    c |       ');
+          const output = input.pipe(
+            concatMap(d => of(d).pipe(
+              delay(10)
+            ))
+          );
+          const expected = '     -- 9ms a 9ms b 9ms (c|) ';
+
+          expectObservable(output).toBe(expected);
+          expectSubscriptions(input.subscriptions).toBe('  ^- - - - --------------------------!');
+        });
+      });
+
+      it('should support time progression syntax', () => {
+        const testScheduler = new TestScheduler(assertDeepEquals);
+
+        testScheduler.run(({ cold, hot, flush, expectObservable, expectSubscriptions }) => {
+          const output = cold('10.2ms a 1.2s b 1m c|');
+          const expected = '   10.2ms a 1.2s b 1m c|';
+
+          expectObservable(output).toBe(expected);
+        });
+      });
+    });
+
     it('should provide the correct helpers', () => {
       const testScheduler = new TestScheduler(assertDeepEquals);
 
@@ -273,22 +339,48 @@ describe('TestScheduler', () => {
         expect(expectSubscriptions).to.be.a('function');
 
         const obs1 = cold('-a-c-e|');
-        const obs2 = hot('-^-b-d-f|');
+        const obs2 = hot(' ^-b-d-f|');
         const output = merge(obs1, obs2);
-        const expected =  '-abcdef|';
+        const expected = ' -abcdef|';
 
         expectObservable(output).toBe(expected);
         expectSubscriptions(obs1.subscriptions).toBe('^-----!');
         expectSubscriptions(obs2.subscriptions).toBe('^------!');
       });
     });
 
+    it('should have each frame represent a single virtual millisecond', () => {
+      const testScheduler = new TestScheduler(assertDeepEquals);
+
+      testScheduler.run(({ cold, expectObservable }) => {
+        const output = cold('-a-b-c--------|').pipe(
+          debounceTime(5)
+        );
+        const expected = '   ------ 4ms c---|';
+        expectObservable(output).toBe(expected);
+      });
+    });
+
+    it('should have no maximum frame count', () => {
+      const testScheduler = new TestScheduler(assertDeepEquals);
+
+      testScheduler.run(({ cold, expectObservable }) => {
+        const output = cold('-a|').pipe(
+          delay(1000 * 10)
+        );
+        const expected = '   - 10s a|';
+        expectObservable(output).toBe(expected);
+      });
+    });
+
     it('should make operators that use AsyncScheduler automatically use TestScheduler for actual scheduling', () => {
       const testScheduler = new TestScheduler(assertDeepEquals);
 
       testScheduler.run(({ cold, expectObservable }) => {
-        const output = cold('-a-b-(c|)').pipe(debounceTime(20), delay(10));
-        const expected =    '------(c|)';
+        const output = cold('-a-b-c--------|').pipe(
+          debounceTime(5)
+        );
+        const expected = '   ----------c---|';
         expectObservable(output).toBe(expected);
       });
     });
@@ -298,8 +390,12 @@ describe('TestScheduler', () => {
         expect(actual).deep.equal(expected);
       });
       testScheduler.run(({ cold, expectObservable }) => {
-        const output = cold('-a-b-(c|)').pipe(debounceTime(20), delay(10));
-        const expected = '------(c|)';
+        const output = cold('-a-b-c|').pipe(
+          concatMap(d => of(d).pipe(
+            delay(10)
+          ))
+        );
+        const expected = '   -- 9ms a 9ms b 9ms (c|)';
         expectObservable(output).toBe(expected);
 
         expect(testScheduler['flushTests'].length).to.equal(1);
@@ -314,8 +410,12 @@ describe('TestScheduler', () => {
       const testScheduler = new TestScheduler(assertDeepEquals);
 
       testScheduler.run(({ cold, expectObservable, flush }) => {
-        const output = cold('-a-b-(c|)').pipe(debounceTime(20), delay(10));
-        const expected = '------(c|)';
+        const output = cold('-a-b-c|').pipe(
+          concatMap(d => of(d).pipe(
+            delay(10)
+          ))
+        );
+        const expected = '   -- 9ms a 9ms b 9ms (c|)';
         expectObservable(output).toBe(expected);
 
         expect(testScheduler['flushTests'].length).to.equal(1);

src/internal/scheduler/VirtualTimeScheduler.ts

@@ -38,10 +38,6 @@ export class VirtualTimeScheduler extends AsyncScheduler {
       throw error;
     }
   }
-
-  public schedule<T>(work: (this: SchedulerAction<T>, state?: T) => void, delay: number = 0, state?: T): Subscription {
-    return new VirtualAction<T>(this, work).schedule(state, delay);
-  }
 }
 
 /**