jasmine-core 2.0.0 → 2.1.0

data/lib/jasmine-core/spec/core/integration/SpecRunningSpec.js

@@ -159,7 +159,7 @@ describe("jasmine spec running", function () {
       ];
       expect(actions).toEqual(expected);
       done();
-    }
+    };
 
     env.addReporter({jasmineDone: assertions});
 
@@ -228,6 +228,257 @@ describe("jasmine spec running", function () {
     env.execute();
   });
 
+  it('should run beforeAlls before beforeEachs and afterAlls after afterEachs', function() {
+    var actions = [];
+
+    env.beforeAll(function() {
+      actions.push('runner beforeAll');
+    });
+
+    env.afterAll(function() {
+      actions.push('runner afterAll');
+    });
+
+    env.beforeEach(function () {
+      actions.push('runner beforeEach');
+    });
+
+    env.afterEach(function () {
+      actions.push('runner afterEach');
+    });
+
+    env.describe('Something', function() {
+      env.beforeEach(function() {
+        actions.push('inner beforeEach');
+      });
+
+      env.afterEach(function() {
+        actions.push('inner afterEach');
+      });
+
+      env.beforeAll(function() {
+        actions.push('inner beforeAll');
+      });
+
+      env.afterAll(function() {
+        actions.push('inner afterAll');
+      });
+
+      env.it('does something or other', function() {
+        actions.push('it');
+      });
+    });
+
+    var assertions = function() {
+      var expected = [
+        "runner beforeAll",
+        "inner beforeAll",
+        "runner beforeEach",
+        "inner beforeEach",
+        "it",
+        "inner afterEach",
+        "runner afterEach",
+        "inner afterAll",
+        "runner afterAll"
+      ];
+      expect(actions).toEqual(expected);
+      done();
+    };
+
+    env.addReporter({jasmineDone: assertions});
+    env.execute();
+  });
+
+  it('should run beforeAlls and afterAlls as beforeEachs and afterEachs in the order declared when runnablesToRun is provided', function() {
+    var actions = [],
+      spec,
+      spec2;
+
+    env.beforeAll(function() {
+      actions.push('runner beforeAll');
+    });
+
+    env.afterAll(function() {
+      actions.push('runner afterAll');
+    });
+
+    env.beforeEach(function () {
+      actions.push('runner beforeEach');
+    });
+
+    env.afterEach(function () {
+      actions.push('runner afterEach');
+    });
+
+    env.describe('Something', function() {
+      env.beforeEach(function() {
+        actions.push('inner beforeEach');
+      });
+
+      env.afterEach(function() {
+        actions.push('inner afterEach');
+      });
+
+      env.beforeAll(function() {
+        actions.push('inner beforeAll');
+      });
+
+      env.afterAll(function() {
+        actions.push('inner afterAll');
+      });
+
+      spec = env.it('does something', function() {
+        actions.push('it');
+      });
+
+      spec2 = env.it('does something or other', function() {
+        actions.push('it2');
+      });
+    });
+
+    var assertions = function() {
+      var expected = [
+        "runner beforeAll",
+        "inner beforeAll",
+        "runner beforeEach",
+        "inner beforeEach",
+        "it",
+        "inner afterEach",
+        "runner afterEach",
+        "inner afterAll",
+        "runner afterAll",
+
+        "runner beforeAll",
+        "inner beforeAll",
+        "runner beforeEach",
+        "inner beforeEach",
+        "it2",
+        "inner afterEach",
+        "runner afterEach",
+        "inner afterAll",
+        "runner afterAll"
+      ];
+      expect(actions).toEqual(expected);
+      done();
+    };
+
+    env.addReporter({jasmineDone: assertions});
+    env.execute([spec.id, spec2.id]);
+  });
+
+  describe('focused runnables', function() {
+    it('runs the relevant alls and eachs for each runnable', function(done) {
+      var actions = [];
+      env.beforeAll(function() {actions.push('beforeAll')});
+      env.afterAll(function() {actions.push('afterAll')});
+      env.beforeEach(function() {actions.push('beforeEach')});
+      env.afterEach(function() {actions.push('afterEach')});
+
+      env.fdescribe('a focused suite', function() {
+        env.it('is run', function() {
+          actions.push('spec in fdescribe')
+        });
+      });
+
+      env.describe('an unfocused suite', function() {
+        env.fit('has a focused spec', function() {
+          actions.push('focused spec')
+        });
+      });
+
+      var assertions = function() {
+        var expected = [
+          'beforeAll',
+          'beforeEach',
+          'spec in fdescribe',
+          'afterEach',
+          'afterAll',
+
+          'beforeAll',
+          'beforeEach',
+          'focused spec',
+          'afterEach',
+          'afterAll'
+        ];
+        expect(actions).toEqual(expected);
+        done();
+      };
+
+      env.addReporter({jasmineDone: assertions});
+      env.execute();
+    });
+
+    it('focused specs in focused suites cause non-focused siblings to not run', function(done){
+      var actions = [];
+
+      env.fdescribe('focused suite', function() {
+        env.it('unfocused spec', function() {
+          actions.push('unfocused spec')
+        });
+        env.fit('focused spec', function() {
+          actions.push('focused spec')
+        });
+      });
+
+      var assertions = function() {
+        var expected = ['focused spec'];
+        expect(actions).toEqual(expected);
+        done();
+      };
+
+      env.addReporter({jasmineDone: assertions});
+      env.execute();
+    });
+
+    it('focused suites in focused suites cause non-focused siblings to not run', function(done){
+      var actions = [];
+
+      env.fdescribe('focused suite', function() {
+        env.it('unfocused spec', function() {
+          actions.push('unfocused spec')
+        });
+        env.fdescribe('inner focused suite', function() {
+          env.it('inner spec', function() {
+            actions.push('inner spec');
+          });
+        });
+      });
+
+      var assertions = function() {
+        var expected = ['inner spec'];
+        expect(actions).toEqual(expected);
+        done();
+      };
+
+      env.addReporter({jasmineDone: assertions});
+      env.execute();
+    });
+
+    it('focused runnables unfocus ancestor focused suites', function() {
+      var actions = [];
+
+      env.fdescribe('focused suite', function() {
+        env.it('unfocused spec', function() {
+          actions.push('unfocused spec')
+        });
+        env.describe('inner focused suite', function() {
+          env.fit('focused spec', function() {
+            actions.push('focused spec');
+          });
+        });
+      });
+
+      var assertions = function() {
+        var expected = ['focused spec'];
+        expect(actions).toEqual(expected);
+        done();
+      };
+
+      env.addReporter({jasmineDone: assertions});
+      env.execute();
+    });
+  });
+
   it("shouldn't run disabled suites", function(done) {
     var specInADisabledSuite = jasmine.createSpy("specInADisabledSuite"),
     suite = env.describe('A Suite', function() {
@@ -236,10 +487,36 @@ describe("jasmine spec running", function () {
       });
     });
 
-    suite.execute(function() {
+    var assertions = function() {
       expect(specInADisabledSuite).not.toHaveBeenCalled();
       done();
+    };
+
+    env.addReporter({jasmineDone: assertions});
+
+    env.execute();
+  });
+
+  it("should allow top level suites to be disabled", function() {
+    var specInADisabledSuite = jasmine.createSpy("specInADisabledSuite"),
+      otherSpec = jasmine.createSpy("otherSpec");
+
+    env.xdescribe('A disabled suite', function() {
+      env.it('spec inside a disabled suite', specInADisabledSuite);
+    });
+    env.describe('Another suite', function() {
+      env.it('another spec', otherSpec);
     });
+
+    var assertions = function() {
+      expect(specInADisabledSuite).not.toHaveBeenCalled();
+      expect(otherSpec).toHaveBeenCalled();
+      done();
+    };
+
+    env.addReporter({jasmineDone: assertions});
+
+    env.execute();
   });
 
   it("should set all pending specs to pending when a suite is run", function(done) {
@@ -254,7 +531,6 @@ describe("jasmine spec running", function () {
     });
   });
 
-
   // TODO: is this useful? It doesn't catch syntax errors
   xit("should recover gracefully when there are errors in describe functions", function() {
     var specs = [];

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

@@ -174,7 +174,7 @@ describe("matchersUtil", function() {
 
   describe("contains", function() {
     it("passes when expected is a substring of actual", function() {
-      expect(j$.matchersUtil.contains("ABC", "B")).toBe(true);
+      expect(j$.matchersUtil.contains("ABC", "BC")).toBe(true);
     });
 
     it("fails when expected is a not substring of actual", function() {
@@ -199,6 +199,23 @@ describe("matchersUtil", function() {
 
       expect(j$.matchersUtil.contains([1, 2], 2, [customTester])).toBe(true);
     });
+
+    it("fails when actual is undefined", function() {
+      expect(j$.matchersUtil.contains(undefined, 'A')).toBe(false);
+    });
+
+    it("fails when actual is null", function() {
+      expect(j$.matchersUtil.contains(null, 'A')).toBe(false);
+    });
+
+    it("passes with array-like objects", function() {
+      var capturedArgs = null;
+      function testFunction(){
+        capturedArgs = arguments;
+      }
+      testFunction('foo', 'bar');
+      expect(j$.matchersUtil.contains(capturedArgs, 'bar')).toBe(true);
+    });
   });
 
   describe("buildMessage", function() {

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

@@ -8,7 +8,8 @@ describe("toBeGreaterThan", function() {
   });
 
   it("fails when actual <= expected", function() {
-    var matcher = j$.matchers.toBeGreaterThan();
+    var matcher = j$.matchers.toBeGreaterThan(),
+      result;
 
     result = matcher.compare(1, 1);
     expect(result.pass).toBe(false);

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

@@ -9,7 +9,8 @@ describe("toBeNaN", function() {
   });
 
   it("fails for anything not a NaN", function() {
-    var matcher = j$.matchers.toBeNaN();
+    var matcher = j$.matchers.toBeNaN(),
+      result;
 
     result = matcher.compare(1);
     expect(result.pass).toBe(false);
@@ -31,6 +32,6 @@ describe("toBeNaN", function() {
     var matcher = j$.matchers.toBeNaN(),
       result = matcher.compare(0);
 
-    expect(result.message).toEqual("Expected 0 to be NaN.");
+    expect(result.message()).toEqual("Expected 0 to be NaN.");
   });
 });

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

@@ -9,7 +9,8 @@ describe("toBeUndefined", function() {
   });
 
   it("fails when matching defined values", function() {
-    var matcher = j$.matchers.toBeUndefined();
+    var matcher = j$.matchers.toBeUndefined(),
+      result;
 
     result = matcher.compare('foo');
     expect(result.pass).toBe(false);

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

@@ -3,7 +3,8 @@ describe("toContain", function() {
     var util = {
         contains: jasmine.createSpy('delegated-contains').and.returnValue(true)
       },
-      matcher = j$.matchers.toContain(util);
+      matcher = j$.matchers.toContain(util),
+      result;
 
     result = matcher.compare("ABC", "B");
     expect(util.contains).toHaveBeenCalledWith("ABC", "B", []);
@@ -15,7 +16,8 @@ describe("toContain", function() {
         contains: jasmine.createSpy('delegated-contains').and.returnValue(true)
       },
       customEqualityTesters = ['a', 'b'],
-      matcher = j$.matchers.toContain(util, customEqualityTesters);
+      matcher = j$.matchers.toContain(util, customEqualityTesters),
+      result;
 
     result = matcher.compare("ABC", "B");
     expect(util.contains).toHaveBeenCalledWith("ABC", "B", ['a', 'b']);

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

@@ -13,7 +13,8 @@ describe("toHaveBeenCalled", function() {
 
   it("fails when the actual was not called", function() {
     var matcher = j$.matchers.toHaveBeenCalled(),
-      uncalledSpy = j$.createSpy('uncalled spy');
+      uncalledSpy = j$.createSpy('uncalled spy'),
+      result;
 
     result = matcher.compare(uncalledSpy);
     expect(result.pass).toBe(false);

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

@@ -11,7 +11,21 @@ describe("toHaveBeenCalledWith", function() {
     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.");
+    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 = j$.matchers.toHaveBeenCalledWith(util, customEqualityTesters),
+        calledSpy = j$.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() {
@@ -24,7 +38,7 @@ describe("toHaveBeenCalledWith", function() {
 
     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.");
+    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() {
@@ -40,7 +54,7 @@ describe("toHaveBeenCalledWith", function() {
     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' ].");
+    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() {

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

@@ -62,7 +62,7 @@ describe("toThrowError", function() {
 
     result = matcher.compare(fn);
     expect(result.pass).toBe(false);
-    expect(result.message).toEqual("Expected function to throw an Error, but it threw 4.");
+    expect(result.message()).toEqual("Expected function to throw an Error, but it threw 4.");
   });
 
   it("fails with the correct message if thrown is a falsy value", function() {
@@ -74,7 +74,7 @@ describe("toThrowError", function() {
 
     result = matcher.compare(fn);
     expect(result.pass).toBe(false);
-    expect(result.message).toEqual("Expected function to throw an Error, but it threw undefined.");
+    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() {
@@ -100,7 +100,7 @@ describe("toThrowError", function() {
     result = matcher.compare(fn, "foo");
 
     expect(result.pass).toBe(true);
-    expect(result.message).toEqual("Expected function not to throw an exception with message 'foo'.");
+    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() {
@@ -113,7 +113,7 @@ describe("toThrowError", function() {
     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'.");
+    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() {
@@ -126,7 +126,7 @@ describe("toThrowError", function() {
     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/.");
+    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() {
@@ -139,7 +139,7 @@ describe("toThrowError", function() {
     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'.");
+    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() {
@@ -155,7 +155,7 @@ describe("toThrowError", function() {
     result = matcher.compare(fn, Error);
 
     expect(result.pass).toBe(true);
-    expect(result.message).toEqual("Expected function not to throw Error.");
+    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() {
@@ -175,7 +175,7 @@ describe("toThrowError", function() {
     result = matcher.compare(fn, CustomError);
 
     expect(result.pass).toBe(true);
-    expect(result.message).toEqual("Expected function not to throw CustomError.");
+    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() {
@@ -191,7 +191,7 @@ describe("toThrowError", function() {
     result = matcher.compare(fn, TypeError);
 
     expect(result.pass).toBe(false);
-    expect(result.message).toEqual("Expected function to throw TypeError, but it threw Error.");
+    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() {
@@ -207,7 +207,7 @@ describe("toThrowError", function() {
     result = matcher.compare(fn, TypeError, "foo");
 
     expect(result.pass).toBe(true);
-    expect(result.message).toEqual("Expected function not to throw TypeError with message \"foo\".");
+    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() {
@@ -227,7 +227,7 @@ describe("toThrowError", function() {
     result = matcher.compare(fn, CustomError, "foo");
 
     expect(result.pass).toBe(true);
-    expect(result.message).toEqual("Expected function not to throw CustomError with message \"foo\".");
+    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() {
@@ -243,7 +243,7 @@ describe("toThrowError", function() {
     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\".");
+    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() {
@@ -259,7 +259,7 @@ describe("toThrowError", function() {
     result = matcher.compare(fn, TypeError, /foo/);
 
     expect(result.pass).toBe(true);
-    expect(result.message).toEqual("Expected function not to throw TypeError with message matching /foo/.");
+    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() {
@@ -275,6 +275,6 @@ describe("toThrowError", function() {
     result = matcher.compare(fn, TypeError, /bar/);
 
     expect(result.pass).toBe(false);
-    expect(result.message).toEqual("Expected function to throw TypeError with message matching /bar/, but it threw TypeError with message \"foo\".");
+    expect(result.message()).toEqual("Expected function to throw TypeError with a message matching /bar/, but it threw TypeError with message 'foo'.");
   });
 });

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

@@ -34,7 +34,7 @@ describe("toThrow", function() {
     result = matcher.compare(fn);
 
     expect(result.pass).toBe(true);
-    expect(result.message).toEqual("Expected function not to throw, but it threw 5.");
+    expect(result.message()).toEqual("Expected function not to throw, but it threw 5.");
   });
 
   it("passes even if what is thrown is falsy", function() {
@@ -46,7 +46,7 @@ describe("toThrow", function() {
 
     result = matcher.compare(fn);
     expect(result.pass).toBe(true);
-    expect(result.message).toEqual("Expected function not to throw, but it threw undefined.");
+    expect(result.message()).toEqual("Expected function not to throw, but it threw undefined.");
   });
 
   it("passes if what is thrown is equivalent to what is expected", function() {
@@ -62,7 +62,7 @@ describe("toThrow", function() {
     result = matcher.compare(fn, 5);
 
     expect(result.pass).toBe(true);
-    expect(result.message).toEqual("Expected function not to throw 5.");
+    expect(result.message()).toEqual("Expected function not to throw 5.");
   });
 
   it("fails if what is thrown is not equivalent to what is expected", function() {
@@ -78,7 +78,7 @@ describe("toThrow", function() {
     result = matcher.compare(fn, "foo");
 
     expect(result.pass).toBe(false);
-    expect(result.message).toEqual("Expected function to throw 'foo', but it threw 5.");
+    expect(result.message()).toEqual("Expected function to throw 'foo', but it threw 5.");
   });
 
   it("fails if what is thrown is not equivalent to undefined", function() {
@@ -94,6 +94,6 @@ describe("toThrow", function() {
     result = matcher.compare(fn, void 0);
 
     expect(result.pass).toBe(false);
-    expect(result.message).toEqual("Expected function to throw undefined, but it threw 5.");
+    expect(result.message()).toEqual("Expected function to throw undefined, but it threw 5.");
   });
 });

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

@@ -0,0 +1,7 @@
+(function() {
+  // By the time onload is called, jasmineRequire will be redefined to point
+  // to the Jasmine source files (and not jasmine.js). So re-require
+  window.j$ = jasmineRequire.core(jasmineRequire);
+  jasmineRequire.html(j$);
+  jasmineRequire.console(jasmineRequire, j$);
+})();

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

@@ -0,0 +1,33 @@
+(function() {
+  var path = require("path"),
+    fs = require("fs");
+
+  var glob = require("glob");
+
+  var j$Require = require(path.join(__dirname, "../../src/core/requireCore.js"));
+
+  global.getJasmineRequireObj = function () {
+    return j$Require;
+  };
+
+  function extend(destination, source) {
+    for (var property in source) destination[property] = source[property];
+    return destination;
+  }
+
+  function getSourceFiles() {
+    var src_files = ['core/**/*.js', 'console/**/*.js', 'version.js'];
+    src_files.forEach(function(file) {
+      var filePath = path.join(__dirname, "../../", 'src/', file);
+      glob.sync(filePath).forEach(function(resolvedFile) {
+        require(resolvedFile);
+      });
+    });
+  }
+
+  extend(j$Require, require(path.join(__dirname,"../../src/console/requireConsole.js")));
+  getSourceFiles();
+  global.j$ = j$Require.core(j$Require);
+
+  j$Require.console(j$Require, j$);
+})();