Added mock_xhr module w/ unit tests.

remoting/webapp/crd/js/xhr.js

 // Copyright (c) 2011 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 /**
  * @fileoverview
  * Utility class for making XHRs more pleasant.
+ *
+ * Note: a mock version of this API exists in mock_xhr.js.
  */
 
 'use strict';
 
 /** @suppress {duplicate} */
 var remoting = remoting || {};
 
 /**
  * @constructor
  * @param {remoting.Xhr.Params} params
  */
 remoting.Xhr = function(params) {
   remoting.Xhr.checkParams_(params);
 
   // Apply URL parameters.
   var url = params.url;
   var parameterString = '';
   if (typeof(params.urlParams) === 'string') {
     parameterString = params.urlParams;
   } else if (typeof(params.urlParams) === 'object') {
     parameterString = remoting.Xhr.urlencodeParamHash(
-        remoting.Xhr.removeNullFields_(params.urlParams));
+        base.copyWithoutNullFields(params.urlParams));
   }
   if (parameterString) {
     url += '?' + parameterString;
   }
 
   // Prepare the build modified headers.
   /** @const */
-  this.headers_ = remoting.Xhr.removeNullFields_(params.headers);
+  this.headers_ = base.copyWithoutNullFields(params.headers);
 
   // Convert the content fields to a single text content variable.
   /** @private {?string} */
   this.content_ = null;
   if (params.textContent !== undefined) {
     this.maybeSetContentType_('text/plain');
     this.content_ = params.textContent;
   } else if (params.formContent !== undefined) {
     this.maybeSetContentType_('application/x-www-form-urlencoded');
     this.content_ = remoting.Xhr.urlencodeParamHash(params.formContent);
@@ skipping 105 matching lines @@
     } else {
       this.sendXhr_();
     }
   }
   return this.deferred_.promise();
 };
 
 /**
  * @param {remoting.Xhr.Params} params
  * @throws {Error} if params are invalid
+ * @private
  */
 remoting.Xhr.checkParams_ = function(params) {
   if (params.urlParams) {
     if (params.url.indexOf('?') != -1) {
       throw new Error('URL may not contain "?" when urlParams is set');
     }
     if (params.url.indexOf('#') != -1) {
       throw new Error('URL may not contain "#" when urlParams is set');
     }
   }
@@ skipping 54 matching lines @@
   if (!(key in this.headers_)) {
     this.headers_[key] = value;
     return true;
   }
   return false;
 };
 
 /** @private */
 remoting.Xhr.prototype.sendXhr_ = function() {
   for (var key in this.headers_) {
-    this.nativeXhr_.setRequestHeader(key, this.headers_[key]);
+    this.nativeXhr_.setRequestHeader(
+        key, /** @type {string} */ (this.headers_[key]));
   }
   this.nativeXhr_.send(this.content_);
   this.content_ = null;  // for gc
 };
 
 /**
  * @private
  */
 remoting.Xhr.prototype.onReadyStateChange_ = function() {
   var xhr = this.nativeXhr_;
   if (xhr.readyState == 4) {
     // See comments at remoting.Xhr.Response.
-    this.deferred_.resolve(new remoting.Xhr.Response(
+    this.deferred_.resolve(remoting.Xhr.Response.fromXhr_(
         xhr, this.acceptJson_));
   }
 };
 
 /**
  * The response-related parts of an XMLHttpRequest.  Note that this
  * class is not just a facade for XMLHttpRequest; it saves the value
  * of the |responseText| field becuase once onReadyStateChange_
  * (above) returns, the value of |responseText| is reset to the empty
  * string!  This is a documented anti-feature of the XMLHttpRequest
  * API.
  *
  * @constructor
- * @param {!XMLHttpRequest} xhr
+ * @param {number} status
+ * @param {string} statusText
+ * @param {?string} url
+ * @param {string} text
  * @param {boolean} allowJson
  */
-remoting.Xhr.Response = function(xhr, allowJson) {
-  /** @private @const */
-  this.allowJson_ = allowJson;
-
+remoting.Xhr.Response = function(
+    status, statusText, url, text, allowJson) {
   /**
    * The HTTP status code.
    * @const {number}
    */
-  this.status = xhr.status;
+  this.status = status;
 
   /**
    * The HTTP status description.
    * @const {string}
    */
-  this.statusText = xhr.statusText;
+  this.statusText = statusText;
 
   /**
    * The response URL, if any.
    * @const {?string}
    */
-  this.url = xhr.responseURL;
+  this.url = url;
 
   /** @private {string} */
-  this.text_ = xhr.responseText || '';
+  this.text_ = text;
+
+  /** @private @const */
+  this.allowJson_ = allowJson;
 
   /** @private {*|undefined}  */
   this.json_ = undefined;
 };
 
 /**
+ * @param {!XMLHttpRequest} xhr
+ * @param {boolean} allowJson
+ * @return {!remoting.Xhr.Response}
+ */
+remoting.Xhr.Response.fromXhr_ = function(xhr, allowJson) {
+  return new remoting.Xhr.Response(
+      xhr.status,
+      xhr.statusText,
+      xhr.responseURL,
+      xhr.responseText || '',
+      allowJson);
+};
+
+/**
  * @return {boolean} True if the response code is outside the 200-299
  *     range (i.e. success as defined by the HTTP protocol).
  */
 remoting.Xhr.Response.prototype.isError = function() {
   return this.status < 200 || this.status >= 300;
 };
 
 /**
  * @return {string} The text content of the response.
  */
 remoting.Xhr.Response.prototype.getText = function() {
   return this.text_;
 };
 
 /**
  * Get the JSON content of the response.  Requires acceptJson to have
  * been true in the request.
  * @return {*} The parsed JSON content of the response.
  */
 remoting.Xhr.Response.prototype.getJson = function() {
   base.debug.assert(this.allowJson_);
   if (this.json_ === undefined) {
     this.json_ = JSON.parse(this.text_);
   }
   return this.json_;
 };
 
 /**
- * Returns a copy of the input object with all null or undefined

[John Williams, 2015/04/02 23:57:06]

Moved to base.js.

- * fields removed.
- *
- * @param {Object<string,?string>|undefined} input
- * @return {!Object<string,string>}
- * @private
- */
-remoting.Xhr.removeNullFields_ = function(input) {
-  /** @type {!Object<string,string>} */
-  var result = {};
-  if (input) {
-    for (var field in input) {
-      var value = input[field];
-      if (value != null) {
-        result[field] = value;
-      }
-    }
-  }
-  return result;
-};
-
-/**
  * Takes an associative array of parameters and urlencodes it.
  *
  * @param {Object<string,string>} paramHash The parameter key/value pairs.
  * @return {string} URLEncoded version of paramHash.
  */
 remoting.Xhr.urlencodeParamHash = function(paramHash) {
   var paramArray = [];
   for (var key in paramHash) {
-    paramArray.push(encodeURIComponent(key) +
-                     '=' + encodeURIComponent(paramHash[key]));
+    var value = paramHash[key];

[John Williams, 2015/04/02 23:57:06]

To match semantics of base.copyWithoutNullFields.

+    if (value != null) {
+      paramArray.push(encodeURIComponent(key) +
+                      '=' + encodeURIComponent(value));
+    }
   }
   if (paramArray.length > 0) {
     return paramArray.join('&');
   }
   return '';
 };