browserstack-webdriver 0.0.1

data/lib/selenium/webdriver.rb

@@ -0,0 +1,71 @@
+require 'childprocess'
+require 'tmpdir'
+require 'fileutils'
+require 'date'
+
+require 'multi_json'
+require 'selenium/webdriver/common'
+
+module Selenium
+  module WebDriver
+    extend JsonHelper
+
+    Point     = Struct.new(:x, :y)
+    Dimension = Struct.new(:width, :height)
+    Location  = Struct.new(:latitude, :longitude, :altitude)
+
+    autoload :Android,   'selenium/webdriver/android'
+    autoload :Chrome,    'selenium/webdriver/chrome'
+    autoload :Firefox,   'selenium/webdriver/firefox'
+    autoload :IE,        'selenium/webdriver/ie'
+    autoload :IPhone,    'selenium/webdriver/iphone'
+    autoload :Opera,     'selenium/webdriver/opera'
+    autoload :PhantomJS, 'selenium/webdriver/phantomjs'
+    autoload :Remote,    'selenium/webdriver/remote'
+    autoload :Safari,    'selenium/webdriver/safari'
+    autoload :Support,   'selenium/webdriver/support'
+
+    # @api private
+
+    def self.root
+      @root ||= File.expand_path("../..", __FILE__)
+    end
+
+    #
+    # Create a new Driver instance with the correct bridge for the given browser
+    #
+    # @param browser [:ie, :internet_explorer, :remote, :chrome, :firefox, :ff, :android, :iphone, :opera, :phantomjs, :safari]
+    #   the driver type to use
+    # @param *rest
+    #   arguments passed to Bridge.new
+    #
+    # @return [Driver]
+    #
+    # @see Selenium::WebDriver::Remote::Bridge
+    # @see Selenium::WebDriver::Firefox::Bridge
+    # @see Selenium::WebDriver::IE::Bridge
+    # @see Selenium::WebDriver::Chrome::Bridge
+    # @see Selenium::WebDriver::Android::Bridge
+    # @see Selenium::WebDriver::IPhone::Bridge
+    # @see Selenium::WebDriver::Opera::Bridge
+    # @see Selenium::WebDriver::PhantomJS::Bridge
+    # @see Selenium::WebDriver::Safari::Bridge
+    #
+    # @example
+    #
+    #   WebDriver.for :firefox, :profile => "some-profile"
+    #   WebDriver.for :firefox, :profile => Profile.new
+    #   WebDriver.for :remote,  :url => "http://localhost:4444/wd/hub", :desired_capabilities => caps
+    #
+    # One special argument is not passed on to the bridges, :listener. You can pass a listener for this option
+    # to get notified of WebDriver events. The passed object must respond to #call or implement the methods from AbstractEventListener.
+    #
+    # @see Selenium::WebDriver::Support::AbstractEventListener
+    #
+
+    def self.for(*args)
+      WebDriver::Driver.for(*args)
+    end
+
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/android.rb

@@ -0,0 +1,9 @@
+module Selenium
+  module WebDriver
+    module Android
+
+    end # Android
+  end # WebDriver
+end # Selenium
+
+require 'selenium/webdriver/android/bridge'

data/lib/selenium/webdriver/android/bridge.rb

@@ -0,0 +1,47 @@
+module Selenium
+  module WebDriver
+    module Android
+
+      #
+      # @api private
+      #
+
+      class Bridge < Remote::Bridge
+
+        DEFAULT_URL = "http://#{Platform.localhost}:8080/wd/hub/"
+
+        def initialize(opts = {})
+          remote_opts = {
+            :url                  => opts.fetch(:url, DEFAULT_URL),
+            :desired_capabilities => opts.fetch(:desired_capabilities, capabilities),
+          }
+
+          remote_opts[:http_client] = opts[:http_client] if opts.has_key?(:http_client)
+
+          super remote_opts
+        end
+
+        def browser
+          :android
+        end
+
+        def driver_extensions
+          [
+            DriverExtensions::TakesScreenshot,
+            DriverExtensions::Rotatable,
+            DriverExtensions::HasInputDevices,
+            DriverExtensions::HasWebStorage,
+            DriverExtensions::HasLocation,
+            DriverExtensions::HasBrowserConnection,
+            DriverExtensions::HasTouchScreen
+          ]
+        end
+
+        def capabilities
+          @capabilities ||= Remote::Capabilities.android
+        end
+
+      end # Bridge
+    end # Android
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/chrome.rb

@@ -0,0 +1,26 @@
+require 'net/http'
+
+require 'selenium/webdriver/chrome/service'
+require 'selenium/webdriver/chrome/bridge'
+require 'selenium/webdriver/chrome/profile'
+
+module Selenium
+  module WebDriver
+
+    module Chrome
+      def self.driver_path=(path)
+        Service.executable_path = path
+      end
+
+      def self.path=(path)
+        Platform.assert_executable path
+        @path = path
+      end
+
+      def self.path
+        @path ||= nil
+      end
+
+    end
+  end
+end

data/lib/selenium/webdriver/chrome/bridge.rb

@@ -0,0 +1,120 @@
+module Selenium
+  module WebDriver
+    module Chrome
+
+      # @api private
+      class Bridge < Remote::Bridge
+
+        def initialize(opts = {})
+          http_client = opts.delete(:http_client)
+
+          if opts.has_key?(:url)
+            url = opts.delete(:url)
+          else
+            @service = Service.default_service(*extract_service_args(opts))
+            @service.start
+
+            url = @service.uri
+          end
+
+          caps = create_capabilities(opts)
+
+          remote_opts = {
+            :url                  => url,
+            :desired_capabilities => caps
+          }
+
+          remote_opts.merge!(:http_client => http_client) if http_client
+
+          super(remote_opts)
+        end
+
+        def browser
+          :chrome
+        end
+
+        def driver_extensions
+          [
+            DriverExtensions::TakesScreenshot,
+            DriverExtensions::HasInputDevices
+          ]
+        end
+
+        def capabilities
+          @capabilities ||= Remote::Capabilities.chrome
+        end
+
+        def quit
+          super
+        ensure
+          @service.stop if @service
+        end
+
+        private
+
+        def create_capabilities(opts)
+          caps                        = opts.delete(:desired_capabilities) { Remote::Capabilities.chrome }
+          args                        = opts.delete(:args) || opts.delete(:switches)
+          native_events               = opts.delete(:native_events)
+          verbose                     = opts.delete(:verbose)
+          profile                     = opts.delete(:profile)
+          detach                      = opts.delete(:detach)
+          proxy                       = opts.delete(:proxy)
+          no_website_testing_defaults = opts.delete(:no_website_testing_defaults)
+          prefs                       = opts.delete(:prefs)
+
+          unless opts.empty?
+            raise ArgumentError, "unknown option#{'s' if opts.size != 1}: #{opts.inspect}"
+          end
+
+          chrome_options = caps['chromeOptions'] || {}
+
+          if args
+            unless args.kind_of? Array
+              raise ArgumentError, ":args must be an Array of Strings"
+            end
+
+            chrome_options['args'] = args.map { |e| e.to_s }
+          end
+
+          if profile
+            data = profile.as_json
+
+            chrome_options.merge! 'profile'    => data['zip'],
+                                  'extensions' => data['extensions']
+          end
+
+
+          chrome_options['binary']                   = Chrome.path if Chrome.path
+          chrome_options['nativeEvents']             = true if native_events
+          chrome_options['verbose']                  = true if verbose
+          chrome_options['detach']                   = detach.nil? || !!detach
+          chrome_options['noWebsiteTestingDefaults'] = true if no_website_testing_defaults
+          chrome_options['prefs']                    = prefs if prefs
+
+          caps['chromeOptions'] = chrome_options
+          caps['proxy'] = proxy if proxy
+
+          # legacy options - for chromedriver < 17.0.963.0
+          caps["chrome.switches"] = chrome_options['args'] if chrome_options.member?('args')
+          %w[binary detach extensions nativeEvents noWebsiteTestingDefaults prefs profile verbose].each do |key|
+            caps["chrome.#{key}"] = chrome_options[key] if chrome_options.member?(key)
+          end
+
+          caps
+        end
+
+        def extract_service_args(opts)
+          args = []
+
+          if opts.has_key?(:service_log_path)
+            args << "--log-path=#{opts.delete(:service_log_path)}"
+          end
+
+          args
+        end
+
+      end # Bridge
+    end # Chrome
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/chrome/profile.rb

@@ -0,0 +1,90 @@
+module Selenium
+  module WebDriver
+    module Chrome
+
+      #
+      # @private
+      #
+
+      class Profile
+        include ProfileHelper
+
+        def initialize(model = nil)
+          @model      = verify_model(model)
+          @extensions = []
+          @encoded_extensions = []
+        end
+
+        def add_extension(path)
+          unless File.file?(path)
+            raise Error::WebDriverError, "could not find extension at #{path.inspect}"
+          end
+
+          @extensions << path
+        end
+
+        def add_encoded_extension(encoded)
+          @encoded_extensions << encoded
+        end
+
+        #
+        # Set a preference in the profile.
+        #
+        # See http://codesearch.google.com/codesearch#OAMlx_jo-ck/src/chrome/common/pref_names.cc&exact_package=chromium
+        #
+
+        def []=(key, value)
+          parts = key.split(".")
+          parts[0..-2].inject(prefs) { |pr, k| pr[k] ||= {} }[parts.last] = value
+        end
+
+        def [](key)
+          parts = key.split(".")
+          parts.inject(prefs) { |pr, k| pr.fetch(k) }
+        end
+
+        def layout_on_disk
+          dir = @model ? create_tmp_copy(@model) : Dir.mktmpdir("webdriver-chrome-profile")
+          FileReaper << dir
+
+          write_prefs_to dir
+
+          dir
+        end
+
+        def as_json(opts = nil)
+          extensions = @extensions.map do |crx_path|
+            File.open(crx_path, "rb") { |crx_file| Base64.strict_encode64 crx_file.read }
+          end
+
+          extensions.concat(@encoded_extensions)
+
+          super.merge('extensions' => extensions)
+        end
+
+        private
+
+        def write_prefs_to(dir)
+          prefs_file = prefs_file_for(dir)
+
+          FileUtils.mkdir_p File.dirname(prefs_file)
+          File.open(prefs_file, "w") { |file| file << WebDriver.json_dump(prefs)  }
+        end
+
+        def prefs
+          @prefs ||= read_model_prefs
+        end
+
+        def read_model_prefs
+          return {} unless @model
+          WebDriver.json_load File.read(prefs_file_for(@model))
+        end
+
+        def prefs_file_for(dir)
+          File.join dir, 'Default', 'Preferences'
+        end
+      end # Profile
+
+    end # Chrome
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/chrome/service.rb

@@ -0,0 +1,75 @@
+module Selenium
+  module WebDriver
+    module Chrome
+
+      #
+      # @api private
+      #
+
+      class Service
+        START_TIMEOUT = 20
+        STOP_TIMEOUT  = 5
+        DEFAULT_PORT  = 9515
+        MISSING_TEXT  = "Unable to find the chromedriver executable. Please download the server from http://chromedriver.storage.googleapis.com/index.html and place it somewhere on your PATH. More info at http://code.google.com/p/selenium/wiki/ChromeDriver."
+
+        attr_reader :uri
+
+        def self.executable_path
+          @executable_path ||= (
+            path = Platform.find_binary "chromedriver"
+            path or raise Error::WebDriverError, MISSING_TEXT
+            Platform.assert_executable path
+
+            path
+          )
+        end
+
+        def self.executable_path=(path)
+          Platform.assert_executable path
+          @executable_path = path
+        end
+
+        def self.default_service(*extra_args)
+          new executable_path, PortProber.above(DEFAULT_PORT), *extra_args
+        end
+
+        def initialize(executable_path, port, *extra_args)
+          @uri           = URI.parse "http://#{Platform.localhost}:#{port}"
+          server_command = [executable_path, "--port=#{port}", *extra_args]
+
+          @process       = ChildProcess.build(*server_command)
+          @socket_poller = SocketPoller.new Platform.localhost, port, START_TIMEOUT
+
+          @process.io.inherit! if $DEBUG == true
+        end
+
+        def start
+          @process.start
+
+          unless @socket_poller.connected?
+            raise Error::WebDriverError, "unable to connect to chromedriver #{@uri}"
+          end
+
+          Platform.exit_hook { stop } # make sure we don't leave the server running
+        end
+
+        def stop
+          return if @process.nil? || @process.exited?
+
+          Net::HTTP.start(uri.host, uri.port) do |http|
+            http.open_timeout = STOP_TIMEOUT / 2
+            http.read_timeout = STOP_TIMEOUT / 2
+
+            http.head("/shutdown")
+          end
+
+          @process.poll_for_exit STOP_TIMEOUT
+        rescue ChildProcess::TimeoutError
+          # ok, force quit
+          @process.stop STOP_TIMEOUT
+        end
+      end # Service
+
+    end # Chrome
+  end # WebDriver
+end # Service