jasmine-core 3.0.0 → 3.1.0

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

@@ -1,99 +0,0 @@
-describe("toHaveBeenCalledBefore", function() {
-  it("throws an exception when the actual is not a spy", function() {
-    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledBefore(),
-        fn = function() {},
-        secondSpy = new jasmineUnderTest.Env().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 = new jasmineUnderTest.Env().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 = new jasmineUnderTest.Env().createSpy('first spy'),
-        secondSpy = new jasmineUnderTest.Env().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 = new jasmineUnderTest.Env().createSpy('first spy'),
-        secondSpy = new jasmineUnderTest.Env().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 = new jasmineUnderTest.Env().createSpy('first spy'),
-        secondSpy = new jasmineUnderTest.Env().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 = new jasmineUnderTest.Env().createSpy('first spy'),
-        secondSpy = new jasmineUnderTest.Env().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 = new jasmineUnderTest.Env().createSpy('first spy'),
-        secondSpy = new jasmineUnderTest.Env().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 = new jasmineUnderTest.Env().createSpy('first spy'),
-        secondSpy = new jasmineUnderTest.Env().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/toHaveBeenCalledSpec.js

@@ -1,47 +0,0 @@
-describe("toHaveBeenCalled", function() {
-  it("passes when the actual was called, with a custom .not fail message", function() {
-    var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
-      calledSpy = new jasmineUnderTest.Env().createSpy('called-spy'),
-      result;
-
-    calledSpy();
-
-    result = matcher.compare(calledSpy);
-    expect(result.pass).toBe(true);
-    expect(result.message).toEqual("Expected spy called-spy not to have been called.");
-  });
-
-  it("fails when the actual was not called", function() {
-    var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
-      uncalledSpy = new jasmineUnderTest.Env().createSpy('uncalled spy'),
-      result;
-
-    result = matcher.compare(uncalledSpy);
-    expect(result.pass).toBe(false);
-  });
-
-  it("throws an exception when the actual is not a spy", function() {
-    var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
-      fn = function() {};
-
-    expect(function() { matcher.compare(fn) }).toThrowError(Error, /Expected a spy, but got Function./);
-  });
-
-  it("throws an exception when invoked with any arguments", function() {
-    var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
-      spy = new jasmineUnderTest.Env().createSpy('sample spy');
-
-    expect(function() { matcher.compare(spy, 'foo') }).toThrowError(Error, /Does not take arguments, use toHaveBeenCalledWith/);
-  });
-
-  it("has a custom message on failure", function() {
-    var matcher = jasmineUnderTest.matchers.toHaveBeenCalled(),
-      spy = new jasmineUnderTest.Env().createSpy('sample-spy'),
-      result;
-
-    result = matcher.compare(spy);
-
-    expect(result.message).toEqual("Expected spy sample-spy to have been called.");
-  });
-});
-

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

@@ -1,86 +0,0 @@
-describe("toHaveBeenCalledTimes", function() {
-  it("passes when the actual 0 matches the expected 0 ", function () {
-    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-        calledSpy = new jasmineUnderTest.Env().createSpy('called-spy'),
-        result;
-    result = matcher.compare(calledSpy, 0);
-    expect(result.pass).toBeTruthy();
-  });
-  it("passes when the actual matches the expected", function() {
-    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-      calledSpy = new jasmineUnderTest.Env().createSpy('called-spy'),
-      result;
-    calledSpy();
-
-    result = matcher.compare(calledSpy, 1);
-    expect(result.pass).toBe(true);
-  });
-
-  it("fails when expected numbers is not supplied", function(){
-     var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-      spy = new jasmineUnderTest.Env().createSpy('spy'),
-      result;
-
-    spy();
-     expect(function() {
-       matcher.compare(spy);
-     }).toThrowError(/The expected times failed is a required argument and must be a number./);
-  });
-
-  it("fails when the actual was called less than the expected", function() {
-    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-      uncalledSpy = new jasmineUnderTest.Env().createSpy('uncalled spy'),
-      result;
-
-    result = matcher.compare(uncalledSpy, 2);
-    expect(result.pass).toBe(false);
-  });
-
-  it("fails when the actual was called more than expected", function() {
-    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-      uncalledSpy = new jasmineUnderTest.Env().createSpy('uncalled spy'),
-      result;
-
-    uncalledSpy();
-    uncalledSpy();
-
-    result = matcher.compare(uncalledSpy, 1);
-    expect(result.pass).toBe(false);
-  });
-
-  it("throws an exception when the actual is not a spy", function() {
-    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-      fn = function() {};
-
-    expect(function() {
-      matcher.compare(fn);
-    }).toThrowError(/Expected a spy, but got Function./);
-  });
-
-  it("has a custom message on failure that tells it was called only once", function() {
-    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-      spy = new jasmineUnderTest.Env().createSpy('sample-spy'),
-      result;
-    spy();
-    spy();
-    spy();
-    spy();
-
-    result = matcher.compare(spy, 1);
-    expect(result.message).toEqual('Expected spy sample-spy to have been called once. It was called ' +  4 + ' times.');
-  });
-
-  it("has a custom message on failure that tells how many times it was called", function() {
-    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledTimes(),
-      spy = new jasmineUnderTest.Env().createSpy('sample-spy'),
-      result;
-    spy();
-    spy();
-    spy();
-    spy();
-
-    result = matcher.compare(spy, 2);
-    expect(result.message).toEqual('Expected spy sample-spy to have been called 2 times. It was called ' +  4 + ' times.');
-  });
-});
-

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

@@ -1,67 +0,0 @@
-describe("toHaveBeenCalledWith", function() {
-
-  it("passes when the actual was called with matching parameters", function() {
-    var util = {
-          contains: jasmine.createSpy('delegated-contains').and.returnValue(true)
-        },
-        matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(util),
-        calledSpy = new jasmineUnderTest.Env().createSpy('called-spy'),
-        result;
-
-    calledSpy('a', 'b');
-    result = matcher.compare(calledSpy, 'a', 'b');
-
-    expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected spy called-spy not to have been called with [ 'a', 'b' ] but it was.");
-  });
-
-  it("passes through the custom equality testers", function() {
-    var util = {
-          contains: jasmine.createSpy('delegated-contains').and.returnValue(true)
-        },
-        customEqualityTesters = [function() { return true; }],
-        matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(util, customEqualityTesters),
-        calledSpy = new jasmineUnderTest.Env().createSpy('called-spy');
-
-    calledSpy('a', 'b');
-    matcher.compare(calledSpy, 'a', 'b');
-
-    expect(util.contains).toHaveBeenCalledWith([['a', 'b']], ['a', 'b'], customEqualityTesters);
-  });
-
-  it("fails when the actual was not called", function() {
-    var util = {
-          contains: jasmine.createSpy('delegated-contains').and.returnValue(false)
-        },
-        matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(util),
-        uncalledSpy = new jasmineUnderTest.Env().createSpy('uncalled spy'),
-        result;
-
-    result = matcher.compare(uncalledSpy);
-    expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected spy uncalled spy to have been called with [  ] but it was never called.");
-  });
-
-  it("fails when the actual was called with different parameters", function() {
-    var util = {
-          contains: jasmine.createSpy('delegated-contains').and.returnValue(false)
-        },
-        matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(util),
-        calledSpy = new jasmineUnderTest.Env().createSpy('called spy'),
-        result;
-
-    calledSpy('a');
-    calledSpy('c', 'd');
-    result = matcher.compare(calledSpy, 'a', 'b');
-
-    expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected spy called spy to have been called with [ 'a', 'b' ] but actual calls were [ 'a' ], [ 'c', 'd' ].");
-  });
-
-  it("throws an exception when the actual is not a spy", function() {
-    var matcher = jasmineUnderTest.matchers.toHaveBeenCalledWith(),
-        fn = function() {};
-
-    expect(function() { matcher.compare(fn) }).toThrowError(/Expected a spy, but got Function./);
-  });
-});

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

@@ -1,43 +0,0 @@
-describe("toMatch", function() {
-
-  it("passes when RegExps are equivalent", function() {
-    var matcher = jasmineUnderTest.matchers.toMatch(),
-      result;
-
-    result = matcher.compare(/foo/, /foo/);
-    expect(result.pass).toBe(true);
-  });
-
-  it("fails when RegExps are not equivalent", function() {
-    var matcher = jasmineUnderTest.matchers.toMatch(),
-      result;
-
-    result = matcher.compare(/bar/, /foo/);
-    expect(result.pass).toBe(false);
-  });
-
-  it("passes when the actual matches the expected string as a pattern", function() {
-    var matcher = jasmineUnderTest.matchers.toMatch(),
-      result;
-
-    result = matcher.compare('foosball', 'foo');
-    expect(result.pass).toBe(true);
-  });
-
-  it("fails when the actual matches the expected string as a pattern", function() {
-    var matcher = jasmineUnderTest.matchers.toMatch(),
-      result;
-
-    result = matcher.compare('bar', 'foo');
-    expect(result.pass).toBe(false);
-  });
-
-  it("throws an Error when the expected is not a String or RegExp", function() {
-    var matcher = jasmineUnderTest.matchers.toMatch();
-
-    expect(function() {
-      matcher.compare('foo', { bar: 'baz' });
-    }).toThrowError(/Expected is not a String or a RegExp/);
-  });
-});
-

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

@@ -1,315 +0,0 @@
-describe("toThrowError", function() {
-  it("throws an error when the actual is not a function", function() {
-    var matcher = jasmineUnderTest.matchers.toThrowError();
-
-    expect(function() {
-      matcher.compare({});
-    }).toThrowError(/Actual is not a Function/);
-  });
-
-  it("throws an error when the expected is not an Error, string, or RegExp", function() {
-    var matcher = jasmineUnderTest.matchers.toThrowError(),
-      fn = function() {
-        throw new Error("foo");
-      };
-
-    expect(function() {
-      matcher.compare(fn, 1);
-    }).toThrowError(/Expected is not an Error, string, or RegExp./);
-  });
-
-  it("throws an error when the expected error type is not an Error", function() {
-    var matcher = jasmineUnderTest.matchers.toThrowError(),
-      fn = function() {
-        throw new Error("foo");
-      };
-
-    expect(function() {
-      matcher.compare(fn, void 0, "foo");
-    }).toThrowError(/Expected error type is not an Error./);
-  });
-
-  it("throws an error when the expected error message is not a string or RegExp", function() {
-    var matcher = jasmineUnderTest.matchers.toThrowError(),
-      fn = function() {
-        throw new Error("foo");
-      };
-
-    expect(function() {
-      matcher.compare(fn, Error, 1);
-    }).toThrowError(/Expected error message is not a string or RegExp./);
-  });
-
-  it("fails if actual does not throw at all", function() {
-    var matcher = jasmineUnderTest.matchers.toThrowError(),
-      fn = function() {
-        return true;
-      },
-      result;
-
-    result = matcher.compare(fn);
-
-    expect(result.pass).toBe(false);
-    expect(result.message).toEqual("Expected function to throw an Error.");
-  });
-
-  it("fails if thrown is not an instanceof Error", function() {
-    var matcher = jasmineUnderTest.matchers.toThrowError(),
-      fn = function() {
-        throw 4;
-      },
-      result;
-
-    result = matcher.compare(fn);
-    expect(result.pass).toBe(false);
-    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()) {
-        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 {
-        // IE 10 and older
-        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() {
-        throw undefined;
-      },
-      result;
-
-    result = matcher.compare(fn);
-    expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw an Error, but it threw undefined.");
-  });
-
-  it("passes if thrown is a type of Error, but there is no expected error", function() {
-    var matcher = jasmineUnderTest.matchers.toThrowError(),
-      fn = function() {
-        throw new TypeError();
-      },
-      result;
-
-    result = matcher.compare(fn);
-
-    expect(result.pass).toBe(true);
-    expect(result.message).toEqual("Expected function not to throw an Error, but it threw TypeError.");
-  });
-
-  it("passes if thrown is an Error and the expected is the same message", function() {
-    var matcher = jasmineUnderTest.matchers.toThrowError(),
-      fn = function() {
-        throw new Error("foo");
-      },
-      result;
-
-    result = matcher.compare(fn, "foo");
-
-    expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw an exception with message 'foo'.");
-  });
-
-  it("fails if thrown is an Error and the expected is not the same message", function() {
-    var matcher = jasmineUnderTest.matchers.toThrowError(),
-      fn = function() {
-        throw new Error("foo");
-      },
-      result;
-
-    result = matcher.compare(fn, "bar");
-
-    expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw an exception with message 'bar', but it threw an exception with message 'foo'.");
-  });
-
-  it("passes if thrown is an Error and the expected is a RegExp that matches the message", function() {
-    var matcher = jasmineUnderTest.matchers.toThrowError(),
-      fn = function() {
-        throw new Error("a long message");
-      },
-      result;
-
-    result = matcher.compare(fn, /long/);
-
-    expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw an exception with a message matching /long/.");
-  });
-
-  it("fails if thrown is an Error and the expected is a RegExp that does not match the message", function() {
-    var matcher = jasmineUnderTest.matchers.toThrowError(),
-      fn = function() {
-        throw new Error("a long message");
-      },
-      result;
-
-    result = matcher.compare(fn, /foo/);
-
-    expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw an exception with a message matching /foo/, but it threw an exception with message 'a long message'.");
-  });
-
-  it("passes if thrown is an Error and the expected the same Error", function() {
-    var util = {
-        equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
-      },
-      matcher = jasmineUnderTest.matchers.toThrowError(),
-      fn = function() {
-        throw new Error();
-      },
-      result;
-
-    result = matcher.compare(fn, Error);
-
-    expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw Error.");
-  });
-
-  it("passes if thrown is a custom error that takes arguments and the expected is the same error", function() {
-    var util = {
-        equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
-      },
-      matcher = jasmineUnderTest.matchers.toThrowError(),
-      CustomError = function CustomError(arg) { arg.x },
-      fn = function() {
-        throw new CustomError({ x: 1 });
-      },
-      result;
-
-    CustomError.prototype = new Error();
-
-    result = matcher.compare(fn, CustomError);
-
-    expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw CustomError.");
-  });
-
-  it("fails if thrown is an Error and the expected is a different Error", function() {
-    var util = {
-        equals: jasmine.createSpy('delegated-equal').and.returnValue(false)
-      },
-      matcher = jasmineUnderTest.matchers.toThrowError(),
-      fn = function() {
-        throw new Error();
-      },
-      result;
-
-    result = matcher.compare(fn, TypeError);
-
-    expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw TypeError, but it threw Error.");
-  });
-
-  it("passes if thrown is a type of Error and it is equal to the expected Error and message", function() {
-    var util = {
-        equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
-      },
-      matcher = jasmineUnderTest.matchers.toThrowError(),
-      fn = function() {
-        throw new TypeError("foo");
-      },
-      result;
-
-    result = matcher.compare(fn, TypeError, "foo");
-
-    expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw TypeError with message 'foo'.");
-  });
-
-  it("passes if thrown is a custom error that takes arguments and it is equal to the expected custom error and message", function() {
-    var util = {
-        equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
-      },
-      matcher = jasmineUnderTest.matchers.toThrowError(),
-      CustomError = function CustomError(arg) { this.message = arg.message },
-      fn = function() {
-        throw new CustomError({message: "foo"});
-      },
-      result;
-
-    CustomError.prototype = new Error();
-
-    result = matcher.compare(fn, CustomError, "foo");
-
-    expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw CustomError with message 'foo'.");
-  });
-
-  it("fails if thrown is a type of Error and the expected is a different Error", function() {
-    var util = {
-        equals: jasmine.createSpy('delegated-equal').and.returnValue(false)
-      },
-      matcher = jasmineUnderTest.matchers.toThrowError(),
-      fn = function() {
-        throw new TypeError("foo");
-      },
-      result;
-
-    result = matcher.compare(fn, TypeError, "bar");
-
-    expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw TypeError with message 'bar', but it threw TypeError with message 'foo'.");
-  });
-
-  it("passes if thrown is a type of Error and has the same type as the expected Error and the message matches the expected message", function() {
-    var util = {
-        equals: jasmine.createSpy('delegated-equal').and.returnValue(true)
-      },
-      matcher = jasmineUnderTest.matchers.toThrowError(),
-      fn = function() {
-        throw new TypeError("foo");
-      },
-      result;
-
-    result = matcher.compare(fn, TypeError, /foo/);
-
-    expect(result.pass).toBe(true);
-    expect(result.message()).toEqual("Expected function not to throw TypeError with a message matching /foo/.");
-  });
-
-  it("fails if thrown is a type of Error and the expected is a different Error", function() {
-    var util = {
-        equals: jasmine.createSpy('delegated-equal').and.returnValue(false)
-      },
-      matcher = jasmineUnderTest.matchers.toThrowError(),
-      fn = function() {
-        throw new TypeError("foo");
-      },
-      result;
-
-    result = matcher.compare(fn, TypeError, /bar/);
-
-    expect(result.pass).toBe(false);
-    expect(result.message()).toEqual("Expected function to throw TypeError with a message matching /bar/, but it threw TypeError with message 'foo'.");
-  });
-});