jasmine-core 1.3.1 → 2.0.0.rc2

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

@@ -1,11 +1,11 @@
-describe('jasmine.jsApiReporter', function() {
-  describe('results', function () {
-    var reporter, spec1, spec2, spec3, expectedSpec1Results, expectedSpec2Results;
+xdescribe('JsApiReporter (integration specs)', function() {
+  describe('results', function() {
+    var reporter, spec1, spec2;
     var env;
     var suite, nestedSuite, nestedSpec;
 
     beforeEach(function() {
-      env = new jasmine.Env();
+      env = new j$.Env();
       env.updateInterval = 0;
 
       suite = env.describe("top-level suite", function() {
@@ -24,34 +24,24 @@ describe('jasmine.jsApiReporter', function() {
           });
         });
 
-        spec3 = env.it("spec 3", function() {
-          this.log('some debug message');
-        });
       });
 
-      reporter = new jasmine.JsApiReporter();
+      reporter = new j$.JsApiReporter({});
       env.addReporter(reporter);
 
       env.execute();
 
-      expectedSpec1Results = {
-        messages: spec1.results().getItems(),
-        result: "passed"
-      };
-      expectedSpec2Results = {
-        messages: spec2.results().getItems(),
-        result: "failed"
-      };
-    });
-
-    it('resultForSpec() should return the result for the given spec', function () {
-      expect(reporter.resultsForSpec(spec1.id)).toEqual(expectedSpec1Results);
-      expect(reporter.resultsForSpec(spec2.id)).toEqual(expectedSpec2Results);
     });
 
-    it('results() should return a hash of all results, indexed by spec id', function () {
-      expect(reporter.results()[spec1.id]).toEqual(expectedSpec1Results);
-      expect(reporter.results()[spec2.id]).toEqual(expectedSpec2Results);
+    it('results() should return a hash of all results, indexed by spec id', function() {
+      var expectedSpec1Results = {
+          result: "passed"
+        },
+        expectedSpec2Results = {
+          result: "failed"
+        };
+      expect(reporter.results()[spec1.id].result).toEqual('passed');
+      expect(reporter.results()[spec2.id].result).toEqual('failed');
     });
 
     it("should return nested suites as children of their parents", function() {
@@ -65,7 +55,6 @@ describe('jasmine.jsApiReporter', function() {
                 { id: 2, name: 'nested spec', type: 'spec', children: [ ] }
               ]
             },
-            { id: 3, name: 'spec 3', type: 'spec', children: [ ] }
           ]
         }
       ]);
@@ -76,12 +65,7 @@ describe('jasmine.jsApiReporter', function() {
         var result = reporter.results()[spec1.id];
         var summarizedResult = reporter.summarizeResult_(result);
         expect(summarizedResult.result).toEqual('passed');
-        expect(summarizedResult.messages.length).toEqual(1);
-        expect(summarizedResult.messages[0].message).toEqual(result.messages[0].message);
-        expect(summarizedResult.messages[0].passed).toBeTruthy();
-        expect(summarizedResult.messages[0].type).toEqual('expect');
-        expect(summarizedResult.messages[0].text).toBeUndefined();
-        expect(summarizedResult.messages[0].trace.stack).toBeUndefined();
+        expect(summarizedResult.messages.length).toEqual(0);
       });
 
       it("should have a stack trace for failing specs", function() {
@@ -91,13 +75,141 @@ describe('jasmine.jsApiReporter', function() {
         expect(summarizedResult.messages[0].trace.stack).toEqual(result.messages[0].trace.stack);
       });
 
-      it("should have messages for specs with messages", function() {
-        var result = reporter.results()[spec3.id];
-        var summarizedResult = reporter.summarizeResult_(result);
-        expect(summarizedResult.result).toEqual('passed');
-        expect(summarizedResult.messages[0].type).toEqual('log');
-        expect(summarizedResult.messages[0].text).toEqual('some debug message');
+    });
+  });
+});
+
+
+describe("JsApiReporter", function() {
+
+  it("knows when a full environment is started", function() {
+    var reporter = new j$.JsApiReporter({});
+
+    expect(reporter.started).toBe(false);
+    expect(reporter.finished).toBe(false);
+
+    reporter.jasmineStarted();
+
+    expect(reporter.started).toBe(true);
+    expect(reporter.finished).toBe(false);
+  });
+
+  it("knows when a full environment is done", function() {
+    var reporter = new j$.JsApiReporter({});
+
+    expect(reporter.started).toBe(false);
+    expect(reporter.finished).toBe(false);
+
+    reporter.jasmineStarted();
+    reporter.jasmineDone({});
+
+    expect(reporter.finished).toBe(true);
+  });
+
+  it("defaults to 'loaded' status", function() {
+    var reporter = new j$.JsApiReporter({});
+
+    expect(reporter.status()).toEqual('loaded');
+  });
+
+  it("reports 'started' when Jasmine has started", function() {
+    var reporter = new j$.JsApiReporter({});
+
+    reporter.jasmineStarted();
+
+    expect(reporter.status()).toEqual('started');
+  });
+
+  it("reports 'done' when Jasmine is done", function() {
+    var reporter = new j$.JsApiReporter({});
+
+    reporter.jasmineDone({});
+
+    expect(reporter.status()).toEqual('done');
+  });
+
+  it("tracks a suite", function() {
+    var reporter = new j$.JsApiReporter({});
+
+    reporter.suiteStarted({
+      id: 123,
+      description: "A suite"
+    });
+
+    var suites = reporter.suites();
+
+    expect(suites).toEqual({123: {id: 123, description: "A suite"}});
+
+    reporter.suiteDone({
+      id: 123,
+      description: "A suite",
+      status: 'passed'
+    });
+
+    expect(suites).toEqual({123: {id: 123, description: "A suite", status: 'passed'}});
+  });
+
+  describe("#specResults", function() {
+    var reporter, specResult1, specResult2;
+    beforeEach(function() {
+      reporter = new j$.JsApiReporter({});
+      specResult1 = {
+        id: 1,
+        description: "A spec"
+      };
+      specResult2 = {
+        id: 2,
+        description: "Another spec"
+      };
+
+      reporter.specDone(specResult1);
+      reporter.specDone(specResult2);
+    });
+
+    it("should return a slice of results", function() {
+      expect(reporter.specResults(0, 1)).toEqual([specResult1]);
+      expect(reporter.specResults(1, 1)).toEqual([specResult2]);
+    });
+
+    describe("when the results do not exist", function() {
+      it("should return a slice of shorter length", function() {
+        expect(reporter.specResults(0, 3)).toEqual([specResult1, specResult2]);
+        expect(reporter.specResults(2, 3)).toEqual([]);
+      });
+    });
+  });
+
+  describe("#executionTime", function() {
+    it("should start the timer when jasmine starts", function() {
+      var timerSpy = jasmine.createSpyObj('timer', ['start', 'elapsed']),
+          reporter = new j$.JsApiReporter({
+            timer: timerSpy
+          });
+
+      reporter.jasmineStarted();
+      expect(timerSpy.start).toHaveBeenCalled();
+    });
+
+    it("should return the time it took the specs to run, in ms", function() {
+      var timerSpy = jasmine.createSpyObj('timer', ['start', 'elapsed']),
+          reporter = new j$.JsApiReporter({
+            timer: timerSpy
+          });
+
+      timerSpy.elapsed.and.callReturn(1000);
+      reporter.jasmineDone();
+      expect(reporter.executionTime()).toEqual(1000);
+    });
+
+    describe("when the specs haven't finished being run", function() {
+      it("should return undefined", function() {
+        var timerSpy = jasmine.createSpyObj('timer', ['start', 'elapsed']),
+            reporter = new j$.JsApiReporter({
+              timer: timerSpy
+            });
+
+        expect(reporter.executionTime()).toBeUndefined();
       });
     });
   });
-});
+});

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

@@ -0,0 +1,64 @@
+describe("ObjectContaining", function() {
+
+  it("matches any actual to an empty object", function() {
+    var containing = new j$.ObjectContaining({});
+
+    expect(containing.jasmineMatches("foo")).toBe(true);
+  });
+
+  it("does not match an empty object actual", function() {
+    var containing = new j$.ObjectContaining("foo");
+
+    expect(function() {
+      containing.jasmineMatches({})
+    }).toThrowError(/not 'foo'/)
+  });
+
+  it("matches when the key/value pair is present in the actual", function() {
+    var containing = new j$.ObjectContaining({foo: "fooVal"});
+
+    expect(containing.jasmineMatches({foo: "fooVal", bar: "barVal"})).toBe(true);
+  });
+
+  it("does not match when the key/value pair is not present in the actual", function() {
+    var containing = new j$.ObjectContaining({foo: "fooVal"});
+
+    expect(containing.jasmineMatches({bar: "barVal", quux: "quuxVal"})).toBe(false);
+  });
+
+  it("does not match when the key is present but the value is different in the actual", function() {
+    var containing = new j$.ObjectContaining({foo: "other"});
+
+    expect(containing.jasmineMatches({foo: "fooVal", bar: "barVal"})).toBe(false);
+  });
+  
+  it("mismatchValues parameter must return array with mismatched reason", function() {
+    var containing = new j$.ObjectContaining({foo: "other"});
+    
+    var mismatchKeys = [];
+    var mismatchValues = [];
+
+    containing.jasmineMatches({foo: "fooVal", bar: "barVal"}, mismatchKeys, mismatchValues);
+    
+    expect(mismatchValues.length).toBe(1);
+    expect(mismatchValues[0]).toEqual("'foo' was 'fooVal' in actual, but was 'other' in expected.");
+  });
+
+  it("adds keys in expected but not actual to the mismatchKeys parameter", function() {
+    var containing = new j$.ObjectContaining({foo: "fooVal"});
+
+    var mismatchKeys = [];
+    var mismatchValues = [];
+
+    containing.jasmineMatches({bar: "barVal"}, mismatchKeys, mismatchValues);
+
+    expect(mismatchKeys.length).toBe(1);
+    expect(mismatchKeys[0]).toEqual("expected has key 'foo', but missing from actual.");
+  });
+
+  it("jasmineToString's itself", function() {
+    var containing = new j$.ObjectContaining({});
+
+    expect(containing.jasmineToString()).toMatch("<jasmine.objectContaining");
+  });
+});

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

@@ -1,34 +1,34 @@
-describe("jasmine.pp", function () {
+describe("j$.pp", function () {
   it("should wrap strings in single quotes", function() {
-    expect(jasmine.pp("some string")).toEqual("'some string'");
-    expect(jasmine.pp("som' string")).toEqual("'som' string'");
+    expect(j$.pp("some string")).toEqual("'some string'");
+    expect(j$.pp("som' string")).toEqual("'som' string'");
   });
 
   it("should stringify primitives properly", function() {
-    expect(jasmine.pp(true)).toEqual("true");
-    expect(jasmine.pp(false)).toEqual("false");
-    expect(jasmine.pp(null)).toEqual("null");
-    expect(jasmine.pp(jasmine.undefined)).toEqual("undefined");
-    expect(jasmine.pp(3)).toEqual("3");
-    expect(jasmine.pp(-3.14)).toEqual("-3.14");
+    expect(j$.pp(true)).toEqual("true");
+    expect(j$.pp(false)).toEqual("false");
+    expect(j$.pp(null)).toEqual("null");
+    expect(j$.pp(jasmine.undefined)).toEqual("undefined");
+    expect(j$.pp(3)).toEqual("3");
+    expect(j$.pp(-3.14)).toEqual("-3.14");
   });
 
   it("should stringify arrays properly", function() {
-    expect(jasmine.pp([1, 2])).toEqual("[ 1, 2 ]");
-    expect(jasmine.pp([1, 'foo', {}, jasmine.undefined, null])).toEqual("[ 1, 'foo', {  }, undefined, null ]");
+    expect(j$.pp([1, 2])).toEqual("[ 1, 2 ]");
+    expect(j$.pp([1, 'foo', {}, jasmine.undefined, null])).toEqual("[ 1, 'foo', {  }, undefined, null ]");
   });
 
   it("should indicate circular array references", function() {
     var array1 = [1, 2];
     var array2 = [array1];
     array1.push(array2);
-    expect(jasmine.pp(array1)).toEqual("[ 1, 2, [ <circular reference: Array> ] ]");
+    expect(j$.pp(array1)).toEqual("[ 1, 2, [ <circular reference: Array> ] ]");
   });
 
   it("should stringify objects properly", function() {
-    expect(jasmine.pp({foo: 'bar'})).toEqual("{ foo : 'bar' }");
-    expect(jasmine.pp({foo:'bar', baz:3, nullValue: null, undefinedValue: jasmine.undefined})).toEqual("{ foo : 'bar', baz : 3, nullValue : null, undefinedValue : undefined }");
-    expect(jasmine.pp({foo: function () {
+    expect(j$.pp({foo: 'bar'})).toEqual("{ foo : 'bar' }");
+    expect(j$.pp({foo:'bar', baz:3, nullValue: null, undefinedValue: jasmine.undefined})).toEqual("{ foo : 'bar', baz : 3, nullValue : null, undefinedValue : undefined }");
+    expect(j$.pp({foo: function () {
     }, bar: [1, 2, 3]})).toEqual("{ foo : Function, bar : [ 1, 2, 3 ] }");
   });
 
@@ -37,39 +37,39 @@ describe("jasmine.pp", function () {
     SomeClass.prototype.foo = "inherited foo";
     var instance = new SomeClass();
     instance.bar = "my own bar";
-    expect(jasmine.pp(instance)).toEqual("{ bar : 'my own bar' }");
+    expect(j$.pp(instance)).toEqual("{ bar : 'my own bar' }");
   });
 
-  it("should not recurse objects and arrays more deeply than jasmine.MAX_PRETTY_PRINT_DEPTH", function() {
-    var originalMaxDepth = jasmine.MAX_PRETTY_PRINT_DEPTH;
+  it("should not recurse objects and arrays more deeply than j$.MAX_PRETTY_PRINT_DEPTH", function() {
+    var originalMaxDepth = j$.MAX_PRETTY_PRINT_DEPTH;
     var nestedObject = { level1: { level2: { level3: { level4: "leaf" } } } };
     var nestedArray  = [1, [2, [3, [4, "leaf"]]]];
 
     try {
-      jasmine.MAX_PRETTY_PRINT_DEPTH = 2;
-      expect(jasmine.pp(nestedObject)).toEqual("{ level1 : { level2 : Object } }");
-      expect(jasmine.pp(nestedArray)).toEqual("[ 1, [ 2, Array ] ]");
+      j$.MAX_PRETTY_PRINT_DEPTH = 2;
+      expect(j$.pp(nestedObject)).toEqual("{ level1 : { level2 : Object } }");
+      expect(j$.pp(nestedArray)).toEqual("[ 1, [ 2, Array ] ]");
 
-      jasmine.MAX_PRETTY_PRINT_DEPTH = 3;
-      expect(jasmine.pp(nestedObject)).toEqual("{ level1 : { level2 : { level3 : Object } } }");
-      expect(jasmine.pp(nestedArray)).toEqual("[ 1, [ 2, [ 3, Array ] ] ]");
+      j$.MAX_PRETTY_PRINT_DEPTH = 3;
+      expect(j$.pp(nestedObject)).toEqual("{ level1 : { level2 : { level3 : Object } } }");
+      expect(j$.pp(nestedArray)).toEqual("[ 1, [ 2, [ 3, Array ] ] ]");
 
-      jasmine.MAX_PRETTY_PRINT_DEPTH = 4;
-      expect(jasmine.pp(nestedObject)).toEqual("{ level1 : { level2 : { level3 : { level4 : 'leaf' } } } }");
-      expect(jasmine.pp(nestedArray)).toEqual("[ 1, [ 2, [ 3, [ 4, 'leaf' ] ] ] ]");
+      j$.MAX_PRETTY_PRINT_DEPTH = 4;
+      expect(j$.pp(nestedObject)).toEqual("{ level1 : { level2 : { level3 : { level4 : 'leaf' } } } }");
+      expect(j$.pp(nestedArray)).toEqual("[ 1, [ 2, [ 3, [ 4, 'leaf' ] ] ] ]");
     } finally {
-      jasmine.MAX_PRETTY_PRINT_DEPTH = originalMaxDepth;
+      j$.MAX_PRETTY_PRINT_DEPTH = originalMaxDepth;
     }
   });
 
   it("should stringify RegExp objects properly", function() {
-    expect(jasmine.pp(/x|y|z/)).toEqual("/x|y|z/");
+    expect(j$.pp(/x|y|z/)).toEqual("/x|y|z/");
   });
 
   it("should indicate circular object references", function() {
     var sampleValue = {foo: 'hello'};
     sampleValue.nested = sampleValue;
-    expect(jasmine.pp(sampleValue)).toEqual("{ foo : 'hello', nested : <circular reference: Object> }");
+    expect(j$.pp(sampleValue)).toEqual("{ foo : 'hello', nested : <circular reference: Object> }");
   });
 
   it("should indicate getters on objects as such", function() {
@@ -81,36 +81,37 @@ describe("jasmine.pp", function () {
       });
     }
     if (sampleValue.__defineGetter__) {
-      expect(jasmine.pp(sampleValue)).toEqual("{ id : 1, calculatedValue : <getter> }");
+      expect(j$.pp(sampleValue)).toEqual("{ id : 1, calculatedValue : <getter> }");
     }
     else {
-      expect(jasmine.pp(sampleValue)).toEqual("{ id : 1 }");
+      expect(j$.pp(sampleValue)).toEqual("{ id : 1 }");
     }
   });
 
 
   it('should not do HTML escaping of strings', function() {
-    expect(jasmine.pp('some <b>html string</b> &', false)).toEqual('\'some <b>html string</b> &\'');
+    expect(j$.pp('some <b>html string</b> &', false)).toEqual('\'some <b>html string</b> &\'');
   });
 
   it("should abbreviate the global (usually window) object", function() {
-    expect(jasmine.pp(jasmine.getGlobal())).toEqual("<global>");
+    expect(j$.pp(jasmine.getGlobal())).toEqual("<global>");
   });
 
   it("should stringify Date objects properly", function() {
     var now = new Date();
-    expect(jasmine.pp(now)).toEqual("Date(" + now.toString() + ")");
+    expect(j$.pp(now)).toEqual("Date(" + now.toString() + ")");
   });
 
   it("should stringify spy objects properly", function() {
     var TestObject = {
-      someFunction: function() {
-      }
-    };
-    spyOn(TestObject, 'someFunction');
-    expect(jasmine.pp(TestObject.someFunction)).toEqual("spy on someFunction");
+          someFunction: function() {}
+        },
+        env = new j$.Env();
+
+    env.spyOn(TestObject, 'someFunction');
+    expect(j$.pp(TestObject.someFunction)).toEqual("spy on someFunction");
 
-    expect(jasmine.pp(jasmine.createSpy("something"))).toEqual("spy on something");
+    expect(j$.pp(j$.createSpy("something"))).toEqual("spy on something");
   });
 
   it("should stringify objects that implement jasmineToString", function () {
@@ -118,7 +119,7 @@ describe("jasmine.pp", function () {
       jasmineToString: function () { return "strung"; }
     };
 
-    expect(jasmine.pp(obj)).toEqual("strung");
+    expect(j$.pp(obj)).toEqual("strung");
   });
 });