evergreen 1.0.0.rc → 1.0.0

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

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

data/lib/jasmine/spec/console/ConsoleReporterSpec.js

@@ -0,0 +1,451 @@
+describe("ConsoleReporter", function() {
+  //keep these literal.  otherwise the test loses value as a test.
+  function green(str) {
+    return '\033[32m' + str + '\033[0m';
+  }
+
+  function red(str) {
+    return '\033[31m' + str + '\033[0m';
+  }
+
+  function yellow(str) {
+    return '\033[33m' + str + '\033[0m';
+  }
+
+  function prefixGreen(str) {
+    return '\033[32m' + str;
+  }
+
+  function prefixRed(str) {
+    return '\033[31m' + str;
+  }
+
+  var newline = "\n";
+
+  var passingSpec = {
+    results: function() {
+      return {
+        passed: function() {
+          return true;
+        }
+      };
+    }
+  },
+    failingSpec = {
+      results: function() {
+        return {
+          passed: function() {
+            return false;
+          }
+        };
+      }
+    },
+    skippedSpec = {
+      results: function() {
+        return {skipped: true};
+      }
+    },
+    passingRun = {
+      specs: function() {
+        return [null, null, null];
+      },
+      results: function() {
+        return {failedCount: 0, items_: [null, null, null]};
+      }
+    },
+    failingRun = {
+      specs: function() {
+        return [null, null, null];
+      },
+      results: function() {
+        return {
+          failedCount: 7, items_: [null, null, null]};
+      }
+    };
+
+  function repeatedlyInvoke(f, times) {
+    for (var i = 0; i < times; i++) f(times + 1);
+  }
+
+  function repeat(thing, times) {
+    var arr = [];
+    for (var i = 0; i < times; i++) arr.push(thing);
+    return arr;
+  }
+
+  function simulateRun(reporter, specResults, suiteResults, finalRunner, startTime, endTime) {
+    reporter.reportRunnerStarting();
+    for (var i = 0; i < specResults.length; i++) {
+      reporter.reportSpecResults(specResults[i]);
+    }
+    for (i = 0; i < suiteResults.length; i++) {
+      reporter.reportSuiteResults(suiteResults[i]);
+    }
+    reporter.runnerStartTime = startTime;
+    reporter.now = function() {
+      return endTime;
+    };
+    reporter.reportRunnerResults(finalRunner);
+  }
+
+  var reporter, out, done;
+
+  beforeEach(function() {
+    out = (function() {
+      var output = "";
+      return {
+        print:function(str) {
+          output += str;
+        },
+        getOutput:function() {
+          return output;
+        },
+        clear: function() {
+          output = "";
+        }
+      };
+    })();
+
+    done = false;
+    reporter = new jasmine.ConsoleReporter(out.print, function(runner) {
+      done = true
+    });
+  });
+
+
+  describe('Integration', function() {
+    it("prints the proper output under a pass scenario - small numbers.", function() {
+      simulateRun(reporter,
+        repeat(passingSpec, 3),
+        [],
+      {
+        specs: function() {
+          return [null, null, null];
+        },
+        results:function() {
+          return {
+            items_: [null, null, null],
+            totalCount: 7,
+            failedCount: 0
+          };
+        }
+      },
+        1000,
+        1777
+        );
+
+      var output = out.getOutput();
+      expect(output).toMatch(/^Started/);
+      expect(output).toMatch(/\.\.\./);
+      expect(output).toMatch(/3 specs, 0 failures/);
+    });
+
+    it("prints the proper output under a pass scenario.  large numbers.", function() {
+      simulateRun(reporter,
+        repeat(passingSpec, 57),
+        [],
+      {
+        specs: function() {
+          return [null, null, null];
+        },
+        results:function() {
+          return {
+            items_: [null, null, null],
+            totalCount: 7,
+            failedCount: 0
+          };
+        }
+      },
+        1000,
+        1777);
+
+      var output = out.getOutput();
+      expect(output).toMatch(/^Started/);
+      expect(output).toMatch(/\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\.\./);
+      expect(output).toMatch(/3 specs, 0 failures/);
+    });
+
+    it("prints the proper output under a failure scenario.", function() {
+      simulateRun(reporter,
+        [failingSpec, passingSpec, failingSpec],
+        [
+          {description:"The oven",
+            results:function() {
+              return {
+                items_:[
+                  {failedCount:2,
+                    description:"heats up",
+                    items_:[
+                      {trace:{stack:"stack trace one\n  second line"}},
+                      {trace:{stack:"stack trace two"}}
+                    ]}
+                ]
+              };
+            }},
+          {description:"The washing machine",
+            results:function() {
+              return {
+                items_:[
+                  {failedCount:2,
+                    description:"washes clothes",
+                    items_:[
+                      {trace:{stack:"stack trace one"}}
+                    ]}
+                ]
+              };
+            }}
+        ],
+      {
+        specs: function() {
+          return [null, null, null];
+        },
+        results:function() {
+          return {
+            items_: [null, null, null],
+            totalCount: 7,
+            failedCount: 2
+          };
+        }
+      },
+        1000,
+        1777);
+
+      var output = out.getOutput();
+      expect(output).toMatch(/^Started/);
+      expect(output).toMatch(/F\.F/);
+      expect(output).toMatch(/The oven heats up\n  stack trace one\n    second line\n  stack trace two/);
+      expect(output).toMatch(/The washing machine washes clothes\n  stack trace one/);
+      expect(output).toMatch(/3 specs, 2 failures/);
+    });
+  });
+
+  describe('When a Jasmine environment executes', function() {
+    beforeEach(function() {
+      reporter.reportRunnerStarting();
+    });
+
+    it("should print 'Started' to the console", function() {
+      expect(out.getOutput()).toEqual("Started" + newline);
+    });
+
+    describe('when a spec reports', function() {
+      beforeEach(function() {
+        out.clear();
+      });
+
+      it("prints a green dot if the spec passes", function() {
+        reporter.reportSpecResults(passingSpec);
+
+        expect(out.getOutput()).toMatch(/\./);
+      });
+
+      it("prints a red dot if the spec fails", function() {
+        reporter.reportSpecResults(failingSpec);
+
+        expect(out.getOutput()).toMatch(/F/);
+      });
+
+      it("prints a yellow star if the spec was skipped", function() {
+        reporter.reportSpecResults(skippedSpec);
+
+        expect(out.getOutput()).toMatch(/\*/);
+      });
+    });
+
+    describe('when a suite reports', function() {
+      var emptyResults;
+      beforeEach(function() {
+        emptyResults = function() {
+          return {
+            items_:[]
+          };
+        };
+      });
+
+      it("remembers suite results", function() {
+        reporter.reportSuiteResults({description: "Oven", results: emptyResults});
+        reporter.reportSuiteResults({description: "Mixer", results: emptyResults});
+
+        expect(reporter.suiteResults[0].description).toEqual('Oven');
+        expect(reporter.suiteResults[1].description).toEqual('Mixer');
+      });
+
+      it("creates a description out of the current suite and any parent suites", function() {
+        var grandparentSuite = {
+          description: "My house",
+          results: emptyResults
+        };
+        var parentSuite = {
+          description: "kitchen",
+          parentSuite: grandparentSuite,
+          results: emptyResults
+        };
+        reporter.reportSuiteResults({ description: "oven", parentSuite: parentSuite, results: emptyResults });
+
+        expect(reporter.suiteResults[0].description).toEqual("My house kitchen oven");
+      });
+
+      it("gathers failing spec results from the suite - the spec must have a description.", function() {
+        reporter.reportSuiteResults({description:"Oven",
+          results: function() {
+            return {
+              items_:[
+                { failedCount: 0, description: "specOne" },
+                { failedCount: 99, description: "specTwo" },
+                { failedCount: 0, description: "specThree" },
+                { failedCount: 88, description: "specFour" },
+                { failedCount: 3 }
+              ]
+            };
+          }});
+
+        expect(reporter.suiteResults[0].failedSpecResults).
+          toEqual([
+          { failedCount: 99, description: "specTwo" },
+          { failedCount: 88, description: "specFour" }
+        ]);
+      });
+
+    });
+
+    describe('and finishes', function() {
+
+      describe('when reporting spec failure information', function() {
+
+        it("prints suite and spec descriptions together as a sentence", function() {
+          reporter.suiteResults = [
+            {description:"The oven", failedSpecResults:[
+              {description:"heats up", items_:[]},
+              {description:"cleans itself", items_:[]}
+            ]},
+            {description:"The mixer", failedSpecResults:[
+              {description:"blends things together", items_:[]}
+            ]}
+          ];
+
+          reporter.reportRunnerResults(failingRun);
+
+          expect(out.getOutput()).toContain("The oven heats up");
+          expect(out.getOutput()).toContain("The oven cleans itself");
+          expect(out.getOutput()).toContain("The mixer blends things together");
+        });
+
+        it("prints stack trace of spec failure", function() {
+          reporter.suiteResults = [
+            {description:"The oven", failedSpecResults:[
+              {description:"heats up",
+                items_:[
+                  {trace:{stack:"stack trace one"}},
+                  {trace:{stack:"stack trace two"}}
+                ]}
+            ]}
+          ];
+
+          reporter.reportRunnerResults(failingRun);
+
+          expect(out.getOutput()).toContain("The oven heats up");
+          expect(out.getOutput()).toContain("stack trace one");
+          expect(out.getOutput()).toContain("stack trace two");
+        });
+
+      });
+
+      describe('when reporting the execution time', function() {
+
+        it("prints the full finished message", function() {
+          reporter.now = function() {
+            return 1000;
+          };
+          reporter.reportRunnerStarting();
+          reporter.now = function() {
+            return 1777;
+          };
+          reporter.reportRunnerResults(failingRun);
+          expect(out.getOutput()).toContain("Finished in 0.777 seconds");
+        });
+
+        it("prints round time numbers correctly", function() {
+          function run(startTime, endTime) {
+            out.clear();
+            reporter.runnerStartTime = startTime;
+            reporter.now = function() {
+              return endTime;
+            };
+            reporter.reportRunnerResults(passingRun);
+          }
+
+          run(1000, 11000);
+          expect(out.getOutput()).toContain("10 seconds");
+
+          run(1000, 2000);
+          expect(out.getOutput()).toContain("1 seconds");
+
+          run(1000, 1100);
+          expect(out.getOutput()).toContain("0.1 seconds");
+
+          run(1000, 1010);
+          expect(out.getOutput()).toContain("0.01 seconds");
+
+          run(1000, 1001);
+          expect(out.getOutput()).toContain("0.001 seconds");
+        });
+      });
+
+      describe("when reporting the results summary", function() {
+        it("prints statistics in green if there were no failures", function() {
+          reporter.reportRunnerResults({
+            specs: function() {
+              return [null, null, null];
+            },
+            results:function() {
+              return {items_: [null, null, null], totalCount: 7, failedCount: 0};
+            }
+          });
+          expect(out.getOutput()).
+            toContain("3 specs, 0 failures");
+        });
+
+        it("prints statistics in red if there was a failure", function() {
+          reporter.reportRunnerResults({
+            specs: function() {
+              return [null, null, null];
+            },
+            results:function() {
+              return {items_: [null, null, null], totalCount: 7, failedCount: 3};
+            }
+          });
+          expect(out.getOutput()).
+            toContain("3 specs, 3 failures");
+        });
+
+        it("handles pluralization with 1's ones appropriately", function() {
+          reporter.reportRunnerResults({
+            specs: function() {
+              return [null];
+            },
+            results:function() {
+              return {items_: [null], totalCount: 1, failedCount: 1};
+            }
+          });
+          expect(out.getOutput()).
+            toContain("1 spec, 1 failure");
+        });
+      });
+
+      describe("done callback", function() {
+        it("calls back when done", function() {
+          expect(done).toBeFalsy();
+          reporter.reportRunnerResults({
+            specs: function() {
+              return [null, null, null];
+            },
+            results:function() {
+              return {items_: [null, null, null], totalCount: 7, failedCount: 0};
+            }
+          });
+          expect(done).toBeTruthy();
+        });
+      });
+    });
+  });
+});