saucelabs-adapter 0.7.6

data/generators/saucelabs_adapter/templates/selenium.yml

@@ -0,0 +1,66 @@
+local: &local
+  selenium_server_address: "127.0.0.1"
+  selenium_server_port: "4444"
+  selenium_browser_key: "*chrome /Applications/Firefox.app/Contents/MacOS/firefox-bin"
+  application_address: "127.0.0.1"
+  application_port: "4000"
+
+local_jsunit:
+  <<: *local
+  application_port: "8080"
+
+# Possible Sauce Labs configurations as of 2009/11/19
+# From: http://saucelabs.com/products/docs/sauce-ondemand/browsers
+#
+# saucelabs_browser_os  saucelabs_browser   saucelabs_browser_version (pick one)
+#
+# "Windows 2003"        "iexplore"          "6.", "7.", "8."
+#                       "firefox"           "2.", "3.0", "3.5"
+#                       "safari"            "3.", "4."
+#                       "opera"             "9."
+#                       "googlechrome"      ""
+# "Linux"               "firefox"           "3."
+saucelabs: &saucelabs
+  # URL of Selenium RC server:
+  selenium_server_address: "saucelabs.com"
+  selenium_server_port: "4444"
+  # Saucelabs credentials / Browser to drive
+  saucelabs_username: "YOUR-SAUCELABS-USERNAME"
+  saucelabs_access_key: "YOUR-SAUCELABS-ACCESS-KEY"
+  saucelabs_browser_os: "Linux"
+  saucelabs_browser: "firefox"
+  saucelabs_browser_version: "3."
+  saucelabs_max_duration_seconds: 1800
+  # Selenium RC browser connects to and tests the app at this URL:
+  application_address: "this will be ovewritten if tunnel_method == :saucetunnel"
+  application_port: 80
+  # App host is actually a tunnel that tunnels from <application_address>:<application_port> to localhost:<tunnel_to_localhost_port>
+  tunnel_method: :saucetunnel
+  tunnel_to_localhost_port: 4000 # Warning: application_port and tunnel_to_localhost_port must be identical if you are using Webrat
+  tunnel_startup_timeout: 240
+
+saucelabs_jsunit: &saucelabs_jsunit
+  <<: *saucelabs
+  # We are using the Jetty server for Saucelabs JsUnit selenium testing.
+  localhost_app_server_port: "8080"
+
+saucelabs_jsunit_firefox:
+  <<: *saucelabs_jsunit
+
+saucelabs_jsunit_ie:
+  <<: *saucelabs_jsunit
+  saucelabs_browser_os: "Windows 2003"
+  saucelabs_browser: "iexplore"
+  saucelabs_browser_version: "7."
+
+saucelabs_jsunit_safari:
+  <<: *saucelabs_jsunit
+  saucelabs_browser_os: "Windows 2003"
+  saucelabs_browser: "safari"
+  saucelabs_browser_version: "4."
+
+saucelabs_jsunit_chrome:
+  <<: *saucelabs_jsunit
+  saucelabs_browser_os: "Windows 2003"
+  saucelabs_browser: "googlechrome"
+  saucelabs_browser_version: ""

data/lib/saucelabs-adapter.rb

@@ -0,0 +1 @@
+require 'saucelabs_adapter'

data/lib/saucelabs_adapter.rb

@@ -0,0 +1,6 @@
+require 'saucelabs_adapter/selenium_config'
+require 'saucelabs_adapter/sauce_tunnel'
+require 'saucelabs_adapter/test_unit_adapter'
+require 'saucelabs_adapter/jsunit_selenium_support'
+module SaucelabsAdapter
+end

data/lib/saucelabs_adapter/jsunit_selenium_support.rb

@@ -0,0 +1,121 @@
+module SaucelabsAdapter
+  module JsunitSeleniumSupport
+
+    def requires
+      require 'saucelabs_adapter/run_utils'
+      require "selenium/client"
+      require 'lsof'
+    end
+
+    def setup_jsunit_selenium(options = {})
+      requires
+      @selenium_config = SeleniumConfig.new(ENV['SELENIUM_ENV'])
+      start_app_server(options)
+      @selenium_driver = @selenium_config.create_driver(options)
+      puts "[JsunitSeleniumSupport] calling @selenium_driver.start" if options[:debug]
+      @selenium_driver.start
+      puts "[JsunitSeleniumSupport] @selenium_driver.start done"  if options[:debug]
+    end
+
+    def teardown_jsunit_selenium
+      @selenium_driver.stop
+      stop_app_server
+    end
+
+    def run_jsunit_test(jsunit_params, options = {})
+      if $:.detect{ |x| x =~ /Selenium/}
+        raise 'Selenium gem should not be in path! (deprecated in favor of selenium-client, which we require)'
+      end
+
+      default_jsunit_params = {
+        :testPage => "/jsunit/javascripts/test-pages/suite.html",
+        :autorun => "true",
+        :setupPageTimeout => "60",
+        :pageLoadTimeout => "60",
+        :suppressCacheBuster => (@selenium_config.selenium_server_address == 'saucelabs.com').to_s
+      }
+      jsunit_params.reverse_merge!(default_jsunit_params)
+
+      test_url = "/jsunit/javascripts/jsunit/jsunit/testRunner.html?" + jsunit_params.map { |k,v| "#{k}=#{v}" }.join("&")
+      run_suite(@selenium_driver, test_url, options)
+    end
+
+    private
+
+    def pid_file
+      prepare_pid_file("#{RAILS_ROOT}/tmp/pids", "mongrel_selenium.pid")
+    end
+
+    def prepare_pid_file(file_path, pid_file_name)
+      FileUtils.mkdir_p File.expand_path(file_path)
+      File.expand_path("#{file_path}/#{pid_file_name}")
+    end
+
+    def local_app_server_port
+      @selenium_config.tunnel_to_localhost_port || @selenium_config.application_port
+    end
+
+    def start_app_server(options = {})
+      stop_app_server
+      puts "[JsunitSeleniumSupport] starting application server:"
+      app_server_logfile_path = options[:app_server_logfile_path] || "#{RAILS_ROOT}/log/jsunit_jetty_app_server.log"
+      RunUtils.run "ant -f #{RAILS_ROOT}/public/javascripts/jsunit/jsunit/build.xml start_server " +
+                          "-Dport=#{local_app_server_port} " +
+                          "-DcustomJsUnitJarPath=#{RAILS_ROOT}/public/javascripts/jsunit/jsunit_jar/jsunit.jar " +
+                          "-DresourceBase=#{RAILS_ROOT}/public >> #{app_server_logfile_path} 2>&1 &"
+    end
+
+    def stop_app_server
+      raise "oops don't know port app server is running on" unless local_app_server_port
+      while Lsof.running?(local_app_server_port)
+        puts "Killing app server at #{local_app_server_port}..."
+        Lsof.kill(local_app_server_port)
+        sleep 1
+      end
+    end
+
+    def run_suite(selenium_driver, suite_path, options = {})
+      default_options = {
+        :timeout_in_seconds => 1200
+      }
+      options.reverse_merge!(default_options)
+
+      selenium_driver.open(suite_path)
+
+      # It would be nice if this worked, but it doesn't (it returns nil even though 'Done' is not in the element).
+      # selenium.wait_for_condition(
+      #   "new RegExp('Done').test(window.mainFrame.mainStatus.document.getElementById('content').innerHTML)")
+
+      tests_completed = false
+      begin_time = Time.now
+      status = ""
+      puts "[JsunitSeleniumSupport] Starting to poll JsUnit..." if options[:verbose]
+      while (Time.now - begin_time) < options[:jsunit_suite_timeout_seconds] && !tests_completed
+        sleep 5
+        status = selenium_driver.js_eval("window.mainFrame.mainStatus.document.getElementById('content').innerHTML")
+        status.gsub!(/^<[bB]>Status:<\/[bB]> /, '')
+        # Long form: window.frames['mainFrame'].frames['mainCounts'].frames['mainCountsRuns'].document.getElementById('content').innerHTML
+        runs = selenium_driver.js_eval("window.mainFrame.mainCounts.mainCountsRuns.document.getElementById('content').innerHTML").strip
+        fails = selenium_driver.js_eval("window.mainFrame.mainCounts.mainCountsFailures.document.getElementById('content').innerHTML").strip
+        errors = selenium_driver.js_eval("window.mainFrame.mainCounts.mainCountsErrors.document.getElementById('content').innerHTML").strip
+        run_count = runs.match(/\d+$/)[0].to_i
+        fail_count = fails.match(/\d+$/)[0].to_i
+        error_count = errors.match(/\d+$/)[0].to_i
+        puts "[JsunitSeleniumSupport] runs/fails/errors: #{run_count}/#{fail_count}/#{error_count} status: #{status}" if options[:verbose]
+        if status =~ /^Done /
+          tests_completed = true
+        end
+      end
+      raise "[JsunitSeleniumSupport] Tests failed to complete after #{options[:jsunit_suite_timeout_seconds]}, status was '#{status}'" unless tests_completed
+
+      puts "[JsunitSeleniumSupport] ********** JSUnit tests complete, Runs: #{run_count}, Fails: #{fail_count}, Errors: #{error_count} **********"
+
+      if (fail_count + error_count > 0)
+          error_messages = selenium_driver.js_eval("window.mainFrame.mainErrors.document.getElementsByName('problemsList')[0].innerHTML")
+          puts "[JsunitSeleniumSupport] Error messages: #{error_messages}"
+      end
+
+      (fail_count + error_count) == 0
+    end
+  end
+end

data/lib/saucelabs_adapter/run_utils.rb

@@ -0,0 +1,14 @@
+class RunUtils
+  def self.run(command, options = {})
+    default_options = {
+      :raise_on_fail => true
+    }
+    options.reverse_merge!(default_options)
+    puts "Executing: #{command}"
+    success = system(command)
+    if !success && options[:raise_on_fail]
+      raise "Command failed: #{command}"
+    end
+    success
+  end
+end

data/lib/saucelabs_adapter/sauce_tunnel.rb

@@ -0,0 +1,122 @@
+require 'net/ssh'
+require 'net/ssh/gateway'
+require 'saucerest-ruby/saucerest'
+require 'saucerest-ruby/gateway'
+
+module SaucelabsAdapter
+  class SauceTunnel
+    DEFAULT_TUNNEL_STARTUP_TIMEOUT = 240
+
+    def initialize(se_config)
+      raise "SauceTunnel.new requires a SeleniumConfig argument" unless se_config.is_a?(SeleniumConfig)
+      @se_config = se_config
+      connect_to_rest_api
+      start_tunnel
+    end
+
+    def start_tunnel
+      say "Setting up tunnel from Saucelabs (#{@se_config.application_address}:#{@se_config.application_port}) to localhost:#{@se_config.tunnel_to_localhost_port} (timeout #{tunnel_startup_timeout}s)..."
+      boot_tunnel_machine
+      setup_ssh_reverse_tunnel
+      # WARNING: JsUnit depends upon the format of this output line:
+      say "Tunnel ID #{@tunnel_id} for #{@se_config.application_address} is up."
+    end
+
+    def tunnel_startup_timeout
+      (@se_config.tunnel_startup_timeout || DEFAULT_TUNNEL_STARTUP_TIMEOUT).to_i
+    end
+
+    def shutdown
+      say "Shutting down tunnel to Saucelabs..."
+      teardown_ssh_reverse_tunnel
+      shutdown_tunnel_machine
+      say "done."
+    end
+
+    private
+
+    def connect_to_rest_api
+      sauce_api_url = "https://#{@se_config.saucelabs_username}:#{@se_config.saucelabs_access_key}@saucelabs.com/rest/#{@se_config.saucelabs_username}/"
+      debug "Connecting to Sauce API at #{sauce_api_url}"
+      @sauce_api_endpoint = SauceREST::Client.new sauce_api_url
+    end
+
+    def boot_tunnel_machine
+      debug "Booting tunnel host:"
+      response = @sauce_api_endpoint.create(:tunnel, 'DomainNames' => [@se_config.application_address])
+      if response.has_key? 'error'
+        raise "Error booting tunnel machine: " + response['error']
+      end
+      @tunnel_id = response['id']
+      debug "Tunnel id: %s" % @tunnel_id
+
+      Timeout::timeout(tunnel_startup_timeout) do
+        last_status = tunnel_status = nil
+        begin
+          sleep 5
+          @tunnel_info = @sauce_api_endpoint.get :tunnel, @tunnel_id
+          tunnel_status = @tunnel_info['Status']
+          debug "  tunnel host is #{tunnel_status}" if tunnel_status != last_status
+          last_status = tunnel_status
+          case tunnel_status
+            when 'new', 'booting'
+              # Alrighty. Keep going.
+            when 'running'
+              # We're done.
+            when 'terminated'
+              raise "There was a problem booting the tunnel machine: it terminated (%s)" % @tunnel_info['Error']
+            else
+              raise "Unknown tunnel machine status: #{tunnel_status} (#{@tunnel_info.inspect})"
+          end
+        end while tunnel_status != 'running'
+      end
+    rescue Timeout::Error
+      error_message = "Tunnel did not come up in #{tunnel_startup_timeout} seconds."
+      STDERR.puts "[saucelabs-adapter] " + error_message
+      shutdown_tunnel_machine
+      raise error_message
+    end
+
+    def shutdown_tunnel_machine
+      return unless @sauce_api_endpoint && @tunnel_id
+      debug "Shutting down tunnel machine:"
+      Timeout::timeout(120) do
+        @sauce_api_endpoint.delete :tunnel, @tunnel_id
+        status = nil
+        begin
+          sleep 5
+          status = @sauce_api_endpoint.get(:tunnel, @tunnel_id)['Status']
+          debug status
+        end while status != 'terminated'
+      end
+    rescue Timeout::Error
+      # Do not raise here, or else you give false negatives from test runs
+      STDERR.puts "*" * 80
+      STDERR.puts "Sauce Tunnel failed to shut down! Go visit http://saucelabs.com/tunnels and shut down the tunnel for #{@se_config.application_address}"
+      STDERR.puts "*" * 80
+    end
+
+    def setup_ssh_reverse_tunnel
+      debug "Starting ssh reverse tunnel"
+      @gateway = Net::SSH::Gateway.new(@tunnel_info['Host'], @se_config.saucelabs_username, {:password => @se_config.saucelabs_access_key})
+      @port = @gateway.open_remote(@se_config.tunnel_to_localhost_port.to_i, "127.0.0.1", @se_config.application_port.to_i, "0.0.0.0")
+    end
+
+    def teardown_ssh_reverse_tunnel
+      if @gateway
+        debug "Shutting down ssh reverse tunnel"
+        @gateway.close(@port) if @port
+        @gateway.shutdown! if @gateway
+        debug "done."
+      end
+    end
+
+    def say(what)
+      STDOUT.puts "[saucelabs-adapter] " + what
+    end
+
+    def debug(what)
+      STDOUT.puts "[saucelabs-adapter]   " + what if ENV['SAUCELABS_ADAPTER_DEBUG']
+    end
+  end
+end

data/lib/saucelabs_adapter/selenium_config.rb

@@ -0,0 +1,152 @@
+module SaucelabsAdapter
+  class SeleniumConfig
+    attr_reader :configuration
+
+    def initialize(configuration_name = nil, selenium_yml_path = nil)
+      selenium_yml_path = selenium_yml_path || File.join(RAILS_ROOT, 'config', 'selenium.yml')
+      SeleniumConfig.parse_yaml(selenium_yml_path)
+      build_configuration(configuration_name)
+    end
+
+    def []=(attribute, value)
+      @configuration[attribute.to_s] = value
+    end
+
+    [ :selenium_server_address, :selenium_server_port,
+      :application_address, :application_port,
+      :saucelabs_username, :saucelabs_access_key,
+      :saucelabs_browser_os, :saucelabs_browser, :saucelabs_browser_version,
+      :saucelabs_max_duration_seconds,
+      :tunnel_method, :tunnel_to_localhost_port, :tunnel_startup_timeout ].each do |attr|
+      define_method(attr) do
+        @configuration[attr.to_s]
+      end
+    end
+
+    def selenium_browser_key
+      if selenium_server_address == 'saucelabs.com'
+        # Create the JSON string that Saucelabs needs:
+        { 'username' => saucelabs_username,
+          'access-key' => saucelabs_access_key,
+          'os' => saucelabs_browser_os,
+          'browser' => saucelabs_browser,
+          'browser-version' => saucelabs_browser_version,
+          'max-duration' => saucelabs_max_duration_seconds.to_i,
+          'job-name' => ENV['SAUCELABS_JOB_NAME'] || Socket.gethostname
+        }.to_json
+      else
+        @configuration['selenium_browser_key']
+      end
+    end
+
+    def application_address
+      if start_sauce_tunnel?
+        # We are using Sauce Labs and Sauce Tunnel.
+        # We need to use a masquerade hostname on the EC2 end of the tunnel that will be unique within the scope of
+        # this account (e.g. pivotallabs).  Therefore we mint a fairly unique hostname here.
+        hostname = Socket.gethostname.split(".").first
+        "#{hostname}-#{Process.pid}.com"
+      else
+        @configuration['application_address']
+      end
+
+    end
+
+    # Takes a Webrat::Configuration object and configures it by calling methods on it
+    def configure_webrat(webrat_configuration_object)
+      {
+        'selenium_server_address' => :selenium_server_address,
+        'selenium_server_port'    => :selenium_server_port,
+        'selenium_browser_key'    => :selenium_browser_key,
+        'application_address'     => :application_address,
+        'application_port'        => :application_port
+      }.each do |webrat_configuration_method, our_accessor|
+        webrat_configuration_object.send("#{webrat_configuration_method}=", self.send(our_accessor).to_s)
+      end
+    end
+
+    # Takes a Polonium::Configuration object and configures it by calling methods on it
+    def configure_polonium(polonium_configuration_object)
+      {
+        'selenium_server_host'      => :selenium_server_address,
+        'selenium_server_port'      => :selenium_server_port,
+        'browser'                   => :selenium_browser_key,
+        'external_app_server_host'  => :application_address,
+        'external_app_server_port'  => :application_port
+      }.each do |polonium_configuration_method, our_accessor|
+        polonium_configuration_object.send("#{polonium_configuration_method}=", self.send(our_accessor).to_s)
+      end
+    end
+
+    def create_driver(selenium_args = {}, options = {})
+      args = selenium_client_driver_args.merge(selenium_args)
+      puts "[saucelabs-adapter] Connecting to Selenium RC server at #{args[:host]}:#{args[:port]} (testing app at #{args[:url]})" if options[:debug]
+      puts "[saucelabs-adapter] args = #{args.inspect}" if options[:debug]
+      driver = ::Selenium::Client::Driver.new(args)
+      puts "[saucelabs-adapter] done" if options[:debug]
+      driver
+    end
+
+    def start_sauce_tunnel?
+      tunnel_method.to_sym == :saucetunnel
+    end
+
+    def self.parse_yaml(selenium_yml_path)
+      raise "[saucelabs-adapter] could not open #{selenium_yml_path}" unless File.exist?(selenium_yml_path)
+      @@selenium_configs ||= YAML.load_file(selenium_yml_path)
+    end
+
+    private
+
+    def build_configuration(configuration_name)
+      @configuration = @@selenium_configs[configuration_name]
+      raise "[saucelabs-adapter] stanza '#{configuration_name}' not found in #{@selenium_yml}" unless @configuration
+      check_configuration(configuration_name)
+    end
+
+    def check_configuration(configuration_name)
+      errors = []
+      errors << require_attributes([:selenium_server_address, :selenium_server_port, :application_port])
+      if selenium_server_address == 'saucelabs.com'
+        errors << require_attributes([ :saucelabs_username, :saucelabs_access_key,
+                                        :saucelabs_browser_os, :saucelabs_browser, :saucelabs_browser_version,
+                                        :saucelabs_max_duration_seconds ],
+                                      "when selenium_server_address is saucelabs.com")
+        case tunnel_method.to_sym
+          when nil, ""
+          when :saucetunnel, :othertunnel
+            errors << require_attributes([:tunnel_to_localhost_port ],
+                                          "if tunnel_method is set")
+          else
+            errors << "Unknown tunnel_method: #{tunnel_method}"
+        end
+      else
+        errors << require_attributes([:selenium_browser_key, :application_address ],
+                                      "unless server is saucelab.com")
+      end
+
+      errors.flatten!.compact!
+      if !errors.empty?
+        raise "[saucelabs-adapter] Aborting; stanza #{configuration_name} has the following errors:\n\t" + errors.join("\n\t")
+      end
+    end
+
+    def require_attributes(names, under_what_circumstances = "")
+      errors = []
+      names.each do |attribute|
+        errors << "#{attribute} is required #{under_what_circumstances}" if send(attribute).nil?
+      end
+      errors
+    end
+
+    def selenium_client_driver_args
+      {
+        :host => selenium_server_address,
+        :port => selenium_server_port.to_s,
+        :browser => selenium_browser_key,
+        :url => "http://#{application_address}:#{application_port}",
+        :timeout_in_seconds => 600
+      }
+    end
+  end
+end