sauce 1.0.2 → 2.0.0

data/lib/sauce/raketasks.rb

@@ -20,13 +20,6 @@ if defined?(Spec::Rake::SpecTask)
         Rake::Task["spec:selenium:runtests"].invoke
       end
 
-      desc "Run the Selenium acceptance tests in spec/selenium using a local Selenium server"
-      task :local => spec_prereq do
-        with_selenium_rc do
-          Rake::Task["spec:selenium:runtests"].invoke
-        end
-      end
-
       desc "" # Hide it from rake -T
       Spec::Rake::SpecTask.new :runtests do |t|
         t.spec_opts = ['--options', "\"#{Rails.root.join('spec', 'spec.opts')}\""]
@@ -54,13 +47,6 @@ if defined?(RSpec::Core::RakeTask)
         Rake::Task["spec:selenium:runtests"].invoke
       end
 
-      desc "Run the Selenium acceptance tests in spec/selenium using a local Selenium server"
-      task :local => spec_prereq do
-        with_selenium_rc do
-          Rake::Task["spec:selenium:runtests"].invoke
-        end
-      end
-
       desc "" # Hide it from rake -T
       RSpec::Core::RakeTask.new :runtests do |t|
         spec_glob = ENV["SAUCE_SPEC_GLOB"] || "spec/selenium/**/*_spec.rb"
@@ -80,13 +66,6 @@ if defined?(Rake::TestTask)
         Rake::Task["test:selenium:runtests"].invoke
       end
 
-      desc "Run the Selenium acceptance tests in spec/selenium using a local Selenium server"
-      task :local do
-        with_selenium_rc do
-          Rake::Task["test:selenium:runtests"].invoke
-        end
-      end
-
       Rake::TestTask.new(:runtests) do |t|
         t.libs << "test"
         test_glob = ENV["SAUCE_TEST_GLOB"] || "test/selenium/**/*_test.rb"

data/lib/sauce/selenium.rb

@@ -1,29 +1,20 @@
 require "selenium/client"
 require "selenium/webdriver"
 
-module Sauce
-  class Selenium < ::Selenium::Client::Driver
-    def initialize(opts={})
-      @config = Sauce::Config.new(opts)
-      super(opts.merge({:host => @config.host, :port => @config.port,
-           :browser => @config.to_browser_string, :url => @config.browser_url}))
-    end
-
-    def passed!
-      self.set_context "sauce:job-result=passed"
-    end
-
-    def failed!
-      self.set_context "sauce:job-result=failed"
-    end
-  end
+require 'selenium/webdriver/remote/http/persistent'
 
+module Sauce
   class Selenium2
+    attr_reader :config, :driver
+
     def initialize(opts={})
       @config = Sauce::Config.new(opts)
-      http_client = ::Selenium::WebDriver::Remote::Http::Default.new
+      http_client = ::Selenium::WebDriver::Remote::Http::Persistent.new
       http_client.timeout = 300 # Browser launch can take a while
-      @driver = ::Selenium::WebDriver.for(:remote, :url => "http://#{@config.username}:#{@config.access_key}@#{@config.host}:#{@config.port}/wd/hub", :desired_capabilities => @config.to_desired_capabilities, :http_client => http_client)
+      @driver = ::Selenium::WebDriver.for(:remote,
+                      :url => "http://#{@config.username}:#{@config.access_key}@#{@config.host}:#{@config.port}/wd/hub",
+                      :desired_capabilities => @config.to_desired_capabilities,
+                      :http_client => http_client)
       http_client.timeout = 90 # Once the browser is up, commands should time out reasonably
     end
 

data/lib/sauce/utilities.rb

@@ -30,23 +30,6 @@ module Sauce
       end
     end
 
-    def with_selenium_rc
-      ENV['LOCAL_SELENIUM'] = "true"
-      STDERR.puts "Starting Selenium RC server on port 4444..."
-
-      jar_file = File.expand_path(File.dirname(__FILE__) + "/../../support/selenium-server.jar")
-      command = ["java", "-jar", jar_file, "-port", "4444"]
-      server = ChildProcess.build(*command)
-      server.start
-      wait_for_server_on_port(4444)
-      STDERR.puts "Selenium RC running!"
-      begin
-        yield
-      ensure
-        Net::HTTP.get("127.0.0.1", "/selenium-server/driver/?cmd=shutDownSeleniumServer", 4444)
-      end
-    end
-
     class RailsServer
       include Sauce::Utilities
 

data/sauce.gemspec

@@ -2,74 +2,23 @@
 
 Gem::Specification.new do |s|
   s.name = %q{sauce}
-  s.version = "1.0.2"
+  s.version = '2.0.0'
 
   s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
-  s.authors = ["Eric Allen", "Sean Grove", "Steven Hazel", "Santiago Suarez Ordoñez"]
-  s.date = %q{2011-07-25}
+  s.authors = ["Eric Allen", "Sean Grove", "Steven Hazel", "R. Tyler Croy", "Santiago Suarez Ordoñez"]
+  s.date = %q{2012-06-26}
   s.default_executable = %q{sauce}
   s.description = %q{A Ruby interface to Sauce OnDemand.}
   s.email = %q{help@saucelabs.com}
   s.executables = ["sauce"]
-  s.files = [
-    "LICENSE",
-    "README.markdown",
-    "Rakefile",
-    "bin/sauce",
-    "examples/helper.rb",
-    "examples/other_spec.rb",
-    "examples/saucelabs_spec.rb",
-    "examples/test_saucelabs.rb",
-    "examples/test_saucelabs2.rb",
-    "generators/sauce/sauce_generator.rb",
-    "generators/sauce/templates/sauce.rake",
-    "lib/generators/sauce/install/install_generator.rb",
-    "lib/generators/sauce/install/templates/sauce.rake",
-    "lib/sauce.rb",
-    "lib/sauce/capybara.rb",
-    "lib/sauce/client.rb",
-    "lib/sauce/config.rb",
-    "lib/sauce/connect.rb",
-    "lib/sauce/heroku.rb",
-    "lib/sauce/integrations.rb",
-    "lib/sauce/job.rb",
-    "lib/sauce/raketasks.rb",
-    "lib/sauce/selenium.rb",
-    "lib/sauce/utilities.rb",
-    "sauce.gemspec",
-    "support/sauce_connect",
-    "support/selenium-server.jar",
-    "support/simplejson/LICENSE.txt",
-    "support/simplejson/__init__.py",
-    "support/simplejson/decoder.py",
-    "support/simplejson/encoder.py",
-    "support/simplejson/ordered_dict.py",
-    "support/simplejson/scanner.py",
-    "support/simplejson/tool.py",
-    "test/helper.rb",
-    "test/test_config.rb",
-    "test/test_job.rb",
-    "test/test_connect.rb",
-    "test/test_selenium.rb",
-    "test/test_selenium2.rb"
-  ]
+  # Include pretty much everything in Git except the examples/ directory
+  s.files = `git ls-files`.split("\n").collect { |f| f unless f.include? 'examples' }.compact
   s.homepage = %q{http://github.com/saucelabs/sauce_ruby}
   s.require_paths = ["lib"]
-  s.rubygems_version = %q{1.4.2}
+  s.rubygems_version = %q{2.0.0}
   s.summary = %q{Ruby access to Sauce Labs' features}
-  s.test_files = [
-    "examples/helper.rb",
-    "examples/other_spec.rb",
-    "examples/saucelabs_spec.rb",
-    "examples/test_saucelabs.rb",
-    "examples/test_saucelabs2.rb",
-    "test/helper.rb",
-    "test/test_config.rb",
-    "test/test_connect.rb",
-    "test/test_selenium.rb",
-    "test/test_job.rb",
-    "test/test_selenium2.rb"
-  ]
+  s.test_files = Dir['test/*.rb']
+  s.add_dependency('net-http-persistent')
 
   if s.respond_to? :specification_version then
     s.specification_version = 3
@@ -104,4 +53,3 @@ Gem::Specification.new do |s|
     s.add_dependency(%q<highline>, [">= 1.5.0"])
   end
 end
-

data/spec/integration/connect_integration_spec.rb

@@ -0,0 +1,84 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+
+describe 'Sauce::Connect integration testing' do
+  def make_connection
+    Sauce::Connect.new({})
+  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 also empty' do
+      expect {
+        ENV['SAUCE_USERNAME'] = nil
+        make_connection
+      }.to raise_error(ArgumentError)
+    end
+
+    it 'should fail if the SAUCE_ACCESS_KEY is empty' do
+      expect {
+        ENV['SAUCE_USERNAME'] = 'testman'
+        ENV['SAUCE_ACCESS_KEY'] = nil
+        make_connection
+      }.to raise_error(ArgumentError)
+
+    end
+
+    after :each do
+      ENV['SAUCE_USERNAME'] = nil
+    end
+  end
+
+  context 'assuming the "fail" username' do
+    let(:conn) { Sauce::Connect.new(:host => 'saucelabs.com',
+                                    :port => 80,
+                                    :username => 'fail') }
+
+    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

data/spec/sauce/capybara/cucumber_spec.rb

@@ -0,0 +1,156 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'sauce/capybara'
+require 'sauce/capybara/cucumber'
+
+# We need to pull in our local spec_helper.rb to test cucumbery things
+require File.dirname(__FILE__) + '/spec_helper'
+
+module Sauce::Capybara
+  describe Cucumber do
+    include Sauce::Capybara::Cucumber
+    include Sauce::Cucumber::SpecHelper
+
+    describe '#use_sauce_driver' do
+      before :each do
+        ::Capybara.current_driver = :test
+      end
+
+      it 'should change Capybara.current_driver to :sauce' do
+        use_sauce_driver
+        ::Capybara.current_driver.should == :sauce
+      end
+    end
+
+    describe 'generating job names' do
+      context 'with a simple, standard scenario' do
+        let(:scenario) do
+          s = double('Cucumber::AST::Scenario')
+          s.stub(:name).and_return('This is a simple scenario')
+          s
+        end
+        let(:feature) do
+          f = double('Cucumber::AST::Feature')
+          f.stub(:short_name).and_return('A simple feature')
+          f
+        end
+
+        before :each do
+          scenario.stub(:feature).and_return(feature)
+        end
+
+        describe '#name_from_scenario' do
+          it 'should generated a useful name' do
+            expected = 'A simple feature - This is a simple scenario'
+            name_from_scenario(scenario).should == expected
+          end
+        end
+
+        describe 'jenkins_name_from_scenario' do
+          it 'should generate the dotted name the Jenkins plugin wants' do
+            expected = 'A simple feature.This is a simple scenario.This is a simple scenario'
+            jenkins_name_from_scenario(scenario).should == expected
+          end
+        end
+      end
+    end
+
+    context 'Around hook' do
+      let(:session_id) { 'deadbeef' }
+      let(:driver) do
+        driver = mock('Sauce::Selenium2 Driver')
+        driver.stub_chain(:browser, :quit)
+        driver.stub_chain(:browser, :session_id).and_return(session_id)
+        driver
+      end
+
+      before :each do
+        # Need to create our nice mocked Capybara driver
+        Capybara.stub_chain(:current_session, :driver).and_return(driver)
+        Sauce::Job.stub(:new).and_return(nil)
+      end
+
+      context 'with a scenario outline' do
+        before :each do
+          $ran_scenario = 0
+        end
+
+        let(:feature) do
+          """
+          Feature: A dummy feature with a table
+            @selenium
+            Scenario Outline: Mic check
+              Given a <Number>
+              When I raise no exceptions
+            Examples: Numbers
+              | Number |
+              |   1    |
+              |   2    |
+          """
+        end
+
+        it 'should have executed the scenario outline twice' do
+          define_steps do
+            Given /^a (\d+)$/ do |number|
+              $ran_scenario = $ran_scenario + 1
+            end
+            When /^I raise no exceptions$/ do
+            end
+            # Set up and invoke our defined Around hook
+            Around('@selenium') do |scenario, block|
+              # We need to fully reference the module function here due to a
+              # change in scoping that will happen to this block courtesy of
+              # define_steps
+              Sauce::Capybara::Cucumber.around_hook(scenario, block)
+            end
+          end
+
+          run_defined_feature feature
+          $ran_scenario.should == 2
+        end
+
+      end
+
+      context 'with a correct scenario' do
+        let(:feature) do
+          """
+          Feature: A dummy feature
+            @selenium
+            Scenario: A dummy scenario
+              Given a scenario
+              When I raise no exceptions
+          """
+        end
+
+        before :each do
+          # Using this gnarly global just because it's easier to just use a
+          # global than try to fish the scenario results back out of the
+          # Cucumber bits
+          $ran_scenario = nil
+        end
+
+        it 'should have executed the feature once' do
+          define_steps do
+            Given /^a scenario$/ do
+            end
+            When /^I raise no exceptions$/ do
+              $ran_scenario = true
+            end
+            # Set up and invoke our defined Around hook
+            Around('@selenium') do |scenario, block|
+              # We need to fully reference the module function here due to a
+              # change in scoping that will happen to this block courtesy of
+              # define_steps
+              Sauce::Capybara::Cucumber.around_hook(scenario, block)
+            end
+          end
+
+          # Make sure we actually configure ourselves
+          Sauce.should_receive(:config)
+          run_defined_feature feature
+          $ran_scenario.should be true
+        end
+      end
+    end
+  end
+end
+

data/spec/sauce/capybara/spec_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
+