Error handling and tests, dojo#59

rorticus · Dec 2, 2016 · 4974ebb · 4974ebb
1 parent 838548b
commit 4974ebb
Show file tree

Hide file tree

Showing 2 changed files with 141 additions and 9 deletions.
diff --git a/src/Observable.ts b/src/Observable.ts
@@ -56,7 +56,13 @@ namespace Shim {
 				this._observer.start(this);
 			}
 
-			this._closer = executor(this);
+			try {
+				this._closer = executor(this);
+			}
+			catch (e) {
+				this.error(e);
+				return;
+			}
 		}
 
 		next(value: any): any {

diff --git a/tests/unit/Observable.ts b/tests/unit/Observable.ts
@@ -2,6 +2,7 @@ import * as registerSuite from 'intern!object';
 import * as assert from 'intern/chai!assert';
 import Observable from '../../src/Observable';
 import Map from '../../src/Map';
+import { queueMicroTask } from '../../src/support/queue';
 import '../../src/Symbol';
 
 registerSuite({
@@ -58,16 +59,62 @@ registerSuite({
 	},
 
 	'creation': {
-		'constructor'(this: any) {
-			let dfd = this.async();
+		'constructor': {
+			'constructor'(this: any) {
+				let dfd = this.async();
 
-			let source = new Observable((observer) => {
-				observer.next(1);
-			});
+				let source = new Observable((observer) => {
+					observer.next(1);
+				});
+
+				source.subscribe(dfd.callback((value: any) => {
+					assert.strictEqual(value, 1);
+				}));
+			},
+			'thrown error during subscription'(this: any) {
+				const dfd = this.async();
+				const source = new Observable((observer) => {
+					observer.next(1);
+					throw new Error('error');
+				});
+
+				let values: any[] = [];
+
+				source.subscribe((value: any) => {
+					values.push(value);
+				}, dfd.callback((error: Error) => {
+					assert.deepEqual(values, [ 1 ]);
+					assert.strictEqual(error.message, 'error');
+				}), dfd.rejectOnError(() => {
+					assert.fail('Should not have completed');
+				}));
+			},
+			'manual error during subscription w/ error handler'(this: any) {
+				const dfd = this.async();
+				const source = new Observable((observer) => {
+					observer.error(new Error('error'));
+				});
+
+				source.subscribe(dfd.rejectOnError(() => {
+					assert.fail('should not have called next');
+				}), dfd.callback((error: Error) => {
+					assert.strictEqual(error.message, 'error');
+				}), dfd.rejectOnError(() => {
+					assert.fail('Should not have completed');
+				}));
+			},
+			'manual error during subscription w/ completion handler'(this: any) {
+				const dfd = this.async();
+				const source = new Observable((observer) => {
+					observer.error(new Error('error'));
+				});
 
-			source.subscribe(dfd.callback((value: any) => {
-				assert.strictEqual(value, 1);
-			}));
+				source.subscribe(dfd.rejectOnError(() => {
+					assert.fail('should not have called next');
+				}), undefined, dfd.callback((error: Error) => {
+					assert.strictEqual(error.message, 'error');
+				}));
+			}
 		},
 		'of': {
 			'multiple values'(this: any) {
@@ -204,6 +251,85 @@ registerSuite({
 				setTimeout(dfd.callback(() => {
 					assert.deepEqual(values, [ 1 ]);
 				}), 100);
+			},
+			'thrown error in subscriber'(this: any) {
+				const dfd = this.async();
+				const source = Observable.of(1, 2, 3);
+
+				source.subscribe(() => {
+					throw new Error('error');
+				}, dfd.callback((error: Error) => {
+					assert.strictEqual(error.message, 'error');
+				}), dfd.rejectOnError(() => {
+					assert.fail('Should not have completed');
+				}));
+			}
+		},
+		'unsubscribe': {
+			'with unsubscribe handler'(this: any) {
+				let unsubscribed = false;
+				const dfd = this.async();
+				const source = new Observable((observer) => {
+					queueMicroTask(() => {
+						observer.next(0);
+
+						queueMicroTask(() => {
+							observer.next(1);
+
+							queueMicroTask(() => {
+								observer.next(2);
+							});
+						});
+					});
+					return () => {
+						unsubscribed = true;
+					};
+				});
+
+				let values: any[] = [];
+
+				const subscription = source.subscribe((value: any) => {
+					values.push(value);
+
+					if (value === 1) {
+						subscription.unsubscribe();
+					}
+				});
+
+				setTimeout(dfd.callback(() => {
+					assert.deepEqual(values, [ 0, 1 ]);
+					assert.isTrue(unsubscribed);
+				}), 100);
+			},
+			'without unsubscribe handler'(this: any) {
+				const dfd = this.async();
+				const source = new Observable((observer) => {
+					queueMicroTask(() => {
+						observer.next(0);
+
+						queueMicroTask(() => {
+							observer.next(1);
+
+							queueMicroTask(() => {
+								observer.next(2);
+							});
+						});
+					});
+				});
+
+				let values: any[] = [];
+
+				const subscription = source.subscribe((value: any) => {
+					values.push(value);
+
+					if (value === 1) {
+						subscription.unsubscribe();
+					}
+				});
+
+				setTimeout(dfd.callback(() => {
+					assert.deepEqual(values, [ 0, 1 ]);
+				}), 100);
 			}
 		}
 	}