Simplified some code and added tests to increase code coverage

2 files changed, 163 insertions, 9 deletions

diff --git a/src/node/test/credentials_test.js b/src/node/test/credentials_test.js
index 647f648ca9..294600c85a 100644
--- a/src/node/test/credentials_test.js
+++ b/src/node/test/credentials_test.js
@@ -76,6 +76,146 @@ var fakeFailingGoogleCredentials = {
   }
 };
 
+var key_data, pem_data, ca_data;
+
+before(function() {
+  var key_path = path.join(__dirname, './data/server1.key');
+  var pem_path = path.join(__dirname, './data/server1.pem');
+  var ca_path = path.join(__dirname, '../test/data/ca.pem');
+  key_data = fs.readFileSync(key_path);
+  pem_data = fs.readFileSync(pem_path);
+  ca_data = fs.readFileSync(ca_path);
+});
+
+describe('channel credentials', function() {
+  describe('#createSsl', function() {
+    it('works with no arguments', function() {
+      var creds;
+      assert.doesNotThrow(function() {
+        creds = grpc.credentials.createSsl();
+      });
+      assert.notEqual(creds, null);
+    });
+    it('works with just one Buffer argument', function() {
+      var creds;
+      assert.doesNotThrow(function() {
+        creds = grpc.credentials.createSsl(ca_data);
+      });
+      assert.notEqual(creds, null);
+    });
+    it('works with 3 Buffer arguments', function() {
+      var creds;
+      assert.doesNotThrow(function() {
+        creds = grpc.credentials.createSsl(ca_data, key_data, pem_data);
+      });
+      assert.notEqual(creds, null);
+    });
+    it('works if the first argument is null', function() {
+      var creds;
+      assert.doesNotThrow(function() {
+        creds = grpc.credentials.createSsl(null, key_data, pem_data);
+      });
+      assert.notEqual(creds, null);
+    });
+    it('fails if the first argument is a non-Buffer value', function() {
+      assert.throws(function() {
+        grpc.credentials.createSsl('test');
+      }, TypeError);
+    });
+    it('fails if the second argument is a non-Buffer value', function() {
+      assert.throws(function() {
+        grpc.credentials.createSsl(null, 'test', pem_data);
+      }, TypeError);
+    });
+    it('fails if the third argument is a non-Buffer value', function() {
+      assert.throws(function() {
+        grpc.credentials.createSsl(null, key_data, 'test');
+      }, TypeError);
+    });
+    it('fails if only 1 of the last 2 arguments is provided', function() {
+      assert.throws(function() {
+        grpc.credentials.createSsl(null, key_data);
+      });
+      assert.throws(function() {
+        grpc.credentials.createSsl(null, null, pem_data);
+      });
+    });
+  });
+});
+
+describe('server credentials', function() {
+  describe('#createSsl', function() {
+    it('accepts a buffer and array as the first 2 arguments', function() {
+      var creds;
+      assert.doesNotThrow(function() {
+        creds = grpc.ServerCredentials.createSsl(ca_data, []);
+      });
+      assert.notEqual(creds, null);
+    });
+    it('accepts a boolean as the third argument', function() {
+      var creds;
+      assert.doesNotThrow(function() {
+        creds = grpc.ServerCredentials.createSsl(ca_data, [], true);
+      });
+      assert.notEqual(creds, null);
+    });
+    it('accepts an object with two buffers in the second argument', function() {
+      var creds;
+      assert.doesNotThrow(function() {
+        creds = grpc.ServerCredentials.createSsl(null,
+                                                 [{private_key: key_data,
+                                                   cert_chain: pem_data}]);
+      });
+      assert.notEqual(creds, null);
+    });
+    it('accepts multiple objects in the second argument', function() {
+      var creds;
+      assert.doesNotThrow(function() {
+        creds = grpc.ServerCredentials.createSsl(null,
+                                                 [{private_key: key_data,
+                                                   cert_chain: pem_data},
+                                                  {private_key: key_data,
+                                                   cert_chain: pem_data}]);
+      });
+      assert.notEqual(creds, null);
+    });
+    it('fails if the second argument is not an Array', function() {
+      assert.throws(function() {
+        grpc.ServerCredentials.createSsl(ca_data, 'test');
+      }, TypeError);
+    });
+    it('fails if the first argument is a non-Buffer value', function() {
+      assert.throws(function() {
+        grpc.ServerCredentials.createSsl('test', []);
+      }, TypeError);
+    });
+    it('fails if the third argument is a non-boolean value', function() {
+      assert.throws(function() {
+        grpc.ServerCredentials.createSsl(ca_data, [], 'test');
+      }, TypeError);
+    });
+    it('fails if the array elements are not objects', function() {
+      assert.throws(function() {
+        grpc.ServerCredentials.createSsl(ca_data, 'test');
+      }, TypeError);
+    });
+    it('fails if the object does not have a Buffer private_key', function() {
+      assert.throws(function() {
+        grpc.ServerCredentials.createSsl(null,
+                                         [{private_key: 'test',
+                                           cert_chain: pem_data}]);
+      }, TypeError);
+    });
+    it('fails if the object does not have a Buffer cert_chain', function() {
+      assert.throws(function() {
+        grpc.ServerCredentials.createSsl(null,
+                                         [{private_key: key_data,
+                                           cert_chain: 'test'}]);
+      }, TypeError);
+    });
+  });
+});
+
 describe('client credentials', function() {
   var Client;
   var server;
@@ -109,20 +249,13 @@ describe('client credentials', function() {
         });
       }
     });
-    var key_path = path.join(__dirname, './data/server1.key');
-    var pem_path = path.join(__dirname, './data/server1.pem');
-    var key_data = fs.readFileSync(key_path);
-    var pem_data = fs.readFileSync(pem_path);
     var creds = grpc.ServerCredentials.createSsl(null,
                                                  [{private_key: key_data,
                                                    cert_chain: pem_data}]);
-    //creds = grpc.ServerCredentials.createInsecure();
     port = server.bind('localhost:0', creds);
     server.start();
 
     Client = proto.TestService;
-    var ca_path = path.join(__dirname, '../test/data/ca.pem');
-    var ca_data = fs.readFileSync(ca_path);
     client_ssl_creds = grpc.credentials.createSsl(ca_data);
     var host_override = 'foo.test.google.fr';
     client_options['grpc.ssl_target_name_override'] = host_override;
diff --git a/src/node/test/server_test.js b/src/node/test/server_test.js
index 999a183b3c..592f47e145 100644
--- a/src/node/test/server_test.js
+++ b/src/node/test/server_test.js
@@ -45,9 +45,30 @@ describe('server', function() {
         new grpc.Server();
       });
     });
-    it('should work with an empty list argument', function() {
+    it('should work with an empty object argument', function() {
       assert.doesNotThrow(function() {
-        new grpc.Server([]);
+        new grpc.Server({});
+      });
+    });
+    it('should work without the new keyword', function() {
+      var server;
+      assert.doesNotThrow(function() {
+        server = grpc.Server();
+      });
+      assert(server instanceof grpc.Server);
+    });
+    it('should only accept objects with string or int values', function() {
+      assert.doesNotThrow(function() {
+        new grpc.Server({'key' : 'value'});
+      });
+      assert.doesNotThrow(function() {
+        new grpc.Server({'key' : 5});
+      });
+      assert.throws(function() {
+        new grpc.Server({'key' : null});
+      });
+      assert.throws(function() {
+        new grpc.Server({'key' : new Date()});
       });
     });
   });