evergreen 1.0.0 → 1.0.1

data/lib/jasmine/lib/jasmine-core/version.rb

@@ -1,6 +1,6 @@
 module Jasmine
   module Core
-    VERSION = "1.1.0"
+    VERSION = "1.2.0"
   end
 end
 

data/lib/jasmine/spec/core/MatchersSpec.js

@@ -352,6 +352,33 @@ describe("jasmine.Matchers", function() {
     }]).toEqual(["a", jasmine.any(Function)])).toPass();
   });
 
+  describe("toEqual with an object implementing jasmineMatches", function () {
+    var matcher;
+    beforeEach(function () {
+      matcher = {
+        jasmineMatches: jasmine.createSpy("jasmineMatches")
+      };
+    });
+
+    describe("on the left side", function () {
+      it("uses the jasmineMatches function", function () {
+        matcher.jasmineMatches.andReturn(false);
+        expect(match(matcher).toEqual("foo")).toFail();
+        matcher.jasmineMatches.andReturn(true);
+        expect(match(matcher).toEqual("foo")).toPass();
+      });
+    });
+
+    describe("on the right side", function () {
+      it("uses the jasmineMatches function", function () {
+        matcher.jasmineMatches.andReturn(false);
+        expect(match("foo").toEqual(matcher)).toFail();
+        matcher.jasmineMatches.andReturn(true);
+        expect(match("foo").toEqual(matcher)).toPass();
+      });
+    });
+  });
+
   it("toEqual handles circular objects ok", function() {
     expect(match({foo: "bar", baz: jasmine.undefined}).toEqual({foo: "bar", baz: jasmine.undefined})).toPass();
     expect(match({foo:['bar','baz','quux']}).toEqual({foo:['bar','baz','quux']})).toPass();
@@ -830,6 +857,252 @@ describe("jasmine.Matchers", function() {
     });
   });
 
+  describe("ObjectContaining", function () {
+    describe("with an empty object", function () {
+      var containing;
+      beforeEach(function () {
+        containing = new jasmine.Matchers.ObjectContaining({});
+      });
+      it("matches everything", function () {
+         expect(containing.jasmineMatches("foo", [], [])).toBe(true);
+      });
+
+      it("says it didn't expect to contain anything", function () {
+        expect(containing.jasmineToString()).toEqual("<jasmine.objectContaining({  })>");
+      });
+    });
+
+    describe("with an object with items in it", function () {
+      var containing, mismatchKeys, mismatchValues;
+      beforeEach(function () {
+        mismatchKeys = [];
+        mismatchValues = [];
+        containing = new jasmine.Matchers.ObjectContaining({foo: "fooVal", bar: "barVal"});
+      });
+
+      it("doesn't match an empty object", function () {
+        expect(containing.jasmineMatches({}, mismatchKeys, mismatchValues)).toBe(false);
+      });
+
+      it("doesn't match an object with none of the specified options", function () {
+        expect(containing.jasmineMatches({baz:"stuff"}, mismatchKeys, mismatchValues)).toBe(false);
+      });
+
+      it("adds a message for each missing key", function () {
+        containing.jasmineMatches({foo: "fooVal"}, mismatchKeys, mismatchValues);
+        expect(mismatchKeys.length).toEqual(1);
+      });
+
+      it("doesn't match an object when the values are different", function () {
+        expect(containing.jasmineMatches({foo:"notFoo", bar:"notBar"}, mismatchKeys, mismatchValues)).toBe(false);
+      });
+
+      it("adds a message when values don't match", function () {
+        containing.jasmineMatches({foo: "fooVal", bar: "notBar"}, mismatchKeys, mismatchValues);
+        expect(mismatchValues.length).toEqual(1);
+      });
+
+      it("doesn't match an object with only one of the values matching", function () {
+        expect(containing.jasmineMatches({foo:"notFoo", bar:"barVal"}, mismatchKeys, mismatchValues)).toBe(false);
+      });
+
+      it("matches when all the values are the same", function () {
+        expect(containing.jasmineMatches({foo: "fooVal", bar: "barVal"}, mismatchKeys, mismatchValues)).toBe(true);
+      });
+
+      it("matches when there are additional values", function () {
+        expect(containing.jasmineMatches({foo: "fooVal", bar: "barVal", baz: "bazVal"}, mismatchKeys, mismatchValues)).toBe(true);
+      });
+
+      it("doesn't modify missingKeys or missingValues when match is successful", function () {
+        containing.jasmineMatches({foo: "fooVal", bar: "barVal"}, mismatchKeys, mismatchValues);
+        expect(mismatchKeys.length).toEqual(0);
+        expect(mismatchValues.length).toEqual(0);
+      });
+
+      it("says what it expects to contain", function () {
+        expect(containing.jasmineToString()).toEqual("<jasmine.objectContaining(" + jasmine.pp({foo:"fooVal", bar:"barVal"}) + ")>");
+      });
+    });
+
+    describe("in real life", function () {
+      var method;
+      beforeEach(function () {
+        method = jasmine.createSpy("method");
+        method({a:"b", c:"d"});
+      });
+      it("works correctly for positive matches", function () {
+        expect(method).toHaveBeenCalledWith(jasmine.objectContaining({a:"b"}));
+      });
+
+      it("works correctly for negative matches", function () {
+        expect(method).not.toHaveBeenCalledWith(jasmine.objectContaining({z:"x"}));
+      });
+    });
+  });
+
+  describe("Matchers.Any", function () {
+    var any;
+    describe(".jasmineToString", function () {
+      describe("with Object", function () {
+        it("says it's looking for an object", function () {
+          any = jasmine.any(Object);
+          expect(any.jasmineToString().replace(/\n/g, "")).toMatch(/<jasmine\.any\(function Object.*\)>/);
+        });
+      });
+
+      describe("with Function", function () {
+        it("says it's looking for a function", function () {
+          any = jasmine.any(Function);
+          expect(any.jasmineToString().replace(/\n/g, "")).toMatch(/<jasmine\.any\(function Function.*\)>/);
+        });
+      });
+
+      describe("with String", function () {
+        it("says it's looking for a string", function () {
+          any = jasmine.any(String);
+          expect(any.jasmineToString().replace(/\n/g, "")).toMatch(/<jasmine\.any\(function String.*\)>/);
+        });
+      });
+
+      describe("with Number", function () {
+        it("says it's looking for a number", function () {
+          any = jasmine.any(Number);
+          expect(any.jasmineToString().replace(/\n/g, "")).toMatch(/<jasmine\.any\(function Number.*\)>/);
+        });
+      });
+
+      describe("with some other defined 'class'", function () {
+        it("says it's looking for an object", function () {
+          function MyClass () {}
+          any = jasmine.any(MyClass);
+          expect(any.jasmineToString().replace("\n", "")).toMatch(/<jasmine\.any\(function MyClass.*\)>/);
+        });
+      });
+    });
+
+    describe(".jasmineMatches", function () {
+      describe("with Object", function () {
+        beforeEach(function () {
+          any = jasmine.any(Object);
+        });
+
+        it("matches an empty object", function () {
+          expect(any.jasmineMatches({})).toEqual(true);
+        });
+
+        it("matches a newed up object", function () {
+          expect(any.jasmineMatches(new Object())).toEqual(true);
+        });
+
+        it("doesn't match a string", function () {
+          expect(any.jasmineMatches("")).toEqual(false);
+        });
+
+        it("doesn't match a number", function () {
+          expect(any.jasmineMatches(123)).toEqual(false);
+        });
+
+        it("doesn't match a function", function () {
+          expect(any.jasmineMatches(function () {})).toEqual(false);
+        });
+      });
+
+      describe("with Function", function () {
+        beforeEach(function () {
+          any = jasmine.any(Function);
+        });
+
+        it("doesn't match an object", function () {
+          expect(any.jasmineMatches({})).toEqual(false);
+        });
+
+        it("doesn't match a string", function () {
+          expect(any.jasmineMatches("")).toEqual(false);
+        });
+
+        it("doesn't match a number", function () {
+          expect(any.jasmineMatches(123)).toEqual(false);
+        });
+
+        it("matches a function", function () {
+          expect(any.jasmineMatches(function () {})).toEqual(true);
+        });
+      });
+
+      describe("with Number", function () {
+        beforeEach(function () {
+          any = jasmine.any(Number);
+        });
+
+        it("doesn't match an object", function () {
+          expect(any.jasmineMatches({})).toEqual(false);
+        });
+
+        it("doesn't match a string", function () {
+          expect(any.jasmineMatches("")).toEqual(false);
+        });
+
+        it("matches a number", function () {
+          expect(any.jasmineMatches(123)).toEqual(true);
+        });
+
+        it("doesn't match a function", function () {
+          expect(any.jasmineMatches(function () {})).toEqual(false);
+        });
+      });
+
+      describe("with String", function () {
+        beforeEach(function () {
+          any = jasmine.any(String);
+        });
+
+        it("doesn't match an object", function () {
+          expect(any.jasmineMatches({})).toEqual(false);
+        });
+
+        it("matches a string", function () {
+          expect(any.jasmineMatches("")).toEqual(true);
+        });
+
+        it("doesn't match a number", function () {
+          expect(any.jasmineMatches(123)).toEqual(false);
+        });
+
+        it("doesn't match a function", function () {
+          expect(any.jasmineMatches(function () {})).toEqual(false);
+        });
+      });
+
+      describe("with some defined 'class'", function () {
+        function MyClass () {}
+        beforeEach(function () {
+          any = jasmine.any(MyClass);
+        });
+
+        it("doesn't match an object", function () {
+          expect(any.jasmineMatches({})).toEqual(false);
+        });
+
+        it("doesn't match a string", function () {
+          expect(any.jasmineMatches("")).toEqual(false);
+        });
+
+        it("doesn't match a number", function () {
+          expect(any.jasmineMatches(123)).toEqual(false);
+        });
+
+        it("doesn't match a function", function () {
+          expect(any.jasmineMatches(function () {})).toEqual(false);
+        });
+
+        it("matches an instance of the defined class", function () {
+          expect(any.jasmineMatches(new MyClass())).toEqual(true);
+        });
+      });
+    });
+  });
+
   describe("all matchers", function() {
     it("should return null, for future-proofing, since we might eventually allow matcher chaining", function() {
       expect(match(true).toBe(true)).toBeUndefined();

data/lib/jasmine/spec/core/PrettyPrintSpec.js

@@ -83,5 +83,12 @@ describe("jasmine.pp", function () {
     expect(jasmine.pp(jasmine.createSpy("something"))).toEqual("spy on something");
   });
 
+  it("should stringify objects that implement jasmineToString", function () {
+    var obj = {
+      jasmineToString: function () { return "strung"; }
+    };
+
+    expect(jasmine.pp(obj)).toEqual("strung");
+  });
 });
 

data/lib/jasmine/spec/html/HTMLReporterSpec.js

@@ -0,0 +1,209 @@
+describe("HtmlReporter", function() {
+  var env;
+  var htmlReporter;
+  var body;
+  var fakeDocument;
+
+  beforeEach(function() {
+    env = new jasmine.Env();
+    env.updateInterval = 0;
+
+    body = document.createElement("body");
+    fakeDocument = { body: body, location: { search: "" } };
+    htmlReporter = new jasmine.HtmlReporter(fakeDocument);
+  });
+
+  function fakeSpec(name) {
+    return {
+      getFullName: function() {
+        return name;
+      }
+    };
+  }
+
+  function findElements(divs, withClass) {
+    var els = [];
+    for (var i = 0; i < divs.length; i++) {
+      if (divs[i].className == withClass) els.push(divs[i]);
+    }
+    return els;
+  }
+
+  function findElement(divs, withClass) {
+    var els = findElements(divs, withClass);
+    if (els.length > 0) {
+      return els[0];
+    }
+    throw new Error("couldn't find div with class " + withClass);
+  }
+
+  it("should run only specs beginning with spec parameter", function() {
+    fakeDocument.location.search = "?spec=run%20this";
+    expect(htmlReporter.specFilter(fakeSpec("run this"))).toBeTruthy();
+    expect(htmlReporter.specFilter(fakeSpec("not the right spec"))).toBeFalsy();
+    expect(htmlReporter.specFilter(fakeSpec("not run this"))).toBeFalsy();
+  });
+
+  describe("running without any specs", function() {
+    var runner;
+    beforeEach(function() {
+      runner = env.currentRunner();
+      env.addReporter(htmlReporter);
+    });
+
+    it("should not error", function() {
+      var exec = function() {
+        runner.execute();
+      };
+      expect(exec).not.toThrow();
+    });
+  });
+
+  describe('Matcher reporting', function() {
+    var getResultMessageDiv = function(body) {
+      var divs = body.getElementsByTagName("div");
+      for (var i = 0; i < divs.length; i++) {
+        if (divs[i].className.match(/resultMessage/)) {
+          return divs[i];
+        }
+      }
+    };
+
+    var runner, spec, fakeTimer;
+    beforeEach(function() {
+      fakeTimer = new jasmine.FakeTimer();
+      env.setTimeout = fakeTimer.setTimeout;
+      env.clearTimeout = fakeTimer.clearTimeout;
+      env.setInterval = fakeTimer.setInterval;
+      env.clearInterval = fakeTimer.clearInterval;
+      runner = env.currentRunner();
+      var suite = new jasmine.Suite(env, 'some suite');
+      runner.add(suite);
+      spec = new jasmine.Spec(env, suite, 'some spec');
+      suite.add(spec);
+      fakeDocument.location.search = "?";
+      env.addReporter(htmlReporter);
+    });
+
+    describe('toContain', function() {
+      it('should show actual and expected', function() {
+        spec.runs(function() {
+          this.expect('foo').toContain('bar');
+        });
+        runner.execute();
+        fakeTimer.tick(0);
+
+        var resultEl = getResultMessageDiv(body);
+        expect(resultEl.innerHTML).toMatch(/foo/);
+        expect(resultEl.innerHTML).toMatch(/bar/);
+      });
+    });
+  });
+
+  describe("failure messages (integration)", function() {
+    var spec, results, expectationResult;
+
+    it("should add the failure message to the DOM (non-toEquals matchers)", function() {
+      env.describe("suite", function() {
+        env.it("will have log messages", function() {
+          this.expect('a').toBeNull();
+        });
+      });
+
+      env.addReporter(htmlReporter);
+      env.execute();
+
+      var divs = body.getElementsByTagName("div");
+      var errorDiv = findElement(divs, 'resultMessage fail');
+      expect(errorDiv.innerHTML).toMatch(/Expected 'a' to be null/);
+    });
+
+    it("should add the failure message to the DOM (non-toEquals matchers) html escaping", function() {
+      env.describe("suite", function() {
+        env.it("will have log messages", function() {
+          this.expect('1 < 2').toBeNull();
+        });
+      });
+
+      env.addReporter(htmlReporter);
+      env.execute();
+
+      var divs = body.getElementsByTagName("div");
+      var errorDiv = findElement(divs, 'resultMessage fail');
+      expect(errorDiv.innerHTML).toMatch(/Expected '1 &lt; 2' to be null/);
+    });
+  });
+
+  describe("log messages", function() {
+    it("should appear in the report of a failed spec", function() {
+      env.describe("suite", function() {
+        env.it("will have log messages", function() {
+          this.log("this is a", "multipart log message");
+          this.expect(true).toBeFalsy();
+        });
+      });
+
+      env.addReporter(htmlReporter);
+      env.execute();
+
+      var divs = body.getElementsByTagName("div");
+      var errorDiv = findElement(divs, 'specDetail failed');
+      expect(errorDiv.innerHTML).toMatch("this is a multipart log message");
+    });
+
+    xit("should work on IE without console.log.apply", function() {
+    });
+  });
+
+  describe("duplicate example names", function() {
+    it("should report failures correctly", function() {
+      var suite1 = env.describe("suite", function() {
+        env.it("will have log messages", function() {
+          this.log("this one fails!");
+          this.expect(true).toBeFalsy();
+        });
+      });
+
+      var suite2 = env.describe("suite", function() {
+        env.it("will have log messages", function() {
+          this.log("this one passes!");
+          this.expect(true).toBeTruthy();
+        });
+      });
+
+      env.addReporter(htmlReporter);
+      env.execute();
+
+      var divs = body.getElementsByTagName("div");
+      var failedSpecDiv = findElement(divs, 'specDetail failed');
+      expect(failedSpecDiv.className).toEqual('specDetail failed');
+      expect(failedSpecDiv.innerHTML).toContain("this one fails!");
+      expect(failedSpecDiv.innerHTML).not.toContain("this one passes!");
+    });
+  });
+
+  describe('#reportSpecStarting', function() {
+    beforeEach(function() {
+      env.describe("suite 1", function() {
+        env.it("spec 1", function() {
+        });
+      });
+      spyOn(htmlReporter, 'log').andCallThrough();
+    });
+
+    it('DOES NOT log running specs by default', function() {
+      env.addReporter(htmlReporter);
+      env.execute();
+
+      expect(htmlReporter.log).not.toHaveBeenCalled();
+    });
+
+    it('logs running specs when log_running_specs is true', function() {
+      htmlReporter.logRunningSpecs = true;
+      env.addReporter(htmlReporter);
+      env.execute();
+
+      expect(htmlReporter.log).toHaveBeenCalledWith('>> Jasmine Running suite 1 spec 1...');
+    });
+  });
+});