sauce 1.0.2 → 2.0.0

data/spec/sauce/capybara_spec.rb

@@ -0,0 +1,121 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+require 'sauce/capybara'
+require 'sauce/capybara/cucumber'
+
+describe Sauce::Capybara do
+  describe '#connect_tunnel' do
+    before :each do
+      $sauce_tunnel = nil
+    end
+
+    let(:connector) do
+      connector = double()
+      connector.should_receive(:connect)
+      connector.should_receive(:wait_until_ready)
+      connector
+    end
+
+    it 'should not do anything if the sauce tunnel exists' do
+      $sauce_tunnel = 1337
+      Sauce::Capybara.connect_tunnel.should == 1337
+    end
+
+    it 'should connect if the tunnel is not connected' do
+      Sauce::Connect.should_receive(:new).and_return(connector)
+
+      Sauce::Capybara.connect_tunnel
+    end
+
+    it 'should pass the quiet option to Sauce::Connect' do
+      Sauce::Connect.should_receive(:new).with(
+                    hash_including(:quiet => true)).and_return(connector)
+      Sauce::Capybara.connect_tunnel(:quiet => true)
+    end
+
+    after :each do
+      $sauce_tunnel = nil
+    end
+  end
+
+  describe Sauce::Capybara::Driver do
+    describe '#browser' do
+      before :each do
+        # Stub out the selenium driver startup
+        Sauce::Selenium2.stub(:new).and_return(nil)
+      end
+      context 'when tunneling is disabled' do
+        it 'should not call #connect_tunnel' do
+          Sauce::Capybara.should_receive(:connect_tunnel).never
+          Sauce.config do |c|
+            c[:start_tunnel] = false
+          end
+
+          driver = Sauce::Capybara::Driver.new(nil)
+          driver.browser
+        end
+      end
+    end
+    context 'with a mock app' do
+      let(:app) { double('Mock App for Driver') }
+
+      subject do
+        Sauce::Capybara::Driver.new(app)
+      end
+
+      describe '#find' do
+        let(:selector) { '#lol' }
+
+        context 'with an environment override' do
+          before :each do
+            ENV['SAUCE_DISABLE_RETRY'] = '1'
+          end
+
+          it 'should not retry and raise the error' do
+          subject.should_receive(:base_find).with(selector).and_raise(Selenium::WebDriver::Error::UnknownError)
+
+          expect {
+            subject.find(selector)
+          }.to raise_error(Selenium::WebDriver::Error::UnknownError)
+          end
+
+          after :each do
+            ENV['SAUCE_DISABLE_RETRY'] = nil
+          end
+        end
+
+        it 'should route through handle_retry' do
+          subject.should_receive(:base_find).with(selector) # BLECH
+          subject.find(selector)
+        end
+
+        it 'should retry 3 times and then raise' do
+          subject.should_receive(:base_find).with(selector).exactly(4).times.and_raise(Selenium::WebDriver::Error::UnknownError)
+
+          expect {
+            subject.find(selector)
+          }.to raise_error(Selenium::WebDriver::Error::UnknownError)
+        end
+      end
+
+      describe '#visit' do
+        it 'should route through #handle_retry' do
+          path = '/lol'
+          subject.should_receive(:base_visit).with(path)
+          subject.visit(path)
+        end
+      end
+
+      describe '#current_url' do
+        it 'should route through #handle_retry' do
+          url = 'http://lol'
+          subject.should_receive(:base_current_url).and_return(url)
+          subject.current_url.should == url
+        end
+      end
+
+    end
+  end
+
+  describe '#install_hooks' do
+  end
+end

data/spec/sauce/config_spec.rb

@@ -0,0 +1,239 @@
+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.capture_traffic
+    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 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."
+
+      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'}
+    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.')
+
+      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'}
+    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.",
+                                :"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',
+                              '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.",
+                                :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',
+                              '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 '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
+  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
+
+    describe 'browsers=' do
+      it 'should default the config to the first item' do
+        Sauce.config do |config|
+          config.browsers = [['TEST_OS', 'TEST_BROWSER', 'TEST_BROWSER_VERSION']]
+        end
+
+        c = Sauce::Config.new
+        c.os.should == 'TEST_OS'
+        c.browser.should == 'TEST_BROWSER'
+        c.browser_version == 'TEST_BROWSER_VERSION'
+      end
+    end
+
+    describe 'browsers' do
+      it 'should return an Array of the (os, browser, version)' do
+        c.os = 'A'
+        c.browser = 'B'
+        c.browser_version = 'C'
+
+        c.browsers.should == [['A', 'B', 'C']]
+      end
+    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
+end
+
+describe Sauce do
+  describe '#get_config' do
+    context 'when #config has never been called' do
+      # See: <https://github.com/saucelabs/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

data/spec/sauce/jasmine_spec.rb

@@ -0,0 +1,49 @@
+require 'spec_helper'
+require 'sauce/jasmine'
+
+describe Sauce::Jasmine::Driver do
+  describe '#initialize' do
+    let(:address) { 'http://saucelabs.com' }
+    let(:browser) { 'firefox' }
+
+    it 'should take set the @http_address' do
+      Sauce::Selenium2.stub(:new)
+      d = Sauce::Jasmine::Driver.new(browser, address)
+      d.http_address.should equal(address)
+    end
+
+    it 'should initialize a Sauce driver' do
+      Sauce::Selenium2.should_receive(:new).with(hash_including(:browser => browser)).and_return(true)
+      d = Sauce::Jasmine::Driver.new(browser, address)
+      d.should_not be_nil
+    end
+  end
+end
+
+
+describe Jasmine::Config do
+  describe '#start' do
+    before :each do
+      # Stub out the creation of the Selenium2 driver itself
+      Sauce::Selenium2.stub(:new)
+      Sauce::Jasmine::Driver.stub(:new).and_return(driver)
+    end
+
+    let(:driver) do
+      driver = mock('Sauce::Jasmine::Driver')
+      driver.stub(:connect)
+      driver
+    end
+
+    it 'should create a Sauce::Jasmine::Driver' do
+      Sauce::Jasmine::Driver.should_receive(:new).and_return(driver)
+      subject.start
+      subject.instance_variable_get(:@client).should be driver
+    end
+
+    it 'should call connect on the driver' do
+      driver.should_receive(:connect)
+      subject.start
+    end
+  end
+end

data/spec/sauce/selenium_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path(File.dirname(__FILE__) + '/../spec_helper')
+
+describe Sauce::Selenium2 do
+  let(:mock_driver) { Hash.new }
+
+  before :each do
+    ::Selenium::WebDriver.should_receive(:for).and_return(mock_driver)
+  end
+
+  describe '#initialize' do
+    it 'should work without arguments' do
+      client = Sauce::Selenium2.new
+      client.should_not be nil
+    end
+
+    it 'should pass the job_name argument into the config' do
+      expected = 'Dummy Job Name'
+      client = Sauce::Selenium2.new(:job_name => expected)
+      client.config[:job_name].should == expected
+    end
+  end
+
+
+  context 'with an initialized object' do
+    before :each do
+      @client = Sauce::Selenium2.new
+    end
+
+    describe '#stop' do
+      it 'should call quit on the driver' do
+        @client.driver.should_receive(:quit).and_return(true)
+        @client.stop
+      end
+    end
+
+    describe '#session_id' do
+      it 'should query the driver for the session_id' do
+        expected = 101
+        bridge = mock('bridge')
+        bridge.should_receive(:session_id).and_return(expected)
+        @client.driver.should_receive(:bridge).and_return(bridge)
+        @client.session_id.should == expected
+      end
+    end
+
+    describe '#method_missing' do
+      it 'should pass #navigate#to onto the driver' do
+        url = 'http://example.com'
+        navigator = mock('navigator')
+        navigator.should_receive(:to).with(url).and_return(true)
+        @client.driver.should_receive(:navigate).and_return(navigator)
+
+        @client.navigate.to url
+      end
+    end
+  end
+end