jasmine-core 1.3.1 → 2.0.0.rc2

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

@@ -0,0 +1,18 @@
+describe("j$.HtmlSpecFilter", function() {
+
+  it("should match when no string is provided", function() {
+    var specFilter = new j$.HtmlSpecFilter();
+
+    expect(specFilter.matches("foo")).toBe(true);
+    expect(specFilter.matches("*bar")).toBe(true);
+  });
+
+  it("should only match the provided string", function() {
+    var specFilter = new j$.HtmlSpecFilter({
+      filterString: function() { return "foo"; }
+    });
+
+    expect(specFilter.matches("foo")).toBe(true);
+    expect(specFilter.matches("bar")).toBe(false);
+  });
+});

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

@@ -2,21 +2,21 @@ describe("MatchersSpec - HTML Dependent", function () {
   var env, spec;
 
   beforeEach(function() {
-    env = new jasmine.Env();
+    env = new j$.Env();
     env.updateInterval = 0;
 
     var suite = env.describe("suite", function() {
       spec = env.it("spec", function() {
       });
     });
-    spyOn(spec, 'addMatcherResult');
+    spyOn(spec, 'addExpectationResult');
 
-    this.addMatchers({
+    addMatchers({
       toPass: function() {
-        return lastResult().passed();
+        return lastResult().passed;
       },
       toFail: function() {
-        return !lastResult().passed();
+        return !lastResult().passed;
       }
     });
   });
@@ -26,13 +26,13 @@ describe("MatchersSpec - HTML Dependent", function () {
   }
 
   function lastResult() {
-    return spec.addMatcherResult.mostRecentCall.args[0];
+    return spec.addExpectationResult.mostRecentCall.args[1];
   }
 
-  it("toEqual with DOM nodes", function() {
+  xit("toEqual with DOM nodes", function() {
     var nodeA = document.createElement('div');
     var nodeB = document.createElement('div');
     expect((match(nodeA).toEqual(nodeA))).toPass();
     expect((match(nodeA).toEqual(nodeB))).toFail();
   });
-});
+});

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

@@ -1,8 +1,8 @@
-describe("jasmine.pp (HTML Dependent)", function () {
+describe("j$.pp (HTML Dependent)", function () {
   it("should stringify HTML nodes properly", function() {
     var sampleNode = document.createElement('div');
     sampleNode.innerHTML = 'foo<b>bar</b>';
-    expect(jasmine.pp(sampleNode)).toEqual("HTMLNode");
-    expect(jasmine.pp({foo: sampleNode})).toEqual("{ foo : HTMLNode }");
+    expect(j$.pp(sampleNode)).toEqual("HTMLNode");
+    expect(j$.pp({foo: sampleNode})).toEqual("{ foo : HTMLNode }");
   });
 });

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

@@ -0,0 +1,43 @@
+describe("QueryString", function() {
+
+  describe("#setParam", function() {
+
+    it("sets the query string to include the given key/value pair", function() {
+      var windowLocation = {
+          search: ""
+        },
+        queryString = new j$.QueryString({
+          getWindowLocation: function() { return windowLocation }
+        });
+
+      queryString.setParam("foo", "bar baz");
+
+      expect(windowLocation.search).toMatch(/foo=bar%20baz/);
+    });
+  });
+
+  describe("#getParam", function() {
+
+    it("returns the value of the requested key", function() {
+      var windowLocation = {
+          search: "?baz=quux%20corge"
+        },
+        queryString = new j$.QueryString({
+          getWindowLocation: function() { return windowLocation }
+        });
+
+      expect(queryString.getParam("baz")).toEqual("quux corge");
+    });
+
+    it("returns null if the key is not present", function() {
+      var windowLocation = {
+          search: ""
+        },
+        queryString = new j$.QueryString({
+          getWindowLocation: function() { return windowLocation }
+        });
+
+      expect(queryString.getParam("baz")).toBeFalsy();
+    });
+  });
+});

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

@@ -0,0 +1,62 @@
+describe("ResultsNode", function() {
+  it("wraps a result", function() {
+    var fakeResult = {
+        id: 123,
+        message: "foo"
+      },
+      node = new j$.ResultsNode(fakeResult, "suite", null);
+
+    expect(node.result).toBe(fakeResult);
+    expect(node.type).toEqual("suite");
+  });
+
+  it("can add children with a type", function() {
+    var fakeResult = {
+        id: 123,
+        message: "foo"
+      },
+      fakeChildResult = {
+        id: 456,
+        message: "bar"
+      },
+      node = new j$.ResultsNode(fakeResult, "suite", null);
+
+    node.addChild(fakeChildResult, "spec");
+
+    expect(node.children.length).toEqual(1);
+    expect(node.children[0].result).toEqual(fakeChildResult);
+    expect(node.children[0].type).toEqual("spec");
+  });
+
+  it("has a pointer back to its parent ResultNode", function() {
+    var fakeResult = {
+        id: 123,
+        message: "foo"
+      },
+      fakeChildResult = {
+        id: 456,
+        message: "bar"
+      },
+      node = new j$.ResultsNode(fakeResult, "suite", null);
+
+    node.addChild(fakeChildResult, "spec");
+
+    expect(node.children[0].parent).toBe(node);
+  });
+
+  it("can provide the most recent child", function() {
+    var fakeResult = {
+        id: 123,
+        message: "foo"
+      },
+      fakeChildResult = {
+        id: 456,
+        message: "bar"
+      },
+      node = new j$.ResultsNode(fakeResult, "suite", null);
+
+    node.addChild(fakeChildResult, "spec");
+
+    expect(node.last()).toBe(node.children[node.children.length - 1]);
+  });
+});

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

@@ -2,124 +2,182 @@ var fs = require('fs');
 var util = require('util');
 var path = require('path');
 
-// yes, really keep this here to keep us honest, but only for jasmine's own runner! [xw]
-// undefined = "diz be undefined yo";
-
-
-var jasmineGlobals = require('../lib/jasmine-core/jasmine.js');
-for (var k in jasmineGlobals) {
-  global[k] = jasmineGlobals[k];
-}
-require('../src/console/ConsoleReporter.js');
-
-/*
- Pulling in code from jasmine-node.
-
- We can't just depend on jasmine-node because it has its own jasmine that it uses.
- */
-
-global.window = {
-  setTimeout: setTimeout,
-  clearTimeout: clearTimeout,
-  setInterval: setInterval,
-  clearInterval: clearInterval
+// boot code for jasmine
+var jasmineRequire = require('../lib/jasmine-core/jasmine.js');
+var jasmine = jasmineRequire.core(jasmineRequire);
+
+var consoleFns = require('../src/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);
+  },
+
+  addMatchers: function(matchers) {
+    return env.addMatchers(matchers);
+  },
+
+  spyOn: function(obj, methodName) {
+    return env.spyOn(obj, methodName);
+  },
+
+  clock: env.clock,
+  setTimeout: env.clock.setTimeout,
+  clearTimeout: env.clock.clearTimeout,
+  setInterval: env.clock.setInterval,
+  clearInterval: env.clock.clearInterval,
+
+  jsApiReporter: new jasmine.JsApiReporter({
+    timer: new jasmine.Timer()
+  })
 };
 
-delete global.window;
+extend(global, jasmineInterface);
 
-function noop() {
+function extend(destination, source) {
+  for (var property in source) destination[property] = source[property];
+  return destination;
 }
 
-jasmine.executeSpecs = function(specs, done, isVerbose, showColors) {
-  for (var i = 0, len = specs.length; i < len; ++i) {
+// 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 jasmineEnv = jasmine.getEnv();
-  var consoleReporter = new jasmine.ConsoleReporter(util.print, done, showColors);
+  var env = jasmine.getEnv();
+  var consoleReporter = new jasmine.ConsoleReporter({
+    print: util.print,
+    onComplete: done,
+    showColors: showColors,
+    timer: new jasmine.Timer()
+  });
 
-  jasmineEnv.addReporter(consoleReporter);
-  jasmineEnv.execute();
-};
+  env.addReporter(consoleReporter);
+  env.execute();
+}
 
-jasmine.getAllSpecFiles = function(dir, matcher) {
-  var specs = [];
+function getFiles(dir, matcher) {
+  var allFiles = [];
 
   if (fs.statSync(dir).isFile() && dir.match(matcher)) {
-    specs.push(dir);
+    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)) {
-        specs.push(filename);
+        allFiles.push(filename);
       } else if (fs.statSync(filename).isDirectory()) {
-        var subfiles = this.getAllSpecFiles(filename, matcher);
+        var subfiles = getFiles(filename);
         subfiles.forEach(function(result) {
-          specs.push(result);
+          allFiles.push(result);
         });
       }
     }
   }
+  return allFiles;
+}
 
-  return specs;
-};
-
-function now() {
-  return new Date().getTime();
+function getSpecFiles(dir) {
+  return getFiles(dir, new RegExp("Spec.js$"));
 }
 
-jasmine.asyncSpecWait = function() {
-  var wait = jasmine.asyncSpecWait;
-  wait.start = now();
-  wait.done = false;
-  (function innerWait() {
-    waits(10);
-    runs(function() {
-      if (wait.start + wait.timeout < now()) {
-        expect('timeout waiting for spec').toBeNull();
-      } else if (wait.done) {
-        wait.done = false;
-      } else {
-        innerWait();
-      }
-    });
-  })();
-};
-jasmine.asyncSpecWait.timeout = 4 * 1000;
-jasmine.asyncSpecDone = function() {
-  jasmine.asyncSpecWait.done = true;
-};
+var j$require = (function() {
+  var exported = {},
+      j$req;
 
-for (var key in jasmine) {
-  exports[key] = jasmine[key];
-}
+  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;
 
-/*
- End jasmine-node runner
- */
+  return j$req;
 
+  function getJasmineRequireObj() {
+    return exported;
+  }
+}());
+
+var 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 '--color':
+      showColors = true;
+      break;
+    case '--noColor':
+      showColors = false;
+      break;
+    case '--verbose':
+      isVerbose = true;
+      break;
+    case '--perf':
+      perfSuite = true;
+      break;
   }
 });
 
-var specs = jasmine.getAllSpecFiles(__dirname, new RegExp(".js$"));
-var domIndependentSpecs = [];
-for (var i = 0; i < specs.length; i++) {
-  if (fs.readFileSync(specs[i], "utf8").indexOf("document.createElement") < 0) {
-    domIndependentSpecs.push(specs[i]);
-  }
+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);
 }
 
-jasmine.executeSpecs(domIndependentSpecs, function(runner, log) {
-  if (runner.results().failedCount === 0) {
+executeSpecs(specs, function(passed) {
+  if (passed) {
     process.exit(0);
   } else {
     process.exit(1);

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

@@ -0,0 +1,10 @@
+describe("performance", function() {
+  for (var i = 0; i < 10000; i++) {
+    it("should pass", function() {
+      expect(true).toBe(true);
+    });
+    it("should fail", function() {
+      expect(true).toBe(false);
+    });
+  }
+});