parameter validation test

Author: baileympearson

lib/kerberos.js

@@ -43,7 +43,7 @@ const originalStep = KerberosClient.prototype.step;
  */
 KerberosClient.prototype.step = async function step(challenge) {
   if (typeof challenge !== 'string') {
-    throw new Error('parameter `challenge` must be a string.');
+    throw new TypeError('parameter `challenge` must be a string.');
   }
   return await promisify(originalStep.bind(this))(challenge);
 };
@@ -60,15 +60,11 @@ const originalWrap = KerberosClient.prototype.wrap;
  * @param {boolean} [options.protect] Indicates if the wrap should request message confidentiality
  * @return {Promise<string>}
  */
-KerberosClient.prototype.wrap = async function wrap(challenge, options) {
+KerberosClient.prototype.wrap = async function wrap(challenge, options = {}) {
   if (typeof challenge !== 'string') {
-    throw new Error('parameter `challenge` must be a string.');
+    throw new TypeError('parameter `challenge` must be a string.');
   }
 
-  // eslint-disable-next-line no-restricted-syntax
-  if (typeof challenge !== 'object' || challenge === null) {
-    throw new Error('parameter `challenge` must be an object.');
-  }
   return await promisify(originalWrap.bind(this))(challenge, options);
 };
 
@@ -83,7 +79,7 @@ const originalUnwrap = KerberosClient.prototype.unwrap;
  */
 KerberosClient.prototype.unwrap = async function unwrap(challenge) {
   if (typeof challenge !== 'string') {
-    throw new Error('parameter `challenge` must be a string.');
+    throw new TypeError('parameter `challenge` must be a string.');
   }
   return await promisify(originalUnwrap.bind(this))(challenge);
 };
@@ -108,7 +104,7 @@ const originalServerStep = KerberosServer.prototype.step;
  */
 KerberosServer.prototype.step = async function step(challenge) {
   if (typeof challenge !== 'string') {
-    throw new Error('parameter `challenge` must be a string.');
+    throw new TypeError('parameter `challenge` must be a string.');
   }
   return await promisify(originalServerStep.bind(this))(challenge);
 };
@@ -139,16 +135,16 @@ KerberosServer.prototype.step = async function step(challenge) {
  */
 async function checkPassword(username, password, service, defaultRealm) {
   if (typeof username !== 'string') {
-    throw new Error('parameter `username` must be a string.');
+    throw new TypeError('parameter `username` must be a string.');
   }
   if (typeof password !== 'string') {
-    throw new Error('parameter `password` must be a string.');
+    throw new TypeError('parameter `password` must be a string.');
   }
   if (typeof service !== 'string') {
-    throw new Error('parameter `service` must be a string.');
+    throw new TypeError('parameter `service` must be a string.');
   }
   if (defaultRealm && typeof defaultRealm !== 'string') {
-    throw new Error('if specified, parameter `defaultRealm` must be a string.');
+    throw new TypeError('if specified, parameter `defaultRealm` must be a string.');
   }
   return await promisify(kerberos.checkPassword)(username, password, service, defaultRealm);
 }
@@ -165,10 +161,10 @@ async function checkPassword(username, password, service, defaultRealm) {
  */
 async function principalDetails(service, hostname) {
   if (typeof service !== 'string') {
-    throw new Error('parameter `service` must be a string.');
+    throw new TypeError('parameter `service` must be a string.');
   }
   if (typeof hostname !== 'string') {
-    throw new Error('parameter `hostname` must be a string.');
+    throw new TypeError('parameter `hostname` must be a string.');
   }
   return await promisify(kerberos.principalDetails)(service, hostname);
 }
@@ -186,7 +182,7 @@ async function principalDetails(service, hostname) {
  */
 async function initializeClient(service, options = { mechOID: GSS_C_NO_OID }) {
   if (typeof service !== 'string') {
-    throw new Error('parameter `service` must be a string.');
+    throw new TypeError('parameter `service` must be a string.');
   }
   return await promisify(kerberos.initializeClient)(service, options);
 }
@@ -200,7 +196,7 @@ async function initializeClient(service, options = { mechOID: GSS_C_NO_OID }) {
  */
 async function initializeServer(service) {
   if (typeof service !== 'string') {
-    throw new Error('parameter `service` must be a string.');
+    throw new TypeError('parameter `service` must be a string.');
   }
   return await promisify(kerberos.initializeServer)(service);
 }

test/kerberos_tests.js

@@ -141,4 +141,84 @@ describe('Kerberos', function () {
       });
     });
   });
+
+  describe('parameter validation', function () {
+    test('initializeClient() throws if service is not a string', async function () {
+      expect(await kerberos.initializeClient().catch(e => e))
+        .to.be.instanceOf(TypeError)
+        .to.match(/`service` must be a string/);
+    });
+
+    test('initializeServer() throws if service is not a string', async function () {
+      expect(await kerberos.initializeServer().catch(e => e))
+        .to.be.instanceOf(TypeError)
+        .to.match(/`service` must be a string/);
+    });
+
+    test('principalDetails() throws if service is not a string', async function () {
+      expect(await kerberos.principalDetails(3, 'foo').catch(e => e))
+        .to.be.instanceOf(TypeError)
+        .to.match(/`service` must be a string/);
+    });
+
+    test('principalDetails() throws if hostname is not a string', async function () {
+      expect(await kerberos.principalDetails('foo', 3).catch(e => e))
+        .to.be.instanceOf(TypeError)
+        .to.match(/`hostname` must be a string/);
+    });
+
+    test('checkPassword() throws if username is not a string', async function () {
+      expect(await kerberos.checkPassword(3, 'password', 'service').catch(e => e))
+        .to.be.instanceOf(TypeError)
+        .to.match(/`username` must be a string/);
+    });
+
+    test('checkPassword() throws if password is not a string', async function () {
+      expect(await kerberos.checkPassword('username', 3, 'service').catch(e => e))
+        .to.be.instanceOf(TypeError)
+        .to.match(/`password` must be a string/);
+    });
+
+    test('checkPassword() throws if service is not a string', async function () {
+      expect(await kerberos.checkPassword('username', 'password', 3).catch(e => e))
+        .to.be.instanceOf(TypeError)
+        .to.match(/`service` must be a string/);
+    });
+
+    test('KerberosServer.step() throws if challenge is not a string', async function () {
+      const service = `HTTP@${hostname}`;
+
+      const server = await kerberos.initializeServer(service);
+      expect(await server.step(3).catch(e => e))
+        .to.be.instanceOf(TypeError)
+        .to.match(/`challenge` must be a string/);
+    });
+
+    describe('KerberosClient', function () {
+      let client;
+      beforeEach(async function () {
+        const service = `HTTP@${hostname}`;
+
+        client = await kerberos.initializeClient(service);
+      });
+
+      test('KerberosClient.unwrap() throws if challenge is not a string', async function () {
+        expect(await client.unwrap(3).catch(e => e))
+          .to.be.instanceOf(TypeError)
+          .to.match(/`challenge` must be a string/);
+      });
+
+      test('KerberosClient.wrap() throws if challenge is not a string', async function () {
+        expect(await client.wrap(3).catch(e => e))
+          .to.be.instanceOf(TypeError)
+          .to.match(/`challenge` must be a string/);
+      });
+
+      test('KerberosClient.step() throws if challenge is not a string', async function () {
+        expect(await client.step(3).catch(e => e))
+          .to.be.instanceOf(TypeError)
+          .to.match(/`challenge` must be a string/);
+      });
+    });
+  });
 });