browserstack-webdriver 0.0.1

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

@@ -0,0 +1,97 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe Selenium::WebDriver::ActionBuilder do
+  let(:bridge)      { double("Bridge").as_null_object }
+  let(:keyboard)    { double(Selenium::WebDriver::Keyboard) }
+  let(:mouse)       { double(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
+
+  it 'can click, hold and release at the current location' do
+    mouse.should_receive(:down).with(nil)
+    mouse.should_receive(:up)
+
+    builder.click_and_hold.release.perform
+  end
+
+end

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

@@ -0,0 +1,43 @@
+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)        { double(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
+
+        it 'takes desired capabilities' do
+          custom_caps = Remote::Capabilities.new
+          custom_caps['foo'] = 'bar'
+
+          http.should_receive(:call).with do |_, _, payload|
+            payload[:desiredCapabilities]['foo'].should == 'bar'
+            resp
+          end
+
+          Bridge.new(:http_client => http, :desired_capabilities => custom_caps)
+        end
+      end
+
+    end # IPhone
+  end # WebDriver
+end # Selenium
+

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

@@ -0,0 +1,137 @@
+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) { double(Service, :start => true, :uri => "http://example.com") }
+        let(:caps)    { {} }
+        let(:http)    { double(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 "sets the prefs capability" do
+          Bridge.new(:http_client => http, :prefs => {:foo => "bar"})
+
+          caps['chromeOptions']['prefs'].should == {:foo => "bar"}
+          caps['chrome.prefs'].should == {:foo => "bar"}
+        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 "lets the user override chrome.noWebsiteTestingDefaults" do
+          Bridge.new(:http_client => http, :no_website_testing_defaults => true)
+
+          caps['chromeOptions']['noWebsiteTestingDefaults'].should be_true
+          caps['chrome.noWebsiteTestingDefaults'].should be_true
+        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
+
+        it 'takes desired capabilities' do
+          custom_caps = Remote::Capabilities.new
+          custom_caps['chromeOptions'] = {'foo' => 'bar'}
+
+          http.should_receive(:call).with do |_, _, payload|
+            payload[:desiredCapabilities]['chromeOptions'].should include('foo' => 'bar')
+            resp
+          end
+
+          Bridge.new(:http_client => http, :desired_capabilities => custom_caps)
+        end
+
+        it 'lets direct arguments take presedence over capabilities' do
+          custom_caps = Remote::Capabilities.new
+          custom_caps['chromeOptions'] = {'args' => %w[foo bar]}
+
+          http.should_receive(:call).with do |_, _, payload|
+            payload[:desiredCapabilities]['chromeOptions']['args'].should == ['baz']
+            resp
+          end
+
+          Bridge.new(:http_client => http, :desired_capabilities => custom_caps, :args => %w[baz])
+        end
+
+        it 'accepts :service_log_path' do
+          Service.should_receive(:default_service).with("--log-path=/foo/bar")
+          Bridge.new(:http_client => http, :service_log_path => "/foo/bar")
+        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 = WebDriver.json_load(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
+          double("ChildProcess", :io => double.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,47 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+
+module Selenium
+  module WebDriver
+    module Firefox
+
+      describe Bridge do
+        let(:launcher) { double(Launcher, :launch => nil, :url => "http://localhost:4444/wd/hub") }
+        let(:resp) { {"sessionId" => "foo", "value" => @default_capabilities }}
+        let(:http) { double(Remote::Http::Default, :call => resp).as_null_object   }
+        let(:caps) { {} }
+
+        before do
+          @default_capabilities = Remote::Capabilities.firefox.as_json
+          Remote::Capabilities.stub(:firefox).and_return(caps)
+          Launcher.stub(:new).and_return(launcher)
+        end
+
+        it "sets the proxy capability" do
+          proxy = Proxy.new(:http => "localhost:9090")
+          caps.should_receive(:proxy=).with proxy
+
+          Bridge.new(:http_client => http, :proxy => proxy)
+        end
+
+        it "raises ArgumentError if passed invalid options" do
+          lambda { Bridge.new(:foo => 'bar') }.should raise_error(ArgumentError)
+        end
+
+        it 'takes desired capabilities' do
+          custom_caps = Remote::Capabilities.new
+          custom_caps['foo'] = 'bar'
+
+          http.should_receive(:call).with do |_, _, payload|
+            payload[:desiredCapabilities]['foo'].should == 'bar'
+            resp
+          end
+
+          Bridge.new(:http_client => http, :desired_capabilities => custom_caps)
+        end
+      end
+
+    end # Firefox
+  end # WebDriver
+end # Selenium
+