| "use strict"; |
| var __extends = (this && this.__extends) || (function () { |
| var extendStatics = function (d, b) { |
| extendStatics = Object.setPrototypeOf || |
| ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) || |
| function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; }; |
| return extendStatics(d, b); |
| } |
| return function (d, b) { |
| extendStatics(d, b); |
| function __() { this.constructor = d; } |
| d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __()); |
| }; |
| })(); |
| Object.defineProperty(exports, "__esModule", { value: true }); |
| var Observable_1 = require("../Observable"); |
| var Notification_1 = require("../Notification"); |
| var ColdObservable_1 = require("./ColdObservable"); |
| var HotObservable_1 = require("./HotObservable"); |
| var SubscriptionLog_1 = require("./SubscriptionLog"); |
| var VirtualTimeScheduler_1 = require("../scheduler/VirtualTimeScheduler"); |
| var AsyncScheduler_1 = require("../scheduler/AsyncScheduler"); |
| var defaultMaxFrame = 750; |
| var TestScheduler = (function (_super) { |
| __extends(TestScheduler, _super); |
| function TestScheduler(assertDeepEqual) { |
| var _this = _super.call(this, VirtualTimeScheduler_1.VirtualAction, defaultMaxFrame) || this; |
| _this.assertDeepEqual = assertDeepEqual; |
| _this.hotObservables = []; |
| _this.coldObservables = []; |
| _this.flushTests = []; |
| _this.runMode = false; |
| return _this; |
| } |
| TestScheduler.prototype.createTime = function (marbles) { |
| var indexOf = marbles.indexOf('|'); |
| if (indexOf === -1) { |
| throw new Error('marble diagram for time should have a completion marker "|"'); |
| } |
| return indexOf * TestScheduler.frameTimeFactor; |
| }; |
| TestScheduler.prototype.createColdObservable = function (marbles, values, error) { |
| if (marbles.indexOf('^') !== -1) { |
| throw new Error('cold observable cannot have subscription offset "^"'); |
| } |
| if (marbles.indexOf('!') !== -1) { |
| throw new Error('cold observable cannot have unsubscription marker "!"'); |
| } |
| var messages = TestScheduler.parseMarbles(marbles, values, error, undefined, this.runMode); |
| var cold = new ColdObservable_1.ColdObservable(messages, this); |
| this.coldObservables.push(cold); |
| return cold; |
| }; |
| TestScheduler.prototype.createHotObservable = function (marbles, values, error) { |
| if (marbles.indexOf('!') !== -1) { |
| throw new Error('hot observable cannot have unsubscription marker "!"'); |
| } |
| var messages = TestScheduler.parseMarbles(marbles, values, error, undefined, this.runMode); |
| var subject = new HotObservable_1.HotObservable(messages, this); |
| this.hotObservables.push(subject); |
| return subject; |
| }; |
| TestScheduler.prototype.materializeInnerObservable = function (observable, outerFrame) { |
| var _this = this; |
| var messages = []; |
| observable.subscribe(function (value) { |
| messages.push({ frame: _this.frame - outerFrame, notification: Notification_1.Notification.createNext(value) }); |
| }, function (err) { |
| messages.push({ frame: _this.frame - outerFrame, notification: Notification_1.Notification.createError(err) }); |
| }, function () { |
| messages.push({ frame: _this.frame - outerFrame, notification: Notification_1.Notification.createComplete() }); |
| }); |
| return messages; |
| }; |
| TestScheduler.prototype.expectObservable = function (observable, subscriptionMarbles) { |
| var _this = this; |
| if (subscriptionMarbles === void 0) { subscriptionMarbles = null; } |
| var actual = []; |
| var flushTest = { actual: actual, ready: false }; |
| var subscriptionParsed = TestScheduler.parseMarblesAsSubscriptions(subscriptionMarbles, this.runMode); |
| var subscriptionFrame = subscriptionParsed.subscribedFrame === Number.POSITIVE_INFINITY ? |
| 0 : subscriptionParsed.subscribedFrame; |
| var unsubscriptionFrame = subscriptionParsed.unsubscribedFrame; |
| var subscription; |
| this.schedule(function () { |
| subscription = observable.subscribe(function (x) { |
| var value = x; |
| if (x instanceof Observable_1.Observable) { |
| value = _this.materializeInnerObservable(value, _this.frame); |
| } |
| actual.push({ frame: _this.frame, notification: Notification_1.Notification.createNext(value) }); |
| }, function (err) { |
| actual.push({ frame: _this.frame, notification: Notification_1.Notification.createError(err) }); |
| }, function () { |
| actual.push({ frame: _this.frame, notification: Notification_1.Notification.createComplete() }); |
| }); |
| }, subscriptionFrame); |
| if (unsubscriptionFrame !== Number.POSITIVE_INFINITY) { |
| this.schedule(function () { return subscription.unsubscribe(); }, unsubscriptionFrame); |
| } |
| this.flushTests.push(flushTest); |
| var runMode = this.runMode; |
| return { |
| toBe: function (marbles, values, errorValue) { |
| flushTest.ready = true; |
| flushTest.expected = TestScheduler.parseMarbles(marbles, values, errorValue, true, runMode); |
| } |
| }; |
| }; |
| TestScheduler.prototype.expectSubscriptions = function (actualSubscriptionLogs) { |
| var flushTest = { actual: actualSubscriptionLogs, ready: false }; |
| this.flushTests.push(flushTest); |
| var runMode = this.runMode; |
| return { |
| toBe: function (marbles) { |
| var marblesArray = (typeof marbles === 'string') ? [marbles] : marbles; |
| flushTest.ready = true; |
| flushTest.expected = marblesArray.map(function (marbles) { |
| return TestScheduler.parseMarblesAsSubscriptions(marbles, runMode); |
| }); |
| } |
| }; |
| }; |
| TestScheduler.prototype.flush = function () { |
| var _this = this; |
| var hotObservables = this.hotObservables; |
| while (hotObservables.length > 0) { |
| hotObservables.shift().setup(); |
| } |
| _super.prototype.flush.call(this); |
| this.flushTests = this.flushTests.filter(function (test) { |
| if (test.ready) { |
| _this.assertDeepEqual(test.actual, test.expected); |
| return false; |
| } |
| return true; |
| }); |
| }; |
| TestScheduler.parseMarblesAsSubscriptions = function (marbles, runMode) { |
| var _this = this; |
| if (runMode === void 0) { runMode = false; } |
| if (typeof marbles !== 'string') { |
| return new SubscriptionLog_1.SubscriptionLog(Number.POSITIVE_INFINITY); |
| } |
| var len = marbles.length; |
| var groupStart = -1; |
| var subscriptionFrame = Number.POSITIVE_INFINITY; |
| var unsubscriptionFrame = Number.POSITIVE_INFINITY; |
| var frame = 0; |
| var _loop_1 = function (i) { |
| var nextFrame = frame; |
| var advanceFrameBy = function (count) { |
| nextFrame += count * _this.frameTimeFactor; |
| }; |
| var c = marbles[i]; |
| switch (c) { |
| case ' ': |
| if (!runMode) { |
| advanceFrameBy(1); |
| } |
| break; |
| case '-': |
| advanceFrameBy(1); |
| break; |
| case '(': |
| groupStart = frame; |
| advanceFrameBy(1); |
| break; |
| case ')': |
| groupStart = -1; |
| advanceFrameBy(1); |
| break; |
| case '^': |
| if (subscriptionFrame !== Number.POSITIVE_INFINITY) { |
| throw new Error('found a second subscription point \'^\' in a ' + |
| 'subscription marble diagram. There can only be one.'); |
| } |
| subscriptionFrame = groupStart > -1 ? groupStart : frame; |
| advanceFrameBy(1); |
| break; |
| case '!': |
| if (unsubscriptionFrame !== Number.POSITIVE_INFINITY) { |
| throw new Error('found a second subscription point \'^\' in a ' + |
| 'subscription marble diagram. There can only be one.'); |
| } |
| unsubscriptionFrame = groupStart > -1 ? groupStart : frame; |
| break; |
| default: |
| if (runMode && c.match(/^[0-9]$/)) { |
| if (i === 0 || marbles[i - 1] === ' ') { |
| var buffer = marbles.slice(i); |
| var match = buffer.match(/^([0-9]+(?:\.[0-9]+)?)(ms|s|m) /); |
| if (match) { |
| i += match[0].length - 1; |
| var duration = parseFloat(match[1]); |
| var unit = match[2]; |
| var durationInMs = void 0; |
| switch (unit) { |
| case 'ms': |
| durationInMs = duration; |
| break; |
| case 's': |
| durationInMs = duration * 1000; |
| break; |
| case 'm': |
| durationInMs = duration * 1000 * 60; |
| break; |
| default: |
| break; |
| } |
| advanceFrameBy(durationInMs / this_1.frameTimeFactor); |
| break; |
| } |
| } |
| } |
| throw new Error('there can only be \'^\' and \'!\' markers in a ' + |
| 'subscription marble diagram. Found instead \'' + c + '\'.'); |
| } |
| frame = nextFrame; |
| out_i_1 = i; |
| }; |
| var this_1 = this, out_i_1; |
| for (var i = 0; i < len; i++) { |
| _loop_1(i); |
| i = out_i_1; |
| } |
| if (unsubscriptionFrame < 0) { |
| return new SubscriptionLog_1.SubscriptionLog(subscriptionFrame); |
| } |
| else { |
| return new SubscriptionLog_1.SubscriptionLog(subscriptionFrame, unsubscriptionFrame); |
| } |
| }; |
| TestScheduler.parseMarbles = function (marbles, values, errorValue, materializeInnerObservables, runMode) { |
| var _this = this; |
| if (materializeInnerObservables === void 0) { materializeInnerObservables = false; } |
| if (runMode === void 0) { runMode = false; } |
| if (marbles.indexOf('!') !== -1) { |
| throw new Error('conventional marble diagrams cannot have the ' + |
| 'unsubscription marker "!"'); |
| } |
| var len = marbles.length; |
| var testMessages = []; |
| var subIndex = runMode ? marbles.replace(/^[ ]+/, '').indexOf('^') : marbles.indexOf('^'); |
| var frame = subIndex === -1 ? 0 : (subIndex * -this.frameTimeFactor); |
| var getValue = typeof values !== 'object' ? |
| function (x) { return x; } : |
| function (x) { |
| if (materializeInnerObservables && values[x] instanceof ColdObservable_1.ColdObservable) { |
| return values[x].messages; |
| } |
| return values[x]; |
| }; |
| var groupStart = -1; |
| var _loop_2 = function (i) { |
| var nextFrame = frame; |
| var advanceFrameBy = function (count) { |
| nextFrame += count * _this.frameTimeFactor; |
| }; |
| var notification = void 0; |
| var c = marbles[i]; |
| switch (c) { |
| case ' ': |
| if (!runMode) { |
| advanceFrameBy(1); |
| } |
| break; |
| case '-': |
| advanceFrameBy(1); |
| break; |
| case '(': |
| groupStart = frame; |
| advanceFrameBy(1); |
| break; |
| case ')': |
| groupStart = -1; |
| advanceFrameBy(1); |
| break; |
| case '|': |
| notification = Notification_1.Notification.createComplete(); |
| advanceFrameBy(1); |
| break; |
| case '^': |
| advanceFrameBy(1); |
| break; |
| case '#': |
| notification = Notification_1.Notification.createError(errorValue || 'error'); |
| advanceFrameBy(1); |
| break; |
| default: |
| if (runMode && c.match(/^[0-9]$/)) { |
| if (i === 0 || marbles[i - 1] === ' ') { |
| var buffer = marbles.slice(i); |
| var match = buffer.match(/^([0-9]+(?:\.[0-9]+)?)(ms|s|m) /); |
| if (match) { |
| i += match[0].length - 1; |
| var duration = parseFloat(match[1]); |
| var unit = match[2]; |
| var durationInMs = void 0; |
| switch (unit) { |
| case 'ms': |
| durationInMs = duration; |
| break; |
| case 's': |
| durationInMs = duration * 1000; |
| break; |
| case 'm': |
| durationInMs = duration * 1000 * 60; |
| break; |
| default: |
| break; |
| } |
| advanceFrameBy(durationInMs / this_2.frameTimeFactor); |
| break; |
| } |
| } |
| } |
| notification = Notification_1.Notification.createNext(getValue(c)); |
| advanceFrameBy(1); |
| break; |
| } |
| if (notification) { |
| testMessages.push({ frame: groupStart > -1 ? groupStart : frame, notification: notification }); |
| } |
| frame = nextFrame; |
| out_i_2 = i; |
| }; |
| var this_2 = this, out_i_2; |
| for (var i = 0; i < len; i++) { |
| _loop_2(i); |
| i = out_i_2; |
| } |
| return testMessages; |
| }; |
| TestScheduler.prototype.run = function (callback) { |
| var prevFrameTimeFactor = TestScheduler.frameTimeFactor; |
| var prevMaxFrames = this.maxFrames; |
| TestScheduler.frameTimeFactor = 1; |
| this.maxFrames = Number.POSITIVE_INFINITY; |
| this.runMode = true; |
| AsyncScheduler_1.AsyncScheduler.delegate = this; |
| var helpers = { |
| cold: this.createColdObservable.bind(this), |
| hot: this.createHotObservable.bind(this), |
| flush: this.flush.bind(this), |
| expectObservable: this.expectObservable.bind(this), |
| expectSubscriptions: this.expectSubscriptions.bind(this), |
| }; |
| try { |
| var ret = callback(helpers); |
| this.flush(); |
| return ret; |
| } |
| finally { |
| TestScheduler.frameTimeFactor = prevFrameTimeFactor; |
| this.maxFrames = prevMaxFrames; |
| this.runMode = false; |
| AsyncScheduler_1.AsyncScheduler.delegate = undefined; |
| } |
| }; |
| return TestScheduler; |
| }(VirtualTimeScheduler_1.VirtualTimeScheduler)); |
| exports.TestScheduler = TestScheduler; |
| //# sourceMappingURL=TestScheduler.js.map |