Use inherited properties in deep equal and inspect

lib/chai/utils/eql.js

@@ -3,6 +3,8 @@
 
 module.exports = _deepEqual;
 
+var getEnumerableProperties = require('./getEnumerableProperties');
+
 // for the browser
 var Buffer;
 try {
@@ -87,8 +89,8 @@ function objEquiv(a, b, memos) {
     return _deepEqual(a, b, memos);
   }
   try {
-    var ka = Object.keys(a),
-        kb = Object.keys(b),
+    var ka = getEnumerableProperties(a),
+        kb = getEnumerableProperties(b),
         key;
   } catch (e) {//happens when one is a string literal and the other isn't
     return false;

lib/chai/utils/getEnumerableProperties.js

@@ -0,0 +1,25 @@
+/*!
+ * Chai - getEnumerableProperties utility
+ * Copyright(c) 2012 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/**
+ * ### .getEnumerableProperties(object)
+ *
+ * This allows the retrieval of enumerable property names of an object,
+ * inherited or not.
+ *
+ * @param {Object} object
+ * @returns {Array}
+ * @name getEnumerableProperties
+ * @api public
+ */
+
+module.exports = function getEnumerableProperties(object) {
+  var result = [];
+  for (var name in object) {
+    result.push(name);
+  }
+  return result;
+};

lib/chai/utils/getProperties.js

@@ -0,0 +1,35 @@
+/*!
+ * Chai - getProperties utility
+ * Copyright(c) 2012 Jake Luer <jake@alogicalparadox.com>
+ * MIT Licensed
+ */
+
+/**
+ * ### .getProperties(object)
+ *
+ * This allows the retrieval of property names of an object, enumerable or not,
+ * inherited or not.
+ *
+ * @param {Object} object
+ * @returns {Array}
+ * @name getProperties
+ * @api public
+ */
+
+module.exports = function getProperties(object) {
+  var result = Object.getOwnPropertyNames(subject);
+
+  function addProperty(property) {
+    if (result.indexOf(property) === -1) {
+      result.push(property);
+    }
+  }
+
+  var proto = Object.getPrototypeOf(subject);
+  while (proto !== null) {
+    Object.getOwnPropertyNames(proto).forEach(addProperty);
+    proto = Object.getPrototypeOf(proto);
+  }
+
+  return result;
+};

lib/chai/utils/inspect.js

@@ -2,6 +2,8 @@
 // https://github.com/joyent/node/blob/f8c335d0caf47f16d31413f89aa28eda3878e3aa/lib/util.js
 
 var getName = require('./getName');
+var getProperties = require('./getProperties');
+var getEnumerableProperties = require('./getEnumerableProperties');
 
 module.exports = inspect;
 
@@ -42,7 +44,7 @@ var getOuterHTML = function(element) {
     return html;
   }
 };
-  
+
 // Returns true if object is a DOM element.
 var isDOMElement = function (object) {
   if (typeof HTMLElement === 'object') {
@@ -78,8 +80,8 @@ function formatValue(ctx, value, recurseTimes) {
   }
 
   // Look up the keys of the object.
-  var visibleKeys = Object.keys(value);
-  var keys = ctx.showHidden ? Object.getOwnPropertyNames(value) : visibleKeys;
+  var visibleKeys = getEnumerableProperties(value);
+  var keys = ctx.showHidden ? getProperties(value) : visibleKeys;
 
   // Some type of object without properties can be shortcutted.
   // In IE, errors have a single `stack` property, or if they are vanilla `Error`,

test/assert.js

@@ -164,9 +164,16 @@ suite('assert', function () {
   test('deepEqual', function() {
     assert.deepEqual({tea: 'chai'}, {tea: 'chai'});
 
+
     err(function () {
       assert.deepEqual({tea: 'chai'}, {tea: 'black'});
     }, "expected { tea: \'chai\' } to deeply equal { tea: \'black\' }");
+
+    var obj1 = Object.create({tea: 'chai'});
+    var obj2 = Object.create({tea: 'black'});
+    err(function () {
+      assert.deepEqual(obj1, obj2);
+    }, "expected { tea: \'chai\' } to deeply equal { tea: \'black\' }");
   });
 
   test('deepEqual (circular)', function() {

test/expect.js

@@ -336,7 +336,7 @@ suite('expect', function () {
 
     err(function(){
       expect(new FakeArgs).not.to.be.empty;
-    }, "expected {} not to be empty");
+    }, "expected { length: 0 } not to be empty");
 
     err(function(){
       expect({arguments: 0}).to.be.empty;

test/should.js

@@ -320,7 +320,7 @@ suite('should', function() {
 
     err(function(){
       (new FakeArgs).should.not.be.empty;
-    }, "expected {} not to be empty");
+    }, "expected { length: 0 } not to be empty");
 
     err(function(){
       ({arguments: 0}).should.be.empty;