percy-appium-app 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba54dc346521591705be68354e98b25018a98a1af988b9d05c7b3e6d6120b92f
-  data.tar.gz: 5fe4abc08f138a09c1f5c95f327f9bebb8c9d4f7899cd0ffbe233d2d95cb5e86
+  metadata.gz: 977a7a790f27d4907f95f7fe43de80d9b22e755320f159a491615a642a836a1d
+  data.tar.gz: e9eb127a4f084f12bffc64aa4263928bf0931352a5ff60d408f91f9e955b0204
 SHA512:
-  metadata.gz: 5434a1ce14329a48bf5411050de8c466ec40e77f3545fa159d566d077d28d88ce027a7ed87ea3a3cf0cc6a851350376a7218d93e6250de93cc165e5ba6179196
-  data.tar.gz: 2a8f9febe81d0490ed25d4f8bca3a2b24851a62d5c51ea33527629e72e810de9a4e0e94593f88727ffe42c25237c43aab785529d1e7bb4d24b5fd81488fedd8e
+  metadata.gz: e50bd2ad6f3fda122ef560e6e264bb2eb1bde38d48d6fcef7a3a53193d1af021d19bd60e04c8785e29cbeb0b5db4372b86ef43779d4716fb6c1006e60c5ab1ed
+  data.tar.gz: 1ce875348fe37874f4fa9d2089a7a9159aedd0977b7f9e5aa1c3042218b0778b098becdcc0fcd5aeb3767c3f0284276dbe170221d7b2beef797fe39a9ed32863

data/percy/environment.rb

@@ -4,22 +4,24 @@ require 'appium_lib'
 require 'appium_lib/version'
 require_relative 'version'
 
-class Environment
-  @percy_build_id = nil
-  @percy_build_url = nil
-  @session_type = nil
+module Percy
+  class Percy::Environment
+    @percy_build_id = nil
+    @percy_build_url = nil
+    @session_type = nil
 
-  class << self
-    attr_accessor :percy_build_id, :percy_build_url, :session_type
+    class << self
+      attr_accessor :percy_build_id, :percy_build_url, :session_type
 
-    def get_client_info(flag = false)
-      sdk_version = SDK_VERSION
-      flag ? "percy-appium-app-ruby/#{sdk_version}" : "percy-appium-app/#{sdk_version}"
-    end
+      def get_client_info(flag = false)
+        sdk_version = Percy::VERSION
+        flag ? "percy-appium-app-ruby/#{sdk_version}" : "percy-appium-app/#{sdk_version}"
+      end
 
-    def get_env_info
-      appium_version = Appium::VERSION # This assumes the 'appium_lib' gem provides a VERSION constant.
-      ["appium/#{appium_version}", "ruby/#{RUBY_VERSION}"]
+      def get_env_info
+        appium_version = Appium::VERSION # This assumes the 'appium_lib' gem provides a VERSION constant.
+        ["appium/#{appium_version}", "ruby/#{RUBY_VERSION}"]
+      end
     end
   end
 end

data/percy/exceptions/exceptions.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 class BaseException < StandardError; end
 
 class UnsupportedDevice < BaseException; end

data/percy/lib/app_percy.rb

@@ -6,50 +6,52 @@ require_relative 'percy_options'
 require_relative '../providers/provider_resolver'
 require_relative '../metadata/metadata_resolver'
 
-class AppPercy
-  attr_accessor :metadata, :provider
+module Percy
+  class AppPercy
+    attr_accessor :metadata, :provider
 
-  def initialize(driver)
-    raise DriverNotSupported unless driver.is_a?(Appium::Core::Base::Driver)
+    def initialize(driver)
+      raise DriverNotSupported unless driver.is_a?(Appium::Core::Base::Driver)
 
-    @driver = driver
-    @metadata = MetadataResolver.resolve(@driver)
-    @provider = ProviderResolver.resolve(@driver)
-    @percy_options = PercyOptions.new(@metadata.capabilities)
-  end
+      @driver = driver
+      @metadata = Percy::MetadataResolver.resolve(@driver)
+      @provider = Percy::ProviderResolver.resolve(@driver)
+      @percy_options = Percy::PercyOptions.new(@metadata.capabilities)
+    end
 
-  def screenshot(name, **kwargs)
-    return nil unless @percy_options.enabled
+    def screenshot(name, **kwargs)
+      return nil unless @percy_options.enabled
 
-    raise TypeError, 'Argument name should be a String' unless name.is_a?(String)
+      raise TypeError, 'Argument name should be a String' unless name.is_a?(String)
 
-    device_name = kwargs[:device_name]
-    raise TypeError, 'Argument device_name should be a String' if device_name && !device_name.is_a?(String)
+      device_name = kwargs[:device_name]
+      raise TypeError, 'Argument device_name should be a String' if device_name && !device_name.is_a?(String)
 
-    fullscreen = kwargs[:full_screen]
-    if fullscreen && !fullscreen.is_a?(TrueClass) && !fullscreen.is_a?(FalseClass)
-      raise TypeError,
-            'Argument fullscreen should be a Boolean'
-    end
+      fullscreen = kwargs[:full_screen]
+      if fullscreen && !fullscreen.is_a?(TrueClass) && !fullscreen.is_a?(FalseClass)
+        raise TypeError,
+              'Argument fullscreen should be a Boolean'
+      end
 
-    status_bar_height = kwargs[:status_bar_height]
-    if status_bar_height && !status_bar_height.is_a?(Integer)
-      raise TypeError,
-            'Argument status_bar_height should be an Integer'
-    end
+      status_bar_height = kwargs[:status_bar_height]
+      if status_bar_height && !status_bar_height.is_a?(Integer)
+        raise TypeError,
+              'Argument status_bar_height should be an Integer'
+      end
+
+      nav_bar_height = kwargs[:nav_bar_height]
+      raise TypeError, 'Argument nav_bar_height should be an Integer' if nav_bar_height && !nav_bar_height.is_a?(Integer)
 
-    nav_bar_height = kwargs[:nav_bar_height]
-    raise TypeError, 'Argument nav_bar_height should be an Integer' if nav_bar_height && !nav_bar_height.is_a?(Integer)
+      orientation = kwargs[:orientation]
+      if orientation && !orientation.is_a?(String)
+        raise TypeError,
+              'Argument orientation should be a String and portrait/landscape'
+      end
 
-    orientation = kwargs[:orientation]
-    if orientation && !orientation.is_a?(String)
-      raise TypeError,
-            'Argument orientation should be a String and portrait/landscape'
+      @provider.screenshot(name, **kwargs)
+      nil
     end
 
-    @provider.screenshot(name, **kwargs)
-    nil
+    attr_reader :percy_options
   end
-
-  attr_reader :percy_options
 end

data/percy/lib/cache.rb

@@ -1,53 +1,54 @@
 # frozen_string_literal: true
+module Percy
+  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
 
-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)
 
-  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
 
-    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
 
-  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)
 
-    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
 
-    session = @@cache.fetch(session_id, {})
-    session.fetch(property, nil)
-  end
+    def self.cleanup_cache
+      now = Time.now.to_i
+      session_ids = []
 
-  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
 
-    @@cache.each do |session_id, session|
-      timestamp = session[TIMEOUT_KEY]
-      session_ids << session_id if now - timestamp >= CACHE_TIMEOUT
+      session_ids.each { |session_id| @@cache.delete(session_id) }
     end
-
-    session_ids.each { |session_id| @@cache.delete(session_id) }
   end
 end

data/percy/lib/cli_wrapper.rb

@@ -9,124 +9,126 @@ 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
+module Percy
+  CLIENT_INFO = "percy-appium-app/#{VERSION}"
+  ENV_INFO = ["appium/#{Appium::VERSION}", "ruby/#{RUBY_VERSION}"].freeze
 
-PERCY_CLI_API = ENV['PERCY_CLI_API'] || 'http://localhost:5338'
+  PERCY_CLI_API = ENV['PERCY_CLI_API'] || 'http://localhost:5338'
 
-class CLIWrapper
-  def initialize; end
+  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)
+    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)
+        raise CLIException, response.body unless response.is_a?(Net::HTTPSuccess)
 
-      data = JSON.parse(response.body)
-      raise CLIException, data['error'] unless data['success']
+        data = JSON.parse(response.body)
+        raise CLIException, data['error'] unless data['success']
+
+        Percy::Environment.percy_build_id = data['build']['id']
+        Percy::Environment.percy_build_url = data['build']['url']
+        Percy::Environment.session_type = data.fetch('type', nil)
 
-      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
 
-      version = response['x-percy-core-version']
-      if version.split('.')[0] != '1'
-        log("Unsupported Percy CLI version, #{version}")
+        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
-      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
+    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'] = Percy::Environment.get_client_info
+      body['environment_info'] = Percy::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
+      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)
+      response = http.request(request)
+      data = JSON.parse(response.body)
 
-    raise CLIException, data.fetch('error', 'UnknownException') if response.code != '200'
+      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'
-    }
+      data
+    end
 
-    uri = URI("#{PERCY_CLI_API}/percy/events")
-    response = Net::HTTP.post(uri, body.to_json, 'Content-Type' => 'application/json')
+    def self.post_failed_event(error)
+      body = {
+        'clientInfo' => Percy::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
 
-    # Handle errors
-    if response.code.to_i != 200
-      data = JSON.parse(response.body)
-      error_message = data.fetch('error', 'UnknownException')
-      raise CLIException, error_message
+      JSON.parse(response.body)
+    rescue StandardError => e
+      log(e.message, on_debug: true)
+      nil
     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
+      }
 
-  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'] = Percy::Environment.get_client_info # Using class method without the underscore
+      body['environment_info'] = Percy::Environment.get_env_info
 
-    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')
 
-    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)
 
-    # Handle errors
-    raise CLIException, "Error: #{response.message}" unless response.is_a?(Net::HTTPSuccess)
+      data = JSON.parse(response.body)
 
-    data = JSON.parse(response.body)
+      if response.code != '200'
+        error_message = data.fetch('error', 'UnknownException')
+        raise CLIException, error_message
+      end
 
-    if response.code != '200'
-      error_message = data.fetch('error', 'UnknownException')
-      raise CLIException, error_message
+      data
     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
-    }
+    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
 end

data/percy/lib/ignore_region.rb

@@ -2,7 +2,8 @@
 
 # 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
+module Percy
+  class IgnoreRegion < Percy::Region
+    # Inherits everything from Percy::Region; no additional code needed unless you want to extend or modify the behavior
+  end
 end

data/percy/lib/percy_automate.rb

@@ -10,50 +10,52 @@ 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.'
+module Percy
+  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 = Percy::PercyOptions.new(@driver.capabilities)
     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)
+    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 = Percy::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
+        }
+
+        Percy::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
-    nil
   end
 end

data/percy/lib/percy_options.rb

@@ -1,37 +1,39 @@
 # frozen_string_literal: true
 
-class PercyOptions
-  IGNORE_ERRORS = 'ignoreErrors'
-  ENABLED = 'enabled'
-  PERCY_OPTIONS = ['percy:options', 'percyOptions'].freeze
+module Percy
+  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 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
+    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
+      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
+      options
+    end
 
-  def ignore_errors
-    @percy_options.fetch(IGNORE_ERRORS, true)
-  end
+    def ignore_errors
+      @percy_options.fetch(IGNORE_ERRORS, true)
+    end
 
-  def enabled
-    @percy_options.fetch(ENABLED, true)
+    def enabled
+      @percy_options.fetch(ENABLED, true)
+    end
   end
-end
+end