jasmine-core 3.0.0 → 3.1.0

data/lib/jasmine-core/spec/core/ExceptionFormatterSpec.js

@@ -1,120 +0,0 @@
-describe("ExceptionFormatter", function() {
-  describe("#message", function() {
-    it('formats Firefox exception messages', function() {
-      var sampleFirefoxException = {
-          fileName: 'foo.js',
-          lineNumber: '1978',
-          message: 'you got your foo in my bar',
-          name: 'A Classic Mistake'
-        },
-        exceptionFormatter = new jasmineUnderTest.ExceptionFormatter(),
-        message = exceptionFormatter.message(sampleFirefoxException);
-
-      expect(message).toEqual('A Classic Mistake: you got your foo in my bar in foo.js (line 1978)');
-    });
-
-    it('formats Webkit exception messages', function() {
-      var sampleWebkitException = {
-          sourceURL: 'foo.js',
-          line: '1978',
-          message: 'you got your foo in my bar',
-          name: 'A Classic Mistake'
-        },
-        exceptionFormatter = new jasmineUnderTest.ExceptionFormatter(),
-        message = exceptionFormatter.message(sampleWebkitException);
-
-      expect(message).toEqual('A Classic Mistake: you got your foo in my bar in foo.js (line 1978)');
-    });
-
-    it('formats V8 exception messages', function() {
-      var sampleV8 = {
-          message: 'you got your foo in my bar',
-          name: 'A Classic Mistake'
-        },
-        exceptionFormatter = new jasmineUnderTest.ExceptionFormatter(),
-        message = exceptionFormatter.message(sampleV8);
-
-      expect(message).toEqual('A Classic Mistake: you got your foo in my bar');
-    });
-
-    it("formats thrown exceptions that aren't errors", function() {
-      var thrown = "crazy error",
-          exceptionFormatter = new jasmineUnderTest.ExceptionFormatter(),
-          message = exceptionFormatter.message(thrown);
-
-      expect(message).toEqual("crazy error thrown");
-    });
-  });
-
-  describe("#stack", function() {
-    it("formats stack traces", function() {
-      var error;
-      try { throw new Error("an error") } catch(e) { error = e; }
-
-      expect(new jasmineUnderTest.ExceptionFormatter().stack(error)).toMatch(/ExceptionFormatterSpec\.js.*\d+/)
-    });
-
-    it("filters Jasmine stack frames from V8 style traces", function() {
-      var error = {
-        stack: 'Error: nope\n' +
-          '    at fn1 (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n' +
-          '    at fn2 (http://localhost:8888/__jasmine__/jasmine.js:4320:20)\n' +
-          '    at fn3 (http://localhost:8888/__jasmine__/jasmine.js:4320:20)\n' +
-          '    at fn4 (http://localhost:8888/__spec__/core/UtilSpec.js:110:19)\n'
-      };
-      var subject = new jasmineUnderTest.ExceptionFormatter({
-        jasmineFile: 'http://localhost:8888/__jasmine__/jasmine.js'
-      });
-      var result = subject.stack(error);
-      expect(result).toEqual('Error: nope\n' +
-          '    at fn1 (http://localhost:8888/__spec__/core/UtilSpec.js:115:19)\n' +
-          '    at <Jasmine>\n' +
-          '    at fn4 (http://localhost:8888/__spec__/core/UtilSpec.js:110:19)'
-      );
-    });
-
-    it("filters Jamine stack frames from Webkit style traces", function() {
-      var error = {
-        stack: 'http://localhost:8888/__spec__/core/UtilSpec.js:115:28\n' +
-          'fn1@http://localhost:8888/__jasmine__/jasmine.js:4320:27\n' +
-          'fn2@http://localhost:8888/__jasmine__/jasmine.js:4320:27\n' +
-          'http://localhost:8888/__spec__/core/UtilSpec.js:115:28'
-      };
-      var subject = new jasmineUnderTest.ExceptionFormatter({
-        jasmineFile: 'http://localhost:8888/__jasmine__/jasmine.js'
-      });
-      var result = subject.stack(error);
-      expect(result).toEqual(
-        'http://localhost:8888/__spec__/core/UtilSpec.js:115:28\n' +
-          '<Jasmine>\n' +
-          'http://localhost:8888/__spec__/core/UtilSpec.js:115:28'
-      );
-    });
-
-    it("filters Jasmine stack frames in this environment", function() {
-      var error, i;
-      try { throw new Error("an error"); } catch(e) { error = e; }
-      var subject = new jasmineUnderTest.ExceptionFormatter({
-        jasmineFile: jasmine.util.jasmineFile()
-      });
-      var result = subject.stack(error);
-      var lines = result.split('\n');
-
-      if (lines[0].match(/an error/)) {
-        lines.shift();
-      }
-
-      expect(lines[0]).toMatch(/ExceptionFormatterSpec.js/);
-      expect(lines[1]).toMatch(/<Jasmine>/);
-
-      // Node has some number of additional frames below Jasmine.
-      for (i = 2; i < lines.length; i++) {
-        expect(lines[i]).not.toMatch(/jasmine.js/);
-      }
-    });
-
-    it("returns null if no Error provided", function() {
-      expect(new jasmineUnderTest.ExceptionFormatter().stack()).toBeNull();
-    });
-  });
-});

data/lib/jasmine-core/spec/core/ExceptionsSpec.js

@@ -1,46 +0,0 @@
-describe('Exceptions:', function() {
-  var env;
-
-  beforeEach(function() {
-    env = new jasmineUnderTest.Env();
-  });
-
-  it('should handle exceptions thrown, but continue', function(done) {
-    var secondTest = jasmine.createSpy('second test');
-    env.describe('Suite for handles exceptions', function () {
-      env.it('should be a test that fails because it throws an exception', function() {
-        throw new Error();
-      });
-      env.it('should be a passing test that runs after exceptions are thrown from a async test', secondTest);
-    });
-
-    var expectations = function() {
-      expect(secondTest).toHaveBeenCalled();
-      done();
-    };
-
-    env.addReporter({ jasmineDone: expectations });
-    env.execute();
-  });
-
-  it("should handle exceptions thrown directly in top-level describe blocks and continue", function(done) {
-    var secondDescribe = jasmine.createSpy("second describe");
-    env.describe("a suite that throws an exception", function () {
-      env.it("is a test that should pass", function () {
-        this.expect(true).toEqual(true);
-      });
-
-      throw new Error("top level error");
-    });
-    env.describe("a suite that doesn't throw an exception", secondDescribe);
-
-    var expectations = function() {
-      expect(secondDescribe).toHaveBeenCalled();
-      done();
-    };
-
-    env.addReporter({ jasmineDone: expectations });
-    env.execute();
-  });
-});
-

data/lib/jasmine-core/spec/core/ExpectationResultSpec.js

@@ -1,61 +0,0 @@
-describe("buildExpectationResult", function() {
-  it("defaults to passed", function() {
-    var result = jasmineUnderTest.buildExpectationResult({passed: 'some-value'});
-    expect(result.passed).toBe('some-value');
-  });
-
-  it("message defaults to Passed for passing specs", function() {
-    var result = jasmineUnderTest.buildExpectationResult({passed: true, message: 'some-value'});
-    expect(result.message).toBe('Passed.');
-  });
-
-  it("message returns the message for failing expectations", function() {
-    var result = jasmineUnderTest.buildExpectationResult({passed: false, message: 'some-value'});
-    expect(result.message).toBe('some-value');
-  });
-
-  it("delegates message formatting to the provided formatter if there was an Error", function() {
-    var fakeError = {message: 'foo'},
-      messageFormatter = jasmine.createSpy("exception message formatter").and.returnValue(fakeError.message);
-
-    var result = jasmineUnderTest.buildExpectationResult(
-      {
-        passed: false,
-        error: fakeError,
-        messageFormatter: messageFormatter
-      });
-
-    expect(messageFormatter).toHaveBeenCalledWith(fakeError);
-    expect(result.message).toEqual('foo');
-  });
-
-  it("delegates stack formatting to the provided formatter if there was an Error", function() {
-    var fakeError = {stack: 'foo'},
-      stackFormatter = jasmine.createSpy("stack formatter").and.returnValue(fakeError.stack);
-
-    var result = jasmineUnderTest.buildExpectationResult(
-      {
-        passed: false,
-        error: fakeError,
-        stackFormatter: stackFormatter
-      });
-
-    expect(stackFormatter).toHaveBeenCalledWith(fakeError);
-    expect(result.stack).toEqual('foo');
-  });
-
-  it("matcherName returns passed matcherName", function() {
-    var result = jasmineUnderTest.buildExpectationResult({matcherName: 'some-value'});
-    expect(result.matcherName).toBe('some-value');
-  });
-
-  it("expected returns passed expected", function() {
-    var result = jasmineUnderTest.buildExpectationResult({expected: 'some-value'});
-    expect(result.expected).toBe('some-value');
-  });
-
-  it("actual returns passed actual", function() {
-    var result = jasmineUnderTest.buildExpectationResult({actual: 'some-value'});
-    expect(result.actual).toBe('some-value');
-  });
-});

data/lib/jasmine-core/spec/core/ExpectationSpec.js

@@ -1,434 +0,0 @@
-describe("Expectation", function() {
-  it("makes custom matchers available to this expectation", function() {
-    var matchers = {
-        toFoo: function() {},
-        toBar: function() {}
-      },
-      expectation;
-
-    expectation = new jasmineUnderTest.Expectation({
-      customMatchers: matchers
-    });
-
-    expect(expectation.toFoo).toBeDefined();
-    expect(expectation.toBar).toBeDefined();
-  });
-
-  it(".addCoreMatchers makes matchers available to any expectation", function() {
-    var coreMatchers = {
-        toQuux: function() {}
-      },
-      expectation;
-
-    jasmineUnderTest.Expectation.addCoreMatchers(coreMatchers);
-
-    expectation = new jasmineUnderTest.Expectation({});
-
-    expect(expectation.toQuux).toBeDefined();
-  });
-
-  it("Factory builds an expectation/negative expectation", function() {
-    var builtExpectation = jasmineUnderTest.Expectation.Factory();
-
-    expect(builtExpectation instanceof jasmineUnderTest.Expectation).toBe(true);
-    expect(builtExpectation.not instanceof jasmineUnderTest.Expectation).toBe(true);
-    expect(builtExpectation.not.isNot).toBe(true);
-  });
-
-  it("wraps matchers's compare functions, passing in matcher dependencies", function() {
-    var fakeCompare = function() { return { pass: true }; },
-      matcherFactory = jasmine.createSpy("matcher").and.returnValue({ compare: fakeCompare }),
-      matchers = {
-        toFoo: matcherFactory
-      },
-      util = {},
-      customEqualityTesters = ['a'],
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      expectation;
-
-    expectation = new jasmineUnderTest.Expectation({
-      util: util,
-      customMatchers: matchers,
-      customEqualityTesters: customEqualityTesters,
-      actual: "an actual",
-      addExpectationResult: addExpectationResult
-    });
-
-    expectation.toFoo("hello");
-
-    expect(matcherFactory).toHaveBeenCalledWith(util, customEqualityTesters)
-  });
-
-  it("wraps matchers's compare functions, passing the actual and expected", function() {
-    var fakeCompare = jasmine.createSpy('fake-compare').and.returnValue({pass: true}),
-      matchers = {
-        toFoo: function() {
-          return {
-            compare: fakeCompare
-          };
-        }
-      },
-      util = {
-        buildFailureMessage: jasmine.createSpy('buildFailureMessage')
-      },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      expectation;
-
-    expectation = new jasmineUnderTest.Expectation({
-      util: util,
-      customMatchers: matchers,
-      actual: "an actual",
-      addExpectationResult: addExpectationResult
-    });
-
-    expectation.toFoo("hello");
-
-    expect(fakeCompare).toHaveBeenCalledWith("an actual", "hello");
-  });
-
-  it("reports a passing result to the spec when the comparison passes", function() {
-    var matchers = {
-        toFoo: function() {
-          return {
-            compare: function() { return { pass: true }; }
-          };
-        }
-      },
-      util = {
-        buildFailureMessage: jasmine.createSpy('buildFailureMessage')
-      },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      expectation;
-
-    expectation = new jasmineUnderTest.Expectation({
-      customMatchers: matchers,
-      util: util,
-      actual: "an actual",
-      addExpectationResult: addExpectationResult
-    });
-
-    expectation.toFoo("hello");
-
-    expect(addExpectationResult).toHaveBeenCalledWith(true, {
-      matcherName: "toFoo",
-      passed: true,
-      message: "",
-      error: undefined,
-      expected: "hello",
-      actual: "an actual"
-    });
-  });
-
-  it("reports a failing result to the spec when the comparison fails", function() {
-    var matchers = {
-        toFoo: function() {
-          return {
-            compare: function() { return { pass: false }; }
-          };
-        }
-      },
-      util = {
-        buildFailureMessage: function() { return ""; }
-      },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      expectation;
-
-    expectation = new jasmineUnderTest.Expectation({
-      customMatchers: matchers,
-      util: util,
-      actual: "an actual",
-      addExpectationResult: addExpectationResult
-    });
-
-    expectation.toFoo("hello");
-
-    expect(addExpectationResult).toHaveBeenCalledWith(false, {
-      matcherName: "toFoo",
-      passed: false,
-      expected: "hello",
-      actual: "an actual",
-      message: "",
-      error: undefined
-    });
-  });
-
-  it("reports a failing result and a custom fail message to the spec when the comparison fails", function() {
-    var matchers = {
-        toFoo: function() {
-          return {
-            compare: function() {
-              return {
-                pass: false,
-                message: "I am a custom message"
-              };
-            }
-          };
-        }
-      },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      expectation;
-
-    expectation = new jasmineUnderTest.Expectation({
-      actual: "an actual",
-      customMatchers: matchers,
-      addExpectationResult: addExpectationResult
-    });
-
-    expectation.toFoo("hello");
-
-    expect(addExpectationResult).toHaveBeenCalledWith(false, {
-      matcherName: "toFoo",
-      passed: false,
-      expected: "hello",
-      actual: "an actual",
-      message: "I am a custom message",
-      error: undefined
-    });
-  });
-
-  it("reports a failing result with a custom fail message function to the spec when the comparison fails", function() {
-    var matchers = {
-        toFoo: function() {
-          return {
-            compare: function() {
-              return {
-                pass: false,
-                message: function() { return "I am a custom message"; }
-              };
-            }
-          };
-        }
-      },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      expectation;
-
-    expectation = new jasmineUnderTest.Expectation({
-      customMatchers: matchers,
-      actual: "an actual",
-      addExpectationResult: addExpectationResult
-    });
-
-    expectation.toFoo("hello");
-
-    expect(addExpectationResult).toHaveBeenCalledWith(false, {
-      matcherName: "toFoo",
-      passed: false,
-      expected: "hello",
-      actual: "an actual",
-      message: "I am a custom message",
-      error: undefined
-    });
-  });
-
-  it("reports a passing result to the spec when the comparison fails for a negative expectation", function() {
-    var matchers = {
-        toFoo: function() {
-          return {
-            compare: function() { return { pass: false }; }
-          };
-        }
-      },
-      util = {
-        buildFailureMessage: function() { return ""; }
-      },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      actual = "an actual",
-      expectation;
-
-    expectation = new jasmineUnderTest.Expectation({
-      customMatchers: matchers,
-      actual: "an actual",
-      addExpectationResult: addExpectationResult,
-      isNot: true
-    });
-
-    expectation.toFoo("hello");
-
-    expect(addExpectationResult).toHaveBeenCalledWith(true, {
-      matcherName: "toFoo",
-      passed: true,
-      message: "",
-      error: undefined,
-      expected: "hello",
-      actual: actual
-    });
-  });
-
-  it("reports a failing result to the spec when the comparison passes for a negative expectation", function() {
-    var matchers = {
-        toFoo: function() {
-          return {
-            compare: function() { return { pass: true }; }
-          };
-        }
-      },
-      util = {
-        buildFailureMessage: function() { return "default message"; }
-      },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      actual = "an actual",
-      expectation;
-
-    expectation = new jasmineUnderTest.Expectation({
-      customMatchers: matchers,
-      actual: "an actual",
-      util: util,
-      addExpectationResult: addExpectationResult,
-      isNot: true
-    });
-
-    expectation.toFoo("hello");
-
-    expect(addExpectationResult).toHaveBeenCalledWith(false, {
-      matcherName: "toFoo",
-      passed: false,
-      expected: "hello",
-      actual: actual,
-      message: "default message",
-      error: undefined
-    });
-  });
-
-  it("reports a failing result and a custom fail message to the spec when the comparison passes for a negative expectation", function() {
-    var matchers = {
-        toFoo: function() {
-          return {
-            compare: function() {
-              return {
-                pass: true,
-                message: "I am a custom message"
-              };
-            }
-          };
-        }
-      },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      actual = "an actual",
-      expectation;
-
-    expectation = new jasmineUnderTest.Expectation({
-      customMatchers: matchers,
-      actual: "an actual",
-      addExpectationResult: addExpectationResult,
-      isNot: true
-    });
-
-    expectation.toFoo("hello");
-
-    expect(addExpectationResult).toHaveBeenCalledWith(false, {
-      matcherName: "toFoo",
-      passed: false,
-      expected: "hello",
-      actual: actual,
-      message: "I am a custom message",
-      error: undefined
-    });
-  });
-
-  it("reports a passing result to the spec when the 'not' comparison passes, given a negativeCompare", function() {
-    var matchers = {
-        toFoo: function() {
-          return {
-            compare: function() { return { pass: true }; },
-            negativeCompare: function() { return { pass: true }; }
-          };
-        }
-      },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      actual = "an actual",
-      expectation;
-
-    expectation = new jasmineUnderTest.Expectation({
-      customMatchers: matchers,
-      actual: "an actual",
-      addExpectationResult: addExpectationResult,
-      isNot: true
-    });
-
-    expectation.toFoo("hello");
-
-    expect(addExpectationResult).toHaveBeenCalledWith(true, {
-      matcherName: "toFoo",
-      passed: true,
-      expected: "hello",
-      actual: actual,
-      message: "",
-      error: undefined
-    });
-  });
-
-  it("reports a failing result and a custom fail message to the spec when the 'not' comparison fails, given a negativeCompare", function() {
-    var matchers = {
-        toFoo: function() {
-          return {
-            compare: function() { return { pass: true }; },
-            negativeCompare: function() {
-              return {
-                pass: false,
-                message: "I'm a custom message"
-              };
-            }
-          };
-        }
-      },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      actual = "an actual",
-      expectation;
-
-    expectation = new jasmineUnderTest.Expectation({
-      customMatchers: matchers,
-      actual: "an actual",
-      addExpectationResult: addExpectationResult,
-      isNot: true
-    });
-
-    expectation.toFoo("hello");
-
-    expect(addExpectationResult).toHaveBeenCalledWith(false, {
-      matcherName: "toFoo",
-      passed: false,
-      expected: "hello",
-      actual: actual,
-      message: "I'm a custom message",
-      error: undefined
-    });
-  });
-  
-  it("reports a custom error message to the spec", function() {
-    var customError = new Error("I am a custom error");
-    var matchers = {
-        toFoo: function() {
-          return {
-            compare: function() {
-              return {
-                pass: false,
-                message: "I am a custom message",
-                error: customError
-              };
-            }
-          };
-        }
-      },
-      addExpectationResult = jasmine.createSpy("addExpectationResult"),
-      expectation;
-
-    expectation = new jasmineUnderTest.Expectation({
-      actual: "an actual",
-      customMatchers: matchers,
-      addExpectationResult: addExpectationResult
-    });
-
-    expectation.toFoo("hello");
-
-    expect(addExpectationResult).toHaveBeenCalledWith(false, {
-      matcherName: "toFoo",
-      passed: false,
-      expected: "hello",
-      actual: "an actual",
-      message: "I am a custom message",
-      error: customError
-    });
-  });
-
-});
-