Close #165 PR: Support Observable. Fixes #84

Author: BarryThePenguin

lib/assert.js

@@ -1,9 +1,12 @@
 'use strict';
 var assert = require('core-assert');
+var observableSymbol = require('./symbol')('observable');
 var x = module.exports;
 
 Object.defineProperty(x, 'AssertionError', {value: assert.AssertionError});
 
+function noop() {}
+
 function create(val, expected, operator, msg, fn) {
 	return {
 		actual: val,
@@ -69,10 +72,14 @@ x.notSame = function (val, expected, msg) {
 };
 
 x.throws = function (fn, err, msg) {
+	if (fn && fn[observableSymbol]) {
+		fn = fn[observableSymbol]().forEach(noop);
+	}
+
 	if (fn && fn.then) {
 		return fn
 			.then(function () {
-				x.throws(function () {}, err, msg);
+				x.throws(noop, err, msg);
 			}, function (fnErr) {
 				x.throws(function () {
 					throw fnErr;
@@ -95,6 +102,10 @@ x.throws = function (fn, err, msg) {
 };
 
 x.doesNotThrow = function (fn, msg) {
+	if (fn && fn[observableSymbol]) {
+		fn = fn[observableSymbol]().forEach(noop);
+	}
+
 	if (fn && fn.then) {
 		return fn
 			.catch(function (err) {

lib/symbol.js

@@ -0,0 +1,18 @@
+function polyfillSymbol(key) {
+	if (typeof Symbol === 'function' && !Symbol[key]) {
+		Object.defineProperty(Symbol, key, {
+			value: Symbol(key)
+		});
+	}
+}
+
+polyfillSymbol('observable');
+
+module.exports = function (key) {
+	if (typeof Symbol !== 'undefined' && Symbol[key]) {
+		return Symbol[key];
+	} else if (typeof Symbol !== 'undefined' && typeof Symbol.for === 'function') {
+		return Symbol.for(key);
+	}
+	return '@@' + key;
+};

lib/test.js

@@ -5,8 +5,11 @@ var setImmediate = require('set-immediate-shim');
 var fnName = require('fn-name');
 var co = require('co-with-promise');
 var maxTimeout = require('max-timeout');
+var observableSymbol = require('./symbol')('observable');
 var assert = require('./assert');
 
+function noop() {}
+
 function Test(title, fn) {
 	if (!(this instanceof Test)) {
 		return new Test(title, fn);
@@ -56,6 +59,10 @@ Object.keys(assert).forEach(function (el) {
 		try {
 			var fn = assert[el].apply(assert, arguments);
 
+			if (fn && fn[observableSymbol]) {
+				fn = fn[observableSymbol]().forEach(noop);
+			}
+
 			if (fn && fn.then) {
 				return fn
 					.then(function () {
@@ -112,6 +119,10 @@ Test.prototype.run = function () {
 		try {
 			var ret = this.fn(this);
 
+			if (ret && ret[observableSymbol]) {
+				ret = ret[observableSymbol]().forEach(noop);
+			}
+
 			if (ret && typeof ret.then === 'function') {
 				ret
 					.then(function () {

package.json

@@ -96,6 +96,7 @@
     "signal-exit": "^2.1.2",
     "tap-spec": "^4.1.0",
     "tape": "^4.0.0",
-    "xo": "*"
+    "xo": "*",
+    "zen-observable": "^0.1.6"
   }
 }

test/fixture/observable.js

@@ -0,0 +1,13 @@
+var Promise = require('bluebird');
+
+// global Promise for zen-observable
+if (!global.Promise) {
+	Object.defineProperty(global, 'Promise', {
+		value: Promise,
+		configurable: true,
+		enumerable: false,
+		writable: true
+	});
+}
+
+module.exports = require('zen-observable');

test/test.js

@@ -7,6 +7,7 @@ var test = require('tape');
 var Runner = require('../lib/runner');
 var fork = require('../lib/fork');
 var ava = require('../lib/test');
+var Observable = require('./fixture/observable');
 
 function execCli(args, cb) {
 	if (!Array.isArray(args)) {
@@ -97,6 +98,25 @@ test('plan assertions with support for promises', function (t) {
 	});
 });
 
+test('plan assertions with support for observables', function (t) {
+	ava(function (a) {
+		a.plan(2);
+
+		var observable = Observable.of();
+
+		setTimeout(function () {
+			a.pass();
+			a.pass();
+		}, 200);
+
+		return observable;
+	}).run().then(function (a) {
+		t.is(a.planCount, 2);
+		t.is(a.assertCount, 2);
+		t.end();
+	});
+});
+
 test('run more assertions than planned', function (t) {
 	ava(function (a) {
 		a.plan(2);
@@ -276,6 +296,94 @@ test('handle throws with false-positive promise', function (t) {
 	});
 });
 
+test('handle throws with thrown observable', function (t) {
+	ava(function (a) {
+		a.plan(1);
+
+		var observable = new Observable(function (observer) {
+			observer.error(new Error());
+		});
+		a.throws(observable);
+	}).run().then(function (a) {
+		t.false(a.assertError);
+		t.end();
+	});
+});
+
+test('handle throws with long running thrown observable', function (t) {
+	ava(function (a) {
+		a.plan(1);
+
+		var observable = new Observable(function (observer) {
+			setTimeout(function () {
+				observer.error(new Error('abc'));
+			}, 2000);
+		});
+
+		a.throws(observable, /abc/);
+	}).run().then(function (a) {
+		t.false(a.assertError);
+		t.end();
+	});
+});
+
+test('handle throws with completed observable', function (t) {
+	ava(function (a) {
+		a.plan(1);
+
+		var observable = Observable.of();
+		a.throws(observable);
+	}).run().catch(function (err) {
+		t.true(err);
+		t.is(err.name, 'AssertionError');
+		t.end();
+	});
+});
+
+test('handle throws with regex', function (t) {
+	ava(function (a) {
+		a.plan(1);
+
+		var observable = new Observable(function (observer) {
+			observer.error(new Error('abc'));
+		});
+		a.throws(observable, /abc/);
+	}).run().then(function (a) {
+		t.false(a.assertionError);
+		t.end();
+	});
+});
+
+test('handle throws with string', function (t) {
+	ava(function (a) {
+		a.plan(1);
+
+		var observable = new Observable(function (observer) {
+			observer.error(new Error('abc'));
+		});
+		a.throws(observable, 'abc');
+	}).run().then(function (a) {
+		t.false(a.assertionError);
+		t.end();
+	});
+});
+
+test('handle throws with false-positive observable', function (t) {
+	ava(function (a) {
+		a.plan(1);
+
+		var observable = new Observable(function (observer) {
+			observer.next(new Error());
+			observer.complete();
+		});
+		a.throws(observable);
+	}).run().catch(function (err) {
+		t.true(err);
+		t.is(err.name, 'AssertionError');
+		t.end();
+	});
+});
+
 test('handle doesNotThrow with error', function (t) {
 	ava(function (a) {
 		a.doesNotThrow(function () {
@@ -328,6 +436,33 @@ test('handle doesNotThrow with rejected promise', function (t) {
 	});
 });
 
+test('handle doesNotThrow with completed observable', function (t) {
+	ava(function (a) {
+		a.plan(1);
+
+		var observable = Observable.of();
+		a.doesNotThrow(observable);
+	}).run().then(function (a) {
+		t.false(a.assertError);
+		t.end();
+	});
+});
+
+test('handle doesNotThrow with thrown observable', function (t) {
+	ava(function (a) {
+		a.plan(1);
+
+		var observable = new Observable(function (observer) {
+			observer.error(new Error());
+		});
+		a.doesNotThrow(observable);
+	}).run().catch(function (err) {
+		t.true(err);
+		t.is(err.name, 'AssertionError');
+		t.end();
+	});
+});
+
 test('run functions after last planned assertion', function (t) {
 	var i = 0;