Class: Appium::Core::Driver

Inherits:
Object
  • Object
show all
Includes:
Waitable
Defined in:
lib/appium_lib_core/driver.rb

Constant Summary collapse

DEFAULT_APPIUM_PORT = 
4723

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Methods included from Waitable

#wait_until, #wait_until_true

Instance Attribute Details

#automation_name ⇒ Symbol (readonly)

Automation name sent to appium server or received by server.
If automation_name is nil, it is not set both client side and server side.

Returns:

  • (Symbol) 


185
186
187
 
# File 'lib/appium_lib_core/driver.rb', line 185

def automation_name
  @automation_name
end

#caps ⇒ Core::Base::Capabilities (readonly)

Selenium webdriver capabilities, but the value is provided capabilities basis.

Returns:



165
166
167
 
# File 'lib/appium_lib_core/driver.rb', line 165

def caps
  @caps
end

#custom_url ⇒ String (readonly)

Custom URL for the selenium server. If set this attribute, ruby_lib_core try to handshake to the custom url.
Defaults to false. Then try to connect to http://127.0.0.1:#{port}.

Returns:

  • (String) 


190
191
192
 
# File 'lib/appium_lib_core/driver.rb', line 190

def custom_url
  @custom_url
end

#default_wait ⇒ Integer (readonly)

Default wait time for elements to appear in Appium server side. Provide { appium_lib: { wait: 30 } } to Appium::Core.for

Returns:

  • (Integer) 


195
196
197
 
# File 'lib/appium_lib_core/driver.rb', line 195

def default_wait
  @default_wait
end

#device ⇒ Symbol (readonly)

Device type to request from the appium server

Returns:

  • (Symbol) —

    :android and :ios, for example



180
181
182
 
# File 'lib/appium_lib_core/driver.rb', line 180

def device
  @device
end

#direct_connect ⇒ Bool (readonly)

Enable updating Http client endpoint following below keys by Appium/Selenium server.
This works with Base::Http::Default.

If your Selenium/Appium server decorates the new session capabilities response with the following keys:

  • directConnectProtocol

  • directConnectHost

  • directConnectPort

  • directConnectPath

ignore them if this parameter is false. Defaults to true. These keys can have appium: prefix.

Note that the server should provide the keys with valid values. The host value must not be

  • loopback (for example ‘127.0.0.1`, `::1`)

  • link-local (for example ‘169.254.x.x`, `fe80::/10`)

  • unspecified/wildcard (‘0.0.0.0`, `::`)

  • multicast (‘224.0.0.0/4`, `ff00::/8`)

Returns:

  • (Bool) 


242
243
244
 
# File 'lib/appium_lib_core/driver.rb', line 242

def direct_connect
  @direct_connect
end

#driver ⇒ Appium::Core::Base::Driver (readonly)

Returns:



221
222
223
 
# File 'lib/appium_lib_core/driver.rb', line 221

def driver
  @driver
end

#enable_idempotency_header ⇒ Bool (readonly)

Return if adding ‘x-idempotency-key’ header is enabled for each new session request. Following commands should not have the key. The key is unique for each http client instance. Defaults to true github.com/appium/appium-base-driver/pull/400

Returns:

  • (Bool) 


176
177
178
 
# File 'lib/appium_lib_core/driver.rb', line 176

def enable_idempotency_header
  @enable_idempotency_header
end

#http_client ⇒ Appium::Core::Base::Http::Default (readonly)

Return http client called in start_driver()

Returns:



169
170
171
 
# File 'lib/appium_lib_core/driver.rb', line 169

def http_client
  @http_client
end

#listener ⇒ Object (readonly)

instance of AbstractEventListener for logging support Nil by default



218
219
220
 
# File 'lib/appium_lib_core/driver.rb', line 218

def listener
  @listener
end

#port ⇒ Integer (readonly)

Appium’s server port. 4723 is by default. Defaults to DEFAULT_APPIUM_PORT.
Provide { appium_lib: { port: 8080 } } to Appium::Core.for. :custom_url is prior than :port if :custom_url is set.

Returns:

  • (Integer) 


201
202
203
 
# File 'lib/appium_lib_core/driver.rb', line 201

def port
  @port
end

#wait_interval ⇒ Integer (readonly)

Return a time to wait interval. 0.5 seconds is by default Wait::DEFAULT_INTERVAL.
Wait interval time for Base::Wait, wait and wait_true.
Provide { appium_lib: { wait_interval: 0.1 } } to Appium::Core.for.

Returns:

  • (Integer) 


214
215
216
 
# File 'lib/appium_lib_core/driver.rb', line 214

def wait_interval
  @wait_interval
end

#wait_timeout ⇒ Integer (readonly)

Return a time wait timeout. 30 seconds is by default Wait::DEFAULT_TIMEOUT.
Wait time for Base::Wait, wait and wait_true.
Provide { appium_lib: { wait_timeout: 20 } } to Appium::Core.for.

Returns:

  • (Integer) 


208
209
210
 
# File 'lib/appium_lib_core/driver.rb', line 208

def wait_timeout
  @wait_timeout
end

Class Method Details

.attach_to(session_id, url: nil, automation_name: nil, platform_name: nil, http_client_ops: { http_client: nil, open_timeout: 999_999, read_timeout: 999_999 }) ⇒ Selenium::WebDriver

Attach to an existing session. The main usage of this method is to attach to an existing session for debugging. The generated driver instance has the capabilities which has the given automationName and platformName only since the W3C WebDriver spec does not provide an endpoint to get running session’s capabilities.

Examples:


new_driver = ::Appium::Core::Driver.attach_to(
  driver.session_id,  # The 'driver' has an existing session id
  url: 'http://127.0.0.1:4723', automation_name: 'UiAutomator2', platform_name: 'Android'
)
new_driver.page_source # for example

Parameters:

  • session_id (String) —

    The session id to attach to.

  • url (String) (defaults to: nil) —

    The WebDriver URL to attach to with the session_id.

  • automation_name (String) (defaults to: nil) —

    The platform name to keep in the dummy capabilities

  • platform_name (String) (defaults to: nil) —

    The automation name to keep in the dummy capabilities

Returns:

  • (Selenium::WebDriver) —

    A new driver instance with the given session id.



368
369
370
371
372
373
374
375
376
377
378
379
 
# File 'lib/appium_lib_core/driver.rb', line 368

def self.attach_to(
  session_id, url: nil, automation_name: nil, platform_name: nil,
  http_client_ops: { http_client: nil, open_timeout: 999_999, read_timeout: 999_999 }
)
  new.attach_to(
    session_id,
    automation_name: automation_name,
    platform_name: platform_name,
    url: url,
    http_client_ops: http_client_ops
  )
end

.for(opts = {}) ⇒ Driver

Creates a new driver and extend particular methods

Examples:


# format 1
@core = Appium::Core.for caps: {...}, appium_lib: {...}
# format 2. 'capabilities:' is also available instead of 'caps:'.
@core = Appium::Core.for url: "http://127.0.0.1:8080", capabilities: {...}, appium_lib: {...}

require 'rubygems'
require 'appium_lib_core'

# Start iOS driver
opts = {
         caps: {
           platformName: :ios,
           platformVersion: '11.0',
           deviceName: 'iPhone Simulator',
           automationName: 'XCUITest',
           app: '/path/to/MyiOS.app'
         },
         appium_lib: {
           port: 8080,
           wait: 0,
           wait_timeout: 20,
           wait_interval: 0.3,
           listener: nil,
         }
       }
@core = Appium::Core.for(opts) # create a core driver with 'opts' and extend methods into 'self'
@core.start_driver # Connect to 'http://127.0.0.1:8080' because of 'port: 8080'

# Start iOS driver with .zip file over HTTP
# 'capabilities:' is also available instead of 'caps:'. Either is fine.
opts = {
         capabilities: {
           platformName: :ios,
           platformVersion: '11.0',
           deviceName: 'iPhone Simulator',
           automationName: 'XCUITest',
           app: 'http://example.com/path/to/MyiOS.app.zip'
         },
         appium_lib: {
           server_url: 'http://custom-host:8080/wd/hub',
           wait: 0,
           wait_timeout: 20,
           wait_interval: 0.3,
           listener: nil,
         }
       }
@core = Appium::Core.for(opts)
@core.start_driver # Connect to 'http://custom-host:8080/wd/hub'

# Start iOS driver as another format. 'url' is available like below
opts = {
         url: "http://custom-host:8080/wd/hub",
         capabilities: {
           platformName: :ios,
           platformVersion: '11.0',
           deviceName: 'iPhone Simulator',
           automationName: 'XCUITest',
           app: '/path/to/MyiOS.app'
         },
         appium_lib: {
           wait: 0,
           wait_timeout: 20,
           wait_interval: 0.3,
           listener: nil,
         }
       }
@core = Appium::Core.for(opts) # create a core driver with 'opts' and extend methods into 'self'
@core.start_driver # start driver with 'url'. Connect to 'http://custom-host:8080/wd/hub'

# With a custom listener
class CustomListener < ::Selenium::WebDriver::Support::AbstractEventListener
  // something
end
capabilities: {
  platformName: :ios,
  platformVersion: '11.0',
  deviceName: 'iPhone Simulator',
  automationName: 'XCUITest',
  app: '/path/to/MyiOS.app'
},
appium_lib: {
  listener: CustomListener.new,
}
@core = Appium::Core.for capabilities: capabilities, appium_lib: appium_lib
@core.start_driver

Parameters:

  • opts (Hash) (defaults to: {}) —

    A options include capabilities for the Appium Server and for the client.

Options Hash (opts):

  • :caps (Hash) —

    Appium capabilities.

  • :capabilities (Hash) —

    The same as :caps. This param is for compatibility with Selenium WebDriver format

  • :appium_lib (Appium::Core::Options) —

    Capabilities affect only ruby client

  • :url (String) —

    The same as :custom_url in :appium_lib. This param is for compatibility with Selenium WebDriver format

Returns:



344
345
346
 
# File 'lib/appium_lib_core/driver.rb', line 344

def self.for(opts = {})
  new.setup_for_new_session(opts)
end

Instance Method Details

#appium_server_version ⇒ Hash

Returns the server’s version info. This method calls driver.remote_status internally

Returns blank hash in a case driver.remote_status got an error such as Selenium Grid. It returns 500 error against ‘remote_status’.

Examples:


@core.appium_server_version
  {
      "build" => {
          "version" => "1.9.2",
          "git-sha" => "fd7c7fd19d3896719616cd970229d73e63b5271a",
          "built" => "2018-11-08 12:24:02 +0900"
      }
  }

@core.appium_server_version #=> {}

Returns:

  • (Hash) 


583
584
585
586
587
588
589
590
591
 
# File 'lib/appium_lib_core/driver.rb', line 583

def appium_server_version
  return {} if @driver.nil?

  @driver.remote_status
rescue StandardError
  # Ignore error case in a case the target appium server
  # does not support `/status` API.
  {}
end

#attach_to(session_id, url: nil, automation_name: nil, platform_name: nil, http_client_ops: { http_client: nil, open_timeout: 999_999, read_timeout: 999_999 }) ⇒ Object

Attach to an existing session

Raises:



508
509
510
511
512
513
514
515
516
517
518
519
520
521
522
523
524
525
526
527
528
529
530
531
532
533
534
535
536
537
538
539
540
541
542
543
 
# File 'lib/appium_lib_core/driver.rb', line 508

def attach_to(session_id, url: nil, automation_name: nil, platform_name: nil,
              http_client_ops: { http_client: nil, open_timeout: 999_999, read_timeout: 999_999 })
  raise ::Appium::Core::Error::ArgumentError, 'The :url must not be nil' if url.nil?
  raise ::Appium::Core::Error::ArgumentError, 'The :automation_name must not be nil' if automation_name.nil?
  raise ::Appium::Core::Error::ArgumentError, 'The :platform_name must not be nil' if platform_name.nil?

  @custom_url = url

  # use lowercase internally
  @automation_name = convert_downcase(automation_name)
  @device = convert_downcase(platform_name)

  extend_for(device: @device, automation_name: @automation_name)

  @http_client = get_http_client http_client: http_client_ops.delete(:http_client),
                                 open_timeout: http_client_ops.delete(:open_timeout),
                                 read_timeout: http_client_ops.delete(:read_timeout)

  # Note that 'enable_idempotency_header' works only a new session reqeust. The attach_to method skips
  # the new session request, this it does not needed.

  begin
    # included https://github.com/SeleniumHQ/selenium/blob/43f8b3f66e7e01124eff6a5805269ee441f65707/rb/lib/selenium/webdriver/remote/driver.rb#L29
    @driver = ::Appium::Core::Base::Driver.new(http_client: @http_client,
                                               url: @custom_url,
                                               listener: @listener,
                                               existing_session_id: session_id,
                                               automation_name: automation_name,
                                               platform_name: platform_name)
  rescue Errno::ECONNREFUSED
    raise ::Appium::Core::Error::SessionNotCreatedError,
          "ERROR: Unable to connect to Appium. Is the server running on #{@custom_url}?"
  end

  @driver
end

#get_http_client(http_client: nil, open_timeout: nil, read_timeout: nil) ⇒ Object 



545
546
547
 
# File 'lib/appium_lib_core/driver.rb', line 545

def get_http_client(http_client: nil, open_timeout: nil, read_timeout: nil)
  http_client || Appium::Core::Base::Http::Default.new(open_timeout: open_timeout, read_timeout: read_timeout)
end

#set_implicit_wait_by_default(wait) ⇒ Object

Ignore setting default wait if the target driver has no implementation



550
551
552
553
554
555
556
557
558
559
 
# File 'lib/appium_lib_core/driver.rb', line 550

def set_implicit_wait_by_default(wait)
  return if @default_wait.nil?

  @driver.manage.timeouts.implicit_wait = wait
rescue ::Selenium::WebDriver::Error::UnknownError => e
  raise ::Appium::Core::Error::ServerError, e.message unless e.message.include?('The operation requested is not yet implemented')

  ::Appium::Logger.debug(e.message)
  {}
end

#setup_for_new_session(opts = {}) ⇒ Object

Set up for a new session



399
400
401
402
403
404
405
406
407
408
409
410
411
 
# File 'lib/appium_lib_core/driver.rb', line 399

def setup_for_new_session(opts = {})
  @custom_url = opts.delete :url # to set the custom url as :url

  @caps = get_caps(opts)

  set_appium_lib_specific_values(get_appium_lib_opts(opts))
  set_app_path
  set_appium_device
  set_automation_name

  extend_for(device: @device, automation_name: @automation_name)
  self
end

#start_driver(server_url: nil, http_client_ops: { http_client: nil, open_timeout: 999_999, read_timeout: 999_999 }) ⇒ Selenium::WebDriver

Creates a new global driver and quits the old one if it exists. You can customise http_client as the following

Examples:


require 'rubygems'
require 'appium_lib_core'

# platformName takes a string or a symbol.

# Start iOS driver
opts = {
         capabilities: {
           platformName: :ios,
           platformVersion: '11.0',
           deviceName: 'iPhone Simulator',
           automationName: 'XCUITest',
           app: '/path/to/MyiOS.app'
         },
         appium_lib: {
           wait: 20,
           wait_timeout: 20,
           wait_interval: 0.3,
         }
       }

@core = Appium::Core.for(opts) # create a core driver with 'opts' and extend methods into 'self'
@driver = @core.start_driver server_url: "http://127.0.0.1:8000"

# Attach custom HTTP client
@driver = @core.start_driver server_url: "http://127.0.0.1:8000",
                             http_client_ops: { http_client: Your:Http:Client.new,
                                                open_timeout: 1_000,
                                                read_timeout: 1_000 }

Parameters:

  • server_url (String) (defaults to: nil) —

    Custom server url to send to requests. Default is “127.0.0.1:4723”.

  • http_client_ops (Hash) (defaults to: { http_client: nil, open_timeout: 999_999, read_timeout: 999_999 }) —

    Options for http client

Options Hash (http_client_ops:):

  • :http_client (Hash) —

    Custom HTTP Client

  • :open_timeout (Hash) —

    Custom open timeout for http client.

  • :read_timeout (Hash) —

    Custom read timeout for http client.

Returns:

  • (Selenium::WebDriver) —

    A new driver instance



456
457
458
459
460
461
462
463
464
465
466
467
468
469
470
471
472
473
474
475
476
477
478
479
480
481
482
483
484
485
486
487
488
489
490
491
492
493
494
495
496
497
498
499
500
501
502
503
504
 
# File 'lib/appium_lib_core/driver.rb', line 456

def start_driver(server_url: nil,
                 http_client_ops: { http_client: nil, open_timeout: 999_999, read_timeout: 999_999 })
  @custom_url ||= "http://127.0.0.1:#{@port}"
  @custom_url = server_url unless server_url.nil?

  @http_client = get_http_client http_client: http_client_ops.delete(:http_client),
                                 open_timeout: http_client_ops.delete(:open_timeout),
                                 read_timeout: http_client_ops.delete(:read_timeout)

  if @enable_idempotency_header
    if @http_client.instance_variable_defined? :@additional_headers
      @http_client.set_additional_header Appium::Core::Base::Http::RequestHeaders::KEYS[:idempotency], SecureRandom.uuid
    else
      ::Appium::Logger.warn 'No additional_headers attribute in this http client instance'
    end
  end

  begin
    @driver = ::Appium::Core::Base::Driver.new(listener: @listener,
                                               http_client: @http_client,
                                               capabilities: @caps, # ::Appium::Core::Base::Capabilities
                                               url: @custom_url,
                                               wait_timeout: @wait_timeout,
                                               wait_interval: @wait_interval)

    if @direct_connect
      d_c = DirectConnections.new(@driver.capabilities)
      if d_c.valid?
        @driver.update_sending_request_to(protocol: d_c.protocol, host: d_c.host, port: d_c.port, path: d_c.path)
      else
        ::Appium::Logger.warn(
          "Direct connect is enabled but the server did not provide valid direct connect information (#{d_c.protocol}, #{d_c.host}, #{d_c.port}, #{d_c.path}). " \
          "Continue with the original URL (#{@custom_url})"
        )
      end
    end
  rescue Errno::ECONNREFUSED => e
    raise "ERROR: Unable to connect to Appium. Is the server running on #{@custom_url}? Error: #{e}"
  end

  if @http_client.instance_variable_defined? :@additional_headers
    # We only need the key for a new session request. Should remove it for other following commands.
    @http_client.delete_additional_header Appium::Core::Base::Http::RequestHeaders::KEYS[:idempotency]
  end

  set_implicit_wait_by_default(@default_wait)

  @driver
end