jasmine_selenium_runner 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: f85e4cefa20dc2a1976e3a56c9ab6f69abaceaf8
-  data.tar.gz: eba4354fd76bc9642d63bb5c33b0adc283dcd21d
+  metadata.gz: 94aa68074fa6bd922eae4c54c51337a27881b366
+  data.tar.gz: ffff97516d2a1241a7c2fa7f08fdc79d12683d3f
 SHA512:
-  metadata.gz: b92bb57994b870683782005d394899af5bf11a896659d3c54578b849ea14f55047750e39b32d517988c9d0bf145359719c88ac0c7b27ae7805778fc88bf896e6
-  data.tar.gz: 11a5f427662ff9c31063be536da4988a7b7ab271d8d67410c0e664edd97dfcf8b31211a0b1b9e251d413845e2fa526089486964490f7c2d687a1214451cf5057
+  metadata.gz: 57a3598792a25d6c482f9630804ef8884a36cac9c7f8a1e576bd75f17df9b216bfadb96756c7f8cbb725d6c120a27ef8623aa918bc99c1bf9e3746d003933ccf
+  data.tar.gz: 222a273ad1d72480624e3676af3b256c8586c2e20f7aef078be1f6fccb4a069adb9d4746eb49e637680ece9890bd0f10fd1dd68e58ac5488ae20b2774dd7fd66

data/README.md

@@ -94,6 +94,28 @@ Create a jasmine_selenium_runner.yml in spec/javascripts/support/ with the follo
     selenium_server: <full url to selenium server>
     browser: <%= ENV['JASMINE_BROWSER'] %>
 
+### Customizing the browser profile
+
+Make a class that extends `JasmineSeleniumRunner::ConfigureJasmine` and override the `selenium_options` method
+
+    class MyConfigurer < JasmineSeleniumRunner::ConfigureJasmine
+      def selenium_options
+        options = super
+        if browser =~ /^firefox/
+          options = super
+          options[:profile] ||= Selenium::WebDriver::Firefox::Profile.new
+          options[:profile]['dom.max_chrome_script_run_time'] = 20
+          options[:profile]['dom.max_script_run_time'] = 20
+        end
+        options
+      end
+    end
+
+Create a jasmine_selenium_runner.yml in spec/javascripts/support/ with the following content:
+
+    ---
+    configuration_class: MyConfigurer
+
 ## Contributing
 
 1. Fork it

data/lib/jasmine/runners/selenium/version.rb

@@ -1,7 +1,7 @@
 module Jasmine
   module Runners
     class Selenium
-      VERSION = "0.1.0"
+      VERSION = "0.1.1"
     end
   end
 end

data/lib/jasmine_selenium_runner/configure_jasmine.rb

@@ -3,59 +3,100 @@ require 'jasmine/runners/selenium'
 require 'selenium-webdriver'
 
 module JasmineSeleniumRunner
-  module ConfigureJasmine
+  class ConfigureJasmine
     def self.install_selenium_runner
       Jasmine.configure do |config|
-        filepath = File.join(Dir.pwd, 'spec', 'javascripts', 'support', 'jasmine_selenium_runner.yml')
-        runner_config = YAML::load(ERB.new(File.read(filepath)).result(binding)) if File.exist?(filepath)
-        runner_config ||= {}
-        config.port = 5555 if runner_config['use_sauce'] #Sauce only proxies certain ports
+        runner_config = load_config
+        config.ci_port = 5555 if runner_config['use_sauce'] #Sauce only proxies certain ports
 
         config.runner = lambda { |formatter, jasmine_server_url|
-          webdriver = nil
-          browser = runner_config['browser'] || 'firefox'
-
-          if runner_config['use_sauce']
-            sauce_config = runner_config['sauce']
-
-            unless sauce_config['tunnel_identifier']
-              require 'sauce/connect'
-              Sauce::Connect.connect!
-            end
-
-            username = sauce_config.fetch('username')
-            key = sauce_config.fetch('access_key')
-            driver_url = "http://#{username}:#{key}@localhost:4445/wd/hub"
-
-            capabilities = {
-              :name => sauce_config['name'],
-              :platform => sauce_config['os'],
-              :version => sauce_config['browser_version'],
-              :build => sauce_config['build'],
-              :tags => sauce_config['tags'],
-              :browserName => browser,
-              'tunnel-identifier' => sauce_config['tunnel_identifier']
-            }
-
-            webdriver = Selenium::WebDriver.for :remote, :url => driver_url, :desired_capabilities => capabilities
-          elsif runner_config['selenium_server']
-            webdriver = Selenium::WebDriver.for :remote, :url => runner_config['selenium_server'], :desired_capabilities => browser.to_sym
-          else
-
-            selenium_options = {}
-            if browser == 'firefox-firebug'
-              require File.join(File.dirname(__FILE__), 'firebug/firebug')
-              (profile = Selenium::WebDriver::Firefox::Profile.new)
-              profile.enable_firebug
-              selenium_options[:profile] = profile
-            end
-            webdriver = Selenium::WebDriver.for(browser.to_sym, selenium_options)
-          end
-
-          Jasmine::Runners::Selenium.new(formatter, jasmine_server_url, webdriver, runner_config['batch_config_size'] || 50)
+          configuration_class = if runner_config['configuration_class']
+                                  const_get(runner_config['configuration_class'])
+                                else
+                                  self
+                                end
+          configuration_class.new(formatter, jasmine_server_url, runner_config).make_runner
         }
       end
     end
+
+    def self.load_config
+      filepath = File.join(Dir.pwd, 'spec', 'javascripts', 'support', 'jasmine_selenium_runner.yml')
+      if File.exist?(filepath)
+        YAML::load(ERB.new(File.read(filepath)).result(binding))
+      else
+        {}
+      end
+    end
+
+    def initialize(formatter, jasmine_server_url, runner_config)
+      @formatter = formatter
+      @jasmine_server_url = jasmine_server_url
+      @runner_config = runner_config
+      @browser = runner_config['browser'] || 'firefox'
+    end
+
+    def make_runner
+      webdriver = nil
+      if runner_config['use_sauce']
+        webdriver = sauce_webdriver(runner_config['sauce'])
+      elsif runner_config['selenium_server']
+        webdriver = remote_webdriver(runner_config['selenium_server'])
+      else
+        webdriver = local_webdriver
+      end
+
+      Jasmine::Runners::Selenium.new(formatter, jasmine_server_url, webdriver, batch_size)
+    end
+
+    def batch_size
+      runner_config['batch_config_size'] || 50
+    end
+
+    def sauce_webdriver(sauce_config)
+      unless sauce_config['tunnel_identifier']
+        require 'sauce/connect'
+        Sauce::Connect.connect!
+      end
+
+      username = sauce_config.fetch('username')
+      key = sauce_config.fetch('access_key')
+      driver_url = "http://#{username}:#{key}@localhost:4445/wd/hub"
+
+      capabilities = {
+        :name => sauce_config['name'],
+        :platform => sauce_config['os'],
+        :version => sauce_config['browser_version'],
+        :build => sauce_config['build'],
+        :tags => sauce_config['tags'],
+        :browserName => browser,
+        'tunnel-identifier' => sauce_config['tunnel_identifier']
+      }
+
+      Selenium::WebDriver.for :remote, :url => driver_url, :desired_capabilities => capabilities
+    end
+
+    def remote_webdriver(server_url)
+      Selenium::WebDriver.for :remote, :url => server_url, :desired_capabilities => browser.to_sym
+    end
+
+    def local_webdriver
+      Selenium::WebDriver.for(browser.to_sym, selenium_options)
+    end
+
+    def selenium_options
+      if browser == 'firefox-firebug'
+        require File.join(File.dirname(__FILE__), 'firebug/firebug')
+        profile = Selenium::WebDriver::Firefox::Profile.new
+        profile.enable_firebug
+        { :profile => profile }
+      else
+        {}
+      end
+    end
+
+    protected
+    attr_reader :formatter, :jasmine_server_url, :runner_config, :browser
   end
 end
 

data/spec/jasmine_selenium_runner/configure_jasmine_spec.rb

@@ -4,48 +4,68 @@ require 'selenium-webdriver'
 require 'jasmine_selenium_runner/configure_jasmine'
 
 describe "Configuring jasmine" do
+  let(:configurer) { JasmineSeleniumRunner::ConfigureJasmine.new(nil, nil, config) }
 
-  class FakeConfig
-    attr_accessor :port, :runner
-  end
+  context "when a custom selenium server is specified" do
+    let(:config) { { 'selenium_server' => 'http://example.com/selenium/stuff' }}
 
-  def configure
-    Dir.stub(:pwd).and_return(working_dir)
-    Jasmine.stub(:configure).and_yield(fake_config)
-    JasmineSeleniumRunner::ConfigureJasmine.install_selenium_runner
+    it "make a webdriver pointing to the custom server" do
+      Selenium::WebDriver.should_receive(:for).with(:remote, hash_including(url: 'http://example.com/selenium/stuff'))
+      configurer.make_runner
+    end
   end
 
-  def stub_config_file(config_obj)
-    config_path = File.join(working_dir, 'spec', 'javascripts', 'support', 'jasmine_selenium_runner.yml')
-    File.stub(:exist?).with(config_path).and_return(true)
-    File.stub(:read).with(config_path).and_return(YAML.dump(config_obj))
+  context "when the user wants firebug installed" do
+    let(:config) { { 'browser' => 'firefox-firebug' } }
+
+    it "should create a firebug profile and pass that to WebDriver" do
+      profile = double(:profile, enable_firebug: nil)
+      Selenium::WebDriver::Firefox::Profile.stub(:new).and_return(profile)
+      Selenium::WebDriver.should_receive(:for).with('firefox-firebug'.to_sym, {profile: profile})
+      configurer.make_runner
+    end
   end
 
-  let(:working_dir) { 'hi' }
-  let(:fake_config) { FakeConfig.new }
+  context "specifying a custom configurer" do
+    class FakeConfig
+      attr_accessor :port, :runner
+    end
 
-  context "when a custom selenium server is specified" do
-    before do
-      stub_config_file 'selenium_server' => 'http://example.com/selenium/stuff'
-      configure
+    def configure
+      Dir.stub(:pwd).and_return(working_dir)
+      Jasmine.stub(:configure).and_yield(fake_config)
+      JasmineSeleniumRunner::ConfigureJasmine.install_selenium_runner
     end
 
-    it "make a webdriver pointing to the custom server" do
-      Selenium::WebDriver.should_receive(:for).with(:remote, hash_including(url: 'http://example.com/selenium/stuff'))
-      fake_config.runner.call(nil, nil)
+    def stub_config_file(config_obj)
+      config_path = File.join(working_dir, 'spec', 'javascripts', 'support', 'jasmine_selenium_runner.yml')
+      File.stub(:exist?).and_call_original
+      File.stub(:exist?).with(config_path).and_return(true)
+      File.stub(:read).and_call_original
+      File.stub(:read).with(config_path).and_return(YAML.dump(config_obj))
+    end
+
+    let(:working_dir) { 'hi' }
+    let(:fake_config) { FakeConfig.new }
+
+    module Foo
+      class Bar
+        def initialize(formatter, jasmine_server_url, config)
+        end
+
+        def make_runner
+        end
+      end
     end
-  end
 
-  context "when the user wants firebug installed" do
     before do
-      stub_config_file 'browser' => 'firefox-firebug'
+      stub_config_file 'configuration_class' => 'Foo::Bar'
       configure
     end
 
-    it "should create a firebug profile and pass that to WebDriver" do
-      profile = double(:profile, enable_firebug: nil)
-      Selenium::WebDriver::Firefox::Profile.stub(:new).and_return(profile)
-      Selenium::WebDriver.should_receive(:for).with('firefox-firebug'.to_sym, {profile: profile})
+    it "should use the custom class" do
+      Selenium::WebDriver.should_not_receive(:for)
+      Foo::Bar.any_instance.should_receive(:make_runner)
       fake_config.runner.call(nil, nil)
     end
   end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: jasmine_selenium_runner
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Rajan Agaskar
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-09-27 00:00:00.000000000 Z
+date: 2013-10-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler