property assertion should only accept strings if nested, fixes #1043

lib/chai/core/assertions.js

@@ -1763,10 +1763,30 @@ module.exports = function (chai, _) {
       , isOwn = flag(this, 'own')
       , flagMsg = flag(this, 'message')
       , obj = flag(this, 'object')
-      , ssfi = flag(this, 'ssfi');
+      , ssfi = flag(this, 'ssfi')
+      , nameType = typeof name;
+
+    flagMsg = flagMsg ? flagMsg + ': ' : '';
+
+    if (isNested) {
+      if (nameType !== 'string') {
+        throw new AssertionError(
+          flagMsg + 'the argument to property must be a string when using nested syntax',
+          undefined,
+          ssfi
+        );
+      }
+    } else {
+      if (nameType !== 'string' && nameType !== 'number' && nameType !== 'symbol') {
+        throw new AssertionError(
+          flagMsg + 'the argument to property must be a string, number, or symbol',
+          undefined,
+          ssfi
+        );
+      }
+    }
 
     if (isNested && isOwn) {
-      flagMsg = flagMsg ? flagMsg + ': ' : '';
       throw new AssertionError(
         flagMsg + 'The "nested" and "own" flags cannot be combined.',
         undefined,
@@ -1775,7 +1795,6 @@ module.exports = function (chai, _) {
     }
 
     if (obj === null || obj === undefined) {
-      flagMsg = flagMsg ? flagMsg + ': ' : '';
       throw new AssertionError(
         flagMsg + 'Target cannot be null or undefined.',
         undefined,

test/assert.js

@@ -1395,6 +1395,7 @@ describe('assert', function () {
     var obj = { foo: { bar: 'baz' } };
     var simpleObj = { foo: 'bar' };
     var undefinedKeyObj = { foo: undefined };
+    var dummyObj = { a: '1' };
     assert.property(obj, 'foo');
     assert.property(obj, 'toString');
     assert.propertyVal(obj, 'toString', Object.prototype.toString);
@@ -1454,6 +1455,14 @@ describe('assert', function () {
     err(function () {
       assert.property(undefined, 'a', 'blah');
     }, "blah: Target cannot be null or undefined.");
+
+    err(function () {
+      assert.propertyVal(dummyObj, 'a', '2', 'blah');
+    }, "blah: expected { a: '1' } to have property 'a' of '2', but got '1'");
+
+    err(function () {
+      assert.nestedProperty({a:1}, {'a':'1'}, 'blah');
+    }, 'blah: the argument to property must be a string when using nested syntax');
   });
 
   it('deepPropertyVal', function () {

test/expect.js

@@ -1462,6 +1462,10 @@ describe('expect', function () {
     err(function () {
       expect(undefined, 'blah').to.have.property("a");
     }, "blah: Target cannot be null or undefined.");
+
+    expect(function () {
+      expect({a:1}).to.have.property(null);
+    }).to.throw('the argument to property must be a string, number, or symbol');
   });
 
   it('property(name, val)', function(){
@@ -1755,6 +1759,10 @@ describe('expect', function () {
       expect({ 'foo.bar': 'baz' })
         .to.have.nested.property('foo.bar');
     }, "expected { 'foo.bar': 'baz' } to have nested property 'foo.bar'");
+
+    expect(function () {
+      expect({a:1}).to.have.nested.property({'a':'1'});
+    }).to.throw('the argument to property must be a string when using nested syntax');
   });
 
   it('nested.property(name, val)', function(){

test/should.js

@@ -1407,6 +1407,16 @@ describe('should', function() {
 
     ({ 'foo.bar[]': 'baz'}).should.have.nested.property('foo\\.bar\\[\\]');
 
+    ({a:1}).should.have.nested.property('a');
+
+    (function () {
+      ({a:1}).should.have.nested.property('{a:1}');
+    }).should.not.throw('the argument to property must be a string when using nested syntax');
+
+    (function () {
+      ({a:1}).should.have.nested.property({'a':'1'});
+    }).should.throw('the argument to property must be a string when using nested syntax');
+
     err(function(){
       ({ 'foo.bar': 'baz' }).should.have.nested.property('foo.bar');
     }, "expected { 'foo.bar': 'baz' } to have nested property 'foo.bar'");