chore(test): add jasmine helpers for virtual time tests

related #151
ReactiveX · Sep 6, 2015 · e892568 · e892568
1 parent b23daf1
commit e892568
Show file tree

Hide file tree

Showing 3 changed files with 113 additions and 2 deletions.
diff --git a/spec/helpers/test-helper.js b/spec/helpers/test-helper.js
@@ -3,8 +3,26 @@
 jasmine.DEFAULT_TIMEOUT_INTERVAL = 1000;
 
 var _ = require("lodash");
+var Rx = require('../../dist/cjs/Rx');
+
+global.rxTestScheduler = null;
+global.cold;
+global.hot;
+global.expectObservable;
+
 
 beforeEach(function () {
+  global.rxTestScheduler = new Rx.TestScheduler(assertDeepEqual);
+  global.hot = function () {
+    setupFlush();
+    return global.rxTestScheduler.createHotObservable.apply(global.rxTestScheduler, arguments);
+  };
+  global.cold = function () {
+    setupFlush();
+    return global.rxTestScheduler.createColdObservable.apply(global.rxTestScheduler, arguments);
+  };
+  global.expectObservable = global.rxTestScheduler.expect.bind(global.rxTestScheduler);
+
   jasmine.addMatchers({
     toDeepEqual: function(util, customEqualityTesters) {
       return {
@@ -15,3 +33,23 @@ beforeEach(function () {
     }
   });
 });
+
+var glit = global.it;
+var willFlush = false;
+
+afterEach(function () {
+  willFlush = false;
+  global.it = glit;
+});
+
+function assertDeepEqual(actual, expected) {
+  return expect(actual).toDeepEqual(actual);
+}
+
+function setupFlush() {
+  willFlush = true;
+  global.it = function () {
+    glit.apply(this, arguments);
+    global.rxTestScheduler.flush();
+  };
+}
diff --git a/spec/schedulers/TestScheduler-spec.js b/spec/schedulers/TestScheduler-spec.js
@@ -64,4 +64,38 @@ describe('TestScheduler', function() {
       expect(expected.length).toBe(0);
     });
   });
+
+  describe('jasmine helpers', function () {
+    describe('rxTestScheduler', function () {
+      it('should exist', function () {
+        expect(rxTestScheduler instanceof Rx.TestScheduler).toBe(true);
+      });
+    });
+
+    describe('cold()', function () {
+      it('should exist', function () {
+        expect(typeof cold).toBe('function');
+      });
+    });
+
+    describe('hot()', function () {
+      it('should exist', function () {
+        expect(typeof hot).toBe('function');
+      });
+    });
+
+    describe('expectObservable()', function () {
+      it('should exist', function () {
+        expect(typeof expectObservable).toBe('function');
+      });
+    });
+
+    describe('end-to-end helper tests', function () {
+      it('should be awesome', function () {
+        var values = { a: 1, b: 2 };
+        var myObservable = cold('---a---b--|', values);
+        expectObservable(myObservable).toBe('---a---b--|', values);
+      });
+    });
+  });
 });
diff --git a/src/schedulers/TestScheduler.ts b/src/schedulers/TestScheduler.ts
@@ -4,6 +4,10 @@ import Notification from '../Notification';
 import Subject from '../Subject';
 
 export default class TestScheduler extends VirtualTimeScheduler {
+  constructor(public assertDeepEqual: (actual: any, expected: any) => boolean | void) {
+    super();
+  }
+
   createColdObservable(marbles: string, values?: any, error?: any) {
     if (marbles.indexOf('^') !== -1) {
       throw new Error('cold observable cannot have subscription offset "^"');
@@ -14,7 +18,7 @@ export default class TestScheduler extends VirtualTimeScheduler {
         this.schedule(() => {
           notification.observe(subscriber);
         }, frame);
-      });
+      }, this);
     });
   }
 
@@ -25,10 +29,45 @@ export default class TestScheduler extends VirtualTimeScheduler {
       this.schedule(() => {
         notification.observe(subject);
       }, frame);
-    });
+    }, this);
     return subject;
   }
 
+  flushTests: ({ observable: Observable<any>, marbles: string, actual?: any[], expected?: any[] })[] = [];
+
+  expect(observable: Observable<any>): ({ toBe: (marbles: string, values?: any, errorValue?: any) => void }) {
+    let actual = [];
+    let subscription = observable.subscribe((value) => {
+      actual.push({ frame: this.frame, notification: Notification.createNext(value) });
+    }, (err) => {
+      actual.push({ frame: this.frame, notification: Notification.createError(err) });
+    }, () => {
+      actual.push({ frame: this.frame, notification: Notification.createComplete() });
+    });
+
+    let flushTest: ({ observable: Observable<any>, marbles: string, actual?: any[], expected?: any[] }) = {
+      observable, actual, marbles: null
+    };
+
+    this.flushTests.push(flushTest);
+
+    return {
+      toBe(marbles: string, values?: any, errorValue?: any) {
+        flushTest.marbles = marbles;
+        flushTest.expected = TestScheduler.parseMarbles(marbles, values, errorValue);
+      }
+    };
+  }
+
+  flush() {    
+    super.flush();
+    const flushTests = this.flushTests
+    while (flushTests.length > 0) {
+      var test = flushTests.shift();
+      this.assertDeepEqual(test.actual, test.expected);
+    }
+  }
+
   static parseMarbles(marbles: string, values?: any, errorValue?: any) : ({ notification: Notification<any>, frame: number })[] {
     let len = marbles.length;
     let results: ({ notification: Notification<any>, frame: number })[] = [];