browserstack-webdriver 0.0.1

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 = ENV['localhost'] || 'localhost'
+          @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['PATH_INFO']
+            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

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

@@ -0,0 +1,239 @@
+module Selenium
+  module WebDriver
+    module SpecSupport
+      class TestEnvironment
+
+        attr_accessor :unguarded
+        attr_reader :driver
+
+        def initialize
+          @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.above(4444),
+              :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 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
+                     when :iphone
+                       create_iphone_driver
+                     when :safari
+                       create_safari_driver
+                     when :phantomjs
+                       create_phantomjs_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                  => ENV['WD_REMOTE_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
+          binary = ENV['chrome_binary']
+          if binary
+            WebDriver::Chrome.path = binary
+          end
+
+          server = ENV['chromedriver'] || ENV['chrome_server']
+          if server
+            WebDriver::Chrome.driver_path = server
+          end
+
+          args = []
+          args << "--no-sandbox" if ENV['TRAVIS']
+
+          WebDriver::Driver.for :chrome,
+                                :native_events => native_events?,
+                                :args          => args
+                                # :http_client => keep_alive_client || http_client
+        end
+
+        def create_phantomjs_driver
+          binary = ENV['phantomjs_binary']
+          if binary
+            WebDriver::PhantomJS.path = binary
+          end
+
+          WebDriver::Driver.for :phantomjs
+        end
+
+        def create_iphone_driver
+          url = ENV['iphone_url']
+          if url
+            WebDriver::Driver.for :iphone, :url => url
+          else
+            WebDriver::Driver.for :iphone
+          end
+        end
+
+        def create_safari_driver
+          if ENV['timeout']
+            WebDriver::Driver.for :safari, :timeout => Integer(ENV['timeout'])
+          else
+            WebDriver::Driver.for :safari
+          end
+        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/sql_database_spec.rb

@@ -0,0 +1,59 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+describe "Driver" do
+  context "sql database" do
+    let(:select) { "SELECT * FROM docs" }
+    let(:insert) { "INSERT INTO docs(docname) VALUES (?)" }
+    let(:delete) { "DELETE from docs" }
+    let(:update) { "UPDATE docs SET docname='DocBar' WHERE docname='DocFooBar'" }
+
+    before do
+      driver.get url_for("html5Page.html")
+      wait.until { driver.find_element(:id => "db_completed") }
+    end
+
+    compliant_on :browser => nil do
+      it "includes inserted rows in the result set" do
+        driver.execute_sql insert, "DocFoo"
+        driver.execute_sql insert, "DocFooBar"
+
+        result = driver.execute_sql select
+        result.rows.size.should == 2
+
+        result.rows[0]['docname'].should == 'DocFoo'
+        result.rows[1]['docname'].should == 'DocFooBar'
+
+        driver.execute_sql delete
+        result = driver.execute_sql select
+        result.rows.size.should == 0
+      end
+
+      it "knows the number of rows affected" do
+        result = driver.execute_sql insert, "DocFooBar"
+        result.rows_affected.should == 1
+
+        result = driver.execute_sql select
+        result.rows_affected.should == 0
+
+        driver.execute_sql update
+        result.rows.affected.should == 1
+      end
+
+      it "returns last inserted row id" do
+        result = driver.execute_sql select
+        result.last_inserted_row_id.should == -1
+
+        driver.execute_sql insert, "DocFoo"
+        result.last_inserted_row_id.should_not == -1
+
+        result = driver.execute_sql select
+        result.last_inserted_row_id.should == -1
+
+        result = driver.execute_sql delete
+        result.last_inserted_row_id.should == -1
+      end
+    end
+
+  end
+end
+

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

@@ -0,0 +1,96 @@
+require File.expand_path("../spec_helper", __FILE__)
+
+module Selenium::WebDriver::DriverExtensions
+  describe HasWebStorage do
+
+    compliant_on :browser => [:android] do
+      shared_examples_for 'web storage' do
+        before {
+          driver.navigate.to url_for("clicks.html")
+          storage.clear
+        }
+
+        it "can get and set items" do
+          storage.should be_empty
+          storage['foo'] = 'bar'
+          storage['foo'].should == 'bar'
+
+          storage['foo1'] = 'bar1'
+          storage['foo1'].should == 'bar1'
+
+          storage.size.should == 2
+        end
+
+        it "can get all keys" do
+          storage['foo1'] = 'bar1'
+          storage['foo2'] = 'bar2'
+          storage['foo3'] = 'bar3'
+
+          storage.size.should == 3
+          storage.keys.should == %w[foo1 foo2 foo3]
+        end
+
+        it "can clear all items" do
+          storage['foo1'] = 'bar1'
+          storage['foo2'] = 'bar2'
+          storage['foo3'] = 'bar3'
+
+          storage.size.should == 3
+          storage.clear
+          storage.size.should == 0
+          storage.keys.should be_empty
+        end
+
+        it "can delete an item" do
+          storage['foo1'] = 'bar1'
+          storage['foo2'] = 'bar2'
+          storage['foo3'] = 'bar3'
+
+          storage.size.should == 3
+          storage.delete('foo1').should == 'bar1'
+          storage.size.should == 2
+        end
+
+        it "knows if a key is set" do
+          storage.should_not have_key('foo1')
+          storage['foo1'] = 'bar1'
+          storage.should have_key('foo1')
+        end
+
+        it "is Enumerable" do
+          storage['foo1'] = 'bar1'
+          storage['foo2'] = 'bar2'
+          storage['foo3'] = 'bar3'
+
+          storage.to_a.should == [
+                                  ['foo1', 'bar1'],
+                                  ['foo2', 'bar2'],
+                                  ['foo3', 'bar3']
+                                 ]
+        end
+
+        it "can fetch an item" do
+          storage['foo1'] = 'bar1'
+          storage.fetch('foo1').should == 'bar1'
+        end
+
+        it "raises IndexError on missing key" do
+          lambda do
+            storage.fetch('no-such-key')
+          end.should raise_error(IndexError, /missing key/)
+        end
+      end
+
+      context "local storage" do
+        let(:storage) { driver.local_storage }
+        it_behaves_like 'web storage'
+      end
+
+      context "session storage" do
+        let(:storage) { driver.session_storage }
+        it_behaves_like 'web storage'
+      end
+    end
+
+  end
+end