refactor(util): expose defineOperation for testing

Author: mbroadst

lib/kerberos.js

@@ -3,6 +3,7 @@
 const kerberos = require('bindings')('kerberos');
 const KerberosClient = kerberos.KerberosClient;
 const KerberosServer = kerberos.KerberosServer;
+const defineOperation = require('./util').defineOperation;
 
 // GSS Flags
 const GSS_C_DELEG_FLAG = 1;
@@ -20,67 +21,6 @@ const GSS_C_NO_OID = 0;
 const GSS_MECH_OID_KRB5 = 9;
 const GSS_MECH_OID_SPNEGO = 6;
 
-function validateParameter(parameter, spec) {
-  if (parameter == null) {
-    throw new TypeError(`Required parameter \`${spec.name}\` missing`);
-  }
-
-  if (spec.type && typeof parameter !== spec.type) {
-    throw new TypeError(
-      `Invalid type for parameter \`${spec.name}\`, expected \`${
-        spec.type
-      }\` but found \`${typeof parameter}\``
-    );
-  }
-}
-
-/**
- * Monkey-patches an existing method to support parameter validation, as well
- * as adding support for returning Promises if callbacks are not provided.
- *
- * @private
- * @param {function} fn the function to override
- * @param {Array<Object>} paramDefs the definitions of each parameter to the function
- */
-function defineOperation(fn, paramDefs) {
-  return function() {
-    const args = Array.prototype.slice.call(arguments);
-    const params = [];
-    for (let i = 0; i < paramDefs.length; ++i) {
-      const def = paramDefs[i];
-      let arg = args[i];
-
-      if (def.default && arg == null) arg = def.default;
-      if (def.type === 'object' && def.default != null) {
-        arg = Object.assign({}, def.default, arg);
-      }
-
-      // special case to allow `options` to be optional
-      if (def.name === 'options' && (typeof arg === 'function' || arg == null)) {
-        arg = {};
-      }
-
-      validateParameter(arg, paramDefs[i]);
-      params.push(arg);
-    }
-
-    const callback = arguments[arguments.length - 1];
-    if (typeof callback !== 'function') {
-      return new Promise((resolve, reject) => {
-        params.push((err, response) => {
-          if (err) return reject(err);
-          resolve(response);
-        });
-
-        fn.apply(this, params);
-      });
-    }
-
-    params.push(callback);
-    fn.apply(this, params);
-  };
-}
-
 /**
  * @class KerberosClient
  *
@@ -147,7 +87,7 @@ KerberosClient.prototype.unwrap = defineOperation(KerberosClient.prototype.unwra
  * @kind function
  * @memberof KerberosServer
  * @param {string} challenge A string containing the base64-encoded client data
- * @param {function} callback
+ * @param {function} [callback]
  * @return {Promise} returns Promise if no callback passed
  */
 KerberosServer.prototype.step = defineOperation(KerberosServer.prototype.step, [

lib/util.js

@@ -0,0 +1,68 @@
+'use strict';
+
+function validateParameter(parameter, spec) {
+  if (parameter == null && spec.required === false) {
+    return;
+  }
+
+  if (parameter == null) {
+    throw new TypeError(`Required parameter \`${spec.name}\` missing`);
+  }
+
+  if (spec.type && typeof parameter !== spec.type) {
+    throw new TypeError(
+      `Invalid type for parameter \`${spec.name}\`, expected \`${
+        spec.type
+      }\` but found \`${typeof parameter}\``
+    );
+  }
+}
+
+/**
+ * Monkey-patches an existing method to support parameter validation, as well
+ * as adding support for returning Promises if callbacks are not provided.
+ *
+ * @private
+ * @param {function} fn the function to override
+ * @param {Array<Object>} paramDefs the definitions of each parameter to the function
+ */
+function defineOperation(fn, paramDefs) {
+  return function() {
+    const args = Array.prototype.slice.call(arguments);
+    const params = [];
+    for (let i = 0; i < paramDefs.length; ++i) {
+      const def = paramDefs[i];
+      let arg = args[i];
+
+      if (def.default && arg == null) arg = def.default;
+      if (def.type === 'object' && def.default != null) {
+        arg = Object.assign({}, def.default, arg);
+      }
+
+      // special case to allow `options` to be optional
+      if (def.name === 'options' && (typeof arg === 'function' || arg == null)) {
+        arg = {};
+      }
+
+      validateParameter(arg, paramDefs[i]);
+      params.push(arg);
+    }
+
+    const callback = params.pop();
+    if (typeof callback !== 'function') {
+      return new Promise((resolve, reject) => {
+        params.push((err, response) => {
+          if (err) return reject(err);
+          resolve(response);
+        });
+
+        fn.apply(this, params);
+      });
+    }
+
+    params.push(callback);
+    fn.apply(this, params);
+  };
+}
+
+module.exports = { defineOperation, validateParameter };