jasmine-core 2.0.2 → 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() {
@@ -207,6 +207,15 @@ describe("matchersUtil", function() {
     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/toThrowErrorSpec.js

@@ -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() {
@@ -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/html/HtmlReporterSpec.js

@@ -65,8 +65,8 @@ describe("New HtmlReporter", function() {
 
   describe("when a spec is done", function() {
     it("logs errors to the console and prints a special symbol if it is an empty spec", function() {
-      if (!window.console) {
-        window.console = { error: function(){} };
+      if (typeof console === "undefined") {
+        console = { error: function(){} };
       }
 
       var env = new j$.Env(),
@@ -179,6 +179,34 @@ describe("New HtmlReporter", function() {
     });
   });
 
+  describe("when there are suite failures", function () {
+    it("displays the exceptions in their own alert bars", function(){
+      var env = new j$.Env(),
+        container = document.createElement("div"),
+        getContainer = function() { return container; },
+        reporter = new j$.HtmlReporter({
+          env: env,
+          getContainer: getContainer,
+          createElement: function() { return document.createElement.apply(document, arguments); },
+          createTextNode: function() { return document.createTextNode.apply(document, arguments); }
+        });
+
+      reporter.initialize();
+
+      reporter.jasmineStarted({});
+      reporter.suiteDone({ status: 'failed', failedExpectations: [{ message: 'My After All Exception' }] });
+      reporter.suiteDone({ status: 'failed', failedExpectations: [{ message: 'My Other Exception' }] });
+      reporter.jasmineDone({});
+
+      var alertBars = container.querySelectorAll(".alert .bar");
+
+      expect(alertBars.length).toEqual(3);
+      expect(alertBars[1].innerHTML).toMatch(/My After All Exception/);
+      expect(alertBars[1].getAttribute("class")).toEqual('bar errored');
+      expect(alertBars[2].innerHTML).toMatch(/My Other Exception/);
+    });
+  });
+
   describe("when Jasmine is done", function() {
     it("adds EMPTY to the link title of specs that have no expectations", function() {
       if (!window.console) {

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

@@ -0,0 +1,195 @@
+var fs = require('fs');
+var util = require('util');
+var path = require('path');
+
+// boot code for jasmine
+var jasmineRequire = require('../lib/jasmine-core/jasmine.js');
+var jasmine = jasmineRequire.core(jasmineRequire);
+
+var consoleFns = require('../lib/console/console.js');
+extend(jasmineRequire, consoleFns);
+jasmineRequire.console(jasmineRequire, jasmine);
+
+var env = jasmine.getEnv();
+
+var jasmineInterface = {
+  describe: function(description, specDefinitions) {
+    return env.describe(description, specDefinitions);
+  },
+
+  xdescribe: function(description, specDefinitions) {
+    return env.xdescribe(description, specDefinitions);
+  },
+
+  it: function(desc, func) {
+    return env.it(desc, func);
+  },
+
+  xit: function(desc, func) {
+    return env.xit(desc, func);
+  },
+
+  beforeEach: function(beforeEachFunction) {
+    return env.beforeEach(beforeEachFunction);
+  },
+
+  afterEach: function(afterEachFunction) {
+    return env.afterEach(afterEachFunction);
+  },
+
+  expect: function(actual) {
+    return env.expect(actual);
+  },
+
+  spyOn: function(obj, methodName) {
+    return env.spyOn(obj, methodName);
+  },
+
+  jsApiReporter: new jasmine.JsApiReporter({
+    timer: new jasmine.Timer()
+  }),
+
+  beforeAll: function(beforeAllFunction) {
+    return env.beforeAll(beforeAllFunction);
+  },
+
+  afterAll: function(afterAllFunction) {
+    return env.afterAll(afterAllFunction);
+  }
+};
+
+extend(global, jasmineInterface);
+
+function extend(destination, source) {
+  for (var property in source) destination[property] = source[property];
+  return destination;
+}
+
+jasmine.addCustomEqualityTester = function(tester) {
+  env.addCustomEqualityTester(tester);
+};
+
+jasmine.addMatchers = function(matchers) {
+  return env.addMatchers(matchers);
+};
+
+jasmine.clock = function() {
+  return env.clock;
+};
+
+// Jasmine "runner"
+function executeSpecs(specs, done, isVerbose, showColors) {
+  global.jasmine = jasmine;
+
+  for (var i = 0; i < specs.length; i++) {
+    var filename = specs[i];
+    require(filename.replace(/\.\w+$/, ""));
+  }
+
+  var env = jasmine.getEnv();
+  var consoleReporter = new jasmine.ConsoleReporter({
+    print: util.print,
+    onComplete: done,
+    showColors: showColors,
+    timer: new jasmine.Timer()
+  });
+
+  env.addReporter(consoleReporter);
+  env.execute();
+}
+
+function getFiles(dir, matcher) {
+  var allFiles = [];
+
+  if (fs.statSync(dir).isFile() && dir.match(matcher)) {
+    allFiles.push(dir);
+  } else {
+    var files = fs.readdirSync(dir);
+    for (var i = 0, len = files.length; i < len; ++i) {
+      var filename = dir + '/' + files[i];
+      if (fs.statSync(filename).isFile() && filename.match(matcher)) {
+        allFiles.push(filename);
+      } else if (fs.statSync(filename).isDirectory()) {
+        var subfiles = getFiles(filename);
+        subfiles.forEach(function(result) {
+          allFiles.push(result);
+        });
+      }
+    }
+  }
+  return allFiles;
+}
+
+function getSpecFiles(dir) {
+  return getFiles(dir, new RegExp("Spec.js$"));
+}
+
+var j$require = (function() {
+  var exported = {},
+      j$req;
+
+  global.getJasmineRequireObj = getJasmineRequireObj;
+
+  j$req = require(__dirname + "/../src/core/requireCore.js");
+  extend(j$req, require(__dirname + "/../src/console/requireConsole.js"));
+
+  var srcFiles = getFiles(__dirname + "/../src/core");
+  srcFiles.push(__dirname + "/../src/version.js");
+  srcFiles.push(__dirname + "/../src/console/ConsoleReporter.js");
+
+  for (var i = 0; i < srcFiles.length; i++) {
+    require(srcFiles[i]);
+  }
+  extend(j$req, exported);
+
+  delete global.getJasmineRequireObj;
+
+  return j$req;
+
+  function getJasmineRequireObj() {
+    return exported;
+  }
+}());
+
+j$ = j$require.core(j$require);
+j$require.console(j$require, j$);
+
+// options from command line
+var isVerbose = false;
+var showColors = true;
+var perfSuite = false;
+
+process.argv.forEach(function(arg) {
+  switch (arg) {
+    case '--color':
+      showColors = true;
+      break;
+    case '--noColor':
+      showColors = false;
+      break;
+    case '--verbose':
+      isVerbose = true;
+      break;
+    case '--perf':
+      perfSuite = true;
+      break;
+  }
+});
+
+specs = [];
+
+if (perfSuite) {
+  specs = getFiles(__dirname + '/performance', new RegExp("test.js$"));
+} else {
+  var consoleSpecs = getSpecFiles(__dirname + "/console"),
+      coreSpecs = getSpecFiles(__dirname + "/core"),
+      specs = consoleSpecs.concat(coreSpecs);
+}
+
+executeSpecs(specs, function(passed) {
+  if (passed) {
+    process.exit(0);
+  } else {
+    process.exit(1);
+  }
+}, isVerbose, showColors);