Add custom equality matcher to support ES 2015 iterables

Summary:
Allows jest to check for equalities of Sets/Maps and Array-like by adding a [custom equality tester](http://jasmine.github.io/2.0/custom_equality.html) for iterators.
Jasmine run custom equality before the normal equality checker, so I also add a test to ensure it didn't break normal Arrays equality (as they implement `Symbol.iterator`).
Closes #923

Reviewed By: cpojer

Differential Revision: D3207226

fb-gh-sync-id: 56c074462a7e49b983c80e10cadeeb951db45118
fbshipit-source-id: 56c074462a7e49b983c80e10cadeeb951db45118

Author: kentaromiura

packages/jest-jasmine2/src/__tests__/iterators-test.js

@@ -0,0 +1,75 @@
+/**
+ * Copyright (c) 2015-present, Facebook, Inc. All rights reserved.
+ *
+ * This source code is licensed under the BSD-style license found in the
+ * LICENSE file in the root directory of this source tree. An additional grant
+ * of patent rights can be found in the PATENTS file in the same directory.
+ *
+ * @emails oncall+jsinfra
+ */
+'use strict';
+
+describe('iterators', () => {
+
+  it('works for arrays', () => {
+    const mixedArray = [1, {}, []];
+
+    expect(mixedArray).toEqual(mixedArray);
+    expect([1, 2, 3]).toEqual([1, 2, 3]);
+    expect([1]).not.toEqual([2]);
+    expect([1, 2, 3]).not.toEqual([1, 2]);
+    expect([1, 2, 3]).not.toEqual([1, 2, 3, 4]);
+  });
+
+  it('works for custom iterables', () => {
+    const iterable = {
+      0: 'a',
+      1: 'b',
+      2: 'c',
+      length: 3,
+      [Symbol.iterator]: Array.prototype[Symbol.iterator],
+    };
+    const expectedIterable = {
+      0: 'a',
+      1: 'b',
+      2: 'c',
+      length: 3,
+      [Symbol.iterator]: Array.prototype[Symbol.iterator],
+    };
+    expect(iterable).toEqual(expectedIterable);
+    expect(iterable).not.toEqual(['a', 'b']);
+    expect(iterable).not.toEqual(['a', 'b', 'c']);
+    expect(iterable).not.toEqual(['a', 'b', 'c', 'd']);
+  });
+
+  it('works for Sets', () => {
+    const numbers = [1, 2, 3, 4];
+    const setOfNumbers = new Set(numbers);
+    expect(setOfNumbers).not.toEqual(new Set());
+    expect(setOfNumbers).not.toBe(numbers);
+    expect(setOfNumbers).not.toEqual([1, 2]);
+    expect(setOfNumbers).not.toEqual([1, 2, 3]);
+    expect(setOfNumbers).toEqual(new Set(numbers));
+
+    const nestedSets = new Set([new Set([1, 2])]);
+    expect(nestedSets).not.toEqual(new Set([new Set([1, 4])]));
+    expect(nestedSets).toEqual(new Set([new Set([1, 2])]));
+  });
+
+  it('works for Maps', () => {
+    const keyValuePairs = [['key1', 'value1'], ['key2', 'value2']];
+    const smallerKeyValuePairs = [['key1', 'value1']];
+    const biggerKeyValuePairs = [
+      ['key1', 'value1'], ['key2', 'value2'], ['key3', 'value3'],
+    ];
+    const map = new Map(keyValuePairs);
+    expect(map).not.toEqual(smallerKeyValuePairs);
+    expect(map).not.toEqual(new Map(smallerKeyValuePairs));
+    expect(map).not.toEqual(biggerKeyValuePairs);
+    expect(map).not.toEqual(new Map(biggerKeyValuePairs));
+    expect(map).not.toEqual(keyValuePairs);
+    expect(map).not.toBe(keyValuePairs);
+    expect(map).toEqual(new Map(keyValuePairs));
+  });
+
+});

packages/jest-jasmine2/src/index.js

@@ -68,7 +68,46 @@ function jasmine2(config, environment, moduleLoader, testPath) {
       moduleLoader.requireModule(config.setupTestFrameworkScriptFile);
     }
   });
+
+  const hasIterator = object => !!(object != null && object[Symbol.iterator]);
+  const iterableEquality = (a, b) => {
+    if (
+      typeof a !== 'object' ||
+      typeof b !== 'object' ||
+      Array.isArray(a) ||
+      Array.isArray(b) ||
+      !hasIterator(a) ||
+      !hasIterator(b)
+    ) {
+      return undefined;
+    }
+    if (a.constructor !== b.constructor) {
+      return false;
+    }
+    const bIterator = b[Symbol.iterator]();
+
+    for (const aValue of a) {
+      const nextB = bIterator.next();
+      if (
+        nextB.done ||
+        !jasmine.matchersUtil.equals(
+          aValue,
+          nextB.value,
+          [iterableEquality]
+        )
+      ) {
+        return false;
+      }
+    }
+    if (!bIterator.next().done) {
+      return false;
+    }
+    return true;
+  };
+
   env.beforeEach(() => {
+    jasmine.addCustomEqualityTester(iterableEquality);
+
     jasmine.addMatchers({
       toBeCalled: () => ({
         compare: (actual, expected) => {

packages/jest-util/lib/JasmineFormatter.js

@@ -101,47 +101,76 @@ class JasmineFormatter {
     return ret;
   }
 
-  prettyPrint(obj, indent, cycleWeakMap) {
+  prettyPrint(object, indent, cycleWeakMap) {
     if (!indent) {
       indent = '';
     }
 
-    if (typeof obj === 'object' && obj !== null) {
-      if (this._jasmine.isDomNode(obj)) {
+    if (typeof object === 'object' && object !== null) {
+
+      if (this._jasmine.isDomNode(object)) {
         let attrStr = '';
-        Array.prototype.forEach.call(obj.attributes, attr => {
+        Array.prototype.forEach.call(object.attributes, attr => {
           const attrName = attr.name.trim();
           const attrValue = attr.value.trim();
           attrStr += ' ' + attrName + '="' + attrValue + '"';
         });
         return (
-          'HTMLNode(<' + obj.tagName + attrStr + '>{...}</' + obj.tagName + '>)'
+          `HTMLNode(<${object.tagName + attrStr}>{...}</${object.tagName}>)`
         );
       }
 
       if (!cycleWeakMap) {
         cycleWeakMap = new WeakMap();
       }
 
-      if (cycleWeakMap.get(obj) === true) {
+      if (cycleWeakMap.get(object) === true) {
         return '<circular reference>';
       }
-      cycleWeakMap.set(obj, true);
+      cycleWeakMap.set(object, true);
+
+      const type = Object.prototype.toString.call(object);
+      const output = [];
+      if (type === '[object Map]') {
+        indent = chalk.gray('|') + ' ' + indent;
+        for (const value of object) {
+          output.push(
+            indent + value[0] + ': ' + this.prettyPrint(
+              value[1],
+              indent,
+              cycleWeakMap
+            )
+          );
+        }
+        return `Map {\n${output.join(',')}\n}`;
+      }
+      if (type === '[object Set]') {
+        for (const value of object) {
+          output.push(
+            this.prettyPrint(
+              value,
+              chalk.gray('|') + ' ' + indent,
+              cycleWeakMap
+            )
+          );
+        }
+        return `Set [\n${indent}${output.join(', ')}\n${indent}]`;
+      }
 
-      const orderedKeys = Object.keys(obj).sort();
+      const orderedKeys = Object.keys(object).sort();
       let value;
       const keysOutput = [];
       const keyIndent = chalk.gray('|') + ' ';
       for (let i = 0; i < orderedKeys.length; i++) {
-        value = obj[orderedKeys[i]];
+        value = object[orderedKeys[i]];
         keysOutput.push(
           indent + keyIndent + orderedKeys[i] + ': ' +
           this.prettyPrint(value, indent + keyIndent, cycleWeakMap)
         );
       }
       return '{\n' + keysOutput.join(',\n') + '\n' + indent + '}';
     } else {
-      return this._jasmine.pp(obj);
+      return this._jasmine.pp(object);
     }
   }
 

packages/jest-util/lib/__tests__/JasmineFormatter-test.js

@@ -11,6 +11,7 @@
 
 jest.disableAutomock();
 
+const chalk = require('chalk');
 const jasmine = require('jest-jasmine1/vendor/jasmine-1.3.0').jasmine;
 const jasmine2Require = require('jest-jasmine2/vendor/jasmine-2.4.1.js');
 const jasmine2 = jasmine2Require.core(jasmine2Require);
@@ -24,16 +25,61 @@ let formatter;
 
 describe('JasmineFormatter', () => {
   describe('pretty printer', () => {
+    beforeEach(() => {
+      formatter = new JasmineFormatter(jasmine2);
+    });
+
     it('should handle JSDOM nodes with Jasmine 1.x', () => {
       formatter = new JasmineFormatter(jasmine);
 
       expect(() => formatter.prettyPrint(jsdom(fixture).body)).not.toThrow();
     });
 
     it('should handle JSDOM nodes with Jasmine 2.x', () => {
-      formatter = new JasmineFormatter(jasmine2);
-
       expect(() => formatter.prettyPrint(jsdom(fixture).body)).not.toThrow();
     });
+
+    it('should pretty print Maps', () => {
+      const map = new Map([['foo', {
+        bar: 'baz',
+      }]]);
+
+      const printed = formatter.prettyPrint(map);
+      const expected = 'Map {\n' +
+      '| foo: {\n' +
+      '| | bar: \'baz\'\n' +
+      '| }\n' +
+      '}';
+      expect(printed).toBe(expected.replace(/\|/g, chalk.gray('|')));
+    });
+
+    it('should pretty print Sets', () => {
+      const set = new Set(['a', 'b', 'c']);
+      const printed = formatter.prettyPrint(set);
+      expect(printed).toBe(`Set [\n'a', 'b', 'c'\n]`);
+    });
+
+    it('should pretty print mix of Sets, Maps and plain objects', () => {
+      const map = new Map([['foo', {
+        bar: 'baz',
+        set: new Set(['a', 'b', {
+          foo: 'bar',
+          baz: 'foo',
+        }]),
+      }]]);
+      const printed = formatter.prettyPrint(map);
+      const expected = 'Map {\n' +
+      '| foo: {\n' +
+      '| | bar: \'baz\',\n' +
+      '| | set: Set [\n' +
+      '| | \'a\', \'b\', {\n' +
+      '| | | | baz: \'foo\',\n' +
+      '| | | | foo: \'bar\'\n' +
+      '| | | }\n' +
+      '| | ]\n' +
+      '| }\n' +
+      '}';
+      expect(printed).toBe(expected.replace(/\|/g, chalk.gray('|')));
+    });
   });
 });