@acutmore/rxjs
Version:
Reactive Extensions for modern JavaScript
340 lines • 14.9 kB
JavaScript
;
var __extends = (this && this.__extends) || (function () {
var 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 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 Observer_1 = require("../Observer");
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 MockPromise_1 = require("./MockPromise");
// v4-backwards-compatibility
var ReactiveTest_1 = require("./ReactiveTest");
// v4-backwards-compatibility
// 750 => 100,001
var defaultMaxFrame = (100 * 1000) + 1;
var TestScheduler = /** @class */ (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 = [];
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 () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
if (args.length === 0) {
// v4-backwards-compatibility
return this.createColdObservable('');
}
var messages;
if (typeof args[0] === 'string') {
var marbles = args[0], values = args[1], error = args[2];
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 "!"');
}
messages = TestScheduler.parseMarbles(marbles, values, error);
}
else {
// v4-backwards-compatibility
messages = args;
}
var cold = new ColdObservable_1.ColdObservable(messages, this);
this.coldObservables.push(cold);
return cold;
};
TestScheduler.prototype.createHotObservable = function () {
var args = [];
for (var _i = 0; _i < arguments.length; _i++) {
args[_i] = arguments[_i];
}
if (args.length === 0) {
// v4-backwards-compatibility
return this.createHotObservable('');
}
var messages;
if (typeof args[0] === 'string') {
var marbles = args[0], values = args[1], error = args[2];
if (marbles.indexOf('!') !== -1) {
throw new Error('hot observable cannot have unsubscription marker "!"');
}
messages = TestScheduler.parseMarbles(marbles, values, error);
}
else {
// v4-backwards-compatibility
messages = args;
}
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, unsubscriptionMarbles) {
var _this = this;
if (unsubscriptionMarbles === void 0) { unsubscriptionMarbles = null; }
var actual = [];
var flushTest = { actual: actual, ready: false };
var unsubscriptionFrame = TestScheduler
.parseMarblesAsSubscriptions(unsubscriptionMarbles).unsubscribedFrame;
var subscription;
this.schedule(function () {
subscription = observable.subscribe(function (x) {
var value = x;
// Support Observable-of-Observables
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() });
});
}, 0);
if (unsubscriptionFrame !== Number.POSITIVE_INFINITY) {
this.schedule(function () { return subscription.unsubscribe(); }, unsubscriptionFrame);
}
this.flushTests.push(flushTest);
return {
toBe: function (marbles, values, errorValue) {
flushTest.ready = true;
flushTest.expected = TestScheduler.parseMarbles(marbles, values, errorValue, true);
}
};
};
TestScheduler.prototype.expectSubscriptions = function (actualSubscriptionLogs) {
var flushTest = { actual: actualSubscriptionLogs, ready: false };
this.flushTests.push(flushTest);
return {
toBe: function (marbles) {
var marblesArray = (typeof marbles === 'string') ? [marbles] : marbles;
flushTest.ready = true;
flushTest.expected = marblesArray.map(function (marbles) {
return TestScheduler.parseMarblesAsSubscriptions(marbles);
});
}
};
};
TestScheduler.prototype.flush = function (limit) {
if (limit === void 0) { limit = Number.POSITIVE_INFINITY; }
var hotObservables = this.hotObservables;
while (hotObservables.length > 0) {
hotObservables.shift().setup();
}
if (limit === Number.POSITIVE_INFINITY) {
_super.prototype.flush.call(this);
var readyFlushTests = this.flushTests.filter(function (test) { return test.ready; });
while (readyFlushTests.length > 0) {
var test_1 = readyFlushTests.shift();
this.assertDeepEqual(test_1.actual, test_1.expected);
}
}
else {
_super.prototype.limitedFlush.call(this, limit);
}
};
TestScheduler.parseMarblesAsSubscriptions = function (marbles) {
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;
for (var i = 0; i < len; i++) {
var frame = i * this.frameTimeFactor;
var c = marbles[i];
switch (c) {
case '-':
case ' ':
break;
case '(':
groupStart = frame;
break;
case ')':
groupStart = -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;
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:
throw new Error('there can only be \'^\' and \'!\' markers in a ' +
'subscription marble diagram. Found instead \'' + c + '\'.');
}
}
if (unsubscriptionFrame < 0) {
return new SubscriptionLog_1.SubscriptionLog(subscriptionFrame);
}
else {
return new SubscriptionLog_1.SubscriptionLog(subscriptionFrame, unsubscriptionFrame);
}
};
TestScheduler.parseMarbles = function (marbles, values, errorValue, materializeInnerObservables) {
if (materializeInnerObservables === void 0) { materializeInnerObservables = false; }
if (marbles.indexOf('!') !== -1) {
throw new Error('conventional marble diagrams cannot have the ' +
'unsubscription marker "!"');
}
var len = marbles.length;
var testMessages = [];
var subIndex = marbles.indexOf('^');
var frameOffset = subIndex === -1 ? 0 : (subIndex * -this.frameTimeFactor);
var getValue = typeof values !== 'object' ?
function (x) { return x; } :
function (x) {
// Support Observable-of-Observables
if (materializeInnerObservables && values[x] instanceof ColdObservable_1.ColdObservable) {
return values[x].messages;
}
return values[x];
};
var groupStart = -1;
for (var i = 0; i < len; i++) {
var frame = i * this.frameTimeFactor + frameOffset;
var notification = void 0;
var c = marbles[i];
switch (c) {
case '-':
case ' ':
break;
case '(':
groupStart = frame;
break;
case ')':
groupStart = -1;
break;
case '|':
notification = Notification_1.Notification.createComplete();
break;
case '^':
break;
case '#':
notification = Notification_1.Notification.createError(errorValue || 'error');
break;
default:
notification = Notification_1.Notification.createNext(getValue(c));
break;
}
if (notification) {
testMessages.push({ frame: groupStart > -1 ? groupStart : frame, notification: notification });
}
}
return testMessages;
};
// v4-backwards-compatibility
TestScheduler.prototype.createObserver = function () {
var scheduler = this;
var messages = [];
var obs = Observer_1.Observer.create(function (v) {
messages.push({ frame: scheduler.now(), notification: Notification_1.Notification.createNext(v) });
}, function (err) {
messages.push({ frame: scheduler.now(), notification: Notification_1.Notification.createError(err) });
}, function () {
messages.push({ frame: scheduler.now(), notification: Notification_1.Notification.createComplete() });
});
obs.messages = messages;
return obs;
};
// v4-backwards-compatibility
TestScheduler.prototype.startScheduler = function (factory, settings) {
if (settings === void 0) { settings = {}; }
var created = settings.created == null ? ReactiveTest_1.ReactiveTest.created : settings.created;
var subscribed = settings.subscribed == null ? ReactiveTest_1.ReactiveTest.subscribed : settings.subscribed;
var disposed = settings.disposed == null ? ReactiveTest_1.ReactiveTest.disposed : settings.disposed;
var testObserver = this.createObserver();
var subscription;
var source;
this.scheduleAbsolute(null, created, function () {
source = factory();
});
this.scheduleAbsolute(null, subscribed, function () {
subscription = source.subscribe(testObserver);
});
this.scheduleAbsolute(null, disposed, function () {
subscription.dispose();
});
this.start();
return testObserver;
};
// v4-backwards-compatibility
TestScheduler.prototype.scheduleAbsolute = function (state, dueTime, action) {
var delay = dueTime - this.clock;
return _super.prototype.scheduleAbsolute.call(this, state, Math.max(0, delay), action);
};
// v4-backwards-compatibility
TestScheduler.prototype.advanceBy = function (time) {
this.flush(this.now() + time);
};
// v4-backwards-compatibility
TestScheduler.prototype.advanceTo = function (time) {
this.flush(time);
};
// v4-backwards-compatibility
TestScheduler.prototype.createResolvedPromise = function (time, value) {
return new MockPromise_1.MockPromise(this, time, value, false);
};
// v4-backwards-compatibility
TestScheduler.prototype.createRejectedPromise = function (time, rejection) {
return new MockPromise_1.MockPromise(this, time, rejection, true);
};
// v4-backwards-compatibility
TestScheduler.prototype.scheduleRelative = function (state, delay, action) {
this.schedule(action, delay, state);
};
// v4-backwards-compatibility
TestScheduler.prototype.stop = function () {
/* noop */
};
return TestScheduler;
}(VirtualTimeScheduler_1.VirtualTimeScheduler));
exports.TestScheduler = TestScheduler;
// v4-backwards-compatibility
TestScheduler.prototype.start = function () { this.flush(); };
//# sourceMappingURL=TestScheduler.js.map