Adds sinon.match.hasNested

docs/release-source/release/matchers.md

@@ -220,6 +220,22 @@ The property might be inherited via the prototype chain. If the optional expecta
 Same as `sinon.match.has` but the property must be defined by the value itself. Inherited properties are ignored.
 
 
+#### `sinon.match.hasNested(propertyPath[, expectation])`
+
+Requires the value to define the given `propertyPath`. Dot (`prop.prop`) and bracket (`prop[0]`) notations are supported as in (Lodash.get)[https://lodash.com/docs/4.4.2#get].
+
+The propertyPath might be inherited via the prototype chain. If the optional expectation is given, the value at the propertyPath is deeply compared with the expectation. The expectation can be another matcher.
+
+
+```javascript
+sinon.match.hasNested("a[0].b.c");
+sinon.match.hasNested("a.b.c");
+
+// Where actual is something like
+var actual = { "a": [{ "b": { "c": 3 } }] };
+```
+
+
 ## Combining matchers
 
 All matchers implement `and` and `or`. This allows to logically combine mutliple matchers. The result is a new matchers that requires both (and) or one of the matchers (or) to return `true`.

lib/sinon/match.js

@@ -3,6 +3,7 @@
 var deepEqual = require("./util/core/deep-equal").use(match); // eslint-disable-line no-use-before-define
 var every = require("./util/core/every");
 var functionName = require("./util/core/function-name");
+var get = require("lodash.get");
 var iterableToString = require("./util/core/iterable-to-string");
 var typeOf = require("./util/core/typeOf");
 var valueToString = require("./util/core/value-to-string");
@@ -225,6 +226,23 @@ match.hasOwn = createPropertyMatcher(function (actual, property) {
     return actual.hasOwnProperty(property);
 }, "hasOwn");
 
+match.hasNested = function (property, value) {
+    assertType(property, "string", "property");
+    var onlyProperty = arguments.length === 1;
+    var message = "hasNested(\"" + property + "\"";
+    if (!onlyProperty) {
+        message += ", " + valueToString(value);
+    }
+    message += ")";
+    return match(function (actual) {
+        if (actual === undefined || actual === null ||
+                get(actual, property) === undefined) {
+            return false;
+        }
+        return onlyProperty || deepEqual(value, get(actual, property));
+    }, message);
+};
+
 match.array = match.typeOf("array");
 
 match.array.deepEquals = function (expectation) {

package.json

@@ -37,6 +37,7 @@
   "dependencies": {
     "diff": "^3.1.0",
     "formatio": "1.2.0",
+    "lodash.get": "^4.4.2",
     "lolex": "^2.1.2",
     "native-promise-only": "^0.8.1",
     "nise": "^1.0.1",

test/match-test.js

@@ -3,7 +3,7 @@
 var assert = require("referee").assert;
 var sinonMatch = require("../lib/sinon/match");
 
-function propertyMatcherTests(matcher) {
+function propertyMatcherTests(matcher, additionalTests) {
     return function () {
         it("returns matcher", function () {
             var has = matcher("foo");
@@ -69,6 +69,10 @@ function propertyMatcherTests(matcher) {
 
             assert(has.test({ callback: function () {} }));
         });
+
+        if (typeof additionalTests === "function") {
+            additionalTests();
+        }
     };
 }
 
@@ -523,6 +527,22 @@ describe("sinonMatch", function () {
     describe(".has", propertyMatcherTests(sinonMatch.has));
     describe(".hasOwn", propertyMatcherTests(sinonMatch.hasOwn));
 
+    describe(".hasNested", propertyMatcherTests(sinonMatch.hasNested, function () {
+
+        it("compares nested value", function () {
+            var hasNested = sinonMatch.hasNested("foo.bar", "doo");
+
+            assert(hasNested.test({ foo: { bar: "doo" } }));
+        });
+
+        it("compares nested array value", function () {
+            var hasNested = sinonMatch.hasNested("foo[0].bar", "doo");
+
+            assert(hasNested.test({ foo: [{ bar: "doo" }] }));
+        });
+
+    }));
+
     describe(".hasSpecial", function () {
         it("returns true if object has inherited property", function () {
             var has = sinonMatch.has("toString");