Updated XHR API so call sites are more descriptive.

remoting/webapp/unittests/dns_blackhole_checker_unittest.js

 // Copyright 2015 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
  * TODO(garykac): Create interface for SignalStrategy.
  * @suppress {checkTypes|checkVars|reportUnknownTypes|visibility}
  */
 
 (function() {
 
 'use strict';
 
 /** @type {(sinon.Spy|function(remoting.SignalStrategy.State))} */
 var onStateChange = null;
 
 /** @type {(sinon.Spy|function(Element):void)} */
 var onIncomingStanzaCallback = null;
 
 /** @type {remoting.DnsBlackholeChecker} */
 var checker = null;
 
 /** @type {remoting.MockSignalStrategy} */
 var signalStrategy = null;
 var fakeXhrs;
 
-module('dns_blackhole_checker', {
+QUnit.module('dns_blackhole_checker', {
   setup: function() {
     fakeXhrs = [];
     sinon.useFakeXMLHttpRequest().onCreate = function(xhr) {
       fakeXhrs.push(xhr);
     };
 
     onStateChange = sinon.spy();
     onIncomingStanzaCallback = sinon.spy();
     signalStrategy = new remoting.MockSignalStrategy();
     checker = new remoting.DnsBlackholeChecker(signalStrategy);
@@ skipping 13 matching lines @@
         'the correct URL is requested');
   },
   teardown: function() {
     base.dispose(checker);
     sinon.assert.calledWith(onStateChange,
                             remoting.SignalStrategy.State.CLOSED);
 
     onStateChange = null;
     onIncomingStanzaCallback = null;
     checker = null;
-  },
+  }
 });
 
+function await(condition) {
+  function loop(count) {
+    if (condition()) {
+      return Promise.resolve();
+    } else if (count > 1000) {
+      return Promise.reject('condition never became true');
+    } else {
+      return Promise.resolve().then(loop.bind(null, count + 1));
+    }
+  };
+  return loop(0);
+};
+
 test('success',
   function() {
-    fakeXhrs[0].respond(200);
-    sinon.assert.notCalled(onStateChange);
+    function checkState(state) {
+      return SpyPromise.run(function() {
+        signalStrategy.setStateForTesting(state);
+      }).then(function() {
+        sinon.assert.calledWith(onStateChange, state);
+        equal(checker.getState(), state);
+      });
+    };
 
-    [
-      remoting.SignalStrategy.State.CONNECTING,
-      remoting.SignalStrategy.State.HANDSHAKE,
-      remoting.SignalStrategy.State.CONNECTED
-    ].forEach(function(state) {
-      signalStrategy.setStateForTesting(state);
-      sinon.assert.calledWith(onStateChange, state);
-      equal(checker.getState(), state);
+    return SpyPromise.run(function() {
+      fakeXhrs[0].respond(200);
+    }).then(function() {
+      sinon.assert.notCalled(onStateChange);
+    }).
+        then(checkState.bind(null, remoting.SignalStrategy.State.CONNECTING)).
+        then(checkState.bind(null, remoting.SignalStrategy.State.HANDSHAKE)).
+        then(checkState.bind(null, remoting.SignalStrategy.State.CONNECTED));
+  });
+
+test('http response after connected',
+  function() {
+    function checkState(state) {
+      return SpyPromise.run(function() {
+        signalStrategy.setStateForTesting(state);
+      }).then(function() {
+        sinon.assert.calledWith(onStateChange, state);
+        equal(checker.getState(), state);
+      });
+    }
+
+    return Promise.resolve().then(function() {
+      return checkState(remoting.SignalStrategy.State.CONNECTING);
+    }).then(function() {
+      return checkState(remoting.SignalStrategy.State.HANDSHAKE);
+    }).then(function() {
+      onStateChange.reset();
+
+      // Verify that DnsBlackholeChecker stays in HANDSHAKE state even if the
+      // signal strategy has connected.
+      return SpyPromise.run(function() {
+        signalStrategy.setStateForTesting(
+            remoting.SignalStrategy.State.CONNECTED);
+      });
+    }).then(function() {
+      sinon.assert.notCalled(onStateChange);
+      equal(checker.getState(), remoting.SignalStrategy.State.HANDSHAKE);
+
+      // Verify that DnsBlackholeChecker goes to CONNECTED state after the
+      // the HTTP request has succeeded.
+      return SpyPromise.run(function() {
+        fakeXhrs[0].respond(200);
+      });
+    }).then(function() {
+      sinon.assert.calledWith(onStateChange,
+                              remoting.SignalStrategy.State.CONNECTED);
+    });
+  });
+
+QUnit.test('connect failed',
+  function() {
+    function checkState(state) {
+      return SpyPromise.run(function() {
+        signalStrategy.setStateForTesting(state);
+      }).then(function() {
+        sinon.assert.calledWith(onStateChange, state);
+      });
+    };
+
+    return SpyPromise.run(function() {
+      fakeXhrs[0].respond(200);
+    }).then(function() {
+      sinon.assert.notCalled(onStateChange);
+    }).
+        then(checkState.bind(null, remoting.SignalStrategy.State.CONNECTING)).
+        then(checkState.bind(null, remoting.SignalStrategy.State.FAILED));
+  });
+
+QUnit.test('blocked',
+  function(assert) {
+    function checkState(state) {
+      onStateChange.reset();
+      return SpyPromise.run(function() {
+        signalStrategy.setStateForTesting(state);
+      }).then(function() {
+        sinon.assert.notCalled(onStateChange);
+        assert.equal(
+            checker.getState(),
+            remoting.SignalStrategy.State.FAILED,
+            'checker state is still FAILED');
+      });
+    };
+
+    return SpyPromise.run(function() {
+      fakeXhrs[0].respond(400);
+    }).then(function() {
+      sinon.assert.calledWith(
+          onStateChange, remoting.SignalStrategy.State.FAILED);
+      assert.equal(
+          checker.getError().tag,
+          remoting.Error.Tag.NOT_AUTHORIZED,
+          'checker error is NOT_AUTHORIZED');
+    }).
+        then(checkState.bind(null, remoting.SignalStrategy.State.CONNECTING)).
+        then(checkState.bind(null, remoting.SignalStrategy.State.HANDSHAKE)).
+        then(checkState.bind(null, remoting.SignalStrategy.State.CONNECTED));
+  });
+
+QUnit.test('blocked after connected',
+  function() {
+    function checkState(state) {
+      return SpyPromise.run(function() {
+        signalStrategy.setStateForTesting(state);
+      }).then(function() {
+        sinon.assert.calledWith(onStateChange, state);
+        equal(checker.getState(), state);
+      });
+    };
+
+    return Promise.resolve().then(function() {
+      return checkState(remoting.SignalStrategy.State.CONNECTING);
+    }).then(function() {
+      return checkState(remoting.SignalStrategy.State.HANDSHAKE);
+    }).then(function() {
+      onStateChange.reset();
+
+      // Verify that DnsBlackholeChecker stays in HANDSHAKE state even
+      // if the signal strategy has connected.
+      return SpyPromise.run(function() {
+        signalStrategy.setStateForTesting(
+            remoting.SignalStrategy.State.CONNECTED);
+      });
+    }).then(function() {
+      sinon.assert.notCalled(onStateChange);
+      equal(checker.getState(), remoting.SignalStrategy.State.HANDSHAKE);
+
+      // Verify that DnsBlackholeChecker goes to FAILED state after it
+      // gets the blocked HTTP response.
+      return SpyPromise.run(function() {
+        fakeXhrs[0].respond(400);
+      });
+    }).then(function() {
+      sinon.assert.calledWith(onStateChange,
+                              remoting.SignalStrategy.State.FAILED);
+      equal(checker.getError().tag, remoting.Error.Tag.NOT_AUTHORIZED);
     });
   }
 );
 
-test('http response after connected',
-  function() {
-    [
-      remoting.SignalStrategy.State.CONNECTING,
-      remoting.SignalStrategy.State.HANDSHAKE,
-    ].forEach(function(state) {
-      signalStrategy.setStateForTesting(state);
-      sinon.assert.calledWith(onStateChange, state);
-      equal(checker.getState(), state);
-    });
-    onStateChange.reset();
-
-    // Verify that DnsBlackholeChecker stays in HANDSHAKE state even if the
-    // signal strategy has connected.
-    signalStrategy.setStateForTesting(remoting.SignalStrategy.State.CONNECTED);
-    sinon.assert.notCalled(onStateChange);
-    equal(checker.getState(), remoting.SignalStrategy.State.HANDSHAKE);
-
-    // Verify that DnsBlackholeChecker goes to CONNECTED state after the
-    // the HTTP request has succeeded.
-    fakeXhrs[0].respond(200);
-    sinon.assert.calledWith(onStateChange,
-                            remoting.SignalStrategy.State.CONNECTED);
-  }
-);
-
-test('connect failed',
-  function() {
-    fakeXhrs[0].respond(200);
-    sinon.assert.notCalled(onStateChange);
-
-    [
-      remoting.SignalStrategy.State.CONNECTING,
-      remoting.SignalStrategy.State.FAILED
-    ].forEach(function(state) {
-      signalStrategy.setStateForTesting(state);
-      sinon.assert.calledWith(onStateChange, state);
-    });
-}
-);
-
-test('blocked',
-  function() {
-    fakeXhrs[0].respond(400);
-    sinon.assert.calledWith(onStateChange,
-                            remoting.SignalStrategy.State.FAILED);
-    equal(checker.getError().tag, remoting.Error.Tag.NOT_AUTHORIZED);
-    onStateChange.reset();
-
-    [
-      remoting.SignalStrategy.State.CONNECTING,
-      remoting.SignalStrategy.State.HANDSHAKE,
-      remoting.SignalStrategy.State.CONNECTED
-    ].forEach(function(state) {
-      signalStrategy.setStateForTesting(state);
-      sinon.assert.notCalled(onStateChange);
-      equal(checker.getState(), remoting.SignalStrategy.State.FAILED);
-    });
-  }
-);
-
-test('blocked after connected',
-  function() {
-    [
-      remoting.SignalStrategy.State.CONNECTING,
-      remoting.SignalStrategy.State.HANDSHAKE,
-    ].forEach(function(state) {
-      signalStrategy.setStateForTesting(state);
-      sinon.assert.calledWith(onStateChange, state);
-      equal(checker.getState(), state);
-    });
-    onStateChange.reset();
-
-    // Verify that DnsBlackholeChecker stays in HANDSHAKE state even if the
-    // signal strategy has connected.
-    signalStrategy.setStateForTesting(remoting.SignalStrategy.State.CONNECTED);
-    sinon.assert.notCalled(onStateChange);
-    equal(checker.getState(), remoting.SignalStrategy.State.HANDSHAKE);
-
-    // Verify that DnsBlackholeChecker goes to FAILED state after it gets the
-    // blocked HTTP response.
-    fakeXhrs[0].respond(400);
-    sinon.assert.calledWith(onStateChange,
-                            remoting.SignalStrategy.State.FAILED);
-    equal(checker.getError().tag, remoting.Error.Tag.NOT_AUTHORIZED);
-  }
-);
-
 })();