Log signal strategy progress to server.

remoting/webapp/unittests/fallback_signal_strategy_unittest.js

Index: remoting/webapp/unittests/fallback_signal_strategy_unittest.js
diff --git a/remoting/webapp/unittests/fallback_signal_strategy_unittest.js b/remoting/webapp/unittests/fallback_signal_strategy_unittest.js
index 18122fd23fff031daec0129a31ccd26ef054d24a..97b2301889362233b7e5b9ae878c9115a38f9191 100644
--- a/remoting/webapp/unittests/fallback_signal_strategy_unittest.js
+++ b/remoting/webapp/unittests/fallback_signal_strategy_unittest.js
@@ -14,6 +14,7 @@ var ControllableSignalStrategy = function(jid, stateChangeCallback) {
   this.dispose = sinon.spy();
   this.connect = sinon.spy();
   this.sendMessage = sinon.spy();
+  this.sendConnectionSetupResults = sinon.spy();
 };
 
 ControllableSignalStrategy.prototype.setIncomingStanzaCallback =
@@ -58,44 +59,47 @@ var createControllableSignalStrategy = function(jid, callback) {
   return new ControllableSignalStrategy(jid, callback);
 };
 
+var MockLogToServer = function() {
+  this.logSignalStrategyProgress = sinon.spy();
+};
+
+MockLogToServer.prototype.assertProgress = function() {
+  equal(this.logSignalStrategyProgress.callCount, arguments.length);
+  for (var i = 0; i < arguments.length; ++i) {
+    equal(this.logSignalStrategyProgress.getCall(i).args[0], arguments[i]);
+  }
+};
+
 var onStateChange = null;
-var onProgressCallback = null;
 var onIncomingStanzaCallback = null;
 var strategy = null;
 var primary = null;
 var secondary = null;
+var logToServer = null;
 
 module('fallback_signal_strategy', {
   setup: function() {
     onStateChange = sinon.spy();
-    onProgressCallback = sinon.spy();
     onIncomingStanzaCallback = sinon.spy();
     strategy = new remoting.FallbackSignalStrategy(
         createControllableSignalStrategy.bind(null, 'primary-jid'),
         createControllableSignalStrategy.bind(null, 'secondary-jid'),
-        onStateChange,
-        onProgressCallback);
+        onStateChange);
     strategy.setIncomingStanzaCallback(onIncomingStanzaCallback);
     primary = strategy.primary_;
     secondary = strategy.secondary_;
+    logToServer = new MockLogToServer();
     primary.setExternalCallbackForTesting(onStateChange);
     secondary.setExternalCallbackForTesting(onStateChange);
   },
   teardown: function() {
     onStateChange = null;
-    onProgressCallback = null;
     onIncomingStanzaCallback = null;
     strategy = null;
     primary = null;
     secondary = null;
+    logToServer = null;
   },
-  // Assert that the progress callback has been called exactly once
-  // since the last call, and with the specified state.
-  assertProgress: function(state) {
-    ok(onProgressCallback.calledOnce);
-    ok(onProgressCallback.calledWith(state));
-    onProgressCallback.reset();
-  }
 });
 
 test('primary succeeds; send & receive routed to it',
@@ -110,12 +114,13 @@ test('primary succeeds; send & receive routed to it',
     primary.setStateForTesting(remoting.SignalStrategy.State.CONNECTING, true);
     primary.setStateForTesting(remoting.SignalStrategy.State.HANDSHAKE, true);
 
-    ok(!onProgressCallback.called);
     primary.setStateForTesting(remoting.SignalStrategy.State.CONNECTED, true);
-    this.assertProgress(
-        remoting.FallbackSignalStrategy.Progress.PRIMARY_SUCCEEDED);
     equal(strategy.getJid(), 'primary-jid');
 
+    strategy.sendConnectionSetupResults(logToServer);
+    logToServer.assertProgress(
+        remoting.FallbackSignalStrategy.Progress.PRIMARY_SUCCEEDED);
+
     ok(!onIncomingStanzaCallback.called);
     primary.onIncomingStanzaCallback('test-receive-primary');
     secondary.onIncomingStanzaCallback('test-receive-secondary');
@@ -147,12 +152,9 @@ test('primary fails; secondary succeeds; send & receive routed to it',
                                true);
     primary.setStateForTesting(remoting.SignalStrategy.State.CONNECTING, true);
 
-    ok(!onProgressCallback.called);
     ok(!secondary.connect.called);
     primary.setStateForTesting(remoting.SignalStrategy.State.FAILED, false);
     ok(secondary.connect.calledWith('server', 'username', 'authToken'));
-    this.assertProgress(
-        remoting.FallbackSignalStrategy.Progress.PRIMARY_FAILED);
 
     secondary.setStateForTesting(remoting.SignalStrategy.State.NOT_CONNECTED,
                                  false);
@@ -160,12 +162,14 @@ test('primary fails; secondary succeeds; send & receive routed to it',
                                  false);
     secondary.setStateForTesting(remoting.SignalStrategy.State.HANDSHAKE, true);
 
-    ok(!onProgressCallback.called);
     secondary.setStateForTesting(remoting.SignalStrategy.State.CONNECTED, true);
-    this.assertProgress(
-        remoting.FallbackSignalStrategy.Progress.SECONDARY_SUCCEEDED);
     equal(strategy.getJid(), 'secondary-jid');
 
+    strategy.sendConnectionSetupResults(logToServer);
+    logToServer.assertProgress(
+        remoting.FallbackSignalStrategy.Progress.PRIMARY_FAILED,
+        remoting.FallbackSignalStrategy.Progress.SECONDARY_SUCCEEDED);
+
     ok(!onIncomingStanzaCallback.called);
     primary.onIncomingStanzaCallback('test-receive-primary');
     secondary.onIncomingStanzaCallback('test-receive-secondary');
@@ -189,19 +193,14 @@ test('primary fails; secondary fails',
 
     primary.setStateForTesting(remoting.SignalStrategy.State.NOT_CONNECTED,
                                true);
-    ok(!onProgressCallback.called);
     ok(!secondary.connect.called);
     primary.setStateForTesting(remoting.SignalStrategy.State.CONNECTING, true);
     primary.setStateForTesting(remoting.SignalStrategy.State.FAILED, false);
     ok(secondary.connect.calledWith('server', 'username', 'authToken'));
-    this.assertProgress(
-        remoting.FallbackSignalStrategy.Progress.PRIMARY_FAILED);

[Jamie, 2015/01/16 22:17:46]

If both signaling strategies fail, it's not possible to log anything, so there's
no point asserting that the correct Progress values were returned.

     secondary.setStateForTesting(remoting.SignalStrategy.State.NOT_CONNECTED,
                                  false);
     primary.setStateForTesting(remoting.SignalStrategy.State.CONNECTING, false);
     secondary.setStateForTesting(remoting.SignalStrategy.State.FAILED, true);
-    this.assertProgress(
-        remoting.FallbackSignalStrategy.Progress.SECONDARY_FAILED);
   }
 );
 
@@ -217,22 +216,22 @@ test('primary times out; secondary succeeds',
     primary.setStateForTesting(remoting.SignalStrategy.State.CONNECTING, true);
     this.clock.tick(strategy.PRIMARY_CONNECT_TIMEOUT_MS_ - 1);
     ok(!secondary.connect.called);
-    ok(!onProgressCallback.called);
     this.clock.tick(1);
     ok(secondary.connect.calledWith('server', 'username', 'authToken'));
-    this.assertProgress(
-        remoting.FallbackSignalStrategy.Progress.PRIMARY_TIMED_OUT);
     secondary.setStateForTesting(remoting.SignalStrategy.State.NOT_CONNECTED,
                                  false);
     secondary.setStateForTesting(remoting.SignalStrategy.State.CONNECTING,
                                  false);
     secondary.setStateForTesting(remoting.SignalStrategy.State.HANDSHAKE, true);
     secondary.setStateForTesting(remoting.SignalStrategy.State.CONNECTED, true);
-    this.assertProgress(
-        remoting.FallbackSignalStrategy.Progress.SECONDARY_SUCCEEDED);
+    strategy.sendConnectionSetupResults(logToServer);
+
     secondary.setStateForTesting(remoting.SignalStrategy.State.CLOSED, true);
     primary.setStateForTesting(remoting.SignalStrategy.State.FAILED, false);
-    this.assertProgress(
+
+    logToServer.assertProgress(
+        remoting.FallbackSignalStrategy.Progress.PRIMARY_TIMED_OUT,
+        remoting.FallbackSignalStrategy.Progress.SECONDARY_SUCCEEDED,
         remoting.FallbackSignalStrategy.Progress.PRIMARY_FAILED_LATE);
   }
 );
@@ -249,18 +248,13 @@ test('primary times out; secondary fails',
     primary.setStateForTesting(remoting.SignalStrategy.State.CONNECTING, true);
     this.clock.tick(strategy.PRIMARY_CONNECT_TIMEOUT_MS_ - 1);
     ok(!secondary.connect.called);
-    ok(!onProgressCallback.called);
     this.clock.tick(1);
     ok(secondary.connect.calledWith('server', 'username', 'authToken'));
-    this.assertProgress(
-        remoting.FallbackSignalStrategy.Progress.PRIMARY_TIMED_OUT);
     secondary.setStateForTesting(remoting.SignalStrategy.State.NOT_CONNECTED,
                                  false);
     secondary.setStateForTesting(remoting.SignalStrategy.State.CONNECTING,
                                  false);
     secondary.setStateForTesting(remoting.SignalStrategy.State.FAILED, true);
-    this.assertProgress(
-        remoting.FallbackSignalStrategy.Progress.SECONDARY_FAILED);
   }
 );
 
@@ -276,19 +270,20 @@ test('primary times out; secondary succeeds; primary succeeds late',
     primary.setStateForTesting(remoting.SignalStrategy.State.CONNECTING, true);
     this.clock.tick(strategy.PRIMARY_CONNECT_TIMEOUT_MS_);
     ok(secondary.connect.calledWith('server', 'username', 'authToken'));
-    this.assertProgress(
-        remoting.FallbackSignalStrategy.Progress.PRIMARY_TIMED_OUT);
     secondary.setStateForTesting(remoting.SignalStrategy.State.NOT_CONNECTED,
                                  false);
     secondary.setStateForTesting(remoting.SignalStrategy.State.CONNECTING,
                                  false);
     secondary.setStateForTesting(remoting.SignalStrategy.State.HANDSHAKE, true);
     secondary.setStateForTesting(remoting.SignalStrategy.State.CONNECTED, true);
-    this.assertProgress(
-        remoting.FallbackSignalStrategy.Progress.SECONDARY_SUCCEEDED);
+    strategy.sendConnectionSetupResults(logToServer);
+
     primary.setStateForTesting(remoting.SignalStrategy.State.HANDSHAKE, false);
     primary.setStateForTesting(remoting.SignalStrategy.State.CONNECTED, false);
-    this.assertProgress(
+
+    logToServer.assertProgress(
+        remoting.FallbackSignalStrategy.Progress.PRIMARY_TIMED_OUT,
+        remoting.FallbackSignalStrategy.Progress.SECONDARY_SUCCEEDED,
         remoting.FallbackSignalStrategy.Progress.PRIMARY_SUCCEEDED_LATE);
   }
 );