Added better error and OAuth support in xhr.js.

remoting/webapp/crd/js/xhr_unittest.js

 // Copyright 2014 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
  */
 
 (function() {
 
 'use strict';
 
+/** @type {sinon.FakeXhrCtrl} */
+var fakeXhrCtrl;
+
 /** @type {sinon.FakeXhr} */
 var fakeXhr;
 
 QUnit.module('xhr', {
   beforeEach: function() {
     fakeXhr = null;
-    sinon.useFakeXMLHttpRequest().onCreate =
+    fakeXhrCtrl = sinon.useFakeXMLHttpRequest();
+    fakeXhrCtrl.onCreate =
         function(/** sinon.FakeXhr */ xhr) {
           fakeXhr = xhr;
         };
+    remoting.identity = new remoting.Identity();
+    sinon.stub(remoting.identity, 'getToken').
+        returns(Promise.resolve('my_token'));

[Jamie, 2015/03/23 23:11:34]

You could alternatively mock chrome.identity (this already exists) and use the
real remoting.Identity wrapper.

[John Williams, 2015/03/24 00:52:12]

This way seems a lot easier, since it doesn't involve messing with callbacks.

[John Williams, 2015/03/24 17:27:36]

After taking a second look, I see I was misunderstanding what you meant, but I'm
not sure it's worth making the change.  It works out to about the same amount of
code, and all things being equal, I generally prefer code that depends on a
general-purpose library like sinon over code that depends on project-specific
utilities.

[Jamie, 2015/03/24 19:44:11]

The problem is that this only mocks one method of remoting.identity (albeit the
only one we're using for this API right now). The advantage of activating the
chrome.identity mock is that it's designed to work with remoting.Identity more
broadly. It's also used by other unit tests, so it's more consistent. And as you
say, it's the same amount of code:

  chromeMocks.activate(['identity']);
  chromeMocks.identity.mock$setToken('my_token');

[John Williams, 2015/03/24 23:34:40]

Done.

+  },
+  afterEach: function() {
+    remoting.identity = null;
   }
 });
 
 QUnit.test('urlencodeParamHash', function(assert) {
   assert.equal(
       remoting.Xhr.urlencodeParamHash({}),
       '');
   assert.equal(
       remoting.Xhr.urlencodeParamHash({'key': 'value'}),
       'key=value');
   assert.equal(
       remoting.Xhr.urlencodeParamHash({'key /?=&': 'value /?=&'}),
       'key%20%2F%3F%3D%26=value%20%2F%3F%3D%26');
   assert.equal(
       remoting.Xhr.urlencodeParamHash({'k1': 'v1', 'k2': 'v2'}),
       'k1=v1&k2=v2');
 });
 
-QUnit.test('basic GET', function(assert) {
+//
+// Test for what happens when the parameters are specified
+// incorrectly.
+//
+
+QUnit.test('invalid *content parameters', function(assert) {
+  assert.throws(function() {
+    new remoting.Xhr({
+      method: 'POST',
+      url: 'http://foo.com',
+      jsonContent: {},
+      formContent: {}
+    });
+  });
+
+  assert.throws(function() {
+    new remoting.Xhr({
+      method: 'POST',
+      url: 'http://foo.com',
+      textContent: '',
+      formContent: {}
+    });
+  });
+
+  assert.throws(function() {
+    new remoting.Xhr({
+      method: 'POST',
+      url: 'http://foo.com',
+      textContent: '',
+      jsonContent: {}
+    });
+  });
+});
+
+
+QUnit.test('invalid URL parameters', function(assert) {
+  assert.throws(function() {
+    new remoting.Xhr({
+      method: 'POST',
+      url: 'http://foo.com?',
+      urlParams: {}
+    });
+  });
+
+  assert.throws(function() {
+    new remoting.Xhr({
+      method: 'POST',
+      url: 'http://foo.com#',
+      urlParams: {}
+    });
+  });
+});
+
+QUnit.test('invalid auth parameters', function(assert) {
+  assert.throws(function() {
+    new remoting.Xhr({
+      method: 'POST',
+      url: 'http://foo.com',
+      useIdentity: false,
+      oauthToken: '',
+      headers: {
+        'Authorization': ''
+      }
+    });
+  });
+
+  assert.throws(function() {
+    new remoting.Xhr({
+      method: 'POST',
+      url: 'http://foo.com',
+      useIdentity: true,
+      headers: {
+        'Authorization': ''
+      }
+    });
+  });
+
+  assert.throws(function() {
+    new remoting.Xhr({
+      method: 'POST',
+      url: 'http://foo.com',
+      useIdentity: true,
+      oauthToken: '',
+      headers: {}
+    });
+  });
+});
+
+QUnit.test('invalid auth parameters', function(assert) {
+  assert.throws(function() {
+    new remoting.Xhr({
+      method: 'POST',
+      url: 'http://foo.com',
+      useIdentity: false,
+      oauthToken: '',
+      headers: {
+        'Authorization': ''
+      }
+    });
+  });
+
+  assert.throws(function() {
+    new remoting.Xhr({
+      method: 'POST',
+      url: 'http://foo.com',
+      useIdentity: true,
+      headers: {
+        'Authorization': ''
+      }
+    });
+  });
+
+  assert.throws(function() {
+    new remoting.Xhr({
+      method: 'POST',
+      url: 'http://foo.com',
+      useIdentity: true,
+      oauthToken: '',
+      headers: {}
+    });
+  });
+});
+
+//
+// The typical case.
+//
+
+QUnit.test('successful GET', function(assert) {
   var promise = new remoting.Xhr({
     method: 'GET',
-    url: 'http://foo.com',
-    responseType: remoting.Xhr.ResponseType.TEXT
+    url: 'http://foo.com'
   }).start().then(function(response) {
-      assert.equal(response.status, 200);
-      assert.equal(response.getText(), 'body');
+    assert.equal(response.status, 200);
+    assert.equal(response.getText(), 'body');
   });
   assert.equal(fakeXhr.method, 'GET');
   assert.equal(fakeXhr.url, 'http://foo.com');
   assert.equal(fakeXhr.withCredentials, false);
   assert.equal(fakeXhr.requestBody, null);
   assert.ok(!('Content-type' in fakeXhr.requestHeaders));
   fakeXhr.respond(200, {}, 'body');
   return promise;
 });
 
-QUnit.test('GET with param string', function(assert) {
+//
+// Handling of errors with different values of ignoreErrors.
+//
+
+QUnit.test('failed GET', function(assert) {
+  var promise = new remoting.Xhr({
+    method: 'GET',
+    url: 'http://foo.com'
+  }).start().then(function(response) {
+    assert.equal(response.status, 500);
+    assert.equal(response.getText(), 'body');
+  });
+  fakeXhr.respond(500, {}, 'body');
+  return promise;
+});
+
+QUnit.test('failed GET with non-ignored error', function(assert) {
+  var expectedError = remoting.Error.fromHttpStatus(500);
+  assert.ok(!expectedError.isNone());
+
   var promise = new remoting.Xhr({
     method: 'GET',
     url: 'http://foo.com',
-    responseType: remoting.Xhr.ResponseType.TEXT,
-    urlParams: 'the_param_string'
-  }).start().then(function(response) {
-    assert.equal(response.status, 200);
-    assert.equal(response.getText(), 'body');
+    ignoreErrors: []
+  }).start().then(function() {
+    assert.ok(false);
+  }, function(/** remoting.Error */ error) {
+    assert.equal(error.getTag(), expectedError.getTag());
   });
-  assert.equal(fakeXhr.method, 'GET');
-  assert.equal(fakeXhr.url, 'http://foo.com?the_param_string');
-  assert.equal(fakeXhr.withCredentials, false);
-  assert.equal(fakeXhr.requestBody, null);
-  assert.ok(!('Content-type' in fakeXhr.requestHeaders));
-  fakeXhr.respond(200, {}, 'body');
+  fakeXhr.respond(500, {}, 'body');
   return promise;
 });
 
-QUnit.test('GET with param object', function(assert) {
+QUnit.test('failed GET with ignored error', function(assert) {
+  var expectedError = remoting.Error.fromHttpStatus(500);
+  assert.ok(!expectedError.isNone());
+
   var promise = new remoting.Xhr({
     method: 'GET',
     url: 'http://foo.com',
-    responseType: remoting.Xhr.ResponseType.TEXT,
-    urlParams: {'a': 'b', 'c': 'd'}
-  }).start().then(function(response) {
-    assert.equal(response.status, 200);
-    assert.equal(response.getText(), 'body');
-  });
-  assert.equal(fakeXhr.method, 'GET');
-  assert.equal(fakeXhr.url, 'http://foo.com?a=b&c=d');
-  assert.equal(fakeXhr.withCredentials, false);
-  assert.equal(fakeXhr.requestBody, null);
-  assert.ok(!('Content-type' in fakeXhr.requestHeaders));
-  fakeXhr.respond(200, {}, 'body');
+    ignoreErrors: [expectedError.getTag()]
+  }).start();
+  fakeXhr.respond(500, {}, 'body');
   return promise;
 });
 
-QUnit.test('GET with headers', function(assert) {
+QUnit.test('204 is not a failure', function(assert) {
+  assert.expect(0);
+  var promise = new remoting.Xhr({
+    method: 'DELETE',
+    url: 'http://foo.com',
+    ignoreErrors: []
+  }).start();
+  fakeXhr.respond(204, {}, 'body');
+  return promise;
+});
+
+//
+// Tests for the effect of acceptJson.
+//
+
+QUnit.test('acceptJson required', function(assert) {
+  var promise = new remoting.Xhr({
+    method: 'GET',
+    url: 'http://foo.com'
+  }).start().then(function(response) {
+    assert.throws(response.getJson);
+  });
+  fakeXhr.respond(200, {}, '{}');
+  return promise;
+});
+
+QUnit.test('JSON response', function(assert) {
+  var responseJson = {
+      'myJsonData': [true]
+  };
+  var responseText = JSON.stringify(responseJson);
   var promise = new remoting.Xhr({
     method: 'GET',
     url: 'http://foo.com',
-    responseType: remoting.Xhr.ResponseType.TEXT,
+    acceptJson: true
+  }).start().then(function(response) {
+    // Calling getText is still OK even when a JSON response is
+    // requested.
+    assert.equal(
+        response.getText(),
+        responseText);
+    // Check that getJson works as advertized.
+    assert.deepEqual(
+        response.getJson(),
+        responseJson);
+    // Calling getJson multiple times doesn't re-parse the response.
+    assert.strictEqual(
+        response.getJson(),
+        response.getJson());
+  });
+  fakeXhr.respond(200, {}, responseText);
+  return promise;
+});
+
+//
+// Tests for various parameters that modify the HTTP request.
+//
+
+QUnit.test('GET with param string', function(assert) {
+  new remoting.Xhr({
+    method: 'GET',
+    url: 'http://foo.com',
+    urlParams: 'the_param_string'
+  }).start();
+  assert.equal(fakeXhr.url, 'http://foo.com?the_param_string');
+});
+
+QUnit.test('GET with param object', function(assert) {
+  new remoting.Xhr({
+    method: 'GET',
+    url: 'http://foo.com',
+    urlParams: {'a': 'b', 'c': 'd'}
+  }).start();
+  assert.equal(fakeXhr.url, 'http://foo.com?a=b&c=d');
+});
+
+QUnit.test('GET with headers', function(assert) {
+  new remoting.Xhr({
+    method: 'GET',
+    url: 'http://foo.com',
     headers: {'Header1': 'headerValue1', 'Header2': 'headerValue2'}
-  }).start().then(function(response) {
-    assert.equal(response.status, 200);
-    assert.equal(response.getText(), 'body');
-  });
-  assert.equal(fakeXhr.method, 'GET');
-  assert.equal(fakeXhr.url, 'http://foo.com');
-  assert.equal(fakeXhr.withCredentials, false);
-  assert.equal(fakeXhr.requestBody, null);
+  }).start();
   assert.equal(
       fakeXhr.requestHeaders['Header1'],
       'headerValue1');
   assert.equal(
       fakeXhr.requestHeaders['Header2'],
       'headerValue2');
-  assert.ok(!('Content-type' in fakeXhr.requestHeaders));
-  fakeXhr.respond(200, {}, 'body');
-  return promise;
 });
 
 
 QUnit.test('GET with credentials', function(assert) {
-  var promise = new remoting.Xhr({
+  new remoting.Xhr({
     method: 'GET',
     url: 'http://foo.com',
-    responseType: remoting.Xhr.ResponseType.TEXT,
     withCredentials: true
-  }).start().then(function(response) {
-    assert.equal(response.status, 200);
-    assert.equal(response.getText(), 'body');
-  });
-  assert.equal(fakeXhr.method, 'GET');
-  assert.equal(fakeXhr.url, 'http://foo.com');
+  }).start();
   assert.equal(fakeXhr.withCredentials, true);
-  assert.equal(fakeXhr.requestBody, null);
-  assert.ok(!('Content-type' in fakeXhr.requestHeaders));
-  fakeXhr.respond(200, {}, 'body');
-  return promise;
 });
 
+//
+// Checking that typical POST requests work.
+//
+
 QUnit.test('POST with text content', function(assert) {
   var done = assert.async();
 
   var promise = new remoting.Xhr({
     method: 'POST',
     url: 'http://foo.com',
-    responseType: remoting.Xhr.ResponseType.TEXT,
     textContent: 'the_content_string'
   }).start().then(function(response) {
     assert.equal(response.status, 200);
     assert.equal(response.getText(), 'body');
     done();
   });
   assert.equal(fakeXhr.method, 'POST');
   assert.equal(fakeXhr.url, 'http://foo.com');
   assert.equal(fakeXhr.withCredentials, false);
   assert.equal(fakeXhr.requestBody, 'the_content_string');
-  assert.ok(!('Content-type' in fakeXhr.requestHeaders));
+  assert.equal(fakeXhr.requestHeaders['Content-type'],
+               'text/plain; charset=UTF-8');
   fakeXhr.respond(200, {}, 'body');
   return promise;
 });
 
 QUnit.test('POST with form content', function(assert) {
-  var promise = new remoting.Xhr({
+  new remoting.Xhr({
     method: 'POST',
     url: 'http://foo.com',
-    responseType: remoting.Xhr.ResponseType.TEXT,
     formContent: {'a': 'b', 'c': 'd'}
-  }).start().then(function(response) {
-    assert.equal(response.status, 200);
-    assert.equal(response.getText(), 'body');
-  });
-  assert.equal(fakeXhr.method, 'POST');
-  assert.equal(fakeXhr.url, 'http://foo.com');
-  assert.equal(fakeXhr.withCredentials, false);
+  }).start();
   assert.equal(fakeXhr.requestBody, 'a=b&c=d');
   assert.equal(
       fakeXhr.requestHeaders['Content-type'],
-      'application/x-www-form-urlencoded');
-  fakeXhr.respond(200, {}, 'body');
+      'application/x-www-form-urlencoded; charset=UTF-8');
+});
+
+//
+// Tests for authentication-related options.
+//
+
+QUnit.test('GET with auth token', function(assert) {
+  new remoting.Xhr({
+    method: 'GET',
+    url: 'http://foo.com',
+    oauthToken: 'my_token'
+  }).start();
+  assert.equal(fakeXhr.requestHeaders['Authorization'],
+              'Bearer my_token');
+});
+
+QUnit.test('GET with useIdentity', function(assert) {
+  var xhr = new remoting.Xhr({
+    method: 'GET',
+    url: 'http://foo.com',
+    useIdentity: true
+  });
+
+  xhr.start();
+
+  var done = assert.async();
+  fakeXhr.addEventListener('loadstart', function() {
+    assert.equal(fakeXhr.requestHeaders['Authorization'],
+                 'Bearer my_token');
+    done();
+  });
+});
+
+
+//
+// Tests for the abort method.
+//
+
+QUnit.test('abort before start', function(assert) {
+  assert.expect(0);
+  var xhr = new remoting.Xhr({
+    method: 'GET',
+    url: 'http://foo.com'
+  });
+  fakeXhr.addEventListener('abort', assert.async());
+  xhr.abort();
+  xhr.start().then(function() {
+    assert.ok(false, 'promise resolved after abort');
+  }, function() {
+    assert.ok(false, 'promise rejected after abort');
+  });
+});
+
+QUnit.test('abort before send', function(assert) {
+  assert.expect(0);
+  var xhr = new remoting.Xhr({
+    method: 'GET',
+    url: 'http://foo.com',
+    useIdentity: true
+  });
+  xhr.start().then(function() {
+    assert.ok(false, 'promise resolved after abort');
+  }, function() {
+    assert.ok(false, 'promise rejected after abort');
+  });
+  fakeXhr.addEventListener('abort', assert.async());
+  xhr.abort();
+});
+
+QUnit.test('abort after resolved', function(assert) {
+  var xhr = new remoting.Xhr({
+    method: 'GET',
+    url: 'http://foo.com',
+    useIdentity: true
+  });
+  var promise = xhr.start().then(function() {
+    assert.ok(true);
+    fakeXhr.addEventListener('abort', assert.async());
+    xhr.abort();
+  });
+  fakeXhr.addEventListener('loadstart', function() {
+    fakeXhr.respond(200, {}, 'body');
+  });
   return promise;
 });
 
-QUnit.test('defaultResponse 200', function(assert) {
-  var done = assert.async();
-
-  var onDone = function() {
-    assert.ok(true);
-    done();
-  };
-
-  var onError = function(error) {
-    assert.ok(false);
-    done();
-  };
-
-  new remoting.Xhr({
-    method: 'POST',
-    url: 'http://foo.com'
-  }).start().then(remoting.Xhr.defaultResponse(onDone, onError));
-  fakeXhr.respond(200, {}, '');
-});
-
-
-QUnit.test('defaultResponse 404', function(assert) {
-  var done = assert.async();
-
-  var onDone = function() {
-    assert.ok(false);
-    done();
-  };
-
-  var onError = function(error) {
-    assert.ok(true);
-    done();
-  };
-
-  new remoting.Xhr({
-    method: 'POST',
-    url: 'http://foo.com'
-  }).start().then(remoting.Xhr.defaultResponse(onDone, onError));
-  fakeXhr.respond(404, {}, '');
-});
-
 })();