Merge branch 'lgandecki-lgandecki-containsMatchers'

Author: searls

regression/src/matchers-test.coffee

@@ -87,13 +87,72 @@ describe '.matchers', ->
       Then -> @matches(td.matchers.contains(true, 5, null, undefined), [true, 5, undefined, null]) == true
       Then -> @matches(td.matchers.contains(true, 5, null, undefined), [true, 5, null]) == false
 
+      describe 'elements containing matchers', ->
+        Then -> @matches(td.matchers.contains('b', td.matchers.isA(Number)), ['a', 3, 'b']) == true
+
     context 'objects', ->
       Then -> @matches(td.matchers.contains(foo: 'bar', baz: 42), foo: 'bar', baz: 42, stuff: this) == true
       Then -> @matches(td.matchers.contains(foo: 'bar', lol: 42), foo: 'bar', baz: 42) == false
       Then -> @matches(td.matchers.contains(lol: {deep: [4,2]}), lol: {deep: [4,2], other: "stuff"}) == true
       Then -> @matches(td.matchers.contains(deep: {thing: 'stuff'}), {}) == false
-      Then -> @matches(td.matchers.contains(deep: {thing: 'stuff'}), deep: {thing: 'stuff', shallow: 5}) == true
-      Then -> @matches(td.matchers.contains({container: {size: 'S'}}), {ingredient: 'beans', container: { type: 'cup', size: 'S'}}) == true
+      Then -> @matches(td.matchers.contains(deep: {thing: 'stuff'}),
+          deep: {thing: 'stuff', shallow: 5}
+        ) == true
+      Then -> @matches(td.matchers.contains({container: {size: 'S'}}),
+          {ingredient: 'beans', container: { type: 'cup', size: 'S'}}
+        ) == true
+
+      describe 'objects containing matchers', ->
+        Then -> @matches(td.matchers.contains(td.matchers.isA(Number)),
+            {a: 'foo', b: 32}
+          ) == true
+        Then -> @matches(td.matchers.contains(td.matchers.isA(Function)),
+            {a: 'foo', b: 32}
+          ) == false
+        Then -> @matches(td.matchers.contains({a: td.matchers.contains(1,2)}),
+            {a: [4,1,2,3]}
+          ) == true
+        Then -> @matches(td.matchers.contains({a: td.matchers.contains(1,5)}),
+            {a: [4,1,2,3]}
+          ) == false
+        Then -> @matches(
+            td.matchers.contains({someString: td.matchers.isA(String)}),
+            {someString: "beautifulString"}
+          ) == true
+        Then -> @matches(
+            td.matchers.contains({someString: td.matchers.isA(String)}),
+            {someString: "beautifulString", irrelevant: true}
+          ) == true
+        Then -> @matches(
+            td.matchers.contains(
+              {nested: {someString: td.matchers.isA(String)}, relevant: true}
+            ),
+            {nested: {someString: "beautifulString"}, relevant: true}
+          ) == true
+        Then -> @matches(
+            td.matchers.contains({someString: td.matchers.isA(String)}),
+            {someString: 4}
+          ) == false
+        Then -> @matches(
+            td.matchers.contains({
+              nested: td.matchers.contains({
+                nestedString: td.matchers.isA(String)
+              })
+            }),
+            {nested: {nestedString: "abc", irrelevant: true}, irrelevantHere: "alsoTrue"}
+          ) == true
+        Then -> @matches(
+            td.matchers.contains({
+              nested: td.matchers.contains({
+                nestedString: td.matchers.isA(Number)
+              })
+            }),
+            {nested: {nestedString: "abc", irrelevant: true}, irrelevantHere: "not a number!"}
+          ) == false
+        Then -> @matches(td.matchers.contains({a: [td.matchers.isA(Number)]}),
+            {a: [5]}
+          ) == true
+
 
     context 'regexp', ->
       Then -> @matches(td.matchers.contains(/abc/), 'abc') == true

src/matchers/builtin/contains.js

@@ -1,27 +1,40 @@
 import _ from '../../wrap/lodash'
 import create from '../create'
+import isMatcher from '../is-matcher'
 
 export default create({
   name: 'contains',
   matches (containings, actualArg) {
     if (containings.length === 0) return false
 
-    return _.every(containings, (containing) => {
-      if (_.isArray(containing)) {
-        return _.some(actualArg, actualElement => _.isEqual(actualElement, containing))
-      } else if (_.isRegExp(containing)) {
-        return containing.test(actualArg)
-      } else if (_.isObjectLike(containing) && _.isObjectLike(actualArg)) {
-        return containsAllSpecified(containing, actualArg)
-      } else {
-        return _.includes(actualArg, containing)
-      }
-    })
+    return _.every(containings, (containing) =>
+      argumentContains(containing, actualArg)
+    )
   }
 })
 
-var containsAllSpecified = (containing, actual) =>
-  actual != null && _.every(containing, (val, key) =>
-    _.isObjectLike(val)
-      ? containsAllSpecified(val, actual[key])
-      : _.isEqual(val, actual[key]))
+const argumentContains = function (containing, actualArg) {
+  if (_.isArray(containing)) {
+    return _.some(actualArg, actualElement => _.isEqual(actualElement, containing))
+  } else if (_.isRegExp(containing)) {
+    return containing.test(actualArg)
+  } else if (isMatcher(containing)) {
+    return _.some(actualArg, containing.__matches)
+  } else if (_.isObjectLike(containing) && _.isObjectLike(actualArg)) {
+    return containsPartialObject(containing, actualArg)
+  } else {
+    return _.includes(actualArg, containing)
+  }
+}
+
+var containsPartialObject = (containing, actual) => {
+  return actual != null && _.every(containing, (val, key) => {
+    if (isMatcher(val)) {
+      return val.__matches(actual[key])
+    } else if (_.isObjectLike(val)) {
+      return containsPartialObject(val, actual[key])
+    } else {
+      return _.isEqual(val, actual[key])
+    }
+  })
+}