jasmine-core 2.0.0 → 2.1.0

data/lib/jasmine-core/spec/html/HtmlReporterSpec.js

@@ -13,7 +13,7 @@ describe("New HtmlReporter", function() {
     reporter.initialize();
 
     // Main top-level elements
-    expect(container.querySelector("div.html-reporter")).toBeTruthy();
+    expect(container.querySelector("div.jasmine_html-reporter")).toBeTruthy();
     expect(container.querySelector("div.banner")).toBeTruthy();
     expect(container.querySelector("div.alert")).toBeTruthy();
     expect(container.querySelector("div.results")).toBeTruthy();
@@ -23,18 +23,36 @@ describe("New HtmlReporter", function() {
     // title banner
     var banner = container.querySelector(".banner");
 
-    var title = banner.querySelector(".title");
-    expect(title.innerHTML).toMatch(/Jasmine/);
+    var title = banner.querySelector("a.title");
+    expect(title.getAttribute('href')).toEqual('http://jasmine.github.io/');
+    expect(title.getAttribute('target')).toEqual('_blank');
 
     var version = banner.querySelector(".version"),
       versionText = 'textContent' in version ? version.textContent : version.innerText;
     expect(versionText).toEqual(j$.version);
   });
 
+  it("builds a single reporter even if initialized multiple times", 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.initialize();
+    reporter.initialize();
+
+    expect(container.querySelectorAll("div.jasmine_html-reporter").length).toEqual(1);
+  });
+
   it("starts the timer when jasmine begins", function() {
     var env = new jasmine.Env(),
         startTimerSpy = jasmine.createSpy("start-timer-spy"),
-        reporter = new jasmine.HtmlReporter({
+        reporter = new j$.HtmlReporter({
           env: env,
           createElement: function() { return document.createElement.apply(document, arguments); },
           timer: { start: startTimerSpy }
@@ -46,6 +64,36 @@ 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 (typeof console === "undefined") {
+        console = { error: 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); }
+      });
+
+      spyOn(console, 'error');
+
+      reporter.initialize();
+
+      reporter.specDone({
+        status: "passed",
+        fullName: 'Some Name',
+        passedExpectations: [],
+        failedExpectations: []
+      });
+      expect(console.error).toHaveBeenCalledWith("Spec \'Some Name\' has no expectations.");
+      var specEl = container.querySelector('.symbol-summary li');
+      expect(specEl.getAttribute("class")).toEqual("empty");
+    });
+
     it("reports the status symbol of a disabled spec", function() {
       var env = new j$.Env(),
         container = document.createElement("div"),
@@ -58,7 +106,7 @@ describe("New HtmlReporter", function() {
         });
       reporter.initialize();
 
-      reporter.specDone({id: 789, status: "disabled", fullName: "symbols should have titles"});
+      reporter.specDone({id: 789, status: "disabled", fullName: "symbols should have titles", passedExpectations: [], failedExpectations: []});
 
       var specEl = container.querySelector('.symbol-summary li');
       expect(specEl.getAttribute("class")).toEqual("disabled");
@@ -78,7 +126,7 @@ describe("New HtmlReporter", function() {
         });
       reporter.initialize();
 
-      reporter.specDone({id: 789, status: "pending"});
+      reporter.specDone({id: 789, status: "pending", passedExpectations: [], failedExpectations: []});
 
       var specEl = container.querySelector('.symbol-summary li');
       expect(specEl.getAttribute("class")).toEqual("pending");
@@ -97,7 +145,7 @@ describe("New HtmlReporter", function() {
         });
       reporter.initialize();
 
-      reporter.specDone({id: 123, status: "passed"});
+      reporter.specDone({id: 123, status: "passed", passedExpectations: [{passed: true}], failedExpectations: []});
 
       var statuses = container.querySelector(".symbol-summary");
       var specEl = statuses.querySelector("li");
@@ -121,7 +169,8 @@ describe("New HtmlReporter", function() {
       reporter.specDone({
         id: 345,
         status: "failed",
-        failedExpectations: []
+        failedExpectations: [],
+        passedExpectations: []
       });
 
       var specEl = container.querySelector(".symbol-summary li");
@@ -130,7 +179,73 @@ 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) {
+        window.console = { error: 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); }
+      });
+
+      spyOn(console, 'error');
+
+      reporter.initialize();
+      reporter.jasmineStarted({});
+      reporter.suiteStarted({id: 1});
+      reporter.specStarted({id: 1, status: 'passed', passedExpectations: [], failedExpectations: []});
+      reporter.specDone({
+        id: 1,
+        status: 'passed',
+        description: 'Spec Description',
+        passedExpectations: [],
+        failedExpectations: []
+      });
+      reporter.suiteDone({id: 1});
+      reporter.jasmineDone({});
+
+      var summary = container.querySelector('.summary');
+      var suite = summary.childNodes[0];
+      var specs = suite.childNodes[1];
+      var spec = specs.childNodes[0];
+      var specLink = spec.childNodes[0];
+      expect(specLink.innerHTML).toMatch(/SPEC HAS NO EXPECTATIONS/);
+    });
+
     it("reports the run time", function() {
       var env = new j$.Env(),
         container = document.createElement("div"),
@@ -178,7 +293,9 @@ describe("New HtmlReporter", function() {
         id: 123,
         description: "with a spec",
         fullName: "A Suite with a spec",
-        status: "passed"
+        status: "passed",
+        failedExpectations: [],
+        passedExpectations: [{passed: true}]
       };
       reporter.specStarted(specResult);
       reporter.specDone(specResult);
@@ -193,7 +310,9 @@ describe("New HtmlReporter", function() {
         id: 124,
         description: "with another spec",
         fullName: "A Suite inner suite with another spec",
-        status: "passed"
+        status: "passed",
+        failedExpectations: [],
+        passedExpectations: [{passed: true}]
       };
       reporter.specStarted(specResult);
       reporter.specDone(specResult);
@@ -205,7 +324,8 @@ describe("New HtmlReporter", function() {
         description: "with a failing spec",
         fullName: "A Suite inner with a failing spec",
         status: "failed",
-        failedExpectations: []
+        failedExpectations: [{}],
+        passedExpectations: []
       };
       reporter.specStarted(specResult);
       reporter.specDone(specResult);
@@ -321,12 +441,33 @@ describe("New HtmlReporter", function() {
       });
     });
 
+    it("shows a message if no specs are run", function(){
+      var env, container, reporter;
+      env = new j$.Env();
+      container = document.createElement("div");
+      var 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.jasmineDone({});
+
+      var alertBars = container.querySelectorAll(".alert .bar");
+      expect(alertBars[0].getAttribute('class')).toMatch(/skipped/);
+      expect(alertBars[0].innerHTML).toMatch(/No specs found/);
+    });
+
     describe("and all specs pass", function() {
       var env, container, reporter;
       beforeEach(function() {
         env = new j$.Env();
         container = document.createElement("div");
-        getContainer = function() { return container; },
+        var getContainer = function() { return container; },
           reporter = new j$.HtmlReporter({
             env: env,
             getContainer: getContainer,
@@ -335,18 +476,22 @@ describe("New HtmlReporter", function() {
           });
         reporter.initialize();
 
-        reporter.jasmineStarted({});
+        reporter.jasmineStarted({ totalSpecsDefined: 2 });
         reporter.specDone({
           id: 123,
           description: "with a spec",
           fullName: "A Suite with a spec",
-          status: "passed"
+          status: "passed",
+          passedExpectations: [{passed: true}],
+          failedExpectations: []
         });
         reporter.specDone({
           id: 124,
           description: "with another spec",
           fullName: "A Suite inner suite with another spec",
-          status: "passed"
+          status: "passed",
+          passedExpectations: [{passed: true}],
+          failedExpectations: []
         });
         reporter.jasmineDone({});
       });
@@ -377,21 +522,23 @@ describe("New HtmlReporter", function() {
       beforeEach(function() {
         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); }
-          });
+        var 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.jasmineStarted({ totalSpecsDefined: 1 });
         reporter.specDone({
           id: 123,
           description: "with a spec",
           fullName: "A Suite with a spec",
-          status: "pending"
+          status: "pending",
+          passedExpectations: [],
+          failedExpectations: []
         });
         reporter.jasmineDone({});
       });
@@ -414,19 +561,19 @@ describe("New HtmlReporter", function() {
 
       beforeEach(function() {
         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); }
-          });
+        container = document.createElement("div");
+        var 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.jasmineStarted({ totalSpecsDefined: 1 });
 
-        var passingResult = {id: 123, status: "passed"};
+        var passingResult = {id: 123, status: "passed", passedExpectations: [{passed: true}], failedExpectations: []};
         reporter.specStarted(passingResult);
         reporter.specDone(passingResult);
 
@@ -435,6 +582,7 @@ describe("New HtmlReporter", function() {
           status: "failed",
           description: "a failing spec",
           fullName: "a suite with a failing spec",
+          passedExpectations: [],
           failedExpectations: [
             {
               message: "a failure message",
@@ -488,7 +636,7 @@ describe("New HtmlReporter", function() {
       });
 
       it("sets the reporter to 'Failures List' mode", function() {
-        var reporterNode = container.querySelector(".html-reporter");
+        var reporterNode = container.querySelector(".jasmine_html-reporter");
         expect(reporterNode.getAttribute("class")).toMatch("failure-list");
       });
     });

data/lib/jasmine-core/spec/html/PrettyPrintHtmlSpec.js

@@ -3,7 +3,7 @@ describe("j$.pp (HTML Dependent)", function () {
     var sampleNode = document.createElement('div');
     sampleNode.innerHTML = 'foo<b>bar</b>';
     expect(j$.pp(sampleNode)).toEqual("HTMLNode");
-    expect(j$.pp({foo: sampleNode})).toEqual("{ foo : HTMLNode }");
+    expect(j$.pp({foo: sampleNode})).toEqual("{ foo: HTMLNode }");
   });
 
   it("should print Firefox's wrapped native objects correctly", function() {

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

@@ -47,7 +47,15 @@ var jasmineInterface = {
 
   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);

data/lib/jasmine-core/spec/npmPackage/npmPackageSpec.js

@@ -0,0 +1,104 @@
+describe('npm package', function() {
+  var path = require('path'),
+      fs = require('fs');
+
+  beforeAll(function() {
+    var shell = require('shelljs'),
+        pack = shell.exec('npm pack', { silent: true });
+
+    this.tarball = pack.output.split('\n')[0];
+    this.tmpDir = '/tmp/jasmine-core';
+
+    fs.mkdirSync(this.tmpDir);
+
+    var untar = shell.exec('tar -xzf ' + this.tarball + ' -C ' + this.tmpDir, { silent: true });
+    expect(untar.code).toBe(0);
+
+    this.packagedCore = require(path.join(this.tmpDir, 'package/lib/jasmine-core.js'));
+  });
+
+  beforeEach(function() {
+    jasmine.addMatchers({
+      toExistInPath: function(util, customEquality) {
+        return {
+          compare: function(actual, expected) {
+            var fullPath = path.resolve(expected, actual);
+            return {
+              pass: fs.existsSync(fullPath)
+            };
+          }
+        };
+      }
+    });
+  });
+
+  afterAll(function() {
+    var cleanup = function (parent, fileOrFolder) {
+      var fullPath = path.join(parent, fileOrFolder);
+      if (fs.statSync(fullPath).isFile()) {
+        fs.unlinkSync(fullPath);
+      } else {
+        fs.readdirSync(fullPath).forEach(cleanup.bind(null, fullPath));
+        fs.rmdirSync(fullPath);
+      }
+    };
+
+    fs.unlink(this.tarball);
+    fs.readdirSync(this.tmpDir).forEach(cleanup.bind(null, this.tmpDir));
+    fs.rmdirSync(this.tmpDir);
+  });
+
+  it('has a root path', function() {
+    expect(this.packagedCore.files.path).toEqual(fs.realpathSync(path.resolve(this.tmpDir, 'package/lib/jasmine-core')));
+  });
+
+  it('has a bootDir', function() {
+    expect(this.packagedCore.files.bootDir).toEqual(fs.realpathSync(path.resolve(this.tmpDir, 'package/lib/jasmine-core')));
+  });
+
+  it('has jsFiles', function() {
+    expect(this.packagedCore.files.jsFiles).toEqual([
+      'jasmine.js',
+      'jasmine-html.js',
+      'json2.js'
+    ]);
+
+    var packagedCore = this.packagedCore;
+    this.packagedCore.files.jsFiles.forEach(function(fileName) {
+      expect(fileName).toExistInPath(packagedCore.files.path);
+    });
+  });
+
+  it('has cssFiles', function() {
+    expect(this.packagedCore.files.cssFiles).toEqual(['jasmine.css']);
+
+    var packagedCore = this.packagedCore;
+    this.packagedCore.files.cssFiles.forEach(function(fileName) {
+      expect(fileName).toExistInPath(packagedCore.files.path);
+    });
+  });
+
+  it('has bootFiles', function() {
+    expect(this.packagedCore.files.bootFiles).toEqual(['boot.js']);
+    expect(this.packagedCore.files.nodeBootFiles).toEqual(['node_boot.js']);
+
+    var packagedCore = this.packagedCore;
+    this.packagedCore.files.bootFiles.forEach(function(fileName) {
+      expect(fileName).toExistInPath(packagedCore.files.bootDir);
+    });
+
+    var packagedCore = this.packagedCore;
+    this.packagedCore.files.nodeBootFiles.forEach(function(fileName) {
+      expect(fileName).toExistInPath(packagedCore.files.bootDir);
+    });
+  });
+
+  it('has an imagesDir', function() {
+    expect(this.packagedCore.files.imagesDir).toEqual(fs.realpathSync(path.resolve(this.tmpDir, 'package/images')));
+    var images = fs.readdirSync(path.resolve(this.tmpDir, 'package/images'));
+
+    expect(images).toContain('jasmine-horizontal.png');
+    expect(images).toContain('jasmine-horizontal.svg');
+    expect(images).toContain('jasmine_favicon.png');
+  });
+});

data/lib/jasmine-core/spec/performance/large_object_test.js

@@ -0,0 +1,36 @@
+describe('Printing a big object', function(){
+  var bigObject;
+  function rand(upper) {
+    return Math.round(upper * Math.random());
+  }
+
+  function generateObject(level) {
+    var object = {};
+
+    for (var i = 0; i < 50; i++) {
+      var decide = rand(2);
+      switch (decide) {
+        case 0:
+          object["cycle" + i] = object;
+        break;
+        case 1:
+          object["number" + i] = rand(100);
+        break;
+        case 2:
+          if (level < 3) {
+          object["nesting" + i] = generateObject(level + 1);
+        }
+        break;
+      }
+
+    }
+
+    return object;
+  }
+
+  it('takes a resonable amount of time', function(){
+    bigObject = generateObject(0);
+    expect(j$.pp(bigObject)).toMatch(/cycle/);
+  });
+});
+

data/lib/jasmine-core/version.rb

@@ -4,6 +4,6 @@
 #
 module Jasmine
   module Core
-    VERSION = "2.0.0"
+    VERSION = "2.1.0"
   end
 end

data/lib/jasmine-core.js

@@ -0,0 +1,37 @@
+module.exports = require("./jasmine-core/jasmine.js");
+module.exports.boot = require('./jasmine-core/node_boot.js');
+
+var path = require('path'),
+    fs = require('fs');
+
+var rootPath = path.join(__dirname, "jasmine-core"),
+    bootFiles = ['boot.js'],
+    nodeBootFiles = ['node_boot.js'],
+    cssFiles = [],
+    jsFiles = [],
+    jsFilesToSkip = ['jasmine.js'].concat(bootFiles, nodeBootFiles);
+
+fs.readdirSync(rootPath).forEach(function(file) {
+  if(fs.statSync(path.join(rootPath, file)).isFile()) {
+    switch(path.extname(file)) {
+      case '.css':
+        cssFiles.push(file);
+      break;
+      case '.js':
+        if (jsFilesToSkip.indexOf(file) < 0) {
+        jsFiles.push(file);
+      }
+      break;
+    }
+  }
+});
+
+module.exports.files = {
+  path: rootPath,
+  bootDir: rootPath,
+  bootFiles: bootFiles,
+  nodeBootFiles: nodeBootFiles,
+  cssFiles: cssFiles,
+  jsFiles: ['jasmine.js'].concat(jsFiles),
+  imagesDir: path.join(__dirname, '../images')
+};

data/lib/jasmine-core.rb

@@ -6,7 +6,7 @@ module Jasmine
       end
 
       def js_files
-        (["jasmine.js"] + Dir.glob(File.join(path, "*.js"))).map { |f| File.basename(f) }.uniq - boot_files
+        (["jasmine.js"] + Dir.glob(File.join(path, "*.js"))).map { |f| File.basename(f) }.uniq - boot_files - node_boot_files
       end
 
       SPEC_TYPES = ["core", "html", "node"]
@@ -27,8 +27,12 @@ module Jasmine
         ["boot.js"]
       end
 
+      def node_boot_files
+        ["node_boot.js"]
+      end
+
       def boot_dir
-        File.join(path, 'boot')
+        path
       end
 
       def spec_files(type)