evergreen 0.3.0 → 0.4.0

data/lib/jasmine/src/Spec.js

@@ -73,14 +73,46 @@ jasmine.Spec.prototype.expect = function(actual) {
   return positive;
 };
 
+/**
+ * Waits a fixed time period before moving to the next block.
+ *
+ * @deprecated Use waitsFor() instead
+ * @param {Number} timeout milliseconds to wait
+ */
 jasmine.Spec.prototype.waits = function(timeout) {
   var waitsFunc = new jasmine.WaitsBlock(this.env, timeout, this);
   this.addToQueue(waitsFunc);
   return this;
 };
 
-jasmine.Spec.prototype.waitsFor = function(timeout, latchFunction, timeoutMessage) {
-  var waitsForFunc = new jasmine.WaitsForBlock(this.env, timeout, latchFunction, timeoutMessage, this);
+/**
+ * Waits for the latchFunction to return true before proceeding to the next block.
+ *
+ * @param {Function} latchFunction
+ * @param {String} optional_timeoutMessage
+ * @param {Number} optional_timeout
+ */
+jasmine.Spec.prototype.waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) {
+  var latchFunction_ = null;
+  var optional_timeoutMessage_ = null;
+  var optional_timeout_ = null;
+
+  for (var i = 0; i < arguments.length; i++) {
+    var arg = arguments[i];
+    switch (typeof arg) {
+      case 'function':
+        latchFunction_ = arg;
+        break;
+      case 'string':
+        optional_timeoutMessage_ = arg;
+        break;
+      case 'number':
+        optional_timeout_ = arg;
+        break;
+    }
+  }
+
+  var waitsForFunc = new jasmine.WaitsForBlock(this.env, optional_timeout_, latchFunction_, optional_timeoutMessage_, this);
   this.addToQueue(waitsForFunc);
   return this;
 };

data/lib/jasmine/src/WaitsForBlock.js

@@ -1,37 +1,52 @@
+/**
+ * A block which waits for some condition to become true, with timeout.
+ *
+ * @constructor
+ * @extends jasmine.Block
+ * @param {jasmine.Env} env The Jasmine environment.
+ * @param {Number} timeout The maximum time in milliseconds to wait for the condition to become true.
+ * @param {Function} latchFunction A function which returns true when the desired condition has been met.
+ * @param {String} message The message to display if the desired condition hasn't been met within the given time period.
+ * @param {jasmine.Spec} spec The Jasmine spec.
+ */
 jasmine.WaitsForBlock = function(env, timeout, latchFunction, message, spec) {
-  this.timeout = timeout;
+  this.timeout = timeout || env.defaultTimeoutInterval;
   this.latchFunction = latchFunction;
   this.message = message;
   this.totalTimeSpentWaitingForLatch = 0;
   jasmine.Block.call(this, env, null, spec);
 };
-
 jasmine.util.inherit(jasmine.WaitsForBlock, jasmine.Block);
 
-jasmine.WaitsForBlock.TIMEOUT_INCREMENT = 100;
+jasmine.WaitsForBlock.TIMEOUT_INCREMENT = 10;
 
-jasmine.WaitsForBlock.prototype.execute = function (onComplete) {
-  var self = this;
-  self.env.reporter.log('>> Jasmine waiting for ' + (self.message || 'something to happen'));
+jasmine.WaitsForBlock.prototype.execute = function(onComplete) {
+  this.env.reporter.log('>> Jasmine waiting for ' + (this.message || 'something to happen'));
   var latchFunctionResult;
   try {
-    latchFunctionResult = self.latchFunction.apply(self.spec);
+    latchFunctionResult = this.latchFunction.apply(this.spec);
   } catch (e) {
-    self.spec.fail(e);
+    this.spec.fail(e);
     onComplete();
     return;
   }
 
   if (latchFunctionResult) {
     onComplete();
-  } else if (self.totalTimeSpentWaitingForLatch >= self.timeout) {
-    var message = 'timed out after ' + self.timeout + ' msec waiting for ' + (self.message || 'something to happen');
-    self.spec.fail({
+  } else if (this.totalTimeSpentWaitingForLatch >= this.timeout) {
+    var message = 'timed out after ' + this.timeout + ' msec waiting for ' + (this.message || 'something to happen');
+    this.spec.fail({
       name: 'timeout',
       message: message
     });
+
+    this.abort = true;
+    onComplete();
   } else {
-    self.totalTimeSpentWaitingForLatch += jasmine.WaitsForBlock.TIMEOUT_INCREMENT;
-    self.env.setTimeout(function () { self.execute(onComplete); }, jasmine.WaitsForBlock.TIMEOUT_INCREMENT);
+    this.totalTimeSpentWaitingForLatch += jasmine.WaitsForBlock.TIMEOUT_INCREMENT;
+    var self = this;
+    this.env.setTimeout(function() {
+      self.execute(onComplete);
+    }, jasmine.WaitsForBlock.TIMEOUT_INCREMENT);
   }
 };

data/lib/jasmine/src/base.js

@@ -21,11 +21,16 @@ jasmine.unimplementedMethod_ = function() {
 jasmine.undefined = jasmine.___undefined___;
 
 /**
- * Default interval for event loop yields. Small values here may result in slow test running. Zero means no updates until all tests have completed.
+ * Default interval in milliseconds for event loop yields (e.g. to allow network activity or to refresh the screen with the HTML-based runner). Small values here may result in slow test running. Zero means no updates until all tests have completed.
  *
  */
 jasmine.DEFAULT_UPDATE_INTERVAL = 250;
 
+/**
+ * Default timeout interval in milliseconds for waitsFor() blocks.
+ */
+jasmine.DEFAULT_TIMEOUT_INTERVAL = 5000;
+
 jasmine.getGlobal = function() {
   function getGlobal() {
     return this;
@@ -490,22 +495,24 @@ var runs = function(func) {
 };
 
 /**
- * Waits for a timeout before moving to the next runs()-defined block.
- * @param {Number} timeout
+ * Waits a fixed time period before moving to the next block.
+ *
+ * @deprecated Use waitsFor() instead
+ * @param {Number} timeout milliseconds to wait
  */
 var waits = function(timeout) {
   jasmine.getEnv().currentSpec.waits(timeout);
 };
 
 /**
- * Waits for the latchFunction to return true before proceeding to the next runs()-defined block.
+ * Waits for the latchFunction to return true before proceeding to the next block.
  *
- * @param {Number} timeout
  * @param {Function} latchFunction
- * @param {String} message
+ * @param {String} optional_timeoutMessage
+ * @param {Number} optional_timeout
  */
-var waitsFor = function(timeout, latchFunction, message) {
-  jasmine.getEnv().currentSpec.waitsFor(timeout, latchFunction, message);
+var waitsFor = function(latchFunction, optional_timeoutMessage, optional_timeout) {
+  jasmine.getEnv().currentSpec.waitsFor.apply(jasmine.getEnv().currentSpec, arguments);
 };
 
 /**

data/lib/jasmine/src/html/TrivialReporter.js

@@ -34,7 +34,7 @@ jasmine.TrivialReporter.prototype.reportRunnerStarting = function(runner) {
   this.outerDiv = this.createDom('div', { className: 'jasmine_reporter' },
       this.createDom('div', { className: 'banner' },
         this.createDom('div', { className: 'logo' },
-            "Jasmine",
+            this.createDom('a', { href: 'http://pivotal.github.com/jasmine/', target: "_blank" }, "Jasmine"),
             this.createDom('span', { className: 'version' }, runner.env.versionString())),
         this.createDom('div', { className: 'options' },
             "Show ",
@@ -70,16 +70,16 @@ jasmine.TrivialReporter.prototype.reportRunnerStarting = function(runner) {
   this.startedAt = new Date();
 
   var self = this;
-  showPassed.onchange = function(evt) {
-    if (evt.target.checked) {
+  showPassed.onclick = function(evt) {
+    if (showPassed.checked) {
       self.outerDiv.className += ' show-passed';
     } else {
       self.outerDiv.className = self.outerDiv.className.replace(/ show-passed/, '');
     }
   };
 
-  showSkipped.onchange = function(evt) {
-    if (evt.target.checked) {
+  showSkipped.onclick = function(evt) {
+    if (showSkipped.checked) {
       self.outerDiv.className += ' show-skipped';
     } else {
       self.outerDiv.className = self.outerDiv.className.replace(/ show-skipped/, '');
@@ -162,7 +162,13 @@ jasmine.TrivialReporter.prototype.reportSpecResults = function(spec) {
 
 jasmine.TrivialReporter.prototype.log = function() {
   var console = jasmine.getGlobal().console;
-  if (console && console.log) console.log.apply(console, arguments);
+  if (console && console.log) {
+    if (console.log.apply) {
+      console.log.apply(console, arguments);
+    } else {
+      console.log(arguments); // ie fix: console.log.apply doesn't exist on ie
+    }
+  }
 };
 
 jasmine.TrivialReporter.prototype.getLocation = function() {

data/lib/jasmine/src/version.json

@@ -1,5 +1,5 @@
 {
-  "major": 0,
-  "minor": 11,
+  "major": 1,
+  "minor": 0,
   "build": 1
 }

data/lib/tasks/evergreen.rake

@@ -1,7 +1,7 @@
 namespace :spec do
   desc "Run JavaScript specs via Evergreen"
   task :javascripts do
-    result = Evergreen::Runner.run(Rails.root)
+    result = Evergreen::Suite.new(Rails.root).run
     Kernel.exit(1) unless result
   end
 end

data/spec/meta_spec.rb

@@ -1,8 +1,8 @@
 require 'spec_helper'
 
 describe Evergreen::Runner do
-  subject { Evergreen::Runner.new(spec) }
-  let(:spec) { Evergreen::Spec.new(root, template) }
+  let(:suite) { Evergreen::Suite.new(root) }
+  subject { Evergreen::Spec.new(suite, template) }
 
   context "with standard setup" do
     let(:root) { File.expand_path('suite1', File.dirname(__FILE__)) }
@@ -22,10 +22,29 @@ describe Evergreen::Runner do
       it { should pass }
     end
 
+    context "invalid coffee" do
+      let(:template) { 'invalid_coffee_spec.coffee' }
+      it { should_not pass }
+    end
+
     context "with slow failing spec" do
       let(:template) { 'slow_spec.coffee' }
       it { should_not pass }
     end
   end
+
+  context "with modified setup" do
+    let(:root) { File.expand_path('suite2', File.dirname(__FILE__)) }
+
+    context "with awesome spec" do
+      let(:template) { 'awesome_spec.js' }
+      it { should pass }
+    end
+
+    context "with failing spec" do
+      let(:template) { 'failing_spec.js' }
+      it { should_not pass }
+    end
+  end
 end
 

data/spec/runner_spec.rb

@@ -2,34 +2,32 @@ require 'spec_helper'
 
 describe Evergreen::Runner do
   let(:root) { File.expand_path('suite1', File.dirname(__FILE__)) }
+  let(:suite) { Evergreen::Suite.new(root) }
+  let(:runner) { Evergreen::Runner.new(suite, buffer) }
+  let(:buffer) { StringIO.new }
 
-  context "with passing spec" do
-    let(:spec) { Evergreen::Spec.new(root, 'testing_spec.js') }
-    subject { Evergreen::Runner.new(spec) }
+  describe '#run' do
+    before { runner.run }
 
-    it { should be_passed }
-    its(:spec) { should == spec }
-    its(:failure_message) { should be_empty }
-  end
-
-  context "with failing spec" do
-    let(:spec) { Evergreen::Spec.new(root, 'failing_spec.js') }
-    subject { Evergreen::Runner.new(spec) }
+    describe 'the buffer' do
+      subject { buffer.rewind; buffer.read }
 
-    it { should_not be_passed }
-    its(:spec) { should == spec }
-    its(:failure_message) { should include("Expected 'bar' to equal 'noooooo'") }
+      it { should include('.F..') }
+      it { should include("Expected 'bar' to equal 'noooooo'") }
+      it { should include("17 examples, 3 failures") }
+    end
   end
 
-  describe '.run' do
-    let(:buffer) { StringIO.new }
-    before { Evergreen::Runner.run(root, buffer) }
+  describe '#run_spec' do
+    let(:spec) { suite.get_spec('failing_spec.js') }
+    before { runner.spec_runner(spec).run }
 
     describe 'the buffer' do
       subject { buffer.rewind; buffer.read }
 
-      it { should include('.F..') }
+      it { should include('.F') }
       it { should include("Expected 'bar' to equal 'noooooo'") }
+      it { should include("2 examples, 1 failures") }
     end
   end
 end

data/spec/spec_helper.rb

@@ -5,19 +5,23 @@ require 'evergreen'
 require 'rspec'
 
 require 'capybara/dsl'
+require 'capybara/envjs'
 
-Capybara.app = Evergreen.application(File.expand_path('suite1', File.dirname(__FILE__)))
-Capybara.default_driver = :selenium
+TEST_DRIVER = :envjs
+
+Capybara.app = Evergreen::Suite.new(File.expand_path('suite1', File.dirname(__FILE__))).application
+Capybara.default_driver = TEST_DRIVER
 
 module EvergreenMatchers
   class PassSpec # :nodoc:
     def matches?(actual)
       @actual = actual
-      @actual.passed?
+      @runner = Evergreen::Runner.new(actual.suite, StringIO.new).spec_runner(@actual)
+      @runner.passed?
     end
 
     def failure_message
-      "expected #{@actual.name} to pass, but it failed with:\n\n#{@actual.failure_message}"
+      "expected #{@actual.name} to pass, but it failed with:\n\n#{@runner.failure_messages}"
     end
 
     def negative_failure_message
@@ -32,4 +36,8 @@ end
 
 RSpec.configure do |config|
   config.include EvergreenMatchers
+  config.before do
+    Evergreen.use_defaults!
+    Evergreen.driver = TEST_DRIVER
+  end
 end

data/spec/spec_spec.rb

@@ -2,7 +2,8 @@ require 'spec_helper'
 
 describe Evergreen::Spec do
   let(:root) { File.expand_path('suite1', File.dirname(__FILE__)) }
-  subject { Evergreen::Spec.new(root, 'testing_spec.js') }
+  let(:suite) { Evergreen::Suite.new(root) }
+  subject { Evergreen::Spec.new(suite, 'testing_spec.js') }
 
   its(:name) { should == 'testing_spec.js' }
   its(:root) { should == root }
@@ -10,16 +11,8 @@ describe Evergreen::Spec do
   its(:url) { should == "/run/testing_spec.js" }
   its(:contents) { should =~ /describe\('testing'/ }
 
-  describe '.all' do
-    subject { Evergreen::Spec.all(root) }
-
-    it "should find all specs in the given root directory" do
-      subject.map(&:name).should include('testing_spec.js', 'foo_spec.js', 'bar_spec.js', 'coffeescript_spec.coffee')
-    end
-  end
-
   context "with coffeescript" do
-    subject { Evergreen::Spec.new(root, 'coffeescript_spec.coffee') }
+    subject { Evergreen::Spec.new(suite, 'coffeescript_spec.coffee') }
     its(:contents) { should =~ /describe\('coffeescript', function/ }
   end
 
@@ -28,7 +21,7 @@ describe Evergreen::Spec do
   end
 
   context "with missing spec file" do
-    subject { Evergreen::Spec.new(root, 'does_not_exist.js') }
+    subject { Evergreen::Spec.new(suite, 'does_not_exist.js') }
     it { should_not exist }
   end
 

data/spec/suite1/spec/javascripts/invalid_coffee_spec.coffee

@@ -0,0 +1 @@
+this => is &! not ( valid coffee script

data/spec/suite1/spec/javascripts/spec_helper.coffee

@@ -1 +1 @@
-window.CoffeeSpecHelper: { coffee: 'script' }
+window.CoffeeSpecHelper = { coffee: 'script' }

data/spec/suite2/config/evergreen.rb

@@ -0,0 +1,5 @@
+Evergreen.configure do |config|
+  config.public_dir = 'public_html'
+  config.template_dir = 'templates'
+  config.spec_dir = 'spec'
+end

data/spec/suite2/public_html/foo.js

@@ -0,0 +1 @@
+var foo = "The Foo";

data/spec/suite2/spec/awesome_spec.js

@@ -0,0 +1,12 @@
+require('/foo.js')
+
+describe('awesome', function() {
+  template('foo.html');
+
+  it('requires public files', function() {
+    expect(foo).toEqual('The Foo');
+  });
+  it('loads templates', function() {
+    expect(document.getElementById('foo').innerHTML).toEqual('The foo template');
+  });
+});

data/spec/suite2/spec/failing_spec.js

@@ -0,0 +1,5 @@
+describe('failing', function() {
+  it('fails', function() {
+    expect('llama').toEqual('monkey');
+  });
+});

data/spec/suite2/templates/foo.html

@@ -0,0 +1 @@
+<div id="foo">The foo template</div>

data/spec/suite_spec.rb

@@ -0,0 +1,26 @@
+require 'spec_helper'
+
+describe Evergreen::Suite do
+  let(:root) { File.expand_path('suite1', File.dirname(__FILE__)) }
+  subject { Evergreen::Suite.new(root) }
+
+  its(:root) { should == root }
+
+  describe '#get_spec' do
+    subject { Evergreen::Suite.new(root).get_spec('testing_spec.js') }
+    its (:name) { should == 'testing_spec.js' }
+    its (:root) { should == root }
+  end
+
+  describe '#specs' do
+    it "should find all specs in the given root directory" do
+      subject.specs.map(&:name).should include('testing_spec.js', 'foo_spec.js', 'bar_spec.js', 'coffeescript_spec.coffee')
+    end
+  end
+
+  describe '#templates' do
+    it "should find all specs in the given root directory" do
+      subject.templates.map(&:name).should include('one_template.html', 'another_template.html')
+    end
+  end
+end