percy-appium-app 1.0.0 → 1.0.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: bdb1ff6892c099d297d97844d8dd24985e6be0361e78da39e274d844945ea869
-  data.tar.gz: ba73fd618e623111852a73900165ae0a9315fe5a8ebb768ca4d3eb8d86928db5
+  metadata.gz: 85a82be9fb7970cea7e6bfbf92341377a6cf4647f07ce09b3a3c4bb52ff25c11
+  data.tar.gz: 03be307ae51ff85c7853cf0284ded40713a91f8bbf4ce36f8f6b7ae69165d26e
 SHA512:
-  metadata.gz: e94a5a62b0a3c82630b63ba011a423978c924bfd31c2ad4de7ea92c1f1a5ce532530a5fcbd2de72f8c89908c404ef353b1ac3c415abb3d3806e6f5eaac125875
-  data.tar.gz: 68fbb5b42c1df5e5b8d39f75debe939d7e76408ff8370e7998f04f60adec7fe37a875504e13b93b9876a39595b67195299d4f4a348407e4064770a5a20e6610d
+  metadata.gz: 986183165da611f44bfd356562c084bdb942d7f87a2e38418746562c1d056894e8a373c4fe3e61a5aa2c3a44a48c9c42d7701e845b30eec7727fdafbe2a78faa
+  data.tar.gz: a21a495cb3cda29740602eb262e23ef67ed7c3fce651d191d1ec91c73bc56b0540f6c8cf55772816da6acdcadf1d07c6040e35a49f4fdfae95e1ca0016ccf2fe

data/.github/workflows/Semgrep.yml

@@ -27,8 +27,7 @@ jobs:
 
     container:
       # A Docker image with Semgrep installed. Do not change this.
-      image: returntocorp/semgrep
-
+      image: returntocorp/semgrep:1.166.0
     # Skip any PR created by dependabot to avoid permission issues:
     if: (github.actor != 'dependabot[bot]')
 

data/.github/workflows/release.yml

@@ -11,7 +11,7 @@ jobs:
         with:
           ruby-version: 2.6
           bundler-cache: true
-      - uses: actions/cache@v2
+      - uses: actions/cache@v3
         with:
           path: "./vendor/bundle"
           key: v1/${{ runner.os }}/ruby-2.6/${{ hashFiles('**/Gemfile.lock') }}

data/.github/workflows/test.yml

@@ -2,6 +2,7 @@ name: Test
 on:
   push:
     branches: [main]
+  pull_request:
   workflow_dispatch:
     inputs:
       branch:
@@ -12,6 +13,10 @@ jobs:
   test:
     name: Test
     strategy:
+      # Run every Ruby version to completion so one leg failing doesn't cancel
+      # the others. Ruby 3.0's appium_lib API drift is fixed by pinning
+      # appium_lib ~> 12.0 (see Gemfile), so all three legs are green.
+      fail-fast: false
       matrix:
         os: [ubuntu-latest]
         ruby: ['2.6', '2.7', '3.0']
@@ -31,10 +36,13 @@ jobs:
         with:
           ruby-version: ${{matrix.ruby}}
           bundler-cache: true
-      - uses: actions/cache@v2
+      - uses: actions/cache@v3
         with:
           path: "./vendor/bundle"
           key: v1/${{ runner.os }}/ruby-${{ matrix.ruby }}/${{ hashFiles('**/Gemfile.lock') }}
           restore-keys: v1/${{ runner.os }}/ruby-${{ matrix.ruby }}/
       - run: bundle install
-      - run: for file in specs/*.rb; do echo $file; bundle exec ruby $file; done
+      # Run each spec via the SimpleCov runner so per-process coverage is
+      # recorded and merged, then collate the merged result and enforce the gate.
+      - run: for file in specs/*.rb; do echo "$file"; bundle exec ruby specs/support/run_spec.rb "$file"; done
+      - run: bundle exec ruby specs/support/coverage_check.rb

data/.gitignore

@@ -1 +1,4 @@
 Gemfile.lock
+/vendor/
+/.bundle/
+coverage/

data/Gemfile

@@ -2,8 +2,12 @@
 
 source 'https://rubygems.org'
 
-gem 'appium_console'
-gem 'appium_lib', '>= 11.2.0'
+# Pin appium_lib to the 12.x line so all Ruby legs (2.6/2.7/3.0) resolve
+# appium_lib_core ~> 5.0, which still exposes Appium::Core::Base::SearchContext.
+# Unpinned, Ruby 3.0 resolved appium_lib 15 / appium_lib_core 9.x, which removed
+# that constant and broke the specs. appium_console 3.0.0 requires appium_lib = 12.0.0.
+gem 'appium_console', '~> 3.0'
+gem 'appium_lib', '~> 12.0'
 gem 'dotenv'
 gem 'minitest'
 gem 'rubocop', require: false
@@ -11,3 +15,4 @@ gem 'tempfile'
 gem 'webmock', '~> 3.18', '>= 3.18.1'
 gem 'webrick', '~> 1.3', '>= 1.3.1'
 gem 'rake', '~> 13.0'
+gem 'simplecov', require: false

data/percy/metadata/android_metadata.rb

@@ -9,14 +9,26 @@ module Percy
     def initialize(driver)
       super(driver)
       @_bars = nil
+      # Intentionally left as the original lookup: this path already degrades to
+      # driver.get_system_bars consistently across all appium_lib_core versions
+      # (the rect read yields a non-Hash, so the rect arithmetic in
+      # get_system_bars rescues to nil and falls back), so it is out of scope for
+      # the snake_case capability fix.
       @_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 }
+      # Use string keys to match the IosMetadata implementation and every
+      # consumer (generic_provider, app_automate, _get_tag), all of which read
+      # device_screen_size['width'] / ['height'].
+      device_screen_size_cap = get_capability_value('deviceScreenSize')
+      if device_screen_size_cap.nil?
+        size = driver.window_size
+        { 'width' => size.width.to_i, 'height' => size.height.to_i }
+      else
+        width, height = device_screen_size_cap.split('x')
+        { 'width' => width.to_i, 'height' => height.to_i }
+      end
     end
 
     def get_system_bars
@@ -68,11 +80,13 @@ module Percy
 
     def _device_name
       if @device_name.nil?
-        desired_caps = capabilities.to_json['desired'] || {}
-        device_name = desired_caps['deviceName']
+        # Normalize the nested desired-caps hash too, so its keys are matched
+        # regardless of casing (camelCase or appium_lib_core 13+ snake_case).
+        desired_caps = Percy::Metadata.normalize_hash(get_capability_value('desired'))
+        device_name = desired_caps['devicename']
         device = desired_caps['device']
         device_name ||= device
-        device_model = capabilities.to_json['deviceModel']
+        device_model = get_capability_value('deviceModel')
         @device_name = device_name || device_model
       end
       @device_name

data/percy/metadata/ios_metadata.rb

@@ -67,11 +67,7 @@ module Percy
     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 = get_capability_value('deviceName') if @device_name.nil?
       @device_name
     end
 

data/percy/metadata/metadata.rb

@@ -25,19 +25,54 @@ module Percy
       caps
     end
 
+    # Normalizes a capability key so lookups are resilient to the differences
+    # across appium_lib_core versions and protocols: camelCase ("platformName"),
+    # snake_case ("platform_name", as returned by appium_lib_core 13+),
+    # SCREAMING ("PLATFORM_NAME") and the W3C vendor prefix ("appium:platformName").
+    # Note: all colons are stripped, not just the vendor-prefix one. This is safe
+    # for every known Appium capability (e.g. "bstack:options" -> "bstackoptions").
+    def self.normalize_capability_key(key)
+      key.to_s.downcase.gsub(/[_:]/, '').sub(/\Aappium/, '')
+    end
+
+    # Builds a {normalized_key => value} view of a capabilities hash. First key
+    # wins, so a camelCase key (e.g. "platformName") takes precedence over a
+    # snake_case duplicate ("platform_name") when both are present, matching the
+    # previous MetadataResolver semantics.
+    def self.normalize_hash(hash)
+      normalized = {}
+      (hash || {}).each do |k, v|
+        nk = normalize_capability_key(k)
+        normalized[nk] = v unless normalized.key?(nk)
+      end
+      normalized
+    end
+
+    # Builds a {normalized_key => value} view of the driver's capabilities,
+    # coercing the appium_lib_core Capabilities object into a plain Hash first.
+    def self.normalized_capabilities(driver)
+      caps = driver.capabilities
+      caps = caps.as_json if caps.respond_to?(:as_json) && !caps.is_a?(Hash)
+      caps = caps.to_h if caps.respond_to?(:to_h) && !caps.is_a?(Hash)
+      normalize_hash(caps)
+    end
+
+    # Reads capabilities fresh on every call (no memoization) so callers always
+    # observe the driver's current capabilities, matching the prior behaviour.
+    def get_capability_value(name)
+      self.class.normalized_capabilities(driver)[self.class.normalize_capability_key(name)]
+    end
+
     def session_id
       driver.session_id
     end
 
     def os_name
-      capabilities['platformName']
+      get_capability_value('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 = get_capability_value('os_version') || get_capability_value('platformVersion') || ''
       os_version = @os_version || os_version
       begin
         os_version.to_f.to_i.to_s
@@ -51,7 +86,7 @@ module Percy
     end
 
     def get_orientation(**kwargs)
-      orientation = kwargs[:orientation] || capabilities['orientation'] || 'PORTRAIT'
+      orientation = kwargs[:orientation] || get_capability_value('orientation') || 'PORTRAIT'
       orientation = orientation.downcase
       orientation = orientation == 'auto' ? _orientation : orientation
       orientation.upcase

data/percy/metadata/metadata_resolver.rb

@@ -1,15 +1,17 @@
 # frozen_string_literal: true
 
 require_relative '../exceptions/exceptions'
+require_relative 'metadata'
 require_relative 'android_metadata'
 require_relative 'ios_metadata'
 
 module Percy
   class MetadataResolver
     def self.resolve(driver)
-      capabilities = driver.capabilities
-      capabilities = capabilities.as_json unless capabilities.is_a?(Hash)
-      platform_name = capabilities.fetch('platformName', '').downcase
+      # Resolve via normalized capability keys so platformName is found
+      # regardless of casing/prefix (camelCase, snake_case as in appium_lib_core
+      # 13+, or the appium: vendor prefix).
+      platform_name = Percy::Metadata.normalized_capabilities(driver)['platformname']&.to_s&.downcase
       case platform_name
       when 'android'
         Percy::AndroidMetadata.new(driver)

data/percy/providers/generic_provider.rb

@@ -137,7 +137,10 @@ module Percy
 
     def get_regions_by_xpath(elements_array, xpaths)
       xpaths.each do |xpath|
-        element = driver.find_element(Appium::Core::Base::SearchContext::FINDERS[:xpath], xpath)
+        # Pass the :xpath finder symbol directly. appium_lib_core 12.x removed
+        # Appium::Core::Base::SearchContext::FINDERS; the symbol form works
+        # across all supported appium_lib versions.
+        element = driver.find_element(:xpath, xpath)
         selector = "xpath: #{xpath}"
         if element
           region = get_region_object(selector, element)

data/percy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Percy
-  VERSION = '1.0.0'.freeze
+  VERSION = '1.0.1'.freeze
 end

data/specs/android_metadata.rb

@@ -29,7 +29,35 @@ class TestAndroidMetadata < Minitest::Test
     @mock_webdriver.expect(:capabilities, android_capabilities.merge('viewportRect' => viewport))
 
     assert(viewport, @android_metadata.viewport)
+    @mock_webdriver.verify
+  end
+
+  def test_device_screen_size_when_device_screen_size_is_nil
+    # Mock capabilities to return a hash without 'deviceScreenSize'
+    android_capabilities = get_android_capabilities
+    android_capabilities.delete('deviceScreenSize')
+    @mock_webdriver.expect(:capabilities, android_capabilities)
+
+    # Mock driver.window_size to return a double with width and height
+    mock_window_size = Minitest::Mock.new
+    mock_window_size.expect(:width, 1080)
+    mock_window_size.expect(:height, 1920)
+    @mock_webdriver.expect(:window_size, mock_window_size)
 
+    # Call the method and assert the result
+    result = @android_metadata.device_screen_size
+    assert_equal({ 'width' => 1080, 'height' => 1920 }, result)
+
+    # Verify mocks
+    mock_window_size.verify
+    @mock_webdriver.verify
+  end
+
+  def test_device_screen_size_when_device_screen_size_is_present
+    # 'deviceScreenSize' => '1080x2280' from get_android_capabilities; parsed into string-keyed hash
+    @mock_webdriver.expect(:capabilities, get_android_capabilities)
+    result = @android_metadata.device_screen_size
+    assert_equal({ 'width' => 1080, 'height' => 2280 }, result)
     @mock_webdriver.verify
   end
 
@@ -74,4 +102,28 @@ class TestAndroidMetadata < Minitest::Test
   def test_scale_factor
     assert_equal(1, @android_metadata.scale_factor)
   end
+
+  # Regression: appium_lib_core 13.x returns capabilities with snake_case keys
+  # (e.g. "device_screen_size" instead of "deviceScreenSize").
+  def test_device_screen_size_with_snake_case_caps
+    android_capabilities = get_android_capabilities
+    android_capabilities.delete('deviceScreenSize')
+    android_capabilities['device_screen_size'] = '1080x2280'
+    @mock_webdriver.expect(:capabilities, android_capabilities)
+
+    result = @android_metadata.device_screen_size
+    assert_equal({ 'width' => 1080, 'height' => 2280 }, result)
+    @mock_webdriver.verify
+  end
+
+  # Regression: the nested desired-caps hash is also normalized, so a
+  # snake_case "device_name" inside "desired" still resolves the device.
+  def test_device_name_with_snake_case_desired_caps
+    android_capabilities = get_android_capabilities
+    android_capabilities['desired'] = { 'device_name' => 'google pixel 4' }
+    @mock_webdriver.expect(:capabilities, android_capabilities)
+    @mock_webdriver.expect(:capabilities, android_capabilities)
+
+    assert_equal('google pixel 4', @android_metadata._device_name)
+  end
 end

data/specs/app_automate.rb

@@ -67,15 +67,170 @@ class TestAppAutomate < Minitest::Test
   end
 
   def test_execute_percy_screenshot_end
-    @app_automate.stub(:execute_percy_screenshot_begin, 'deviceName' => 'abc', 'osVersion' => '123') do
+    # Wrap the stub return hashes in explicit braces. Under Ruby 3 keyword
+    # argument separation, a bare trailing hash is otherwise parsed as keyword
+    # args to Minitest's stub, raising ArgumentError.
+    @app_automate.stub(:execute_percy_screenshot_begin, { 'deviceName' => 'abc', 'osVersion' => '123' }) do
       @app_automate.stub(:execute_percy_screenshot_end, nil) do
-        @app_automate.stub(:screenshot, 'link' => 'https://link') do
+        @app_automate.stub(:screenshot, { 'link' => 'https://link' }) do
           @app_automate.screenshot('name')
         end
       end
     end
   end
 
+  # Covers app_automate.rb lines 34-36: the rescue branch in #screenshot where the
+  # super call fails, #execute_percy_screenshot_end is invoked with 'failure', and the
+  # error is re-raised.
+  def test_screenshot_failure_calls_end_and_reraises
+    captured = {}
+    @app_automate.stub(:execute_percy_screenshot_begin, nil) do
+      # super (GenericProvider#screenshot) calls _get_tiles first; make it blow up.
+      @app_automate.stub(:_get_tiles, ->(**_kwargs) { raise StandardError, 'boom' }) do
+        @app_automate.stub(:execute_percy_screenshot_end,
+                           lambda do |name, url, status, sync = nil, message = nil|
+                             captured[:name] = name
+                             captured[:url] = url
+                             captured[:status] = status
+                             captured[:sync] = sync
+                             captured[:message] = message
+                           end) do
+          error = assert_raises(StandardError) { @app_automate.screenshot('failing-shot') }
+          assert_equal 'boom', error.message
+        end
+      end
+    end
+    assert_equal 'failing-shot', captured[:name]
+    assert_equal 'failure', captured[:status]
+    assert_equal 'boom', captured[:message]
+  end
+
+  # Covers app_automate.rb lines 24-26: when begin returns session details, the device
+  # metadata and debug url are set before the super screenshot (driven through the stubbed
+  # collaborators _get_tiles/_find_regions/_post_screenshots) succeeds.
+  def test_screenshot_success_sets_metadata_and_debug_url
+    session_details = {
+      'deviceName' => 'Google Pixel 7',
+      'osVersion' => '13.0',
+      'buildHash' => 'bhash',
+      'sessionHash' => 'shash'
+    }
+    post_response = { 'link' => 'https://link', 'data' => { 'ok' => true } }
+    @app_automate.stub(:execute_percy_screenshot_begin, session_details) do
+      @app_automate.stub(:_get_tiles, []) do
+        @app_automate.stub(:_get_tag, {}) do
+          @app_automate.stub(:_find_regions, []) do
+            @app_automate.stub(:_post_screenshots, post_response) do
+              @app_automate.stub(:execute_percy_screenshot_end, nil) do
+                result = @app_automate.screenshot('shot')
+                assert_equal({ 'ok' => true }, result)
+              end
+            end
+          end
+        end
+      end
+    end
+    assert_equal 'Google Pixel 7', @metadata.device_name
+    @mock_webdriver.expect(:capabilities, get_android_capabilities)
+    assert_equal '13', @metadata.os_version
+    assert_equal 'https://app-automate.browserstack.com/dashboard/v2/builds/bhash/sessions/shash',
+                 @app_automate.get_debug_url
+  end
+
+  # Covers app_automate.rb line 50: when PERCY_DISABLE_REMOTE_UPLOADS=true and the
+  # screenshot is NOT fullpage, _get_tiles falls back to the generic provider's _get_tiles
+  # (run for real against the mock webdriver), returning a single file-backed tile.
+  def test_get_tiles_disable_remote_uploads_non_fullpage_falls_back_to_super
+    ENV['PERCY_DISABLE_REMOTE_UPLOADS'] = 'true'
+    @mock_webdriver.expect(:screenshot_as, 'png-bytes', [:png])
+
+    tiles = nil
+    @metadata.stub(:status_bar_height, 100) do
+      @metadata.stub(:navigation_bar_height, 150) do
+        tiles = @app_automate._get_tiles(fullpage: false)
+      end
+    end
+
+    assert_equal 1, tiles.length
+    dict_tile = tiles[0].to_h
+    assert_includes dict_tile, 'filepath'
+    assert(File.exist?(dict_tile['filepath']))
+    assert_equal 100, dict_tile['status_bar_height']
+    assert_equal 150, dict_tile['nav_bar_height']
+    File.delete(tiles[0].filepath)
+  ensure
+    ENV.delete('PERCY_DISABLE_REMOTE_UPLOADS')
+  end
+
+  # Covers app_automate.rb lines 49 (fullpage warning puts) and the path that does NOT
+  # fall back to super (line 50 skipped because fullpage_ss is true): full remote
+  # screenshot orchestration continues with PERCY_DISABLE_REMOTE_UPLOADS=true.
+  def test_get_tiles_disable_remote_uploads_fullpage_warns_and_continues
+    ENV['PERCY_DISABLE_REMOTE_UPLOADS'] = 'true'
+    metadata_mock = Minitest::Mock.new
+    metadata_mock.expect(:device_screen_size, { 'width' => 1080, 'height' => 1920 })
+    metadata_mock.expect(:scale_factor, 1)
+    metadata_mock.expect(:status_bar_height, 100)
+    metadata_mock.expect(:navigation_bar_height, 150)
+
+    @metadata.stub(:device_screen_size, { 'width' => 1080, 'height' => 1920 }) do
+      @metadata.stub(:scale_factor, 1) do
+        @metadata.stub(:status_bar_height, 100) do
+          @metadata.stub(:navigation_bar_height, 150) do
+            @app_automate.stub(:execute_percy_screenshot, {
+                                 'result' => '[{"sha":"abc-1234","header_height":10,"footer_height":20}]'
+                               }) do
+              tiles = @app_automate._get_tiles(fullpage: true)
+              assert_equal 1, tiles.length
+              assert_equal 'abc', tiles[0].sha
+              assert_equal 100, tiles[0].status_bar_height
+              assert_equal 150, tiles[0].nav_bar_height
+              assert_equal 10, tiles[0].header_height
+              assert_equal 20, tiles[0].footer_height
+            end
+          end
+        end
+      end
+    end
+  ensure
+    ENV.delete('PERCY_DISABLE_REMOTE_UPLOADS')
+  end
+
+  # Covers app_automate.rb lines 100-104: the rescue in #execute_percy_screenshot_begin
+  # when execute_script raises; it logs and returns nil.
+  def test_execute_percy_screenshot_begin_handles_error_returns_nil
+    @mock_webdriver.expect(:execute_script, nil) do
+      raise StandardError, 'begin failed'
+    end
+    result = @app_automate.execute_percy_screenshot_begin('Screenshot 1')
+    assert_nil result
+    @mock_webdriver.verify
+  end
+
+  # Covers app_automate.rb lines 123-125: the rescue in #execute_percy_screenshot_end
+  # when execute_script raises; it logs and swallows the error (returns nil).
+  def test_execute_percy_screenshot_end_handles_error
+    @mock_webdriver.expect(:execute_script, nil) do
+      raise StandardError, 'end failed'
+    end
+    result = @app_automate.execute_percy_screenshot_end('Screenshot 1', 'snapshot-url', 'success')
+    assert_nil result
+    @mock_webdriver.verify
+  end
+
+  # Covers app_automate.rb lines 156-159: the rescue in #execute_percy_screenshot when
+  # execute_script raises; it logs and re-raises the error.
+  def test_execute_percy_screenshot_handles_error_reraises
+    @mock_webdriver.expect(:execute_script, nil) do
+      raise StandardError, 'screenshot failed'
+    end
+    error = assert_raises(StandardError) do
+      @app_automate.execute_percy_screenshot(1080, 'singlepage', 5)
+    end
+    assert_equal 'screenshot failed', error.message
+    @mock_webdriver.verify
+  end
+
   def test_get_tiles
     # Mocking Percy::Metadata's session_id method
     metadata_mock = Minitest::Mock.new

data/specs/app_percy.rb

@@ -136,6 +136,33 @@ class TestAppPercy < Minitest::Test
     end
   end
 
+  def test_throws_error_when_string_arg_type_mismatch
+    # Three constructions, each followed by a screenshot call with a
+    # non-String value for test_case / labels / th_test_case_execution_id.
+    3.times do
+      @mock_android_webdriver.expect(:is_a?, true, [Appium::Core::Base::Driver])
+    end
+    20.times do
+      @mock_android_webdriver.expect(:capabilities, get_android_capabilities)
+    end
+    3.times do
+      @mock_android_webdriver.expect(:instance_variable_get, @bridge, [:@bridge])
+      @http.expect(:instance_variable_get, @server_url, [:@server_url])
+      @bridge.expect(:instance_variable_get, @http, [:@http])
+      @server_url.expect(:to_s, 'https://hub-cloud.browserstack.com/wd/hub')
+    end
+
+    assert_raises(TypeError) do
+      Percy::AppPercy.new(@mock_android_webdriver).screenshot('screenshot 1', test_case: 123)
+    end
+    assert_raises(TypeError) do
+      Percy::AppPercy.new(@mock_android_webdriver).screenshot('screenshot 1', labels: 123)
+    end
+    assert_raises(TypeError) do
+      Percy::AppPercy.new(@mock_android_webdriver).screenshot('screenshot 1', th_test_case_execution_id: 123)
+    end
+  end
+
   private
 
   def disable_percy_options(mock_webdriver, num = 1)

data/specs/cli_wrapper.rb

@@ -16,6 +16,20 @@ def mock_poa_screenshot(fail: false)
     .to_return(body: "{\"success\": #{fail ? 'false, "error": "test"' : 'true'}}", status: (fail ? 500 : 200))
 end
 
+def mock_healthcheck_with_version(version)
+  stub_request(:get, 'http://localhost:5338/percy/healthcheck')
+    .to_return(
+      body: JSON.dump(success: true, build: { 'id' => '123', 'url' => 'dummy_url' }, type: 'automate'),
+      status: 200,
+      headers: { 'X-Percy-Core-Version' => version }
+    )
+end
+
+def mock_failed_event(fail: false)
+  stub_request(:post, 'http://localhost:5338/percy/events')
+    .to_return(body: "{\"success\": #{fail ? 'false, "error": "test"' : 'true'}}", status: (fail ? 500 : 200))
+end
+
 # Test suite for the Percy::CLIWrapper class
 class TestCLIWrapper < Minitest::Test
   def setup
@@ -143,4 +157,56 @@ class TestCLIWrapper < Minitest::Test
     assert_nil response['labels']
     assert_nil response['th_test_case_execution_id']
   end
+
+  # Targets cli_wrapper.rb lines 42-43: CLI minor version below 27 disables the SDK.
+  def test_percy_enabled_with_unsupported_minor_version
+    Percy::CLIWrapper.instance_variable_set(:@percy_enabled, nil)
+    mock_healthcheck_with_version('1.26.0')
+
+    assert_output(/Please upgrade to the latest CLI version/) do
+      assert_equal(false, Percy::CLIWrapper.percy_enabled?)
+    end
+  ensure
+    Percy::CLIWrapper.instance_variable_set(:@percy_enabled, nil)
+  end
+
+  # Targets cli_wrapper.rb lines 74, 79, 80, 89: post_failed_event success path
+  # builds the body, posts to /percy/events and parses the response.
+  def test_post_failed_event_success
+    mock_failed_event
+
+    result = Percy::CLIWrapper.post_failed_event('some error')
+
+    assert_equal({ 'success' => true }, result)
+  end
+
+  # Targets cli_wrapper.rb lines 83-86 (error branch) and 91-92 (rescue -> nil):
+  # a non-200 response raises CLIException internally which is rescued and nil returned.
+  def test_post_failed_event_handles_error_response
+    mock_failed_event(fail: true)
+
+    assert_nil Percy::CLIWrapper.post_failed_event('some error')
+  end
+
+  # Targets cli_wrapper.rb lines 91-92: a network/parse failure is rescued and nil returned.
+  def test_post_failed_event_rescues_exceptions
+    stub_request(:post, 'http://localhost:5338/percy/events').to_raise(StandardError.new('boom'))
+
+    assert_nil Percy::CLIWrapper.post_failed_event('some error')
+  end
+
+  # Targets cli_wrapper.rb lines 121-122: response is a 2xx success but not exactly 200,
+  # so the error message is extracted from the body and raised.
+  def test_post_poa_screenshots_raises_on_non_200_success
+    stub_request(:post, 'http://localhost:5338/percy/automateScreenshot')
+      .to_return(body: '{"success": false, "error": "poa error"}', status: 201)
+
+    error = assert_raises(CLIException) do
+      @cli_wrapper.post_poa_screenshots(
+        'snapshot', 'session-id', 'http://example.com',
+        { 'browser' => 'chrome' }, { 'platform' => 'Windows' }, {}
+      )
+    end
+    assert_equal('poa error', error.message)
+  end
 end

data/specs/driver_metadata.rb

@@ -5,6 +5,7 @@ require 'minitest/mock'
 require 'appium_lib'
 
 require_relative '../percy/metadata/driver_metadata'
+require_relative '../percy/lib/cache'
 
 # Test suite for the Percy::DriverMetadata class
 class TestDriverMetadata < Minitest::Test
@@ -66,4 +67,25 @@ class TestDriverMetadata < Minitest::Test
 
     assert(session_caps, @metadata.session_capabilities)
   end
+
+  def test_session_capabilities_caches_desired_capabilities_on_cache_miss
+    # Force a clean cache and use a unique session id so the cache lookup misses
+    # and the desired_capabilities branch (set_cache) is exercised.
+    Percy::Cache.force_cleanup_cache
+    session_id = 'session_id_session_caps_miss'
+    desired_caps = {
+      'platform' => 'chrome_android',
+      'browserVersion' => '115.0.1',
+      'session_name' => 'abc'
+    }
+    # session_id is read by session_capabilities, get_cache and set_cache.
+    3.times { @mock_webdriver.expect(:session_id, session_id) }
+    @mock_webdriver.expect(:desired_capabilities, desired_caps)
+
+    fetched = @metadata.session_capabilities
+    assert_equal(desired_caps, fetched)
+    # Now the value is cached: read straight back without another driver call.
+    @mock_webdriver.expect(:session_id, session_id)
+    assert_equal(desired_caps, @metadata.session_capabilities)
+  end
 end

data/specs/generic_providers.rb

@@ -13,6 +13,13 @@ class TestGenericProvider < Minitest::Test
   include Appium
   COMPARISON_RESPONSE = { 'comparison' => { 'id' => 123, 'url' => 'https://percy-build-url' } }.freeze
 
+  # Some tests below permanently redefine Percy::Metadata#session_id and
+  # Percy::AndroidMetadata#get_system_bars via class_eval to route them at fixed-count
+  # mocks. Snapshot the pristine implementations once so teardown can restore them and the
+  # suite stays order-independent (the original suite is flaky on certain seeds otherwise).
+  PRISTINE_SESSION_ID = Percy::Metadata.instance_method(:session_id)
+  PRISTINE_GET_SYSTEM_BARS = Percy::AndroidMetadata.instance_method(:get_system_bars)
+
   def setup
     @existing_dir = 'existing-dir'
     teardown
@@ -37,6 +44,20 @@ class TestGenericProvider < Minitest::Test
     if Dir.exist?(@existing_dir)
       FileUtils.remove_dir(@existing_dir, force: true)
     end
+    restore_pristine_metadata_methods
+  end
+
+  # Undo the class_eval monkey-patching done by tests like test_post_screenshots and
+  # test_non_app_automate so subsequent tests see the real implementations.
+  def restore_pristine_metadata_methods
+    pristine_session_id = PRISTINE_SESSION_ID
+    pristine_get_system_bars = PRISTINE_GET_SYSTEM_BARS
+    Percy::Metadata.class_eval do
+      define_method(:session_id) { |*args, &blk| pristine_session_id.bind(self).call(*args, &blk) }
+    end
+    Percy::AndroidMetadata.class_eval do
+      define_method(:get_system_bars) { |*args, &blk| pristine_get_system_bars.bind(self).call(*args, &blk) }
+    end
   end
 
   def test_get_dir_without_env_variable
@@ -133,6 +154,30 @@ class TestGenericProvider < Minitest::Test
     File.delete(tile.filepath)
   end
 
+  # Covers generic_provider.rb line 75: requesting a fullpage screenshot on the generic
+  # provider logs the "only supported on App Automate" fallback message and still produces
+  # a single page tile.
+  def test_get_tiles_fullpage_logs_fallback
+    status_bar_height = 11
+    nav_bar_height = 22
+    logged = []
+    @generic_provider.stub(:log, ->(message, **_kwargs) { logged << message }) do
+      tile = @generic_provider._get_tiles(
+        fullpage: true,
+        status_bar_height: status_bar_height,
+        nav_bar_height: nav_bar_height
+      )[0]
+      dict_tile = tile.to_h
+      assert_includes dict_tile, 'filepath'
+      assert(File.exist?(dict_tile['filepath']))
+      assert_equal status_bar_height, dict_tile['status_bar_height']
+      assert_equal nav_bar_height, dict_tile['nav_bar_height']
+      File.delete(tile.filepath)
+    end
+    assert_includes logged,
+                    'Full page screenshot is only supported on App Automate. Falling back to single page screenshot.'
+  end
+
   def test_get_tiles_kwargs
     status_bar_height = 135
     nav_bar_height = 246
@@ -256,7 +301,7 @@ class TestGenericProvider < Minitest::Test
     end
 
     @mock_webdriver.expect(:find_element, mock_element,
-                           [Appium::Core::Base::SearchContext::FINDERS[:xpath], '//path/to/element'])
+                           [:xpath, '//path/to/element'])
 
     elements_array = []
     xpaths = ['//path/to/element']
@@ -271,7 +316,7 @@ class TestGenericProvider < Minitest::Test
   end
 
   def test_get_regions_by_xpath_with_non_existing_element
-    @mock_webdriver.expect(:find_element, [Appium::Core::Base::SearchContext::FINDERS[:xpath], '//path/to/element']) do
+    @mock_webdriver.expect(:find_element, [:xpath, '//path/to/element']) do
       raise Appium::Core::Error::NoSuchElementError, 'Test error'
     end
     elements_array = []
@@ -309,7 +354,7 @@ class TestGenericProvider < Minitest::Test
       mock_element.expect(:size, Selenium::WebDriver::Dimension.new(100, 200))
     end
 
-    @mock_webdriver.expect(:find_element, [Appium::Core::Base::SearchContext::FINDERS[:accessibility_id], 'id1']) do
+    @mock_webdriver.expect(:find_element, [:accessibility_id, 'id1']) do
       raise Appium::Core::Error::NoSuchElementError, 'Test error'
     end
 

data/specs/ios_metadata.rb

@@ -69,6 +69,25 @@ class TestIOSMetadata < Minitest::Test
     assert_equal({ 'height' => 40 }, status_bar)
   end
 
+  def test_status_bar_from_viewport_top
+    # Seed a viewport with a non-zero `top` so status_bar uses the viewport
+    # height (view_port['top']) instead of the static config scale_factor path.
+    Percy::Cache.force_cleanup_cache
+    session_id = 'session_id_viewport_top'
+    Percy::Cache.set_cache(session_id, Percy::Cache::VIEWPORT, { 'top' => 30, 'height' => 200, 'width' => 100 })
+
+    # status_bar -> viewport reads the seeded cache (1 session_id call); since
+    # top != 0 it returns view_port['top'] directly.
+    @mock_webdriver.expect(:session_id, session_id)
+
+    status_bar = @ios_metadata.status_bar
+    assert_equal({ 'height' => 30 }, status_bar)
+  end
+
+  def test_navigation_bar
+    assert_equal({ 'height' => 0 }, @ios_metadata.navigation_bar)
+  end
+
   def test_scale_factor_present_in_devices_json
     @mock_webdriver.expect(:capabilities, { 'deviceName' => 'iPhone 6' })
     assert_equal(2, @ios_metadata.scale_factor)
@@ -86,4 +105,15 @@ class TestIOSMetadata < Minitest::Test
 
     assert_equal(2, @ios_metadata.scale_factor)
   end
+
+  def test_device_name_with_camel_case_caps
+    @mock_webdriver.expect(:capabilities, { 'deviceName' => 'iPhone 14' })
+    assert_equal('iPhone 14', @ios_metadata.device_name)
+  end
+
+  # Regression: appium_lib_core 13.x returns capabilities with snake_case keys.
+  def test_device_name_with_snake_case_caps
+    @mock_webdriver.expect(:capabilities, { 'device_name' => 'iPhone 14' })
+    assert_equal('iPhone 14', @ios_metadata.device_name)
+  end
 end

data/specs/metadata.rb

@@ -108,6 +108,16 @@ class TestMetadata < Minitest::Test
     assert_equal('10', os_ver)
   end
 
+  def test_metadata_os_version_returns_empty_string_on_error
+    # os_version that does not respond to #to_f (a Hash) makes the
+    # `os_version.to_f.to_i.to_s` conversion raise, exercising the rescue path.
+    capabilities = { 'os_version' => {} }
+    @mock_webdriver.expect(:capabilities, capabilities)
+    @mock_webdriver.expect(:capabilities, capabilities)
+    @mock_webdriver.expect(:capabilities, capabilities)
+    assert_equal('', @metadata.os_version)
+  end
+
   def test_metadata_value_from_devices_info_for_android
     android_device = 'google pixel 7'
     android_device_info = { '13' => { 'status_bar' => '118', 'nav_bar' => '63' } }
@@ -127,4 +137,26 @@ class TestMetadata < Minitest::Test
       @metadata.value_from_devices_info('scale_factor', ios_device)
     )
   end
+
+  def test_normalize_capability_key
+    # camelCase, snake_case, SCREAMING and the appium: vendor prefix all
+    # collapse to the same normalized key.
+    %w[platformName platform_name PLATFORM_NAME appium:platformName].each do |key|
+      assert_equal('platformname', Percy::Metadata.normalize_capability_key(key))
+    end
+    assert_equal('platformname', Percy::Metadata.normalize_capability_key(:platformName))
+  end
+
+  # Regression: appium_lib_core 13.x returns capabilities with snake_case keys.
+  def test_metadata_os_name_with_snake_case_caps
+    @mock_webdriver.expect(:capabilities, { 'platform_name' => 'Android' })
+    assert_equal('Android', @metadata.os_name)
+  end
+
+  def test_metadata_os_version_with_snake_case_platform_version
+    capabilities = { 'platform_version' => '14' }
+    @mock_webdriver.expect(:capabilities, capabilities)
+    @mock_webdriver.expect(:capabilities, capabilities)
+    assert_equal('14', @metadata.os_version)
+  end
 end

data/specs/metadata_resolver.rb

@@ -20,6 +20,24 @@ class MetadataResolverTestCase < Minitest::Test
     assert_instance_of(Percy::AndroidMetadata, resolved_metadata)
     @mock_webdriver.verify
   end
+  
+  def test_android_resolved_with_PLATFORM_NAME
+    @mock_webdriver.expect(:capabilities, { 'PLATFORM_NAME' => 'Android' })
+    @mock_webdriver.expect(:capabilities, { 'PLATFORM_NAME' => 'Android' })
+    resolved_metadata = Percy::MetadataResolver.resolve(@mock_webdriver)
+
+    assert_instance_of(Percy::AndroidMetadata, resolved_metadata)
+    @mock_webdriver.verify
+  end
+
+  def test_android_resolved_with_platform_name
+    @mock_webdriver.expect(:capabilities, { 'platform_name' => 'Android' })
+    @mock_webdriver.expect(:capabilities, { 'platform_name' => 'Android' })
+    resolved_metadata = Percy::MetadataResolver.resolve(@mock_webdriver)
+
+    assert_instance_of(Percy::AndroidMetadata, resolved_metadata)
+    @mock_webdriver.verify
+  end
 
   def test_ios_resolved
     @mock_webdriver.expect(:capabilities, { 'platformName' => 'iOS' })
@@ -29,6 +47,23 @@ class MetadataResolverTestCase < Minitest::Test
     @mock_webdriver.verify
   end
 
+  def test_ios_resolved_with_platform_name
+    @mock_webdriver.expect(:capabilities, { 'platform_name' => 'iOS' })
+    resolved_metadata = Percy::MetadataResolver.resolve(@mock_webdriver)
+
+    assert_instance_of(Percy::IOSMetadata, resolved_metadata)
+    @mock_webdriver.verify
+  end
+
+  def test_platformName_precedence_over_platform_name
+    @mock_webdriver.expect(:capabilities, { 'platformName' => 'Android', 'platform_name' => 'iOS' })
+    @mock_webdriver.expect(:capabilities, { 'platformName' => 'Android', 'platform_name' => 'iOS' })
+    resolved_metadata = Percy::MetadataResolver.resolve(@mock_webdriver)
+
+    assert_instance_of(Percy::AndroidMetadata, resolved_metadata)
+    @mock_webdriver.verify
+  end
+
   def test_unknown_platform_exception
     @mock_webdriver.expect(:capabilities, { 'platformName' => 'Something Random' })
 
@@ -38,4 +73,14 @@ class MetadataResolverTestCase < Minitest::Test
 
     @mock_webdriver.verify
   end
+
+  def test_unknown_platform_exception_with_platform_name
+    @mock_webdriver.expect(:capabilities, { 'platform_name' => 'Something Random' })
+
+    assert_raises(PlatformNotSupported) do
+      Percy::MetadataResolver.resolve(@mock_webdriver)
+    end
+
+    @mock_webdriver.verify
+  end
 end

data/specs/percy_automate.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'json'
+require 'webmock/minitest'
+require 'appium_lib'
+
+require_relative '../percy/lib/percy_automate'
+require_relative '../percy/lib/percy_options'
+require_relative '../percy/lib/cli_wrapper'
+require_relative 'mocks/mock_methods'
+
+def mock_poa_screenshot(fail: false)
+  stub_request(:post, 'http://localhost:5338/percy/automateScreenshot')
+    .to_return(body: "{\"success\": #{fail ? 'false, "error": "test"' : 'true'}}", status: (fail ? 500 : 200))
+end
+
+# Test suite for the Percy::PercyOnAutomate class
+class TestPercyOnAutomate < Minitest::Test
+  def setup
+    @mock_driver = Minitest::Mock.new
+    @bridge = Minitest::Mock.new
+    @http = Minitest::Mock.new
+    @server_url = Minitest::Mock.new
+    WebMock.enable!
+  end
+
+  def teardown
+    WebMock.disable!
+  end
+
+  # Targets percy_automate.rb line 17: an unsupported driver raises DriverNotSupported.
+  def test_initialize_raises_for_unsupported_driver
+    assert_raises(DriverNotSupported) do
+      Percy::PercyOnAutomate.new(Object.new)
+    end
+  end
+
+  # Targets percy_automate.rb lines 56-58: when the screenshot post fails, the error
+  # is rescued and logged rather than propagated.
+  def test_screenshot_rescues_and_logs_on_failure
+    mock_poa_screenshot(fail: true)
+
+    @mock_driver.expect(:is_a?, true, [Appium::Core::Base::Driver])
+    @mock_driver.expect(:capabilities, { 'percy:options' => { 'enabled' => true } })
+
+    5.times do
+      @mock_driver.expect(:session_id, 'Dummy_session_id')
+    end
+    @mock_driver.expect(:instance_variable_get, @bridge, [:@bridge])
+    @http.expect(:instance_variable_get, @server_url, [:@server_url])
+    @bridge.expect(:instance_variable_get, @http, [:@http])
+    @server_url.expect(:to_s, 'https://hub-cloud.browserstack.com/wd/hub')
+    @mock_driver.expect(:capabilities, { 'key' => 'value' })
+    @mock_driver.expect(:desired_capabilities, { 'key' => 'value' })
+
+    percy = Percy::PercyOnAutomate.new(@mock_driver)
+
+    result = nil
+    assert_output(/Could not take Screenshot 'Snapshot 1'/) do
+      result = percy.screenshot('Snapshot 1', options: {})
+    end
+    assert_nil result
+  end
+end

data/specs/screenshot.rb

@@ -383,7 +383,7 @@ class TestPercyScreenshot < Minitest::Test
                     })
     end
     driver.expect(:find_element, mock_element,
-                  [Appium::Core::Base::SearchContext::FINDERS[:xpath], '//path/to/element'])
+                  [:xpath, '//path/to/element'])
 
     percy_screenshot(driver, 'screenshot 1', ignore_regions_xpaths: xpaths)
 
@@ -416,4 +416,87 @@ class TestPercyScreenshot < Minitest::Test
     mock_healthcheck(type: 'automate')
     assert_raises(Exception) { percy_screenshot(@mock_webdriver) }
   end
+
+  def test_swallows_screenshot_error_when_ignore_errors_true
+    mock_healthcheck
+    # /percy/events is hit by post_failed_event in the rescue path.
+    stub_request(:post, 'http://localhost:5338/percy/events')
+      .to_return(status: 200, body: '{"success": true}')
+
+    # Force the AppPercy (non-automate) provider so the rescue path in
+    # percy-appium-app.rb is exercised. session_type is memoized across tests.
+    Percy::Environment.session_type = nil
+
+    # Android caps have percy:options.ignoreErrors => true, so the error is
+    # swallowed and percy_screenshot returns nil. A non-String name makes
+    # AppPercy#screenshot raise a TypeError after construction succeeds.
+    driver = build_app_driver(get_android_capabilities)
+
+    result = nil
+    assert_output(/Could not take screenshot/) do
+      result = percy_screenshot(driver, 12_345)
+    end
+    assert_nil result
+    assert(@requests.any? { |r| r.uri.path == '/percy/events' })
+  end
+
+  def test_reraises_screenshot_error_when_ignore_errors_false
+    mock_healthcheck
+    stub_request(:post, 'http://localhost:5338/percy/events')
+      .to_return(status: 200, body: '{"success": true}')
+
+    Percy::Environment.session_type = nil
+
+    # Build caps whose percy:options.ignoreErrors is false so the rescue path
+    # re-raises after posting the failed event.
+    caps = get_android_capabilities.dup
+    caps['percy:options'] = { 'enabled' => true, 'ignoreErrors' => false }
+    caps['percyOptions'] = { 'enabled' => true, 'ignoreErrors' => false }
+    driver = build_app_driver(caps)
+
+    assert_output(/Could not take screenshot/) do
+      assert_raises(TypeError) { percy_screenshot(driver, 12_345) }
+    end
+    assert(@requests.any? { |r| r.uri.path == '/percy/events' })
+  end
+
+  private
+
+  # Builds a Minitest::Mock driver that survives AppPercy construction
+  # (is_a? Appium driver, capabilities, remote_url) for the rescue-path tests.
+  def build_app_driver(caps)
+    driver = Minitest::Mock.new
+    bridge = Minitest::Mock.new
+    http = Minitest::Mock.new
+    server_url = Minitest::Mock.new
+
+    driver.expect(:is_a?, true, [Appium::Core::Base::Driver])
+    20.times { driver.expect(:capabilities, caps) }
+    3.times do
+      driver.expect(:instance_variable_get, bridge, [:@bridge])
+      http.expect(:instance_variable_get, server_url, [:@server_url])
+      bridge.expect(:instance_variable_get, http, [:@http])
+      server_url.expect(:to_s, 'https://hub-cloud.browserstack.com/wd/hub')
+    end
+    driver
+  end
+end
+
+# Test suite for the `hashed` helper in percy/common/common.rb
+class TestHashedHelper < Minitest::Test
+  # Stand-in object that responds to #as_json (core objects do not in this env).
+  class JsonableDouble
+    def as_json
+      { 'converted' => true }
+    end
+  end
+
+  def test_hashed_returns_hash_unchanged
+    input = { 'a' => 1 }
+    assert_same(input, hashed(input))
+  end
+
+  def test_hashed_converts_non_hash_via_as_json
+    assert_equal({ 'converted' => true }, hashed(JsonableDouble.new))
+  end
 end

data/specs/support/coverage_check.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+# Collates the per-process SimpleCov results written during the spec loop and
+# enforces the coverage gate. Run after all specs:
+#   bundle exec ruby specs/support/coverage_check.rb
+require 'simplecov'
+
+SimpleCov.collate Dir['coverage/.resultset.json'] do
+  add_filter '/specs/'
+  track_files 'percy/**/*.rb'
+  minimum_coverage line: 100
+end

data/specs/support/run_spec.rb

@@ -0,0 +1,9 @@
+# frozen_string_literal: true
+
+# Per-spec runner used by CI: `bundle exec ruby specs/support/run_spec.rb specs/<file>.rb`.
+# Requires spec_helper first (starting SimpleCov within the bundler context, which
+# a command-line `-r` flag cannot do reliably) and then loads the target spec.
+require_relative 'spec_helper'
+
+spec_file = ARGV[0] or abort('usage: run_spec.rb <spec_file>')
+load File.expand_path(spec_file)

data/specs/support/spec_helper.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+# Loaded (via `ruby -r ./specs/support/spec_helper`) before each spec so
+# SimpleCov can instrument the percy source. The suite runs one spec per
+# process, so each process records its own result under a unique command_name;
+# SimpleCov merges them into coverage/.resultset.json, and
+# specs/support/coverage_check.rb collates the merged result and enforces the gate.
+require 'simplecov'
+
+SimpleCov.start do
+  add_filter '/specs/'
+  track_files 'percy/**/*.rb'
+  command_name "specs:#{File.basename(ARGV.first || $PROGRAM_NAME)}"
+  merge_timeout 3600
+end

metadata

@@ -1,14 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: percy-appium-app
 version: !ruby/object:Gem::Version
-  version: 1.0.0
+  version: 1.0.1
 platform: ruby
 authors:
 - BroswerStack
-autorequire:
 bindir: bin
 cert_chain: []
-date: 2024-10-28 00:00:00.000000000 Z
+date: 1980-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: appium_lib
@@ -178,8 +177,12 @@ files:
 - specs/metadata.rb
 - specs/metadata_resolver.rb
 - specs/mocks/mock_methods.rb
+- specs/percy_automate.rb
 - specs/percy_options.rb
 - specs/screenshot.rb
+- specs/support/coverage_check.rb
+- specs/support/run_spec.rb
+- specs/support/spec_helper.rb
 - specs/tile.rb
 homepage: ''
 licenses:
@@ -187,7 +190,6 @@ licenses:
 metadata:
   bug_tracker_uri: https://github.com/percy/percy-appium-ruby/issues
   source_code_uri: https://github.com/percy/percy-appium-ruby
-post_install_message:
 rdoc_options: []
 require_paths:
 - percy
@@ -202,8 +204,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.1.4
-signing_key:
+rubygems_version: 3.6.9
 specification_version: 4
 summary: Percy visual testing for Ruby Appium Mobile Apps
 test_files: []