eyes_selenium 2.8.0 → 2.9.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 8bda53f17529e689e03352afba4a1cbd1136842c
-  data.tar.gz: 236f00c59c65e2cfc9cf1a4dda3123e51d657f52
+  metadata.gz: 9ebc04f208fa510c98a5260826fb118d86291185
+  data.tar.gz: d5226529324ab94f2cca6a96b059851b11102384
 SHA512:
-  metadata.gz: ce4ad55156e7b1f223a7e8e52c2481baf429913e3094042c2c7d10e56ddddf85153c78c25aec9bf8de50a8021350c381834c2059196620ed515d2d44b0e83abf
-  data.tar.gz: 64332482dafa33a07c796242c3e8bc0ee3a09ef24e543bec555a16e8c4afc77b314605d5eca8973dc42c46ab1ca632f39cccf881e9c5ea628dbcaf47e6010d3e
+  metadata.gz: 6038fb5f5d17c9eb8a9d80d984c4160ddbac031e81d442e50cb8223124d45199192b56bcf80dedd5573d2d94c8157424a123bd7f32140165e6eea7ec69be87d8
+  data.tar.gz: df5fba1575662b834bf311a14a5f21a97a69612204e8957867c86cdf10edd0c6b989216ffb229a60d8b7c5e99737517f6ec8f8d8e67664fe033fbf86779b96ad

data/appium_eyes_example.rb

@@ -1,47 +1,57 @@
 require 'eyes_selenium'
+require 'openssl'
 
-Applitools::Eyes.api_key = 'YOUR_API_KEY'
-
-## 
+OpenSSL::SSL::VERIFY_PEER = OpenSSL::SSL::VERIFY_NONE
+##
 # Based on Appium example: https://github.com/appium/appium/blob/master/sample-code/examples/ruby/
 
-desired_capabilities = {
-    "device" => "Android",
-    "version" => "4.2",
-    "app" => "http://appium.s3.amazonaws.com/NotesList.apk",
-    "app-package" => "com.example.android.notepad",
-    "app-activity" => ".NotesList"
-}
 
-def create_note(text)
-	@driver.find_element(:name, "New note").click
-	@driver.find_element(:tag_name, "textfield").send_keys text
-	@eyes.check_window("Note: #{text}")
-	@driver.find_element(:name, "Save").click
+def android_caps
+	{
+			deviceName:          'Samsung Galaxy S4 Emulator',
+			platformName:        'Android',
+			platformVersion:     4.4,
+			app:                 '/Users/daniel/test/NotesList.apk',
+			appPackage:        	 'com.example.android.notepad',
+			appActivity:         '.NotesList',
+			# orientation:				 'landscape',
+			newCommandTimeout:	 300
+	}
+end
+def ios_caps
+	{
+			deviceName:          'iPhone 6',
+			platformName:        'ios',
+			platformVersion:     8.3,
+			app:                 '/Users/daniel/Library/Developer/Xcode/DerivedData/HelloXcode-cldusyhxlaclfkbirmthhbgpchqv/Build/Products/Debug-iphonesimulator/HelloXcode.app',
+			orientation:	 'landscape',
+			newCommandTimeout:	 300
+	}
 end
 
-def clear_note_by_text(text)
-	@driver.find_element(:name, "#{text}").click
-	@driver.find_element(:tag_name, "textfield").clear
-	@driver.find_element(:name, "Save").click
+def appium_opts
+	{
+			server_url: 'http://127.0.0.1:4723/wd/hub',
+	}
 end
 
-@eyes = Applitools::Eyes.new
+
+@eyes = Applitools::Eyes.new(server_url: 'https://localhost.applitools.com')
+@eyes.log_handler = Logger.new(STDOUT)
+@eyes.api_key = ENV['APPLITOOLS_API_KEY']
 begin
-	@driver = Selenium::WebDriver.for(:remote, :url => 'http://127.0.0.1:4723/wd/hub', :desired_capabilities => desired_capabilities)
-	@driver = @eyes.open(app_name: 'Selenium Israel', test_name: 'Appium Notepad', driver: @driver)
+	@driver = Appium::Driver.new({caps: android_caps, appium_lib: appium_opts})
+	# @driver = Appium::Driver.new({caps: ios_caps, appium_lib: appium_opts})
+	@driver.start_driver
+	# @driver.driver.rotate :landscape
+  puts "Screen size: #{@driver.driver.manage.window.size}"
+  puts "orientation: #{@driver.driver.orientation}"
+  puts @driver.caps
+	@eyes.open(app_name: 'Selenium Israel', test_name: 'Appium Notepad', driver: @driver)
 	@eyes.check_window("No notes")
 
-	create_note "I didn't expect a kind of Spanish Inquisition!"
-	create_note "Nobody expects the Spanish Inquisition!"
-	@eyes.check_window("Two notes")
-
-	clear_note_by_text "I didn't expect a kind of Spanish Inquisition!"
-	@eyes.check_window("One note")
-
 	@eyes.close
 ensure
-	sleep 5
 	@eyes.abort_if_not_closed
-	@driver.quit
+	@driver.driver_quit
 end

data/eyes_selenium.gemspec

@@ -18,8 +18,9 @@ Gem::Specification.new do |spec|
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
   spec.require_paths = ["lib"]
 
-  spec.add_dependency "selenium-webdriver", [">= 2.37"]
-  spec.add_dependency "httparty" 
+  spec.add_dependency "selenium-webdriver", [">= 2.45.0"]
+  spec.add_dependency "appium_lib", [">= 6.0.0"]
+  spec.add_dependency "httparty"
   spec.add_dependency "oily_png", [">= 1.1.0"] 
 
   spec.add_development_dependency "bundler", "~> 1.3"

data/lib/eyes_selenium/eyes/agent_connector.rb

@@ -35,10 +35,8 @@ class Applitools::AgentConnector
   def start_session(session_start_info)
    self.class.headers 'Content-Type' => 'application/json'
    res = self.class.post(@endpoint_uri, query: {apiKey: api_key}, body: { startInfo: session_start_info.to_hash }.to_json)
-   EyesLogger.debug "Got response! #{res}"
    status_code = res.response.message
    parsed_res = res.parsed_response
-   EyesLogger.debug "Parsed response #{parsed_res}"
    Applitools::Session.new(parsed_res['id'], parsed_res['url'], status_code == 'Created' )
   end
 

data/lib/eyes_selenium/eyes/driver.rb

@@ -1,7 +1,35 @@
 require 'socket'
 require 'selenium-webdriver'
+require 'appium_lib'
+
 class  Applitools::Driver
 
+  # Prepares an image for being sent to the Eyes server (e.g., handling rotation, scaling etc.).
+  #
+  # +driver+:: +Applitools::Driver+ The driver which produced the screenshot.
+  # +image+:: +ChunkyPNG::Canvas+ The image to normalize.
+  #
+  # Returns:
+  # +Integer+ The rotation of the screenshot we get from the webdriver (degrees).
+  def self.normalize_image!(driver, image, rotation=0)
+    EyesLogger.debug "#{__method__}()"
+    # Handling rotation
+    num_quadrants = 0
+    if rotation != 0
+      if rotation % 90 != 0
+        raise Applitools::EyesError.new "Currently only quadrant rotations are supported. Current rotation: #{rotation}"
+      end
+      num_quadrants = (rotation / 90).to_i
+    elsif 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
+    if num_quadrants != 0
+      Applitools::Utils::ImageUtils.quadrant_rotate!(image, num_quadrants)
+    end
+  end
+
+
   include Selenium::WebDriver::DriverExtensions::HasInputDevices
 
   attr_reader :remote_server_url, :remote_session_id, :screenshot_taker, :eyes
@@ -9,7 +37,7 @@ class  Applitools::Driver
 
   DRIVER_METHODS = [
     :title, :execute_script, :execute_async_script, :quit, :close, :get,
-    :post, :page_source, :window_handles, :window_handle, :switch_to, 
+    :post, :page_source, :window_handles, :window_handle, :switch_to,
     :navigate, :manage, :capabilities
   ]
 
@@ -17,8 +45,9 @@ class  Applitools::Driver
   #
   def initialize(eyes, options)
     @driver = options[:driver]
+    @is_mobile_device = options.fetch(:is_mobile_device, false)
     @eyes = eyes
-    # FIXME fix getting "remote address url" or remove "Screenshot taker" alltogether.
+    # FIXME fix getting "remote address url" or remove "Screenshot taker" altogether.
     # @remote_server_url = address_of_remote_server
     @remote_server_url = 'MOCK_URL'
     @remote_session_id = remote_session_id
@@ -29,7 +58,7 @@ class  Applitools::Driver
       else
         @screenshot_taker = Applitools::ScreenshotTaker.new(@remote_server_url, @remote_session_id)
       end
-    rescue => e 
+    rescue => e
       raise Applitools::EyesError.new "Can't take screenshots (#{e.message})"
     end
   end
@@ -40,14 +69,64 @@ class  Applitools::Driver
     end
   end
 
-  def screenshot_as(output_type)
-    return driver.screenshot_as(output_type) if !screenshot_taker
+  # Returns:
+  # +String+ The platform name or +nil+ if it is undefined.
+  def platform_name
+    driver.capabilities['platformName']
+  end
+
+  # Returns:
+  # +String+ The platform version or +nil+ if it is undefined.
+  def platform_version
+    version = driver.capabilities['platformVersion']
+    version.nil? ? nil : version.to_s
+  end
 
-    if output_type.downcase.to_sym != :base64
-      raise Applitools::EyesError.new("#{output_type} ouput type not supported for screenshot")
+  # Returns:
+  # +true+ if the driver is an Android driver.
+  def android?
+    platform_name.to_s.upcase == 'ANDROID'
+  end
+
+  # Returns:
+  # +true+ if the driver is an iOS driver.
+  def ios?
+    platform_name.to_s.upcase == 'IOS'
+  end
+
+  # Returns:
+  # +true+ if the driver orientation is landscape.
+  def landscape_orientation?
+    driver.orientation.to_s.upcase == 'LANDSCAPE'
+  end
+
+  # Returns:
+  # +true+ if the platform running the test is a mobile platform. +false+ otherwise.
+  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
+
+  def screenshot_as(output_type)
+    # TODO Check if screenshot_taker is still required
+    if screenshot_taker
+      if output_type.downcase.to_sym != :base64
+        raise Applitools::EyesError.new("#{output_type} output type not supported for screenshot")
+      end
+      screenshot64 = screenshot_taker.screenshot
+    else
+      screenshot = driver.screenshot_as(output_type)
+      # We only support additional processing of the output (such as rotation) for Base64 type of screenshots.
+      if output_type.downcase.to_sym != :base64
+        return screenshot
+      end
+      screenshot64 = screenshot
     end
-    screenshot_taker.screenshot
-  end 
+    screenshot = Applitools::Utils::ImageUtils.png_image_from_base64(screenshot64)
+    Applitools::Driver.normalize_image!(self, screenshot)
+    Applitools::Utils::ImageUtils.base64_from_png_image(screenshot)
+  end
 
   def mouse
     Applitools::EyesMouse.new(self, driver.mouse)
@@ -103,6 +182,7 @@ class  Applitools::Driver
     execute_script 'return navigator.userAgent'
   rescue => e
     EyesLogger.info "getUserAgent(): Failed to obtain user-agent string (#{e.message})"
+    return nil
   end
 
   private

data/lib/eyes_selenium/eyes/eyes.rb

@@ -91,6 +91,8 @@ class Applitools::Eyes
 
     if driver.is_a?(Selenium::WebDriver::Driver)
       @driver = Applitools::Driver.new(self, {driver: driver})
+    elsif driver.is_a?(Appium::Driver)
+      @driver = Applitools::Driver.new(self, {driver: driver.driver, is_mobile_device: true})
     else
       unless driver.is_a?(Applitools::Driver)
         raise Applitools::EyesError.new("Driver is not a Selenium::WebDriver::Driver (#{driver.class.name})")
@@ -250,32 +252,60 @@ class Applitools::Eyes
       params.fetch(:driver, nil)
     end
 
-    def mobile_os
-      caps = driver.capabilities
-      device = caps['device'] ? caps['device'] : caps[:platform]
-      if device && device!=''
-        major_version = caps[:version] ? caps[:version].split('.')[0] : ''
-        major_version = (major_version != nil) && (major_version != '') && (major_version != '0') ? major_version : nil
-        major_version.nil? ? ('%s' % device) : ('%s %s' % [device, major_version])
-      end
-    end
-
     def inferred_environment
       user_agent = driver.user_agent
       if user_agent
-        'useragent:' + user_agent
+        "useragent:#{user_agent}"
       else
-        mos = mobile_os
-        if not mos.nil?
-          'pos:;%s' % mos
+        nil
+      end
+    end
+
+    # Application environment is the environment (e.g., the host OS) which runs the application under test.
+    #
+    # Returns:
+    # +Applitools::Environment+ The application environment.
+    def app_environment
+      os = host_os
+      if os.nil?
+        EyesLogger.info 'No OS set, checking for mobile OS...'
+        if driver.mobile_device?
+          platform_name = nil
+          EyesLogger.info 'Mobile device detected! Checking device type..'
+          if driver.android?
+            EyesLogger.info 'Android detected.'
+            platform_name = 'Android'
+          elsif driver.ios?
+            EyesLogger.info 'iOS detected.'
+            platform_name = 'iOS'
+          else
+            EyesLogger.info 'Unknown device type.'
+          end
+          # We only set the OS if we identified the device type.
+          unless platform_name.nil?
+            platform_version = driver.platform_version
+            if platform_version.nil?
+              os = platform_name
+            else
+              # Notice that Ruby's +split+ function's +limit+ is the number of elements, whereas in Python it is the
+              # maximum splits performed (which is why they are set differently).
+              major_version = platform_version.split('.', 2)[0]
+              os = "#{platform_name} #{major_version}"
+            end
+            EyesLogger.info "Setting OS: #{os}"
+          end
+        else
+          EyesLogger.info 'No mobile OS detected.'
         end
       end
+      # Create and return the environment object.
+      Applitools::Environment.new(os, host_app, viewport_size, inferred_environment)
     end
 
     def start_session
       assign_viewport_size
       self.batch ||= Applitools::BatchInfo.new
-      app_env = Applitools::Environment.new(host_os, host_app, viewport_size, inferred_environment)
+      app_env = app_environment
       self.session_start_info = Applitools::StartInfo.new(
           full_agent_id, app_name, test_name, batch, baseline_name, app_env, match_level, nil, branch_name, parent_branch_name
       )

data/lib/eyes_selenium/eyes/match_window_task.rb

@@ -94,8 +94,9 @@ class Applitools::MatchWindowTask
       title = eyes.title
       EyesLogger.debug 'Getting screenshot...'
       screenshot64 = driver.screenshot_as(:base64)
+      # We need a reference to the raw bytes of the PNG, which is why we didn't
+      # use +Applitools::Utils::ImageUtils.image_from_base64+.
       EyesLogger.debug 'Done! Decoding base64...'
-      # 'encoded', as in 'png'.
       current_screenshot_encoded = Base64.decode64(screenshot64)
       EyesLogger.debug 'Done! Creating image object from PNG...'
       @current_screenshot = ChunkyPNG::Image.from_blob(current_screenshot_encoded)

data/lib/eyes_selenium/eyes/viewport_size.rb

@@ -48,11 +48,19 @@ class Applitools::ViewportSize
       width  = extract_viewport_width
       height = extract_viewport_height
     rescue => e
-      EyesLogger.info "getViewportSize(): failed to extract viewport size using Javascript: (#{e.message})"
+      EyesLogger.info "#{__method__}(): Failed to extract viewport size using Javascript: (#{e.message})"
     end
     if width.nil? || height.nil?
-      EyesLogger.info 'getViewportSize(): using window size as viewport size.'
+      EyesLogger.info "#{__method__}(): Using window size as viewport size."
       width, height = *browser_size.values
+      width, height = width.ceil, height.ceil
+      begin
+        if driver.landscape_orientation? && height > width
+          width, height = height, width
+        end
+      rescue NameError
+        # Ignored. This error will occur for web based drivers, since they don't have the "orientation" attribute.
+      end
     end
     Applitools::Dimension.new(width,height)
   end
@@ -64,7 +72,7 @@ class Applitools::ViewportSize
       self.dimension = Struct.new(:width, :height).new(dimension[:width], dimension[:height])
     elsif !dimension.respond_to?(:width) || !dimension.respond_to?(:height)
       raise ArgumentError, "expected #{dimension.inspect}:#{dimension.class}" +
-                           " to respond to #width and #height, or be a hash with these keys"
+                           ' to respond to #width and #height, or be a hash with these keys.'
     end
     self.browser_size = dimension
     verify_size(:browser_size)

data/lib/eyes_selenium/utils.rb

@@ -1,5 +1,6 @@
 module Applitools
   module Utils
     require 'eyes_selenium/utils/image_delta_compressor'
+    require 'eyes_selenium/utils/image_utils'
   end
 end

data/lib/eyes_selenium/utils/image_delta_compressor.rb

@@ -1,21 +1,21 @@
 =begin
 Applitools SDK class.
 
-Provides image compression based on image sequences and deflate
+Provides image compression based on image sequences and deflate.
 =end
 require 'oily_png'
-require 'base64'
 
 class Applitools::Utils::ImageDeltaCompressor
 
   # Compresses the target image based on the source image.
+  #
   # +target+:: +ChunkyPNG::Canvas+ The image to compress based on the source image.
   # +target_encoded+:: +Array+ The uncompressed image as binary string.
   # +source+:: +ChunkyPNG::Canvas+ The source image used as a base for compressing the target image.
   # +block_size+:: +Integer+ The width/height of each block.
-  # ++
+  #
   # Returns +String+ The binary result (either the compressed image, or the uncompressed image if the compression
-  # is greater in length)
+  # is greater in length).
   def self.compress_by_raw_blocks(target, target_encoded, source, block_size = 10)
     # If we can't compress for any reason, return the target image as is.
     if source.nil? || (source.height != target.height) || (source.width != target.width)
@@ -84,7 +84,7 @@ class Applitools::Utils::ImageDeltaCompressor
   ### PRIVATE
   private
 
-  @@PREAMBLE = "applitools"
+  @@PREAMBLE = 'applitools'
   @@FORMAT_RAW_BLOCKS = 3
 
   Dimension = Struct.new(:width, :height)

data/lib/eyes_selenium/utils/image_utils.rb

@@ -0,0 +1,76 @@
+=begin
+Applitools SDK class.
+
+Provides images manipulation functionality.
+=end
+require 'oily_png'
+require 'base64'
+
+module Applitools::Utils::ImageUtils
+
+  # Creates an image object from the PNG bytes.
+  # +png_bytes+:: +String+ A binary string of the PNG bytes of the image.
+  #
+  # Returns:
+  # +ChunkyPNG::Canvas+ An image object.
+  def self.png_image_from_bytes(png_bytes)
+    EyesLogger.debug "#{__method__}()"
+    image = ChunkyPNG::Image.from_blob(png_bytes)
+    EyesLogger.debug 'Done!'
+    return image
+  end
+    
+  # Creates an image instance from a base64 representation of its PNG encoding.
+  #
+  # +png_bytes64+:: +String+ The Base64 representation of a PNG image.
+  #
+  # Returns:
+  # +ChunkyPNG::Canvas+ An image object.
+  def self.png_image_from_base64(png_bytes64)
+    EyesLogger.debug "#{__method__}()"
+    png_bytes = Base64.decode64(png_bytes64)
+    EyesLogger.debug 'Done!'
+    return png_image_from_bytes(png_bytes)
+  end
+
+  # Get the raw PNG bytes of an image.
+  #
+  # +ChunkyPNG::Canvas+ The image object for which to get the PNG bytes.
+  #
+  # Returns:
+  # +String+ The PNG bytes of the image.
+  def self.bytes_from_png_image(image)
+    EyesLogger.debug "#{__method__}()"
+    png_bytes = image.to_blob
+    EyesLogger.debug 'Done!'
+    return png_bytes
+  end
+
+  # Get the Base64 representation of the raw PNG bytes of an image.
+  #
+  # +ChunkyPNG::Canvas+ The image object for which to get the PNG bytes.
+  #
+  # Returns:
+  # +String+ the Base64 representation of the raw PNG bytes of an image.
+  def self.base64_from_png_image(image)
+    EyesLogger.debug "#{__method__}()"
+    png_bytes = bytes_from_png_image(image)
+    EyesLogger.debug 'Encoding as base64...'
+    image64 = Base64.encode64(png_bytes)
+    EyesLogger.debug 'Done!'
+    return image64
+  end
+
+  # Rotates a matrix 90 deg clockwise or counter clockwise (depending whether num_quadrants is positive or negative,
+  # respectively).
+  #
+  # +image+:: +ChunkyPNG::Canvas+ The image to rotate.
+  # +num_quadrants+:: +Integer+ The number of rotations to perform. Positive values are used for clockwise rotation
+  #                   and negative values are used for counter-clockwise rotation.
+  #
+  def self.quadrant_rotate!(image, num_quadrants)
+    rotate_method = num_quadrants > 0 ? image.method('rotate_right!'.to_sym) : image.method('rotate_left!'.to_sym)
+    (0..(num_quadrants.abs-1)).each { rotate_method.call }
+    return image
+  end
+end

data/lib/eyes_selenium/version.rb

@@ -1,3 +1,3 @@
 module Applitools
-  VERSION = '2.8.0'
+  VERSION = '2.9.0'
 end

data/test_script.rb

@@ -14,8 +14,8 @@ begin
   eyes.test(app_name: 'Ruby SDK', test_name: 'Applitools website test', viewport_size: {width: 1024, height: 768}, driver: my_webdriver) do |driver|
     driver.get 'http://www.applitools.com'
     eyes.check_window('initial')
-    eyes.check_region(:css, 'li.pricing', 'Pricing button')
-    driver.find_element(:css, 'li.pricing a').click
+    eyes.check_region(:css, '.pricing', 'Pricing button')
+    driver.find_element(:css, '.pricing a').click
     eyes.check_window('pricing page')
   end
 ensure

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: eyes_selenium
 version: !ruby/object:Gem::Version
-  version: 2.8.0
+  version: 2.9.0
 platform: ruby
 authors:
 - Applitools team
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2015-03-27 00:00:00.000000000 Z
+date: 2015-04-23 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: selenium-webdriver
@@ -16,14 +16,28 @@ dependencies:
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.37'
+        version: 2.45.0
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - ">="
       - !ruby/object:Gem::Version
-        version: '2.37'
+        version: 2.45.0
+- !ruby/object:Gem::Dependency
+  name: appium_lib
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.0
 - !ruby/object:Gem::Dependency
   name: httparty
   requirement: !ruby/object:Gem::Requirement
@@ -164,6 +178,7 @@ files:
 - lib/eyes_selenium/eyes_logger.rb
 - lib/eyes_selenium/utils.rb
 - lib/eyes_selenium/utils/image_delta_compressor.rb
+- lib/eyes_selenium/utils/image_utils.rb
 - lib/eyes_selenium/version.rb
 - spec/find_spec.rb
 - test_script.rb