bbc-selenium-webdriver 1.17.0

data/spec/unit/selenium/webdriver/action_builder_spec.rb

@@ -0,0 +1,90 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe Selenium::WebDriver::ActionBuilder do
+  let(:bridge)      { mock("Bridge").as_null_object }
+  let(:keyboard)    { mock(Selenium::WebDriver::Keyboard) }
+  let(:mouse)       { mock(Selenium::WebDriver::Mouse)    }
+  let(:element)     { Selenium::WebDriver::Element.new(bridge, 'element')  }
+  let(:builder)     { Selenium::WebDriver::ActionBuilder.new(mouse, keyboard) }
+
+  it "should create all keyboard actions" do
+    keyboard.should_receive(:press).with(:shift)
+    keyboard.should_receive(:send_keys).with("abc")
+    keyboard.should_receive(:release).with(:control)
+
+    builder.key_down(:shift).
+            send_keys("abc").
+            key_up(:control).perform
+  end
+
+  it "should pass an element to keyboard actions" do
+    mouse.should_receive(:click).with(element)
+    keyboard.should_receive(:press).with(:shift)
+
+    builder.key_down(element, :shift).perform
+  end
+
+  it "should allow supplying individual elements to keyboard actions" do
+    element2 = Selenium::WebDriver::Element.new(bridge, 'element2')
+    element3 = Selenium::WebDriver::Element.new(bridge, 'element3')
+
+    mouse.should_receive(:click).with(element)
+    keyboard.should_receive(:press).with(:shift)
+    mouse.should_receive(:click).with(element2)
+    keyboard.should_receive(:send_keys).with("abc")
+    mouse.should_receive(:click).with(element3)
+    keyboard.should_receive(:release).with(:control)
+
+    builder.key_down(element, :shift ).
+            send_keys(element2, "abc").
+            key_up(element3, :control).perform
+  end
+
+  it "should create all mouse actions" do
+    mouse.should_receive(:down).with(element)
+    mouse.should_receive(:up).with(element)
+    mouse.should_receive(:click).with(element)
+    mouse.should_receive(:double_click).with(element)
+    mouse.should_receive(:move_to).with(element)
+    mouse.should_receive(:context_click).with(element)
+
+    builder.click_and_hold(element).
+            release(element).
+            click(element).
+            double_click(element).
+            move_to(element).
+            context_click(element).perform
+  end
+
+  it "should drag and drop" do
+    source = element
+    target = Selenium::WebDriver::Element.new(bridge, 'element2')
+
+    mouse.should_receive(:down).with(source)
+    mouse.should_receive(:move_to).with(target)
+    mouse.should_receive(:up)
+
+    builder.drag_and_drop(source, target).perform
+  end
+
+  it "should drag and drop with offsets" do
+    source = element
+
+    mouse.should_receive(:down).with(source)
+    mouse.should_receive(:move_by).with(-300, 400)
+    mouse.should_receive(:up)
+
+    builder.drag_and_drop_by(source, -300, 400).perform
+  end
+
+  it "can move the mouse by coordinates" do
+    mouse.should_receive(:down).with(element)
+    mouse.should_receive(:move_by).with(-300, 400)
+    mouse.should_receive(:up)
+
+    builder.click_and_hold(element).
+            move_by(-300, 400).
+            release.perform
+  end
+
+end

data/spec/unit/selenium/webdriver/android/bridge_spec.rb

@@ -0,0 +1,31 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+
+module Selenium
+  module WebDriver
+    module Android
+      describe Android do
+        let(:default_url) { URI.parse(Android::Bridge::DEFAULT_URL) }
+        let(:resp)        { {"sessionId" => "foo", "value" => Remote::Capabilities.android.as_json }}
+        let(:http)        { mock(Remote::Http::Default, :call => resp).as_null_object   }
+
+        it "uses the default Android driver URL" do
+          http.should_receive(:server_url=).with default_url
+          Bridge.new(:http_client => http)
+        end
+
+        it "uses the user-provided URL" do
+          http.should_receive(:server_url=).with URI.parse("http://example.com")
+          Bridge.new(:http_client => http, :url => "http://example.com")
+        end
+
+        it "uses the default HTTP client when none is specified" do
+          Remote::Http::Default.should_receive(:new).and_return http
+          Bridge.new
+        end
+      end
+
+    end # IPhone
+  end # WebDriver
+end # Selenium
+

data/spec/unit/selenium/webdriver/chrome/bridge_spec.rb

@@ -0,0 +1,94 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+
+module Selenium
+  module WebDriver
+    module Chrome
+
+      describe Bridge do
+        let(:resp)    { {"sessionId" => "foo", "value" => @default_capabilities }}
+        let(:service) { mock(Service, :start => true, :uri => "http://example.com") }
+        let(:caps)    { {} }
+        let(:http)    { mock(Remote::Http::Default, :call => resp).as_null_object   }
+
+        before do
+          @default_capabilities = Remote::Capabilities.chrome.as_json
+
+          Remote::Capabilities.stub!(:chrome).and_return(caps)
+          Service.stub!(:default_service).and_return(service)
+        end
+
+        it "sets the nativeEvents capability" do
+          Bridge.new(:http_client => http, :native_events => true)
+
+          caps['chromeOptions']['nativeEvents'].should be_true
+          caps['chrome.nativeEvents'].should be_true
+        end
+
+        it "sets the args capability" do
+          Bridge.new(:http_client => http, :args => %w[--foo=bar])
+
+          caps['chromeOptions']['args'].should == %w[--foo=bar]
+          caps['chrome.switches'].should == %w[--foo=bar]
+        end
+
+        it "sets the proxy capabilitiy" do
+          proxy = Proxy.new(:http => "localhost:1234")
+          Bridge.new(:http_client => http, :proxy => proxy)
+
+          caps['proxy'].should == proxy
+        end
+
+        it "sets the chrome.verbose capability" do
+          Bridge.new(:http_client => http, :verbose => true)
+
+          caps['chromeOptions']['verbose'].should be_true
+          caps['chrome.verbose'].should be_true
+        end
+
+        it "sets the chrome.detach capability" do
+          Bridge.new(:http_client => http) # true by default
+
+          caps['chromeOptions']['detach'].should be_true
+          caps['chrome.detach'].should be_true
+        end
+
+        it "lets the user override chrome.detach" do
+          Bridge.new(:http_client => http, :detach => false)
+
+          caps['chromeOptions']['detach'].should be_false
+          caps['chrome.detach'].should be_false
+        end
+
+        it "uses the user-provided server URL if given" do
+          Service.should_not_receive(:default_service)
+          http.should_receive(:server_url=).with(URI.parse("http://example.com"))
+
+          Bridge.new(:http_client => http, :url => "http://example.com")
+        end
+
+        it "raises an ArgumentError if args is not an Array" do
+          lambda { Bridge.new(:args => "--foo=bar")}.should raise_error(ArgumentError)
+        end
+
+        it "uses the given profile" do
+          profile = Profile.new
+
+          profile['some_pref'] = true
+          profile.add_extension(__FILE__)
+
+          Bridge.new(:http_client => http, :profile => profile)
+
+          profile_data = profile.as_json
+          caps['chromeOptions']['profile'].should == profile_data['zip']
+          caps['chromeOptions']['extensions'].should == profile_data['extensions']
+
+          caps['chrome.profile'].should == profile_data['zip']
+          caps['chrome.extensions'].should == profile_data['extensions']
+        end
+      end
+
+    end # Chrome
+  end # WebDriver
+end # Selenium
+

data/spec/unit/selenium/webdriver/chrome/profile_spec.rb

@@ -0,0 +1,57 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+
+module Selenium
+  module WebDriver
+    module Chrome
+
+      describe Profile do
+        let(:profile) { Profile.new }
+        let(:model) { "/some/path" }
+        let(:model_profile) { Profile.new(model) }
+
+        before do
+          File.stub!(:exist?).with(model).and_return true
+          File.stub!(:directory?).with(model).and_return true
+
+          Dir.stub!(:mktmpdir => "/tmp/some/path")
+          FileUtils.stub!(:rm_rf)
+          FileUtils.stub!(:mkdir_p)
+          FileUtils.stub!(:cp_r)
+        end
+
+        it "should set and get preference paths" do
+          profile['foo.bar.baz'] = true
+          profile['foo.bar.baz'].should == true
+        end
+
+        it "reads existing prefs" do
+          File.should_receive(:read).with("/some/path/Default/Preferences").
+                                     and_return('{"autofill": {"enabled": false}}')
+
+          model_profile['autofill.enabled'].should == false
+        end
+
+        it "writes out prefs" do
+          File.should_receive(:read).with("/some/path/Default/Preferences").
+                                     and_return('{"autofill": {"enabled": false}}')
+
+          model_profile['some.other.pref'] = 123
+
+          mock_io = StringIO.new
+          FileUtils.should_receive(:mkdir_p).with("/tmp/some/path/Default")
+          File.should_receive(:open).with("/tmp/some/path/Default/Preferences", "w").and_yield(mock_io)
+
+          model_profile.layout_on_disk
+
+          result = MultiJson.decode(mock_io.string)
+
+          result['autofill']['enabled'].should == false
+          result['some']['other']['pref'].should == 123
+        end
+      end
+
+    end # Chrome
+  end # WebDriver
+end # Selenium
+

data/spec/unit/selenium/webdriver/chrome/service_spec.rb

@@ -0,0 +1,44 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+module Selenium
+  module WebDriver
+    module Chrome
+
+      describe Service do
+        let(:mock_process) do
+          mock("ChildProcess", :io => mock.as_null_object, :start => true)
+        end
+
+        # ugh.
+        before { Service.instance_variable_set("@executable_path", nil) }
+
+        it "uses the user-provided path if set" do
+          Platform.stub!(:os => :unix)
+          Platform.stub!(:assert_executable).with("/some/path")
+          Chrome.driver_path = "/some/path"
+
+          ChildProcess.should_receive(:build).
+                       with { |*args| args.first.should == "/some/path" }.
+                       and_return(mock_process)
+
+          Service.default_service
+        end
+
+        it "finds the Chrome server binary by searching PATH" do
+          Platform.stub!(:os => :unix)
+          Platform.should_receive(:find_binary).once.and_return("/some/path")
+          Platform.should_receive(:assert_executable).with("/some/path")
+
+          Service.executable_path.should == "/some/path"
+        end
+
+        it "raises a nice error if the server binary can't be found" do
+          Platform.stub!(:find_binary).and_return(nil)
+
+          lambda { Service.executable_path }.should raise_error(Error::WebDriverError, /code\.google\.com/)
+        end
+
+      end
+    end # Chrome
+  end # WebDriver
+end # Selenium

data/spec/unit/selenium/webdriver/error_spec.rb

@@ -0,0 +1,41 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+module Selenium
+  module WebDriver
+    describe Error do
+
+      context "backwards compatibility" do
+        it "aliases StaleElementReferenceError as ObsoleteElementError" do
+          lambda {
+            raise Error::StaleElementReferenceError
+          }.should raise_error(Error::ObsoleteElementError)
+        end
+
+        it "aliases UnknownError as UnhandledError" do
+          lambda {
+            raise Error::UnknownError
+          }.should raise_error(Error::UnhandledError)
+        end
+
+        it "aliases JavascriptError as UnexpectedJavascriptError" do
+          lambda {
+            raise Error::JavascriptError
+          }.should raise_error(Error::UnexpectedJavascriptError)
+        end
+
+        it "aliases NoAlertPresentError as NoAlertOpenError" do
+          lambda {
+            raise Error::NoAlertPresentError
+          }.should raise_error(Error::NoAlertOpenError)
+        end
+
+        it "aliases ElementNotVisibleError as ElementNotDisplayedError" do
+          lambda {
+            raise Error::ElementNotVisibleError
+          }.should raise_error(Error::ElementNotDisplayedError)
+        end
+      end
+
+    end
+  end
+end

data/spec/unit/selenium/webdriver/firefox/bridge_spec.rb

@@ -0,0 +1,17 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+
+module Selenium
+  module WebDriver
+    module Firefox
+
+      describe Bridge do
+        it "raises ArgumentError if passed invalid options" do
+          lambda { Bridge.new(:foo => 'bar') }.should raise_error(ArgumentError)
+        end
+      end
+
+    end # Firefox
+  end # WebDriver
+end # Selenium
+

data/spec/unit/selenium/webdriver/iphone/bridge_spec.rb

@@ -0,0 +1,30 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+
+module Selenium
+  module WebDriver
+    module IPhone
+      describe Bridge do
+        let(:default_url) { URI.parse(IPhone::Bridge::DEFAULT_URL) }
+        let(:resp)        { {"sessionId" => "foo", "value" => Remote::Capabilities.iphone.as_json }}
+        let(:http)        { mock(Remote::Http::Default, :call => resp).as_null_object   }
+
+        it "uses the default iPhone driver URL" do
+          http.should_receive(:server_url=).with default_url
+          Bridge.new(:http_client => http)
+        end
+
+        it "uses the user-provided URL" do
+          http.should_receive(:server_url=).with URI.parse("http://example.com")
+          Bridge.new(:http_client => http, :url => "http://example.com")
+        end
+
+        it "uses the default HTTP client when none is specified" do
+          Remote::Http::Default.should_receive(:new).and_return http
+          Bridge.new
+        end
+      end
+
+    end # IPhone
+  end # WebDriver
+end # Selenium

data/spec/unit/selenium/webdriver/proxy_spec.rb

@@ -0,0 +1,87 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+module Selenium
+  module WebDriver
+    describe Proxy do
+      let :proxy_settings do
+        {
+          :ftp         => "mythicalftpproxy:21",
+          :http        => "mythicalproxy:80",
+          :no_proxy    => "noproxy",
+          :ssl         => "mythicalsslproxy",
+        }
+      end
+
+      it "raises ArgumentError if passed invalid options" do
+        lambda { Proxy.new(:invalid_options => 'invalid') }.should raise_error(ArgumentError)
+      end
+
+      it "raises ArgumentError if passed an invalid proxy type" do
+        lambda { Proxy.new(:type => :invalid) }.should raise_error(ArgumentError)
+      end
+
+      it "raises ArgumentError if the proxy type is changed" do
+        proxy = Proxy.new(:type => :manual)
+        lambda { proxy.type = :pac }.should raise_error(ArgumentError)
+      end
+
+      it "should allow valid options for a manual proxy" do
+        proxy = Proxy.new(proxy_settings)
+
+        proxy.ftp.should      == proxy_settings[:ftp]
+        proxy.http.should     == proxy_settings[:http]
+        proxy.no_proxy.should == proxy_settings[:no_proxy]
+        proxy.ssl.should      == proxy_settings[:ssl]
+      end
+
+      it "should return a hash of the json properties to serialize" do
+        proxy_json = Proxy.new(proxy_settings).as_json
+
+        proxy_json['proxyType'].should    == "MANUAL"
+        proxy_json['ftpProxy'].should     == proxy_settings[:ftp]
+        proxy_json['httpProxy'].should    == proxy_settings[:http]
+        proxy_json['noProxy'].should      == proxy_settings[:no_proxy]
+        proxy_json['sslProxy'].should     == proxy_settings[:ssl]
+      end
+
+      it "should configure a PAC proxy" do
+        proxy_json = Proxy.new(:pac => "http://example.com/foo.pac").as_json
+
+        proxy_json['proxyType'].should == "PAC"
+        proxy_json['proxyAutoconfigUrl'].should == "http://example.com/foo.pac"
+      end
+
+      it "should configure an auto-detected proxy" do
+        proxy_json = Proxy.new(:auto_detect => true).as_json
+
+        proxy_json['proxyType'].should == "AUTODETECT"
+        proxy_json['autodetect'].should be_true
+      end
+
+      it "should only add settings that are not nil" do
+        settings = {:type => :manual, :http => "http proxy"}
+
+        proxy = Proxy.new(settings)
+        proxy_json = proxy.as_json
+
+        proxy_json.delete('proxyType').should == settings[:type].to_s.upcase
+        proxy_json.delete('httpProxy').should == settings[:http]
+
+        proxy_json.should be_empty
+      end
+
+      it "returns a JSON string" do
+        proxy = Proxy.new(proxy_settings)
+        proxy.to_json.should be_kind_of(String)
+      end
+
+      it "can be serialized and deserialized" do
+        proxy = Proxy.new(proxy_settings)
+        other = Proxy.json_create(proxy.as_json)
+
+        proxy.should == other
+      end
+
+    end
+  end
+end