browserstack-webdriver 0.0.1

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,124 @@
+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
+
+          ["http_proxy", "HTTP_PROXY"].each { |proxy_var|
+            it "honors the #{proxy_var} environment varable" do
+              with_env(proxy_var => "http://proxy.org:8080") do
+                http = client.send :http
+
+                http.should be_proxy
+                http.proxy_address.should == "proxy.org"
+                http.proxy_port.should == 8080
+              end
+            end
+
+            it "handles #{proxy_var} without http://" do
+              with_env(proxy_var => "proxy.org:8080") do
+                http = client.send :http
+
+                http.should be_proxy
+                http.proxy_address.should == "proxy.org"
+                http.proxy_port.should == 8080
+              end
+            end
+          }
+
+          ["no_proxy", "NO_PROXY"].each do |no_proxy_var|
+            it "honors the #{no_proxy_var} environment variable when matching" do
+              with_env("HTTP_PROXY" => "proxy.org:8080", no_proxy_var => "example.com") do
+                http = client.send :http
+                http.should_not be_proxy
+              end
+            end
+
+            it "ignores the #{no_proxy_var} environment variable when not matching" do
+              with_env("HTTP_PROXY" => "proxy.org:8080", no_proxy_var => "foo.com") do
+                http = client.send :http
+
+                http.should be_proxy
+                http.proxy_address.should == "proxy.org"
+                http.proxy_port.should == 8080
+              end
+            end
+
+              it "understands a comma separated list of domains in #{no_proxy_var}" do
+                with_env("HTTP_PROXY" => "proxy.org:8080", no_proxy_var => "example.com,foo.com") do
+                  http = client.send :http
+                  http.should_not be_proxy
+                end
+              end
+
+            unless RUBY_VERSION > "2.0" # Ruby 2.0 does its own proxy handling in net/http, which breaks this behaviour
+              it "understands an asterisk in #{no_proxy_var}" do
+                with_env("HTTP_PROXY" => "proxy.org:8080", no_proxy_var => "*") do
+                  http = client.send :http
+                  http.should_not be_proxy
+                end
+              end
+            end
+
+            it "understands subnetting in #{no_proxy_var}" do
+              with_env("HTTP_PROXY" => "proxy.org:8080", no_proxy_var => "localhost,127.0.0.0/8") do
+                client.server_url = URI.parse("http://127.0.0.1:4444/wd/hub")
+
+                http = client.send :http
+                http.should_not be_proxy
+              end
+            end
+          end
+
+          it "raises a sane error if a proxy is refusing connections" do
+            with_env("http_proxy" => "http://localhost:1234") do
+              http = client.send :http
+              http.should_receive(:request).and_raise Errno::ECONNREFUSED.new("Connection refused")
+
+              lambda {
+                client.call :post, 'http://example.com/foo/bar', {}
+              }.should raise_error(Errno::ECONNREFUSED, %r[using proxy: http://localhost:1234])
+            end
+          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)        { double(:Element)}
+  let(:bridge)         { double(: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)         { double 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.stub(:new).and_return socket
+          states.each { |state|
+            socket.should_receive(:connect_nonblock).
+                   and_raise(state ? Errno::EISCONN.new("connection in progress") : Errno::ECONNREFUSED.new("connection refused"))
+          }
+        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")
+
+          # on rbx, we can't add expectations to Time.now since it will be called by the kernel code.
+          poller.should_receive(:time_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,27 @@
+require 'rubygems'
+require 'time'
+require 'rspec'
+require 'ci/reporter/rspec'
+require 'webmock/rspec'
+require 'selenium-webdriver'
+
+module Selenium
+  module WebDriver
+    module UnitSpecHelper
+
+      def with_env(hash, &blk)
+        hash.each { |k,v| ENV[k.to_s] = v.to_s }
+        yield
+      ensure
+        hash.each_key { |k| ENV.delete(k) }
+      end
+
+    end
+  end
+end
+
+RSpec.configure do |c|
+  c.include Selenium::WebDriver::UnitSpecHelper
+
+  c.filter_run :focus => true if ENV['focus']
+end

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

@@ -0,0 +1,119 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+module Selenium
+  module WebDriver
+    module Support
+      describe Color do
+        it "converts rgb to rgb" do
+          str = "rgb(1, 2, 3)"
+          Color.from_string(str).rgb.should == str
+        end
+
+        it "converts rgb to rgba" do
+          str = "rgb(1, 2, 3)"
+          Color.from_string(str).rgba.should == "rgba(1, 2, 3, 1)"
+        end
+
+        it "converts rgb percent to rgba" do
+          str = "rgb(10%, 20%, 30%)"
+          Color.from_string(str).rgba.should == "rgba(25, 51, 76, 1)"
+        end
+
+        it "allows whitespace in rgb string" do
+          str = "rgb(\t1,   2    , 3)"
+          Color.from_string(str).rgb.should == "rgb(1, 2, 3)"
+        end
+
+        it "converts rgba to rgba" do
+          str = "rgba(1, 2, 3, 0.5)"
+          Color.from_string(str).rgba.should == str
+        end
+
+        it "converts rgba percent to rgba" do
+          str = "rgba(10%, 20%, 30%, 0.5)"
+          Color.from_string(str).rgba.should == "rgba(25, 51, 76, 0.5)"
+        end
+
+        it "converts hex to hex" do
+          str = "#ff00a0"
+          Color.from_string(str).hex.should == str
+        end
+
+        it "converts hex to rgb" do
+          hex = "#01Ff03"
+          rgb = "rgb(1, 255, 3)"
+
+          Color.from_string(hex).rgb.should == rgb
+        end
+
+        it "converts hex to rgba" do
+          hex = "#01Ff03"
+          rgba = "rgba(1, 255, 3, 1)"
+
+          Color.from_string(hex).rgba.should == rgba
+
+          hex = "#00ff33";
+          rgba = "rgba(0, 255, 51, 1)"
+
+          Color.from_string(hex).rgba.should == rgba
+        end
+
+        it "converts rgb to hex" do
+          Color.from_string("rgb(1, 255, 3)").hex.should == "#01ff03"
+        end
+
+        it "converts hex3 to rgba" do
+          Color.from_string("#0f3").rgba.should == "rgba(0, 255, 51, 1)"
+        end
+
+        it "converts hsl to rgba" do
+          hsl = "hsl(120, 100%, 25%)"
+          rgba = "rgba(0, 128, 0, 1)"
+
+          Color.from_string(hsl).rgba.should == rgba
+
+          hsl = "hsl(100, 0%, 50%)"
+          rgba = "rgba(128, 128, 128, 1)"
+
+          Color.from_string(hsl).rgba.should == "rgba(128, 128, 128, 1)"
+        end
+
+        it "converts hsla to rgba" do
+          hsla = "hsla(120, 100%, 25%, 1)"
+          rgba = "rgba(0, 128, 0, 1)"
+
+          Color.from_string(hsla).rgba.should == rgba
+
+          hsla = "hsla(100, 0%, 50%, 0.5)"
+          rgba = "rgba(128, 128, 128, 0.5)"
+
+          Color.from_string(hsla).rgba.should == rgba
+        end
+
+        it "is equal to a color with the same values" do
+          rgba  = "rgba(30, 30, 30, 0.2)"
+          other = "rgba(30, 30, 30, 1)"
+
+          Color.from_string(rgba).should == Color.from_string(rgba)
+          Color.from_string(rgba).should_not == Color.from_string(other)
+        end
+
+        it "implements #hash correctly" do
+          a = Color.from_string("#000")
+          b = Color.from_string("#001")
+          c = Color.from_string("#000")
+
+          h = {}
+          h[a] = 1
+          h[b] = 2
+          h[c] = 3
+
+          h.values.sort.should == [2, 3]
+        end
+
+      end
+    end
+  end
+end
+
+

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) { double(Remote::Bridge, :driver_extensions => []) }
+        let(:listener) { double("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