lib/watir/capabilities.rb in watir-6.19.1 vs lib/watir/capabilities.rb in watir-7.0.0.beta1
- old
+ new
@@ -9,289 +9,113 @@
end
@options = options.dup
Watir.logger.info "Creating Browser instance of #{browser} with user provided options: #{@options.inspect}"
- deprecate_options_capabilities
- deprecate_desired_capabilities
- deprecate_url_service if @options.key?(:service) && @options.key?(:url)
+ if @options.key?(:capabilities) && @options.key?(:options)
+ raise(ArgumentError, ':capabilities and :options are not both allowed')
+ end
+ raise(ArgumentError, ':url and :service are not both allowed') if @options.key?(:service) && @options.key?(:url)
- @browser = deprecate_remote(browser) || browser.nil? && infer_browser || browser.to_sym
+ @browser = browser.nil? && infer_browser || browser
- @selenium_browser = options[:url] ? :remote : @browser
- @selenium_opts = {}
+ @selenium_browser = @options.key?(:url) ? :remote : @browser
end
def to_args
[@selenium_browser, process_arguments]
end
private
def process_arguments
- @selenium_opts[:listener] = @options.delete(:listener) if @options.key?(:listener)
+ selenium_opts = {}
+ selenium_opts[:listener] = @options.delete(:listener) if @options.key?(:listener)
if @options.key?(:url)
- @selenium_opts[:url] = @options.delete(:url)
+ selenium_opts[:url] = @options.delete(:url)
else
- process_service(@options.delete(:service))
+ service = process_service
+ selenium_opts[:service] = service if service
end
- process_http_client
- process_browser_options
- process_capabilities
- Watir.logger.info "Creating Browser instance with Watir processed options: #{@selenium_opts.inspect}"
+ selenium_opts[:http_client] = process_http_client
+ selenium_opts[:capabilities] = @options.delete(:capabilities) || process_browser_options
- @selenium_opts
+ Watir.logger.info "Creating Browser instance with Watir processed options: #{selenium_opts.inspect}"
+ selenium_opts
end
def process_http_client
http_client = @options.delete(:http_client) || Watir::HttpClient.new
- if http_client.is_a?(Hash)
- http_client = Watir::HttpClient.new(http_client)
- elsif !http_client.is_a?(Selenium::WebDriver::Remote::Http::Common)
- raise TypeError, ':http_client must be a Hash or a Selenium HTTP Client instance'
- end
- unless http_client.is_a?(Watir::HttpClient)
+ case http_client
+ when Hash
+ Watir::HttpClient.new(**http_client)
+ when Watir::HttpClient
+ http_client
+ when Selenium::WebDriver::Remote::Http::Common
Watir.logger.warn 'Check out the new Watir::HttpClient and let us know if there are missing features you need',
ids: [:watir_client]
+ http_client
+ else
+ raise TypeError, ':http_client must be a Hash or a Selenium HTTP Client instance'
end
-
- process_http_client_timeouts(http_client)
- @selenium_opts[:http_client] = http_client
end
def process_browser_options
browser_options = @options.delete(:options) || {}
- process_w3c_capabilities(browser_options)
+ options = browser_options if browser_options.is_a? Selenium::WebDriver::Options
+ options ||= Selenium::WebDriver::Options.send(@browser, **browser_options)
+
+ browser_specific_options(options)
+ raise ArgumentError, "#{@options} are unrecognized arguments for Browser constructor" unless @options.empty?
+
+ options
+ end
+
+ def browser_specific_options(options)
case @browser
- when :chrome
- process_chrome_options(browser_options)
+ when :chrome, :edge, :microsoftedge
+ if @options.delete(:headless)
+ options.args << '--headless'
+ options.args << '--disable-gpu'
+ options.args << '--no-sandbox'
+ end
when :firefox
- process_firefox_options(browser_options)
+ options.headless! if @options.delete(:headless)
when :safari
- process_safari_options(browser_options)
- when :ie, :internet_explorer
- process_ie_options(browser_options)
+ Selenium::WebDriver::Safari.technology_preview! if @options.delete(:technology_preview)
end
end
- def process_capabilities
- caps = @options.delete(:capabilities)
+ def process_service
+ service = @options.delete(:service)
- unless @options.empty?
- Watir.logger.deprecate('passing unrecognized arguments into Browser constructor',
- 'appropriate keyword to nest all arguments',
- ids: %i[unknown_keyword capabilities],
- reference: 'http://watir.com/guides/capabilities.html')
- end
+ case service
+ when nil
+ nil
+ when Hash
+ return if service.empty?
- if caps
- @selenium_opts.merge!(@options)
+ Selenium::WebDriver::Service.send(@browser, **service)
+ when Selenium::WebDriver::Service
+ service
else
- caps = Selenium::WebDriver::Remote::Capabilities.send @browser, @options.merge(@w3c_caps)
+ raise TypeError, "#{service} needs to be Selenium Service or Hash instance"
end
-
- @selenium_opts[:desired_capabilities] = caps
end
- def deprecate_desired_capabilities
- return unless @options.key?(:desired_capabilities)
-
- Watir.logger.deprecate(':desired_capabilities to initialize Browser',
- ':capabilities or preferably :options',
- ids: [:desired_capabilities],
- reference: 'http://watir.com/guides/capabilities.html')
- @options[:capabilities] = @options.delete(:desired_capabilities)
- end
-
- def deprecate_url_service
- Watir.logger.deprecate('allowing Browser initialization with both :url & :service',
- 'just :service',
- ids: [:url_service],
- reference: 'http://watir.com/guides/capabilities.html')
- end
-
- def process_http_client_timeouts(http_client)
- deprecate_client_timeout(http_client) if @options.key? :client_timeout
- deprecate_open_timeout(http_client) if @options.key? :open_timeout
- deprecate_read_timeout(http_client) if @options.key? :read_timeout
- end
-
- def deprecate_client_timeout(http_client)
- Watir.logger.deprecate(':client_timeout to initialize Browser',
- ':open_timeout and/or :read_timeout in a Hash with :http_client key',
- ids: [:http_client_timeout],
- reference: 'http://watir.com/guides/capabilities.html')
- timeout = @options.delete(:client_timeout)
- http_client.open_timeout = timeout
- http_client.read_timeout = timeout
- end
-
- def deprecate_open_timeout(http_client)
- Watir.logger.deprecate(':open_timeout to initialize Browser',
- ':open_timeout in a Hash with :http_client key',
- ids: %i[http_open_timeout capabilities],
- reference: 'http://watir.com/guides/capabilities.html')
- http_client.open_timeout = @options.delete(:open_timeout)
- end
-
- def deprecate_read_timeout(http_client)
- Watir.logger.deprecate(':read_timeout to initialize Browser',
- ':read_timeout in a Hash with :http_client key',
- ids: %i[http_read_timeout capabilities],
- reference: 'http://watir.com/guides/capabilities.html')
- http_client.read_timeout = @options.delete(:read_timeout)
- end
-
- def process_chrome_options(browser_options)
- @selenium_opts[:options] = browser_options if browser_options.is_a? Selenium::WebDriver::Chrome::Options
- @selenium_opts[:options] ||= Selenium::WebDriver::Chrome::Options.new(**browser_options)
-
- process_args
-
- return unless @options.delete(:headless)
-
- @selenium_opts[:options].args << '--headless'
- @selenium_opts[:options].args << '--disable-gpu'
- end
-
- def process_firefox_options(browser_options)
- @selenium_opts[:options] = browser_options if browser_options.is_a? Selenium::WebDriver::Firefox::Options
-
- @selenium_opts[:options] ||= Selenium::WebDriver::Firefox::Options.new(**browser_options)
- if @options.key?(:profile)
- new = 'Initializing Browser with both :profile and :option'
- old = ':profile as a key inside :option'
- Watir.logger.deprecate new, old, ids: [:firefox_profile]
-
- @selenium_opts[:options].profile = @options.delete(:profile)
- end
-
- @selenium_opts[:options].args << '--headless' if @options.delete(:headless)
- end
-
- def process_safari_options(browser_options)
- @selenium_opts[:options] = browser_options if browser_options.is_a? Selenium::WebDriver::Safari::Options
- @selenium_opts[:options] ||= Selenium::WebDriver::Safari::Options.new(**browser_options)
- Selenium::WebDriver::Safari.technology_preview! if @options.delete(:technology_preview)
- end
-
- def process_ie_options(browser_options)
- @selenium_opts[:options] = browser_options if browser_options.is_a? Selenium::WebDriver::IE::Options
- @selenium_opts[:options] ||= Selenium::WebDriver::IE::Options.new(**browser_options)
-
- process_args
- end
-
- def process_service(service)
- service = deprecate_service_keywords if service.nil?
-
- @selenium_opts[:service] = case service
- when Hash
- return if service.empty?
-
- Selenium::WebDriver::Service.send(@browser, service)
- when Selenium::WebDriver::Service
- service
- else
- raise TypeError, "#{service} needs to be Selenium Service or Hash instance"
- end
- end
-
- def deprecate_service_keywords
- service = {}
- if @options.key?(:port)
- Watir.logger.deprecate(':port to initialize Browser',
- ':port in a Hash with :service key',
- ids: %i[port_keyword capabilities],
- reference: 'http://watir.com/guides/capabilities.html')
- service[:port] = @options.delete(:port)
- end
- if @options.key?(:driver_opts)
- Watir.logger.deprecate(':driver_opts to initialize Browser',
- ':args as Array in a Hash with :service key',
- ids: %i[driver_opts_keyword capabilities],
- reference: 'http://watir.com/guides/capabilities.html')
- service[:args] = @options.delete(:driver_opts)
- end
- service
- end
-
- def process_args
- args = if @options.key?(:args)
- deprecate_args
- @options.delete(:args)
- elsif @options.key?(:switches)
- deprecate_switches
- @options.delete(:switches)
- else
- []
- end
- args.each { |arg| @selenium_opts[:options].args << arg }
- end
-
- def deprecate_args
- Watir.logger.deprecate(':args to initialize Browser',
- ':args inside Hash with :options key',
- ids: %i[args_keyword capabilities],
- reference: 'http://watir.com/guides/capabilities.html')
- end
-
- def deprecate_switches
- Watir.logger.deprecate(':switches to initialize Browser',
- ':switches inside Hash with :options key',
- ids: %i[switches_keyword capabilities],
- reference: 'http://watir.com/guides/capabilities.html')
- end
-
- def deprecate_remote(browser)
- return unless browser == :remote
-
- Watir.logger.deprecate(':remote to initialize Browser',
- 'browser key along with remote url',
- ids: %i[remote_keyword capabilities],
- reference: 'http://watir.com/guides/capabilities.html')
- infer_browser
- end
-
def infer_browser
if @options.key?(:browser)
@options.delete(:browser)
elsif @options.key?(:capabilities)
- @options[:capabilities].browser_name.tr(' ', '_').to_sym
+ @options[:capabilities].browser_name.tr(' ', '_').downcase.to_sym
elsif @options.key?(:options)
@options[:options].class.to_s.split('::')[-2].downcase.to_sym
else
:chrome
end
- end
-
- def process_w3c_capabilities(opts)
- @w3c_caps = {}
- return unless opts.is_a?(Hash)
-
- w3c_keys = %i[browser_version platform_name accept_insecure_certs page_load_strategy proxy set_window_rect
- timeouts unhandled_prompt_behavior strict_file_interactibility]
-
- opts.each do |key, _val|
- next unless key.to_s.include?(':') || w3c_keys.include?(key)
-
- @w3c_caps[key] = opts.delete(key)
- end
- end
-
- def deprecate_options_capabilities
- return unless @options.key?(:capabilities) && @options.key?(:options)
-
- old = 'initializing Browser with both options and capabilities'
- new = 'Hash with :options, Selenium Options instance with :options or' \
-'Selenium Capabilities instance with :capabilities'
- Watir.logger.deprecate(old,
- new,
- ids: %i[options_capabilities capabilities],
- reference: 'http://watir.com/guides/capabilities.html')
end
end
end