Merge pull request #1232 from lucasfcosta/sets-matchers

Sets matchers

docs/release-source/release/matchers.md

@@ -147,6 +147,21 @@ Requires a `Map` to be deep equal another one.
 Requires a `Map` to contain each one of the items the given map has.
 
 
+#### `sinon.match.set"
+
+Requires the value to be a `Set`.
+
+
+#### `sinon.match.set.deepEquals(set)`
+
+Requires a `Set` to be deep equal another one.
+
+
+#### `sinon.match.set.contains(set)`
+
+Requires a `Set` to contain each one of the items the given set has.
+
+
 #### `sinon.match.regexp"
 
 Requires the value to be a regular expression.

lib/sinon/match.js

@@ -284,6 +284,26 @@ match.map.contains = function mapContains(expectation) {
     }, "contains(Map[" + iterableToString(expectation) + "])");
 };
 
+match.set = match.typeOf("set");
+
+match.set.deepEquals = function setDeepEquals(expectation) {
+    return match(function (actual) {
+        // Comparing lengths is the fastest way to spot a difference before iterating through every item
+        var sameLength = actual.size === expectation.size;
+        return typeOf(actual) === "set" && sameLength && every(actual, function (element) {
+            return expectation.has(element);
+        });
+    }, "deepEquals(Set[" + iterableToString(expectation) + "])");
+};
+
+match.set.contains = function setContains(expectation) {
+    return match(function (actual) {
+        return typeOf(actual) === "set" && every(expectation, function (element) {
+            return actual.has(element);
+        });
+    }, "contains(Set[" + iterableToString(expectation) + "])");
+};
+
 match.bool = match.typeOf("boolean");
 match.number = match.typeOf("number");
 match.string = match.typeOf("string");

test/match-test.js

@@ -848,6 +848,102 @@ describe("sinonMatch", function () {
         });
     });
 
+    describe(".set", function () {
+        it("is typeOf set matcher", function () {
+            var set = sinonMatch.set;
+
+            assert(sinonMatch.isMatcher(set));
+            assert.equals(set.toString(), "typeOf(\"set\")");
+        });
+
+        describe("set.deepEquals", function () {
+            if (typeof Set === "function") {
+                it("has a .deepEquals matcher", function () {
+                    var setOne = new Set();
+                    setOne.add("one");
+                    setOne.add("two");
+                    setOne.add("three");
+
+                    var deepEquals = sinonMatch.set.deepEquals(setOne);
+                    assert(sinonMatch.isMatcher(deepEquals));
+                    assert.equals(deepEquals.toString(), "deepEquals(Set['one','two','three'])");
+                });
+
+                it("matches sets with the exact same elements", function () {
+                    var setOne = new Set();
+                    setOne.add("one");
+                    setOne.add("two");
+                    setOne.add("three");
+
+                    var setTwo = new Set();
+                    setTwo.add("one");
+                    setTwo.add("two");
+                    setTwo.add("three");
+
+                    var setThree = new Set();
+                    setThree.add("one");
+                    setThree.add("two");
+
+                    var deepEquals = sinonMatch.set.deepEquals(setOne);
+                    assert(deepEquals.test(setTwo));
+                    assert.isFalse(deepEquals.test(setThree));
+                    assert.isFalse(deepEquals.test(new Set()));
+                });
+
+                it("fails when passed a non-set object", function () {
+                    var deepEquals = sinonMatch.array.deepEquals(new Set());
+                    assert.isFalse(deepEquals.test({}));
+                    assert.isFalse(deepEquals.test([]));
+                });
+            }
+        });
+
+        describe("set.contains", function () {
+            if (typeof Set === "function") {
+                it("has a .contains matcher", function () {
+                    var setOne = new Set();
+                    setOne.add("one");
+                    setOne.add("two");
+                    setOne.add("three");
+
+                    var contains = sinonMatch.set.contains(setOne);
+                    assert(sinonMatch.isMatcher(contains));
+                    assert.equals(contains.toString(), "contains(Set['one','two','three'])");
+                });
+
+                it("matches sets containing the given elements", function () {
+                    var setOne = new Set();
+                    setOne.add("one");
+                    setOne.add("two");
+                    setOne.add("three");
+
+                    var setTwo = new Set();
+                    setTwo.add("one");
+                    setTwo.add("two");
+                    setTwo.add("three");
+
+                    var setThree = new Set();
+                    setThree.add("one");
+                    setThree.add("two");
+
+                    var setFour = new Set();
+                    setFour.add("one");
+                    setFour.add("four");
+
+                    assert(sinonMatch.set.contains(setTwo).test(setOne));
+                    assert(sinonMatch.set.contains(setThree).test(setOne));
+                    assert.isFalse(sinonMatch.set.contains(setFour).test(setOne));
+                });
+
+                it("fails when passed a non-set object", function () {
+                    var contains = sinonMatch.set.contains(new Set());
+                    assert.isFalse(contains.test({}));
+                    assert.isFalse(contains.test([]));
+                });
+            }
+        });
+    });
+
     describe(".regexp", function () {
         it("is typeOf regexp matcher", function () {
             var regexp = sinonMatch.regexp;