jsunit-sauce 0.0.1

data/LICENSE

@@ -0,0 +1,19 @@
+Copyright (c) 2011 Sauce Labs Inc
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1 @@
+JSUnit glue for running your JSUnit tests in Sauce OnDemand

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'rake'
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |test|
+  test.libs << 'lib'
+  test.pattern = 'test/test_*.rb'
+  test.verbose = true
+end
+
+task :default => :test

data/Users/epall/Dropbox/code/jsunit-sauce/lib/sauce/jsunit/run_utils.rb

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

data/Users/epall/Dropbox/code/jsunit-sauce/lib/sauce/jsunit/selenium_config.rb

@@ -0,0 +1,220 @@
+module Sauce
+  module JSUnit
+    class SeleniumConfig
+
+      include Utilities
+
+      attr_reader :configuration
+
+      def initialize(configuration_name = nil, selenium_yml_path = nil)
+        selenium_yml_path = selenium_yml_path || File.join(ENV['RAILS_ROOT'] || 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
+
+      [ :test_framework, :start_server,
+        :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,
+        :tunnel_username, :tunnel_password, :tunnel_keyfile,
+        :jsunit_polling_interval_seconds, :kill_mongrel_after_suite ].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_tunnel? &&
+          [:sauceconnecttunnel, :saucetunnel].include?(@configuration['tunnel_method'].to_sym)
+          # We are using Sauce Labs and Sauce Connect Tunnel or Sauce Tunnel.
+          # We need to use a masquerade hostname on the EC2/Sauce 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)
+        # NOTE: application_port_for_selenium requires version > 0.7.3 of webrat
+        # Prior versions only have application_address, and don't have a concept of
+        # starting a rails server at one port, and hitting it at selenium via another
+        {
+          'selenium_server_address' => :selenium_server_address,
+          'selenium_server_port'    => :selenium_server_port,
+          'selenium_browser_key'    => :selenium_browser_key,
+          'application_address'     => :application_address,
+          'application_port_for_selenium' => start_tunnel? ? :tunnel_to_localhost_port : :application_port,
+          '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 = {})
+        args = selenium_client_driver_args.merge(selenium_args)
+        say "Connecting to Selenium RC server at #{args[:host]}:#{args[:port]} (testing app at #{args[:url]})" if ENV['SAUCELABS_ADAPTER_DEBUG']
+        say "args = #{display_safely(args)}" if ENV['SAUCELABS_ADAPTER_DEBUG']
+        driver = ::Selenium::Client::Driver.new(args)
+        debug "done"
+        driver
+      end
+
+      def start_tunnel?
+        !tunnel_method.nil? && tunnel_method.to_sym != :othertunnel
+      end
+
+      def kill_mongrel_after_suite?
+        return true if kill_mongrel_after_suite.nil?
+        kill_mongrel_after_suite.to_s == 'true'
+      end
+
+      def self.parse_yaml(selenium_yml_path)
+        raise "[saucelabs-adapter] could not open #{selenium_yml_path}" unless File.exist?(selenium_yml_path)
+        file_contents = File.open(selenium_yml_path).read
+        erb_parsed_file_contents = ERB.new(%{#{file_contents}}).result
+          configs = YAML.load(erb_parsed_file_contents)
+          @@selenium_configs ||= configs
+      end
+
+      private
+
+      def display_safely(selenium_args)
+        safe = selenium_args.dup
+        begin
+          safe[:browser] = JSON.parse( safe[:browser])
+          safe[:browser]['access-key'] = safe[:browser]['access-key'][0..4] + '...'
+          safe[:browser] = safe[:browser].to_json
+        rescue
+          # args are not always json, e.g. when running locally
+          # for now, just ignore any exceptions when trying to parse args with json
+        end
+        safe.inspect
+      end
+
+      def build_configuration(configuration_name)
+        @configuration = @@selenium_configs[configuration_name]
+        raise "[saucelabs-adapter] stanza '#{configuration_name}' not found in #{@selenium_yml}" unless @configuration
+        # If the Saucelabs-Adapter picked a port out of a range during this session, use it.
+        if ENV['SAUCELABS_ADAPTER_APPLICATION_PORT']
+          @configuration['application_port'] = ENV['SAUCELABS_ADAPTER_APPLICATION_PORT'].to_i
+          debug("Using application port #{application_port} from environment variable SAUCELABS_ADAPTER_APPLICATION_PORT", 2)
+        end
+        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 => "when selenium_server_address is saucelabs.com")
+          if tunnel_method
+            case tunnel_method.to_sym
+            when nil, ""
+            when :saucetunnel
+              errors << require_attributes([:tunnel_to_localhost_port ], :when => "if tunnel_method is :saucetunnel")
+            when :sauceconnecttunnel
+              errors << require_attributes([:tunnel_to_localhost_port ], :when => "if tunnel_method is :sauceconnecttunnel")
+            when :othertunnel
+              errors << require_attributes([:application_address], :when => "when tunnel_method is :othertunnel")
+              errors << require_attributes([:tunnel_to_localhost_port ], :when => "if tunnel_method is :othertunnel")
+            when :sshtunnel
+              errors << require_attributes([:application_address], :when => "when tunnel_method is :sshtunnel")
+              errors << require_attributes([:tunnel_password, :tunnel_keyfile],
+                                           :when => "when tunnel_method is :sshtunnel",
+                                           :any_or_all => :any)
+              if application_address && application_port.is_a?(String) && application_port =~ /(\d+)-(\d+)/
+                # We have been given a port range. Find an unused one.
+                port = find_unused_port(application_address, ($1.to_i)..($2.to_i))
+                @configuration['application_port'] = port
+                @configuration['tunnel_to_localhost_port'] = port if test_framework.to_sym == :webrat
+                # Pass this calculated value on to any other instances of SeleniumConfig created
+                ENV['SAUCELABS_ADAPTER_APPLICATION_PORT'] = port.to_s
+              end
+              if tunnel_keyfile && !File.exist?(File.expand_path(tunnel_keyfile))
+                errors << "tunnel_keyfile '#{tunnel_keyfile}' does not exist" 
+              end
+            else
+              errors << "Unknown tunnel_method: #{tunnel_method}"
+            end
+          end
+        else
+          errors << require_attributes([:selenium_browser_key, :application_address ],
+                                       :when => "unless server is saucelabs.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, options = {})
+        default_options = {
+          :when => "",
+          :any_or_all => :all
+        }
+        options = default_options.merge(options)
+
+        errors = []
+        names.each do |attribute|
+          errors << "#{attribute} is required #{options[:when]}" if send(attribute).nil?
+        end
+        errors = [] if options[:any_or_all] == :any && errors.size < names.size
+        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
+end

data/Users/epall/Dropbox/code/jsunit-sauce/lib/sauce/jsunit/utilities.rb

@@ -0,0 +1,69 @@
+module Sauce
+  module JSUnit
+    module Utilities
+
+      def diagnostics_prefix
+        @diagnostics_prefix ||= '[saucelabs-adapter]'
+      end
+
+      def say(what)
+        STDOUT.puts "#{diagnostics_prefix} #{what}"
+      end
+
+      def debug(what, print_if_level_ge = 0)
+        if ENV['SAUCELABS_ADAPTER_DEBUG']
+          actual_level = ENV['SAUCELABS_ADAPTER_DEBUG'].to_i
+          STDOUT.puts "#{diagnostics_prefix}   #{what}" if print_if_level_ge >= actual_level
+        end
+      end
+
+      def raise_with_message(message)
+        raise "#{diagnostics_prefix} #{message}"
+      end
+
+      def find_unused_port(hostname, range = (3000..5000))
+        debug 'searching for unused port', 2
+        range.each do |port|
+          debug "trying #{hostname}:#{port}", 2
+          begin
+            socket = TCPSocket.new(hostname, port)
+          rescue Errno::ECONNREFUSED
+            debug "it's good, returning #{port}", 2
+            return port
+          ensure
+            socket.close if socket
+          end
+        end
+      end
+
+      # parameters required when invoked by test_unit
+      def start_mongrel(suite_name = {})
+        pid_file = File.join(RAILS_ROOT, "tmp", "pids", "mongrel_selenium.pid")
+        port = suite_name[:port] rescue @selenium_config.application_port
+        say "Starting mongrel at #{pid_file}, port #{port}"
+        system "mongrel_rails start -d --chdir='#{RAILS_ROOT}' --port=#{port} --environment=test --pid #{pid_file} %"
+      end
+
+      def kill_mongrel_if_needed(suite_name = {})
+        mongrel_pid_file = File.join(RAILS_ROOT, "tmp", "pids", "mongrel_selenium.pid")
+        if File.exists?(mongrel_pid_file)
+          pid = File.read(mongrel_pid_file).to_i
+          say "Killing mongrel at #{pid}"
+          Process.kill("KILL", pid)
+        end
+        if File.exists?(mongrel_pid_file)
+          FileUtils.rm(mongrel_pid_file)
+        end
+      end
+
+      def setup_tunnel(suite_name = {})
+        @tunnel = SaucelabsAdapter::Tunnel.factory(@selenium_config)
+        @tunnel.start_tunnel
+      end
+
+      def teardown_tunnel(suite_name = {})
+        @tunnel.shutdown
+      end
+    end
+  end
+end

data/Users/epall/Dropbox/code/jsunit-sauce/lib/sauce/jsunit.rb

@@ -0,0 +1,134 @@
+require 'sauce/jsunit/utilities'
+module Sauce
+  module JSUnit
+    include Utilities
+
+    def requires
+      require 'sauce'
+      require 'sauce/jsunit/run_utils'
+      require 'sauce/jsunit/selenium_config'
+      require "selenium/client"
+      require 'lsof'
+    end
+
+    def setup_jsunit_selenium(options = {})
+      @diagnostics_prefix = '[SauceJSUnit]'
+      requires
+      @selenium_config = SeleniumConfig.new(ENV['SELENIUM_ENV'])
+      start_app_server(options)
+      @tunnel = Sauce::Connect.new(:port => 8080, :domain => "jsunit.test")
+      @tunnel.wait_until_ready
+      @selenium_driver = Sauce::Selenium.new(:job_name => "JSUnit", :browser_url=>"http://jsunit.test/")
+      debug "calling @selenium_driver.start"
+      @selenium_driver.start_new_browser_session :trustAllSSLCertificates => false
+      debug "@selenium_driver.start done"
+    end
+
+    def teardown_jsunit_selenium
+      @selenium_driver.stop
+      @tunnel.disconnect
+      stop_app_server
+    end
+
+    def run_jsunit_test(jsunit_params, options = {})
+      if $:.detect{ |x| x =~ /Selenium/}
+        raise_with_message '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 = default_jsunit_params.merge(jsunit_params)
+
+      test_url = "/jsunit/javascripts/jsunit/jsunit/testRunner.html?" + jsunit_params.map { |k,v| "#{k}=#{v}" }.join("&")
+      if @selenium_config.jsunit_polling_interval_seconds
+        options = {:polling_interval => @selenium_config.jsunit_polling_interval_seconds}.merge(options)
+      end
+      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
+      say "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_with_message "oops don't know port app server is running on" unless local_app_server_port
+      while Lsof.running?(local_app_server_port)
+        say "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,
+        :polling_interval => 5
+      }
+      options = default_options.merge(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 = ""
+      say "Starting to poll JsUnit (every #{options[:polling_interval]}s)..." if options[:verbose]
+      while (Time.now - begin_time) < options[:jsunit_suite_timeout_seconds] && !tests_completed
+        sleep options[:polling_interval]
+        debug "polling now...", 2
+        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
+        say "runs/fails/errors: #{run_count}/#{fail_count}/#{error_count} status: #{status}" if options[:verbose]
+        if status =~ /^Done /
+          tests_completed = true
+        end
+      end
+      raise_with_message "Tests failed to complete after #{options[:jsunit_suite_timeout_seconds]}, status was '#{status}'" unless tests_completed
+
+      say "********** 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")
+          say "Error messages: #{error_messages}"
+      end
+
+      (fail_count + error_count) == 0
+    end
+  end
+end

data/Users/epall/Dropbox/code/jsunit-sauce/test/helper.rb

@@ -0,0 +1,5 @@
+require 'rubygems'
+require 'test/unit'
+
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(File.dirname(__FILE__))

metadata

@@ -0,0 +1,107 @@
+--- !ruby/object:Gem::Specification 
+name: jsunit-sauce
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Eric Allen
+- Chad Wooley
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-02-04 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: sauce
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 95
+        segments: 
+        - 0
+        - 16
+        - 0
+        version: 0.16.0
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: childprocess
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 23
+        segments: 
+        - 0
+        - 1
+        - 6
+        version: 0.1.6
+  type: :runtime
+  version_requirements: *id002
+description: Adapter to run JsUnit test suites using browsers in Sauce OnDemand
+email: eric@hackerengineer.net
+executables: []
+
+extensions: []
+
+extra_rdoc_files: 
+- LICENSE
+- README.md
+files: 
+- LICENSE
+- README.md
+- Rakefile
+- /Users/epall/Dropbox/code/jsunit-sauce/lib/sauce/jsunit/run_utils.rb
+- /Users/epall/Dropbox/code/jsunit-sauce/lib/sauce/jsunit/selenium_config.rb
+- /Users/epall/Dropbox/code/jsunit-sauce/lib/sauce/jsunit/utilities.rb
+- /Users/epall/Dropbox/code/jsunit-sauce/lib/sauce/jsunit.rb
+- /Users/epall/Dropbox/code/jsunit-sauce/test/helper.rb
+has_rdoc: true
+homepage: http://github.com/saucelabs/jsunit-sauce
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.4.2
+signing_key: 
+specification_version: 3
+summary: JsUnit + Sauce OnDemand
+test_files: []
+