bbc-selenium-webdriver 1.17.0

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,111 @@
+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
+      end
+    end
+  end
+end

data/spec/unit/selenium/webdriver/remote/http/common_spec.rb

@@ -0,0 +1,24 @@
+require File.expand_path("../../../spec_helper", __FILE__)
+
+module Selenium
+  module WebDriver
+    module Remote
+      module Http
+        describe Common do
+
+          it "sends non-empty body header for POST requests without command data" do
+            common = Common.new
+            common.server_url = URI.parse("http://server")
+
+            common.should_receive(:request).
+                  with(:post, URI.parse("http://server/clear"),
+                        hash_including("Content-Length" => "2"), "{}")
+
+            common.call(:post, "clear", nil)
+          end
+
+        end # Common
+      end # Http
+    end # Remote
+  end # WebDriver
+end # Selenium

data/spec/unit/selenium/webdriver/remote/http/default_spec.rb

@@ -0,0 +1,46 @@
+require File.expand_path("../../../spec_helper", __FILE__)
+
+module Selenium
+  module WebDriver
+    module Remote
+      module Http
+        describe Default do
+          let(:client) {
+            client = Default.new
+            client.server_url = URI.parse("http://example.com")
+
+            client
+          }
+
+          it "uses the specified timeout" do
+            client.timeout = 10
+            http = client.send :http
+
+            http.open_timeout.should == 10
+            http.read_timeout.should == 10
+          end
+
+          it "uses the specified proxy" do
+            client.proxy = Proxy.new(:http => "http://foo:bar@proxy.org:8080")
+            http = client.send :http
+
+            http.should be_proxy
+            http.proxy_address.should == "proxy.org"
+            http.proxy_port.should == 8080
+            http.proxy_user.should == "foo"
+            http.proxy_pass.should == "bar"
+
+            http.address.should == "example.com"
+          end
+
+          it "raises an error if the proxy is not an HTTP proxy" do
+            client.proxy = Proxy.new(:ftp => "ftp://example.com")
+            lambda { client.send :http }.should raise_error(Error::WebDriverError)
+          end
+        end
+
+      end # Http
+    end # Remote
+  end # WebDriver
+end # Selenium
+

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

@@ -0,0 +1,61 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe "SearchContext" do
+  class TestSearchContext
+    attr_reader :bridge, :ref
+
+    include Selenium::WebDriver::SearchContext
+
+    def initialize(bridge)
+      @bridge = bridge
+    end
+  end
+
+  let(:element)        { mock(:Element)}
+  let(:bridge)         { mock(:Bridge).as_null_object   }
+  let(:search_context) { TestSearchContext.new(bridge)  }
+
+  context "finding a single element" do
+    it "accepts a hash" do
+      bridge.should_receive(:find_element_by).with('id', "bar", nil).and_return(element)
+      search_context.find_element(:id => "bar").should == element
+    end
+
+    it "accepts two arguments" do
+      bridge.should_receive(:find_element_by).with('id', "bar", nil).and_return(element)
+      search_context.find_element(:id, "bar").should == element
+    end
+
+    it "raises an error if given an invalid 'by'" do
+      lambda {
+        search_context.find_element(:foo => "bar")
+      }.should raise_error(ArgumentError, 'cannot find element by :foo')
+    end
+
+    it "does not modify the hash given" do
+      selector = {:id => "foo"}
+
+      search_context.find_element(selector)
+
+      selector.should == {:id => "foo"}
+    end
+  end
+
+  context "finding multiple elements" do
+    it "accepts a hash" do
+      bridge.should_receive(:find_elements_by).with('id', "bar", nil).and_return([])
+      search_context.find_elements(:id => "bar").should == []
+    end
+
+    it "accepts two arguments" do
+      bridge.should_receive(:find_elements_by).with('id', "bar", nil).and_return([])
+      search_context.find_elements(:id, "bar").should == []
+    end
+
+    it "raises an error if given an invalid 'by'" do
+      lambda {
+        search_context.find_elements(:foo => "bar")
+      }.should raise_error(ArgumentError, 'cannot find elements by :foo')
+    end
+  end
+end

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

@@ -0,0 +1,68 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+module Selenium
+  module WebDriver
+    describe SocketPoller do
+      let(:poller)         { Selenium::WebDriver::SocketPoller.new("localhost", 1234, 5, 0.05)  }
+      let(:socket)         { mock Socket, :close => true}
+
+      def setup_connect(*states)
+        # TODO(jari): find a cleaner way to solve the platform-specific collaborators
+        if Platform.jruby?
+          states.each { |state|
+            if state
+              TCPSocket.should_receive(:new).and_return socket
+            else
+              TCPSocket.should_receive(:new).and_raise Errno::ECONNREFUSED
+            end
+          }
+        else
+          Socket.should_receive(:new).any_number_of_times.and_return socket
+          states.each { |state|
+            socket.should_receive(:connect_nonblock).
+                   and_raise(state ? Errno::EISCONN : Errno::ECONNREFUSED)
+          }
+        end
+      end
+
+      describe "#connected?" do
+        it "returns true when the socket is listening" do
+          setup_connect false, true
+          poller.should be_connected
+        end
+
+        it "returns false if the socket is not listening after the given timeout" do
+          setup_connect false
+
+          start = Time.parse("2010-01-01 00:00:00")
+          wait  = Time.parse("2010-01-01 00:00:04")
+          stop  = Time.parse("2010-01-01 00:00:06")
+
+          Time.should_receive(:now).and_return(start, wait, stop)
+          poller.should_not be_connected
+        end
+      end
+
+      describe "#closed?" do
+        it "returns true when the socket is closed" do
+          setup_connect true, true, false
+          
+          poller.should be_closed
+        end
+
+        it "returns false if the socket is still listening after the given timeout" do
+          setup_connect true
+          
+          start = Time.parse("2010-01-01 00:00:00")
+          wait  = Time.parse("2010-01-01 00:00:04")
+          stop  = Time.parse("2010-01-01 00:00:06")
+
+          Time.should_receive(:now).and_return(start, wait, stop)
+
+          poller.should_not be_closed
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,6 @@
+require 'rubygems'
+require 'time'
+require 'rspec'
+require 'ci/reporter/rspec'
+require 'webmock/rspec'
+require 'selenium-webdriver'

data/spec/unit/selenium/webdriver/support/event_firing_spec.rb

@@ -0,0 +1,111 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+module Selenium
+  module WebDriver
+    module Support
+
+      describe EventFiringBridge do
+        let(:bridge) { mock(Remote::Bridge, :driver_extensions => []) }
+        let(:listener) { mock("EventListener") }
+        let(:event_firing_bridge) { EventFiringBridge.new(bridge, listener) }
+        let(:driver) { Driver.new(event_firing_bridge) }
+        let(:element) { Element.new(event_firing_bridge, "ref") }
+
+        context "navigation" do
+          it "fires events for navigate.to" do
+            url = "http://example.com"
+
+            listener.should_receive(:before_navigate_to).with(url, instance_of(Driver))
+            bridge.should_receive(:get).with(url)
+            listener.should_receive(:after_navigate_to).with(url, instance_of(Driver))
+
+            driver.navigate.to(url)
+          end
+
+          it "fires events for navigate.back" do
+            listener.should_receive(:before_navigate_back).with instance_of(Driver)
+            bridge.should_receive(:goBack)
+            listener.should_receive(:after_navigate_back).with instance_of(Driver)
+
+            driver.navigate.back
+          end
+
+          it "fires events for navigate.forward" do
+            listener.should_receive(:before_navigate_forward).with instance_of(Driver)
+            bridge.should_receive(:goForward)
+            listener.should_receive(:after_navigate_forward).with instance_of(Driver)
+
+            driver.navigate.forward
+          end
+        end
+
+        context "finding elements" do
+          it "fires events for find_element" do
+            listener.should_receive(:before_find).with('id', "foo", instance_of(Driver))
+            bridge.should_receive(:find_element_by).with('id', "foo", nil).and_return(element)
+            listener.should_receive(:after_find).with('id', "foo", instance_of(Driver))
+
+            driver.find_element(:id => "foo")
+          end
+
+          it "fires events for find_elements" do
+            listener.should_receive(:before_find).with('class name', "foo", instance_of(Driver))
+            bridge.should_receive(:find_elements_by).with('class name', "foo", nil).and_return([element])
+            listener.should_receive(:after_find).with('class name', "foo", instance_of(Driver))
+
+            driver.find_elements(:class => "foo")
+          end
+        end
+
+        context "changing elements" do
+          it "fires events for send_keys" do
+            listener.should_receive(:before_change_value_of).with(instance_of(Element), instance_of(Driver))
+            bridge.should_receive(:sendKeysToElement).with("ref", ["cheese"])
+            listener.should_receive(:after_change_value_of).with(instance_of(Element), instance_of(Driver))
+
+            element.send_keys "cheese"
+          end
+
+          it "fires events for clear" do
+            listener.should_receive(:before_change_value_of).with(instance_of(Element), instance_of(Driver))
+            bridge.should_receive(:clearElement).with("ref")
+            listener.should_receive(:after_change_value_of).with(instance_of(Element), instance_of(Driver))
+
+            element.clear
+          end
+        end
+
+        context "executing scripts" do
+          it "fires events for execute_script" do
+            script, arg = 'script', 'arg'
+
+            listener.should_receive(:before_execute_script).with(script, instance_of(Driver))
+            bridge.should_receive(:executeScript).with(script, arg)
+            listener.should_receive(:after_execute_script).with(script, instance_of(Driver))
+
+            driver.execute_script script, arg
+          end
+        end
+
+        context "closing and quitting" do
+          it "fires events for close" do
+            listener.should_receive(:before_close).with instance_of(Driver)
+            bridge.should_receive(:close)
+            listener.should_receive(:after_close).with instance_of(Driver)
+
+            driver.close
+          end
+
+          it "fires events for quit" do
+            listener.should_receive(:before_quit).with instance_of(Driver)
+            bridge.should_receive(:quit)
+            listener.should_receive(:after_quit).with instance_of(Driver)
+
+            driver.quit
+          end
+        end
+      end
+
+    end # Support
+  end # WebDriver
+end # Selenium