sauce_ruby 3.5.6

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: d0e0aad8cbfd23b54304b3b5190e3af87159e509
+  data.tar.gz: 35a9bc2da5f12d59c72f17a06836d9c57d3310fa
+SHA512:
+  metadata.gz: c27dc8ae6d754fdb7ae798b26f1cb02f234cf42937c3217ae585c484225cd3860f7b8ba929d9ecb0c2f9cc67f7ae8e449523ef35f1762723dcc5c89372278185
+  data.tar.gz: 6667deae41d668ac3c819ac9756ee9d92520ca97304921ff94b3f53dcccc88e3ff1a26439300590f2cd0a26fa308ef1454b588255a0982e277750ea786d9adcf

data/bin/sauce

@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby
+require 'rubygems'
+require 'cmdparse'
+require 'yaml'
+require 'fileutils'
+require 'json'
+require 'highline/import'
+
+sauce_dir = File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib'))
+$LOAD_PATH.unshift(sauce_dir) unless $LOAD_PATH.include?(sauce_dir)
+
+  require 'sauce'
+
+cmd = CmdParse::CommandParser.new(true, true)
+cmd.program_name = "sauce "
+cmd.program_version = [0, 1, 0]
+
+cmd.add_command(CmdParse::HelpCommand.new)
+
+class ConnectCommand < CmdParse::Command
+  def usage
+    "Usage: #{commandparser.program_name}connect"
+  end
+end
+connect = ConnectCommand.new('connect', false)
+connect.short_desc = 'Connect a Sauce Connect tunnel'
+connect.set_execution_block do |args|
+  begin
+    require 'sauce/connect'
+  rescue LoadError
+    puts "Please install the sauce-connect gem (`gem install sauce-connect`) in order to use Sauce Connect"
+    exit 1
+  end
+  require 'sauce/config'
+  config = Sauce::Config.new
+  command = "#{Sauce::Connect.connect_command} #{config.username} #{config.access_key} #{ARGV[1 .. -1]}"
+  exec(command)
+end
+cmd.add_command(connect)
+
+
+# configure
+class ConfigureCommand < CmdParse::Command
+  def usage
+    "Usage: #{commandparser.program_name}configure USERNAME ACCESS_KEY"
+  end
+end
+configure = ConfigureCommand.new('configure', false)
+configure.short_desc = "Configure Sauce Labs credentials"
+configure.set_execution_block do |args|
+  if args.length < 2
+    puts configure.usage
+    exit 1
+  end
+  username = args[0]
+  access_key = args[1]
+  dir = File.join(File.expand_path("~"), ".sauce")
+  FileUtils.mkdir(dir) unless File.directory?(dir)
+
+  out = File.new(File.join(dir, "ondemand.yml"), 'w')
+  out.write(YAML.dump({"username" => username, "access_key" => access_key}))
+  out.close()
+end
+cmd.add_command(configure)
+
+#create
+create = CmdParse::Command.new('create', false)
+create.short_desc = "Create a new Sauce Labs account"
+create.set_execution_block do |args|
+  puts "Let's create a new account!"
+  username = ask("Username: ")
+  password = ask("Password: ") { |q| q.echo = "*" }
+  email = ask("Email: ")
+  name = ask("Full name: ")
+
+  body = {
+    :username => username,
+    :password => password,
+    :email => email,
+    :name => name,
+    :token => "c8eb3e2645005bcbbce7e2c208c6b7a71555d908"
+  }.to_json
+
+  begin
+    result = RestClient.post("http://saucelabs.com/rest/v1/users",
+                              body, :content_type => :json, :accept => :json)
+  rescue => e
+    begin
+      puts "ERROR: #{JSON.load(e.response)['errors']}"
+    rescue
+      puts "ERROR: #{e.response}"
+    end
+  else
+    result = JSON.load(result)
+
+    puts "Account #{username} created successfully."
+    puts "Your access key is: #{result['access_key']}"
+  end
+end
+
+cmd.add_command(create)
+
+cmd.parse

data/lib/childprocess/process.rb

@@ -0,0 +1,34 @@
+module ChildProcess
+  module Unix
+    class Process < AbstractProcess
+
+      def return_unless_timeout
+        lambda do |timeout|
+          begin
+            return poll_for_exit timeout
+          rescue TimeoutError
+          end
+        end
+      end
+
+      def stop(timeout = 3, signal=nil)
+        assert_started
+
+        unless signal.nil?
+          send_signal signal
+          return_unless_timeout.call(timeout)
+        end
+
+        send_term
+        return_unless_timeout.call(timeout)
+
+        send_kill
+        wait
+      rescue Errno::ECHILD, Errno::ESRCH
+        # handle race condition where process dies between timeout
+        # and send_kill
+        true
+      end
+    end
+  end
+end

data/lib/generators/sauce/install/install_generator.rb

@@ -0,0 +1,54 @@
+module Sauce
+  module Generators
+    class InstallGenerator < Rails::Generators::Base
+      source_root File.expand_path("../templates", __FILE__)
+
+      desc "Prep application for Sauce OnDemand Selenium tests"
+
+      argument :username, :type => :string, :required => false
+      argument :api_key, :type => :string, :required => false
+
+      def copy_rake_tasks
+        copy_file "sauce.rake", "lib/tasks/sauce.rake"
+      end
+
+      def configure_credentials
+        if username
+          system("sauce config #{username} #{api_key}")
+        end
+      end
+
+      def setup_spec
+        if File.directory? 'spec'
+          empty_directory "spec/selenium"
+          append_file "spec/spec_helper.rb", generate_config
+        end
+      end
+
+      def setup_test
+        if File.directory? 'test'
+          empty_directory "test/selenium"
+          append_file "test/test_helper.rb", generate_config
+        end
+      end
+
+      private
+
+      def generate_config
+        return <<-CONFIG
+
+require 'sauce'
+
+Sauce.config do |conf|
+    conf[:browsers] = [
+        ["Windows 2003", "firefox", "3.6."]
+    ]
+    conf[:application_host] = "127.0.0.1"
+    conf[:application_port] = "3001"
+    conf[:browser_url] = "http://localhost:3001/"
+end
+          CONFIG
+      end
+    end
+  end
+end

data/lib/parallel_tests/cli_patch.rb

@@ -0,0 +1,23 @@
+module ParallelTests
+  class CLI
+    def run_tests_in_parallel(num_processes, options)
+      test_results = nil
+
+      report_time_taken do
+        groups = @runner.tests_in_groups(options[:files], num_processes, options)
+        non_empty_groups = groups.reject {|group| group.empty?}
+        Sauce::TestBroker.test_groups = non_empty_groups
+
+        report_number_of_tests(non_empty_groups)
+
+        test_results = execute_in_parallel(non_empty_groups, non_empty_groups.size, options) do |group|
+          run_tests(group, Sauce::TestBroker.group_index(group), num_processes, options)
+        end
+
+        report_results(test_results)
+      end
+
+      abort final_fail_message if any_test_failed?(test_results)
+    end
+  end
+end

data/lib/parallel_tests/saucecucumber/runner.rb

@@ -0,0 +1,43 @@
+require "parallel_tests/cucumber/runner"
+
+module ParallelTests
+  module Saucecucumber
+    class Runner < ParallelTests::Cucumber::Runner
+
+      def self.run_tests(test_files, process_number, num_processes, options)
+        options = options.dup
+        sanitized_test_files = test_files.map { |val| Shellwords.escape(val) }
+        env = Sauce::TestBroker.next_environment(test_files)
+        env.merge!({"AUTOTEST" => "1"}) if $stdout.tty? # display color when we are in a terminal
+        options.merge!({:env => env})
+        cmd = [
+            executable,
+            (runtime_logging if File.directory?(File.dirname(runtime_log))),
+            cucumber_opts(options[:test_options]),
+            *sanitized_test_files
+        ].compact.join(" ")
+        execute_command(cmd, process_number, num_processes, options)
+      end
+
+      def self.tests_in_groups(tests, num_groups, options={})
+        originals = (options[:group_by] == :steps) ? Grouper.by_steps(find_tests(tests, options), num_groups, options) : super
+        all_tests = originals.flatten * Sauce::TestBroker.test_platforms(:cucumber).length
+        base_group_size = all_tests.length / num_groups
+        num_full_groups = all_tests.length - (base_group_size * num_groups)
+
+        curpos = 0
+        groups = []
+        num_groups.times do |i|
+          group_size = base_group_size
+          if i < num_full_groups
+            group_size += 1
+          end
+          groups << all_tests.slice(curpos, group_size)
+          curpos += group_size
+        end
+
+        groups
+      end
+    end
+  end
+end

data/lib/parallel_tests/saucerspec/runner.rb

@@ -0,0 +1,40 @@
+require "yaml"
+require "parallel_tests/rspec/runner"
+
+module ParallelTests
+  module Saucerspec
+    class Runner < ParallelTests::RSpec::Runner
+
+      def self.run_tests(test_files, process_number, num_processes, options)
+        our_options = options.dup
+        exe = executable # expensive, so we cache
+        version = (exe =~ /\brspec\b/ ? 2 : 1)
+        cmd = [exe, our_options[:test_options], (rspec_2_color if version == 2), spec_opts, *test_files].compact.join(" ")
+        env = Sauce::TestBroker.next_environment(test_files)
+        env << " #{rspec_1_color}" if version == 1
+        our_options.merge!(:env => env)
+        execute_command(cmd, process_number, num_processes, our_options)
+      end
+
+
+      def self.tests_in_groups(tests, num_groups, options={})
+        all_tests = super.flatten * Sauce::TestBroker.test_platforms(:rspec).length
+        base_group_size = all_tests.length / num_groups
+        num_full_groups = all_tests.length - (base_group_size * num_groups)
+
+        curpos = 0
+        groups = []
+        num_groups.times do |i|
+          group_size = base_group_size
+          if i < num_full_groups
+            group_size += 1
+          end
+          groups << all_tests.slice(curpos, group_size)
+          curpos += group_size
+        end
+
+        groups
+      end
+    end
+  end
+end

data/lib/sauce.rb

@@ -0,0 +1,33 @@
+if defined?(Rails)
+  require "sauce/railtie"
+else
+  require 'tasks/parallel_testing'
+end
+
+require 'sauce/version'
+require 'sauce/utilities'
+require 'sauce/utilities/rake'
+require 'sauce/job'
+require 'sauce/client'
+require 'sauce/config'
+require 'sauce/selenium'
+require 'sauce/test_base'
+require 'sauce/rspec/rspec'
+require 'sauce/test_unit'
+require 'parallel_tests/saucerspec/runner'
+require 'parallel_tests/saucecucumber/runner'
+
+
+# Ruby before 1.9.3-p382 does not handle exit codes correctly when nested
+if RUBY_VERSION == "1.9.3" && RUBY_PATCHLEVEL < 392
+  module Kernel
+    alias :existing_at_exit :at_exit
+    def at_exit(&block)
+      existing_at_exit do
+        exit_status = $!.status if $!.is_a?(SystemExit)
+        block.call
+        exit exit_status if exit_status
+      end
+    end
+  end
+end

data/lib/sauce/capybara.rb

@@ -0,0 +1,189 @@
+require 'capybara'
+require 'sauce/config'
+require 'sauce/selenium'
+require 'sauce/version'
+
+
+$sauce_tunnel = nil
+
+module Sauce
+  module Capybara
+    class Driver < ::Capybara::Selenium::Driver
+      RETRY_ON = [::Selenium::WebDriver::Error::UnhandledError,
+                  ::Selenium::WebDriver::Error::UnknownError]
+      MAX_RETRIES = 3
+
+      def handle_retry(method, *args, &block)
+        retries = 0
+
+        # Disable retries only when we really really want to, this will remain
+        # an undocomented hack for the time being
+        if ENV['SAUCE_DISABLE_RETRY']
+          retries = MAX_RETRIES
+        end
+
+        begin
+          send("base_#{method}".to_sym, *args, &block)
+        rescue *RETRY_ON => e
+          if retries < MAX_RETRIES
+            puts "Received an exception (#{e}), retrying"
+            retries = retries + 1
+            retry
+          else
+            raise
+          end
+        end
+      end
+
+      alias :base_visit :visit
+      alias :base_current_url :current_url
+      alias :base_within_frame :within_frame
+      alias :base_within_window :within_window
+      alias :base_find_window :find_window
+      alias :base_execute_script :execute_script
+      alias :base_evaluate_script :evaluate_script
+
+      @methods_to_retry = [:visit, :current_url,
+        :within_frame, :within_window, :find_window, :source,
+        :execute_script, :evaluate_script
+      ]
+
+      if method_defined? :find
+        alias :base_find :find
+        @methods_to_retry += [:find]
+      else
+        alias :base_find_css :find_css
+        alias :base_find_xpath :find_xpath
+        @methods_to_retry += [:find_css, :find_xpath]
+      end
+
+      if Gem::Version.new(::Capybara::VERSION) < Gem::Version.new(2)
+        alias :base_body :body
+        alias :base_source :source
+
+        @methods_to_retry + [:body, :source]
+      else
+        alias :base_html :html
+        @methods_to_retry + [:html]
+      end
+
+      @methods_to_retry.each do |method|
+        define_method(method) do |*args, &block|
+          handle_retry(method, *args, &block)
+        end
+      end
+
+      # Oh gods why didn't I comment these when I wrote them?
+      # These are what I think I'm doing.
+      #
+      # Returns the browser currently being used or fetches a new
+      # browser, either from the RSpec integration or by creating
+      # one.
+      def browser
+        # Return the existing browser if we have it
+        unless existing_browser?
+          # Try to get a driver from the driver pool
+          @browser = rspec_browser
+          unless @browser
+            @browser = Sauce::Selenium2.new
+            at_exit do
+              finish!
+            end
+          end
+        end
+        @browser
+      end
+
+      # Returns the rspec created browser if it exists
+      def rspec_browser
+        if browser = Sauce.driver_pool[Thread.current.object_id]
+          @using_rspec_browser = true
+        else
+          @using_rspec_browser = false
+        end
+        browser
+      end
+
+      # If a browser has been created OR RSpec has put one in the diriver pool
+      # and we're using that browser, returns true.
+      def existing_browser?
+        if @using_rspec_browser
+          @browser == Sauce.driver_pool[Thread.current.object_id]
+        else
+          @browser
+        end
+      end
+
+      def finish!
+        @browser.quit if existing_browser?
+        @browser = nil
+
+        # Rethink how to do this.  RSpec still references the driver pool.
+        Sauce.driver_pool[Thread.current.object_id] = nil
+        @using_rspec_browser = nil
+      end
+
+      def render(path)
+        browser.save_screenshot path
+      end
+    end
+
+    def self.configure_capybara
+      ::Capybara.configure do |config|
+        if Sauce::Config.new[:start_local_application]
+          config.server_port = Sauce::Config.get_application_port
+        end
+        begin
+          #config.always_include_port = true
+        rescue
+          # This option is only in Capybara 2+
+        end
+      end
+    end
+
+    def self.configure_capybara_for_rspec
+      begin
+        require "rspec/core"
+        ::RSpec.configure do |config|
+          config.before :suite do 
+            ::Capybara.configure do |capy_config|
+              sauce_config = Sauce::Config.new
+              if capy_config.app_host.nil?
+                if sauce_config[:start_local_application]
+                  host = sauce_config[:application_host] || "127.0.0.1"
+                  port = sauce_config[:application_port]
+                  capy_config.app_host = "http://#{host}:#{port}"
+                  capy_config.run_server = false
+                end
+              end
+            end
+          end
+        end
+      rescue LoadError => e
+        # User is not using RSpec
+      end
+    end
+  end
+end
+
+Capybara.register_driver :sauce do |app|
+  driver = Sauce::Capybara::Driver.new(app)
+end
+
+Sauce::Capybara.configure_capybara
+
+# Monkeypatch Capybara to not use :selenium driver
+require 'capybara/dsl'
+module Capybara
+  def self.javascript_driver
+    @javascript_driver || :sauce
+  end
+end
+
+module Sauce
+  module RSpec
+    module SeleniumExampleGroup
+      Sauce::Capybara.configure_capybara_for_rspec
+    end
+  end
+end