jasmine 1.0.1.1 → 1.0.2.0

data/lib/generators/jasmine/templates/spec/javascripts/support/jasmine.yml

@@ -0,0 +1,73 @@
+# src_files
+#
+# Return an array of filepaths relative to src_dir to include before jasmine specs.
+# Default: []
+#
+# EXAMPLE:
+#
+# src_files:
+#   - lib/source1.js
+#   - lib/source2.js
+#   - dist/**/*.js
+#
+src_files:
+    - public/javascripts/**/*.js
+
+# stylesheets
+#
+# Return an array of stylesheet filepaths relative to src_dir to include before jasmine specs.
+# Default: []
+#
+# EXAMPLE:
+#
+# stylesheets:
+#   - css/style.css
+#   - stylesheets/*.css
+#
+stylesheets:
+
+# helpers
+#
+# Return an array of filepaths relative to spec_dir to include before jasmine specs.
+# Default: ["helpers/**/*.js"]
+#
+# EXAMPLE:
+#
+# helpers:
+#   - helpers/**/*.js
+#
+helpers:
+
+# spec_files
+#
+#  Return an array of filepaths relative to spec_dir to include.
+# Default: ["**/*[sS]pec.js"]
+#
+# EXAMPLE:
+#
+# spec_files:
+#   - **/*[sS]pec.js
+#
+spec_files:
+
+# src_dir
+#
+# Source directory path. Your src_files must be returned relative to this path. Will use root if left blank.
+# Default: project root
+#
+# EXAMPLE:
+#
+# src_dir: public
+#
+src_dir:
+
+# spec_dir
+#
+# Spec directory path. Your spec_files must be returned relative to this path.
+# Default: spec/javascripts
+#
+# EXAMPLE:
+#
+# spec_dir: spec/javascripts
+#
+spec_dir:

data/lib/generators/jasmine/templates/spec/javascripts/support/jasmine_config.rb

@@ -0,0 +1,23 @@
+module Jasmine
+  class Config
+
+    # Add your overrides or custom config code here
+
+  end
+end
+
+
+# Note - this is necessary for rspec2, which has removed the backtrace
+module Jasmine
+  class SpecBuilder
+    def declare_spec(parent, spec)
+      me = self
+      example_name = spec["name"]
+      @spec_ids << spec["id"]
+      backtrace = @example_locations[parent.description + " " + example_name]
+      parent.it example_name, {} do
+        me.report_spec(spec["id"])
+      end
+    end
+  end
+end

data/lib/generators/jasmine/templates/spec/javascripts/support/jasmine_runner.rb

@@ -0,0 +1,32 @@
+$:.unshift(ENV['JASMINE_GEM_PATH']) if ENV['JASMINE_GEM_PATH'] # for gem testing purposes
+
+require 'rubygems'
+require 'jasmine'
+jasmine_config_overrides = File.expand_path(File.join(File.dirname(__FILE__), 'jasmine_config.rb'))
+require jasmine_config_overrides if File.exist?(jasmine_config_overrides)
+if Jasmine::rspec2?
+  require 'rspec'
+else
+  require 'spec'
+end
+
+jasmine_config = Jasmine::Config.new
+spec_builder = Jasmine::SpecBuilder.new(jasmine_config)
+
+should_stop = false
+
+if Jasmine::rspec2?
+  RSpec.configuration.after(:suite) do
+    spec_builder.stop if should_stop
+  end
+else
+  Spec::Runner.configure do |config|
+    config.after(:suite) do
+      spec_builder.stop if should_stop
+    end
+  end
+end
+
+spec_builder.start
+should_stop = true
+spec_builder.declare_suites

data/lib/jasmine.rb

@@ -1,8 +1,33 @@
-require 'jasmine/base'
-require 'jasmine/config'
-require 'jasmine/server'
-require 'jasmine/selenium_driver'
+jasmine_files = ['base',
+                 'config',
+                 'server',
+                 'selenium_driver',
+                 'spec_builder',
+                 'command_line_tool']
 
-require 'jasmine/spec_builder'
+jasmine_files << 'generator' if Gem.available? "rails", ">= 3.0"
 
-require 'jasmine/command_line_tool'
+jasmine_files.each do |file|
+  require File.join('jasmine', file)
+end
+
+if Jasmine.rails3?
+  module Jasmine
+    class Railtie < Rails::Railtie
+
+      config.before_configuration do
+        old_jasmine_rakefile = ::Rails.root.join('lib', 'tasks', 'jasmine.rake')
+        if old_jasmine_rakefile.exist?
+          raise RuntimeError.new(
+            "You no longer need to have jasmine.rake in your project, as it is now automatically loaded " +
+            "from the Jasmine gem. Please delete '#{old_jasmine_rakefile}' before continuing."
+          )
+        end
+      end
+
+      rake_tasks do
+        load "jasmine/tasks/jasmine.rake"
+      end
+    end
+  end
+end

data/lib/jasmine/command_line_tool.rb

@@ -36,6 +36,7 @@ module Jasmine
         copy_unless_exists('jasmine-example/spec/PlayerSpec.js', 'spec/javascripts/PlayerSpec.js')
         copy_unless_exists('jasmine-example/spec/SpecHelper.js', 'spec/javascripts/helpers/SpecHelper.js')
         copy_unless_exists('spec/javascripts/support/jasmine_runner.rb')
+        copy_unless_exists('spec/javascripts/support/jasmine_config.rb')
 
         rails_tasks_dir = dest_path('lib/tasks')
         if File.exist?(rails_tasks_dir)

data/lib/jasmine/config.rb

@@ -11,18 +11,19 @@ module Jasmine
       ENV["JASMINE_HOST"] || 'http://localhost'
     end
 
-    def external_selenium_server_port
-      ENV['SELENIUM_SERVER_PORT'] && ENV['SELENIUM_SERVER_PORT'].to_i > 0 ? ENV['SELENIUM_SERVER_PORT'].to_i : nil
+    def jasmine_port
+      ENV["JASMINE_PORT"] || Jasmine::find_unused_port
     end
 
     def start_server(port = 8888)
-      handler = Rack::Handler.default
-      handler.run Jasmine.app(self), :Port => port, :AccessLog => []
+      server = Rack::Server.new(:Port => port, :AccessLog => [])
+      server.instance_variable_set(:@app, Jasmine.app(self)) # workaround for Rack bug, when Rack > 1.2.1 is released Rack::Server.start(:app => Jasmine.app(self)) will work
+      server.start
     end
 
     def start
-      start_servers
-      @client = Jasmine::SeleniumDriver.new("localhost", @selenium_server_port, "*#{browser}", "#{jasmine_host}:#{@jasmine_server_port}/")
+      start_jasmine_server
+      @client = Jasmine::SeleniumDriver.new(browser, "#{jasmine_host}:#{@jasmine_server_port}/")
       @client.connect
     end
 
@@ -31,7 +32,7 @@ module Jasmine
     end
 
     def start_jasmine_server
-      @jasmine_server_port = Jasmine::find_unused_port
+      @jasmine_server_port = jasmine_port
       Thread.new do
         start_server(@jasmine_server_port)
       end
@@ -44,23 +45,6 @@ module Jasmine
       ::RbConfig::CONFIG['host_os'] =~ /mswin|mingw/
     end
 
-    def start_selenium_server
-      @selenium_server_port = external_selenium_server_port
-      if @selenium_server_port.nil?
-        @selenium_server_port = Jasmine::find_unused_port
-        require 'selenium_rc'
-        SeleniumRC::Server.send(:include, SeleniumServerForkHackForRSpec)
-        SeleniumRC::Server.boot("localhost", @selenium_server_port, :args => [windows? ? ">NUL" : "> /dev/null"])
-      else
-        Jasmine::wait_for_listener(@selenium_server_port, "selenium server")
-      end
-    end
-
-    def start_servers
-      start_jasmine_server
-      start_selenium_server
-    end
-
     def run
       begin
         start
@@ -82,10 +66,14 @@ module Jasmine
 
     def match_files(dir, patterns)
       dir = File.expand_path(dir)
-      patterns.collect do |pattern|
-        matches = Dir.glob(File.join(dir, pattern))
-        matches.collect {|f| f.sub("#{dir}/", "")}.sort
-      end.flatten.uniq
+      negative, positive = patterns.partition {|pattern| /^!/ =~ pattern}
+      chosen, negated = [positive, negative].collect do |patterns|
+        patterns.collect do |pattern|
+          matches = Dir.glob(File.join(dir, pattern.gsub(/^!/,'')))
+          matches.collect {|f| f.sub("#{dir}/", "")}.sort
+        end.flatten.uniq
+      end
+      chosen - negated
     end
 
     def simple_config
@@ -170,21 +158,5 @@ module Jasmine
         []
       end
     end
-
-    module SeleniumServerForkHackForRSpec
-      # without this, Selenium's forked process will attempt to run specs a second time at exit;
-      # see http://www.ruby-forum.com/topic/212722
-      def self.included(base)
-        alias_method :fork_without_fix_for_rspec, :fork
-        alias_method :fork, :fork_with_fix_for_rspec
-      end
-
-      def fork_with_fix_for_rspec
-        fork_without_fix_for_rspec do
-          yield
-          at_exit { exit! }
-        end
-      end
-    end
   end
 end

data/lib/jasmine/generator.rb

@@ -0,0 +1,9 @@
+require 'rails'
+
+module Jasmine
+  class Railtie < ::Rails::Railtie
+    rake_tasks do
+      load "jasmine/tasks/jasmine.rake"
+    end
+  end
+end

data/lib/jasmine/selenium_driver.rb

@@ -1,28 +1,30 @@
 module Jasmine
   class SeleniumDriver
-    def initialize(selenium_host, selenium_port, selenium_browser_start_command, http_address)
-      require 'json/pure' unless defined?(JSON)
-      require 'selenium/client'
-      @driver = Selenium::Client::Driver.new(
-        selenium_host,
-        selenium_port,
-        selenium_browser_start_command,
-        http_address
-      )
+    def initialize(browser, http_address)
+      require 'selenium-webdriver'
+      selenium_server = if ENV['SELENIUM_SERVER']
+        ENV['SELENIUM_SERVER']
+      elsif ENV['SELENIUM_SERVER_PORT']
+        "http://localhost:#{ENV['SELENIUM_SERVER_PORT']}/wd/hub"
+      end
+      @driver = if selenium_server
+        Selenium::WebDriver.for :remote, :url => selenium_server, :desired_capabilities => browser.to_sym
+      else
+        Selenium::WebDriver.for browser.to_sym
+      end
       @http_address = http_address
     end
 
     def tests_have_finished?
-      @driver.get_eval("window.jasmine.getEnv().currentRunner.finished") == "true"
+      @driver.execute_script("return window.jasmine.getEnv().currentRunner.finished") == "true"
     end
 
     def connect
-      @driver.start
-      @driver.open("/")
+      @driver.navigate.to @http_address
     end
 
     def disconnect
-      @driver.stop
+      @driver.quit
     end
 
     def run
@@ -30,15 +32,13 @@ module Jasmine
         sleep 0.1
       end
 
-      puts @driver.get_eval("window.results()")
-      failed_count = @driver.get_eval("window.jasmine.getEnv().currentRunner.results().failedCount").to_i
+      puts @driver.execute_script("return window.results()")
+      failed_count = @driver.execute_script("return window.jasmine.getEnv().currentRunner.results().failedCount").to_i
       failed_count == 0
     end
 
     def eval_js(script)
-      escaped_script = "'" + script.gsub(/(['\\])/) { '\\' + $1 } + "'"
-
-      result = @driver.get_eval("try { eval(#{escaped_script}, window); } catch(err) { window.eval(#{escaped_script}); }")
+      result = @driver.execute_script(script)
       JSON.parse("{\"result\":#{result}}")["result"]
     end
 

data/lib/jasmine/server.rb

@@ -1,29 +1,5 @@
 require 'rack'
 
-# Backport Rack::Handler.default from Rack 1.1.0 for Rails 2.3.x compatibility.
-unless Rack::Handler.respond_to?(:default)
-  module Rack::Handler
-    def self.default(options = {})
-      # Guess.
-      if ENV.include?("PHP_FCGI_CHILDREN")
-        # We already speak FastCGI
-        options.delete :File
-        options.delete :Port
-
-        Rack::Handler::FastCGI
-      elsif ENV.include?("REQUEST_METHOD")
-        Rack::Handler::CGI
-      else
-        begin
-          Rack::Handler::Mongrel
-        rescue LoadError => e
-          Rack::Handler::WEBrick
-        end
-      end
-    end
-  end
-end
-
 module Jasmine
   class RunAdapter
     def initialize(config)

data/lib/jasmine/spec_builder.rb

@@ -53,12 +53,12 @@ module Jasmine
 
     def load_suite_info
       started = Time.now
-      while !eval_js('jsApiReporter && jsApiReporter.started') do
+      while !eval_js('return jsApiReporter && jsApiReporter.started') do
         raise "couldn't connect to Jasmine after 60 seconds" if (started + 60 < Time.now)
         sleep 0.1
       end
 
-      @suites = eval_js("var result = jsApiReporter.suites(); if (window.Prototype && Object.toJSON) { Object.toJSON(result) } else { JSON.stringify(result) }")
+      @suites = eval_js("var result = jsApiReporter.suites(); if (window.Prototype && Object.toJSON) { return Object.toJSON(result) } else { return JSON.stringify(result) }")
     end
 
     def results_for(spec_id)
@@ -69,14 +69,14 @@ module Jasmine
     def load_results
       @spec_results = {}
       @spec_ids.each_slice(50) do |slice|
-        @spec_results.merge!(eval_js("var result = jsApiReporter.resultsForSpecs(#{json_generate(slice)}); if (window.Prototype && Object.toJSON) { Object.toJSON(result) } else { JSON.stringify(result) }"))
+        @spec_results.merge!(eval_js("var result = jsApiReporter.resultsForSpecs(#{json_generate(slice)}); if (window.Prototype && Object.toJSON) { return Object.toJSON(result) } else { return JSON.stringify(result) }"))
       end
       @spec_results
     end
 
     def wait_for_suites_to_finish_running
       puts "Waiting for suite to finish in browser ..."
-      while !eval_js('jsApiReporter.finished') do
+      while !eval_js('return jsApiReporter.finished') do
         sleep 0.1
       end
     end

data/lib/jasmine/tasks/jasmine.rake

@@ -15,7 +15,7 @@ namespace :jasmine do
 
     if Jasmine::rspec2?
       RSpec::Core::RakeTask.new(:jasmine_continuous_integration_runner) do |t|
-        t.rspec_opts = ["--color", "--format", "progress"]
+        t.rspec_opts = ["--colour", "--format", "progress"]
         t.verbose = true
         t.pattern = ['spec/javascripts/support/jasmine_runner.rb']
       end
@@ -30,7 +30,7 @@ namespace :jasmine do
   end
 
   task :server => "jasmine:require" do
-    jasmine_config_overrides = 'spec/javascripts/support/jasmine_config.rb'
+    jasmine_config_overrides = './spec/javascripts/support/jasmine_config.rb'
     require jasmine_config_overrides if File.exist?(jasmine_config_overrides)
 
     puts "your tests are here:"

data/lib/jasmine/version.rb

@@ -0,0 +1,3 @@
+module Jasmine
+  VERSION = "1.0.2.0"
+end

data/spec/config_spec.rb

@@ -1,40 +1,28 @@
 require File.expand_path(File.join(File.dirname(__FILE__), "spec_helper"))
+require 'selenium-webdriver'
 
 describe Jasmine::Config do
-
   describe "configuration" do
-
-    before(:all) do
+    before :each do
       temp_dir_before
 
       Dir::chdir @tmp
-      create_rails 'rails-project'
-      Dir::chdir 'rails-project'
-
-      FileUtils.cp_r(File.join(@root, 'generators'), 'vendor')
-
-      if rails3?
-        raise Exception.new('rails 3 generators not yet implemented!')
-      else
-        `./script/generate jasmine`
-      end
+      dir_name = "test_js_project"
+      `mkdir -p #{dir_name}`
+      Dir::chdir dir_name
+      `#{@root}/bin/jasmine init .`
 
-      Dir::chdir @old_dir
+      @project_dir  = Dir.pwd
 
-      @rails_dir = "#{@tmp}/rails-project"
+      @template_dir = File.expand_path(File.join(@root, "generators/jasmine/templates"))
+      @config       = Jasmine::Config.new
     end
 
-    after(:all) do
+    after(:each) do
       temp_dir_after
     end
 
-    before(:each) do
-      @template_dir = File.expand_path(File.join(File.dirname(__FILE__), "../generators/jasmine/templates"))
-      @config = Jasmine::Config.new
-    end
-
     describe "defaults" do
-
       it "src_dir uses root when src dir is blank" do
         @config.stub!(:project_root).and_return('some_project_root')
         @config.stub!(:simple_config_file).and_return(File.join(@template_dir, 'spec/javascripts/support/jasmine.yml'))
@@ -46,51 +34,77 @@ describe Jasmine::Config do
         @config.stub!(:project_root).and_return('some_project_root')
         @config.simple_config_file.should == (File.join('some_project_root', 'spec/javascripts/support/jasmine.yml'))
       end
-
     end
 
-
     describe "simple_config" do
       before(:each) do
-        @config.stub!(:src_dir).and_return(File.join(@rails_dir, "."))
-        @config.stub!(:spec_dir).and_return(File.join(@rails_dir, "spec/javascripts"))
+        @config.stub!(:src_dir).and_return(File.join(@project_dir, "."))
+        @config.stub!(:spec_dir).and_return(File.join(@project_dir, "spec/javascripts"))
       end
 
-      shared_examples_for "simple_config defaults" do
-        it "should return the correct files and mappings" do
-          @config.src_files.should == []
+      describe "using default jasmine.yml" do
+        before(:each) do
+          @config.stub!(:simple_config_file).and_return(File.join(@template_dir, 'spec/javascripts/support/jasmine.yml'))
+        end
+
+        it "should find the source files" do
+          @config.src_files.should =~ ['public/javascripts/Player.js', 'public/javascripts/Song.js']
+        end
+
+        it "should find the stylesheet files" do
           @config.stylesheets.should == []
+        end
+
+        it "should find the spec files" do
           @config.spec_files.should == ['PlayerSpec.js']
+        end
+
+        it "should find any helpers" do
           @config.helpers.should == ['helpers/SpecHelper.js']
+        end
+
+        it "should build an array of all the JavaScript files to include, source files then spec files" do
           @config.js_files.should == [
-            '/__spec__/helpers/SpecHelper.js',
-            '/__spec__/PlayerSpec.js',
+                  '/public/javascripts/Player.js',
+                  '/public/javascripts/Song.js',
+                  '/__spec__/helpers/SpecHelper.js',
+                  '/__spec__/PlayerSpec.js'
           ]
-          @config.js_files("PlayerSpec.js").should ==
-            ['/__spec__/helpers/SpecHelper.js',
-             '/__spec__/PlayerSpec.js']
-          @config.spec_files_full_paths.should == [
-            File.join(@rails_dir, 'spec/javascripts/PlayerSpec.js'),
+        end
+
+        it "should allow the js_files to be filtered" do
+          @config.js_files("PlayerSpec.js").should == [
+                  '/public/javascripts/Player.js',
+                  '/public/javascripts/Song.js',
+                  '/__spec__/helpers/SpecHelper.js',
+                  '/__spec__/PlayerSpec.js'
           ]
         end
+
+        it "should report the full paths of the spec files" do
+          @config.spec_files_full_paths.should == [File.join(@project_dir, 'spec/javascripts/PlayerSpec.js')]
+        end
       end
 
       it "should parse ERB" do
-        @config.stub!(:simple_config_file).and_return(File.expand_path(File.join(File.dirname(__FILE__), 'fixture/jasmine.erb.yml')))
+        @config.stub!(:simple_config_file).and_return(File.expand_path(File.join(@root, 'spec', 'fixture','jasmine.erb.yml')))
         Dir.stub!(:glob).and_return { |glob_string| [glob_string] }
-        @config.src_files.should == [
-          'file0.js',
-          'file1.js',
-          'file2.js',
-          ]
+        @config.src_files.should == ['file0.js', 'file1.js', 'file2.js',]
       end
 
-
-      describe "if sources.yaml not found" do
+      describe "if jasmine.yml not found" do
         before(:each) do
           File.stub!(:exist?).and_return(false)
         end
-        it_should_behave_like "simple_config defaults"
+
+        it "should default to loading no source files" do
+          @config.src_files.should be_empty
+        end
+
+        it "should default to loading no stylesheet files" do
+          @config.stylesheets.should be_empty
+        end
+
       end
 
       describe "if jasmine.yml is empty" do
@@ -98,22 +112,20 @@ describe Jasmine::Config do
           @config.stub!(:simple_config_file).and_return(File.join(@template_dir, 'spec/javascripts/support/jasmine.yml'))
           YAML.stub!(:load).and_return(false)
         end
-        it_should_behave_like "simple_config defaults"
 
-      end
+        it "should default to loading no source files" do
+          @config.src_files.should be_empty
+        end
 
-#      describe "using default jasmine.yml" do
-#        before(:each) do
-#          @config.stub!(:simple_config_file).and_return(File.join(@template_dir, 'spec/javascripts/support/jasmine.yml'))
-#        end
-#        it_should_behave_like "simple_config defaults"
-#
-#      end
+        it "should default to loading no stylesheet files" do
+          @config.stylesheets.should be_empty
+        end
+      end
 
       describe "should use the first appearance of duplicate filenames" do
         before(:each) do
           Dir.stub!(:glob).and_return { |glob_string| [glob_string] }
-          fake_config = Hash.new.stub!(:[]).and_return {|x| ["file1.ext", "file2.ext", "file1.ext"]}
+          fake_config = Hash.new.stub!(:[]).and_return { |x| ["file1.ext", "file2.ext", "file1.ext"] }
           @config.stub!(:simple_config).and_return(fake_config)
         end
 
@@ -144,23 +156,42 @@ describe Jasmine::Config do
 
         it "spec_files_full_paths" do
           @config.spec_files_full_paths.should == [
-              File.expand_path("spec/javascripts/file1.ext", @rails_dir),
-              File.expand_path("spec/javascripts/file2.ext", @rails_dir)
+                  File.expand_path("spec/javascripts/file1.ext", @project_dir),
+                  File.expand_path("spec/javascripts/file2.ext", @project_dir)
           ]
         end
+      end
+
+      describe "should allow .gitignore style negation (!pattern)" do
+        before(:each) do
+          Dir.stub!(:glob).and_return { |glob_string| [glob_string] }
+          fake_config = Hash.new.stub!(:[]).and_return { |x| ["file1.ext", "!file1.ext", "file2.ext"] }
+          @config.stub!(:simple_config).and_return(fake_config)
+        end
 
+        it "should not contain negated files" do
+          @config.src_files.should == ["file2.ext"]
+        end
       end
 
       it "simple_config stylesheets" do
         @config.stub!(:simple_config_file).and_return(File.join(@template_dir, 'spec/javascripts/support/jasmine.yml'))
+
         YAML.stub!(:load).and_return({'stylesheets' => ['foo.css', 'bar.css']})
         Dir.stub!(:glob).and_return { |glob_string| [glob_string] }
+
         @config.stylesheets.should == ['foo.css', 'bar.css']
       end
 
-
       it "using rails jasmine.yml" do
+        ['public/javascripts/prototype.js',
+         'public/javascripts/effects.js',
+         'public/javascripts/controls.js',
+         'public/javascripts/dragdrop.js',
+         'public/javascripts/application.js'].each { |f| `touch #{f}` }
+
         @config.stub!(:simple_config_file).and_return(File.join(@template_dir, 'spec/javascripts/support/jasmine-rails.yml'))
+
         @config.spec_files.should == ['PlayerSpec.js']
         @config.helpers.should == ['helpers/SpecHelper.js']
         @config.src_files.should == ['public/javascripts/prototype.js',
@@ -171,87 +202,107 @@ describe Jasmine::Config do
                                      'public/javascripts/Player.js',
                                      'public/javascripts/Song.js']
         @config.js_files.should == [
-          '/public/javascripts/prototype.js',
-          '/public/javascripts/effects.js',
-          '/public/javascripts/controls.js',
-          '/public/javascripts/dragdrop.js',
-          '/public/javascripts/application.js',
-          '/public/javascripts/Player.js',
-          '/public/javascripts/Song.js',
-          '/__spec__/helpers/SpecHelper.js',
-          '/__spec__/PlayerSpec.js',
+                '/public/javascripts/prototype.js',
+                '/public/javascripts/effects.js',
+                '/public/javascripts/controls.js',
+                '/public/javascripts/dragdrop.js',
+                '/public/javascripts/application.js',
+                '/public/javascripts/Player.js',
+                '/public/javascripts/Song.js',
+                '/__spec__/helpers/SpecHelper.js',
+                '/__spec__/PlayerSpec.js',
         ]
         @config.js_files("PlayerSpec.js").should == [
-          '/public/javascripts/prototype.js',
-          '/public/javascripts/effects.js',
-          '/public/javascripts/controls.js',
-          '/public/javascripts/dragdrop.js',
-          '/public/javascripts/application.js',
-          '/public/javascripts/Player.js',
-          '/public/javascripts/Song.js',
-          '/__spec__/helpers/SpecHelper.js',
-          '/__spec__/PlayerSpec.js'
+                '/public/javascripts/prototype.js',
+                '/public/javascripts/effects.js',
+                '/public/javascripts/controls.js',
+                '/public/javascripts/dragdrop.js',
+                '/public/javascripts/application.js',
+                '/public/javascripts/Player.js',
+                '/public/javascripts/Song.js',
+                '/__spec__/helpers/SpecHelper.js',
+                '/__spec__/PlayerSpec.js'
         ]
-
       end
-
     end
-
   end
 
-  describe "browser configuration" do
-    it "should use firefox by default" do
-      ENV.stub!(:[], "JASMINE_BROWSER").and_return(nil)
-      config = Jasmine::Config.new
-      config.stub!(:start_servers)
-      Jasmine::SeleniumDriver.should_receive(:new).
-        with(anything(), anything(), "*firefox", anything()).
-        and_return(mock(Jasmine::SeleniumDriver, :connect => true))
-      config.start
+  describe "environment variables" do
+    def stub_env_hash(hash)
+      ENV.stub!(:[]) do |arg|
+        hash[arg]
+      end
     end
+    describe "browser configuration" do
+      it "should use firefox by default" do
+        stub_env_hash({"JASMINE_BROWSER" => nil})
+        config = Jasmine::Config.new
+        config.stub!(:start_jasmine_server)
+        Jasmine::SeleniumDriver.should_receive(:new).
+            with("firefox", anything).
+            and_return(mock(Jasmine::SeleniumDriver, :connect => true))
+        config.start
+      end
 
-    it "should use ENV['JASMINE_BROWSER'] if set" do
-      ENV.stub!(:[], "JASMINE_BROWSER").and_return("mosaic")
-      config = Jasmine::Config.new
-      config.stub!(:start_servers)
-      Jasmine::SeleniumDriver.should_receive(:new).
-        with(anything(), anything(), "*mosaic", anything()).
-        and_return(mock(Jasmine::SeleniumDriver, :connect => true))
-      config.start
+      it "should use ENV['JASMINE_BROWSER'] if set" do
+        stub_env_hash({"JASMINE_BROWSER" => "mosaic"})
+        config = Jasmine::Config.new
+        config.stub!(:start_jasmine_server)
+        Jasmine::SeleniumDriver.should_receive(:new).
+            with("mosaic", anything).
+            and_return(mock(Jasmine::SeleniumDriver, :connect => true))
+        config.start
+      end
     end
-  end
 
-  describe "jasmine host" do
-    it "should use http://localhost by default" do
-      config = Jasmine::Config.new
-      config.instance_variable_set(:@jasmine_server_port, '1234')
-      config.stub!(:start_servers)
+    describe "jasmine host" do
+      it "should use http://localhost by default" do
+        stub_env_hash({})
+        config = Jasmine::Config.new
+        config.instance_variable_set(:@jasmine_server_port, '1234')
+        config.stub!(:start_jasmine_server)
+
+        Jasmine::SeleniumDriver.should_receive(:new).
+            with(anything, "http://localhost:1234/").
+            and_return(mock(Jasmine::SeleniumDriver, :connect => true))
+        config.start
+      end
 
-      Jasmine::SeleniumDriver.should_receive(:new).
-        with(anything(), anything(), anything(), "http://localhost:1234/").
-        and_return(mock(Jasmine::SeleniumDriver, :connect => true))
-      config.start
-    end
+      it "should use ENV['JASMINE_HOST'] if set" do
+        stub_env_hash({"JASMINE_HOST" => "http://some_host"})
+        config = Jasmine::Config.new
+        config.instance_variable_set(:@jasmine_server_port, '1234')
+        config.stub!(:start_jasmine_server)
 
-    it "should use ENV['JASMINE_HOST'] if set" do
-      ENV.stub!(:[], "JASMINE_HOST").and_return("http://some_host")
-      config = Jasmine::Config.new
-      config.instance_variable_set(:@jasmine_server_port, '1234')
-      config.stub!(:start_servers)
+        Jasmine::SeleniumDriver.should_receive(:new).
+            with(anything, "http://some_host:1234/").
+            and_return(mock(Jasmine::SeleniumDriver, :connect => true))
+        config.start
+      end
 
-      Jasmine::SeleniumDriver.should_receive(:new).
-        with(anything(), anything(), anything(), "http://some_host:1234/").
-        and_return(mock(Jasmine::SeleniumDriver, :connect => true))
-      config.start
+      it "should use ENV['JASMINE_PORT'] if set" do
+        stub_env_hash({"JASMINE_PORT" => "4321"})
+        config = Jasmine::Config.new
+        Jasmine.stub!(:wait_for_listener)
+        config.stub!(:start_server)
+        Jasmine::SeleniumDriver.should_receive(:new).
+            with(anything, "http://localhost:4321/").
+            and_return(mock(Jasmine::SeleniumDriver, :connect => true))
+        config.start
+      end
     end
-  end
 
-  describe "#start_selenium_server" do
-    it "should use an existing selenium server if SELENIUM_SERVER_PORT is set" do
-      config = Jasmine::Config.new
-      ENV.stub!(:[], "SELENIUM_SERVER_PORT").and_return(1234)
-      Jasmine.should_receive(:wait_for_listener).with(1234, "selenium server")
-      config.start_selenium_server
+    describe "external selenium server" do
+      it "should use an external selenium server if SELENIUM_SERVER is set" do
+        stub_env_hash({"SELENIUM_SERVER" => "http://myseleniumserver.com:4441"})
+        Selenium::WebDriver.should_receive(:for).with(:remote, :url => "http://myseleniumserver.com:4441", :desired_capabilities => :firefox)
+        Jasmine::SeleniumDriver.new('firefox', 'http://localhost:8888')
+      end
+      it "should use an local selenium server with a specific port if SELENIUM_SERVER_PORT is set" do
+        stub_env_hash({"SELENIUM_SERVER_PORT" => "4441"})
+        Selenium::WebDriver.should_receive(:for).with(:remote, :url => "http://localhost:4441/wd/hub", :desired_capabilities => :firefox)
+        Jasmine::SeleniumDriver.new('firefox', 'http://localhost:8888')
+      end
     end
   end
 end