browserstack-webdriver 0.0.1

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

@@ -0,0 +1,91 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+
+module Selenium
+  module WebDriver
+    module IE
+
+      describe Bridge do
+        let(:resp)    { {"sessionId" => "foo", "value" => @default_capabilities.as_json }}
+        let(:server)  { double(Server, :start => 5555, :uri => "http://example.com") }
+        let(:caps)    { {} }
+        let(:http)    { double(Remote::Http::Default, :call => resp).as_null_object   }
+
+        before do
+          Server.stub(:get => server)
+          @default_capabilities = Remote::Capabilities.internet_explorer
+          Remote::Capabilities.stub(:internet_explorer => caps)
+        end
+
+        it "raises ArgumentError if passed invalid options" do
+          lambda { Bridge.new(:foo => 'bar') }.should raise_error(ArgumentError)
+        end
+
+        it "accepts the :introduce_flakiness_by_ignoring_security_domains option" do
+          Bridge.new(
+            :introduce_flakiness_by_ignoring_security_domains => true,
+            :http_client => http
+          )
+
+          caps['ignoreProtectedModeSettings'].should be_true
+        end
+
+        it "has native events enabled by default" do
+          Bridge.new(:http_client => http)
+
+          caps['nativeEvents'].should be_true
+        end
+
+        it "can disable native events" do
+          Bridge.new(
+            :native_events => false,
+            :http_client => http
+          )
+
+          caps['nativeEvents'].should be_false
+        end
+
+        it 'sets the server log level and log file' do
+          server.should_receive(:log_level=).with :trace
+          server.should_receive(:log_file=).with '/foo/bar'
+
+          Bridge.new(
+            :log_level   => :trace,
+            :log_file    => '/foo/bar',
+            :http_client => http
+          )
+        end
+
+        it 'takes desired capabilities' do
+          custom_caps = Remote::Capabilities.new
+          custom_caps['ignoreProtectedModeSettings'] = true
+
+          http.should_receive(:call).with do |_, _, payload|
+            payload[:desiredCapabilities]['ignoreProtectedModeSettings'].should be_true
+            resp
+          end
+
+          Bridge.new(:http_client => http, :desired_capabilities => custom_caps)
+        end
+
+        it 'can override desired capabilities through direct arguments' do
+          custom_caps = Remote::Capabilities.new
+          custom_caps['ignoreProtectedModeSettings'] = false
+
+          http.should_receive(:call).with do |_, _, payload|
+            payload[:desiredCapabilities]['ignoreProtectedModeSettings'].should be_true
+            resp
+          end
+
+          Bridge.new(
+            :http_client => http,
+            :desired_capabilities => custom_caps,
+            :introduce_flakiness_by_ignoring_security_domains => true
+          )
+        end
+
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,42 @@
+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)        { double(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
+
+        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/log_entry_spec.rb

@@ -0,0 +1,11 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+module Selenium
+  module WebDriver
+    describe LogEntry do
+      it 'has specs' do
+        pending
+      end
+    end
+  end
+end

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

@@ -0,0 +1,44 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+module Selenium
+  module WebDriver
+    module Opera
+
+      describe Bridge do
+        let(:resp)    { {"sessionId" => "foo", "value" => Remote::Capabilities.opera.as_json }}
+        let(:service) { double(Service, :start => true, :uri => "http://example.com") }
+        let(:http)    { double(Remote::Http::Default, :call => resp).as_null_object   }
+
+        before do
+          Service.stub(:default_service => service)
+        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
+
+        it 'lets direct arguments take presedence over capabilities' do
+          custom_caps = Remote::Capabilities.new
+          custom_caps['opera.arguments'] = '--foo 1'
+
+          http.should_receive(:call).with do |_, _, payload|
+            payload[:desiredCapabilities]['opera.arguments'].should == '--foo 2'
+            resp
+          end
+
+          Bridge.new(:http_client => http, :desired_capabilities => custom_caps, :arguments => %w[--foo 2])
+        end
+      end
+
+    end # Opera
+  end # WebDriver
+end # Selenium
+

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

@@ -0,0 +1,55 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+
+module Selenium
+  module WebDriver
+    module PhantomJS
+      describe Bridge do
+
+        let(:resp)    { {"sessionId" => "foo", "value" => Remote::Capabilities.phantomjs.as_json }}
+        let(:service) { double(Service, :start => true, :uri => "http://example.com") }
+        let(:http)    { double(Remote::Http::Default, :call => resp).as_null_object   }
+
+        before do
+          Service.stub(:default_service).and_return(service)
+        end
+
+        it 'starts the server with the given arguments' do
+          service.should_receive(:start).with(%w[--foo --bar])
+          Bridge.new(:http_client => http, :args => %w[--foo --bar])
+        end
+
+        it 'reads server arguments from desired capabilities if not given directly' do
+          service.should_receive(:start).with(%w[--foo --bar])
+
+          caps = Remote::Capabilities.phantomjs
+          caps['phantomjs.cli.args'] = %w[--foo --bar]
+
+          Bridge.new(:http_client => http, :desired_capabilities => caps)
+        end
+
+        it 'takes desired capabilities' do
+          custom_caps = Remote::Capabilities.new(:browser_name => 'foo')
+
+          http.should_receive(:call).with do |verb, post, payload|
+            payload[:desiredCapabilities].should == custom_caps
+            resp
+          end
+
+          Bridge.new(:http_client => http, :desired_capabilities => custom_caps)
+        end
+
+        it 'lets direct arguments take presedence over capabilities' do
+          service.should_receive(:start).with(%w[--foo --bar])
+
+          caps = Remote::Capabilities.phantomjs
+          caps['phantomjs.cli.args'] = %w[--baz]
+
+          Bridge.new(:http_client => http, :desired_capabilities => caps, :args => %w[--foo --bar])
+        end
+
+      end
+    end # PhantomJS
+  end # WebDriver
+end # Selenium
+

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

@@ -0,0 +1,106 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+module Selenium
+  module WebDriver
+    describe Proxy do
+      let :proxy_settings do # manual proxy settings
+        {
+          :ftp            => "mythicalftpproxy:21",
+          :http           => "mythicalproxy:80",
+          :no_proxy       => "noproxy",
+          :ssl            => "mythicalsslproxy",
+          :socks          => "mythicalsocksproxy:65555",
+          :socks_username => "test",
+          :socks_password => "test",
+        }
+      end
+
+      let :pac_proxy_settings do
+        {
+          :pac         => "http://example.com/foo.pac",
+        }
+      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 => :direct)
+        lambda { proxy.type = :system }.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]
+        proxy.socks.should          == proxy_settings[:socks]
+        proxy.socks_username.should == proxy_settings[:socks_username]
+        proxy.socks_password.should == proxy_settings[:socks_password]
+      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]
+        proxy_json['socksProxy'].should    == proxy_settings[:socks]
+        proxy_json['socksUsername'].should == proxy_settings[:socks_username]
+        proxy_json['socksPassword'].should == proxy_settings[:socks_password]
+      end
+
+      it "should configure a PAC proxy" do
+        proxy_json = Proxy.new(pac_proxy_settings).as_json
+
+        proxy_json['proxyType'].should == "PAC"
+        proxy_json['proxyAutoconfigUrl'].should == pac_proxy_settings[: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
+
+      it 'deserializes to nil if proxyType is UNSPECIFIED' do
+        Proxy.json_create('proxyType' => 'UNSPECIFIED').should be_nil
+      end
+    end
+
+  end
+end

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

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

data/spec/unit/selenium/webdriver/remote/capabilities_spec.rb

@@ -0,0 +1,115 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+module Selenium
+  module WebDriver
+    module Remote
+      describe Capabilities do
+
+        it "has default capabilities for Android" do
+          caps = Capabilities.android
+          caps.browser_name.should == "android"
+          caps.platform.should == :android
+        end
+
+        it "has default capabilities for Chrome" do
+          caps = Capabilities.chrome
+          caps.browser_name.should == "chrome"
+        end
+
+        it "has default capabilities for Firefox" do
+          caps = Capabilities.firefox
+          caps.browser_name.should == "firefox"
+        end
+
+        it "has default capabilities for HtmlUnit" do
+          caps = Capabilities.htmlunit
+          caps.browser_name.should == "htmlunit"
+        end
+
+        it "has default capabilities for Internet Explorer" do
+          caps = Capabilities.internet_explorer
+          caps.browser_name.should == "internet explorer"
+        end
+
+        it "has default capabilities for iPhone" do
+          caps = Capabilities.iphone
+          caps.browser_name.should == "iPhone"
+        end
+
+        it "has default capabilities for iPad" do
+          caps = Capabilities.ipad
+          caps.browser_name.should == "iPad"
+        end
+
+        it "has default capabilities for Opera" do
+          caps = Capabilities.opera
+          caps.browser_name.should == "opera"
+        end
+
+
+        it "should default to no proxy" do
+          Capabilities.new.proxy.should be_nil
+        end
+
+        it "can set and get standard capabilities" do
+          caps = Capabilities.new
+
+          caps.browser_name = "foo"
+          caps.browser_name.should == "foo"
+
+          caps.native_events = true
+          caps.native_events.should == true
+        end
+
+        it "can set and get arbitrary capabilities" do
+          caps = Capabilities.chrome
+          caps['chrome'] = :foo
+          caps['chrome'].should == :foo
+        end
+
+        it "should set the given proxy" do
+          proxy = Proxy.new
+          capabilities = Capabilities.new(:proxy => proxy)
+
+          capabilities.proxy.should == proxy
+        end
+
+        it "should accept a Hash" do
+          capabilities = Capabilities.new(:proxy => {:http => "foo:123"})
+          capabilities.proxy.http.should == "foo:123"
+        end
+
+        it "should return a hash of the json properties to serialize" do
+          capabilities_hash = Capabilities.new(:proxy => {:http => "some value"}).as_json
+          proxy_hash = capabilities_hash["proxy"]
+
+          capabilities_hash["proxy"].should be_kind_of(Hash)
+          proxy_hash['httpProxy'].should == "some value"
+          proxy_hash['proxyType'].should == "MANUAL"
+        end
+
+        it "should not contain proxy hash when no proxy settings" do
+          capabilities_hash = Capabilities.new.as_json
+          capabilities_hash.should_not have_key("proxy")
+        end
+
+        it "can merge capabilities" do
+          a, b = Capabilities.chrome, Capabilities.htmlunit
+          a.merge!(b)
+
+          a.browser_name.should == "htmlunit"
+          a.javascript_enabled.should be_false
+        end
+
+        it "can be serialized and deserialized to JSON" do
+          caps = Capabilities.new(:browser_name => "firefox", :custom_capability => true)
+          caps.should == Capabilities.json_create(caps.as_json)
+        end
+
+        it 'does not camel case the :firefox_binary capability' do
+          Capabilities.new(:firefox_binary => "/foo/bar").as_json.should include('firefox_binary')
+        end
+      end
+    end
+  end
+end