sauce_ruby 3.5.6

data/lib/sauce/driver_pool.rb

@@ -0,0 +1,5 @@
+module Sauce
+  def self.driver_pool
+    @@driver_pool ||= {}
+  end
+end

data/lib/sauce/heroku.rb

@@ -0,0 +1,18 @@
+module Sauce
+  if ENV['SAUCE_ONDEMAND_HEROKU_URL'] and ENV['URL']
+
+    # Heroku Configuation
+    config                   = JSON.parse RestClient.get(ENV['SAUCE_ONDEMAND_HEROKU_URL']).body
+    Sauce::Selenium_browsers = JSON.parse config["SAUCE_ONDEMAND_BROWSERS"]
+    Sauce::Selenium_url      =            "#{config['SAUCE_ONDEMAND_PROTOCOL']}#{ENV['URL']}"
+    Sauce::Selenium_host     =            config["SAUCE_ONDEMAND_SERVER"  ]
+    Sauce::Selenium_port     =            config["SAUCE_ONDEMAND_PORT"    ]
+  else
+    
+    # Local Configuration
+    Sauce::Selenium_url      = ENV['SELENIUM_URL']     || "http://localhost:3000"
+    Sauce::Selenium_host     = ENV['SELENIUM_HOST']    || "localhost"
+    Sauce::Selenium_port     = ENV['SELENIUM_PORT']    || "4444"
+    Sauce::Selenium_browsers = ENV['SELENIUM_BROWSER'] || ["*firefox"]
+  end
+end

data/lib/sauce/job.rb

@@ -0,0 +1,159 @@
+require 'sauce/client'
+
+module Sauce
+  # Interact with a Sauce Labs selenium jobs as if it were a ruby object
+  class Job
+
+    class CannotDeleteJobError < StandardError; end #:nodoc
+
+    attr_accessor :id, :owner, :status, :error
+    attr_accessor :name, :browser, :browser_version, :os
+    attr_accessor :creation_time, :start_time, :end_time
+    attr_accessor :public, :video_url, :log_url, :tags
+    attr_accessor :passed, :custom_data
+
+    # Get the class @@client.
+    # TODO: Consider metaprogramming this away
+    def self.client
+      @@client
+    end
+
+    # Set the class @@client.
+    # TODO: Consider metaprogramming this away
+    def self.client=(client)
+      @@client = client
+    end
+
+    # Get the class @@client.
+    # TODO: Consider metaprogramming this away
+    def self.account
+      @@account
+    end
+
+    # Set the class @@client.
+    # TODO: Consider metaprogramming this away
+    def self.account=(account)
+      @@account = account
+    end
+
+    def self.first
+      self.all.first
+    end
+
+    def self.last
+      self.all.last
+    end
+
+    # Misnomer: Gets the most recent 100 jobs
+    # TODO: Allow/automate paging
+    def self.all(options={})
+      url = "jobs"
+      url += "?full=true" if options[:full] #unless options[:id_only]
+      responses = @@client[url].get
+      responses = JSON.parse responses.to_s
+      return responses.collect{|response| Sauce::Job.new(response)}
+    end
+
+    def self.destroy
+      self.all.each { |tunnel| tunnel.destroy }
+    end
+
+    def self.find(options={})
+      if options.class == String
+        id = options
+      elsif options.class == Hash
+        id = options[:id]
+      end
+
+      @@client ||= Sauce::Client.new
+
+      #puts "GET-URL: #{@@client.url}jobs/#{id}"
+      response = @@client["jobs/#{id}"].get
+
+      # TODO: Return nil if bad response
+      Sauce::Job.new JSON.parse(response.to_s)
+    end
+
+    # Creates an instance representing a job.
+    def initialize(options)
+      build!(options)
+      @client = Sauce::Client.new
+    end
+
+    # Retrieves the latest information on this job from the Sauce Labs' server
+    def refresh!
+      response = JSON.parse @@client["jobs/#{@id}"].get.body
+      #puts "\tjob refresh with: #{response}"
+      build! response
+      self
+    end
+
+    # Save/update the current information for the job
+    def save
+      #puts "Saving job:\n -X PUT #{@@client['jobs']}/#{@id} -H 'Content-Type: application/json' -d '#{self.to_json}'"
+      response = @client["jobs/#{@id}"].put(self.to_json,
+                                             {:content_type => :json,
+                                               :accept => :json}).body
+      JSON.parse(response)
+    end
+
+    def to_json(options={})
+      json = {
+        :id =>              @id,
+        :'custom-data' =>   @custom_data,
+        :owner =>           @owner,
+        :status =>          @status,
+        :error =>           @error,
+        :name =>            @name,
+        :browser =>         @browser,
+        :browser_version => @browser_version,
+        :os =>              @os,
+        :creation_time =>   @creation_time,
+        :start_time =>      @start_time,
+        :end_time =>        @end_time,
+        :video_url =>       @video_url,
+        :log_url =>         @log_url,
+        :public =>          @public,
+        :tags =>            @tags,
+        :passed =>          @passed
+      }
+
+      options[:except].each { |key| json.delete(key) } if options[:except]
+      json = json.select { |key,value| options[:only].include? key } if options[:only]
+
+      return json.to_json
+    end
+
+    def delete
+      raise CannonDeleteJobError("Cannot delete jobs via Sauce Labs'  REST API currently")
+    end
+
+    protected
+
+    # Sets all internal variables from a hash
+    def build!(options)
+      # Massage JSON
+      options.each { |key,value| options[key] = false if options[key] == "false" }
+
+      @id              = options["id"]
+      @owner           = options["owner"]
+      @status          = options["status"]
+      @error           = options["error"]
+      @name            = options["name"]
+      @browser         = options["browser"]
+      @browser_version = options["browser_version"]
+      @os              = options["os"]
+      @creation_time   = options["creation_time"].to_i
+      @start_time      = options["start_time"].to_i
+      @end_time        = options["end_time"].to_i
+      @video_url       = options["video_url"]
+      @log_url         = options["log_url"]
+      @public          = options["public"]
+      @tags            = options["tags"]
+      @passed          = options["passed"]
+      @custom_data     = options['custom-data']
+
+      raise NoIDError if @id.nil? or @id.empty?
+    end
+  end
+end

data/lib/sauce/parallel.rb

@@ -0,0 +1,16 @@
+require 'parallel_tests'
+
+def start_tunnel_for_parallel_tests(c)
+  c[:start_tunnel] = ParallelTests.first_process?
+  if ParallelTests.first_process?
+    at_exit do
+      if ParallelTests.first_process?
+        ParallelTests.wait_for_other_processes_to_finish
+      end
+    end
+  else
+    while not File.exist? "sauce_connect.ready"
+      sleep 0.5
+    end
+  end
+end

data/lib/sauce/parallel/test_broker.rb

@@ -0,0 +1,110 @@
+require "rest-client"
+require "json"
+require "yaml"
+require "sauce/parallel/test_group"
+require "thread"
+
+module Sauce
+  class TestBroker
+    CUCUMBER_CONFIG_FILES = ["./features/support/sauce_helper.rb"]
+    RSPEC_CONFIG_FILES = ["./spec/sauce_helper.rb", "./spec/spec_helper.rb"]
+
+    def self.reset
+      if defined? @@platforms
+        remove_class_variable(:@@platforms)
+      end
+      @groups = {}
+    end
+
+    def self.environment_mutex
+      @@m ||= Mutex.new
+    end
+
+    def self.next_environment(group)
+      environment_mutex.synchronize do
+        browsers = {}
+        group.each do |file|
+          file = "./" + file
+          test_groups[file] ||= TestGroup.new(self.test_platforms)
+          browsers[file] ||= []
+          browsers[file] << test_groups[file].next_platform
+        end
+
+        on_windows = RbConfig::CONFIG['host_os'] =~ /cygwin|mswin|mingw|bccwin|wince|emx/
+        format_string = on_windows ? "%s" : "'%s'"
+        perfile_browsers = format_string % [JSON.generate(browsers)]
+
+        return {:SAUCE_PERFILE_BROWSERS => perfile_browsers}
+      end
+    end
+
+    def self.test_groups
+      @groups ||= {}
+    end
+
+    def self.test_groups=(groups)
+      @groups = groups.reduce({}) do |hash, g|
+        hash[g] = TestGroup.new(self.test_platforms)
+        hash
+      end
+
+      @group_indexes = groups.uniq.reduce({}) do |rh, g|
+        rh[g] =(groups.each_index.select {|i| groups[i] == g})
+        rh
+      end
+    end
+
+    def self.group_index(group)
+      @group_indexes[group].shift
+    end
+
+    def self.test_platforms(tool=:rspec)
+      unless defined? @@platforms
+        load_sauce_config(tool)
+        @@platforms ||= Sauce.get_config[:browsers]
+      end
+      @@platforms
+    end
+
+    def self.concurrency
+      response = RestClient.get "#{rest_jobs_url}/#{SAUCE_USERNAME}/limits"
+      res = JSON.parse(response)["concurrency"]
+    end
+
+    def self.rest_jobs_url
+      "https://#{AUTH_DETAILS}@saucelabs.com/rest/v1"
+    end
+
+    def self.load_sauce_config(tool=:rspec)
+      case tool
+        when :rspec
+          primary_files = RSPEC_CONFIG_FILES
+          secondary_files = CUCUMBER_CONFIG_FILES
+        when :cucumber
+          primary_files = CUCUMBER_CONFIG_FILES
+          secondary_files = RSPEC_CONFIG_FILES
+      end
+
+      configuration_file = self.find_config_file(primary_files, secondary_files)
+      unless configuration_file
+        possible_config_files = primary_files + secondary_files
+        error_message = "Could not find Sauce configuration. Please make sure one of the following files exists:\n"
+        error_message << possible_config_files.map { |file_path| "  - #{file_path}" }.join("\n")
+        raise error_message
+      end
+      require configuration_file
+    end
+
+    def self.find_config_file(primary_files, secondary_files)
+      find_in_file_list(primary_files) || find_in_file_list(secondary_files)
+    end
+
+    def self.find_in_file_list(list)
+      list.find { |file_path| File.exists?(file_path) }
+    end
+
+    SAUCE_USERNAME = ENV["SAUCE_USERNAME"]
+    SAUCE_ACCESS_KEY = ENV["SAUCE_ACCESS_KEY"]
+    AUTH_DETAILS = "#{SAUCE_USERNAME}:#{SAUCE_ACCESS_KEY}"
+  end
+end

data/lib/sauce/parallel/test_group.rb

@@ -0,0 +1,24 @@
+module Sauce
+  class TestGroup
+    def initialize(platforms)
+      @platforms = platforms
+      @index = 0
+    end
+
+    def next_platform
+      platform = @platforms[@index]
+      @index += 1
+      begin
+        caps ={
+          'os' => platform[0],
+          'browser' => platform[1],
+          'version' => platform[2]
+        }
+        caps.merge!({:caps => platform[3]}) if platform[3]
+        caps
+      rescue NoMethodError => e
+        puts "I don't have any config"
+      end
+    end
+  end
+end

data/lib/sauce/railtie.rb

@@ -0,0 +1,11 @@
+require 'sauce'
+require 'rails'
+module Sauce
+  class Railtie < Rails::Railtie
+    rake_tasks do
+      require 'sauce/version'
+      require 'sauce/utilities/rake'
+      require 'tasks/parallel_testing'
+    end
+  end
+end

data/lib/sauce/raketasks.rb

@@ -0,0 +1,83 @@
+require 'sauce'
+
+spec_prereq = File.exist?(File.join(::Rails.root.to_s, 'config', 'database.yml')) ? "db:test:prepare" : :noop
+task :noop do
+end
+
+class Rake::Task
+  def abandon
+    @actions.clear
+  end
+end
+
+include Sauce::Utilities
+
+if defined?(Spec::Rake::SpecTask)
+  namespace :spec do
+    namespace :selenium do
+      desc "Run the Selenium acceptance tests in spec/selenium using Sauce OnDemand"
+      task :sauce => spec_prereq do
+        Rake::Task["spec:selenium:runtests"].invoke
+      end
+
+      desc "" # Hide it from rake -T
+      Spec::Rake::SpecTask.new :runtests do |t|
+        t.spec_opts = ['--options', "\"#{Rails.root.join('spec', 'spec.opts')}\""]
+        spec_glob = ENV["SAUCE_SPEC_GLOB"] || "spec/selenium/**/*_spec.rb"
+        t.spec_files = FileList[spec_glob]
+      end
+    end
+
+    task :selenium => "selenium:sauce"
+  end
+
+  Rake::Task[:spec].abandon
+  desc "Run all specs in spec directory (excluding plugin specs)"
+  Spec::Rake::SpecTask.new(:spec => spec_prereq) do |t|
+    t.spec_opts = ['--options', "\"#{RAILS_ROOT}/spec/spec.opts\""]
+    t.spec_files = FileList['spec/**/*_spec.rb'].exclude('spec/selenium/*')
+  end
+end
+
+if defined?(RSpec::Core::RakeTask)
+  namespace :spec do
+    namespace :selenium do
+      desc "Run the Selenium acceptance tests in spec/selenium using Sauce OnDemand"
+      task :sauce => spec_prereq do
+        Rake::Task["spec:selenium:runtests"].invoke
+      end
+
+      desc "" # Hide it from rake -T
+      RSpec::Core::RakeTask.new :runtests do |t|
+        spec_glob = ENV["SAUCE_SPEC_GLOB"] || "spec/selenium/**/*_spec.rb"
+        t.pattern = spec_glob
+      end
+    end
+
+    task :selenium => "selenium:sauce"
+  end
+end
+
+if defined?(Rake::TestTask)
+  namespace :test do
+    namespace :selenium do
+      desc "Run the Selenium acceptance tests in test/selenium using Sauce OnDemand"
+      task :sauce do
+        Rake::Task["test:selenium:runtests"].invoke
+      end
+
+      Rake::TestTask.new(:runtests) do |t|
+        t.libs << "test"
+        test_glob = ENV["SAUCE_TEST_GLOB"] || "test/selenium/**/*_test.rb"
+        t.pattern = test_glob
+        t.verbose = true
+      end
+      # Hide it from rake -T
+      Rake::Task['test:selenium:runtests'].instance_variable_set(:@full_comment, nil)
+      Rake::Task['test:selenium:runtests'].instance_variable_set(:@comment, nil)
+      Rake::Task['test:selenium:runtests'].enhance(["db:test:prepare"])
+    end
+
+    task :selenium => "selenium:sauce"
+  end
+end

data/lib/sauce/rspec/rspec.rb

@@ -0,0 +1,186 @@
+require 'sauce/utilities'
+require 'sauce_whisk'
+require 'sauce/rspec/rspec_one_support'
+require 'sauce/rspec/rspec_formatter'
+
+begin
+  require 'rspec/core'
+  module Sauce
+    module RSpec
+      @@server = nil
+
+      def self.server
+        return @@server
+      end
+
+      def self.server=(s)
+        @@server = s
+      end
+
+      def self.setup_environment
+        ::RSpec.configuration.before(:all, :sauce => true) do
+          Sauce::RSpec.start_tools_for_sauce_tag
+        end
+
+        ::RSpec.configuration.before :all do
+          Sauce::RSpec.start_tools_for_selenium_directory
+          Sauce::RSpec.register_default_hook
+          Sauce::RSpec.register_jenkins_hook if ENV['JENKINS_SERVER_COOKIE']
+        end
+        
+        ::RSpec.configuration.after :suite do
+          Sauce::RSpec.stop_tools
+        end
+      end
+
+      def self.start_tools_for_sauce_tag
+        config = Sauce::Config.new
+        if config[:start_tunnel]
+          Sauce::Utilities::Connect.start_from_config(config)
+        end
+
+        unless self.server
+          self.server= Sauce::Utilities::RailsServer.start_if_required(config)
+        end
+      end
+
+      def self.start_tools_for_selenium_directory
+        config = Sauce::Config.new
+        # TODO: Check which rspec version this changed in -- If < 2, change.
+        files_to_run = ::RSpec.configuration.respond_to?(:files_to_run) ? ::RSpec.configuration.files_to_run :
+          ::RSpec.configuration.settings[:files_to_run]
+
+        running_selenium_specs = files_to_run.any? {|file| file =~ /spec\/selenium\//}
+        need_tunnel = running_selenium_specs && config[:application_host]
+
+        if need_tunnel && config[:start_tunnel]
+          Sauce::Utilities::Connect.start_from_config(config)
+        end
+
+        if running_selenium_specs
+          unless self.server
+            self.server= Sauce::Utilities::RailsServer.start_if_required(config)
+          end
+        end
+      end
+
+      def self.register_default_hook
+        Sauce.config do |c|
+          c.after_job :rspec do |id, platform, name, success|
+            SauceWhisk::Jobs.change_status id, success
+          end
+        end
+      end
+
+      def self.register_jenkins_hook
+        Sauce.config do |c|
+          c.after_job :jenkins do |id, platform, name, success|
+            puts "SauceOnDemandSessionID=#{id} job-name=#{name}"
+          end
+        end
+      end
+      
+      def self.stop_tools
+        Sauce::Utilities::Connect.close
+        server.stop if self.server
+        Sauce::Utilities.warn_if_suspect_misconfiguration
+      end
+
+      module SeleniumExampleGroup
+        include Sauce::TestBase
+        attr_reader :selenium
+        alias_method :s, :selenium
+
+        def self.rspec_current_example
+          lambda { |context| ::RSpec.current_example }
+        end
+
+        def self.context_example
+          lambda { |context| context.example }
+        end
+
+        def self.find_example_method
+          ::RSpec.respond_to?(:current_example) ? rspec_current_example : context_example 
+        end
+
+        def self.current_example
+          @@current_example_fetcher ||= find_example_method
+        end
+
+        # TODO V4 -- Remove this entirely
+        def page
+          if self.class.included_modules.any? {|m| m.name == 'Capybara::DSL'}
+            ::Capybara.current_session
+          else
+            warn Sauce::Utilities.page_deprecation_message
+            @selenium
+          end
+        end
+
+        def self.included(othermod)
+          othermod.around do |the_test|
+            config = Sauce::Config.new
+            description = the_test.metadata[:full_description]
+            file = the_test.metadata[:file_path]
+            exceptions = {}
+            test_each config.caps_for_location(file), description do |selenium, caps|
+
+              example = SeleniumExampleGroup.current_example.call(self)
+              example.instance_variable_set(:@exception, nil)
+              
+              @selenium = selenium
+              Sauce.driver_pool[Thread.current.object_id] = @selenium
+              example.metadata[:sauce_public_link] = SauceWhisk.public_link(@selenium.session_id)
+
+              begin
+                the_test.run
+                success = example.exception.nil?
+              ensure
+                @selenium.stop
+                begin
+                  os = caps[:os]
+                  browser = caps[:browser]
+                  version = caps[:version]
+                  unless success
+                    exceptions["#{os} - #{browser} #{version}"] = example.exception
+                  end
+                  platform = {:os => os, :browser => browser, :version => version}
+                  config.run_post_job_hooks(@selenium.session_id, platform, description, success)
+                rescue Exception => e
+                  STDERR.puts "Error running post job hooks"
+                  STDERR.puts e
+                end
+                Sauce.driver_pool.delete Thread.current.object_id
+              end
+              if (exceptions.length > 0)
+                example.instance_variable_set(:@exception, exceptions.first[1])
+              end
+            end
+          end
+        end
+
+        def self.inclusion_params
+          params = [self]
+          gem_version = Gem::Version.new ::RSpec::Core::Version::STRING
+          file_path_hash = {:file_path => Regexp.compile('spec[\\\/]selenium')}
+          if (gem_version >= Gem::Version.new('2.99.0'))
+            params = params + [file_path_hash]
+          else
+            params = params + [{:example_group => file_path_hash}]
+          end
+          params
+        end
+
+        ::RSpec.configuration.include(*self.inclusion_params)
+        ::RSpec.configuration.include(self, :sauce => true)
+
+        Sauce::RSpec.setup_environment
+      end
+    end
+  end
+rescue LoadError, TypeError
+  # User doesn't have RSpec 2.x installed
+rescue => e
+  STDERR.puts "Exception caught: #{e.to_s}"
+  exit 1
+end