Resolved merge conflicts with master

3 files changed, 154 insertions, 3 deletions

diff --git a/src/node/test/channel_test.js b/src/node/test/channel_test.js
index c991d7b25b..d81df2a36d 100644
--- a/src/node/test/channel_test.js
+++ b/src/node/test/channel_test.js
@@ -36,6 +36,26 @@
 var assert = require('assert');
 var grpc = require('bindings')('grpc.node');
 
+/**
+ * This is used for testing functions with multiple asynchronous calls that
+ * can happen in different orders. This should be passed the number of async
+ * function invocations that can occur last, and each of those should call this
+ * function's return value
+ * @param {function()} done The function that should be called when a test is
+ *     complete.
+ * @param {number} count The number of calls to the resulting function if the
+ *     test passes.
+ * @return {function()} The function that should be called at the end of each
+ *     sequence of asynchronous functions.
+ */
+function multiDone(done, count) {
+  return function() {
+    count -= 1;
+    if (count <= 0) {
+      done();
+    }
+  };
+}
 var insecureCreds = grpc.Credentials.createInsecure();
 
 describe('channel', function() {
@@ -86,14 +106,16 @@ describe('channel', function() {
     });
   });
   describe('close', function() {
+    var channel;
+    beforeEach(function() {
+      channel = new grpc.Channel('hostname', insecureCreds, {});
+    });
     it('should succeed silently', function() {
-      var channel = new grpc.Channel('hostname', insecureCreds, {});
       assert.doesNotThrow(function() {
         channel.close();
       });
     });
     it('should be idempotent', function() {
-      var channel = new grpc.Channel('hostname', insecureCreds, {});
       assert.doesNotThrow(function() {
         channel.close();
         channel.close();
@@ -101,9 +123,68 @@ describe('channel', function() {
     });
   });
   describe('getTarget', function() {
+    var channel;
+    beforeEach(function() {
+      channel = new grpc.Channel('hostname', insecureCreds, {});
+    });
     it('should return a string', function() {
-      var channel = new grpc.Channel('localhost', insecureCreds, {});
       assert.strictEqual(typeof channel.getTarget(), 'string');
     });
   });
+  describe('getConnectivityState', function() {
+    var channel;
+    beforeEach(function() {
+      channel = new grpc.Channel('hostname', insecureCreds, {});
+    });
+    it('should return IDLE for a new channel', function() {
+      assert.strictEqual(channel.getConnectivityState(),
+                         grpc.connectivityState.IDLE);
+    });
+  });
+  describe('watchConnectivityState', function() {
+    var channel;
+    beforeEach(function() {
+      channel = new grpc.Channel('localhost', insecureCreds, {});
+    });
+    afterEach(function() {
+      channel.close();
+    });
+    it('should time out if called alone', function(done) {
+      var old_state = channel.getConnectivityState();
+      var deadline = new Date();
+      deadline.setSeconds(deadline.getSeconds() + 1);
+      channel.watchConnectivityState(old_state, deadline, function(err, value) {
+        assert(err);
+        done();
+      });
+    });
+    it('should complete if a connection attempt is forced', function(done) {
+      var old_state = channel.getConnectivityState();
+      var deadline = new Date();
+      deadline.setSeconds(deadline.getSeconds() + 1);
+      channel.watchConnectivityState(old_state, deadline, function(err, value) {
+        assert.ifError(err);
+        assert.notEqual(value.new_state, old_state);
+        done();
+      });
+      channel.getConnectivityState(true);
+    });
+    it('should complete twice if called twice', function(done) {
+      done = multiDone(done, 2);
+      var old_state = channel.getConnectivityState();
+      var deadline = new Date();
+      deadline.setSeconds(deadline.getSeconds() + 1);
+      channel.watchConnectivityState(old_state, deadline, function(err, value) {
+        assert.ifError(err);
+        assert.notEqual(value.new_state, old_state);
+        done();
+      });
+      channel.watchConnectivityState(old_state, deadline, function(err, value) {
+        assert.ifError(err);
+        assert.notEqual(value.new_state, old_state);
+        done();
+      });
+      channel.getConnectivityState(true);
+    });
+  });
 });
diff --git a/src/node/test/constant_test.js b/src/node/test/constant_test.js
index e251dd3428..fa06ad4e4d 100644
--- a/src/node/test/constant_test.js
+++ b/src/node/test/constant_test.js
@@ -90,6 +90,18 @@ var propagateFlagNames = [
   'CANCELLATION',
   'DEFAULTS'
 ];
+/*
+ * List of all connectivity state names
+ * @const
+ * @type {Array.<string>}
+ */
+var connectivityStateNames = [
+  'IDLE',
+  'CONNECTING',
+  'READY',
+  'TRANSIENT_FAILURE',
+  'FATAL_FAILURE'
+];
 
 describe('constants', function() {
   it('should have all of the status constants', function() {
@@ -110,4 +122,10 @@ describe('constants', function() {
              'call error missing: ' + propagateFlagNames[i]);
     }
   });
+  it('should have all of the connectivity states', function() {
+    for (var i = 0; i < connectivityStateNames.length; i++) {
+      assert(grpc.connectivityState.hasOwnProperty(connectivityStateNames[i]),
+             'connectivity status missing: ' + connectivityStateNames[i]);
+    }
+  });
 });
diff --git a/src/node/test/surface_test.js b/src/node/test/surface_test.js
index 5e731ea42b..52515cc8e7 100644
--- a/src/node/test/surface_test.js
+++ b/src/node/test/surface_test.js
@@ -133,6 +133,58 @@ describe('Server.prototype.addProtoService', function() {
     });
   });
 });
+describe('Client#$waitForReady', function() {
+  var server;
+  var port;
+  var Client;
+  var client;
+  before(function() {
+    server = new grpc.Server();
+    port = server.bind('localhost:0', grpc.ServerCredentials.createInsecure());
+    server.start();
+    Client = surface_client.makeProtobufClientConstructor(mathService);
+  });
+  beforeEach(function() {
+    client = new Client('localhost:' + port, grpc.Credentials.createInsecure());
+  });
+  after(function() {
+    server.shutdown();
+  });
+  it('should complete when called alone', function(done) {
+    client.$waitForReady(Infinity, function(error) {
+      assert.ifError(error);
+      done();
+    });
+  });
+  it('should complete when a call is initiated', function(done) {
+    client.$waitForReady(Infinity, function(error) {
+      assert.ifError(error);
+      done();
+    });
+    var call = client.div({}, function(err, response) {});
+    call.cancel();
+  });
+  it('should complete if called more than once', function(done) {
+    done = multiDone(done, 2);
+    client.$waitForReady(Infinity, function(error) {
+      assert.ifError(error);
+      done();
+    });
+    client.$waitForReady(Infinity, function(error) {
+      assert.ifError(error);
+      done();
+    });
+  });
+  it('should complete if called when already ready', function(done) {
+    client.$waitForReady(Infinity, function(error) {
+      assert.ifError(error);
+      client.$waitForReady(Infinity, function(error) {
+        assert.ifError(error);
+        done();
+      });
+    });
+  });
+});
 describe('Echo service', function() {
   var server;
   var client;