Class: Applitools::Selenium::Driver

Inherits:
SimpleDelegator
  • Object
show all
Extended by:
Forwardable
Defined in:
lib/applitools/selenium/driver.rb

Direct Known Subclasses

Poltergeist::Driver

Constant Summary collapse

RIGHT_ANGLE = 
90
FINDERS =

Available finders

{
  class: 'class name',
  class_name: 'class name',
  css: 'css selector',
  id: 'id',
  link: 'link text',
  link_text: 'link text',
  name: 'name',
  partial_link_text: 'partial link text',
  tag_name: 'tag name',
  xpath: 'xpath'
}.freeze

Instance Attribute Summary collapse

Class Method Summary collapse

Instance Method Summary collapse

Constructor Details

#initialize(eyes, options) ⇒ Driver

Initializes a class instance.

If driver is not provided, Applitools::Selenium::Driver will raise an EyesError exception.

Parameters:

Options Hash (options):

  • :driver (Selenium::WebDriver::Driver) —

    The Selenium webdriver instance.

  • :is_mobile_device (Boolean) —

    Whether is a mobile device or not.



44
45
46
47
48
49
50
51
 
# File 'lib/applitools/selenium/driver.rb', line 44

def initialize(eyes, options)
  super(options[:driver])
  @is_mobile_device = options.fetch(:is_mobile_device, false)
  @eyes = eyes
  @frame_chain = Applitools::Selenium::FrameChain.new
  @browser = Applitools::Selenium::Browser.new(self, @eyes)
  Applitools::EyesLogger.warn '"screenshot_as" method not found!' unless driver.respond_to? :screenshot_as
end

Instance Attribute Details

#browser ⇒ Object (readonly)

Returns the value of attribute browser.



30
31
32
 
# File 'lib/applitools/selenium/driver.rb', line 30

def browser
  @browser
end

#rotation ⇒ Object

Returns the value of attribute rotation.



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

def rotation
  @rotation
end

Class Method Details

.normalize_image(driver, image, rotation) ⇒ Object 



306
307
308
309
 
# File 'lib/applitools/selenium/driver.rb', line 306

def normalize_image(driver, image, rotation)
  normalize_rotation(driver, image, rotation)
  normalize_width(driver, image)
end

.normalize_rotation(driver, image, rotation) ⇒ Object

Rotates the image as necessary. The rotation is either manually forced by passing a value in the rotation parameter, or automatically inferred if the rotation parameter is nil.

driver

Applitools::Selenium::Driver The driver which produced the screenshot.

image

ChunkyPNG::Canvas The image to normalize.

rotation

Integer|nil The degrees by which to rotate the image: positive values = clockwise rotation,

negative values = counter-clockwise, 0 = force no rotation, +nil+ = rotate automatically when needed.



318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
 
# File 'lib/applitools/selenium/driver.rb', line 318

def normalize_rotation(driver, image, rotation)
  return if rotation && rotation.zero?

  num_quadrants = 0
  if !rotation.nil?
    if (rotation % RIGHT_ANGLE).nonzero?
      raise Applitools::EyesError.new('Currently only quadrant rotations are supported. Current rotation: '\
      "#{rotation}")
    end
    num_quadrants = (rotation / RIGHT_ANGLE).to_i
  elsif rotation.nil? && driver.mobile_device? && driver.landscape_orientation? && image.height > image.width
    # For Android, we need to rotate images to the right, and for iOS to the left.
    num_quadrants = driver.android? ? 1 : -1
  end

  Applitools::Utils::ImageUtils.quadrant_rotate!(image, num_quadrants)
end

.normalize_width(driver, image) ⇒ Object 



336
337
338
339
340
341
 
# File 'lib/applitools/selenium/driver.rb', line 336

def normalize_width(driver, image)
  return if driver.mobile_device?

  normalization_factor = driver.browser.image_normalization_factor(image)
  Applitools::Utils::ImageUtils.scale!(image, normalization_factor) unless normalization_factor == 1
end

Instance Method Details

#android? ⇒ Boolean

Returns true if test is running on Android platform

Returns:

  • (Boolean) 


171
172
173
 
# File 'lib/applitools/selenium/driver.rb', line 171

def android?
  platform_name.to_s.upcase == ANDROID
end

#default_content_viewport_size(force_query = false) ⇒ Applitools::RectangleSize

Gets default_content_viewport_size.

Parameters:

  • force_query (Boolean) (defaults to: false) —

    if set to true, forces querying of viewport size from the browser, otherwise returns cached value.

Returns:

  • (Applitools::RectangleSize) —

    The default content viewport size.



199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
 
# File 'lib/applitools/selenium/driver.rb', line 199

def default_content_viewport_size(force_query = false)
  logger.info('default_content_viewport_size()')
  if cached_default_content_viewport_size && !force_query
    logger.info "Using cached viewport_size #{cached_default_content_viewport_size}"
    return cached_default_content_viewport_size
  end

  current_frames = frame_chain
  switch_to.default_content unless current_frames.empty?
  logger.info 'Extracting viewport size...'
  @cached_default_content_viewport_size = Applitools::Utils::EyesSeleniumUtils.extract_viewport_size(self)
  logger.info "Done! Viewport size is #{@cached_default_content_viewport_size}"

  switch_to.frames(frame_chain: current_frames) unless current_frames.empty?
  @cached_default_content_viewport_size
end

#execute_script(*args) ⇒ Object

Executes javascript in browser context.

Raises:

  • (Applitools::EyesDriverOperationException) 


56
57
58
 
# File 'lib/applitools/selenium/driver.rb', line 56

def execute_script(*args)
  raises_error { __getobj__.execute_script(*args) }
end

#find_element(how, what) ⇒ Applitools::Selenium::Element

Finds an element in a window.

Examples:

driver.find_element :css, '.some_class'
driver.find_element :css => '.some_class'
driver.find_element :id, 'element_id'

Parameters:

  • how (Symbol) —

    Defines the way that what parameter will be interpreted (finder). Can be one of: :class, :class_name, :css, :id, :link, :link_text, :name, :partial_link_text, :tag_name, :xpath

  • what (String) —

    The selector to find an element

Returns:

Raises:

  • (ArgumentError) —

    if invalid finder (how) is passed



138
139
140
141
142
143
144
145
 
# File 'lib/applitools/selenium/driver.rb', line 138

def find_element(*args)
  how, what = extract_args(args)

  # Make sure that "how" is a valid locator.
  raise ArgumentError, "cannot find element by: #{how.inspect}" unless FINDERS[how.to_sym]

  Applitools::Selenium::Element.new(self, driver.find_element(how, what))
end

#find_elements(how, what) ⇒ [Applitools::Selenium::Element]

Finds elements in a window.

Examples:

driver.find_elements :css, '.some_class'
driver.find_elements :css => '.some_class'
driver.find_elements :id, 'element_id'

Parameters:

  • how (Symbol) —

    Defines the way that what parameter will be interpreted (finder). Can be one of: :class, :class_name, :css, :id, :link, :link_text, :name, :partial_link_text, :tag_name, :xpath

  • what (String) —

    The selector to find an element

Returns:

Raises:

  • (ArgumentError) —

    if invalid finder (how) is passed



162
163
164
165
166
167
168
 
# File 'lib/applitools/selenium/driver.rb', line 162

def find_elements(*args)
  how, what = extract_args(args)

  raise ArgumentError, "cannot find element by: #{how.inspect}" unless FINDERS[how.to_sym]

  driver.find_elements(how, what).map { |el| Applitools::Selenium::Element.new(self, el) }
end

#frame_chain ⇒ Applitools::Selenium::FrameChain

Returns a copy of current frame chain. Frame chain stores information about all parent frames,

including scroll offset an frame coordinates.

Returns:

  • (Applitools::Selenium::FrameChain) —

    The frame chain.



184
185
186
 
# File 'lib/applitools/selenium/driver.rb', line 184

def frame_chain
  Applitools::Selenium::FrameChain.new other: @frame_chain
end

#frame_chain! ⇒ Object

Returns current frame chain. Frame chain stores information about all parent frames,

including scroll offset an frame coordinates



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

def frame_chain!
  @frame_chain
end

#hide_scrollbars ⇒ Object

Hide the main document’s scrollbars and returns the original overflow value.



91
92
93
 
# File 'lib/applitools/selenium/driver.rb', line 91

def hide_scrollbars
  @browser.hide_scrollbars
end

#ios? ⇒ Boolean

Returns true if test is running on iOS platform

Returns:

  • (Boolean) 


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

def ios?
  platform_name.to_s.upcase == IOS
end

#landscape_orientation? ⇒ Boolean

Returns true if the driver orientation is landscape.

Returns:

  • (Boolean) 


76
77
78
79
80
81
 
# File 'lib/applitools/selenium/driver.rb', line 76

def landscape_orientation?
  driver.orientation.to_s.upcase == LANDSCAPE
rescue NameError, Selenium::WebDriver::Error::WebDriverError, Selenium::WebDriver::Error::UnknownError
  Applitools::EyesLogger.debug 'driver has no "orientation" attribute. Assuming: portrait.'
  false
end

#mobile_device? ⇒ Boolean

Returns true if the platform running the test is a mobile platform. false otherwise.

Returns:

  • (Boolean) 


84
85
86
87
88
 
# File 'lib/applitools/selenium/driver.rb', line 84

def mobile_device?
  # We CAN'T check if the device is an +Appium::Driver+ since it is not a RemoteWebDriver. Because of that we use a
  # flag we got as an option in the constructor.
  @is_mobile_device
end

#overflow=(overflow) ⇒ Object Also known as: set_overflow

Set the overflow value for document element and return the original overflow value.



96
97
98
 
# File 'lib/applitools/selenium/driver.rb', line 96

def overflow=(overflow)
  @browser.set_overflow(overflow)
end

#platform_name ⇒ String

Returns the platform name.

Returns:

  • (String) —

    The platform name or nil if it is undefined.



63
64
65
 
# File 'lib/applitools/selenium/driver.rb', line 63

def platform_name
  capabilities['platformName']
end

#platform_version ⇒ String

Returns the platform version.

Returns:

  • (String) —

    The platform version or nil if it is undefined.



70
71
72
73
 
# File 'lib/applitools/selenium/driver.rb', line 70

def platform_version
  version = capabilities['platformVersion']
  version.nil? ? nil : version.to_s
end

#remote_web_driver ⇒ Object

Returns native driver

Returns:

  • Selenium::WebDriver



103
104
105
 
# File 'lib/applitools/selenium/driver.rb', line 103

def remote_web_driver
  driver
end

#screenshot_as(format) {|png_screenshot| ... } ⇒ String

Takes a screenshot.

Parameters:

  • format (:Symbol) —

    A format to store screenshot (one of :base64 or :png)

Yields:

  • (png_screenshot)

Returns:

  • (String) —

    A byte string, representing the screenshot



113
114
115
116
117
118
119
120
121
 
# File 'lib/applitools/selenium/driver.rb', line 113

def screenshot_as(format)
  raise "Invalid format (#{format}) passed! Available formats: :png, :base64" unless [:base64, :png].include? format
  png_screenshot = driver.screenshot_as(:png)
  yield png_screenshot if block_given?
  screenshot = Applitools::Screenshot.from_any_image(png_screenshot)
  self.class.normalize_rotation(self, screenshot, rotation)
  return Applitools::Utils::ImageUtils.base64_from_png_image(screenshot.restore) if format == :base64
  screenshot.to_blob
end

#switch_to ⇒ Object 



216
217
218
219
220
 
# File 'lib/applitools/selenium/driver.rb', line 216

def switch_to
  @switch_to ||= Applitools::Selenium::EyesTargetLocator.new(
    self, driver.switch_to, FrameChangeEventListener.new(self)
  )
end