sauce_ruby 3.5.6

data/spec/sauce/config/browser_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+describe "Sauce::Config" do
+  describe "#browser" do
+
+    after :all do
+      ENV["TEST_ENV_NUMBER"] = nil
+    end
+
+    context "when @opts[:browser] is not nil" do
+      it "returns @opts[:browser]" do
+        Sauce.clear_config
+
+        Sauce.config do |c|
+          c[:browser] = "Opera"
+        end
+
+        Sauce::Config.new.browser.should eq "Opera"
+      end
+
+      it "defaults version to blank for Chrome" do
+        Sauce.clear_config
+
+        Sauce.config do |c|
+          c[:browser] = "Chrome"
+          c[:os] = "Windows"
+        end
+
+        Sauce::Config.new.browser_version.should eq nil
+      end
+    end
+
+    context "when @opts[:browser] is nil" do
+      context "and this is not parallel test" do
+        it "defaults to the first row of :browsers" do
+          Sauce.clear_config
+
+          ENV["TEST_ENV_NUMBER"] = nil
+
+          Sauce.config do |c|
+            c[:browsers] = [["Windows", "Opera", 10]]
+          end
+
+          Sauce::Config.new.browser.should eq "Opera"
+        end
+      end
+
+      context "and this is *not* a parallel test" do
+        it "should return the value set for :browser" do
+          ENV["TEST_ENV_NUMBER"] = "2"
+
+          Sauce.clear_config
+
+          expect {
+            Sauce::Config.new.browser.should_raise
+          }.to raise_exception(StandardError, no_browser_message)
+        end
+      end
+    end
+  end
+end
+
+def no_browser_message
+  <<-MESSAGE
+No browser has been configured.
+
+It seems you're trying to run your tests in parallel, but haven't configured your specs/tests to use the Sauce integration.
+
+To fix this, add :sauce => true to your specs or make your tests subclasses of Sauce::TestCase or Sauce::RailsTestCase.
+
+For more details check the gem readme at https://github.com/saucelabs/sauce_ruby/blob/master/README.markdown
+  MESSAGE
+end

data/spec/sauce/config/config_spec.rb

@@ -0,0 +1,400 @@
+require File.expand_path(File.dirname(__FILE__) + '/../../spec_helper')
+require 'sauce/config'
+
+describe Sauce::Config do
+  let(:c) do
+    config = Sauce::Config.new
+    config.stub(:silence_warnings).and_return(true)
+    config
+  end
+  before :each do
+    Sauce.clear_config
+  end
+
+  describe '#[]' do
+    it "should return nil for options that don't exist" do
+      c = Sauce::Config.new
+      c[:undefined].should be_nil
+    end
+
+    it "should return defaults if they haven't been set" do
+      c = Sauce::Config.new
+      c[:browser].should == Sauce::Config::DEFAULT_OPTIONS[:browser]
+    end
+
+    it "should return the value set in the constructor" do
+      c = Sauce::Config.new(:myoption => 1337)
+      c[:myoption].should == 1337
+    end
+  end
+
+  describe "#[]=" do
+    it "should allow setting arbitrary options" do
+      c[:setting_option] = 1337
+      c[:setting_option].should == 1337
+    end
+
+    it "should allow using strings for keys" do
+      c["my-option"] = 1337
+      c["my-option"].should == 1337
+    end
+  end
+
+  describe 'deprecate method_missing' do
+    it 'should warn when accessing an old style method' do
+      c.stub(:silence_warnings).and_return(false)
+      c.should_receive(:warn).with(anything)
+      c.start_tunnel
+    end
+  end
+
+  describe '#host' do
+    it 'should return ondemand.saucelabs.com by default' do
+      c.host.should == 'ondemand.saucelabs.com'
+    end
+  end
+
+  describe '#os' do
+    it 'should return the value set in the config block' do
+      Sauce.config do |config|
+        config[:os] = 'TEST_OS'
+      end
+
+      c = Sauce::Config.new
+      c[:os].should == 'TEST_OS'
+    end
+  end
+
+  describe '#to_browser_string' do
+    before :each do
+      @original_env = {}
+      Sauce::Config::ENVIRONMENT_VARIABLES.each do |key|
+        @original_env[key] = ENV[key] if ENV[key]
+      end
+    end
+
+    it 'should create a browser string when running under the Jenkins plugin' do
+      browsers_string = "[{\"os\":\"LINUX\",\"browser\":\"opera\",\"url\":\"sauce-ondemand:?os=Linux&browser=opera&browser-version=12\",\"browser-version\":\"12\"}]"
+      browsers = JSON.parse(browsers_string)
+      ENV['SAUCE_ONDEMAND_BROWSERS'] = browsers_string
+
+      config = Sauce::Config.new
+      result = JSON.parse(config.to_browser_string)
+
+      result['os'].should == browsers.first['os']
+      result['browser'].should == browsers.first['browser']
+      result['browser-version'].should == browsers.first['browser-version']
+    end
+
+    it 'should create a browser string from the environment' do
+      ENV['SAUCE_USERNAME'] = "test_user"
+      ENV['SAUCE_ACCESS_KEY'] = "test_access"
+      ENV['SAUCE_OS'] = "Linux"
+      ENV['SAUCE_BROWSER'] = "firefox"
+      ENV['SAUCE_BROWSER_VERSION'] = "3."
+      ENV['BUILD_TAG'] = 'test env build'
+
+      config = Sauce::Config.new
+      browser_data = JSON.parse(config.to_browser_string)
+      browser_data.should == {'name' => 'Unnamed Ruby job',
+                              'access-key' => 'test_access',
+                              'os' => 'Linux',
+                              'username' => 'test_user',
+                              'browser-version' => '3.',
+                              'browser' => 'firefox',
+                              'build' => 'test env build'}
+    end
+
+    it 'should create a browser string from the environment set by the jenkins plugin' do
+      ENV['SAUCE_USERNAME'] = 'test_user'
+      ENV['SAUCE_ACCESS_KEY'] = 'test_access'
+      ENV['SAUCE_OS'] = 'Linux'
+      ENV['SAUCE_BROWSER'] = 'firefox'
+      ENV['SAUCE_BROWSER_VERSION'] = '3.'
+      ENV['SAUCE_JOB_NAME'] = 'Named Ruby Job'
+      ENV['BUILD_TAG'] = 'test env build'
+
+      config = Sauce::Config.new
+      browser_data = JSON.parse(config.to_browser_string)
+      browser_data.should == {'name' => 'Named Ruby Job',
+                              'access-key' => 'test_access',
+                              'os' => 'Linux',
+                              'username' => 'test_user',
+                              'browser-version' => '3.',
+                              'browser' => 'firefox',
+                              'build' => 'test env build'}
+
+    end
+
+    it 'should create a browser string from parameters' do
+      config = Sauce::Config.new(:username => 'test_user',
+                                 :access_key => 'test_access',
+                                 :os => 'Linux',
+                                 :browser => 'firefox',
+                                 :browser_version => '3.',
+                                 :build => 'test param build')
+
+      browser_data = JSON.parse(config.to_browser_string)
+      browser_data.should == {'name' => 'Unnamed Ruby job',
+                              'access-key' => 'test_access',
+                              'os' => 'Linux',
+                              'username' => 'test_user',
+                              'browser-version' => '3.',
+                              'browser' => 'firefox',
+                              'build' => 'test param build'}
+    end
+
+    it 'should create a browser string with optional parameters' do
+      config = Sauce::Config.new(:username => "test_user", :access_key => "test_access",
+                                :os => "Linux", :browser => "firefox", :browser_version => "3.",
+                                :build => "test opt build",
+                                :"user-extensions-url" => "testing")
+      browser_data = JSON.parse(config.to_browser_string)
+      browser_data.should == {'name' => 'Unnamed Ruby job',
+                              'access-key' => 'test_access',
+                              'os' => 'Linux',
+                              'username' => 'test_user',
+                              'browser-version' => '3.',
+                              'browser' => 'firefox',
+                              'build' => 'test opt build',
+                              'user-extensions-url' => 'testing',
+      }
+    end
+
+    it 'should create a browser string with optional parameters as underscored symbols' do
+      config = Sauce::Config.new(:username => "test_user", :access_key => "test_access",
+                                :os => "Linux", :browser => "firefox", :browser_version => "3.",
+                                :build => "test opt build",
+                                :user_extensions_url => "testing")
+      browser_data = JSON.parse(config.to_browser_string)
+      browser_data.should == {'name' => 'Unnamed Ruby job',
+                              'access-key' => 'test_access',
+                              'os' => 'Linux',
+                              'username' => 'test_user',
+                              'browser-version' => '3.',
+                              'browser' => 'firefox',
+                              'build' => 'test opt build',
+                              'user-extensions-url' => 'testing'}
+    end
+
+    after :each do
+        Sauce::Config::ENVIRONMENT_VARIABLES.each do |key|
+          ENV[key] = @original_env[key]
+        end
+    end
+  end
+
+  describe '#to_desired_capabilities' do
+    context 'with custom sauce options' do
+      context 'max-duration' do
+        subject do
+          Sauce::Config.new(:'max-duration' => 600).to_desired_capabilities
+        end
+
+        it { should have_key :'max-duration' }
+      end
+
+      context "prerun" do
+        subject do
+          Sauce::Config.new('prerun' => "Something Prerun").to_desired_capabilities
+        end
+
+        it { should have_key :'prerun'}
+      end
+
+      context 'iedriver-version' do
+        subject do
+          Sauce::Config.new('iedriver-version' => '2.30.1').to_desired_capabilities
+        end
+
+        it { should have_key :'iedriver-version' }
+      end
+    end
+
+    context 'with a :name set' do
+      subject do
+        Sauce::Config.new(:name => 'As Sweet').to_desired_capabilities[:name]
+      end
+
+      it {should eq "As Sweet"}
+    end
+
+    context 'platforms' do
+      it 'should refer to Windows 2003 as WINDOWS' do
+        config = Sauce::Config.new(:os => "Windows 2003")
+        config.to_desired_capabilities[:platform].should == 'WINDOWS'
+      end
+
+      it 'should refer to Windows 2008 as VISTA' do
+        config = Sauce::Config.new(:os => "Windows 2008")
+        config.to_desired_capabilities[:platform].should == 'VISTA'
+      end
+    end
+
+    context 'client_version' do
+      let(:config) {Sauce::Config.new()}
+
+      it 'should include the Ruby engine' do
+        config.to_desired_capabilities[:client_version].should include RUBY_ENGINE
+      end
+
+      it "should include the ruby platform" do
+        config.to_desired_capabilities[:client_version].should include RUBY_PLATFORM
+      end
+
+      it "should include the ruby version" do
+        config.to_desired_capabilities[:client_version].should include RUBY_VERSION
+      end
+
+      it "should include the gem version" do
+        config.to_desired_capabilities[:client_version].should include Sauce.version
+      end
+
+      it "should include a bracketed array of tools in use" do
+        config.to_desired_capabilities[:client_version].should include config.tools.to_s
+      end
+    end
+
+    context 'with unusual options' do
+      let(:config) {Sauce::Config.new}
+
+      it 'should ignore them by default' do
+        config[:new_option] = 'caramel'
+        config.to_desired_capabilities[:new_option].should be_nil
+      end
+
+      it 'should include them when configured with exceptions' do
+        config[:new_option] = 'elderflower'
+        config.whitelist :new_option
+        config.to_desired_capabilities[:new_option].should include 'elderflower'
+      end
+
+      it 'should include them when created anew' do
+        config.whitelist :new_option
+        config_two = Sauce::Config.new({})
+        config_two[:new_option] = 'elderflower'
+        config_two.to_desired_capabilities[:new_option].should include 'elderflower'
+      end
+
+      it 'should allow multiple exceptions' do
+        config[:new_option] = 'elderflower'
+        config[:another_option] = 'mint'
+        config.whitelist :new_option
+        config.whitelist :another_option
+          
+        config.to_desired_capabilities[:new_option].should include 'elderflower'
+        config.to_desired_capabilities[:another_option].should include 'mint'
+        config.to_desired_capabilities[:not_an_option].should be_nil
+      end
+    end
+  end
+
+  describe "#tools" do
+    let(:config) {Sauce::Config.new}
+
+    before :each do
+      config.stub(:is_defined?).and_call_original
+    end
+
+    it "should include rspec if present" do
+      config.tools.should include "Rspec"
+    end
+
+    it "should include capybara" do
+      config.stub(:is_defined?).with("Capybara") {true}
+      config.tools.should include "Capybara"
+    end
+
+    it "should not include capybara when absent" do
+      config.stub(:is_defined?).with("Capybara") {false}
+      config.tools.should_not include "Capybara"
+    end
+
+    it "should not include cucumber when not present" do
+      config.stub(:is_defined?).with("Cucumber") {false}
+      config.tools.should_not include "Cucumber"
+    end
+
+    it "should include cucumber when present" do
+      config.stub(:is_defined?).with("Cucumber") {true}
+      config.tools.should include "Cucumber"
+    end
+
+    it "should include test::unit if present" do
+      config.stub(:is_defined?).with("Test","Unit") {true}
+      config.tools.should include "Test::Unit"
+    end
+
+    it "should not include test::unit if absent" do
+      config.stub(:is_defined?).with("Test", "Unit") {false}
+      config.tools.should_not include "Test::Unit"
+    end
+  end
+
+  context 'configuring Sauce' do
+    it 'should make foo? methods for set boolean values' do
+      c.some_option = true
+      c.some_option?.should be true
+    end
+
+    it 'should allow overrides as constructor options' do
+      Sauce.config do |config|
+        config[:browsers] = [['OS1', 'BROWSER1', 'BROWSER_VERSION1']]
+      end
+
+      c = Sauce::Config.new(:os => 'OS2', :browser => 'BROWSER2',
+                            :browser_version => 'BROWSER_VERSION2')
+      c.os.should == 'OS2'
+      c.browser.should == 'BROWSER2'
+      c.browser_version.should == 'BROWSER_VERSION2'
+    end
+  end
+
+  describe "#"
+end
+
+describe Sauce do
+
+  # Ensure any doubles are removed to stop other tests choking
+  after :all do
+    Sauce.clear_config
+  end
+
+  describe '#get_config' do
+    context 'when #config has never been called' do
+      # See: <https://github.com/sauce-labs/sauce_ruby/issues/59>
+      before :each do
+        # This is kind of hack-ish, but the best way I can think to properly
+        # prevent this class variable from existing
+        Sauce.instance_variable_set(:@cfg, nil)
+      end
+
+      it 'should return a newly created Sauce::Config' do
+        dummy_config = double('Sauce::Config')
+        Sauce::Config.should_receive(:new).and_return(dummy_config)
+        Sauce.get_config.should_not be nil
+      end
+    end
+
+    context 'when config has been called' do
+      before :each do
+        Sauce.clear_config
+        Sauce.config do |c|
+          c[:some_setting] = true
+        end
+      end
+      it 'should return the same config with the same configuration' do
+        Sauce.get_config.should_not be nil
+        Sauce.get_config[:some_setting].should be true
+      end
+    end
+  end
+
+  describe '#clear_config' do
+    it 'should reset the config object' do
+      c = Sauce.get_config
+      Sauce.clear_config
+      c.should_not equal(Sauce.get_config)
+    end
+  end
+end