Adding more fromEventPattern tests

Author: mattpodwysocki

tests/observable/fromeventpattern.js

@@ -1,11 +1,72 @@
 (function () {
+  'use strict';
   /* jshint undef: true, unused: true */
   /* globals QUnit, test, Rx, equal */
+  var Observable = Rx.Observable,
+    slice = Array.prototype.slice,
+    onNext = Rx.ReactiveTest.onNext,
+    onError = Rx.ReactiveTest.onError;
 
-  QUnit.module('FromEventPattern');
+  QUnit.module('fromEventPattern', {
+    setup : function() {
+      this.scheduler = new Rx.TestScheduler();
+    }
+  });
+
+  function FakeDojoElement(nodeName) {
+    this.listeners = {};
+    this.nodeName = nodeName;
+    this.onCalled = false;
+    this.offCalled = false;
+  }
+
+  FakeDojoElement.prototype.on = function (eventName, handler) {
+    this.listeners[eventName] = handler;
+    this.onCalled = true;
+    return new FakeDojoDisposable(this, eventName);
+  };
+
+  FakeDojoElement.prototype.trigger = function (eventName) {
+    var args = slice.call(arguments, 1);
+    if (eventName in this.listeners) {
+      this.listeners[eventName].apply(null, args);
+    }
+  };
+
+  function FakeDojoDisposable(parent, eventName) {
+    this.parent = parent;
+    this.eventName = eventName;
+  }
+
+  FakeDojoDisposable.prototype.disconnect = function () {
+    delete this.parent.listeners[this.eventName];
+    this.parent.offCalled = true;
+  };
+
+  test('fromEventPattern with return from add handler', function () {
+    var element = new FakeDojoElement('foo');
+
+    this.scheduler.scheduleFuture(null, 210, function() {
+      equal(element.onCalled, true);
+      equal(element.offCalled, false);
+    });
+
+    this.scheduler.scheduleFuture(null, 220, function() {
+      element.trigger('someEvent', 42);
+    });
+
+    var result = this.scheduler.startScheduler(function() {
+      return Observable.fromEventPattern(
+        function (h) { return element.on('someEvent', h); },
+        function (_, d) { d.disconnect(); }
+      );
+    });
+
+    result.messages.assertEqual(onNext(220, 42));
+
+    equal(element.offCalled, true);
+  });
 
-  var Observable = Rx.Observable,
-      slice = Array.prototype.slice;
 
   /** Fake DOM Element */
   function FakeDOMStandardElement(nodeName) {
@@ -15,12 +76,12 @@
     this.removeEventListenerCalled = false;
   }
 
-  FakeDOMStandardElement.prototype.addEventListener = function (eventName, handler) {
+  FakeDOMStandardElement.prototype.addEventListener = function (eventName, handler, useCapture) {
     this.listeners[eventName] = handler;
     this.addEventListenerCalled = true;
   };
 
-  FakeDOMStandardElement.prototype.removeEventListener = function (eventName, handler) {
+  FakeDOMStandardElement.prototype.removeEventListener = function (eventName, handler, useCapture) {
     delete this.listeners[eventName];
     this.removeEventListenerCalled = true;
   };
@@ -32,46 +93,86 @@
     }
   };
 
-  test('Event 1', function () {
+  test('fromEventPattern', function () {
     var element = new FakeDOMStandardElement('foo');
 
-    var d = Observable.fromEventPattern(
-      function (h) { element.addEventListener('someEvent', h, false); },
-      function (h) { element.removeEventListener('someEvent', h, false); }
-    )
-    .subscribe(function (x) {
-      equal(x, 42);
+    this.scheduler.scheduleFuture(null, 210, function() {
+      equal(element.addEventListenerCalled, true);
+      equal(element.removeEventListenerCalled, false);
     });
 
-    element.trigger('someEvent', 42);
-    equal(element.addEventListenerCalled, true);
-    equal(element.removeEventListenerCalled, false);
+    this.scheduler.scheduleFuture(null, 220, function() {
+      element.trigger('someEvent', 42);
+    });
 
-    d.dispose();
+    var result = this.scheduler.startScheduler(function() {
+      return Observable.fromEventPattern(
+        function (h) { element.addEventListener('someEvent', h); },
+        function (h) { element.removeEventListener('someEvent', h); }
+      );
+    });
+
+    result.messages.assertEqual(onNext(220, 42));
 
     equal(element.removeEventListenerCalled, true);
   });
 
-  test('Event 2', function () {
+  test('fromEventPattern selector', function () {
     var element = new FakeDOMStandardElement('foo');
 
-    var d = Observable.fromEventPattern(
-        function (h) { element.addEventListener('someEvent', h, false); },
-        function (h) { element.removeEventListener('someEvent', h, false); },
+    this.scheduler.scheduleFuture(null, 210, function() {
+      equal(element.addEventListenerCalled, true);
+      equal(element.removeEventListenerCalled, false);
+    });
+
+    this.scheduler.scheduleFuture(null, 220, function() {
+      element.trigger('someEvent', 'baz', 'quux');
+    });
+
+    var result = this.scheduler.startScheduler(function() {
+      return Observable.fromEventPattern(
+        function (h) { element.addEventListener('someEvent', h); },
+        function (h) { element.removeEventListener('someEvent', h); },
         function (baz, quux) {
           return { foo: baz, bar: quux };
         }
-      )
-      .subscribe(function (x) {
-        equal(x.foo, 'baz');
-        equal(x.bar, 'quux');
-      });
+      );
+    });
 
-    element.trigger('someEvent', 'baz', 'quux');
-    equal(element.addEventListenerCalled, true);
-    equal(element.removeEventListenerCalled, false);
+    result.messages.assertEqual(
+      onNext(220, {foo: 'baz', bar: 'quux'})
+    );
+
+    equal(element.removeEventListenerCalled, true);
+  });
+
+  test('fromEventPattern selector throws', function () {
+    var error = new Error();
+
+    var element = new FakeDOMStandardElement('foo');
+
+    this.scheduler.scheduleFuture(null, 210, function() {
+      equal(element.addEventListenerCalled, true);
+      equal(element.removeEventListenerCalled, false);
+    });
+
+    this.scheduler.scheduleFuture(null, 220, function() {
+      element.trigger('someEvent', 'baz', 'quux');
+    });
+
+    var result = this.scheduler.startScheduler(function() {
+      return Observable.fromEventPattern(
+        function (h) { element.addEventListener('someEvent', h); },
+        function (h) { element.removeEventListener('someEvent', h); },
+        function () {
+          throw error;
+        }
+      );
+    });
 
-    d.dispose();
+    result.messages.assertEqual(
+      onError(220, error)
+    );
 
     equal(element.removeEventListenerCalled, true);
   });