bbc-selenium-webdriver 1.17.0

data/spec/integration/selenium/webdriver/spec_support/test_environment.rb

@@ -0,0 +1,199 @@
+module Selenium
+  module WebDriver
+    module SpecSupport
+      class TestEnvironment
+
+        attr_accessor :unguarded
+        attr_reader :driver
+
+        def initialize
+          puts "creating test env :: #{ruby_description}"
+
+          @create_driver_error       = nil
+          @create_driver_error_count = 0
+
+          # TODO: get rid of ENV
+          @driver = (ENV['WD_SPEC_DRIVER'] || raise("must set WD_SPEC_DRIVER")).to_sym
+        end
+
+        def browser
+          if driver == :remote
+            # TODO: get rid of ENV
+            (ENV['WD_REMOTE_BROWSER'] || :firefox).to_sym
+          else
+            driver
+          end
+        end
+
+        def driver_instance
+          @driver_instance ||= new_driver_instance
+        end
+
+        def reset_driver!
+          quit_driver
+          @driver_instance = new_driver_instance
+        end
+
+        def quit_driver
+          @driver_instance.quit if @driver_instance
+        end
+
+        def new_driver_instance
+          check_for_previous_error
+          create_driver
+        end
+
+        def app_server
+          @app_server ||= (
+            path = File.join(root_folder, "common/src/web")
+            s = RackServer.new(path)
+            s.start
+
+            s
+          )
+        end
+
+        def remote_server
+          @remote_server ||= (
+            Selenium::Server.new(remote_server_jar,
+              :port       => PortProber.random,
+              :log        => !!$DEBUG,
+              :background => true,
+              :timeout    => 60
+            )
+          )
+        end
+
+        def remote_server_jar
+          @remote_server_jar ||= File.join(root_folder, "build/java/server/test/org/openqa/selenium/server-with-tests-standalone.jar")
+        end
+
+        def quit
+          app_server.stop
+
+          if defined?(@remote_server)
+            @remote_server.stop
+          end
+
+          @driver_instance = @app_server = @remote_server = nil
+        ensure
+          Guards.report
+        end
+
+        def unguarded?
+          @unguarded ||= false
+        end
+
+        def native_events?
+          @native_events ||= !!ENV['native']
+        end
+
+        def url_for(filename)
+          url = app_server.where_is filename
+          url.sub!("127.0.0.1", "10.0.2.2") if browser == :android
+
+          url
+        end
+
+        private
+
+        def ruby_description
+          defined?(RUBY_DESCRIPTION) ? RUBY_DESCRIPTION : "ruby-#{RUBY_VERSION}"
+        end
+
+        def root_folder
+          @root_folder ||= File.expand_path("../../../../../../../", __FILE__)
+        end
+
+        def create_driver
+          instance = case driver
+                     when :remote
+                       create_remote_driver
+                     when :opera
+                       create_opera_driver
+                     when :firefox
+                       create_firefox_driver
+                     when :chrome
+                       create_chrome_driver
+                     else
+                       WebDriver::Driver.for driver
+                     end
+
+          @create_driver_error_count -= 1 unless @create_driver_error_count == 0
+          instance
+        rescue => ex
+          @create_driver_error = ex
+          @create_driver_error_count += 1
+          raise ex
+        end
+
+        def remote_capabilities
+          caps  = WebDriver::Remote::Capabilities.send(ENV['WD_REMOTE_BROWSER'] || 'firefox')
+
+          caps.javascript_enabled    = true
+          caps.css_selectors_enabled = true
+
+          caps
+        end
+
+        MAX_ERRORS = 4
+
+        class DriverInstantiationError < StandardError
+        end
+
+        def check_for_previous_error
+          return unless @create_driver_error && @create_driver_error_count >= MAX_ERRORS
+
+          msg = "previous #{@create_driver_error_count} instantiations of driver #{driver.inspect} failed, not trying again"
+          msg << " (#{@create_driver_error.message})"
+
+          raise DriverInstantiationError, msg, @create_driver_error.backtrace
+        end
+
+        def create_remote_driver
+          WebDriver::Driver.for(:remote,
+            :desired_capabilities => remote_capabilities,
+            :url                  => remote_server.webdriver_url,
+            :http_client          => keep_alive_client || http_client
+          )
+        end
+
+        def create_opera_driver
+          ENV['SELENIUM_SERVER_JAR'] = remote_server_jar
+          WebDriver::Driver.for :opera, :logging_level => ENV['log'] ? :config : :severe
+        end
+
+        def create_firefox_driver
+          if native_events?
+            profile = WebDriver::Firefox::Profile.new
+            profile.native_events = true
+
+            WebDriver::Driver.for :firefox, :profile => profile
+          else
+            WebDriver::Driver.for :firefox
+          end
+        end
+
+        def create_chrome_driver
+          WebDriver::Driver.for :chrome,
+                                :native_events => native_events?
+                                # :http_client   => keep_alive_client || http_client
+        end
+
+        def keep_alive_client
+          require 'selenium/webdriver/remote/http/persistent'
+          STDERR.puts "INFO: using net-http-persistent"
+
+          Selenium::WebDriver::Remote::Http::Persistent.new
+        rescue LoadError
+           # net-http-persistent not available
+        end
+
+        def http_client
+          Selenium::WebDriver::Remote::Http::Default.new
+        end
+
+      end # TestEnvironment
+    end # SpecSupport
+  end # WebDriver
+end # Selenium

data/spec/integration/selenium/webdriver/target_locator_spec.rb

@@ -0,0 +1,170 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe "Selenium::WebDriver::TargetLocator" do
+  let(:wait) { Selenium::WebDriver::Wait.new }
+  
+  it "should find the active element" do
+    driver.navigate.to url_for("xhtmlTest.html")
+    driver.switch_to.active_element.should be_an_instance_of(WebDriver::Element)
+  end
+
+  not_compliant_on :browser => :iphone do
+    it "should switch to a frame" do
+      driver.navigate.to url_for("iframes.html")
+      driver.switch_to.frame("iframe1")
+
+      # TODO: expectations?
+    end
+
+    it "should switch to a frame by Element" do
+      driver.navigate.to url_for("iframes.html")
+
+      iframe = driver.find_element(:tag_name => "iframe")
+      driver.switch_to.frame(iframe)
+
+      # TODO: expectations?
+    end
+  end
+
+  not_compliant_on :browser => [:ie, :iphone] do
+    it "should switch to a window and back when given a block" do
+      driver.navigate.to url_for("xhtmlTest.html")
+
+      driver.find_element(:link, "Open new window").click
+      driver.title.should == "XHTML Test Page"
+
+      driver.switch_to.window("result") do
+        wait.until { driver.title == "We Arrive Here" }
+      end
+
+      wait.until { driver.title == "XHTML Test Page" }
+
+      reset_driver!
+    end
+
+    it "should handle exceptions inside the block" do
+      driver.navigate.to url_for("xhtmlTest.html")
+
+      driver.find_element(:link, "Open new window").click
+      driver.title.should == "XHTML Test Page"
+
+      lambda {
+        driver.switch_to.window("result") { raise "foo" }
+      }.should raise_error(RuntimeError, "foo")
+
+      driver.title.should == "XHTML Test Page"
+
+      reset_driver!
+    end
+    
+    it "should switch to a window" do
+      driver.navigate.to url_for("xhtmlTest.html")
+
+      driver.find_element(:link, "Open new window").click
+      wait.until { driver.title == "XHTML Test Page" }
+
+      driver.switch_to.window("result")
+      wait.until { driver.title == "We Arrive Here" }
+
+      reset_driver!
+    end
+
+    it "should use the original window if the block closes the popup" do
+      driver.navigate.to url_for("xhtmlTest.html")
+
+      driver.find_element(:link, "Open new window").click
+      driver.title.should == "XHTML Test Page"
+
+      driver.switch_to.window("result") do
+        wait.until { driver.title == "We Arrive Here" }
+        driver.close
+      end
+
+      driver.current_url.should include("xhtmlTest.html")
+      driver.title.should == "XHTML Test Page"
+      reset_driver!
+    end
+  end
+
+  not_compliant_on :browser => [:android, :iphone] do
+    it "should switch to default content" do
+      driver.navigate.to url_for("iframes.html")
+
+      driver.switch_to.frame 0
+      driver.switch_to.default_content
+
+      driver.find_element(:id => "iframe_page_heading")
+    end
+  end
+
+  describe "alerts" do
+    not_compliant_on :browser => [:opera, :iphone] do
+      it "allows the user to accept an alert" do
+        driver.navigate.to url_for("alerts.html")
+        driver.find_element(:id => "alert").click
+
+        driver.switch_to.alert.accept
+
+        driver.title.should == "Testing Alerts"
+      end
+    end
+
+    not_compliant_on({:browser => :chrome, :platform => :macosx}, # http://code.google.com/p/chromium/issues/detail?id=90519
+                     {:browser => :opera},
+                     {:browser => :iphone}) do 
+      it "allows the user to dismiss an alert" do
+        driver.navigate.to url_for("alerts.html")
+        driver.find_element(:id => "alert").click
+
+        driver.switch_to.alert.dismiss
+
+        driver.title.should == "Testing Alerts"
+      end
+    end
+
+    not_compliant_on :browser => [:opera, :iphone] do
+      it "allows the user to set the value of a prompt" do
+        driver.navigate.to url_for("alerts.html")
+        driver.find_element(:id => "prompt").click
+
+        alert = driver.switch_to.alert
+        alert.send_keys "cheese"
+        alert.accept
+
+        text = driver.find_element(:id => "text").text
+        text.should == "cheese"
+      end
+
+      it "allows the user to get the text of an alert" do
+        driver.navigate.to url_for("alerts.html")
+        driver.find_element(:id => "alert").click
+
+        alert = driver.switch_to.alert
+        text = alert.text
+        alert.accept
+
+        text.should == "cheese"
+      end
+    end
+
+    not_compliant_on :browser => [:chrome, :ie, :opera, :iphone] do
+      it "raises NoAlertOpenError if no alert is present" do
+        lambda { driver.switch_to.alert }.should raise_error(
+          Selenium::WebDriver::Error::NoAlertOpenError, /alert/i)
+      end
+    end
+    
+    compliant_on :browser => nil do
+      it "raises an UnhandledAlertError if an alert has not been dealt with" do
+        driver.navigate.to url_for("alerts.html")
+        driver.find_element(:id => "alert").click
+    
+        lambda { driver.title }.should raise_error(Selenium::WebDriver::Error::UnhandledAlertError)
+    
+        driver.title.should == "Testing Alerts"
+      end
+    end
+    
+  end
+end
+

data/spec/integration/selenium/webdriver/timeout_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe "Timeouts" do
+
+  before do
+    driver.manage.timeouts.implicit_wait = 0
+    driver.navigate.to url_for("dynamic.html")
+  end
+
+  after { driver.manage.timeouts.implicit_wait = 0 }
+
+  it "should implicitly wait for a single element" do
+    driver.manage.timeouts.implicit_wait = 3
+
+    driver.find_element(:id => 'adder').click
+    driver.find_element(:id => 'box0')
+  end
+
+  it "should still fail to find an element with implicit waits enabled" do
+    driver.manage.timeouts.implicit_wait = 0.5
+    lambda { driver.find_element(:id => "box0") }.should raise_error(WebDriver::Error::NoSuchElementError)
+  end
+
+  it "should return after first attempt to find one after disabling implicit waits" do
+    driver.manage.timeouts.implicit_wait = 3
+    driver.manage.timeouts.implicit_wait = 0
+
+    lambda { driver.find_element(:id => "box0") }.should raise_error(WebDriver::Error::NoSuchElementError)
+  end
+
+  it "should implicitly wait until at least one element is found when searching for many" do
+    add = driver.find_element(:id => "adder")
+
+    driver.manage.timeouts.implicit_wait = 2
+    add.click
+    add.click
+
+    driver.find_elements(:class_name => "redbox").should_not be_empty
+  end
+
+  it "should still fail to find elements when implicit waits are enabled" do
+    driver.manage.timeouts.implicit_wait = 0.5
+    driver.find_elements(:class_name => "redbox").should be_empty
+  end
+
+  it "should return after first attempt to find many after disabling implicit waits" do
+    add = driver.find_element(:id => "adder")
+
+    driver.manage.timeouts.implicit_wait = 3
+    driver.manage.timeouts.implicit_wait = 0
+    add.click
+
+    driver.find_elements(:class_name => "redbox").should be_empty
+  end
+
+end

data/spec/integration/selenium/webdriver/window_spec.rb

@@ -0,0 +1,56 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+module Selenium
+  module WebDriver
+    describe Window do
+      let(:window) { driver.manage.window }
+
+      compliant_on :browser => :firefox do
+        it "gets the size of the current window" do
+          size = window.size
+
+          size.should be_kind_of(Dimension)
+
+          size.width.should > 0
+          size.height.should > 0
+        end
+
+        it "sets the size of the current window" do
+          size = window.size
+
+          target_width = size.width - 20
+          target_height = size.height - 20
+
+          window.size = Dimension.new(target_width, target_height)
+
+          new_size = window.size
+          new_size.width.should == target_width
+          new_size.height.should == target_height
+        end
+
+        it "gets the position of the current window" do
+          pos = driver.manage.window.position
+
+          pos.should be_kind_of(Point)
+
+          pos.x.should >= 0
+          pos.y.should >= 0
+        end
+
+        it "sets the position of the current window" do
+          pos = window.position
+
+          target_x = pos.x + 10
+          target_y = pos.y + 10
+
+          window.position = Point.new(target_x, target_y)
+
+          new_pos = window.position
+          new_pos.x.should == target_x
+          new_pos.y.should == target_y
+        end
+      end
+
+    end
+  end
+end