bbc-selenium-webdriver 1.17.0

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

@@ -0,0 +1,44 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe "Navigation" do
+  let(:wait) { Selenium::WebDriver::Wait.new }
+
+  it "should navigate back and forward" do
+    form_title   = "We Leave From Here"
+    result_title = "We Arrive Here"
+    form_url     = url_for "formPage.html"
+    result_url   = url_for "resultPage.html"
+
+    driver.navigate.to form_url
+    driver.title.should == form_title
+
+    driver.find_element(:id, 'imageButton').submit
+    wait.until { driver.title != form_title }
+
+    driver.current_url.should include(result_url)
+    driver.title.should == result_title
+
+    driver.navigate.back
+
+    driver.current_url.should include(form_url)
+    driver.title.should == form_title
+
+    driver.navigate.forward
+    driver.current_url.should include(result_url)
+    driver.title.should == result_title
+  end
+
+  it "should refresh the page" do
+    changed_title = "Changed"
+
+    driver.navigate.to url_for("javascriptPage.html")
+    driver.find_element(:link_text, "Change the page title!").click
+    driver.title.should == changed_title
+
+    driver.navigate.refresh
+    wait.until { driver.title != changed_title }
+
+    driver.title.should == "Testing Javascript"
+  end
+end
+

data/spec/integration/selenium/webdriver/opera/driver_spec.rb

@@ -0,0 +1,47 @@
+module Selenium
+  module WebDriver
+    module Opera
+
+      describe Driver do
+
+        before(:all) { GlobalTestEnv.quit_driver rescue nil }
+
+        it 'raises ArgumentError if sent an unknown capability as an argument' do
+          lambda {
+            Selenium::WebDriver.for :opera, :foo => 'bar'
+          }.should raise_error(ArgumentError)
+        end
+
+        it 'accepts an array of custom command-line arguments' do
+          begin
+            driver = Selenium::WebDriver.for :opera, :arguments => ['-geometry 800x600']
+          ensure
+            driver.quit if driver
+          end
+        end
+
+        it 'raises ArgumentError if :arguments is not an Array' do
+          lambda {
+            Selenium::WebDriver.for :opera, :arguments => '-foo'
+          }.should raise_error(ArgumentError)
+        end
+
+        it 'accepts a valid logging level' do
+          begin
+            driver = Selenium::WebDriver.for :opera, :logging_level => :config
+            # TODO(andreastt): Validate output to console
+          ensure
+            driver.quit if driver
+          end
+        end
+
+        it 'raises ArgumentError if :logging_level uses an invalid logging level' do
+          lambda {
+            Selenium::WebDriver.for :opera, :logging_level => :hoobaflooba
+          }.should raise_error(ArgumentError)
+        end
+      end
+
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe "Options" do
+  describe "cookie management" do
+    it "should get all" do
+      driver.navigate.to url_for("xhtmlTest.html")
+      driver.manage.add_cookie :name => "foo", :value => "bar"
+
+      cookies = driver.manage.all_cookies
+
+      cookies.should have(1).things
+      cookies.first[:name].should == "foo"
+      cookies.first[:value].should == "bar"
+    end
+
+    it "should delete one" do
+      driver.navigate.to url_for("xhtmlTest.html")
+
+      driver.manage.add_cookie :name => "foo", :value => "bar"
+      driver.manage.delete_cookie("foo")
+    end
+
+    it "should delete all" do
+      driver.navigate.to url_for("xhtmlTest.html")
+
+      driver.manage.add_cookie :name => "foo", :value => "bar"
+      driver.manage.delete_all_cookies
+      driver.manage.all_cookies.should be_empty
+    end
+
+    not_compliant_on :browser => [:ie, :android, :iphone] do
+      it "should use DateTime for expires" do
+        driver.navigate.to url_for("xhtmlTest.html")
+
+        expected = DateTime.new(2039)
+        driver.manage.add_cookie :name    => "foo", 
+                                 :value   => "bar", 
+                                 :expires => expected
+
+        actual = driver.manage.cookie_named("foo")[:expires]
+        actual.should be_kind_of(DateTime)
+        actual.should == expected
+      end
+    end
+  end
+end
+
+
+

data/spec/integration/selenium/webdriver/remote/element_spec.rb

@@ -0,0 +1,24 @@
+module Selenium
+  module WebDriver
+    describe Element do
+      before do
+        driver.file_detector = lambda { |str| __FILE__ }
+      end
+
+      after do
+        driver.file_detector = nil
+      end
+
+      it "uses the file detector" do
+        driver.navigate.to url_for("upload.html")
+
+        driver.find_element(:id => "upload").send_keys("random string")
+        driver.find_element(:id => "go").submit
+
+        driver.switch_to.frame("upload_target")
+        body = driver.find_element(:xpath => "//body")
+        body.text.should include("uses the set file detector")
+      end
+    end
+  end # WebDriver
+end # Selenium

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

@@ -0,0 +1,44 @@
+require 'rubygems'
+require 'time'
+require 'rspec'
+require 'ci/reporter/rspec'
+
+require 'selenium-webdriver'
+require 'selenium/webdriver/spec_support'
+
+include Selenium
+
+if WebDriver::Platform.jruby?
+  require 'java'
+
+  [
+    Dir['build/**/*.jar'],
+    Dir['third_party/java/{jetty,servlet-api}/*.jar']
+  ].flatten.each { |jar| require jar }
+
+
+  GlobalTestEnv = WebDriver::SpecSupport::JRubyTestEnvironment.new
+else
+  GlobalTestEnv = WebDriver::SpecSupport::TestEnvironment.new
+end
+
+class Object
+  include WebDriver::SpecSupport::Guards
+end
+
+RSpec.configure do |c|
+  c.include(WebDriver::SpecSupport::Helpers)
+  c.before(:suite) do
+    if GlobalTestEnv.driver == :remote
+      GlobalTestEnv.remote_server.start
+    end
+  end
+
+  c.after(:suite) do
+    GlobalTestEnv.quit_driver
+  end
+end
+
+WebDriver::Platform.exit_hook { GlobalTestEnv.quit }
+
+$stdout.sync = true

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

@@ -0,0 +1,13 @@
+require 'selenium/server'
+require 'selenium/webdriver/spec_support/test_environment'
+require 'selenium/webdriver/spec_support/jruby_test_environment'
+require 'selenium/webdriver/spec_support/guards'
+require 'selenium/webdriver/spec_support/helpers'
+
+module Selenium
+  module WebDriver
+    module SpecSupport
+      autoload :RackServer, 'selenium/webdriver/spec_support/rack_server'
+    end
+  end
+end

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

@@ -0,0 +1,86 @@
+module Selenium
+  module WebDriver
+    module SpecSupport
+      module Guards
+
+        class << self
+          def guards
+            @guards ||= Hash.new { |hash, key| hash[key] = [] }
+          end
+
+          def record(guard_name, options, data)
+            options.each do |opts|
+              opts = current_env.merge(opts)
+              key = opts.values_at(:browser, :driver, :platform, :native).join('.')
+              guards[key] << [guard_name, data]
+            end
+          end
+
+          def report
+            key = [
+              GlobalTestEnv.browser,
+              GlobalTestEnv.driver,
+              Platform.os,
+              GlobalTestEnv.native_events?
+            ].join(".")
+
+            gs = guards[key]
+
+            print "\n\nSpec guards for this implementation: "
+
+            if gs.empty?
+             puts "none."
+            else
+              puts
+              gs.each do |guard_name, data|
+                puts "\t#{guard_name.to_s.ljust(20)}: #{data.inspect}"
+              end
+            end
+          end
+
+          def current_env
+            {
+              :browser  => GlobalTestEnv.browser,
+              :driver   => GlobalTestEnv.driver,
+              :platform => Platform.os,
+              :native   => GlobalTestEnv.native_events?
+            }
+          end
+
+          #
+          # not_compliant_on :browser => [:firefox, :chrome]
+          #   - guard this spec for both firefox and chrome
+          #
+          # not_compliant_on {:browser => :chrome, :platform => :macosx}, {:browser => :opera}
+          #   - guard this spec for Chrome on OSX and Opera on any OS
+
+          def env_matches?(opts)
+            opts.any? { |env|
+              env.all? { |key, value|
+                if value.kind_of?(Array)
+                  value.include? current_env[key]
+                else
+                  value == current_env[key]
+                end
+              }
+            }
+          end
+        end
+
+        def not_compliant_on(*opts, &blk)
+          Guards.record(:not_compliant, opts, :file => caller.first)
+          yield unless Guards.env_matches?(opts)
+        end
+
+        def compliant_on(*opts, &blk)
+          Guards.record(:compliant_on, opts, :file => caller.first)
+          yield if Guards.env_matches?(opts)
+        end
+
+        alias_method :not_compliant_when, :not_compliant_on
+        alias_method :compliant_when,     :compliant_on
+
+      end # Guards
+    end # SpecSupport
+  end # WebDriver
+end # Selenium

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

@@ -0,0 +1,46 @@
+module Selenium
+  module WebDriver
+    module SpecSupport
+      module Helpers
+
+        def driver
+          GlobalTestEnv.driver_instance
+        end
+
+        def reset_driver!
+          GlobalTestEnv.reset_driver!
+        end
+
+        def url_for(filename)
+          GlobalTestEnv.url_for filename
+        end
+
+        def fix_windows_path(path)
+          return path unless WebDriver::Platform.os == :windows
+
+          if GlobalTestEnv.browser == :ie
+            path = path[%r[file://(.*)], 1]
+            path.gsub!("/", '\\')
+
+            "file://#{path}"
+          else
+            path.sub(%r[file:/{0,2}], "file:///")
+          end
+        end
+
+        def long_wait
+          @long_wait ||= Wait.new(:timeout => 30)
+        end
+
+        def short_wait
+          @short_wait ||= Wait.new(:timeout => 3)
+        end
+
+        def wait(timeout = 10)
+          Wait.new(:timeout => timeout)
+        end
+
+      end # Helpers
+    end # SpecSupport
+  end # WebDriver
+end # Selenium

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

@@ -0,0 +1,29 @@
+module Selenium
+  module WebDriver
+    module SpecSupport
+      class JRubyTestEnvironment < TestEnvironment
+
+        def app_server
+          @app_server ||= in_process_test_environment.appServer
+        end
+
+        def url_for(filename)
+          app_server.whereIs filename
+        end
+
+        def quit
+          super
+          @in_process_test_environment.stop
+          @in_process_test_environment = nil
+        end
+
+        private
+
+        def in_process_test_environment
+          @in_process_test_environment ||= org.openqa.selenium.environment.InProcessTestEnvironment.new
+        end
+
+      end # JRubyTestEnvironmnet
+    end # SpecSupport
+  end # WebDriver
+end # Selenium

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

@@ -0,0 +1,123 @@
+require 'rack'
+require 'socket'
+
+module Selenium
+  module WebDriver
+    module SpecSupport
+      class RackServer
+
+        START_TIMEOUT = 30
+
+        def initialize(path, port = nil)
+          @path = path
+          @app  = TestApp.new(path)
+
+          @host = "127.0.0.1"
+          @port = Integer(port || PortProber.above(8180))
+        end
+
+        def start
+          if Platform.jruby?
+            start_threaded
+          elsif Platform.windows?
+            start_windows
+          else
+            start_forked
+          end
+
+          unless SocketPoller.new(@host, @port, START_TIMEOUT).connected?
+            raise "rack server not launched in #{START_TIMEOUT} seconds"
+          end
+        end
+
+        def run
+          handler.run @app, :Host => @host, :Port => @port
+        end
+
+        def where_is(file)
+          "http://#{@host}:#{@port}/#{file}"
+        end
+
+        def stop
+          if defined?(@thread) && @thread
+            @thread.kill
+          elsif defined?(@pid) && @pid
+            Process.kill('KILL', @pid)
+            Process.waitpid(@pid)
+          elsif defined?(@process) && @process
+            @process.stop
+          end
+        end
+
+        private
+
+        def handler
+          # can't use Platform here since it's being run as a file on Windows + IE.
+          if RUBY_PLATFORM =~ /mswin|msys|mingw32/
+            handlers = %w[mongrel webrick]
+          else
+            handlers = %w[thin mongrel webrick]
+          end
+
+          handler = handlers.find { |h| load_handler h }
+          constant = handler == 'webrick' ? "WEBrick" : handler.capitalize
+          Rack::Handler.const_get constant
+        end
+
+        def load_handler(handler)
+          require handler
+          true
+        rescue LoadError
+          false
+        end
+
+        def start_forked
+          @pid = fork { run }
+        end
+
+        def start_threaded
+          Thread.abort_on_exception = true
+          @thread = Thread.new { run }
+          sleep 0.5
+        end
+
+        def start_windows
+          if %w[ie internet_explorer].include? ENV['WD_SPEC_DRIVER']
+            # For IE, the combination of Windows + FFI + MRI seems to cause a
+            # deadlock with the get() call and the server thread.
+            # Workaround by running this file in a subprocess.
+            @process = ChildProcess.build("ruby", "-r", "rubygems", __FILE__, @path, @port).start
+          else
+            start_threaded
+          end
+        end
+
+        class TestApp
+          def initialize(file_root)
+            @static = Rack::File.new(file_root)
+          end
+
+          def call(env)
+            case env['REQUEST_PATH']
+            when "/common/upload"
+              req = Rack::Request.new(env)
+
+              status = 200
+              header = {"Content-Type" => "text/html"}
+              body   = req['upload'][:tempfile].read
+
+              [status, header, [body]]
+            else
+              @static.call env
+            end
+          end
+        end
+
+      end # RackServer
+    end # SpecSupport
+  end # WebDriver
+end # Selenium
+
+if __FILE__ == $0
+  Selenium::WebDriver::SpecSupport::RackServer.new(ARGV[0], ARGV[1]).run
+end