sauce_ruby 3.5.6

data/lib/sauce/utilities/rails_server.rb

@@ -0,0 +1,95 @@
+require 'childprocess'
+require 'childprocess/process'
+
+module Sauce
+  module Utilities
+    class RailsServer
+      include Sauce::Utilities
+
+      def self.start_if_required(config)
+        if config[:start_local_application] && self.is_rails_app?
+          server = new
+          server.start
+
+          return server
+        end
+
+        return server
+      end
+
+      def self.is_rails_app?
+        return !major_version.nil?
+      end
+
+      def self.major_version
+        paths = ["script/server", "script/rails", "bin/rails"]
+        startup_script = paths.detect {|path| File.exists? path}
+
+        case startup_script
+          when 'script/server'
+            return 2
+          when 'script/rails'
+            return 3
+          when 'bin/rails'
+            return 4
+          else
+            return nil
+        end
+      end
+
+      def self.process_arguments
+        case major_version
+          when 2
+            ["ruby", "script/server"]
+          else
+            ["bundle", "exec", "rails", "server"]
+        end
+      end
+
+      def self.server_pool
+        @@server_pool ||= {}
+      end
+
+      attr_reader :port
+
+      def start
+        @port = Sauce::Config.new[:application_port]
+
+        if ENV["TEST_ENV_NUMBER"]
+          @test_env = ENV["TEST_ENV_NUMBER"].to_i
+        end
+
+        STDERR.puts "Starting Rails server on port #{@port}..."
+
+        @process_args = RailsServer.process_arguments
+        @process_args.push *["-e", "test", "--port", "#{@port}"]
+
+        if @test_env
+          @process_args.push *["--pid", "#{Dir.pwd}/tmp/pids/server-#{@test_env}"]
+        end
+
+        @server = ChildProcess.build *@process_args
+        @server.io.inherit!
+        @server.start
+
+        wait_for_server_on_port(@port)
+
+        at_exit do
+          @server.stop(3, "INT")
+          RailsServer.server_pool.delete Thread.current.object_id
+        end
+        STDERR.puts "Rails server running!"
+
+        RailsServer.server_pool[Thread.current.object_id] = @server
+      end
+
+      def stop
+        begin
+          @server.stop(3, "INT")
+        rescue
+          STDERR.puts "Rails server could not be killed. Did it fail to start?"
+        end
+      end
+    end
+  end
+end

data/lib/sauce/utilities/rake.rb

@@ -0,0 +1,32 @@
+module Sauce
+  module Utilities
+    module Rake
+
+      def self.sauce_helper
+        helper_text = <<-ENDHEADER
+# You should edit this file with the browsers you wish to use
+# For options, check out http://saucelabs.com/docs/platforms
+require "sauce"
+        ENDHEADER
+
+        helper_text << "require \"sauce/capybara\"" if Object.const_defined? "Capybara"
+        helper_text << <<-ENDFILE
+
+Sauce.config do |config|
+  config[:browsers] = [
+    ["OS", "BROWSER", "VERSION"],
+    ["OS", "BROWSER", "VERSION"]
+  ]
+  config[:sauce_connect_4_executable] = # path to Sauce Connect 4 executable
+end
+        ENDFILE
+        if Object.const_defined? "Capybara"
+          helper_text << "Capybara.default_driver = :sauce \n"
+          helper_text << "Capybara.javascript_driver = :sauce"
+        end
+        
+        return helper_text
+      end
+    end
+  end
+end

data/lib/sauce/version.rb

@@ -0,0 +1,9 @@
+module Sauce
+  MAJOR_VERSION = '3.5'
+  PATCH_VERSION = '6'
+
+  def version
+    "#{MAJOR_VERSION}.#{PATCH_VERSION}"
+  end
+  module_function :version
+end

data/lib/sauce/webmock.rb

@@ -0,0 +1,16 @@
+require 'webmock/config'
+
+config = WebMock::Config.instance
+
+unless config.allow_net_connect
+  allow_localhost = config.allow_localhost
+  allow = config.allow || []
+  allow << /saucelabs.com/
+  connect_on_start = config.net_http_connect_on_start
+
+  WebMock.disable_net_connect!(
+    :allow_localhost => allow_localhost,
+    :allow => allow, 
+    :net_http_connect_on_start => connect_on_start
+  )
+end

data/lib/tasks/parallel_testing.rb

@@ -0,0 +1,148 @@
+require "sauce/parallel/test_broker"
+require "parallel_tests"
+require "parallel_tests/tasks"
+require "parallel_tests/cli_patch"
+require "shellwords"
+
+namespace :sauce do
+  desc "Run specs in parallel on Sauce Labs"
+  task :spec, :files, :concurrency, :test_options, :parallel_options do |t, args|
+    ::RSpec::Core::Runner.disable_autorun!
+    run_parallel_tests(t, args, :rspec)
+  end
+
+  desc "Run features in parallel on Sauce Labs"
+  task :features, :files, :concurrency, :test_options, :parallel_options do |t, args|
+    run_parallel_tests(t, args, :cucumber)
+  end
+
+  namespace :install do
+    desc "Set up your Cucumber features to run in parallel on Sauce Labs"
+    task :features do
+      Rake::Task["sauce:install:create_helper"].execute(:helper_type => :features)
+      puts <<-ENDLINE
+  -----------------------------------------------------------------------
+  The Sauce gem is now installed!
+
+  Next steps:
+
+  1.  Edit features/support/sauce_helper.rb with your required platforms
+  2.  Set the SAUCE_USERNAME and SAUCE_ACCESS_KEY environment variables
+  3.  Run your tests with 'rake sauce:features'
+  -----------------------------------------------------------------------
+      ENDLINE
+    end
+
+    desc "Set up your specs to run in parallel on Sauce Labs"
+    task :spec do
+      Rake::Task["sauce:install:create_helper"].execute(:helper_type => :spec)
+      helper_path = File.exist?("spec/rails_helper.rb") ? "spec/rails_helper.rb" : "spec/spec_helper.rb"
+      unless File.open(helper_path) { |f| f.read.match "require \"sauce_helper\""}
+        File.open(helper_path, "a") do |f|
+          f.write "require \"sauce_helper\""
+        end
+      else
+        STDERR.puts "WARNING - The Sauce gem is already integrated into your rspec setup"
+      end
+      puts <<-ENDLINE
+  --------------------------------------------------------------------------------
+  The Sauce gem is now installed!
+
+  Next steps:
+
+  1.  Edit spec/sauce_helper.rb with your required platforms & Sauce Connect 4 path
+  2.  Make sure we've not mangled your spec/*_helper.rb requiring sauce_helper
+  3.  Set the SAUCE_USERNAME and SAUCE_ACCESS_KEY environment variables
+  3.  Run your tests with 'rake sauce:spec'
+  --------------------------------------------------------------------------------
+      ENDLINE
+    end
+
+    task :create_helper, [:helper_type] do |t, args|
+      path = args[:helper_type].to_sym == :features ? "features/support/sauce_helper.rb" : "spec/sauce_helper.rb"
+      unless File.exists? path
+        File.open(path, "w") do |f|
+          f.write(Sauce::Utilities::Rake.sauce_helper)
+        end
+      else
+        STDERR.puts "WARNING - sauce_helper has already been created."
+      end
+    end
+  end
+end
+
+def run_parallel_tests(t, args, command)
+  if ParallelTests.number_of_running_processes == 0
+    username    = ENV["SAUCE_USERNAME"].to_s
+    access_key  = ENV["SAUCE_ACCESS_KEY"].to_s
+    if(!username.empty? && !access_key.empty?)
+      parallel_arguments = parse_task_args(command, args)
+      ParallelTests::CLI.new.run(parallel_arguments)
+    else
+      puts <<-ENDLINE
+    -----------------------------------------------------------------------
+    Your Sauce username and/or access key are unavailable. Please:
+    1.  Set the SAUCE_USERNAME and SAUCE_ACCESS_KEY environment variables.
+    2.  Rerun your tests.
+    -----------------------------------------------------------------------
+      ENDLINE
+    end
+  else
+    puts <<-ENDLINE
+  ---------------------------------------------------------------------------
+  There are already parallel_tests processes running.  This can interfere
+  with test startup and shutdown.
+
+  If you're not running other parallel tests, this might be caused by zombie
+  processes (The worst kind of processes).  Kill `em off and try again.
+  ---------------------------------------------------------------------------
+    ENDLINE
+    exit(1)
+  end
+end
+
+def parse_task_args(test_tool=:rspec, args)
+  default = {
+    :concurrency => [Sauce::TestBroker.concurrency, 20].min
+  }
+
+  if test_tool == :rspec
+    default[:test_options] = '-t sauce'
+    default[:files] = 'spec'
+  end
+
+  if test_tool == :cucumber
+    default[:files] = 'features'
+  end
+
+  env_args = {
+    :concurrency => ENV['concurrency'],
+    :features => ENV['features'],
+    :parallel_options => ENV['parallel_test_options'],
+    :test_options => ENV['test_options'],
+    :files => ENV['test_files']
+  }
+
+  concurrency = args[:concurrency] || env_args[:concurrency] || default[:concurrency]
+  test_options = args[:test_options] || env_args[:test_options] || default[:test_options]
+  parallel_options = args[:parallel_options] || env_args[:parallel_options]
+  files = args[:files] || env_args[:files] || default[:files]
+
+  return_args = [
+    '-n', concurrency.to_s,
+    '--type'
+  ]
+
+  return_args.push 'saucerspec' if test_tool == :rspec
+  return_args.push 'saucecucumber' if test_tool == :cucumber
+
+  if test_options
+    return_args.push '-o'
+    return_args.push test_options
+  end
+
+  return_args.push *(parallel_options.split(' ')) if parallel_options
+  return_args.concat files.split
+
+  return return_args
+end

data/spec/cucumber_helper.rb

@@ -0,0 +1,42 @@
+# NOTE: This file is verbatim "borrowed" from the cucumber source tree:
+# <https://github.com/cucumber/cucumber/blob/master/spec/cucumber/formatter/spec_helper.rb>
+
+require 'cucumber'
+
+module Sauce
+  module Cucumber
+    module SpecHelper
+      def run_defined_feature(content)
+        features = load_features(content || raise("No feature content defined!"))
+        run(features)
+      end
+
+      def step_mother
+        @step_mother ||= ::Cucumber::Runtime.new
+      end
+
+      def load_features(content)
+        feature_file = ::Cucumber::FeatureFile.new('mock.feature', content)
+        features = ::Cucumber::Ast::Features.new
+        filters = []
+        feature = feature_file.parse(filters, {})
+        features.add_feature(feature) if feature
+        features
+      end
+
+      def run(features)
+        configuration = ::Cucumber::Configuration.default
+        tree_walker = ::Cucumber::Ast::TreeWalker.new(step_mother, [@formatter], configuration)
+        tree_walker.visit_features(features)
+      end
+
+      def define_steps(&block)
+        rb = step_mother.load_programming_language('rb')
+        dsl = Object.new
+        dsl.extend ::Cucumber::RbSupport::RbDsl
+        dsl.instance_exec &block
+      end
+    end
+  end
+end
+

data/spec/integration/connect/spec/spec_helper.rb

@@ -0,0 +1,21 @@
+require "simplecov"
+
+SimpleCov.start do
+  SimpleCov.root "#{Dir.pwd}/../../../"
+  command_name 'Connect Integration'
+  use_merging true
+  merge_timeout 6000
+end
+
+require "sauce"
+require "capybara/rspec"
+require "sauce/capybara"
+
+Sauce.config do |c|
+  c[:start_tunnel] = true
+  c[:warn_on_skipped_integration] = false
+  c[:sauce_connect_4_executable] = ENV["SAUCE_CONNECT_4_EXECUTABLE"]
+ end
+
+app = proc { |env| [200, {}, ["Hello Sauce!"]]}
+Capybara.app = app

data/spec/integration/connect/spec/start_tunnel_spec.rb

@@ -0,0 +1,9 @@
+require "spec_helper"
+
+describe "Sauce::Config" do
+  it "should start Connect when start_tunnel is set" do
+    tunnel = Sauce::Utilities::Connect.tunnel
+    tunnel.should_not be_nil
+    tunnel.status.should eq "running"
+  end
+end

data/spec/integration/connect/spec/with_capybara_spec.rb

@@ -0,0 +1,10 @@
+require "spec_helper"
+
+describe "Capybara" do
+	describe "Without :sauce tagging", :js => true, :type => :feature do
+    it "should connect using the port", :js => true do
+      visit "/"
+      expect(page).to have_content "Hello Sauce!"
+    end
+  end
+end

data/spec/integration/connect_integration_spec.rb

@@ -0,0 +1,99 @@
+require 'spec_helper'
+require 'sauce/connect'
+
+describe 'Sauce::Connect integration testing' do
+  def make_connection
+    Sauce::Connect.new({})
+  end
+
+  def backup_and_wipe_env_var(var)
+    self.instance_variable_set("@env_#{var}",  ENV[var])
+    ENV[var] = nil
+  end
+
+  def restore_env_var(var)
+    value_of_variable = self.instance_variable_get("@env_#{var}")
+    ENV[var] = value_of_variable unless value_of_variable.nil? 
+  end
+
+  before :each do
+    Sauce.clear_config
+  end
+
+  context 'assuming valid Sauce Labs authentication' do
+    # Defining a nil in the let since the before block will run after the let.
+    # Running make_connection inside of a `let` block could end up with us
+    # using the previous test's Sauce.config. BAD NEWS
+    before :each do
+      @conn = make_connection
+    end
+
+    it 'should have start with an uninitialized status' do
+      @conn.status.should == 'uninitialized'
+    end
+
+    it 'should have a "running" status if the tunnel is connected' do
+      @conn.connect
+      @conn.wait_until_ready
+      @conn.status.should == 'running'
+    end
+
+    after :each do
+      @conn.disconnect if @conn
+    end
+  end
+
+  context 'assuming an invalid/nonexistent username' do
+    before :each do
+      Sauce.config do |config|
+        config[:username] = nil
+        config[:access_key] = nil
+      end
+    end
+
+    it 'should fail if the SAUCE_USERNAME is empty' do
+      expect {
+        backup_and_wipe_env_var "SAUCE_USERNAME"
+        ENV['SAUCE_USERNAME'] = nil
+        make_connection
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'should fail if the SAUCE_ACCESS_KEY is empty' do
+      expect {
+        backup_and_wipe_env_var "SAUCE_ACCESS_KEY"
+        backup_and_wipe_env_var "SAUCE_USERNAME"
+
+        ENV['SAUCE_USERNAME'] = 'testman'
+        make_connection
+      }.to raise_error(ArgumentError)
+
+    end
+
+    after :each do
+      restore_env_var "SAUCE_USERNAME"
+      restore_env_var "SAUCE_ACCESS_KEY"
+    end
+  end
+
+  context 'assuming the "fail" username' do
+    let(:conn) { Sauce::Connect.new(:host => 'saucelabs.com',
+                                    :port => 80,
+                                    :username => 'fail',
+                                    :access_key => 'edededdedededeee') }
+
+    it 'should set the error status' do
+      start = Time.now
+      conn.connect
+      while ((Time.now - start) < 60) && !conn.error
+        sleep 0.5
+      end
+
+      conn.error.should_not be nil
+    end
+
+    after :each do
+      conn.disconnect
+    end
+  end
+end