Add XMLHttpRequestUpload support

README.md

@@ -134,6 +134,14 @@ Get the request headers.
 
 Get the request body.
 
+#### .progress(loaded : number, total : number, lengthComputable : bool)
+
+Trigger progress event. Pass in loaded size, total size and if event is lengthComputable.
+
+#### .uploadProgress(loaded : number, total : number, lengthComputable : bool)
+
+Trigger progress event on the upload object. Pass in loaded size, total size and if event is lengthComputable.
+
 ### MockResponse
 
 #### .status() : number
@@ -184,10 +192,6 @@ Get whether the response will trigger a time out.
 
 Set whether the response will trigger a time out. `timeout` defaults to the value set on the XHR object.
 
-#### .progress(loaded : number, total : number, lengthComputable : bool)
-
-Trigger progress event. Pass in loaded size, total size and if event is lengthComputable.
-
 ## Change log
 
 ### 1.9.0

lib/MockEventTarget.js

@@ -0,0 +1,51 @@
+/**
+ * An EventTarget object
+ * @constructor
+ */
+function MockEventTarget() {
+  this._eventListeners = [];
+}
+
+
+/**
+ * Trigger an event
+ * @param   {String} event
+ * @param   {Object} eventDetails
+ * @returns {MockEventTarget}
+ */
+MockEventTarget.prototype.trigger = function(event, eventDetails) {
+  for (var x = 0; x < this._eventListeners.length; x++) {
+    var eventListener = this._eventListeners[x];
+
+    if (eventListener.event === event) {
+      var eventListenerDetails = eventDetails || {};
+      eventListenerDetails.currentTarget = this;
+      eventListenerDetails.type = event;
+      eventListener.listener.call(this, eventListenerDetails);
+    }
+  }
+
+  return this;
+};
+
+MockEventTarget.prototype.addEventListener = function(event, listener) {
+  this._eventListeners.push({
+    event: event,
+    listener: listener
+  });
+};
+
+MockEventTarget.prototype.removeEventListener = function(event, listener) {
+  var currentIndex = 0;
+
+  while (currentIndex < this._eventListeners.length) {
+    var eventListener = this._eventListeners[currentIndex];
+    if (eventListener.event === event && eventListener.listener === listener) {
+      this._eventListeners.splice(currentIndex, 1);
+    } else {
+      currentIndex++;
+    }
+  }
+};
+
+module.exports = MockEventTarget;

lib/MockRequest.js

@@ -100,4 +100,20 @@ MockRequest.prototype.progress = function(loaded, total, lengthComputable) {
   })
 };
 
+
+/**
+ * Trigger upload progress event
+ * @param   {number} [loaded]
+ * @param   {number} [total]
+ * @param   {boolean} [lengthComputable]
+ * @returns {}
+ */
+MockRequest.prototype.uploadProgress = function(loaded, total, lengthComputable) {
+  this._xhr.upload.trigger('progress', {
+    lengthComputable: lengthComputable || true,
+    loaded: loaded,
+    total: total
+  })
+};
+
 module.exports = MockRequest;

lib/MockXMLHttpRequest.js

@@ -1,5 +1,6 @@
 var MockRequest   = require('./MockRequest');
 var MockResponse  = require('./MockResponse');
+var MockEventTarget = require('./MockEventTarget');
 
 var notImplementedError = new Error('This feature hasn\'t been implmented yet. Please submit an Issue or Pull Request on Github.');
 
@@ -72,14 +73,18 @@ MockXMLHttpRequest.handle = function(request) {
  * @constructor
  */
 function MockXMLHttpRequest() {
+  MockEventTarget.call(this);
   this.reset();
-  this._eventListeners = [];
+  this.upload = new MockEventTarget();
   this.timeout = 0;
   // some libraries (like Mixpanel) use the presence of this field to check if XHR is properly supported
   // https://developer.mozilla.org/en-US/docs/Web/API/XMLHttpRequest/withCredentials
   this.withCredentials = false;
 }
 
+MockXMLHttpRequest.prototype = Object.create(MockEventTarget.prototype);
+MockXMLHttpRequest.prototype.constructor = MockXMLHttpRequest;
+
 /**
  * Reset the response values
  * @private
@@ -115,18 +120,7 @@ MockXMLHttpRequest.prototype.trigger = function(event, eventDetails) {
     this['on'+event]();
   }
 
-  for (var x = 0; x < this._eventListeners.length; x++) {
-    var eventListener = this._eventListeners[x];
-
-    if (eventListener.event === event) {
-      var eventListenerDetails = eventDetails || {};
-      eventListenerDetails.currentTarget = this;
-      eventListenerDetails.type = event;
-      eventListener.listener.call(this, eventListenerDetails);
-    }
-  }
-
-  return this;
+  return MockEventTarget.prototype.trigger.apply(this, arguments);
 };
 
 MockXMLHttpRequest.prototype.open = function(method, url, async, user, password) {
@@ -171,6 +165,8 @@ MockXMLHttpRequest.prototype.send = function(data) {
         }, typeof(timeout) === 'number' ? timeout : self.timeout+1);
 
       } else {
+        //trigger a load event to indicate the data has been sent
+        self.upload.trigger('load');
 
         //map the response to the XHR object
         self.status             = response.status();
@@ -203,6 +199,7 @@ MockXMLHttpRequest.prototype.abort = function() {
 
   if (this.readyState > MockXMLHttpRequest.STATE_UNSENT && this.readyState < MockXMLHttpRequest.STATE_DONE) {
     this.readyState = MockXMLHttpRequest.STATE_UNSENT;
+    this.upload.trigger('abort');
     this.trigger('abort');
   }
 
@@ -233,24 +230,4 @@ MockXMLHttpRequest.prototype.getResponseHeader = function(name) {
   return this._responseHeaders[name.toLowerCase()] || null;
 };
 
-MockXMLHttpRequest.prototype.addEventListener = function(event, listener) {
-  this._eventListeners.push({
-    event: event,
-    listener: listener
-  });
-};
-
-MockXMLHttpRequest.prototype.removeEventListener = function(event, listener) {
-  var currentIndex = 0;
-
-  while (currentIndex < this._eventListeners.length) {
-    var eventListener = this._eventListeners[currentIndex];
-    if (eventListener.event === event && eventListener.listener === listener) {
-      this._eventListeners.splice(currentIndex, 1);
-    } else {
-      currentIndex++;
-    }
-  }
-};
-
 module.exports = MockXMLHttpRequest;

test/MockXMLHttpRequest.js

@@ -262,4 +262,82 @@ describe('MockXMLHttpRequest', function() {
 
   });
 
+  describe('upload.addEventListener()', function() {
+
+    it('should allow registering load event listener', function(done) {
+
+      MockXMLHttpRequest.addHandler(function(req, res) {
+        return res
+      });
+
+      var xhr = new MockXMLHttpRequest();
+      xhr.upload.addEventListener('load', function(event) {
+        assert.equal(event.currentTarget, xhr.upload);
+        assert.equal(event.type, 'load');
+        assert.equal(this, xhr.upload);
+        done();
+      });
+      xhr.open('/');
+      xhr.send();
+
+    });
+
+    it('should allow registering abort event listener', function(done) {
+
+      MockXMLHttpRequest.addHandler(function(req, res) {
+        return res
+      });
+
+      var xhr = new MockXMLHttpRequest();
+      xhr.upload.addEventListener('abort', function(event) {
+        assert.equal(event.currentTarget, xhr.upload);
+        assert.equal(this, xhr.upload);
+        done();
+      });
+      xhr.open('/');
+      xhr.send();
+      xhr.abort();
+
+    });
+
+    it('should allow registering progress event listener', function(done) {
+
+      MockXMLHttpRequest.addHandler(function(req, res) {
+        req.uploadProgress(50, 100);
+
+        return res
+      });
+
+      var xhr = new MockXMLHttpRequest();
+      xhr.upload.addEventListener('progress', function(event) {
+        assert.equal(event.lengthComputable, true);
+        assert.equal(event.loaded, 50);
+        assert.equal(event.total, 100);
+        done();
+      });
+      xhr.open('/');
+      xhr.send();
+
+    });
+
+    it('should allow unregistering event listener', function(done) {
+
+      MockXMLHttpRequest.addHandler(function(req, res) {
+        return res
+      });
+
+      var xhr = new MockXMLHttpRequest();
+      var removeLoadFunction = function () { done() }
+      xhr.upload.addEventListener('load', function(event) {
+        done();
+      });
+      xhr.upload.addEventListener('load', removeLoadFunction);
+      xhr.upload.removeEventListener('load', removeLoadFunction);
+      xhr.open('/');
+      xhr.send();
+
+    });
+
+  })
+
 });