browserstack-webdriver 0.0.1

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

@@ -0,0 +1,263 @@
+module Selenium
+  module WebDriver
+    module Firefox
+      class Profile
+        include ProfileHelper
+
+        VALID_PREFERENCE_TYPES   = [TrueClass, FalseClass, Integer, Float, String]
+        WEBDRIVER_EXTENSION_PATH = File.expand_path("#{WebDriver.root}/selenium/webdriver/firefox/extension/webdriver.xpi")
+        WEBDRIVER_PREFS          = {
+          :native_events    => 'webdriver_enable_native_events',
+          :untrusted_certs  => 'webdriver_accept_untrusted_certs',
+          :untrusted_issuer => 'webdriver_assume_untrusted_issuer',
+          :port             => 'webdriver_firefox_port',
+          :log_file         => 'webdriver.log.file'
+        }
+
+        attr_reader   :name, :log_file
+        attr_writer   :secure_ssl, :native_events, :load_no_focus_lib
+
+        class << self
+          def ini
+            @ini ||= ProfilesIni.new
+          end
+
+          def from_name(name)
+            ini[name]
+          end
+
+          def default_preferences
+            @default_preferences ||= WebDriver.json_load(
+              File.read(File.expand_path("#{WebDriver.root}/selenium/webdriver/firefox/extension/prefs.json"))
+            ).freeze
+          end
+        end
+
+        #
+        # Create a new Profile instance
+        #
+        # @example User configured profile
+        #
+        #   profile = Selenium::WebDriver::Firefox::Profile.new
+        #   profile['network.proxy.http'] = 'localhost'
+        #   profile['network.proxy.http_port'] = 9090
+        #
+        #   driver = Selenium::WebDriver.for :firefox, :profile => profile
+        #
+
+        def initialize(model = nil)
+          @model = verify_model(model)
+
+          model_prefs = read_model_prefs
+
+          if model_prefs.empty?
+            @native_events     = DEFAULT_ENABLE_NATIVE_EVENTS
+            @secure_ssl        = DEFAULT_SECURE_SSL
+            @untrusted_issuer  = DEFAULT_ASSUME_UNTRUSTED_ISSUER
+            @load_no_focus_lib = DEFAULT_LOAD_NO_FOCUS_LIB
+
+            @additional_prefs  = {}
+          else
+            # TODO: clean this up
+            @native_events     = model_prefs.delete(WEBDRIVER_PREFS[:native_events]) == "true"
+            @secure_ssl        = model_prefs.delete(WEBDRIVER_PREFS[:untrusted_certs]) != "true"
+            @untrusted_issuer  = model_prefs.delete(WEBDRIVER_PREFS[:untrusted_issuer]) == "true"
+            @load_no_focus_lib = model_prefs.delete(WEBDRIVER_PREFS[:load_no_focus_lib]) == "true" # not stored in profile atm, so will always be false.
+            @additional_prefs  = model_prefs
+          end
+
+          @extensions        = {}
+        end
+
+        def layout_on_disk
+          profile_dir = @model ? create_tmp_copy(@model) : Dir.mktmpdir("webdriver-profile")
+          FileReaper << profile_dir
+
+          install_extensions(profile_dir)
+          delete_lock_files(profile_dir)
+          delete_extensions_cache(profile_dir)
+          update_user_prefs_in(profile_dir)
+
+          profile_dir
+        end
+
+
+        #
+        # Set a preference for this particular profile.
+        #
+        # @see http://kb.mozillazine.org/About:config_entries
+        # @see http://preferential.mozdev.org/preferences.html
+        #
+
+        def []=(key, value)
+          unless VALID_PREFERENCE_TYPES.any? { |e| value.kind_of? e }
+            raise TypeError, "expected one of #{VALID_PREFERENCE_TYPES.inspect}, got #{value.inspect}:#{value.class}"
+          end
+
+          if value.kind_of?(String) && Util.stringified?(value)
+            raise ArgumentError, "preference values must be plain strings: #{key.inspect} => #{value.inspect}"
+          end
+
+          @additional_prefs[key.to_s] = value
+        end
+
+        def port=(port)
+          self[WEBDRIVER_PREFS[:port]] = port
+        end
+
+        def log_file=(file)
+          @log_file = file
+          self[WEBDRIVER_PREFS[:log_file]] = file
+        end
+
+        def add_webdriver_extension
+          unless @extensions.has_key?(:webdriver)
+            add_extension(WEBDRIVER_EXTENSION_PATH, :webdriver)
+          end
+        end
+
+        #
+        # Add the extension (directory, .zip or .xpi) at the given path to the profile.
+        #
+
+        def add_extension(path, name = extension_name_for(path))
+          @extensions[name] = Extension.new(path)
+        end
+
+        def native_events?
+          @native_events == true
+        end
+
+        def load_no_focus_lib?
+          @load_no_focus_lib == true
+        end
+
+        def secure_ssl?
+          @secure_ssl == true
+        end
+
+        def assume_untrusted_certificate_issuer?
+          @untrusted_issuer == true
+        end
+
+        def assume_untrusted_certificate_issuer=(bool)
+          @untrusted_issuer = bool
+        end
+
+        def proxy=(proxy)
+          unless proxy.kind_of? Proxy
+            raise TypeError, "expected #{Proxy.name}, got #{proxy.inspect}:#{proxy.class}"
+          end
+
+          case proxy.type
+          when :manual
+            self['network.proxy.type'] = 1
+
+            set_manual_proxy_preference "ftp", proxy.ftp
+            set_manual_proxy_preference "http", proxy.http
+            set_manual_proxy_preference "ssl", proxy.ssl
+            set_manual_proxy_preference "socks", proxy.socks
+
+            if proxy.no_proxy
+              self["network.proxy.no_proxies_on"] = proxy.no_proxy
+            else
+              self["network.proxy.no_proxies_on"] = ""
+            end
+          when :pac
+            self['network.proxy.type'] = 2
+            self['network.proxy.autoconfig_url'] = proxy.pac
+          when :auto_detect
+            self['network.proxy.type'] = 4
+          else
+            raise ArgumentError, "unsupported proxy type #{proxy.type}"
+          end
+
+          proxy
+        end
+
+        private
+
+        def set_manual_proxy_preference(key, value)
+          return unless value
+
+          host, port = value.to_s.split(":", 2)
+
+          self["network.proxy.#{key}"] = host
+          self["network.proxy.#{key}_port"] = Integer(port) if port
+        end
+
+        def install_extensions(directory)
+          destination = File.join(directory, "extensions")
+
+          @extensions.each do |name, extension|
+            p :extension => name if $DEBUG
+            extension.write_to(destination)
+          end
+        end
+
+        def read_model_prefs
+          return {} unless @model
+
+          read_user_prefs(File.join(@model, 'user.js'))
+        end
+
+        def delete_extensions_cache(directory)
+          FileUtils.rm_f File.join(directory, "extensions.cache")
+        end
+
+        def delete_lock_files(directory)
+          %w[.parentlock parent.lock].each do |name|
+            FileUtils.rm_f File.join(directory, name)
+          end
+        end
+
+        def extension_name_for(path)
+          File.basename(path, File.extname(path))
+        end
+
+        def update_user_prefs_in(directory)
+          path = File.join(directory, 'user.js')
+          prefs = read_user_prefs(path)
+
+          prefs.merge! self.class.default_preferences.fetch 'mutable'
+          prefs.merge! @additional_prefs
+          prefs.merge! self.class.default_preferences.fetch 'frozen'
+
+          prefs[WEBDRIVER_PREFS[:untrusted_certs]]  = !secure_ssl?
+          prefs[WEBDRIVER_PREFS[:native_events]]    = native_events?
+          prefs[WEBDRIVER_PREFS[:untrusted_issuer]] = assume_untrusted_certificate_issuer?
+
+          # If the user sets the home page, we should also start up there
+          prefs["startup.homepage_welcome_url"] = prefs["browser.startup.homepage"]
+
+          write_prefs prefs, path
+        end
+
+        def read_user_prefs(path)
+          prefs = {}
+          return prefs unless File.exist?(path)
+
+          File.read(path).split("\n").each do |line|
+            if line =~ /user_pref\("([^"]+)"\s*,\s*(.+?)\);/
+              key, value = $1.strip, $2.strip
+
+              # wrap the value in an array to make it a valid JSON string.
+              prefs[key] = WebDriver.json_load("[#{value}]").first
+            end
+          end
+
+          prefs
+        end
+
+        def write_prefs(prefs, path)
+          File.open(path, "w") { |file|
+            prefs.each do |key, value|
+              file.puts %{user_pref("#{key}", #{WebDriver.json_dump value});}
+            end
+          }
+        end
+
+      end # Profile
+    end # Firefox
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/firefox/profiles_ini.rb

@@ -0,0 +1,62 @@
+module Selenium
+  module WebDriver
+    module Firefox
+
+      # @api private
+      class ProfilesIni
+
+        def initialize
+          @ini_path = File.join(Util.app_data_path, "profiles.ini")
+          @profile_paths = {}
+
+          parse if File.exist?(@ini_path)
+        end
+
+        def [](name)
+          path = @profile_paths[name]
+          path && Profile.new(path)
+        end
+
+        def refresh
+          @profile_paths.clear
+          parse
+        end
+
+        private
+
+        def parse
+          string      = File.read @ini_path
+          name        = nil
+          is_relative = nil
+          path        = nil
+
+          string.split("\n").each do |line|
+            case line
+            when /^\[Profile/
+              if p = path_for(name, is_relative, path)
+                @profile_paths[name] = p
+                name, path = nil
+              end
+            when /^Name=(.+)$/
+              name = $1.strip
+            when /^IsRelative=(.+)$/
+              is_relative = $1.strip == "1"
+            when /^Path=(.+)$/
+              path = $1.strip
+            end
+          end
+
+          if p = path_for(name, is_relative, path)
+            @profile_paths[name] = p
+          end
+        end
+
+        def path_for(name, is_relative, path)
+          return unless [name, path].any?
+          path = is_relative ? File.join(Util.app_data_path, path) : path
+        end
+
+      end # ProfilesIni
+    end # Firefox
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/firefox/socket_lock.rb

@@ -0,0 +1,61 @@
+module Selenium
+  module WebDriver
+    module Firefox
+
+      #
+      # @api private
+      #
+
+      class SocketLock
+
+        def initialize(port, timeout)
+          @port    = port
+          @timeout = timeout
+        end
+
+        def locked(&blk)
+          lock
+
+          begin
+            yield
+          ensure
+            release
+          end
+        end
+
+        private
+
+        def lock
+          max_time = Time.now + @timeout
+
+          until can_lock? || Time.now >= max_time
+            sleep 0.1
+          end
+
+          unless did_lock?
+            raise Error::WebDriverError, "unable to bind to locking port #{@port} within #{@timeout} seconds"
+          end
+        end
+
+        def release
+          @server && @server.close
+        end
+
+        def can_lock?
+          @server = TCPServer.new(Platform.localhost, @port)
+          ChildProcess.close_on_exec @server
+
+          true
+        rescue SocketError, Errno::EADDRINUSE, Errno::EBADF => ex
+          $stderr.puts "#{self}: #{ex.message}" if $DEBUG
+          false
+        end
+
+        def did_lock?
+          !!@server
+        end
+
+      end # SocketLock
+    end # Firefox
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/firefox/util.rb

@@ -0,0 +1,29 @@
+module Selenium
+  module WebDriver
+    module Firefox
+
+      # @api private
+      module Util
+        module_function
+
+        def app_data_path
+          case Platform.os
+          when :windows
+            "#{ENV['APPDATA']}\\Mozilla\\Firefox"
+          when :macosx
+            "#{Platform.home}/Library/Application Support/Firefox"
+          when :unix, :linux
+            "#{Platform.home}/.mozilla/firefox"
+          else
+            raise "Unknown os: #{Platform.os}"
+          end
+        end
+
+        def stringified?(str)
+          str =~ /^".*"$/
+        end
+
+      end # Util
+    end # Firefox
+  end # WebDriver
+end # Selenium

data/lib/selenium/webdriver/ie.rb

@@ -0,0 +1,19 @@
+module Selenium
+  module WebDriver
+
+    # @api private
+    module IE
+      def self.driver_path=(path)
+        Platform.assert_executable path
+        @driver_path = path
+      end
+
+      def self.driver_path
+        @driver_path ||= nil
+      end
+    end
+  end
+end
+
+require 'selenium/webdriver/ie/server'
+require 'selenium/webdriver/ie/bridge'

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

@@ -0,0 +1,68 @@
+module Selenium
+  module WebDriver
+    module IE
+
+      #
+      # @api private
+      #
+
+      class Bridge < Remote::Bridge
+
+        HOST            = Platform.localhost
+        DEFAULT_PORT    = 5555
+        DEFAULT_TIMEOUT = 30
+
+        def initialize(opts = {})
+          caps          = opts.delete(:desired_capabilities) { Remote::Capabilities.internet_explorer }
+          timeout       = opts.delete(:timeout) { DEFAULT_TIMEOUT }
+          port          = opts.delete(:port) { PortProber.above(DEFAULT_PORT) }
+          http_client   = opts.delete(:http_client)
+          ignore_mode   = opts.delete(:introduce_flakiness_by_ignoring_security_domains)
+          native_events = opts.delete(:native_events) != false
+
+          @server = Server.get
+
+          @server.log_level = opts.delete(:log_level) if opts[:log_level]
+          @server.log_file  = opts.delete(:log_file) if opts[:log_file]
+
+          unless opts.empty?
+            raise ArgumentError, "unknown option#{'s' if opts.size != 1}: #{opts.inspect}"
+          end
+
+          @port = @server.start Integer(port), timeout
+
+          if ignore_mode
+            caps['ignoreProtectedModeSettings'] = true
+          end
+
+          caps['nativeEvents'] = native_events
+
+          remote_opts = {
+            :url => @server.uri,
+            :desired_capabilities => caps
+          }
+
+          remote_opts[:http_client] = http_client if http_client
+
+          super(remote_opts)
+        end
+
+        def browser
+          :internet_explorer
+        end
+
+        def driver_extensions
+          [DriverExtensions::TakesScreenshot, DriverExtensions::HasInputDevices]
+        end
+
+        def quit
+          super
+          nil
+        ensure
+          @server.stop
+        end
+
+      end # Bridge
+    end # IE
+  end # WebDriver
+end # Selenium