jasmine-core 1.3.1 → 2.0.0.rc2

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

@@ -0,0 +1,56 @@
+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 j$.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 j$.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 j$.ExceptionFormatter(),
+        message = exceptionFormatter.message(sampleV8);
+
+      expect(message).toEqual('A Classic Mistake: you got your foo in my bar');
+
+    });
+  });
+
+  describe("#stack", function() {
+    it("formats stack traces from Webkit, Firefox, node.js or IE10+", function() {
+      if (jasmine.getEnv().ieVersion < 10 || jasmine.getEnv().safariVersion < 6) { return; }
+
+      var error;
+      try { throw new Error("an error") } catch(e) { error = e; }
+
+      expect(new j$.ExceptionFormatter().stack(error)).toMatch(/ExceptionFormatterSpec\.js.*\d+/)
+    });
+
+    it("returns null if no Error provided", function() {
+      expect(new j$.ExceptionFormatter().stack()).toBeNull();
+    });
+  });
+});

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

@@ -1,39 +1,14 @@
-describe('Exceptions:', function() {
+xdescribe('Exceptions:', function() {
   var env;
 
   beforeEach(function() {
-    env = new jasmine.Env();
+    env = new j$.Env();
     env.updateInterval = 0;
   });
 
-  it('jasmine.formatException formats Firefox exception messages as expected', function() {
-    var sampleFirefoxException = {
-      fileName: 'foo.js',
-      line: '1978',
-      message: 'you got your foo in my bar',
-      name: 'A Classic Mistake'
-    };
-
-    var expected = 'A Classic Mistake: you got your foo in my bar in foo.js (line 1978)';
-
-    expect(jasmine.util.formatException(sampleFirefoxException)).toEqual(expected);
-  });
-
-  it('jasmine.formatException formats Webkit exception messages as expected', function() {
-    var sampleWebkitException = {
-      sourceURL: 'foo.js',
-      lineNumber: '1978',
-      message: 'you got your foo in my bar',
-      name: 'A Classic Mistake'
-    };
-
-    var expected = 'A Classic Mistake: you got your foo in my bar in foo.js (line 1978)';
-
-    expect(jasmine.util.formatException(sampleWebkitException)).toEqual(expected);
-  });
-
   describe('with break on exception', function() {
     it('should not catch the exception', function() {
+      env.catchExceptions(false);
       var suite = env.describe('suite for break on exceptions', function() {
         env.it('should break when an exception is thrown', function() {
           throw new Error('I should hit a breakpoint!');
@@ -42,16 +17,11 @@ describe('Exceptions:', function() {
       var runner = env.currentRunner();
       var dont_change = 'I will never change!';
 
-      var oldCatch = jasmine.CATCH_EXCEPTIONS;
-      jasmine.CATCH_EXCEPTIONS = false;
       try {
         suite.execute();
         dont_change = 'oops I changed';
       }
       catch (e) {}
-      finally {
-        jasmine.CATCH_EXCEPTIONS = oldCatch;
-      }
 
       expect(dont_change).toEqual('I will never change!');
     });
@@ -59,117 +29,36 @@ describe('Exceptions:', function() {
 
   describe("with catch on exception", function() {
     it('should handle exceptions thrown, but continue', function() {
-      var fakeTimer = new jasmine.FakeTimer();
-      env.setTimeout = fakeTimer.setTimeout;
-      env.clearTimeout = fakeTimer.clearTimeout;
-      env.setInterval = fakeTimer.setInterval;
-      env.clearInterval = fakeTimer.clearInterval;
-
-      //we run two exception tests to make sure we continue after throwing an exception
-      var suite = env.describe('Suite for handles exceptions', function () {
+      var ranSecondTest = false,
+      suite = env.describe('Suite for handles exceptions', function () {
         env.it('should be a test that fails because it throws an exception', function() {
-          throw new Error('fake error 1');
+          throw new Error();
         });
-
-        env.it('should be another test that fails because it throws an exception', function() {
-          this.runs(function () {
-            throw new Error('fake error 2');
-          });
-          this.runs(function () {
-            this.expect(true).toEqual(true);
-          });
-        });
-
-        env.it('should be a passing test that runs after exceptions are thrown', function() {
-          this.expect(true).toEqual(true);
-        });
-
-        env.it('should be another test that fails because it throws an exception after a wait', function() {
-          this.runs(function () {
-            var foo = 'foo';
-          });
-          this.waits(250);
-          this.runs(function () {
-            throw new Error('fake error 3');
-          });
-        });
-
         env.it('should be a passing test that runs after exceptions are thrown from a async test', function() {
-          this.expect(true).toEqual(true);
+          ranSecondTest = true;
         });
       });
 
-      var runner = env.currentRunner();
       suite.execute();
-      fakeTimer.tick(2500);
-
-      var suiteResults = suite.results();
-      var specResults = suiteResults.getItems();
-
-      expect(suiteResults.passed()).toEqual(false);
-      //
-      expect(specResults.length).toEqual(5);
-      expect(specResults[0].passed()).toMatch(false);
-      var blockResults = specResults[0].getItems();
-      expect(blockResults[0].passed()).toEqual(false);
-      expect(blockResults[0].message).toMatch(/fake error 1/);
-
-      expect(specResults[1].passed()).toEqual(false);
-      blockResults = specResults[1].getItems();
-      expect(blockResults[0].passed()).toEqual(false);
-      expect(blockResults[0].message).toMatch(/fake error 2/);
-      expect(blockResults[1].passed()).toEqual(true);
-
-      expect(specResults[2].passed()).toEqual(true);
-
-      expect(specResults[3].passed()).toEqual(false);
-      blockResults = specResults[3].getItems();
-      expect(blockResults[0].message).toMatch(/fake error 3/);
-
-      expect(specResults[4].passed()).toEqual(true);
+      expect(ranSecondTest).toBe(true);
     });
 
     it("should handle exceptions thrown directly in top-level describe blocks and continue", function () {
-      var suite = env.describe("a top level describe block that throws an exception", function () {
+      var ranSecondDescribe = false, suite, suite2, runner = env.currentRunner();
+      suite = 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");
       });
-
-      suite.execute();
-      var suiteResults = suite.results();
-      var specResults = suiteResults.getItems();
-
-      expect(suiteResults.passed()).toEqual(false);
-      expect(specResults.length).toEqual(2);
-
-      expect(specResults[1].description).toMatch(/encountered a declaration exception/);
-    });
-
-    it("should handle exceptions thrown directly in nested describe blocks and continue", function () {
-      var suite = env.describe("a top level describe", function () {
-        env.describe("a mid-level describe that throws an exception", function () {
-          env.it("is a test that should pass", function () {
-            this.expect(true).toEqual(true);
-          });
-
-          throw new Error("a mid-level error");
-        });
+      suite2 = env.describe("a suite that doesn't throw an exception", function () {
+        ranSecondDescribe = true;
       });
 
-      suite.execute();
-      var suiteResults = suite.results();
-      var specResults = suiteResults.getItems();
-
-      expect(suiteResults.passed()).toEqual(false);
-      expect(specResults.length).toEqual(1);
-
-      var nestedSpecResults = specResults[0].getItems();
-
-      expect(nestedSpecResults.length).toEqual(2);
-      expect(nestedSpecResults[1].description).toMatch(/encountered a declaration exception/);
+      runner.execute();
+      expect(ranSecondDescribe).toBe(true);
     });
   });
+
 });

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

@@ -0,0 +1,61 @@
+describe("buildExpectationResult", function() {
+  it("defaults to passed", function() {
+    var result = j$.buildExpectationResult({passed: 'some-value'});
+    expect(result.passed).toBe('some-value');
+  });
+
+  it("message defaults to Passed for passing specs", function() {
+    var result = j$.buildExpectationResult({passed: true, message: 'some-value'});
+    expect(result.message).toBe('Passed.');
+  });
+
+  it("message returns the message for failing expecations", function() {
+    var result = j$.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.callReturn(fakeError.message);
+
+    var result = j$.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.callReturn(fakeError.stack);
+
+    var result = j$.buildExpectationResult(
+      {
+        passed: false,
+        error: fakeError,
+        stackFormatter: stackFormatter
+      });
+
+    expect(stackFormatter).toHaveBeenCalledWith(fakeError);
+    expect(result.stack).toEqual('foo');
+  });
+
+  it("matcherName returns passed matcherName", function() {
+    var result = j$.buildExpectationResult({matcherName: 'some-value'});
+    expect(result.matcherName).toBe('some-value');
+  });
+
+  it("expected returns passed expected", function() {
+    var result = j$.buildExpectationResult({expected: 'some-value'});
+    expect(result.expected).toBe('some-value');
+  });
+
+  it("actual returns passed actual", function() {
+    var result = j$.buildExpectationResult({actual: 'some-value'});
+    expect(result.actual).toBe('some-value');
+  });
+});

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

@@ -0,0 +1,320 @@
+describe("Expectation", function() {
+  it(".addMatchers makes matchers available to any expectation", function() {
+    var matchers = {
+        toFoo: function() {},
+        toBar: function() {}
+      },
+      expectation;
+
+    j$.Expectation.addMatchers(matchers);
+
+    expectation = new j$.Expectation({});
+
+    expect(expectation.toFoo).toBeDefined();
+    expect(expectation.toBar).toBeDefined();
+  });
+
+  it(".addCoreMatchers makes matchers available to any expectation", function() {
+    var coreMatchers = {
+        toQuux: function() {}
+      },
+      expectation;
+
+    j$.Expectation.addCoreMatchers(coreMatchers);
+
+    expectation = new j$.Expectation({});
+
+    expect(expectation.toQuux).toBeDefined();
+  });
+
+  it(".resetMatchers should keep only core matchers", function() {
+    var matchers = {
+        toFoo: function() {}
+      },
+      coreMatchers = {
+        toQuux: function() {}
+      },
+      expectation;
+
+    j$.Expectation.addCoreMatchers(coreMatchers);
+    j$.Expectation.addMatchers(matchers);
+    j$.Expectation.resetMatchers();
+
+    expectation = new j$.Expectation({});
+
+    expect(expectation.toQuux).toBeDefined();
+    expect(expectation.toFoo).toBeUndefined();
+  });
+
+  it("Factory builds an expectaion/negative expectation", function() {
+    var builtExpectation = j$.Expectation.Factory();
+
+    expect(builtExpectation instanceof j$.Expectation).toBe(true);
+    expect(builtExpectation.not instanceof j$.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.callReturn({ compare: fakeCompare }),
+      matchers = {
+        toFoo: matcherFactory
+      },
+      util = {},
+      customEqualityTesters = ['a'],
+      addExpectationResult = jasmine.createSpy("addExpectationResult"),
+      expectation;
+
+    j$.Expectation.addMatchers(matchers);
+
+    expectation = new j$.Expectation({
+      util: util,
+      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.callReturn({pass: true}),
+      matchers = {
+        toFoo: function() {
+          return {
+            compare: fakeCompare
+          };
+        }
+      },
+      util = {
+        buildFailureMessage: jasmine.createSpy('buildFailureMessage')
+      },
+      addExpectationResult = jasmine.createSpy("addExpectationResult"),
+      expectation;
+
+    j$.Expectation.addMatchers(matchers);
+
+    expectation = new j$.Expectation({
+      util: util,
+      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;
+
+    j$.Expectation.addMatchers(matchers);
+
+    expectation = new j$.Expectation({
+      matchers: matchers,
+      util: util,
+      actual: "an actual",
+      addExpectationResult: addExpectationResult
+    });
+
+    expectation.toFoo("hello");
+
+    expect(addExpectationResult).toHaveBeenCalledWith(true, {
+      matcherName: "toFoo",
+      passed: true,
+      message: "",
+      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;
+
+    j$.Expectation.addMatchers(matchers);
+
+    expectation = new j$.Expectation({
+      matchers: 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: ""
+    });
+  });
+
+  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;
+
+    j$.Expectation.addMatchers(matchers);
+
+    expectation = new j$.Expectation({
+      matchers: 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"
+    });
+  });
+
+  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;
+
+    j$.Expectation.addMatchers(matchers);
+
+    expectation = new j$.Expectation({
+      matchers: matchers,
+      actual: "an actual",
+      addExpectationResult: addExpectationResult,
+      isNot: true
+    });
+
+    expectation.toFoo("hello");
+
+    expect(addExpectationResult).toHaveBeenCalledWith(true, {
+      matcherName: "toFoo",
+      passed: true,
+      message: "",
+      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 messge"; }
+      },
+      addExpectationResult = jasmine.createSpy("addExpectationResult"),
+      actual = "an actual",
+      expectation;
+
+    j$.Expectation.addMatchers(matchers);
+
+    expectation = new j$.Expectation({
+      matchers: 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 messge"
+    });
+  });
+
+  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;
+
+    j$.Expectation.addMatchers(matchers);
+
+    expectation = new j$.Expectation({
+      matchers: 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"
+    });
+  });
+});