evergreen 0.3.0 → 0.4.0

data/README.rdoc

@@ -2,13 +2,13 @@
 
 "Because green is the new Blue(Ridge)"
 
-Evergreen is a tool to run javascript unit tests for client side JavaScript. It combines a runner which allows you to serve up and run your specs in a browser, as well as a headless runner based on envjs. Evergreen uses the Jasmine unit testing framework for JavaScript.
+Evergreen is a tool to run javascript unit tests for client side JavaScript. It combines a server which allows you to serve up and run your specs in a browser, as well as a runner which uses Capybara and any of its drivers to run your specs. Evergreen uses the Jasmine unit testing framework for JavaScript.
 
 http://github.com/jnicklas/evergreen
 
 == Philosophy
 
-Evergreen is a unit testing tool. It's purpose is to test JavaScript in isolation from your application. If you need a tool that tests how your JavaScript integrates with your application you should use an integration testing framework, such as {Capybara}[http://github.com/jnicklas/capybara].
+Evergreen is a unit testing tool. Its purpose is to test JavaScript in isolation from your application. If you need a tool that tests how your JavaScript integrates with your application you should use an integration testing framework, such as {Capybara}[http://github.com/jnicklas/capybara].
 
 == Installation
 
@@ -39,19 +39,45 @@ Alternatively you can run the specs headlessly by running:
 
     evergreen run
 
-
 == Integrating with Rails 3
 
 Add Evergreen to your Gemfile:
 
     gem 'evergreen', :require => 'evergreen/rails'
 
-Start your rails application and navigate to /evergreen/list. You should now see a list of all spec files, click on one to run it.
+Start your rails application and navigate to /evergreen. You should now see a list of all spec files, click on one to run it.
 
 There's a rake task provided for you that you can use to run your specs:
 
     rake spec:javascripts
 
+== Integrating with Rails 2
+
+Add the following line to your Rakefile:
+
+    require 'evergreen/tasks'
+
+This will give you the `spec:javascripts` rake task. Note that mounting is not possible under Rails 2 and that `require 'evergreen/rails'` will fail.
+
+== Configuration
+
+By default, Evergreen uses Selenium to run your specs and assumes a certain directory structure. If this standard is fine for you, then you don't need to do anything else. If you need to configure Evergreen to suit your needs, Evergreen will automatically look for and load the following files:
+
+    config/evergreen.rb
+    .evergreen
+    ~/.evergreen
+
+The content of these files could look like this:
+
+    require 'capybara/envjs'
+
+    Evergreen.configure do |config|
+      config.driver = :envjs
+      config.public_dir = 'public_html'
+      config.template_dir = 'templates'
+      config.spec_dir = 'spec'
+    end
+
 == Transactions
 
 One problem often faced when writing unit tests for client side code is that changes to the page are not reverted for the next example, so that successive examples become dependent on each other. Evergreen adds a special div to your page with an id of test. This div is automatically emptied before each example. You should avoid appending markup to the page body and instead append it to this test div:

data/config/routes.rb

@@ -1,3 +1,3 @@
 Rails.application.routes.draw do
-  mount Evergreen.application(Rails.root), :at => '/evergreen'
+  mount Evergreen.rails, :at => '/evergreen'
 end

data/lib/evergreen.rb

@@ -1,71 +1,35 @@
 require 'rubygems'
 require 'sinatra/base'
 require 'capybara'
-require 'capybara/wait_until'
 require 'launchy'
 require 'evergreen/version'
+require 'evergreen/application'
 require 'json'
 
 module Evergreen
   autoload :Cli, 'evergreen/cli'
   autoload :Server, 'evergreen/server'
   autoload :Runner, 'evergreen/runner'
+  autoload :Suite, 'evergreen/suite'
   autoload :Spec, 'evergreen/spec'
   autoload :Template, 'evergreen/template'
 
   class << self
-    def application(root, driver=:serve)
-      Rack::Builder.new do
-        map "/jasmine" do
-          use Rack::Static, :urls => ["/"], :root => File.expand_path('jasmine/lib', File.dirname(__FILE__))
-          run lambda { |env| [404, {}, "No such file"]}
-        end
+    attr_accessor :driver, :public_dir, :template_dir, :spec_dir
 
-        map "/resources" do
-          use Rack::Static, :urls => ["/"], :root => File.expand_path('evergreen/resources', File.dirname(__FILE__))
-          run lambda { |env| [404, {}, "No such file"]}
-        end
-
-        map "/" do
-          app = Class.new(Sinatra::Base).tap do |app|
-            app.reset!
-            app.class_eval do
-              set :static, true
-              set :root, File.expand_path('evergreen', File.dirname(__FILE__))
-              set :public, File.expand_path(File.join(root, 'public'), File.dirname(__FILE__))
-
-              helpers do
-                def url(path)
-                  request.env['SCRIPT_NAME'].to_s + path.to_s
-                end
-              end
-
-              get '/' do
-                @specs = Spec.all(root)
-                erb :list
-              end
-
-              get '/list' do
-                @specs = Spec.all(root)
-                erb :list
-              end
-
-              get '/run/*' do |name|
-                @spec = Spec.new(root, name)
-                @js_spec_helper = Spec.new(root, 'spec_helper.js')
-                @coffee_spec_helper = Spec.new(root, 'spec_helper.coffee')
-                @driver = driver
-                erb :spec
-              end
+    def configure
+      yield self
+    end
 
-              get '/spec/*' do |name|
-                Spec.new(root, name).read
-              end
-            end
-          end
-          run app
-        end
+    def use_defaults!
+      configure do |config|
+        config.driver = :selenium
+        config.public_dir = 'public'
+        config.spec_dir = 'spec/javascripts'
+        config.template_dir = 'spec/javascripts/templates'
       end
     end
   end
 end
+
+Evergreen.use_defaults!

data/lib/evergreen/application.rb

@@ -0,0 +1,46 @@
+module Evergreen
+  def self.application(suite)
+    Rack::Builder.new do
+      map "/jasmine" do
+        use Rack::Static, :urls => ["/"], :root => File.expand_path('../jasmine/lib', File.dirname(__FILE__))
+        run lambda { |env| [404, {}, "No such file"]}
+      end
+
+      map "/resources" do
+        use Rack::Static, :urls => ["/"], :root => File.expand_path('resources', File.dirname(__FILE__))
+        run lambda { |env| [404, {}, "No such file"]}
+      end
+
+      map "/" do
+        app = Class.new(Sinatra::Base).tap do |app|
+          app.reset!
+          app.class_eval do
+            set :static, true
+            set :root, File.expand_path('.', File.dirname(__FILE__))
+            set :public, File.expand_path(File.join(suite.root, Evergreen.public_dir), File.dirname(__FILE__))
+
+            helpers do
+              def url(path)
+                request.env['SCRIPT_NAME'].to_s + path.to_s
+              end
+            end
+
+            get '/' do
+              @suite = suite
+              erb :list
+            end
+
+            get '/run/*' do |name|
+              @suite = suite
+              @spec = suite.get_spec(name)
+              @js_spec_helper = suite.get_spec('spec_helper.js')
+              @coffee_spec_helper = suite.get_spec('spec_helper.coffee')
+              erb :spec
+            end
+          end
+        end
+        run app
+      end
+    end
+  end
+end

data/lib/evergreen/cli.rb

@@ -10,10 +10,10 @@ module Evergreen
 
       case command
       when "serve"
-        Evergreen::Server.run(root)
+        Evergreen::Suite.new(root).serve
         return true
       when "run"
-        return Evergreen::Runner.run(root)
+        return Evergreen::Suite.new(root).run
       else
         puts "no such command '#{command}'"
         return false

data/lib/evergreen/rails.rb

@@ -2,6 +2,10 @@ require 'evergreen'
 require 'rails'
 
 module Evergreen
+  def self.rails
+    Evergreen::Suite.new(Rails.root).application
+  end
+
   class Railtie < Rails::Engine
   end
 end

data/lib/evergreen/resources/evergreen.css

@@ -18,6 +18,8 @@ a {
 
 #test {
   min-height: 50px;
+  max-height: 300px;
+  overflow: auto;
   margin: 30px auto 30px;
 }
 
@@ -59,4 +61,4 @@ a {
   text-align: center;
   font-size: 13px;
   color: #aaa;
-}
+}

data/lib/evergreen/resources/evergreen.js

@@ -2,6 +2,8 @@ if(!this.JSON){this.JSON={};}
 
 var Evergreen = {};
 
+Evergreen.dots = ""
+
 Evergreen.ReflectiveReporter = function() {
   this.reportRunnerStarting = function(runner) {
     Evergreen.results = [];
@@ -15,6 +17,7 @@ Evergreen.ReflectiveReporter = function() {
       message: item.message,
       trace: item.trace
     });
+    Evergreen.dots += (results.failedCount === 0) ? "." : "F";
   };
   this.reportRunnerResults = function(runner) {
     Evergreen.done = true;

data/lib/evergreen/runner.rb

@@ -1,60 +1,148 @@
 module Evergreen
   class Runner
-    attr_reader :spec
-
-    def self.run(root, io=STDOUT)
-      runners = Spec.all(root).map { |spec| new(spec) }
-      runners.each do |runner|
-        if runner.passed?
-          io.print '.'
-        else
-          io.print 'F'
-        end
+    class Example
+      def initialize(row)
+        @row = row
+      end
+
+      def passed?
+        @row['passed']
       end
-      io.puts ""
 
-      runners.each do |runner|
-        io.puts runner.failure_message unless runner.passed?
+      def failure_message
+        unless passed?
+          msg = []
+          msg << "  Failed: #{@row['name']}"
+          msg << "    #{@row['message']}"
+          msg << "    in #{@row['trace']['fileName']}:#{@row['trace']['lineNumber']}" if @row['trace']
+          msg.join("\n")
+        end
       end
-      runners.all? { |runner| runner.passed? }
     end
 
-    def initialize(spec)
-      @spec = spec
+    class SpecRunner
+      attr_reader :runner, :spec
+
+      def initialize(runner, spec)
+        @runner = runner
+        @spec = spec
+      end
+
+      def session
+        runner.session
+      end
+
+      def io
+        runner.io
+      end
+
+      def run
+        io.puts dots
+        io.puts failure_messages
+        io.puts "\n#{examples.size} examples, #{failed_examples.size} failures"
+        passed?
+      end
+
+      def examples
+        @results ||= begin
+          session.visit(spec.url)
+
+          previous_results = ""
+
+          session.wait_until(180) do
+            dots = session.evaluate_script('Evergreen.dots')
+            io.print dots.sub(/^#{Regexp.escape(previous_results)}/, '')
+            io.flush
+            previous_results = dots
+            session.evaluate_script('Evergreen.done')
+          end
+
+          dots = session.evaluate_script('Evergreen.dots')
+          io.print dots.sub(/^#{Regexp.escape(previous_results)}/, '')
+
+          JSON.parse(session.evaluate_script('Evergreen.getResults()')).map do |row|
+            Example.new(row)
+          end
+        end
+      end
+
+      def failed_examples
+        examples.select { |example| not example.passed? }
+      end
+
+      def passed?
+        examples.all? { |example| example.passed? }
+      end
+
+      def dots
+        examples; ""
+      end
+
+      def failure_messages
+        unless passed?
+          examples.map { |example| example.failure_message }.compact.join("\n\n")
+        end
+      end
     end
 
-    def name
-      spec.name
+    attr_reader :suite, :io
+
+    def initialize(suite, io=STDOUT)
+      @suite = suite
+      @io = io
     end
 
-    def passed?
-      failed_examples.empty?
+    def spec_runner(spec)
+      SpecRunner.new(self, spec)
     end
 
-    def failure_message
-      failed_examples.map do |row|
-        msg = []
-        msg << "  Failed: #{row['name']}"
-        msg << "    #{row['message']}"
-        msg << "    in #{row['trace']['fileName']}:#{row['trace']['lineNumber']}" if row['trace']
-        msg.join("\n")
-      end.join("\n\n")
+    def run
+      before = Time.now
+
+      io.puts ""
+      io.puts dots.to_s
+      io.puts ""
+      if failure_messages
+        io.puts failure_messages
+        io.puts ""
+      end
+
+      seconds = "%.2f" % (Time.now - before)
+      io.puts "Finished in #{seconds} seconds"
+      io.puts "#{examples.size} examples, #{failed_examples.size} failures"
+      passed?
     end
 
-  protected
+    def examples
+      spec_runners.map { |spec_runner| spec_runner.examples }.flatten
+    end
 
     def failed_examples
-      results.select { |row| !row['passed'] }
+      examples.select { |example| not example.passed? }
+    end
+
+    def passed?
+      spec_runners.all? { |spec_runner| spec_runner.passed? }
+    end
+
+    def dots
+      spec_runners.map { |spec_runner| spec_runner.dots }.join
     end
 
-    def results
-      @results ||= begin
-        session = Capybara::Session.new(:selenium, Evergreen.application(spec.root, :selenium))
-        session.visit(spec.url)
-        session.wait_until(180) { session.evaluate_script('Evergreen.done') }
-        JSON.parse(session.evaluate_script('Evergreen.getResults()'))
+    def failure_messages
+      unless passed?
+        spec_runners.map { |spec_runner| spec_runner.failure_messages }.compact.join("\n\n")
       end
     end
 
+    def session
+      @session ||= Capybara::Session.new(Evergreen.driver, suite.application)
+    end
+
+  protected
+
+    def spec_runners
+      @spec_runners ||= suite.specs.map { |spec| SpecRunner.new(self, spec) }
+    end
   end
 end

data/lib/evergreen/server.rb

@@ -1,30 +1,21 @@
 module Evergreen
   class Server
-    def self.run(root)
-      serve = new(root)
-      serve.boot
-      serve.launch_browser
-    end
-
-    def initialize(root)
-      @root = root
-    end
+    attr_reader :suite
 
-    def server
-      @server ||= Capybara::Server.new(Evergreen.application(@root))
+    def initialize(suite)
+      @suite = suite
     end
 
-    def boot
+    def serve
       server.boot
+      Launchy.open(server.url('/'))
+      sleep
     end
 
-    def root_url
-      server.url('/')
-    end
+  protected
 
-    def launch_browser
-      Launchy.open(root_url)
-      sleep
+    def server
+      @server ||= Capybara::Server.new(suite.application)
     end
   end
 end