[6a3a178] | 1 | import { Observable } from '../Observable';
|
---|
| 2 | import { Notification } from '../Notification';
|
---|
| 3 | import { ColdObservable } from './ColdObservable';
|
---|
| 4 | import { HotObservable } from './HotObservable';
|
---|
| 5 | import { TestMessage } from './TestMessage';
|
---|
| 6 | import { SubscriptionLog } from './SubscriptionLog';
|
---|
| 7 | import { Subscription } from '../Subscription';
|
---|
| 8 | import { VirtualTimeScheduler, VirtualAction } from '../scheduler/VirtualTimeScheduler';
|
---|
| 9 | import { AsyncScheduler } from '../scheduler/AsyncScheduler';
|
---|
| 10 |
|
---|
| 11 | const defaultMaxFrame: number = 750;
|
---|
| 12 |
|
---|
| 13 | export interface RunHelpers {
|
---|
| 14 | cold: typeof TestScheduler.prototype.createColdObservable;
|
---|
| 15 | hot: typeof TestScheduler.prototype.createHotObservable;
|
---|
| 16 | flush: typeof TestScheduler.prototype.flush;
|
---|
| 17 | expectObservable: typeof TestScheduler.prototype.expectObservable;
|
---|
| 18 | expectSubscriptions: typeof TestScheduler.prototype.expectSubscriptions;
|
---|
| 19 | }
|
---|
| 20 |
|
---|
| 21 | interface FlushableTest {
|
---|
| 22 | ready: boolean;
|
---|
| 23 | actual?: any[];
|
---|
| 24 | expected?: any[];
|
---|
| 25 | }
|
---|
| 26 |
|
---|
| 27 | export type observableToBeFn = (marbles: string, values?: any, errorValue?: any) => void;
|
---|
| 28 | export type subscriptionLogsToBeFn = (marbles: string | string[]) => void;
|
---|
| 29 |
|
---|
| 30 | export class TestScheduler extends VirtualTimeScheduler {
|
---|
| 31 | public readonly hotObservables: HotObservable<any>[] = [];
|
---|
| 32 | public readonly coldObservables: ColdObservable<any>[] = [];
|
---|
| 33 | private flushTests: FlushableTest[] = [];
|
---|
| 34 | private runMode = false;
|
---|
| 35 |
|
---|
| 36 | constructor(public assertDeepEqual: (actual: any, expected: any) => boolean | void) {
|
---|
| 37 | super(VirtualAction, defaultMaxFrame);
|
---|
| 38 | }
|
---|
| 39 |
|
---|
| 40 | createTime(marbles: string): number {
|
---|
| 41 | const indexOf: number = marbles.indexOf('|');
|
---|
| 42 | if (indexOf === -1) {
|
---|
| 43 | throw new Error('marble diagram for time should have a completion marker "|"');
|
---|
| 44 | }
|
---|
| 45 | return indexOf * TestScheduler.frameTimeFactor;
|
---|
| 46 | }
|
---|
| 47 |
|
---|
| 48 | /**
|
---|
| 49 | * @param marbles A diagram in the marble DSL. Letters map to keys in `values` if provided.
|
---|
| 50 | * @param values Values to use for the letters in `marbles`. If ommitted, the letters themselves are used.
|
---|
| 51 | * @param error The error to use for the `#` marble (if present).
|
---|
| 52 | */
|
---|
| 53 | createColdObservable<T = string>(marbles: string, values?: { [marble: string]: T }, error?: any): ColdObservable<T> {
|
---|
| 54 | if (marbles.indexOf('^') !== -1) {
|
---|
| 55 | throw new Error('cold observable cannot have subscription offset "^"');
|
---|
| 56 | }
|
---|
| 57 | if (marbles.indexOf('!') !== -1) {
|
---|
| 58 | throw new Error('cold observable cannot have unsubscription marker "!"');
|
---|
| 59 | }
|
---|
| 60 | const messages = TestScheduler.parseMarbles(marbles, values, error, undefined, this.runMode);
|
---|
| 61 | const cold = new ColdObservable<T>(messages, this);
|
---|
| 62 | this.coldObservables.push(cold);
|
---|
| 63 | return cold;
|
---|
| 64 | }
|
---|
| 65 |
|
---|
| 66 | /**
|
---|
| 67 | * @param marbles A diagram in the marble DSL. Letters map to keys in `values` if provided.
|
---|
| 68 | * @param values Values to use for the letters in `marbles`. If ommitted, the letters themselves are used.
|
---|
| 69 | * @param error The error to use for the `#` marble (if present).
|
---|
| 70 | */
|
---|
| 71 | createHotObservable<T = string>(marbles: string, values?: { [marble: string]: T }, error?: any): HotObservable<T> {
|
---|
| 72 | if (marbles.indexOf('!') !== -1) {
|
---|
| 73 | throw new Error('hot observable cannot have unsubscription marker "!"');
|
---|
| 74 | }
|
---|
| 75 | const messages = TestScheduler.parseMarbles(marbles, values, error, undefined, this.runMode);
|
---|
| 76 | const subject = new HotObservable<T>(messages, this);
|
---|
| 77 | this.hotObservables.push(subject);
|
---|
| 78 | return subject;
|
---|
| 79 | }
|
---|
| 80 |
|
---|
| 81 | private materializeInnerObservable(observable: Observable<any>,
|
---|
| 82 | outerFrame: number): TestMessage[] {
|
---|
| 83 | const messages: TestMessage[] = [];
|
---|
| 84 | observable.subscribe((value) => {
|
---|
| 85 | messages.push({ frame: this.frame - outerFrame, notification: Notification.createNext(value) });
|
---|
| 86 | }, (err) => {
|
---|
| 87 | messages.push({ frame: this.frame - outerFrame, notification: Notification.createError(err) });
|
---|
| 88 | }, () => {
|
---|
| 89 | messages.push({ frame: this.frame - outerFrame, notification: Notification.createComplete() });
|
---|
| 90 | });
|
---|
| 91 | return messages;
|
---|
| 92 | }
|
---|
| 93 |
|
---|
| 94 | expectObservable(observable: Observable<any>,
|
---|
| 95 | subscriptionMarbles: string = null): ({ toBe: observableToBeFn }) {
|
---|
| 96 | const actual: TestMessage[] = [];
|
---|
| 97 | const flushTest: FlushableTest = { actual, ready: false };
|
---|
| 98 | const subscriptionParsed = TestScheduler.parseMarblesAsSubscriptions(subscriptionMarbles, this.runMode);
|
---|
| 99 | const subscriptionFrame = subscriptionParsed.subscribedFrame === Number.POSITIVE_INFINITY ?
|
---|
| 100 | 0 : subscriptionParsed.subscribedFrame;
|
---|
| 101 | const unsubscriptionFrame = subscriptionParsed.unsubscribedFrame;
|
---|
| 102 | let subscription: Subscription;
|
---|
| 103 |
|
---|
| 104 | this.schedule(() => {
|
---|
| 105 | subscription = observable.subscribe(x => {
|
---|
| 106 | let value = x;
|
---|
| 107 | // Support Observable-of-Observables
|
---|
| 108 | if (x instanceof Observable) {
|
---|
| 109 | value = this.materializeInnerObservable(value, this.frame);
|
---|
| 110 | }
|
---|
| 111 | actual.push({ frame: this.frame, notification: Notification.createNext(value) });
|
---|
| 112 | }, (err) => {
|
---|
| 113 | actual.push({ frame: this.frame, notification: Notification.createError(err) });
|
---|
| 114 | }, () => {
|
---|
| 115 | actual.push({ frame: this.frame, notification: Notification.createComplete() });
|
---|
| 116 | });
|
---|
| 117 | }, subscriptionFrame);
|
---|
| 118 |
|
---|
| 119 | if (unsubscriptionFrame !== Number.POSITIVE_INFINITY) {
|
---|
| 120 | this.schedule(() => subscription.unsubscribe(), unsubscriptionFrame);
|
---|
| 121 | }
|
---|
| 122 |
|
---|
| 123 | this.flushTests.push(flushTest);
|
---|
| 124 | const { runMode } = this;
|
---|
| 125 |
|
---|
| 126 | return {
|
---|
| 127 | toBe(marbles: string, values?: any, errorValue?: any) {
|
---|
| 128 | flushTest.ready = true;
|
---|
| 129 | flushTest.expected = TestScheduler.parseMarbles(marbles, values, errorValue, true, runMode);
|
---|
| 130 | }
|
---|
| 131 | };
|
---|
| 132 | }
|
---|
| 133 |
|
---|
| 134 | expectSubscriptions(actualSubscriptionLogs: SubscriptionLog[]): ({ toBe: subscriptionLogsToBeFn }) {
|
---|
| 135 | const flushTest: FlushableTest = { actual: actualSubscriptionLogs, ready: false };
|
---|
| 136 | this.flushTests.push(flushTest);
|
---|
| 137 | const { runMode } = this;
|
---|
| 138 | return {
|
---|
| 139 | toBe(marbles: string | string[]) {
|
---|
| 140 | const marblesArray: string[] = (typeof marbles === 'string') ? [marbles] : marbles;
|
---|
| 141 | flushTest.ready = true;
|
---|
| 142 | flushTest.expected = marblesArray.map(marbles =>
|
---|
| 143 | TestScheduler.parseMarblesAsSubscriptions(marbles, runMode)
|
---|
| 144 | );
|
---|
| 145 | }
|
---|
| 146 | };
|
---|
| 147 | }
|
---|
| 148 |
|
---|
| 149 | flush() {
|
---|
| 150 | const hotObservables = this.hotObservables;
|
---|
| 151 | while (hotObservables.length > 0) {
|
---|
| 152 | hotObservables.shift().setup();
|
---|
| 153 | }
|
---|
| 154 |
|
---|
| 155 | super.flush();
|
---|
| 156 |
|
---|
| 157 | this.flushTests = this.flushTests.filter(test => {
|
---|
| 158 | if (test.ready) {
|
---|
| 159 | this.assertDeepEqual(test.actual, test.expected);
|
---|
| 160 | return false;
|
---|
| 161 | }
|
---|
| 162 | return true;
|
---|
| 163 | });
|
---|
| 164 | }
|
---|
| 165 |
|
---|
| 166 | /** @nocollapse */
|
---|
| 167 | static parseMarblesAsSubscriptions(marbles: string, runMode = false): SubscriptionLog {
|
---|
| 168 | if (typeof marbles !== 'string') {
|
---|
| 169 | return new SubscriptionLog(Number.POSITIVE_INFINITY);
|
---|
| 170 | }
|
---|
| 171 | const len = marbles.length;
|
---|
| 172 | let groupStart = -1;
|
---|
| 173 | let subscriptionFrame = Number.POSITIVE_INFINITY;
|
---|
| 174 | let unsubscriptionFrame = Number.POSITIVE_INFINITY;
|
---|
| 175 | let frame = 0;
|
---|
| 176 |
|
---|
| 177 | for (let i = 0; i < len; i++) {
|
---|
| 178 | let nextFrame = frame;
|
---|
| 179 | const advanceFrameBy = (count: number) => {
|
---|
| 180 | nextFrame += count * this.frameTimeFactor;
|
---|
| 181 | };
|
---|
| 182 | const c = marbles[i];
|
---|
| 183 | switch (c) {
|
---|
| 184 | case ' ':
|
---|
| 185 | // Whitespace no longer advances time
|
---|
| 186 | if (!runMode) {
|
---|
| 187 | advanceFrameBy(1);
|
---|
| 188 | }
|
---|
| 189 | break;
|
---|
| 190 | case '-':
|
---|
| 191 | advanceFrameBy(1);
|
---|
| 192 | break;
|
---|
| 193 | case '(':
|
---|
| 194 | groupStart = frame;
|
---|
| 195 | advanceFrameBy(1);
|
---|
| 196 | break;
|
---|
| 197 | case ')':
|
---|
| 198 | groupStart = -1;
|
---|
| 199 | advanceFrameBy(1);
|
---|
| 200 | break;
|
---|
| 201 | case '^':
|
---|
| 202 | if (subscriptionFrame !== Number.POSITIVE_INFINITY) {
|
---|
| 203 | throw new Error('found a second subscription point \'^\' in a ' +
|
---|
| 204 | 'subscription marble diagram. There can only be one.');
|
---|
| 205 | }
|
---|
| 206 | subscriptionFrame = groupStart > -1 ? groupStart : frame;
|
---|
| 207 | advanceFrameBy(1);
|
---|
| 208 | break;
|
---|
| 209 | case '!':
|
---|
| 210 | if (unsubscriptionFrame !== Number.POSITIVE_INFINITY) {
|
---|
| 211 | throw new Error('found a second subscription point \'^\' in a ' +
|
---|
| 212 | 'subscription marble diagram. There can only be one.');
|
---|
| 213 | }
|
---|
| 214 | unsubscriptionFrame = groupStart > -1 ? groupStart : frame;
|
---|
| 215 | break;
|
---|
| 216 | default:
|
---|
| 217 | // time progression syntax
|
---|
| 218 | if (runMode && c.match(/^[0-9]$/)) {
|
---|
| 219 | // Time progression must be preceeded by at least one space
|
---|
| 220 | // if it's not at the beginning of the diagram
|
---|
| 221 | if (i === 0 || marbles[i - 1] === ' ') {
|
---|
| 222 | const buffer = marbles.slice(i);
|
---|
| 223 | const match = buffer.match(/^([0-9]+(?:\.[0-9]+)?)(ms|s|m) /);
|
---|
| 224 | if (match) {
|
---|
| 225 | i += match[0].length - 1;
|
---|
| 226 | const duration = parseFloat(match[1]);
|
---|
| 227 | const unit = match[2];
|
---|
| 228 | let durationInMs: number;
|
---|
| 229 |
|
---|
| 230 | switch (unit) {
|
---|
| 231 | case 'ms':
|
---|
| 232 | durationInMs = duration;
|
---|
| 233 | break;
|
---|
| 234 | case 's':
|
---|
| 235 | durationInMs = duration * 1000;
|
---|
| 236 | break;
|
---|
| 237 | case 'm':
|
---|
| 238 | durationInMs = duration * 1000 * 60;
|
---|
| 239 | break;
|
---|
| 240 | default:
|
---|
| 241 | break;
|
---|
| 242 | }
|
---|
| 243 |
|
---|
| 244 | advanceFrameBy(durationInMs / this.frameTimeFactor);
|
---|
| 245 | break;
|
---|
| 246 | }
|
---|
| 247 | }
|
---|
| 248 | }
|
---|
| 249 |
|
---|
| 250 | throw new Error('there can only be \'^\' and \'!\' markers in a ' +
|
---|
| 251 | 'subscription marble diagram. Found instead \'' + c + '\'.');
|
---|
| 252 | }
|
---|
| 253 |
|
---|
| 254 | frame = nextFrame;
|
---|
| 255 | }
|
---|
| 256 |
|
---|
| 257 | if (unsubscriptionFrame < 0) {
|
---|
| 258 | return new SubscriptionLog(subscriptionFrame);
|
---|
| 259 | } else {
|
---|
| 260 | return new SubscriptionLog(subscriptionFrame, unsubscriptionFrame);
|
---|
| 261 | }
|
---|
| 262 | }
|
---|
| 263 |
|
---|
| 264 | /** @nocollapse */
|
---|
| 265 | static parseMarbles(marbles: string,
|
---|
| 266 | values?: any,
|
---|
| 267 | errorValue?: any,
|
---|
| 268 | materializeInnerObservables: boolean = false,
|
---|
| 269 | runMode = false): TestMessage[] {
|
---|
| 270 | if (marbles.indexOf('!') !== -1) {
|
---|
| 271 | throw new Error('conventional marble diagrams cannot have the ' +
|
---|
| 272 | 'unsubscription marker "!"');
|
---|
| 273 | }
|
---|
| 274 | const len = marbles.length;
|
---|
| 275 | const testMessages: TestMessage[] = [];
|
---|
| 276 | const subIndex = runMode ? marbles.replace(/^[ ]+/, '').indexOf('^') : marbles.indexOf('^');
|
---|
| 277 | let frame = subIndex === -1 ? 0 : (subIndex * -this.frameTimeFactor);
|
---|
| 278 | const getValue = typeof values !== 'object' ?
|
---|
| 279 | (x: any) => x :
|
---|
| 280 | (x: any) => {
|
---|
| 281 | // Support Observable-of-Observables
|
---|
| 282 | if (materializeInnerObservables && values[x] instanceof ColdObservable) {
|
---|
| 283 | return values[x].messages;
|
---|
| 284 | }
|
---|
| 285 | return values[x];
|
---|
| 286 | };
|
---|
| 287 | let groupStart = -1;
|
---|
| 288 |
|
---|
| 289 | for (let i = 0; i < len; i++) {
|
---|
| 290 | let nextFrame = frame;
|
---|
| 291 | const advanceFrameBy = (count: number) => {
|
---|
| 292 | nextFrame += count * this.frameTimeFactor;
|
---|
| 293 | };
|
---|
| 294 |
|
---|
| 295 | let notification: Notification<any>;
|
---|
| 296 | const c = marbles[i];
|
---|
| 297 | switch (c) {
|
---|
| 298 | case ' ':
|
---|
| 299 | // Whitespace no longer advances time
|
---|
| 300 | if (!runMode) {
|
---|
| 301 | advanceFrameBy(1);
|
---|
| 302 | }
|
---|
| 303 | break;
|
---|
| 304 | case '-':
|
---|
| 305 | advanceFrameBy(1);
|
---|
| 306 | break;
|
---|
| 307 | case '(':
|
---|
| 308 | groupStart = frame;
|
---|
| 309 | advanceFrameBy(1);
|
---|
| 310 | break;
|
---|
| 311 | case ')':
|
---|
| 312 | groupStart = -1;
|
---|
| 313 | advanceFrameBy(1);
|
---|
| 314 | break;
|
---|
| 315 | case '|':
|
---|
| 316 | notification = Notification.createComplete();
|
---|
| 317 | advanceFrameBy(1);
|
---|
| 318 | break;
|
---|
| 319 | case '^':
|
---|
| 320 | advanceFrameBy(1);
|
---|
| 321 | break;
|
---|
| 322 | case '#':
|
---|
| 323 | notification = Notification.createError(errorValue || 'error');
|
---|
| 324 | advanceFrameBy(1);
|
---|
| 325 | break;
|
---|
| 326 | default:
|
---|
| 327 | // Might be time progression syntax, or a value literal
|
---|
| 328 | if (runMode && c.match(/^[0-9]$/)) {
|
---|
| 329 | // Time progression must be preceeded by at least one space
|
---|
| 330 | // if it's not at the beginning of the diagram
|
---|
| 331 | if (i === 0 || marbles[i - 1] === ' ') {
|
---|
| 332 | const buffer = marbles.slice(i);
|
---|
| 333 | const match = buffer.match(/^([0-9]+(?:\.[0-9]+)?)(ms|s|m) /);
|
---|
| 334 | if (match) {
|
---|
| 335 | i += match[0].length - 1;
|
---|
| 336 | const duration = parseFloat(match[1]);
|
---|
| 337 | const unit = match[2];
|
---|
| 338 | let durationInMs: number;
|
---|
| 339 |
|
---|
| 340 | switch (unit) {
|
---|
| 341 | case 'ms':
|
---|
| 342 | durationInMs = duration;
|
---|
| 343 | break;
|
---|
| 344 | case 's':
|
---|
| 345 | durationInMs = duration * 1000;
|
---|
| 346 | break;
|
---|
| 347 | case 'm':
|
---|
| 348 | durationInMs = duration * 1000 * 60;
|
---|
| 349 | break;
|
---|
| 350 | default:
|
---|
| 351 | break;
|
---|
| 352 | }
|
---|
| 353 |
|
---|
| 354 | advanceFrameBy(durationInMs / this.frameTimeFactor);
|
---|
| 355 | break;
|
---|
| 356 | }
|
---|
| 357 | }
|
---|
| 358 | }
|
---|
| 359 |
|
---|
| 360 | notification = Notification.createNext(getValue(c));
|
---|
| 361 | advanceFrameBy(1);
|
---|
| 362 | break;
|
---|
| 363 | }
|
---|
| 364 |
|
---|
| 365 | if (notification) {
|
---|
| 366 | testMessages.push({ frame: groupStart > -1 ? groupStart : frame, notification });
|
---|
| 367 | }
|
---|
| 368 |
|
---|
| 369 | frame = nextFrame;
|
---|
| 370 | }
|
---|
| 371 | return testMessages;
|
---|
| 372 | }
|
---|
| 373 |
|
---|
| 374 | run<T>(callback: (helpers: RunHelpers) => T): T {
|
---|
| 375 | const prevFrameTimeFactor = TestScheduler.frameTimeFactor;
|
---|
| 376 | const prevMaxFrames = this.maxFrames;
|
---|
| 377 |
|
---|
| 378 | TestScheduler.frameTimeFactor = 1;
|
---|
| 379 | this.maxFrames = Number.POSITIVE_INFINITY;
|
---|
| 380 | this.runMode = true;
|
---|
| 381 | AsyncScheduler.delegate = this;
|
---|
| 382 |
|
---|
| 383 | const helpers = {
|
---|
| 384 | cold: this.createColdObservable.bind(this),
|
---|
| 385 | hot: this.createHotObservable.bind(this),
|
---|
| 386 | flush: this.flush.bind(this),
|
---|
| 387 | expectObservable: this.expectObservable.bind(this),
|
---|
| 388 | expectSubscriptions: this.expectSubscriptions.bind(this),
|
---|
| 389 | };
|
---|
| 390 | try {
|
---|
| 391 | const ret = callback(helpers);
|
---|
| 392 | this.flush();
|
---|
| 393 | return ret;
|
---|
| 394 | } finally {
|
---|
| 395 | TestScheduler.frameTimeFactor = prevFrameTimeFactor;
|
---|
| 396 | this.maxFrames = prevMaxFrames;
|
---|
| 397 | this.runMode = false;
|
---|
| 398 | AsyncScheduler.delegate = undefined;
|
---|
| 399 | }
|
---|
| 400 | }
|
---|
| 401 | }
|
---|