Clean up getters/setters in errors

Author: pfmooney

lib/errors/index.js

@@ -1,6 +1,7 @@
 // Copyright 2011 Mark Cavage, Inc.  All rights reserved.
 
 var util = require('util');
+var assert = require('assert-plus');
 
 var LDAPResult = require('../messages').LDAPResult;
 
@@ -11,36 +12,46 @@ var CODES = require('./codes');
 var ERRORS = [];
 
 
-
 ///--- Error Base class
 
-function LDAPError(errorName, errorCode, msg, dn, caller) {
+function LDAPError(message, dn, caller) {
   if (Error.captureStackTrace)
     Error.captureStackTrace(this, caller || LDAPError);
 
-  this.__defineGetter__('dn', function () {
-    return (dn ? (dn.toString() || '') : '');
-  });
-  this.__defineGetter__('code', function () {
-    return errorCode;
-  });
-  this.__defineGetter__('name', function () {
-    return errorName;
-  });
-  this.__defineGetter__('message', function () {
-    return msg || errorName;
-  });
+  this.lde_message = message;
+  this.lde_dn = dn;
 }
 util.inherits(LDAPError, Error);
-
+Object.defineProperties(LDAPError.prototype, {
+  name: {
+    get: function getName() { return 'LDAPError'; },
+    configurable: false
+  },
+  code: {
+    get: function getCode() { return CODES.LDAP_OTHER; },
+    configurable: false
+  },
+  message: {
+    get: function getMessage() {
+      return this.lde_message || this.name;
+    },
+    configurable: false
+  },
+  dn: {
+    get: function getDN() {
+      return (this.lde_dn ? this.lde_dn.toString() : '');
+    },
+    configurable: false
+  }
+});
 
 
 ///--- Exported API
-// Some whacky games here to make sure all the codes are exported
 
 module.exports = {};
 module.exports.LDAPError = LDAPError;
 
+// Some whacky games here to make sure all the codes are exported
 Object.keys(CODES).forEach(function (code) {
   module.exports[code] = CODES[code];
   if (code === 'LDAP_SUCCESS')
@@ -62,26 +73,29 @@ Object.keys(CODES).forEach(function (code) {
   // At this point LDAP_OPERATIONS_ERROR is now OperationsError in $err
   // and 'Operations Error' in $msg
   module.exports[err] = function (message, dn, caller) {
-    LDAPError.call(this,
-                   err,
-                   CODES[code],
-                   message || msg,
-                   dn || null,
-                   caller || module.exports[err]);
+    LDAPError.call(this, message, dn, caller || module.exports[err]);
   };
   module.exports[err].constructor = module.exports[err];
   util.inherits(module.exports[err], LDAPError);
+  Object.defineProperties(module.exports[err].prototype, {
+    name: {
+      get: function getName() { return err; },
+      configurable: false
+    },
+    code: {
+      get: function getCode() { return CODES[code]; },
+      configurable: false
+    }
+  });
 
   ERRORS[CODES[code]] = {
     err: err,
     message: msg
   };
 });
 
-
 module.exports.getError = function (res) {
-  if (!(res instanceof LDAPResult))
-    throw new TypeError('res (LDAPResult) required');
+  assert.ok(res instanceof LDAPResult, 'res (LDAPResult) required');
 
   var errObj = ERRORS[res.status];
   var E = module.exports[errObj.err];
@@ -90,10 +104,8 @@ module.exports.getError = function (res) {
                module.exports.getError);
 };
 
-
 module.exports.getMessage = function (code) {
-  if (typeof (code) !== 'number')
-    throw new TypeError('code (number) required');
+  assert.number(code, 'code (number) required');
 
   var errObj = ERRORS[code];
   return (errObj && errObj.message ? errObj.message : '');
@@ -103,34 +115,37 @@ module.exports.getMessage = function (code) {
 ///--- Custom application errors
 
 function ConnectionError(message) {
-  LDAPError.call(this,
-                 'ConnectionError',
-                 CODES.LDAP_OTHER,
-                 message,
-                 null,
-                 ConnectionError);
+  LDAPError.call(this, message, null, ConnectionError);
 }
 util.inherits(ConnectionError, LDAPError);
 module.exports.ConnectionError = ConnectionError;
+Object.defineProperties(ConnectionError.prototype, {
+  name: {
+    get: function () { return 'ConnectionError'; },
+    configurable: false
+  }
+});
 
 function AbandonedError(message) {
-  LDAPError.call(this,
-                 'AbandonedError',
-                 CODES.LDAP_OTHER,
-                 message,
-                 null,
-                 AbandonedError);
+  LDAPError.call(this, message, null, AbandonedError);
 }
 util.inherits(AbandonedError, LDAPError);
 module.exports.AbandonedError = AbandonedError;
+Object.defineProperties(AbandonedError.prototype, {
+  name: {
+    get: function () { return 'AbandonedError'; },
+    configurable: false
+  }
+});
 
 function TimeoutError(message) {
-  LDAPError.call(this,
-                 'TimeoutError',
-                 CODES.LDAP_OTHER,
-                 message,
-                 null,
-                 TimeoutError);
+  LDAPError.call(this, message, null, TimeoutError);
 }
 util.inherits(TimeoutError, LDAPError);
 module.exports.TimeoutError = TimeoutError;
+Object.defineProperties(TimeoutError.prototype, {
+  name: {
+    get: function () { return 'TimeoutError'; },
+    configurable: false
+  }
+});

test/errors.test.js

@@ -0,0 +1,39 @@
+// Copyright 2015 Joyent, Inc.
+
+var test = require('tape').test;
+
+var ldap = require('../lib/index');
+
+
+///--- Tests
+
+test('basic error', function (t) {
+  var msg = 'mymsg';
+  var err = new ldap.LDAPError(msg, null, null);
+  t.ok(err);
+  t.equal(err.name, 'LDAPError');
+  t.equal(err.code, ldap.LDAP_OTHER);
+  t.equal(err.dn, '');
+  t.equal(err.message, msg);
+  t.end();
+});
+
+test('"custom" errors', function (t) {
+  var errors = [
+    { name: 'ConnectionError', func: ldap.ConnectionError },
+    { name: 'AbandonedError', func: ldap.AbandonedError },
+    { name: 'TimeoutError', func: ldap.TimeoutError }
+  ];
+
+  errors.forEach(function (entry) {
+    var msg = entry.name + 'msg';
+    var err = new entry.func(msg);
+    t.ok(err);
+    t.equal(err.name, entry.name);
+    t.equal(err.code, ldap.LDAP_OTHER);
+    t.equal(err.dn, '');
+    t.equal(err.message, msg);
+  });
+
+  t.end();
+});