jasmine-core 2.2.0 → 2.3.0

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

@@ -22,7 +22,7 @@ describe("Any", function() {
 
     expect(any.asymmetricMatch({})).toBe(true);
   });
-  
+
   it("matches a Boolean", function() {
     var any = new j$.Any(Boolean);
 
@@ -39,8 +39,7 @@ describe("Any", function() {
   it("jasmineToString's itself", function() {
     var any = new j$.Any(Number);
 
-    expect(any.jasmineToString()).toMatch('<jasmine.any');
-    expect(any.jasmineToString()).toMatch('Number');
+    expect(any.jasmineToString()).toEqual('<jasmine.any(Number)>');
   });
 
 });

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

@@ -55,4 +55,35 @@ describe("ObjectContaining", function() {
 
     expect(containing.asymmetricMatch({})).toBe(false);
   });
+
+  it("matches defined properties", function(){
+    // IE 8 doesn't support `definePropery` on non-DOM nodes
+    if (jasmine.getEnv().ieVersion < 9) { return; }
+
+    var containing = new j$.ObjectContaining({ foo: "fooVal" });
+
+    var definedPropertyObject = {};
+    Object.defineProperty(definedPropertyObject, "foo", {
+      get: function() { return "fooVal" }
+    });
+    expect(containing.asymmetricMatch(definedPropertyObject)).toBe(true);
+  });
+
+  it("matches prototype properties", function(){
+    var containing = new j$.ObjectContaining({ foo: "fooVal" });
+
+    var prototypeObject = {foo: "fooVal"};
+    var obj;
+
+    if (Object.create) {
+      obj = Object.create(prototypeObject);
+    } else {
+      function Foo() {}
+      Foo.prototype = prototypeObject;
+      Foo.prototype.constructor = Foo;
+      obj = new Foo();
+    }
+
+    expect(containing.asymmetricMatch(obj)).toBe(true);
+  });
 });

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

@@ -612,8 +612,6 @@ describe("Env integration", function() {
       expect(calls).toEqual([
         "before",
         "first spec",
-        "after",
-        "before",
         "second spec",
         "after"
       ]);
@@ -861,6 +859,36 @@ describe("Env integration", function() {
       env.execute();
     });
 
+    it("should not use the mock clock for asynchronous timeouts", function(){
+      var env = new j$.Env(),
+        reporter = jasmine.createSpyObj('fakeReporter', [ "specDone", "jasmineDone" ]),
+        clock = env.clock;
+
+      reporter.jasmineDone.and.callFake(function() {
+        expect(reporter.specDone.calls.count()).toEqual(1);
+        expect(reporter.specDone.calls.argsFor(0)[0]).toEqual(jasmine.objectContaining({status: 'passed'}));
+      });
+
+      env.addReporter(reporter);
+      j$.DEFAULT_TIMEOUT_INTERVAL = 5;
+
+      env.beforeAll(function() {
+        clock.install();
+      });
+
+      env.afterAll(function() {
+        clock.uninstall();
+      });
+
+      env.it("spec that should not time out", function(done) {
+        clock.tick(6);
+        expect(true).toEqual(true);
+        done();
+      });
+
+      env.execute();
+    });
+
     it("should wait the specified interval before reporting an afterAll that fails to call done", function(done) {
       var env = new j$.Env(),
       reporter = jasmine.createSpyObj('fakeReport', ['jasmineDone','suiteDone']);
@@ -971,9 +999,6 @@ describe("Env integration", function() {
 
       env.addReporter({
         specDone: specDone,
-        specStarted: function() {
-          jasmine.clock().tick(1);
-        },
         jasmineDone: function() {
           expect(specDone).toHaveBeenCalledWith(jasmine.objectContaining({
             description: 'has a default message',
@@ -1033,6 +1058,10 @@ describe("Env integration", function() {
       });
 
       env.execute();
+      jasmine.clock().tick(1);
+      jasmine.clock().tick(1);
+      jasmine.clock().tick(1);
+      jasmine.clock().tick(1);
     });
   });
 
@@ -1177,7 +1206,7 @@ describe("Env integration", function() {
         totalSpecsDefined: 1
       });
 
-      expect(reporter.specDone).not.toHaveBeenCalled();
+      expect(reporter.specDone).toHaveBeenCalledWith(jasmine.objectContaining({ status: 'disabled' }));
       expect(reporter.suiteDone.calls.count()).toBe(3);
 
       done();

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

@@ -1,6 +1,5 @@
 describe("jasmine spec running", function () {
   var env;
-  var fakeTimer;
 
   beforeEach(function() {
     env = new j$.Env();
@@ -61,13 +60,17 @@ describe("jasmine spec running", function () {
     expect(bar).toEqual(0);
     expect(baz).toEqual(0);
     expect(quux).toEqual(0);
-    nested.execute(function() {
+    var assertions = function() {
       expect(foo).toEqual(1);
       expect(bar).toEqual(1);
       expect(baz).toEqual(1);
       expect(quux).toEqual(1);
       done();
-    });
+    };
+
+    env.addReporter({ jasmineDone: assertions });
+
+    env.execute();
   });
 
   it("should permit nested describes", function(done) {
@@ -289,7 +292,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(done) {
+  it('should run beforeAlls and afterAlls in the order declared when runnablesToRun is provided', function(done) {
     var actions = [],
       spec,
       spec2;
@@ -342,17 +345,13 @@ describe("jasmine spec running", function () {
         "inner beforeAll",
         "runner beforeEach",
         "inner beforeEach",
-        "it",
+        "it2",
         "inner afterEach",
         "runner afterEach",
-        "inner afterAll",
-        "runner afterAll",
 
-        "runner beforeAll",
-        "inner beforeAll",
         "runner beforeEach",
         "inner beforeEach",
-        "it2",
+        "it",
         "inner afterEach",
         "runner afterEach",
         "inner afterAll",
@@ -363,7 +362,7 @@ describe("jasmine spec running", function () {
     };
 
     env.addReporter({jasmineDone: assertions});
-    env.execute([spec.id, spec2.id]);
+    env.execute([spec2.id, spec.id]);
   });
 
   it('only runs *Alls once in a focused suite', function(done){
@@ -416,9 +415,7 @@ describe("jasmine spec running", function () {
           'beforeEach',
           'spec in fdescribe',
           'afterEach',
-          'afterAll',
 
-          'beforeAll',
           'beforeEach',
           'focused spec',
           'afterEach',
@@ -549,10 +546,14 @@ describe("jasmine spec running", function () {
         pendingSpec = env.it("I am a pending spec");
       });
 
-    suite.execute(function() {
+    var assertions = function() {
       expect(pendingSpec.status()).toBe("pending");
       done();
-    });
+    };
+
+    env.addReporter({jasmineDone: assertions});
+
+    env.execute();
   });
 
   // TODO: is this useful? It doesn't catch syntax errors
@@ -603,4 +604,96 @@ describe("jasmine spec running", function () {
     ));
 
   });
+
+  it("re-enters suites that have no *Alls", function(done) {
+    var actions = [],
+        spec1, spec2, spec3;
+
+    env.describe("top", function() {
+      spec1 = env.it("spec1", function() {
+        actions.push("spec1");
+      });
+
+      spec2 = env.it("spec2", function() {
+        actions.push("spec2");
+      });
+    });
+
+    spec3 = env.it("spec3", function() {
+      actions.push("spec3");
+    });
+
+    env.addReporter({
+      jasmineDone: function() {
+        expect(actions).toEqual(["spec2", "spec3", "spec1"]);
+        done();
+      }
+    });
+
+    env.execute([spec2.id, spec3.id, spec1.id]);
+  });
+
+  it("refuses to re-enter suites with a beforeAll", function() {
+    var actions = [],
+        spec1, spec2, spec3;
+
+    env.describe("top", function() {
+      env.beforeAll(function() {});
+
+      spec1 = env.it("spec1", function() {
+        actions.push("spec1");
+      });
+
+      spec2 = env.it("spec2", function() {
+        actions.push("spec2");
+      });
+    });
+
+    spec3 = env.it("spec3", function() {
+      actions.push("spec3");
+    });
+
+    env.addReporter({
+      jasmineDone: function() {
+        expect(actions).toEqual([]);
+        done();
+      }
+    });
+
+    expect(function() {
+      env.execute([spec2.id, spec3.id, spec1.id]);
+    }).toThrowError(/beforeAll/);
+  });
+
+  it("refuses to re-enter suites with a afterAll", function() {
+    var actions = [],
+        spec1, spec2, spec3;
+
+    env.describe("top", function() {
+      env.afterAll(function() {});
+
+      spec1 = env.it("spec1", function() {
+        actions.push("spec1");
+      });
+
+      spec2 = env.it("spec2", function() {
+        actions.push("spec2");
+      });
+    });
+
+    spec3 = env.it("spec3", function() {
+      actions.push("spec3");
+    });
+
+    env.addReporter({
+      jasmineDone: function() {
+        expect(actions).toEqual([]);
+        done();
+      }
+    });
+
+    expect(function() {
+      env.execute([spec2.id, spec3.id, spec1.id]);
+    }).toThrowError(/afterAll/);
+  });
 });

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

@@ -171,6 +171,33 @@ describe("matchersUtil", function() {
       expect(j$.matchersUtil.equals(a,b)).toBe(true);
     });
 
+    it("passes for equivalent objects from different vm contexts", function() {
+      if (typeof require !== 'function') {
+        return;
+      }
+      var vm = require('vm');
+      var sandbox = {
+        obj: null
+      };
+      vm.runInNewContext('obj = {a: 1, b: 2}', sandbox);
+
+      expect(j$.matchersUtil.equals(sandbox.obj, {a: 1, b: 2})).toBe(true);
+    });
+
+    it("passes for equivalent arrays from different vm contexts", function() {
+      if (typeof require !== 'function') {
+        return;
+      }
+
+      var vm = require('vm');
+      var sandbox = {
+        arr: null
+      };
+      vm.runInNewContext('arr = [1, 2]', sandbox);
+
+      expect(j$.matchersUtil.equals(sandbox.arr, [1, 2])).toBe(true);
+    });
+
     it("passes when Any is used", function() {
       var number = 3,
         anyNumber = new j$.Any(Number);

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

@@ -170,7 +170,6 @@ describe("toThrowError", function() {
       result;
 
     CustomError.prototype = new Error();
-    CustomError.prototype.constructor = CustomError;
 
     result = matcher.compare(fn, CustomError);
 
@@ -222,7 +221,6 @@ describe("toThrowError", function() {
       result;
 
     CustomError.prototype = new Error();
-    CustomError.prototype.constructor = CustomError;
 
     result = matcher.compare(fn, CustomError, "foo");
 

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

@@ -266,7 +266,7 @@ describe("New HtmlReporter", function() {
       timer.elapsed.and.returnValue(100);
       reporter.jasmineDone();
 
-      var duration = container.querySelector(".banner .duration");
+      var duration = container.querySelector(".alert .duration");
       expect(duration.innerHTML).toMatch(/finished in 0.1s/);
     });
 
@@ -364,6 +364,40 @@ describe("New HtmlReporter", function() {
 //      expect(specLink.getAttribute("title")).toEqual("A Suite with a spec");
     });
 
+    it("has an options menu", 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.jasmineDone({});
+
+      var trigger = container.querySelector('.run-options .trigger'),
+          payload = container.querySelector('.run-options .payload');
+
+      expect(payload.className).not.toContain('open');
+
+      trigger.onclick();
+
+      expect(payload.className).toContain('open');
+
+      trigger.onclick();
+
+      expect(payload.className).not.toContain('open');
+    });
+
     describe("UI for raising/catching exceptions", function() {
       it("should be unchecked if the env is catching", function() {
         var env = new j$.Env(),
@@ -442,6 +476,86 @@ describe("New HtmlReporter", function() {
       });
     });
 
+    describe("UI for throwing errors on expectation failures", function() {
+      it("should be unchecked if not throwing", 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.jasmineDone({});
+
+        var throwingExpectationsUI = container.querySelector(".throw");
+        expect(throwingExpectationsUI.checked).toBe(false);
+      });
+
+      it("should be checked if throwing", 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);
+            }
+          });
+
+        env.throwOnExpectationFailure(true);
+
+        reporter.initialize();
+        reporter.jasmineDone({});
+
+        var throwingExpectationsUI = container.querySelector(".throw");
+        expect(throwingExpectationsUI.checked).toBe(true);
+      });
+
+      it("should affect the query param for throw expectation failures", function() {
+        var env = new j$.Env(),
+          container = document.createElement("div"),
+          throwingExceptionHandler = jasmine.createSpy('throwingExceptions'),
+          getContainer = function() {
+            return container;
+          },
+          reporter = new j$.HtmlReporter({
+            env: env,
+            getContainer: getContainer,
+            onThrowExpectationsClick: throwingExceptionHandler,
+            createElement: function() {
+              return document.createElement.apply(document, arguments);
+            },
+            createTextNode: function() {
+              return document.createTextNode.apply(document, arguments);
+            }
+          });
+
+        reporter.initialize();
+        reporter.jasmineDone({});
+
+        var throwingExpectationsUI = container.querySelector(".throw");
+        throwingExpectationsUI.click();
+
+        expect(throwingExceptionHandler).toHaveBeenCalled();
+      });
+    });
+
     it("shows a message if no specs are run", function(){
       var env, container, reporter;
       env = new j$.Env();