selenium-webdriver 2.45.0 → 3.142.7

data/Gemfile.lock

@@ -1,48 +0,0 @@
-PATH
-  remote: .
-  specs:
-    selenium-webdriver (2.45.0)
-      childprocess (~> 0.5)
-      multi_json (~> 1.0)
-      rubyzip (~> 1.0)
-      websocket (~> 1.0)
-
-GEM
-  remote: https://rubygems.org/
-  specs:
-    addressable (2.3.7)
-    builder (3.2.2)
-    childprocess (0.5.5)
-      ffi (~> 1.0, >= 1.0.11)
-    ci_reporter (1.9.2)
-      builder (>= 2.1.2)
-    crack (0.4.2)
-      safe_yaml (~> 1.0.0)
-    diff-lcs (1.2.5)
-    ffi (1.9.6)
-    multi_json (1.10.1)
-    rack (1.5.2)
-    rspec (2.99.0)
-      rspec-core (~> 2.99.0)
-      rspec-expectations (~> 2.99.0)
-      rspec-mocks (~> 2.99.0)
-    rspec-core (2.99.2)
-    rspec-expectations (2.99.2)
-      diff-lcs (>= 1.1.3, < 2.0)
-    rspec-mocks (2.99.2)
-    rubyzip (1.1.7)
-    safe_yaml (1.0.4)
-    webmock (1.18.0)
-      addressable (>= 2.3.6)
-      crack (>= 0.3.2)
-    websocket (1.2.1)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  ci_reporter (~> 1.6, >= 1.6.2)
-  rack (~> 1.0)
-  rspec (~> 2.99.0)
-  selenium-webdriver!
-  webmock (~> 1.7, >= 1.7.5)

data/lib/selenium/client/base.rb

@@ -1,132 +0,0 @@
-module Selenium
-  module Client
-
-		# Driver constructor and session management commands
-    module Base
-      include Selenium::Client::Protocol
-      include Selenium::Client::GeneratedDriver
-      include Selenium::Client::Extensions
-      include Selenium::Client::Idiomatic
-
-      attr_reader :host, :port, :browser_string, :browser_url,
-                  :default_timeout_in_seconds,
-                  :default_javascript_framework,
-                  :highlight_located_element_by_default
-
-      #
-      # Create a new client driver
-      #
-      # Example:
-      #
-      # Selenium::Client::Driver.new \
-      #     :host => "localhost",
-      #     :port => 4444,
-      #     :browser => "*firefox",
-      #     :timeout_in_seconds => 10,
-      #     :url => "http://localhost:3000",
-      #
-      # You can also set the default javascript framework used for :wait_for
-      # AJAX and effects semantics (:prototype is the default value):
-      #
-      # Selenium::Client::Driver.new \
-      #     :host => "localhost",
-      #     :port => 4444,
-      #     :browser => "*firefox",
-      #     :timeout_in_seconds => 10,
-      #     :url => "http://localhost:3000",
-      #     :javascript_framework => :jquery
-      #
-      # You can also enables automatic highlighting of located elements
-      # by passing the highlight_located_element option, e.g.
-      #
-      # Selenium::Client::Driver.new \
-      #     :host => "localhost",
-      #     :port => 4444,
-      #     :browser => "*firefox",
-      #     :highlight_located_element => true
-      #
-      def initialize(*args)
-        if args[0].kind_of?(Hash)
-          options = args[0]
-          @host = options[:host]
-          @port = options[:port].to_i
-          @browser_string = options[:browser]
-          @browser_url = options[:url]
-          @default_timeout_in_seconds = (options[:timeout_in_seconds] || 300).to_i
-          @default_javascript_framework = options[:javascript_framework] || :prototype
-          @highlight_located_element_by_default = options[:highlight_located_element] || false
-        else
-          @host = args[0]
-          @port = args[1].to_i
-          @browser_string = args[2]
-          @browser_url = args[3]
-          @default_timeout_in_seconds = (args[4] || 300).to_i
-          @default_javascript_framework = :prototype
-          @highlight_located_element_by_default = false
-        end
-
-        @extension_js = ""
-        @session_id = nil
-      end
-
-      def session_started?
-        not @session_id.nil?
-      end
-
-      # Starts a new browser session (launching a new browser matching
-      # configuration provided at driver creation time).
-      #
-      # Browser session specific option can also be provided. e.g.
-      #
-      #    driver.start_new_browser_session(:captureNetworkTraffic => true)
-      #
-      def start_new_browser_session(options={})
-        start_args = [@browser_string, @browser_url, @extension_js]
-
-        if driver = options.delete(:driver)
-          expected_browser_string = "*webdriver"
-          unless @browser_string == expected_browser_string
-            raise ArgumentError, "can't use :driver unless the browser string is #{expected_browser_string.inspect} (got #{@browser_string.inspect})"
-          end
-
-          sid = driver.capabilities['webdriver.remote.sessionid']
-          sid or raise ArgumentError, "This driver can not be wrapped in the RC API."
-
-          start_args << "webdriver.remote.sessionid=#{sid}"
-        end
-
-        start_args << options.collect {|key,value| "#{key.to_s}=#{value.to_s}"}.sort.join(";")
-
-        @session_id = string_command "getNewBrowserSession", start_args
-        # Consistent timeout on the remote control and driver side.
-        # Intuitive and this is what you want 90% of the time
-        self.remote_control_timeout_in_seconds = @default_timeout_in_seconds
-        self.highlight_located_element = true if highlight_located_element_by_default
-      end
-
-      def close_current_browser_session
-        remote_control_command "testComplete" if @session_id
-        @session_id = nil
-      end
-
-      def start(opts = {})
-        start_new_browser_session opts
-      end
-
-      def stop
-	      close_current_browser_session
-      end
-
-      def chrome_backend?
-        ["*chrome", "*firefox", "*firefox2", "*firefox3"].include?(@browser_string)
-      end
-
-      def javascript_extension=(new_javascript_extension)
-        @extension_js = new_javascript_extension
-      end
-	    alias :set_extension_js :javascript_extension=
-
-    end
-
-  end
-end

data/lib/selenium/client/driver.rb

@@ -1,10 +0,0 @@
-module Selenium
-  module Client
-
-    # Client driver providing the complete API to drive a Selenium Remote Control
-    class Driver
-      include Selenium::Client::Base
-    end
-
-  end
-end

data/lib/selenium/client/errors.rb

@@ -1,9 +0,0 @@
-module Selenium
-  module Client
-    class CommandError < RuntimeError
-    end
-
-    class ProtocolError < RuntimeError
-    end
-  end
-end

data/lib/selenium/client/extensions.rb

@@ -1,118 +0,0 @@
-module Selenium
-  module Client
-
-    # Convenience methods not explicitely part of the protocol
-    module Extensions
-
-	    # These for all Ajax request to finish (Only works if you are using prototype, the wait happens in the browser)
-	    #
-	    # See http://davidvollbracht.com/2008/6/4/30-days-of-tech-day-3-waitforajax for
-	    # more background.
-      def wait_for_ajax(options={})
-		    builder = JavascriptExpressionBuilder.new active_javascript_framework(options)
-	      wait_for_condition builder.no_pending_ajax_requests.script,
-	                         options[:timeout_in_seconds]
-      end
-
-	    # Wait for all Prototype effects to be processed (the wait happens in the browser).
-	    #
-	    # Credits to http://github.com/brynary/webrat/tree/master
-			def wait_for_effects(options={})
-		    builder = JavascriptExpressionBuilder.new active_javascript_framework(options)
-			  wait_for_condition builder.no_pending_effects.script,
-			                     options[:timeout_in_seconds]
-			end
-
-      # Wait for an element to be present (the wait happens in the browser).
-      def wait_for_element(locator, options={})
-        builder = JavascriptExpressionBuilder.new
-        builder.find_element(locator).append("element != null;")
-        wait_for_condition builder.script, options[:timeout_in_seconds]
-      end
-
-      # Wait for an element to NOT be present (the wait happens in the browser).
-      def wait_for_no_element(locator, options={})
-        builder = JavascriptExpressionBuilder.new
-        builder.find_element(locator).append("element == null;")
-        wait_for_condition builder.script, options[:timeout_in_seconds]
-      end
-
-			# Wait for some text to be present (the wait is happening browser side).
-			#
-      # wait_for_text will search for the given argument within the innerHTML
-      # of the current DOM. Note that this method treats a single string
-      # as a special case.
-      #
-      # ==== Parameters
-      # wait_for_text accepts an optional hash of parameters:
-      # * <tt>:element</tt> - a selenium locator for an element limiting
-      #   the search scope.
-      # * <tt>:timeout_in_seconds</tt> - duration in seconds after  which we
-      #   time out if text cannot be found.
-      #
-      # ==== Regular Expressions
-      # In addition to plain strings, wait_for_text accepts regular expressions
-      # as the pattern specification.
-      #
-      # ==== Examples
-      # The following are equivalent, and will match "some text" anywhere
-      # within the document:
-      #   wait_for_text "some text"
-      #   wait_for_text /some text/
-      #
-      # This will match "some text" anywhere within the specified element:
-      #   wait_for_text /some text/, :element => "container"
-      #
-      # This will match "some text" only if it exactly matches the complete
-      # innerHTML of the specified element:
-      #   wait_for_text "some text", :element => "container"
-      #
-      def wait_for_text(pattern, options={})
-        builder = JavascriptExpressionBuilder.new
-		    builder.find_text(pattern, options).append("text_match == true;")
-        wait_for_condition builder.script, options[:timeout_in_seconds]
-      end
-
-      # Wait for some text to NOT be present (the wait happens in the browser).
-      #
-      # See wait_for_text for usage details.
-      def wait_for_no_text(pattern, options={})
-        builder = JavascriptExpressionBuilder.new
-		    builder.find_text(pattern, options).append("text_match == false;")
-        wait_for_condition builder.script, options[:timeout_in_seconds]
-      end
-
-      # Wait for a field to get a specific value (the wait happens in the browser).
-      def wait_for_field_value(locator, expected_value, options={})
-        builder = JavascriptExpressionBuilder.new
-        builder.find_element(locator).element_value_is(expected_value)
-        wait_for_condition builder.script, options[:timeout_in_seconds]
-      end
-
-      # Wait for a field to not have a specific value (the wait happens in the browser).
-      def wait_for_no_field_value(locator, expected_value, options={})
-        builder = JavascriptExpressionBuilder.new
-        builder.find_element(locator).element_value_is_not(expected_value)
-        wait_for_condition builder.script, options[:timeout_in_seconds]
-      end
-
-      # Wait for something to be visible (the wait happens in the browser).
-      def wait_for_visible(locator, options={})
-        builder = JavascriptExpressionBuilder.new
-        wait_for_condition builder.visible(locator).script, options[:timeout_in_seconds]
-      end
-
-      # Wait for something to not be visible (the wait happens in the browser).
-      def wait_for_not_visible(locator, options={})
-        builder = JavascriptExpressionBuilder.new
-        wait_for_condition builder.not_visible(locator).script, options[:timeout_in_seconds]
-      end
-
-      def active_javascript_framework(options)
-        options[:javascript_framework] || default_javascript_framework
-      end
-
-    end
-
-  end
-end