jasmine-core 2.99.2 → 3.0.0

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

@@ -0,0 +1,18 @@
+describe("jasmineUnderTest.HtmlSpecFilter", function() {
+
+  it("should match when no string is provided", function() {
+    var specFilter = new jasmineUnderTest.HtmlSpecFilter();
+
+    expect(specFilter.matches("foo")).toBe(true);
+    expect(specFilter.matches("*bar")).toBe(true);
+  });
+
+  it("should only match the provided string", function() {
+    var specFilter = new jasmineUnderTest.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

@@ -0,0 +1,37 @@
+describe("MatchersSpec - HTML Dependent", function () {
+  var env, spec;
+
+  beforeEach(function() {
+    env = new jasmineUnderTest.Env();
+
+    var suite = env.describe("suite", function() {
+      spec = env.it("spec", function() {
+      });
+    });
+    spyOn(spec, 'addExpectationResult');
+
+    addMatchers({
+      toPass: function() {
+        return lastResult().passed;
+      },
+      toFail: function() {
+        return !lastResult().passed;
+      }
+    });
+  });
+
+  function match(value) {
+    return spec.expect(value);
+  }
+
+  function lastResult() {
+    return spec.addExpectationResult.mostRecentCall.args[1];
+  }
+
+  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

@@ -0,0 +1,27 @@
+describe("jasmineUnderTest.pp (HTML Dependent)", function () {
+  it("should stringify non-element HTML nodes properly", function() {
+    var sampleNode = document.createTextNode("");
+    expect(jasmineUnderTest.pp(sampleNode)).toEqual("HTMLNode");
+    expect(jasmineUnderTest.pp({foo: sampleNode})).toEqual("Object({ foo: HTMLNode })");
+  });
+
+  it("should stringify empty HTML elements as their opening tags", function () {
+    var simple = document.createElement('div');
+    simple.className = 'foo';
+    expect(jasmineUnderTest.pp(simple)).toEqual('<div class="foo">');
+  });
+
+  it("should stringify non-empty HTML elements as tags with placeholders", function() {
+    var nonEmpty = document.createElement('div');
+    nonEmpty.className = 'foo';
+    nonEmpty.innerHTML = '<p>Irrelevant</p>';
+    expect(jasmineUnderTest.pp(nonEmpty)).toEqual('<div class="foo">...</div>');
+  });
+
+  it("should print Firefox's wrapped native objects correctly", function() {
+    if(jasmine.getEnv().firefoxVersion) {
+      try { new CustomEvent(); } catch(e) { var err = e; };
+      expect(jasmineUnderTest.pp(err)).toMatch(/Not enough arguments/);
+    }
+  });
+});

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

@@ -0,0 +1,72 @@
+describe("QueryString", function() {
+
+  describe("#navigateWithNewParam", function() {
+    it("sets the query string to include the given key/value pair", function() {
+      var windowLocation = {
+          search: ""
+        },
+        queryString = new jasmineUnderTest.QueryString({
+          getWindowLocation: function() { return windowLocation }
+        });
+
+      queryString.navigateWithNewParam("foo", "bar baz");
+
+      expect(windowLocation.search).toMatch(/foo=bar%20baz/);
+    });
+
+    it("leaves existing params alone", function() {
+      var windowLocation = {
+        search: "?foo=bar"
+      },
+      queryString = new jasmineUnderTest.QueryString({
+        getWindowLocation: function() { return windowLocation }
+      });
+
+      queryString.navigateWithNewParam("baz", "quux");
+
+      expect(windowLocation.search).toMatch(/foo=bar/);
+      expect(windowLocation.search).toMatch(/baz=quux/);
+    });
+  });
+
+  describe('#fullStringWithNewParam', function() {
+    it("gets the query string including the given key/value pair", function() {
+      var windowLocation = {
+        search: "?foo=bar"
+      },
+      queryString = new jasmineUnderTest.QueryString({
+        getWindowLocation: function() { return windowLocation }
+      });
+
+      var result = queryString.fullStringWithNewParam("baz", "quux");
+
+      expect(result).toMatch(/foo=bar/);
+      expect(result).toMatch(/baz=quux/);
+    });
+  });
+
+  describe("#getParam", function() {
+
+    it("returns the value of the requested key", function() {
+      var windowLocation = {
+          search: "?baz=quux%20corge"
+        },
+        queryString = new jasmineUnderTest.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 jasmineUnderTest.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 jasmineUnderTest.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 jasmineUnderTest.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 jasmineUnderTest.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 jasmineUnderTest.ResultsNode(fakeResult, "suite", null);
+
+    node.addChild(fakeChildResult, "spec");
+
+    expect(node.last()).toBe(node.children[node.children.length - 1]);
+  });
+});

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

@@ -0,0 +1,39 @@
+describe('Spy Registry browser-specific behavior', function() {
+  function createSpy(name, originalFn) {
+    return jasmineUnderTest.Spy(name, originalFn);
+  }
+
+  it('can spy on and unspy window.onerror', function() {
+    requireWriteableOnerror();
+
+    var spies = [],
+      spyRegistry = new jasmineUnderTest.SpyRegistry({
+        currentSpies: function() { return spies; },
+        createSpy: createSpy,
+        global: window
+      }),
+      originalHandler = window.onerror;
+
+    try {
+      spyRegistry.spyOn(window, 'onerror');
+      spyRegistry.clearSpies();
+      expect(window.onerror).toBe(originalHandler);
+    } finally {
+      window.onerror = originalHandler;
+    }
+  });
+
+  function requireWriteableOnerror() {
+    var descriptor;
+
+    try {
+      descriptor = Object.getOwnPropertyDescriptor(window, 'onerror');
+    } catch(e) {
+      // IE 8 doesn't support `definePropery` on non-DOM nodes
+    }
+
+    if (descriptor && !(descriptor.writable || descriptor.set)) {
+      pending('Browser declares window.onerror to be readonly');
+    }
+  }
+});

data/lib/jasmine-core/spec/html/matchers/toHaveClassSpec.js

@@ -0,0 +1,48 @@
+describe('toHaveClass', function() {
+  it('fails for a DOM element that lacks the expected class', function() {
+    var matcher = jasmineUnderTest.matchers.toHaveClass(),
+      result = matcher.compare(document.createElement('div'), 'foo');
+
+    expect(result.pass).toBe(false);
+  });
+
+  it('passes for a DOM element that has the expected class', function() {
+    var matcher = jasmineUnderTest.matchers.toHaveClass(),
+      el = document.createElement('div');
+
+    el.className = 'foo bar baz';
+
+    expect(matcher.compare(el, 'foo').pass).toBe(true);
+    expect(matcher.compare(el, 'bar').pass).toBe(true);
+    expect(matcher.compare(el, 'bar').pass).toBe(true);
+  });
+
+  it('fails for a DOM element that only has other classes', function() {
+    var matcher = jasmineUnderTest.matchers.toHaveClass(),
+      el = document.createElement('div');
+
+    el.className = 'foo bar';
+
+    expect(matcher.compare(el, 'fo').pass).toBe(false);
+  });
+
+  it('throws an exception when actual is not a DOM element', function() {
+    var matcher = jasmineUnderTest.matchers.toHaveClass();
+
+    expect(function() {
+      matcher.compare('x', 'foo');
+    }).toThrowError("'x' is not a DOM element");
+
+    expect(function() {
+      matcher.compare(undefined, 'foo');
+    }).toThrowError('undefined is not a DOM element');
+
+    expect(function() {
+      matcher.compare(document.createTextNode(''), 'foo')
+    }).toThrowError('HTMLNode is not a DOM element');
+
+    expect(function() {
+      matcher.compare({classList: ''}, 'foo');
+    }).toThrowError("Object({ classList: '' }) is not a DOM element");
+  });
+});

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

@@ -0,0 +1,101 @@
+describe('npm package', function() {
+  var path = require('path'),
+      temp = require('temp').track(),
+      fs = require('fs');
+
+  beforeAll(function() {
+    var shell = require('shelljs'),
+        pack = shell.exec('npm pack', { silent: true});
+
+    this.tarball = pack.stdout.split('\n')[0];
+    this.tmpDir = temp.mkdirSync(); // automatically deleted on exit
+
+    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.unlinkSync(this.tarball);
+  });
+
+  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(jasmineUnderTest.pp(bigObject)).toMatch(/cycle/);
+  });
+});
+