mirror of
https://github.com/JamesIves/github-pages-deploy-action.git
synced 2023-12-15 20:03:39 +08:00
360 lines
15 KiB
JavaScript
360 lines
15 KiB
JavaScript
/** PURE_IMPORTS_START tslib,_Observable,_Notification,_ColdObservable,_HotObservable,_SubscriptionLog,_scheduler_VirtualTimeScheduler,_scheduler_AsyncScheduler PURE_IMPORTS_END */
|
|
import * as tslib_1 from "tslib";
|
|
import { Observable } from '../Observable';
|
|
import { Notification } from '../Notification';
|
|
import { ColdObservable } from './ColdObservable';
|
|
import { HotObservable } from './HotObservable';
|
|
import { SubscriptionLog } from './SubscriptionLog';
|
|
import { VirtualTimeScheduler, VirtualAction } from '../scheduler/VirtualTimeScheduler';
|
|
import { AsyncScheduler } from '../scheduler/AsyncScheduler';
|
|
var defaultMaxFrame = 750;
|
|
var TestScheduler = /*@__PURE__*/ (function (_super) {
|
|
tslib_1.__extends(TestScheduler, _super);
|
|
function TestScheduler(assertDeepEqual) {
|
|
var _this = _super.call(this, 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(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(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.createNext(value) });
|
|
}, function (err) {
|
|
messages.push({ frame: _this.frame - outerFrame, notification: Notification.createError(err) });
|
|
}, function () {
|
|
messages.push({ frame: _this.frame - outerFrame, notification: 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) {
|
|
value = _this.materializeInnerObservable(value, _this.frame);
|
|
}
|
|
actual.push({ frame: _this.frame, notification: Notification.createNext(value) });
|
|
}, function (err) {
|
|
actual.push({ frame: _this.frame, notification: Notification.createError(err) });
|
|
}, function () {
|
|
actual.push({ frame: _this.frame, notification: 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(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(subscriptionFrame);
|
|
}
|
|
else {
|
|
return new 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) {
|
|
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.createComplete();
|
|
advanceFrameBy(1);
|
|
break;
|
|
case '^':
|
|
advanceFrameBy(1);
|
|
break;
|
|
case '#':
|
|
notification = 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.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.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.delegate = undefined;
|
|
}
|
|
};
|
|
return TestScheduler;
|
|
}(VirtualTimeScheduler));
|
|
export { TestScheduler };
|
|
//# sourceMappingURL=TestScheduler.js.map
|