sauce_ruby 3.5.6

data/spec/sauce/config/default_browsers_spec.rb

@@ -0,0 +1,46 @@
+require "rspec"
+
+describe "Sauce::Config :browsers" do
+  before :each do
+    Sauce.clear_config
+  end
+
+  context "When unset" do
+    it "defaults to the tutorial browsers" do
+      tutorial_browsers = [
+        ["Windows 8", "Internet Explorer", "10"],
+        ["Windows 7", "Firefox", "20"],
+        ["OS X 10.8", "Safari", "6"],
+        ["Linux", "Chrome", nil]
+      ]
+
+      Sauce::Config.new[:browsers].should eq tutorial_browsers
+    end
+  end
+
+  context "When set" do
+    before :each do
+      Sauce.clear_config
+
+      Sauce.config do |config|
+        config[:browsers] = [['TEST_OS', 'TEST_BROWSER', 'TEST_BROWSER_VERSION']]
+      end
+    end
+
+    it 'should default the config to the first item' do
+      c = Sauce::Config.new
+      c.os.should == 'TEST_OS'
+      c.browser.should == 'TEST_BROWSER'
+      c.browser_version == 'TEST_BROWSER_VERSION'
+    end
+
+    it 'should return an Array of the (os, browser, version)' do
+      c = Sauce::Config.new
+      c[:os] = 'A'
+      c[:browser] = 'B'
+      c[:browser_version] = 'C'
+
+      c.browsers.should == [['A', 'B', 'C']]
+    end
+  end
+end

data/spec/sauce/config/environment_config_spec.rb

@@ -0,0 +1,106 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'sauce/config'
+
+describe "Sauce::Config" do
+  describe "#extract_options_from_hash" do
+    let(:test_options) {
+      {
+        "SAUCE_USERNAME" => "user",
+        "SAUCE_ACCESS_KEY" => "ac",
+        "SAUCE_APPLICATION_HOST" => "application_host"
+      }
+    }
+
+    let(:test_config) {Sauce::Config.new}
+
+    it "should set any options starting with SAUCE" do
+      test_config
+      opts = test_config.send(:extract_options_from_hash, test_options)
+
+      opts[:username].should eq "user"
+      opts[:application_host].should eq "application_host"
+    end
+
+    context "when passed the jenkins authentication parameters" do
+      let(:jenkins_options) {
+        {
+          "SAUCE_USER_NAME" => "jenkins_user",
+          "SAUCE_API_KEY" => "jenkins_access_key"
+        }
+      }
+
+      it "should parse the SAUCE_USER_NAME value" do
+        test_config
+        opts = test_config.send(:extract_options_from_hash, jenkins_options)
+
+        opts[:username].should eq "jenkins_user"
+      end
+
+      it "should parse the SAUCE_USER_NAME value" do
+        test_config
+        opts = test_config.send(:extract_options_from_hash, jenkins_options)
+
+        opts[:access_key].should eq "jenkins_access_key"
+      end
+    end
+
+    context "when passed build numbers" do
+      it "should accept BUILD_NUMBER" do
+        opts = test_config.send(:extract_options_from_hash, {"BUILD_NUMBER" => "build"})
+        opts[:build].should eq "build"
+      end
+
+      it "should accept TRAVIS_BUILD_NUMBER" do
+        opts = test_config.send(:extract_options_from_hash, {"TRAVIS_BUILD_NUMBER" => "build"})
+        opts[:build].should eq "build"
+      end
+
+      it "should accept CIRCLE_BUILD_NUM" do
+        opts = test_config.send(:extract_options_from_hash, {"CIRCLE_BUILD_NUM" => "build"})
+        opts[:build].should eq "build"
+      end
+    end
+
+    context "when passed browsers in a json array keyed to SAUCE_ONDEMAND_BROWSERS" do
+      let(:browsers) {
+        { "SAUCE_ONDEMAND_BROWSERS" => [
+            {:os => "os1", :browser => "ie1", "browser-version" => "version1"},
+            {:os => "os2", :browser => "ie2", "browser-version" => "version2"}
+          ].to_json,
+          "SAUCE_BROWSER" => "not_browser",
+          "SAUCE_BROWSER_VERSION" => "not_version",
+          "SAUCE_OS" => "not_os"
+        }
+      }
+
+      it "should extract the browsers" do
+        opts = test_config.send(:extract_options_from_hash, browsers)
+        opts[:browsers].should eq([
+          ["os1", "ie1", "version1"],
+          ["os2", "ie2", "version2"]
+        ])
+      end
+    end
+
+    context "when passed browsers in a json array keyed to SAUCE_BROWSERS" do
+      let(:browsers) {
+        { "SAUCE_BROWSERS" => [
+            {:os => "os1", :browser => "ie1", "version" => "version1"},
+            {:os => "os2", :browser => "ie2", "version" => "version2"}
+        ].to_json,
+          "SAUCE_BROWSER" => "not_browser",
+          "SAUCE_BROWSER_VERSION" => "not_version",
+          "SAUCE_OS" => "not_os"
+        }
+      }
+
+      it "should extract the browsers" do
+        opts = test_config.send(:extract_options_from_hash, browsers)
+        opts[:browsers].should eq([
+          ["os1", "ie1", "version1", nil],
+          ["os2", "ie2", "version2", nil]
+        ])
+      end
+    end
+  end
+end

data/spec/sauce/config/load_defaults_spec.rb

@@ -0,0 +1,50 @@
+require "spec_helper"
+
+describe "Sauce" do
+  before :each do
+    Sauce.clear_config
+  end
+
+  describe "#get_config" do
+    it "returns an empty config by default" do
+      Sauce.get_config.opts.should eq Sauce::Config.new(false).opts
+    end
+
+    it "Can return default options" do
+      Sauce.get_config(:default).opts.should eq Sauce::Config.new().opts
+      Sauce.get_config(:default).opts.length.should_not eq 0
+    end
+  end
+
+  describe "::Config" do
+    describe "#new" do
+      before :each do
+        Sauce.clear_config
+      end
+
+      context "passed a hash and :without_defaults => false" do
+        let(:c) { Sauce::Config.new(:myoption => 1337, :without_defaults => false) }
+        
+        it "uses options from the hash" do
+          c[:myoption].should == 1337
+        end
+
+        it "defaults other options" do
+          c[:host].should equal Sauce::Config::DEFAULT_OPTIONS[:host]
+        end
+      end
+
+      context "passed a hash and :without_defaults => true" do
+        let(:c) { Sauce::Config.new(:myoption => 1337, :without_defaults => true) }
+        
+        it "uses options from the hash" do
+          c[:myoption].should == 1337
+        end
+
+        it "does not default other options" do
+          c[:host].should be_nil
+        end
+      end
+    end
+  end
+end

data/spec/sauce/config/perfile_browser_spec.rb

@@ -0,0 +1,105 @@
+require "spec_helper"
+
+describe "Sauce::Config" do
+  describe "#perfile_browsers" do
+    before :each do
+      ENV['SAUCE_PERFILE_BROWSERS'] = nil
+    end
+
+    after :each do
+      ENV['SAUCE_PERFILE_BROWSERS'] = nil
+    end
+
+    it "returns browsers when perfile_browsers is blank" do
+      expected_browsers = [
+        ["Linux", "Chrome", "nil"]
+      ]
+
+      Sauce.config do |c|
+        c[:browsers] = expected_browsers
+      end
+
+      config = Sauce::Config.new
+
+      filename = "./features/duckduck.feature"
+      fn = 14
+
+      Sauce::Config.new.caps_for_location(filename, fn).should eq expected_browsers
+    end
+
+    it "should return the browsers for the requested location" do
+      expected_browsers = [
+        ["Linux", "Chrome", "nil", {}],
+        ["Mac", "Safari", "5", {}]
+      ]
+
+      browser_hash = expected_browsers.map { |a| 
+       {"os" => a[0], "browser" => a[1], "version" => a[2], "caps" => a[3]}
+      }
+
+      env_hash = {
+        "./features/duckduck.feature:14"=> browser_hash,
+        "./features/adifferent.feature"=>[
+          {"os"=>"Windows 7", "browser"=>"Firefox", "version"=>"19"}
+        ]
+      }
+
+      ENV['SAUCE_PERFILE_BROWSERS'] = env_hash.to_json
+
+      filename = "./features/duckduck.feature"
+      fn = 14
+
+      Sauce::Config.new.caps_for_location(filename, fn).should eq expected_browsers
+    end
+
+    it "returns the line number location if present" do
+      expected_browsers = [
+        ["Linux", "Chrome", "nil", {}],
+        ["Mac", "Safari", "5", {}]
+      ]
+
+      browser_hash = expected_browsers.map { |a| 
+       {"os" => a[0], "browser" => a[1], "version" => a[2]}
+      }
+
+      env_hash = {
+        "./features/duckduck.feature"=>[
+          {"os"=>"Windows 7", "browser"=>"Firefox", "version"=>"19"}
+        ],
+        "./features/duckduck.feature:11"=> browser_hash
+      }
+
+      ENV['SAUCE_PERFILE_BROWSERS'] = env_hash.to_json
+
+      filename = "./features/duckduck.feature"
+      fn = 11
+
+      Sauce::Config.new.caps_for_location(filename, fn).should eq expected_browsers
+    end
+
+    it "ignores line number if it can't find it" do
+      expected_browsers = [
+        ["Linux", "Chrome", "nil", {}],
+        ["Mac", "Safari", "5", {}]
+      ]
+
+      browser_hash = expected_browsers.map { |a| 
+       {"os" => a[0], "browser" => a[1], "version" => a[2]}
+      }
+
+      env_hash = {
+        "./features/duckduck.feature:11"=>[
+          {"os"=>"Windows 7", "browser"=>"Firefox", "version"=>"19"}
+        ],
+        "./features/duckduck.feature"=> browser_hash
+      }
+
+      ENV['SAUCE_PERFILE_BROWSERS'] = env_hash.to_json
+
+      filename = "./features/duckduck.feature"
+      fn = 6
+
+      Sauce::Config.new.caps_for_location(filename, fn).should eq expected_browsers
+    end
+  end
+end

data/spec/sauce/connect_spec.rb

@@ -0,0 +1,21 @@
+require "spec_helper"
+
+describe "Sauce::Connect" do
+  describe "#connect" do
+    context "skip_connection_test is false" do
+
+      before do
+        Sauce.clear_config
+      end
+
+      it "ensures it can gain access to Sauce Connect's servers" do
+      end
+    end
+
+    context "skip_connection_test is true" do
+      it "does not try to connect to Sauce Connect's servers" do
+      end
+    end
+  end
+  
+end

data/spec/sauce/cucumber_spec.rb

@@ -0,0 +1,212 @@
+require 'spec_helper'
+
+require 'sauce/cucumber'
+# We need to pull in the cucumber_helper to effectively test cucumbery things
+require 'cucumber_helper'
+
+module Sauce::Capybara
+  describe Cucumber do
+    include Sauce::Capybara::Cucumber
+    include Sauce::Cucumber::SpecHelper
+
+    before :each do
+      Sauce::Utilities::Connect.stub(:start) {}
+    end
+
+    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 = double('Sauce::Selenium2 Driver')
+        driver.stub(:finish!)
+        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)
+        SauceWhisk::Job.stub(:new).and_return(nil)
+        Sauce::Selenium2.stub(:new).with(anything).and_return Object.new
+        Sauce.config do |c|
+          c[:browsers] = [
+            ["OS X 10.8", "Safari", "6"],
+            ["Linux", "Chrome", nil]
+          ]
+        end
+      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 twice for each browser' 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 eq 4 # 2 browsers, two examples
+        end
+
+      end
+
+      context "when using sauce/connect" 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
+          Sauce.config do |c|
+            c[:start_tunnel] = true
+          end
+          $ran_scenario = nil
+        end
+
+        after :all do
+          Sauce::Utilities::Connect.stub(:start) {}
+        end
+
+        it 'should have set up a tunnel' 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::Utilities::Connect.should_receive(:start).with(anything).and_return {true}
+          run_defined_feature feature
+          $ran_scenario.should be true
+        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 = 0
+        end
+
+        it 'should have executed the feature once for each browser' do
+          define_steps do
+            Given /^a scenario$/ do
+            end
+            When /^I raise no exceptions$/ do
+              $ran_scenario += 1
+            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 eq 2 # Two browsers
+        end
+      end
+    end
+  end
+end
+