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, #wait_true

Constructor Details

#initialize(target, opts = {}) ⇒ Driver 



131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
 
# File 'lib/appium_lib_core/driver.rb', line 131

def initialize(target, opts = {})
  @delegate_target = target # for testing purpose

  opts = Appium.symbolize_keys opts
  validate_keys(opts)

  @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, target: target)

  self # rubocop:disable Lint/Void
end

Instance Attribute Details

#automation_name ⇒ Hash (readonly)

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



22
23
24
 
# File 'lib/appium_lib_core/driver.rb', line 22

def automation_name
  @automation_name
end

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

Selenium webdriver capabilities



9
10
11
 
# File 'lib/appium_lib_core/driver.rb', line 9

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. False is by default and then “127.0.0.1:##port/wd/hub” is used.



27
28
29
 
# File 'lib/appium_lib_core/driver.rb', line 27

def custom_url
  @custom_url
end

#default_wait ⇒ Integer (readonly)

Default wait time for elements to appear Returns the default client side wait. 20 seconds is by default. Provide Appium::Drive like { appium_lib: { wait: 30 } }



39
40
41
 
# File 'lib/appium_lib_core/driver.rb', line 39

def default_wait
  @default_wait
end

#device ⇒ Symbol (readonly)

Device type to request from the appium server



17
18
19
 
# File 'lib/appium_lib_core/driver.rb', line 17

def device
  @device
end

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



64
65
66
 
# File 'lib/appium_lib_core/driver.rb', line 64

def driver
  @driver
end

#export_session ⇒ Boolean (readonly)

Export session id to textfile in /tmp for 3rd party tools. False bu default.



31
32
33
 
# File 'lib/appium_lib_core/driver.rb', line 31

def export_session
  @export_session
end

#export_session_path ⇒ String (readonly) 



33
34
35
 
# File 'lib/appium_lib_core/driver.rb', line 33

def export_session_path
  @export_session_path
end

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

Return http client called in start_driver()



13
14
15
 
# File 'lib/appium_lib_core/driver.rb', line 13

def http_client
  @http_client
end

#listener ⇒ Object (readonly)

instance of AbstractEventListener for logging support Nil by default



61
62
63
 
# File 'lib/appium_lib_core/driver.rb', line 61

def listener
  @listener
end

#port ⇒ Integer (readonly)

Appium’s server port. 4723 is by default. Provide Appium::Drive like { appium_lib: { port: 8080 } }



44
45
46
 
# File 'lib/appium_lib_core/driver.rb', line 44

def port
  @port
end

#wait_interval ⇒ Integer (readonly)

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



57
58
59
 
# File 'lib/appium_lib_core/driver.rb', line 57

def wait_interval
  @wait_interval
end

#wait_timeout ⇒ Integer (readonly)

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



51
52
53
 
# File 'lib/appium_lib_core/driver.rb', line 51

def wait_timeout
  @wait_timeout
end

Class Method Details

.for(target, opts = {}) ⇒ Driver

Creates a new global driver and extend particular methods to ‘target`

Examples:


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: {
           server_url: "http://custom-host:8080/wd/hub.com",
           export_session: false,
           port: 8080,
           wait: 0,
           wait_timeout: 20,
           wait_interval: 0.3,
           listener: nil,
         }
       }
@core = Appium::Core.for(self, opts) # create a core driver with `opts` and extend methods into `self`
@core.start_driver(server_url: server_url) # start driver

# Start iOS driver with .zip file over HTTP
opts = {
         caps: {
           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.com",
           export_session: false,
           port: 8080,
           wait: 0,
           wait_timeout: 20,
           wait_interval: 0.3,
           listener: nil,
         }
       }
@core = Appium::Core.for(self, opts)
@core.start_driver(server_url: server_url)



120
121
122
 
# File 'lib/appium_lib_core/driver.rb', line 120

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

Instance Method Details

#appium_server_version ⇒ Hash

Returns the server’s version info Returns blank hash for Selenium Grid since ‘remote_status` gets 500 error

Examples:


@core.appium_server_version
  {
      "build" => {
          "version" => "0.18.1",
          "revision" => "d242ebcfd92046a974347ccc3a28f0e898595198"
      }
  }


@core.appium_server_version #=> {}



281
282
283
284
285
286
287
 
# File 'lib/appium_lib_core/driver.rb', line 281

def appium_server_version
  @driver.remote_status
rescue Selenium::WebDriver::Error::ServerError => e
  raise ::Appium::Core::Error::ServerError unless e.message.include?('status code 500')
  # driver.remote_status returns 500 error for using selenium grid
  {}
end

#platform_version ⇒ Array<Integer>

Return the platform version as an array of integers

Examples:


@core.platform_version #=> [10,1,1]



296
297
298
299
 
# File 'lib/appium_lib_core/driver.rb', line 296

def platform_version
  p_version = @driver.capabilities['platformVersion']
  p_version.split('.').map(&:to_i)
end

#quit_driver ⇒ void

This method returns an undefined value.

Quits the driver

Examples:


@core.quit_driver



256
257
258
259
260
 
# File 'lib/appium_lib_core/driver.rb', line 256

def quit_driver
  @driver.quit
rescue # rubocop:disable Lint/RescueWithoutErrorClass
  nil
end

#screenshot(png_save_path) ⇒ File

Takes a png screenshot and saves to the target path.

Examples:


@core.screenshot '/tmp/hi.png' #=> nil
# same as `@driver.save_screenshot png_save_path`



311
312
313
314
 
# File 'lib/appium_lib_core/driver.rb', line 311

def screenshot(png_save_path)
  warn '[DEPRECATION] screenshot will be removed. Please use driver.save_screenshot instead.'
  @driver.save_screenshot png_save_path
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 = {
         caps: {
           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(self, opts) # create a core driver with `opts` and extend methods into `self`
@driver = @core.start_driver

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.



186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
 
# File 'lib/appium_lib_core/driver.rb', line 186

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

  create_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)

  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,
                                               desired_capabilities: @caps,
                                               url: server_url,
                                               listener: @listener)

    # export session
    write_session_id(@driver.session_id, @export_session_path) if @export_session
  rescue Errno::ECONNREFUSED
    raise "ERROR: Unable to connect to Appium. Is the server running on #{server_url}?"
  end

  # If "automationName" is set only server side, this method set "automationName" attribute into @automation_name.
  # Since @automation_name is set only client side before start_driver is called.
  set_automation_name_if_nil

  set_implicit_wait_by_default(@default_wait)

  @driver
end