jasmine-core 2.1.3 → 2.2.0

data/lib/jasmine-core/spec/core/asymmetric_equality/StringMatchingSpec.js

@@ -0,0 +1,27 @@
+describe("StringMatching", function() {
+  it("matches a string against a provided regexp", function() {
+    var matcher = new j$.StringMatching(/foo/);
+
+    expect(matcher.asymmetricMatch('barfoobaz')).toBe(true);
+    expect(matcher.asymmetricMatch('barbaz')).toBe(false);
+  });
+
+  it("matches a string against provided string", function() {
+    var matcher = new j$.StringMatching('foo');
+
+    expect(matcher.asymmetricMatch('barfoobaz')).toBe(true);
+    expect(matcher.asymmetricMatch('barbaz')).toBe(false);
+  });
+
+  it("raises an Error when the expected is not a String or RegExp", function() {
+    expect(function() {
+      new j$.StringMatching({});
+    }).toThrowError(/not a String or a RegExp/);
+  });
+
+  it("jasmineToString's itself", function() {
+    var matching = new j$.StringMatching(/^foo/);
+
+    expect(matching.jasmineToString()).toEqual("<jasmine.stringMatching(/^foo/)>");
+  });
+});

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

@@ -161,9 +161,24 @@ describe("Env integration", function() {
           })]
         }));
         expect(specDone).toHaveBeenCalledWith(jasmine.objectContaining({
-          description: 'has a message from an Error',
+          description: 'has a message and stack trace from an Error',
           failedExpectations: [jasmine.objectContaining({
-            message: 'Failed: error message'
+            message: 'Failed: error message',
+            stack: {
+              asymmetricMatch: function(other) {
+                if (!other) {
+                  // IE doesn't give us a stacktrace so just ignore it.
+                  return true;
+                }
+                var split = other.split('\n'),
+                    firstLine = split[0];
+                if (firstLine.indexOf('error message') >= 0) {
+                  // Chrome inserts the message and a newline before the first stacktrace line.
+                  firstLine = split[1];
+                }
+                return firstLine.indexOf('EnvSpec') >= 0;
+              }
+            }
           })]
         }));
         done();
@@ -179,7 +194,7 @@ describe("Env integration", function() {
         env.fail('messy message');
       });
 
-      env.it('has a message from an Error', function() {
+      env.it('has a message and stack trace from an Error', function() {
         env.fail(new Error('error message'));
       });
     });
@@ -1122,6 +1137,67 @@ describe("Env integration", function() {
     env.execute();
   });
 
+  it('should report pending spec messages', function(done) {
+    var env = new j$.Env(),
+        reporter = jasmine.createSpyObj('fakeReporter', [
+          'specDone',
+          'jasmineDone'
+        ]);
+
+    reporter.jasmineDone.and.callFake(function() {
+      var specStatus = reporter.specDone.calls.argsFor(0)[0];
+
+      expect(specStatus.pendingReason).toBe('with a message');
+
+      done();
+    });
+
+    env.addReporter(reporter);
+
+    env.it('will be pending', function() {
+      env.pending('with a message');
+    });
+
+    env.execute();
+  });
+
+  it('should report xdescribes as expected', function(done) {
+    var env = new j$.Env(),
+        reporter = jasmine.createSpyObj('fakeReporter', [
+          "jasmineStarted",
+          "jasmineDone",
+          "suiteStarted",
+          "suiteDone",
+          "specStarted",
+          "specDone"
+        ]);
+
+    reporter.jasmineDone.and.callFake(function() {
+      expect(reporter.jasmineStarted).toHaveBeenCalledWith({
+        totalSpecsDefined: 1
+      });
+
+      expect(reporter.specDone).not.toHaveBeenCalled();
+      expect(reporter.suiteDone.calls.count()).toBe(3);
+
+      done();
+    });
+
+    env.addReporter(reporter);
+
+    env.describe("A Suite", function() {
+      env.describe("nested", function() {
+        env.xdescribe("xd out", function() {
+          env.it("with a spec", function() {
+            env.expect(true).toBe(false);
+          });
+        });
+      });
+    });
+
+    env.execute();
+  });
+
   it("should be possible to get full name from a spec", function() {
     var env = new j$.Env({global: { setTimeout: setTimeout }}),
         topLevelSpec, nestedSpec, doublyNestedSpec;

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

@@ -228,7 +228,7 @@ describe("jasmine spec running", function () {
     env.execute();
   });
 
-  it('should run beforeAlls before beforeEachs and afterAlls after afterEachs', function() {
+  it('should run beforeAlls before beforeEachs and afterAlls after afterEachs', function(done) {
     var actions = [];
 
     env.beforeAll(function() {
@@ -289,7 +289,7 @@ describe("jasmine spec running", function () {
     env.execute();
   });
 
-  it('should run beforeAlls and afterAlls as beforeEachs and afterEachs in the order declared when runnablesToRun is provided', function() {
+  it('should run beforeAlls and afterAlls as beforeEachs and afterEachs in the order declared when runnablesToRun is provided', function(done) {
     var actions = [],
       spec,
       spec2;
@@ -366,6 +366,30 @@ describe("jasmine spec running", function () {
     env.execute([spec.id, spec2.id]);
   });
 
+  it('only runs *Alls once in a focused suite', function(done){
+    var actions = [];
+
+    env.fdescribe('Suite', function() {
+      env.beforeAll(function(){
+        actions.push('beforeAll');
+      });
+      env.it('should run beforeAll once', function() {
+        actions.push('spec');
+      });
+      env.afterAll(function(){
+        actions.push('afterAll');
+      });
+    });
+
+    var assertions = function() {
+      expect(actions).toEqual(['beforeAll', 'spec', 'afterAll']);
+      done();
+    };
+
+    env.addReporter({jasmineDone: assertions});
+    env.execute();
+  });
+
   describe('focused runnables', function() {
     it('runs the relevant alls and eachs for each runnable', function(done) {
       var actions = [];

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

@@ -58,6 +58,16 @@ describe("matchersUtil", function() {
       expect(j$.matchersUtil.equals([1, 2], [1, 2, 3])).toBe(false);
     });
 
+    it("fails for Arrays whose contents are equivalent, but have differing properties", function() {
+      var one = [1,2,3],
+          two = [1,2,3];
+
+      one.foo = 'bar';
+      two.foo = 'baz';
+
+      expect(j$.matchersUtil.equals(one, two)).toBe(false);
+    });
+
     it("passes for Errors that are the same type and have the same message", function() {
       expect(j$.matchersUtil.equals(new Error("foo"), new Error("foo"))).toBe(true);
     });
@@ -122,6 +132,45 @@ describe("matchersUtil", function() {
       expect(j$.matchersUtil.equals(a,b)).toBe(true);
     });
 
+    it("passes for equivalent DOM nodes", function() {
+      if (typeof document === 'undefined') {
+        return;
+      }
+      var a = document.createElement("div");
+      a.setAttribute("test-attr", "attr-value")
+      a.appendChild(document.createTextNode('test'));
+
+      var b = document.createElement("div");
+      b.setAttribute("test-attr", "attr-value")
+      b.appendChild(document.createTextNode('test'));
+
+      expect(j$.matchersUtil.equals(a,b)).toBe(true);
+    });
+
+    it("fails for DOM nodes with different attributes or child nodes", function() {
+      if (typeof document === 'undefined') {
+        return;
+      }
+      var a = document.createElement("div");
+      a.setAttribute("test-attr", "attr-value")
+      a.appendChild(document.createTextNode('test'));
+
+      var b = document.createElement("div");
+      b.setAttribute("test-attr", "attr-value2")
+      b.appendChild(document.createTextNode('test'));
+
+      expect(j$.matchersUtil.equals(a,b)).toBe(false);
+
+      b.setAttribute("test-attr", "attr-value");
+      expect(j$.matchersUtil.equals(a,b)).toBe(true);
+
+      b.appendChild(document.createTextNode('2'));
+      expect(j$.matchersUtil.equals(a,b)).toBe(false);
+
+      a.appendChild(document.createTextNode('2'));
+      expect(j$.matchersUtil.equals(a,b)).toBe(true);
+    });
+
     it("passes when Any is used", function() {
       var number = 3,
         anyNumber = new j$.Any(Number);
@@ -142,9 +191,31 @@ describe("matchersUtil", function() {
       var obj = {
         foo: 3,
         bar: 7
-      };
+      },
+      containing = new j$.ObjectContaining({foo: 3});
+
+      expect(j$.matchersUtil.equals(obj, containing)).toBe(true);
+      expect(j$.matchersUtil.equals(containing, obj)).toBe(true);
+    });
+
+    it("passes when an asymmetric equality tester returns true", function() {
+      var tester = { asymmetricMatch: function(other) { return true; } };
 
-      expect(j$.matchersUtil.equals(obj, new j$.ObjectContaining({foo: 3}))).toBe(true);
+      expect(j$.matchersUtil.equals(false, tester)).toBe(true);
+      expect(j$.matchersUtil.equals(tester, false)).toBe(true);
+    });
+
+    it("fails when an asymmetric equality tester returns false", function() {
+      var tester = { asymmetricMatch: function(other) { return false; } };
+
+      expect(j$.matchersUtil.equals(true, tester)).toBe(false);
+      expect(j$.matchersUtil.equals(tester, true)).toBe(false);
+    });
+
+    it("passes when ArrayContaining is used", function() {
+      var arr = ["foo", "bar"];
+
+      expect(j$.matchersUtil.equals(arr, new j$.ArrayContaining(["bar"]))).toBe(true);
     });
 
     it("passes when a custom equality matcher returns true", function() {
@@ -170,6 +241,45 @@ describe("matchersUtil", function() {
 
       expect(j$.matchersUtil.equals(1, 1, [tester])).toBe(false);
     });
+
+    it("passes for an asymmetric equality tester that returns true when a custom equality tester return false", function() {
+      var asymmetricTester = { asymmetricMatch: function(other) { return true; } },
+          symmetricTester = function(a, b) { return false; };
+
+      expect(j$.matchersUtil.equals(asymmetricTester, true, [symmetricTester])).toBe(true);
+      expect(j$.matchersUtil.equals(true, asymmetricTester, [symmetricTester])).toBe(true);
+    });
+
+    it("passes when an Any is compared to an Any that checks for the same type", function() {
+      var any1 = new j$.Any(Function),
+          any2 = new j$.Any(Function);
+
+      expect(j$.matchersUtil.equals(any1, any2)).toBe(true);
+    });
+
+    it("passes for null prototype objects with same properties", function () {
+      if (jasmine.getEnv().ieVersion < 9) { return; }
+
+      var objA = Object.create(null),
+          objB = Object.create(null);
+
+      objA.name = 'test';
+      objB.name = 'test';
+
+      expect(j$.matchersUtil.equals(objA, objB)).toBe(true);
+    });
+
+    it("fails for null prototype objects with different properties", function () {
+      if (jasmine.getEnv().ieVersion < 9) { return; }
+
+      var objA = Object.create(null),
+          objB = Object.create(null);
+
+      objA.name = 'test';
+      objB.test = 'name';
+
+      expect(j$.matchersUtil.equals(objA, objB)).toBe(false);
+    });
   });
 
   describe("contains", function() {

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

@@ -30,5 +30,13 @@ describe("toMatch", function() {
     result = matcher.compare('bar', 'foo');
     expect(result.pass).toBe(false);
   });
+
+  it("throws an Error when the expected is not a String or RegExp", function() {
+    var matcher = j$.matchers.toMatch();
+
+    expect(function() {
+      matcher.compare('foo', { bar: 'baz' });
+    }).toThrowError('Expected is not a String or a RegExp');
+  });
 });
 

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

@@ -278,7 +278,8 @@ describe("New HtmlReporter", function() {
           env: env,
           getContainer: getContainer,
           createElement: function() { return document.createElement.apply(document, arguments); },
-          createTextNode: function() { return document.createTextNode.apply(document, arguments); }
+          createTextNode: function() { return document.createTextNode.apply(document, arguments); },
+          addToExistingQueryString: function(key, value) { return "?foo=bar&" + key + "=" + value; }
         });
       reporter.initialize();
 
@@ -350,7 +351,7 @@ describe("New HtmlReporter", function() {
       var suiteDetail = outerSuite.childNodes[0];
       var suiteLink = suiteDetail.childNodes[0];
       expect(suiteLink.innerHTML).toEqual("A Suite");
-      expect(suiteLink.getAttribute('href')).toEqual("?spec=A%20Suite");
+      expect(suiteLink.getAttribute('href')).toEqual("?foo=bar&spec=A Suite");
 
       var specs = outerSuite.childNodes[1];
       var spec = specs.childNodes[0];
@@ -359,7 +360,7 @@ describe("New HtmlReporter", function() {
 
       var specLink = spec.childNodes[0];
       expect(specLink.innerHTML).toEqual("with a spec");
-      expect(specLink.getAttribute("href")).toEqual("?spec=A%20Suite%20with%20a%20spec");
+      expect(specLink.getAttribute("href")).toEqual("?foo=bar&spec=A Suite with a spec");
 //      expect(specLink.getAttribute("title")).toEqual("A Suite with a spec");
     });
 
@@ -532,14 +533,17 @@ describe("New HtmlReporter", function() {
         reporter.initialize();
 
         reporter.jasmineStarted({ totalSpecsDefined: 1 });
-        reporter.specDone({
+        var specStatus = {
           id: 123,
           description: "with a spec",
           fullName: "A Suite with a spec",
           status: "pending",
           passedExpectations: [],
-          failedExpectations: []
-        });
+          failedExpectations: [],
+          pendingReason: "my custom pending reason"
+        };
+        reporter.specStarted(specStatus);
+        reporter.specDone(specStatus);
         reporter.jasmineDone({});
       });
 
@@ -554,6 +558,12 @@ describe("New HtmlReporter", function() {
 
         expect(specFailure.childNodes.length).toEqual(0);
       });
+
+      it("displays the custom pending reason", function() {
+        var pendingDetails = container.querySelector(".summary .pending");
+
+        expect(pendingDetails.innerHTML).toContain("my custom pending reason");
+      });
     });
 
     describe("and some tests fail", function() {
@@ -567,7 +577,8 @@ describe("New HtmlReporter", function() {
           env: env,
           getContainer: getContainer,
           createElement: function() { return document.createElement.apply(document, arguments); },
-          createTextNode: function() { return document.createTextNode.apply(document, arguments); }
+          createTextNode: function() { return document.createTextNode.apply(document, arguments); },
+          addToExistingQueryString: function(key, value) { return "?foo=bar&" + key + "=" + value; }
         });
         reporter.initialize();
 
@@ -614,7 +625,7 @@ describe("New HtmlReporter", function() {
 
         var specLink = specDiv.childNodes[0];
         expect(specLink.getAttribute("title")).toEqual("a suite with a failing spec");
-        expect(specLink.getAttribute("href")).toEqual("?spec=a%20suite%20with%20a%20failing%20spec");
+        expect(specLink.getAttribute("href")).toEqual("?foo=bar&spec=a suite with a failing spec");
 
         var message = failure.childNodes[1].childNodes[0];
         expect(message.getAttribute("class")).toEqual("result-message");

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("Object({ foo: HTMLNode })");
   });
 
   it("should print Firefox's wrapped native objects correctly", function() {

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

@@ -1,7 +1,6 @@
 describe("QueryString", function() {
 
-  describe("#setParam", function() {
-
+  describe("#navigateWithNewParam", function() {
     it("sets the query string to include the given key/value pair", function() {
       var windowLocation = {
           search: ""
@@ -10,10 +9,40 @@ describe("QueryString", function() {
           getWindowLocation: function() { return windowLocation }
         });
 
-      queryString.setParam("foo", "bar baz");
+      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 j$.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 j$.QueryString({
+        getWindowLocation: function() { return windowLocation }
+      });
+
+      var result = queryString.fullStringWithNewParam("baz", "quux");
+
+      expect(result).toMatch(/foo=bar/);
+      expect(result).toMatch(/baz=quux/);
+    });
   });
 
   describe("#getParam", function() {