percy-appium-app 0.0.1

data/percy/lib/cache.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+class Cache
+  attr_reader :cache
+
+  @@cache = {}
+  CACHE_TIMEOUT = 5 * 60 # 5 * 60 seconds
+  TIMEOUT_KEY = 'last_access_time'
+
+  SESSION_DETAILS = 'session_details'
+  SYSTEM_BARS = 'system_bars'
+  WINDOW_SIZE = 'window_size'
+  VIEWPORT = 'viewport'
+  SESSION_CAPABILITIES = 'session_capabilities'
+  CAPABILITIES = 'capabilities'
+  COMMAND_EXECUTOR_URL = 'command_executor_url'
+
+  def cache
+    @@cache
+  end
+
+  def self.set_cache(session_id, property, value)
+    raise TypeError, 'Argument session_id should be a String' unless session_id.is_a?(String)
+    raise TypeError, 'Argument property should be a String' unless property.is_a?(String)
+
+    session = @@cache.fetch(session_id, {})
+    session[TIMEOUT_KEY] = Time.now.to_i
+    session[property] = value
+    @@cache[session_id] = session
+  end
+
+  def self.get_cache(session_id, property)
+    cleanup_cache
+
+    raise TypeError, 'Argument session_id should be a String' unless session_id.is_a?(String)
+    raise TypeError, 'Argument property should be a String' unless property.is_a?(String)
+
+    session = @@cache.fetch(session_id, {})
+    session.fetch(property, nil)
+  end
+
+  def self.cleanup_cache
+    now = Time.now.to_i
+    session_ids = []
+
+    @@cache.each do |session_id, session|
+      timestamp = session[TIMEOUT_KEY]
+      session_ids << session_id if now - timestamp >= CACHE_TIMEOUT
+    end
+
+    session_ids.each { |session_id| @@cache.delete(session_id) }
+  end
+end

data/percy/lib/cli_wrapper.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+require 'appium_lib/version'
+require_relative '../common/common'
+require_relative '../exceptions/exceptions'
+require_relative '../version'
+require_relative '../environment'
+
+CLIENT_INFO = "percy-appium-app/#{SDK_VERSION}"
+ENV_INFO = ["appium/#{Appium::VERSION}", "ruby/#{RUBY_VERSION}"].freeze
+
+PERCY_CLI_API = ENV['PERCY_CLI_API'] || 'http://localhost:5338'
+
+class CLIWrapper
+  def initialize; end
+
+  def self.percy_enabled?
+    @percy_enabled ||= begin
+      uri = URI("#{PERCY_CLI_API}/percy/healthcheck")
+      response = Net::HTTP.get_response(uri)
+
+      raise CLIException, response.body unless response.is_a?(Net::HTTPSuccess)
+
+      data = JSON.parse(response.body)
+      raise CLIException, data['error'] unless data['success']
+
+      Environment.percy_build_id = data['build']['id']
+      Environment.percy_build_url = data['build']['url']
+      Environment.session_type = data.fetch('type', nil)
+
+      version = response['x-percy-core-version']
+      if version.split('.')[0] != '1'
+        log("Unsupported Percy CLI version, #{version}")
+        return false
+      end
+      return true unless version.split('.')[1].to_i < 27
+
+      log('Please upgrade to the latest CLI version for using this SDK. Minimum compatible version is 1.27.0-beta.0')
+      return false
+    rescue StandardError => e
+      log('Percy is not running, disabling screenshots')
+      log(e, on_debug: true)
+      return false
+    end
+  end
+
+  def post_screenshots(name, tag, tiles, external_debug_url = nil, ignored_elements_data = nil,
+                       considered_elements_data = nil)
+    body = request_body(name, tag, tiles, external_debug_url, ignored_elements_data, considered_elements_data)
+    body['client_info'] = Environment.get_client_info
+    body['environment_info'] = Environment.get_env_info
+
+    uri = URI("#{PERCY_CLI_API}/percy/comparison")
+    http = Net::HTTP.new(uri.host, uri.port)
+    request = Net::HTTP::Post.new(uri, 'Content-Type' => 'application/json')
+    request.body = body.to_json
+
+    response = http.request(request)
+    data = JSON.parse(response.body)
+
+    raise CLIException, data.fetch('error', 'UnknownException') if response.code != '200'
+
+    data
+  end
+
+  def self.post_failed_event(error)
+    body = {
+      'clientInfo' => Environment.get_client_info(true),
+      'message' => error,
+      'errorKind' => 'sdk'
+    }
+
+    uri = URI("#{PERCY_CLI_API}/percy/events")
+    response = Net::HTTP.post(uri, body.to_json, 'Content-Type' => 'application/json')
+
+    # Handle errors
+    if response.code.to_i != 200
+      data = JSON.parse(response.body)
+      error_message = data.fetch('error', 'UnknownException')
+      raise CLIException, error_message
+    end
+
+    JSON.parse(response.body)
+  rescue StandardError => e
+    log(e.message, on_debug: true)
+    nil
+  end
+
+  def post_poa_screenshots(name, session_id, command_executor_url, capabilities, desired_capabilities, options = nil)
+    body = {
+      'sessionId' => session_id,
+      'commandExecutorUrl' => command_executor_url,
+      'capabilities' => capabilities.dup, # In Ruby, you can duplicate the hash with `dup`
+      'sessionCapabilities' => desired_capabilities.dup,
+      'snapshotName' => name,
+      'options' => options
+    }
+
+    body['client_info'] = Environment.get_client_info # Using class method without the underscore
+    body['environment_info'] = Environment.get_env_info
+
+    uri = URI("#{PERCY_CLI_API}/percy/automateScreenshot")
+    response = Net::HTTP.post(uri, body.to_json, 'Content-Type' => 'application/json')
+
+    # Handle errors
+    raise CLIException, "Error: #{response.message}" unless response.is_a?(Net::HTTPSuccess)
+
+    data = JSON.parse(response.body)
+
+    if response.code != '200'
+      error_message = data.fetch('error', 'UnknownException')
+      raise CLIException, error_message
+    end
+
+    data
+  end
+
+  def request_body(name, tag, tiles, external_debug_url, ignored_elements_data, considered_elements_data)
+    tiles = tiles.map(&:to_h)
+    {
+      'name' => name,
+      'tag' => tag,
+      'tiles' => tiles,
+      'ignored_elements_data' => ignored_elements_data,
+      'external_debug_url' => external_debug_url,
+      'considered_elements_data' => considered_elements_data
+    }
+  end
+end

data/percy/lib/ignore_region.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+
+# lib/ignore_region.rb
+require_relative 'region'
+
+class IgnoreRegion < Region
+  # Inherits everything from Region; no additional code needed unless you want to extend or modify the behavior
+end

data/percy/lib/percy_automate.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'appium_lib'
+require_relative '../exceptions/exceptions'
+require_relative '../metadata/driver_metadata'
+require_relative '../lib/cli_wrapper'
+
+IGNORE_ELEMENT_KEY = 'ignore_region_appium_elements'
+IGNORE_ELEMENT_ALT_KEY = 'ignoreRegionAppiumElements'
+CONSIDER_ELEMENT_KEY = 'consider_region_appium_elements'
+CONSIDER_ELEMENT_ALT_KEY = 'considerRegionAppiumElements'
+
+class PercyOnAutomate
+  def initialize(driver)
+    unless driver.is_a?(Appium::Core::Base::Driver)
+      raise DriverNotSupported, 'The provided driver instance is not supported.'
+    end
+
+    @driver = driver
+    @percy_options = PercyOptions.new(@driver.capabilities)
+  end
+
+  def screenshot(name, **options)
+    return nil unless @percy_options.enabled
+    raise TypeError, 'Argument name should be a string' unless name.is_a?(String)
+    raise KeyError, 'Please pass the last parameter as "options" key' unless options.key?(:options)
+
+    metadata = DriverMetadata.new(@driver)
+    options = options[:options] || {}
+
+    begin
+      options[IGNORE_ELEMENT_KEY] = options.delete(IGNORE_ELEMENT_ALT_KEY) if options.key?(IGNORE_ELEMENT_ALT_KEY)
+      options[CONSIDER_ELEMENT_KEY] = options.delete(CONSIDER_ELEMENT_ALT_KEY) if options.key?(CONSIDER_ELEMENT_ALT_KEY)
+
+      ignore_region_elements = options.fetch(IGNORE_ELEMENT_KEY, []).map(&:id)
+      consider_region_elements = options.fetch(CONSIDER_ELEMENT_KEY, []).map(&:id)
+      options.delete(IGNORE_ELEMENT_KEY)
+      options.delete(CONSIDER_ELEMENT_KEY)
+
+      additional_options = {
+        'ignore_region_elements' => ignore_region_elements,
+        'consider_region_elements' => consider_region_elements
+      }
+
+      CLIWrapper.new.post_poa_screenshots(
+        name,
+        metadata.session_id,
+        metadata.command_executor_url,
+        metadata.capabilities,
+        metadata.session_capabilities,
+        options.merge(additional_options)
+      )
+    rescue StandardError => e
+      log("Could not take Screenshot '#{name}'")
+      log(e.message, on_debug: true)
+    end
+    nil
+  end
+end

data/percy/lib/percy_options.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+class PercyOptions
+  IGNORE_ERRORS = 'ignoreErrors'
+  ENABLED = 'enabled'
+  PERCY_OPTIONS = ['percy:options', 'percyOptions'].freeze
+
+  def initialize(capabilities)
+    @capabilities = capabilities
+    @capabilities = @capabilities.as_json unless @capabilities.is_a?(Hash)
+    @percy_options = _parse_percy_options || {}
+  end
+
+  def _parse_percy_options
+    options = PERCY_OPTIONS.map { |key| @capabilities.fetch(key, nil) }
+    options = if options.any? { |element| !element.nil? }
+                options[0] || options[1]
+              else
+                {}
+              end
+
+    if options
+      options[IGNORE_ERRORS] = @capabilities.fetch("percy.#{IGNORE_ERRORS}", true) unless options.key?(IGNORE_ERRORS)
+      options[ENABLED] = @capabilities.fetch("percy.#{ENABLED}", true) unless options.key?(ENABLED)
+    end
+
+    options
+  end
+
+  def ignore_errors
+    @percy_options.fetch(IGNORE_ERRORS, true)
+  end
+
+  def enabled
+    @percy_options.fetch(ENABLED, true)
+  end
+end

data/percy/lib/region.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+# lib/region.rb
+class Region
+  attr_accessor :top, :bottom, :left, :right
+
+  def initialize(top, bottom, left, right)
+    raise ArgumentError, 'Only Positive integer is allowed!' if [top, bottom, left, right].any?(&:negative?)
+    raise ArgumentError, 'Invalid ignore region parameters!' if top >= bottom || left >= right
+
+    @top = top
+    @bottom = bottom
+    @left = left
+    @right = right
+  end
+
+  def valid?(screen_height, screen_width)
+    return false if @top >= screen_height || @bottom > screen_height || @left >= screen_width || @right > screen_width
+
+    true
+  end
+end

data/percy/lib/tile.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+class Tile
+  attr_reader :filepath, :status_bar_height, :nav_bar_height, :header_height, :footer_height, :fullscreen, :sha
+
+  def initialize(status_bar_height, nav_bar_height, header_height, footer_height, filepath: nil, sha: nil,
+                 fullscreen: false)
+    @filepath = filepath
+    @status_bar_height = status_bar_height
+    @nav_bar_height = nav_bar_height
+    @header_height = header_height
+    @footer_height = footer_height
+    @fullscreen = fullscreen
+    @sha = sha
+  end
+
+  def to_h
+    {
+      'filepath' => @filepath,
+      'status_bar_height' => @status_bar_height,
+      'nav_bar_height' => @nav_bar_height,
+      'header_height' => @header_height,
+      'footer_height' => @footer_height,
+      'fullscreen' => @fullscreen,
+      'sha' => @sha
+    }
+  end
+end

data/percy/metadata/android_metadata.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative 'metadata'
+require_relative '../lib/cache'
+
+class AndroidMetadata < Metadata
+  def initialize(driver)
+    super(driver)
+    @_bars = nil
+    @_viewport_rect = capabilities.to_json['viewportRect']
+  end
+
+  def device_screen_size
+    caps = capabilities
+    caps = caps.as_json unless caps.is_a?(Hash)
+    width, height = caps['deviceScreenSize'].split('x')
+    { 'width' => width.to_i, 'height' => height.to_i }
+  end
+
+  def get_system_bars
+    @_bars = Cache.get_cache(session_id, Cache::SYSTEM_BARS)
+    if @_viewport_rect
+      begin
+        @_bars = {
+          'statusBar' => { 'height' => @_viewport_rect['top'] },
+          'navigationBar' => {
+            'height' => device_screen_size['height'] - @_viewport_rect['height'] - @_viewport_rect['top']
+          }
+        }
+      rescue StandardError
+        @_bars = nil
+      end
+    end
+    if @_bars.nil?
+      @_bars = driver.get_system_bars
+      Cache.set_cache(session_id, Cache::SYSTEM_BARS, @_bars)
+    end
+    @_bars
+  end
+
+  def status_bar
+    status_bar = get_system_bars['statusBar']
+    if status_bar['height'] == 1
+      response = value_from_devices_info('status_bar', _device_name.upcase, os_version)
+      return { 'height' => response }
+    end
+    status_bar
+  end
+
+  def navigation_bar
+    navigation_bar = get_system_bars['navigationBar']
+    if navigation_bar['height'] == 1
+      response = { 'height' => value_from_devices_info('nav_bar', _device_name.upcase, os_version) }
+      return response
+    end
+    navigation_bar
+  end
+
+  def viewport
+    capabilities.to_json['viewportRect']
+  end
+
+  def scale_factor
+    1
+  end
+
+  def _device_name
+    if @device_name.nil?
+      desired_caps = capabilities.to_json['desired'] || {}
+      device_name = desired_caps['deviceName']
+      device = desired_caps['device']
+      device_name ||= device
+      device_model = capabilities.to_json['deviceModel']
+      @device_name = device_name || device_model
+    end
+    @device_name
+  end
+end

data/percy/metadata/driver_metadata.rb

@@ -0,0 +1,40 @@
+# frozen_string_literal: true
+
+require_relative '../lib/cache'
+
+class DriverMetadata
+  def initialize(driver)
+    @driver = driver
+  end
+
+  def session_id
+    @driver.session_id
+  end
+
+  def command_executor_url
+    url = Cache.get_cache(session_id, Cache::COMMAND_EXECUTOR_URL)
+    if url.nil?
+      url = @driver.instance_variable_get(:@bridge).instance_variable_get(:@http).instance_variable_get(:@server_url).to_s
+      Cache.set_cache(session_id, Cache::COMMAND_EXECUTOR_URL, url)
+    end
+    url
+  end
+
+  def capabilities
+    caps = Cache.get_cache(session_id, Cache::SESSION_CAPABILITIES)
+    if caps.nil?
+      caps = @driver.capabilities.dup # In Ruby, use dup to create a shallow copy of the hash
+      Cache.set_cache(session_id, Cache::SESSION_CAPABILITIES, caps)
+    end
+    caps
+  end
+
+  def session_capabilities
+    session_caps = Cache.get_cache(session_id, Cache::SESSION_CAPABILITIES)
+    if session_caps.nil?
+      session_caps = @driver.desired_capabilities.dup # Assuming there is a desired_capabilities method
+      Cache.set_cache(session_id, Cache::SESSION_CAPABILITIES, session_caps)
+    end
+    session_caps
+  end
+end

data/percy/metadata/ios_metadata.rb

@@ -0,0 +1,83 @@
+# frozen_string_literal: true
+
+require_relative 'metadata'
+require_relative '../lib/cache'
+
+class IOSMetadata < Metadata
+  attr_reader :_window_size
+
+  def initialize(driver)
+    super(driver)
+    @_viewport = {}
+    @_window_size = {}
+  end
+
+  def device_screen_size
+    vp = viewport
+    height = vp.fetch('top', 0) + vp.fetch('height', 0)
+    width = vp.fetch('width', 0)
+    if  height.zero? && width.zero?
+      scale_factor = value_from_devices_info('scale_factor', device_name)
+      height = get_window_size['height'] * scale_factor
+      width = get_window_size['width'] * scale_factor
+    end
+    { 'width' => width, 'height' => height }
+  end
+
+  def status_bar
+    height = 0
+    view_port = viewport
+    if view_port.fetch('top', 0) != 0
+      height = view_port['top']
+    else
+      scale_factor = value_from_devices_info('scale_factor', device_name)
+      status_bar_height = value_from_devices_info('status_bar', device_name)
+      height = status_bar_height.to_i * scale_factor.to_i
+    end
+    { 'height' => height }
+  end
+
+  def navigation_bar
+    { 'height' => 0 }
+  end
+
+  def get_window_size
+    @_window_size = Cache.get_cache(session_id, Cache::WINDOW_SIZE)
+    unless @_window_size
+      @_window_size = driver.get_window_size
+      Cache.set_cache(session_id, Cache::WINDOW_SIZE, @_window_size)
+    end
+    @_window_size
+  end
+
+  def viewport
+    @_viewport = Cache.get_cache(session_id, Cache::VIEWPORT)
+    if @_viewport.nil? || (@_viewport.is_a?(Hash) && @_viewport.empty?)
+      begin
+        @_viewport = execute_script('mobile: viewportRect')
+        Cache.set_cache(session_id, Cache::VIEWPORT, @_viewport)
+      rescue StandardError
+        log('Could not use viewportRect; using static config', on_debug: true)
+        # setting `viewport` as empty hash so that it's not nil anymore
+        Cache.set_cache(session_id, Cache::VIEWPORT, {})
+      end
+    end
+    @_viewport || { 'top' => 0, 'height' => 0, 'width' => 0 }
+  end
+
+  def device_name
+    if @device_name.nil?
+      caps = capabilities
+      caps = caps.as_json unless caps.is_a?(Hash)
+      @device_name = caps['deviceName']
+    end
+    @device_name
+  end
+
+  def scale_factor
+    scale_factor = value_from_devices_info('scale_factor', device_name)
+    return viewport['width'] / get_window_size['width'] if scale_factor.zero?
+
+    scale_factor
+  end
+end

data/percy/metadata/metadata.rb

@@ -0,0 +1,108 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'pathname'
+require_relative '../common/common'
+
+DEVICE_INFO_FILE_PATH = File.join(File.dirname(__FILE__), '..', 'configs', 'devices.json')
+DEVICE_INFO = JSON.parse(File.read(DEVICE_INFO_FILE_PATH))
+
+class Metadata
+  attr_reader :driver, :device_info
+  attr_accessor :device_name, :os_version, :device_info
+
+  def initialize(driver)
+    @driver = driver
+    @device_name = nil
+    @os_version = nil
+    @device_info = {}
+  end
+
+  def capabilities
+    caps = driver.capabilities
+    caps = caps.as_json unless caps.is_a?(Hash)
+    caps
+  end
+
+  def session_id
+    driver.session_id
+  end
+
+  def os_name
+    capabilities['platformName']
+  end
+
+  def os_version
+    caps = capabilities
+    caps = caps.as_json unless caps.is_a?(Hash)
+
+    os_version = caps['os_version'] || caps['platformVersion'] || ''
+    os_version = @os_version || os_version
+    begin
+      os_version.to_f.to_i.to_s
+    rescue StandardError
+      ''
+    end
+  end
+
+  def remote_url
+    driver.instance_variable_get(:@bridge).instance_variable_get(:@http).instance_variable_get(:@server_url).to_s
+  end
+
+  def get_orientation(**kwargs)
+    orientation = kwargs[:orientation] || capabilities['orientation'] || 'PORTRAIT'
+    orientation = orientation.downcase
+    orientation = orientation == 'auto' ? _orientation : orientation
+    orientation.upcase
+  end
+
+  def _orientation
+    driver.orientation.downcase
+  end
+
+  def device_screen_size
+    raise NotImplementedError
+  end
+
+  def _device_name
+    raise NotImplementedError
+  end
+
+  def status_bar
+    raise NotImplementedError
+  end
+
+  def status_bar_height
+    status_bar['height']
+  end
+
+  def navigation_bar
+    raise NotImplementedError
+  end
+
+  def navigation_bar_height
+    navigation_bar['height']
+  end
+
+  def viewport
+    raise NotImplementedError
+  end
+
+  def execute_script(command)
+    driver.execute_script(command)
+  end
+
+  def value_from_devices_info(key, device_name, os_version = nil)
+    device_info = get_device_info(device_name)
+    device_info = device_info[os_version] || {} if os_version
+    device_info[key].to_i || 0
+  end
+
+  def get_device_info(device_name)
+    return @device_info unless @device_info.empty?
+
+    @device_info = DEVICE_INFO[device_name.downcase] || {}
+    log("#{device_name.downcase} does not exist in config.") if @device_info.empty?
+    @device_info
+  end
+end

data/percy/metadata/metadata_resolver.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require_relative '../exceptions/exceptions'
+require_relative 'android_metadata'
+require_relative 'ios_metadata'
+
+class MetadataResolver
+  def self.resolve(driver)
+    capabilities = driver.capabilities
+    capabilities = capabilities.as_json unless capabilities.is_a?(Hash)
+    platform_name = capabilities.fetch('platformName', '').downcase
+    case platform_name
+    when 'android'
+      AndroidMetadata.new(driver)
+    when 'ios'
+      IOSMetadata.new(driver)
+    else
+      raise PlatformNotSupported
+    end
+  end
+end