jasmine-core 2.5.2 → 2.6.0

data/lib/jasmine-core/spec/core/matchers/toEqualSpec.js

@@ -1,20 +1,39 @@
 describe("toEqual", function() {
+  "use strict";
+
+  function compareEquals(actual, expected) {
+    var util = jasmineUnderTest.matchersUtil,
+      matcher = jasmineUnderTest.matchers.toEqual(util);
+
+    var result = matcher.compare(actual, expected);
+
+    return result;
+  }
+
   it("delegates to equals function", function() {
     var util = {
-        equals: jasmine.createSpy('delegated-equals').and.returnValue(true)
+        equals: jasmine.createSpy('delegated-equals').and.returnValue(true),
+        buildFailureMessage: function() {
+          return 'does not matter'
+        },
+        DiffBuilder: jasmineUnderTest.matchersUtil.DiffBuilder
       },
       matcher = jasmineUnderTest.matchers.toEqual(util),
       result;
 
     result = matcher.compare(1, 1);
 
-    expect(util.equals).toHaveBeenCalledWith(1, 1, []);
+    expect(util.equals).toHaveBeenCalledWith(1, 1, [], jasmine.anything());
     expect(result.pass).toBe(true);
   });
 
   it("delegates custom equality testers, if present", function() {
     var util = {
-        equals: jasmine.createSpy('delegated-equals').and.returnValue(true)
+        equals: jasmine.createSpy('delegated-equals').and.returnValue(true),
+        buildFailureMessage: function() {
+          return 'does not matter'
+        },
+        DiffBuilder: jasmineUnderTest.matchersUtil.DiffBuilder
       },
       customEqualityTesters = ['a', 'b'],
       matcher = jasmineUnderTest.matchers.toEqual(util, customEqualityTesters),
@@ -22,7 +41,476 @@ describe("toEqual", function() {
 
     result = matcher.compare(1, 1);
 
-    expect(util.equals).toHaveBeenCalledWith(1, 1, ['a', 'b']);
+    expect(util.equals).toHaveBeenCalledWith(1, 1, ['a', 'b'], jasmine.anything());
     expect(result.pass).toBe(true);
   });
+
+  it("reports the difference between objects that are not equal", function() {
+    var actual = {x: 1, y: 3},
+      expected = {x: 2, y: 3},
+      message = "Expected $.x = 1 to equal 2.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports the difference between nested objects that are not equal", function() {
+    var actual = {x: {y: 1}},
+      expected = {x: {y: 2}},
+      message = "Expected $.x.y = 1 to equal 2.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("formats property access so that it's valid JavaScript", function() {
+    var actual = {'my prop': 1},
+      expected = {'my prop': 2},
+      message = "Expected $['my prop'] = 1 to equal 2.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports missing properties", function() {
+    var actual = {x: {}},
+      expected = {x: {y: 1}},
+      message =
+        "Expected $.x to have properties\n" +
+        "    y: 1";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports extra properties", function() {
+    var actual = {x: {y: 1, z: 2}},
+      expected = {x: {}},
+      message =
+        "Expected $.x not to have properties\n" +
+        "    y: 1\n" +
+        "    z: 2";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("pretty-prints properties", function() {
+    var actual = {x: {y: 'foo bar'}},
+      expected = {x: {}},
+      message =
+        "Expected $.x not to have properties\n" +
+        "    y: 'foo bar'"
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports extra and missing properties together", function() {
+    var actual = {x: {y: 1, z: 2, f: 4}},
+      expected = {x: {y: 1, z: 2, g: 3}},
+      message =
+        "Expected $.x to have properties\n" +
+        "    g: 3\n" +
+        "Expected $.x not to have properties\n" +
+        "    f: 4";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports extra and missing properties of the root-level object", function() {
+    var actual = {x: 1},
+      expected = {a: 1},
+      message =
+        "Expected object to have properties\n" +
+        "    a: 1\n" +
+        "Expected object not to have properties\n" +
+        "    x: 1";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports multiple incorrect values", function() {
+    var actual = {x: 1, y: 2},
+      expected = {x: 3, y: 4},
+      message =
+        "Expected $.x = 1 to equal 3.\n" +
+        "Expected $.y = 2 to equal 4.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatch between actual child object and expected child number", function() {
+    var actual = {x: {y: 2}},
+      expected = {x: 1},
+      message = "Expected $.x = Object({ y: 2 }) to equal 1.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("uses the default failure message if actual is not an object", function() {
+    var actual = 1,
+      expected = {x: {}},
+      message = "Expected 1 to equal Object({ x: Object({  }) }).";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("uses the default failure message if expected is not an object", function() {
+    var actual = {x: {}},
+      expected = 1,
+      message = "Expected Object({ x: Object({  }) }) to equal 1.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("uses the default failure message given arrays with different lengths", function() {
+    var actual = [1, 2],
+      expected = [1, 2, 3],
+      message =
+        "Expected [ 1, 2 ] to equal [ 1, 2, 3 ].";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports a mismatch between elements of equal-length arrays", function() {
+    var actual = [1, 2, 5],
+      expected = [1, 2, 3],
+      message = "Expected $[2] = 5 to equal 3.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports a mismatch between multiple array elements", function() {
+    var actual = [2, 2, 5],
+      expected = [1, 2, 3],
+      message =
+        "Expected $[0] = 2 to equal 1.\n" +
+        "Expected $[2] = 5 to equal 3.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports a mismatch between properties of objects in arrays", function() {
+    var actual = [{x: 1}],
+      expected = [{x: 2}],
+      message = "Expected $[0].x = 1 to equal 2.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports a mismatch between arrays in objects", function() {
+    var actual = {x: [1]},
+      expected = {x: [2]},
+      message =
+        "Expected $.x[0] = 1 to equal 2.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches between nested arrays", function() {
+    var actual = [[1]],
+      expected = [[2]],
+      message =
+        "Expected $[0][0] = 1 to equal 2.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches involving NaN", function() {
+    var actual = {x: 0},
+      expected = {x: 0/0},
+      message = "Expected $.x = 0 to equal NaN.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches involving regular expressions", function() {
+    var actual = {x: '1'},
+      expected = {x: /1/},
+      message = "Expected $.x = '1' to equal /1/.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches involving infinities", function() {
+    var actual = {x: 0},
+      expected = {x: 1/0},
+      message = "Expected $.x = 0 to equal Infinity.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches involving booleans", function() {
+    var actual = {x: false},
+      expected = {x: true},
+      message = "Expected $.x = false to equal true.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches involving strings", function() {
+    var actual = {x: 'foo'},
+      expected = {x: 'bar'},
+      message = "Expected $.x = 'foo' to equal 'bar'.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches involving undefined", function() {
+    var actual = {x: void 0},
+      expected = {x: 0},
+      message = "Expected $.x = undefined to equal 0.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches involving null", function() {
+    var actual = {x: null},
+      expected = {x: 0},
+      message = "Expected $.x = null to equal 0.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches between objects with different constructors", function () {
+    function Foo() {}
+    function Bar() {}
+
+    var actual = {x: new Foo()},
+        expected = {x: new Bar()},
+        message = "Expected $.x to be a kind of Bar, but was Foo({  }).";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports type mismatches at the root level", function () {
+    function Foo() {}
+    function Bar() {}
+
+    var actual = new Foo(),
+      expected = new Bar(),
+      message = "Expected object to be a kind of Bar, but was Foo({  }).";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  function constructorIsNotEnumerable() {
+    // in IE8, the constructor property is not enumerable, even if it is an
+    // own property of the object.
+    // Objects that differ only by an own `constructor` property are thus
+    // considered equal in IE8.
+    for (var key in {constructor: 1}) {
+      return false;
+    }
+    return true;
+  }
+
+  it("reports mismatches between objects with their own constructor property", function () {
+    if (constructorIsNotEnumerable()) {
+      return;
+    }
+
+    function Foo() {}
+    function Bar() {}
+
+    var actual = {x: {constructor: 'blerf'}},
+        expected = {x: {constructor: 'ftarrh'}},
+        message = "Expected $.x.constructor = 'blerf' to equal 'ftarrh'.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches between an object with a real constructor and one with its own constructor property", function () {
+    if (constructorIsNotEnumerable()) {
+      return;
+    }
+
+    function Foo() {}
+    function Bar() {}
+
+    var actual = {x: {}},
+      expected = {x: {constructor: 'ftarrh'}},
+      message =
+        "Expected $.x to have properties\n" +
+        "    constructor: 'ftarrh'";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+    expect(compareEquals(expected, actual).message).toEqual(
+      "Expected $.x not to have properties\n    constructor: 'ftarrh'"
+    );
+  });
+
+  it("reports mismatches between 0 and -0", function() {
+    var actual = {x: 0},
+      expected = {x: -0},
+      message = "Expected $.x = 0 to equal -0.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches between Errors", function() {
+    var actual = {x: new Error("the error you got")},
+      expected = {x: new Error("the error you want")},
+      message = "Expected $.x = Error: the error you got to equal Error: the error you want.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches between Functions", function() {
+    var actual = {x: function() {}},
+      expected = {x: function() {}},
+      message = "Expected $.x = Function to equal Function.";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("does not report deep mismatches within Sets", function() {
+    // TODO: implement deep comparison of set elements
+    jasmine.getEnv().requireFunctioningSets();
+
+    var actual = new Set([1]),
+      expected = new Set([2]),
+      message = 'Expected Set( 1 ) to equal Set( 2 ).';
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches between Sets nested in objects", function() {
+    jasmine.getEnv().requireFunctioningSets();
+
+    var actual = {sets: [new Set([1])]},
+      expected = {sets: [new Set([2])]},
+      message = "Expected $.sets[0] = Set( 1 ) to equal Set( 2 ).";
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports mismatches between Sets of different lengths", function() {
+    jasmine.getEnv().requireFunctioningSets();
+
+    var actual = new Set([1, 2]),
+      expected = new Set([2]),
+      message = 'Expected Set( 1, 2 ) to equal Set( 2 ).';
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  function isNotRunningInBrowser() {
+    return typeof document === 'undefined'
+  }
+
+  it("reports mismatches between DOM nodes with different tags", function() {
+    if(isNotRunningInBrowser()) {
+      return;
+    }
+
+    var actual = {a: document.createElement('div')},
+      expected = {a: document.createElement('p')},
+      message = 'Expected $.a = HTMLNode to equal HTMLNode.';
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it('reports mismatches between DOM nodes with different content', function() {
+    if(isNotRunningInBrowser()) {
+      return;
+    }
+
+    var nodeA = document.createElement('div'),
+      nodeB = document.createElement('div');
+
+    nodeA.innerText = 'foo'
+    nodeB.innerText = 'bar'
+
+    var actual = {a: nodeA},
+      expected = {a: nodeB},
+      message = 'Expected $.a = HTMLNode to equal HTMLNode.';
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  })
+
+  it("reports mismatches between a DOM node and a bare Object", function() {
+    if(isNotRunningInBrowser()) {
+      return;
+    }
+
+    var actual = {a: document.createElement('div')},
+      expected = {a: {}},
+      message = 'Expected $.a = HTMLNode to equal Object({  }).';
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  });
+
+  it("reports asymmetric mismatches", function() {
+    var actual = {a: 1},
+      expected = {a: jasmineUnderTest.any(String)},
+      message = 'Expected $.a = 1 to equal <jasmine.any(String)>.';
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+    expect(compareEquals(actual, expected).pass).toBe(false)
+  });
+
+  it("reports asymmetric mismatches when the asymmetric comparand is the actual value", function() {
+    var actual = {a: jasmineUnderTest.any(String)},
+      expected = {a: 1},
+      message = 'Expected $.a = <jasmine.any(String)> to equal 1.';
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+    expect(compareEquals(actual, expected).pass).toBe(false)
+  });
+
+  it("does not report a mismatch when asymmetric matchers are satisfied", function() {
+    var actual = {a: 'a'},
+      expected = {a: jasmineUnderTest.any(String)},
+      message = 'Expected $.a = 1 to equal <jasmine.any(String)>.';
+
+    expect(compareEquals(actual, expected).pass).toBe(true)
+  });
+
+  it("works on big complex stuff", function() {
+    var actual = {
+      foo: [
+        {bar: 1, things: ['a', 'b']},
+        {bar: 2, things: ['a', 'b']}
+      ],
+      baz: [
+        {a: {b: 1}}
+      ],
+      quux: 1,
+      nan: 0,
+      aRegexp: 'hi',
+      inf: -1/0,
+      boolean: false,
+      notDefined: 0,
+      aNull: void 0
+    }
+
+    var expected = {
+      foo: [
+        {bar: 2, things: ['a', 'b', 'c']},
+        {bar: 2, things: ['a', 'd']}
+      ],
+      baz: [
+        {a: {b: 1, c: 1}}
+      ],
+      quux: [],
+      nan: 0/0,
+      aRegexp: /hi/,
+      inf: 1/0,
+      boolean: true,
+      notDefined: void 0,
+      aNull: null
+    }
+
+    var message =
+      'Expected $.foo[0].bar = 1 to equal 2.\n' +
+      "Expected $.foo[0].things = [ 'a', 'b' ] to equal [ 'a', 'b', 'c' ].\n" +
+      "Expected $.foo[1].things[1] = 'b' to equal 'd'.\n" +
+      'Expected $.baz[0].a to have properties\n' +
+      '    c: 1\n' +
+      'Expected $.quux = 1 to equal [  ].\n' +
+      'Expected $.nan = 0 to equal NaN.\n' +
+      "Expected $.aRegexp = 'hi' to equal /hi/.\n" +
+      'Expected $.inf = -Infinity to equal Infinity.\n' +
+      'Expected $.boolean = false to equal true.\n' +
+      'Expected $.notDefined = 0 to equal undefined.\n' +
+      'Expected $.aNull = undefined to equal null.'
+
+    expect(compareEquals(actual, expected).message).toEqual(message);
+  })
 });

data/lib/jasmine-core/spec/core/matchers/toHaveBeenCalledBeforeSpec.js

@@ -0,0 +1,99 @@
+describe("toHaveBeenCalledBefore", function() {
+  it("throws an exception when the actual is not a spy", function() {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
+        fn = function() {},
+        secondSpy = jasmineUnderTest.createSpy('second spy');
+
+    expect(function() { matcher.compare(fn, secondSpy) }).toThrowError(Error, /Expected a spy, but got Function./);
+  });
+
+  it("throws an exception when the expected is not a spy", function() {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
+        firstSpy = jasmineUnderTest.createSpy('first spy'),
+        fn = function() {};
+
+    expect(function() { matcher.compare(firstSpy, fn) }).toThrowError(Error, /Expected a spy, but got Function./);
+  });
+
+  it("fails when the actual was not called", function() {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
+        firstSpy = jasmineUnderTest.createSpy('first spy'),
+        secondSpy = jasmineUnderTest.createSpy('second spy');
+
+    secondSpy();
+
+    result = matcher.compare(firstSpy, secondSpy);
+    expect(result.pass).toBe(false);
+    expect(result.message).toMatch(/Expected spy first spy to have been called./);
+  });
+
+  it("fails when the expected was not called", function() {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
+        firstSpy = jasmineUnderTest.createSpy('first spy'),
+        secondSpy = jasmineUnderTest.createSpy('second spy');
+
+    firstSpy();
+
+    result = matcher.compare(firstSpy, secondSpy);
+    expect(result.pass).toBe(false);
+    expect(result.message).toMatch(/Expected spy second spy to have been called./);
+  });
+
+  it("fails when the actual is called after the expected", function() {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
+        firstSpy = jasmineUnderTest.createSpy('first spy'),
+        secondSpy = jasmineUnderTest.createSpy('second spy'),
+        result;
+
+    secondSpy();
+    firstSpy();
+
+    result = matcher.compare(firstSpy, secondSpy);
+    expect(result.pass).toBe(false);
+    expect(result.message).toEqual('Expected spy first spy to have been called before spy second spy');
+  });
+
+	it("fails when the actual is called before and after the expected", function() {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
+        firstSpy = jasmineUnderTest.createSpy('first spy'),
+        secondSpy = jasmineUnderTest.createSpy('second spy'),
+        result;
+
+    firstSpy();
+    secondSpy();
+    firstSpy();
+
+    result = matcher.compare(firstSpy, secondSpy);
+    expect(result.pass).toBe(false);
+    expect(result.message).toEqual('Expected latest call to spy first spy to have been called before first call to spy second spy (no interleaved calls)');
+  });
+
+	it("fails when the expected is called before and after the actual", function() {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
+        firstSpy = jasmineUnderTest.createSpy('first spy'),
+        secondSpy = jasmineUnderTest.createSpy('second spy'),
+        result;
+
+    secondSpy();
+    firstSpy();
+    secondSpy();
+
+    result = matcher.compare(firstSpy, secondSpy);
+    expect(result.pass).toBe(false);
+    expect(result.message).toEqual('Expected first call to spy second spy to have been called after latest call to spy first spy (no interleaved calls)');
+  });
+
+  it("passes when the actual is called before the expected", function() {
+    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
+        firstSpy = jasmineUnderTest.createSpy('first spy'),
+        secondSpy = jasmineUnderTest.createSpy('second spy'),
+        result;
+
+    firstSpy();
+    secondSpy();
+
+    result = matcher.compare(firstSpy, secondSpy);
+    expect(result.pass).toBe(true);
+    expect(result.message).toEqual('Expected spy first spy to not have been called before spy second spy, but it was');
+  });
+});

data/lib/jasmine-core/spec/core/matchers/toThrowErrorSpec.js

@@ -65,6 +65,43 @@ describe("toThrowError", function() {
     expect(result.message()).toEqual("Expected function to throw an Error, but it threw 4.");
   });
 
+  describe("when error is from another frame", function() {
+    function isNotRunningInBrowser() {
+      return typeof document === 'undefined'
+    }
+
+    var iframe = null;
+
+    afterEach(function() {
+      if (iframe !== null) {
+        document.body.removeChild(iframe);
+      }
+    });
+
+    it("passes if thrown is an instanceof Error regardless of global that contains its constructor", function() {
+      if (isNotRunningInBrowser() || jasmine.getEnv().phantomVersion < 2 || jasmine.getEnv().ieVersion < 10) {
+        return;
+      }
+
+      var matcher = jasmineUnderTest.matchers.toThrowError();
+      iframe = document.body.appendChild(document.createElement("iframe"));
+      iframe.src = "about:blank";
+      var iframeDocument = iframe.contentWindow.document;
+
+      if (iframeDocument.body) {
+        iframeDocument.body.appendChild(iframeDocument.createElement("script"))
+        .textContent = "function method() { throw new Error('foo'); }";
+      } else {
+        // older IE
+        iframeDocument.write("<html><head><script>function method() { throw new Error('foo'); }</script></head></html>");
+      }
+
+      var result = matcher.compare(iframe.contentWindow.method);
+      expect(result.pass).toBe(true);
+      expect(result.message).toEqual("Expected function not to throw an Error, but it threw Error.");
+    });
+  });
+
   it("fails with the correct message if thrown is a falsy value", function() {
     var matcher = jasmineUnderTest.matchers.toThrowError(),
       fn = function() {

data/lib/jasmine-core/spec/helpers/BrowserFlags.js

@@ -20,4 +20,8 @@
     return /Firefox\/([0-9]{0,})/.exec(userAgent);
   });
 
+  env.phantomVersion = browserVersion(function(userAgent) {
+    return /PhantomJS\/([0-9]{0,})/.exec(userAgent);
+  });
+
 })(jasmine.getEnv());

data/lib/jasmine-core/spec/helpers/checkForSet.js

@@ -0,0 +1,21 @@
+(function(env) {
+  function hasFunctioningSets() {
+    if (typeof Set === 'undefined') { return false; }
+
+    try {
+      var s = new Set([4]);
+      if (s.size !== 1) { return false; }
+      if (s.values().next().value !== 4) { return false; }
+      return true;
+    } catch(e) {
+      return false;
+    }
+  }
+
+  env.requireFunctioningSets = function() {
+    if (!hasFunctioningSets()) {
+      env.pending("Browser has incomplete or missing support for Sets");
+    }
+  };
+
+})(jasmine.getEnv());