percy-appium-app 0.0.1 → 0.0.2.pre.beta.0

data/percy/providers/provider_resolver.rb

@@ -5,13 +5,15 @@ require_relative '../metadata/metadata_resolver'
 require_relative 'app_automate'
 require_relative 'generic_provider'
 
-class ProviderResolver
-  def self.resolve(driver)
-    metadata = MetadataResolver.resolve(driver)
-    providers = [AppAutomate, GenericProvider]
-    providers.each do |provider|
-      return provider.new(driver, metadata) if provider.supports(metadata.remote_url)
+module Percy
+  class ProviderResolver
+    def self.resolve(driver)
+      metadata = Percy::MetadataResolver.resolve(driver)
+      providers = [Percy::AppAutomate, Percy::GenericProvider]
+      providers.each do |provider|
+        return provider.new(driver, metadata) if provider.supports(metadata.remote_url)
+      end
+      raise UnknownProvider
     end
-    raise UnknownProvider
   end
 end

data/percy/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Percy
-  VERSION = '0.0.1'.freeze
+  VERSION = '0.0.2-beta.0'.freeze
 end

data/percy-appium-app.gemspec

@@ -26,6 +26,7 @@ Gem::Specification.new do |spec|
   spec.require_paths = ['percy']
 
   spec.add_runtime_dependency 'appium_lib', '~> 12.0'
+  spec.add_runtime_dependency 'dotenv', '~> 2.8'
 
   spec.add_development_dependency 'bundler', '~> 2.4'
   spec.add_development_dependency 'minitest', '~> 5.20'

data/specs/android_metadata.rb

@@ -1,19 +1,17 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/MethodLength
-
 require 'minitest/autorun'
 require 'minitest/mock'
 require 'appium_lib'
 require_relative 'mocks/mock_methods'
 require_relative '../percy/metadata/android_metadata'
 
-# Test suite for the AndroidMetadata class
+# Test suite for the Percy::AndroidMetadata class
 class TestAndroidMetadata < Minitest::Test
   def setup
     @mock_webdriver = Minitest::Mock.new
     @mock_webdriver.expect(:capabilities, get_android_capabilities)
-    @android_metadata = AndroidMetadata.new(@mock_webdriver)
+    @android_metadata = Percy::AndroidMetadata.new(@mock_webdriver)
   end
 
   def test_android_execute_script

data/specs/app_automate.rb

@@ -1,23 +1,20 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/MethodLength
-# rubocop:disable Metrics/AbcSize
-
 require 'minitest/autorun'
 require 'minitest/mock'
 require_relative '../percy/providers/app_automate'
 require_relative '../percy/metadata/android_metadata'
 require_relative 'mocks/mock_methods'
 
-# Test suite for the AppAutomate class
+# Test suite for the Percy::AppAutomate class
 class TestAppAutomate < Minitest::Test
   COMPARISON_RESPONSE = { 'success' => true, 'link' => 'https://snapshots-url' }.freeze
 
   def setup
     @mock_webdriver = Minitest::Mock.new
     @mock_webdriver.expect(:capabilities, get_android_capabilities)
-    @metadata = AndroidMetadata.new(@mock_webdriver)
-    @app_automate = AppAutomate.new(@mock_webdriver, @metadata)
+    @metadata = Percy::AndroidMetadata.new(@mock_webdriver)
+    @app_automate = Percy::AppAutomate.new(@mock_webdriver, @metadata)
   end
 
   def test_app_automate_get_debug_url
@@ -28,18 +25,18 @@ class TestAppAutomate < Minitest::Test
   end
 
   def test_app_automate_supports_with_correct_url
-    app_automate_session = AppAutomate.supports('https://hub-cloud.browserstack.com/wd/hub')
+    app_automate_session = Percy::AppAutomate.supports('https://hub-cloud.browserstack.com/wd/hub')
     assert_equal true, app_automate_session
   end
 
   def test_app_automate_supports_with_incorrect_url
-    app_automate_session = AppAutomate.supports('https://hub-cloud.generic.com/wd/hub')
+    app_automate_session = Percy::AppAutomate.supports('https://hub-cloud.generic.com/wd/hub')
     assert_equal false, app_automate_session
   end
 
   def test_app_automate_supports_with_AA_DOMAIN
     ENV['AA_DOMAIN'] = 'bsstag'
-    app_automate_session = AppAutomate.supports('bsstag.com')
+    app_automate_session = Percy::AppAutomate.supports('bsstag.com')
     assert_equal true, app_automate_session
     ENV['AA_DOMAIN'] = nil
   end
@@ -80,23 +77,23 @@ class TestAppAutomate < Minitest::Test
   end
 
   def test_get_tiles
-    # Mocking Metadata's session_id method
+    # Mocking Percy::Metadata's session_id method
     metadata_mock = Minitest::Mock.new
     metadata_mock.expect(:session_id, 'session_id_123')
 
-    # Mocking AndroidMetadata's methods
+    # Mocking Percy::AndroidMetadata's methods
     android_metadata_mock = Minitest::Mock.new
     android_metadata_mock.expect(:device_screen_size, { 'width' => 1080, 'height' => 1920 })
     android_metadata_mock.expect(:navigation_bar_height, 150)
     android_metadata_mock.expect(:status_bar_height, 100)
 
-    Metadata.class_eval do
+    Percy::Metadata.class_eval do
       define_method(:session_id) do
         metadata_mock.session_id
       end
     end
 
-    AndroidMetadata.class_eval do
+    Percy::AndroidMetadata.class_eval do
       define_method(:device_screen_size) do
         android_metadata_mock.device_screen_size
       end

data/specs/app_percy.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/MethodLength
-
 require 'minitest/autorun'
 # require 'webmock/minitest'
 require_relative '../percy/lib/app_percy'
@@ -12,7 +10,7 @@ require_relative '../percy/providers/generic_provider'
 require_relative '../percy/lib/cli_wrapper'
 require_relative 'mocks/mock_methods'
 
-# Test suite for the AppPercy class
+# Test suite for the Percy::AppPercy class
 class TestAppPercy < Minitest::Test
   COMPARISON_RESPONSE = { 'link' => 'https://snapshot_url', 'success' => true }.freeze
 
@@ -38,10 +36,10 @@ class TestAppPercy < Minitest::Test
 
     ENV['PERCY_DISABLE_REMOTE_UPLOADS'] = 'true'
 
-    app_percy = AppPercy.new(@mock_android_webdriver)
+    app_percy = Percy::AppPercy.new(@mock_android_webdriver)
 
-    assert_instance_of(AndroidMetadata, app_percy.metadata)
-    assert_instance_of(AppAutomate, app_percy.provider)
+    assert_instance_of(Percy::AndroidMetadata, app_percy.metadata)
+    assert_instance_of(Percy::AppAutomate, app_percy.provider)
   end
 
   def test_android_on_non_app_automate
@@ -57,9 +55,9 @@ class TestAppPercy < Minitest::Test
     5.times do
       @mock_android_webdriver.expect(:capabilities, get_android_capabilities)
     end
-    app_percy = AppPercy.new(@mock_android_webdriver)
-    assert_instance_of(AndroidMetadata, app_percy.metadata)
-    assert_instance_of(GenericProvider, app_percy.provider)
+    app_percy = Percy::AppPercy.new(@mock_android_webdriver)
+    assert_instance_of(Percy::AndroidMetadata, app_percy.metadata)
+    assert_instance_of(Percy::GenericProvider, app_percy.provider)
   end
 
   def test_ios_on_app_automate
@@ -68,9 +66,9 @@ class TestAppPercy < Minitest::Test
     5.times do
       @mock_ios_webdriver.expect(:capabilities, get_ios_capabilities)
     end
-    app_percy = AppPercy.new(@mock_ios_webdriver)
-    assert_instance_of(IOSMetadata, app_percy.metadata)
-    assert_instance_of(AppAutomate, app_percy.provider)
+    app_percy = Percy::AppPercy.new(@mock_ios_webdriver)
+    assert_instance_of(Percy::IOSMetadata, app_percy.metadata)
+    assert_instance_of(Percy::AppAutomate, app_percy.provider)
   end
 
   def test_ios_on_non_app_automate
@@ -84,16 +82,16 @@ class TestAppPercy < Minitest::Test
     3.times do
       @mock_ios_webdriver.expect(:capabilities, get_ios_capabilities)
     end
-    app_percy = AppPercy.new(@mock_ios_webdriver)
-    assert_instance_of(IOSMetadata, app_percy.metadata)
-    assert_instance_of(GenericProvider, app_percy.provider)
+    app_percy = Percy::AppPercy.new(@mock_ios_webdriver)
+    assert_instance_of(Percy::IOSMetadata, app_percy.metadata)
+    assert_instance_of(Percy::GenericProvider, app_percy.provider)
   end
 
   def test_screenshot_with_percy_options_disabled
     disable_percy_options(@mock_android_webdriver, num = 5)
     make_mock_driver_appium(@mock_android_webdriver)
     mock_driver_remote_url(@mock_android_webdriver, 'some-other-url', num = 2)
-    app_percy = AppPercy.new(@mock_android_webdriver)
+    app_percy = Percy::AppPercy.new(@mock_android_webdriver)
     assert_nil app_percy.screenshot('screenshot 1')
   end
 
@@ -101,7 +99,7 @@ class TestAppPercy < Minitest::Test
     disable_percy_options(@mock_android_webdriver, num = 5)
     make_mock_driver_appium(@mock_android_webdriver)
     mock_driver_remote_url(@mock_android_webdriver, 'some-other-url', num = 2)
-    app_percy = AppPercy.new(@mock_android_webdriver)
+    app_percy = Percy::AppPercy.new(@mock_android_webdriver)
     assert_nil app_percy.screenshot('screenshot 1')
   end
 
@@ -112,7 +110,7 @@ class TestAppPercy < Minitest::Test
                                    })
 
     assert_raises(Exception) do
-      AppPercy.screenshot(@mock_android_webdriver, 'screenshot')
+      Percy::AppPercy.screenshot(@mock_android_webdriver, 'screenshot')
     end
   end
 
@@ -125,16 +123,16 @@ class TestAppPercy < Minitest::Test
       @mock_android_webdriver.expect(:capabilities, caps)
     end
 
-    GenericProvider.stub(:supports, false) do
+    Percy::GenericProvider.stub(:supports, false) do
       assert_raises(UnknownProvider) do
-        _provider = AppPercy.new(@mock_android_webdriver).provider
+        _provider = Percy::AppPercy.new(@mock_android_webdriver).provider
       end
     end
   end
 
   def test_invalid_driver
     assert_raises(DriverNotSupported) do
-      AppPercy.new(Object.new)
+      Percy::AppPercy.new(Object.new)
     end
   end
 
@@ -169,7 +167,7 @@ class TestAppPercy < Minitest::Test
                           })
 
     assert_raises(Exception) do
-      AppPercy.screenshot(mock_webdriver, 'screenshot')
+      Percy::AppPercy.screenshot(mock_webdriver, 'screenshot')
     end
   end
 end

data/specs/cache.rb

@@ -5,52 +5,52 @@ require 'minitest/mock'
 require 'time'
 require_relative '../percy/lib/cache'
 
-# Test suite for the Cache class
+# Test suite for the Percy::Cache class
 class TestCache < Minitest::Test
   def setup
-    @cache = Cache.new
+    @cache = Percy::Cache.new
     @session_id = 'session_id_123'
     @prop = 'window_size'
     @value = { 'top' => 'Top Value' }
-    Cache.set_cache(@session_id, @prop, @value)
+    Percy::Cache.set_cache(@session_id, @prop, @value)
   end
 
   def test_set_cache
-    assert_raises(Exception) { Cache.set_cache(123, 123, 123) }
-    assert_raises(Exception) { Cache.set_cache(@session_id, 123, 123) }
+    assert_raises(Exception) { Percy::Cache.set_cache(123, 123, 123) }
+    assert_raises(Exception) { Percy::Cache.set_cache(@session_id, 123, 123) }
 
     assert_includes @cache.cache, @session_id
     assert_equal @cache.cache[@session_id][@prop], @value
   end
 
   def test_get_cache_invalid_args
-    assert_raises(Exception) { Cache.get_cache(123, 123) }
-    assert_raises(Exception) { Cache.get_cache(@session_id, 123) }
+    assert_raises(Exception) { Percy::Cache.get_cache(123, 123) }
+    assert_raises(Exception) { Percy::Cache.get_cache(@session_id, 123) }
   end
 
   def test_get_cache_success
     mock_cleanup_cache = Minitest::Mock.new
     mock_cleanup_cache.expect(:call, nil)
 
-    Cache.stub(:cleanup_cache, -> { mock_cleanup_cache.call }) do
-      window_size = Cache.get_cache(@session_id, @prop)
+    Percy::Cache.stub(:cleanup_cache, -> { mock_cleanup_cache.call }) do
+      window_size = Percy::Cache.get_cache(@session_id, @prop)
       assert_equal @value, window_size
       mock_cleanup_cache.verify
     end
   end
 
   def test_cleanup_cache
-    previous_value = Cache::CACHE_TIMEOUT
-    Cache.send(:remove_const, :CACHE_TIMEOUT)
-    Cache.const_set(:CACHE_TIMEOUT, 1)
+    previous_value = Percy::Cache::CACHE_TIMEOUT
+    Percy::Cache.send(:remove_const, :CACHE_TIMEOUT)
+    Percy::Cache.const_set(:CACHE_TIMEOUT, 1)
 
-    cache_timeout = Cache::CACHE_TIMEOUT
+    cache_timeout = Percy::Cache::CACHE_TIMEOUT
     sleep(cache_timeout + 1)
     assert_includes @cache.cache, @session_id
-    Cache.cleanup_cache
+    Percy::Cache.cleanup_cache
     refute_includes @cache.cache, @session_id
 
-    Cache.send(:remove_const, :CACHE_TIMEOUT)
-    Cache.const_set(:CACHE_TIMEOUT, previous_value)
+    Percy::Cache.send(:remove_const, :CACHE_TIMEOUT)
+    Percy::Cache.const_set(:CACHE_TIMEOUT, previous_value)
   end
 end

data/specs/cli_wrapper.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/MethodLength
-
 require 'minitest/autorun'
 require 'webmock/minitest'
 require 'json'
@@ -18,10 +16,10 @@ def mock_poa_screenshot(fail: false)
     .to_return(body: "{\"success\": #{fail ? 'false, "error": "test"' : 'true'}}", status: (fail ? 500 : 200))
 end
 
-# Test suite for the CLIWrapper class
+# Test suite for the Percy::CLIWrapper class
 class TestCLIWrapper < Minitest::Test
   def setup
-    @cli_wrapper = CLIWrapper.new
+    @cli_wrapper = Percy::CLIWrapper.new
     @ignored_elements_data = {
       'ignore_elements_data' => {
         'selector' => 'xpath: some_xpath',
@@ -85,7 +83,7 @@ class TestCLIWrapper < Minitest::Test
     mock_screenshot
 
     assert_equal(
-      @cli_wrapper.post_screenshots('some-name', {}, [Tile.new(10, 10, 20, 20, filepath: 'some-file-path')],
+      @cli_wrapper.post_screenshots('some-name', {}, [Percy::Tile.new(10, 10, 20, 20, filepath: 'some-file-path')],
                                     'some-debug-url'),
       { 'link' => 'snapshot-url-link', 'success' => true }
     )
@@ -95,14 +93,14 @@ class TestCLIWrapper < Minitest::Test
     mock_screenshot
 
     assert_equal(
-      @cli_wrapper.post_screenshots('some-name', {}, [Tile.new(10, 10, 20, 20, filepath: 'some-file-path')],
+      @cli_wrapper.post_screenshots('some-name', {}, [Percy::Tile.new(10, 10, 20, 20, filepath: 'some-file-path')],
                                     'some-debug-url', @ignored_elements_data),
       { 'link' => 'snapshot-url-link', 'success' => true }
     )
   end
 
   def test_request_body
-    tile = Tile.new(10, 10, 20, 20, filepath: 'some-file-path')
+    tile = Percy::Tile.new(10, 10, 20, 20, filepath: 'some-file-path')
     tag = { 'name' => 'Tag' }
     name = 'some-name'
     debug_url = 'debug-url'
@@ -117,7 +115,7 @@ class TestCLIWrapper < Minitest::Test
   end
 
   def test_request_body_when_optional_values_are_null
-    tile = Tile.new(10, 10, 20, 20, filepath: 'some-file-path')
+    tile = Percy::Tile.new(10, 10, 20, 20, filepath: 'some-file-path')
     tag = { 'name' => 'Tag' }
     name = 'some-name'
     debug_url = nil

data/specs/driver_metadata.rb

@@ -1,14 +1,12 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/MethodLength
-
 require 'minitest/autorun'
 require 'minitest/mock'
 require 'appium_lib'
 
 require_relative '../percy/metadata/driver_metadata'
 
-# Test suite for the DriverMetadata class
+# Test suite for the Percy::DriverMetadata class
 class TestDriverMetadata < Minitest::Test
   def setup
     @mock_webdriver = Minitest::Mock.new
@@ -16,7 +14,7 @@ class TestDriverMetadata < Minitest::Test
     @bridge = Minitest::Mock.new
     @server_url = Minitest::Mock.new
 
-    @metadata = DriverMetadata.new(@mock_webdriver)
+    @metadata = Percy::DriverMetadata.new(@mock_webdriver)
   end
 
   def test_session_id

data/specs/generic_providers.rb

@@ -1,8 +1,5 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/MethodLength
-# rubocop:disable Metrics/AbcSize
-
 require 'minitest/autorun'
 require 'securerandom'
 require 'appium_lib'
@@ -11,7 +8,7 @@ require_relative '../percy/metadata/android_metadata'
 require_relative '../percy/lib/region'
 require_relative 'mocks/mock_methods'
 
-# Test suite for the GenericProvider class
+# Test suite for the Percy::GenericProvider class
 class TestGenericProvider < Minitest::Test
   include Appium
   COMPARISON_RESPONSE = { 'comparison' => { 'id' => 123, 'url' => 'https://percy-build-url' } }.freeze
@@ -31,8 +28,8 @@ class TestGenericProvider < Minitest::Test
     png_bytes = 'some random bytes'
     @mock_webdriver.expect(:screenshot_as, png_bytes, [:png])
 
-    @android_metadata = AndroidMetadata.new(@mock_webdriver)
-    @generic_provider = GenericProvider.new(@mock_webdriver, @android_metadata)
+    @android_metadata = Percy::AndroidMetadata.new(@mock_webdriver)
+    @generic_provider = Percy::GenericProvider.new(@mock_webdriver, @android_metadata)
   end
 
   def teardown
@@ -166,13 +163,13 @@ class TestGenericProvider < Minitest::Test
       @mock_webdriver.expect(:capabilities, get_android_capabilities)
     end
 
-    Metadata.class_eval do
+    Percy::Metadata.class_eval do
       define_method(:session_id) do
         mock.session_id
       end
     end
 
-    AndroidMetadata.class_eval do
+    Percy::AndroidMetadata.class_eval do
       6.times do
         define_method(:get_system_bars) do
           mock.get_system_bars
@@ -192,7 +189,7 @@ class TestGenericProvider < Minitest::Test
   end
 
   def test_supports
-    assert GenericProvider.supports('some-dummy-url')
+    assert Percy::GenericProvider.supports('some-dummy-url')
   end
 
   def test_non_app_automate
@@ -202,7 +199,7 @@ class TestGenericProvider < Minitest::Test
       mock.expect(:session_id, session_id)
     end
 
-    Metadata.class_eval do
+    Percy::Metadata.class_eval do
       4.times do
         define_method(:session_id) do
           mock.session_id
@@ -353,8 +350,8 @@ class TestGenericProvider < Minitest::Test
     @mock_webdriver.expect(:capabilities, get_android_capabilities)
     @mock_webdriver.expect(:capabilities, get_android_capabilities)
     @mock_webdriver.expect(:capabilities, get_android_capabilities)
-    valid_ignore_region = Region.new(100, 200, 200, 300)
-    invalid_ignore_region = Region.new(100, 2390, 200, 300)
+    valid_ignore_region = Percy::Region.new(100, 200, 200, 300)
+    invalid_ignore_region = Percy::Region.new(100, 2390, 200, 300)
 
     elements_array = []
     custom_locations = [valid_ignore_region, invalid_ignore_region]

data/specs/ignore_regions.rb

@@ -1,7 +1,5 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/MethodLength
-
 require 'minitest/autorun'
 require_relative '../percy/lib/ignore_region'
 
@@ -12,7 +10,7 @@ class TestIgnoreRegion < Minitest::Test
     bottom = 20
     left = 30
     right = 40
-    ignore_region = IgnoreRegion.new(top, bottom, left, right)
+    ignore_region = Percy::IgnoreRegion.new(top, bottom, left, right)
 
     assert_equal ignore_region.top, top
     assert_equal ignore_region.bottom, bottom
@@ -21,29 +19,29 @@ class TestIgnoreRegion < Minitest::Test
   end
 
   def test_ignore_region_negative_input
-    assert_raises(ArgumentError) { IgnoreRegion.new(-10, 20, 30, 40) }
-    assert_raises(ArgumentError) { IgnoreRegion.new(10, 20, -30, 40) }
-    assert_raises(ArgumentError) { IgnoreRegion.new(10, 20, 30, -40) }
-    assert_raises(ArgumentError) { IgnoreRegion.new(-10, -20, -30, -40) }
+    assert_raises(ArgumentError) { Percy::IgnoreRegion.new(-10, 20, 30, 40) }
+    assert_raises(ArgumentError) { Percy::IgnoreRegion.new(10, 20, -30, 40) }
+    assert_raises(ArgumentError) { Percy::IgnoreRegion.new(10, 20, 30, -40) }
+    assert_raises(ArgumentError) { Percy::IgnoreRegion.new(-10, -20, -30, -40) }
   end
 
   def test_ignore_region_invalid_input
-    assert_raises(ArgumentError) { IgnoreRegion.new(20, 10, 30, 40) } # bottom < top
-    assert_raises(ArgumentError) { IgnoreRegion.new(10, 20, 40, 30) } # right < left
+    assert_raises(ArgumentError) { Percy::IgnoreRegion.new(20, 10, 30, 40) } # bottom < top
+    assert_raises(ArgumentError) { Percy::IgnoreRegion.new(10, 20, 40, 30) } # right < left
   end
 
   def test_ignore_region_is_valid
-    ignore_region = IgnoreRegion.new(10, 20, 30, 40)
+    ignore_region = Percy::IgnoreRegion.new(10, 20, 30, 40)
     screen_height = 100
     screen_width = 200
     assert_equal true, ignore_region.valid?(screen_height, screen_width)
 
-    ignore_region = IgnoreRegion.new(10, 200, 30, 400)
+    ignore_region = Percy::IgnoreRegion.new(10, 200, 30, 400)
     height = 100
     width = 200
     assert_equal false, ignore_region.valid?(height, width)
 
-    ignore_region = IgnoreRegion.new(10, 20, 30, 40)
+    ignore_region = Percy::IgnoreRegion.new(10, 20, 30, 40)
     screen_height = 5
     screen_width = 10
     assert_equal false, ignore_region.valid?(screen_height, screen_width)

data/specs/ios_metadata.rb

@@ -5,14 +5,14 @@ require 'minitest/mock'
 require_relative 'mocks/mock_methods'
 require_relative '../percy/metadata/ios_metadata'
 
-# Test suite for the IOSMetadata class
+# Test suite for the Percy::IOSMetadata class
 class TestIOSMetadata < Minitest::Test
   def setup
     @mock_webdriver = Minitest::Mock.new
     @bridge = Minitest::Mock.new
     @http = Minitest::Mock.new
     @server_url = Minitest::Mock.new
-    @ios_metadata = IOSMetadata.new(@mock_webdriver)
+    @ios_metadata = Percy::IOSMetadata.new(@mock_webdriver)
   end
 
   def test_ios_execute_script

data/specs/metadata.rb

@@ -1,16 +1,13 @@
 # frozen_string_literal: true
 
-# rubocop:disable Metrics/MethodLength
-# rubocop:disable Metrics/AbcSize
-
 require 'minitest/autorun'
 require_relative '../percy/metadata/metadata'
 
-# Test suite for the Metadata class
+# Test suite for the Percy::Metadata class
 class TestMetadata < Minitest::Test
   def setup
     @mock_webdriver = Minitest::Mock.new
-    @metadata = Metadata.new(@mock_webdriver)
+    @metadata = Percy::Metadata.new(@mock_webdriver)
   end
 
   def test_metadata_properties

data/specs/metadata_resolver.rb

@@ -6,7 +6,7 @@ require_relative '../percy/metadata/android_metadata'
 require_relative '../percy/metadata/ios_metadata'
 require_relative '../percy/metadata/metadata_resolver'
 
-# Test suite for the MetadataResolver class
+# Test suite for the Percy::MetadataResolver class
 class MetadataResolverTestCase < Minitest::Test
   def setup
     @mock_webdriver = Minitest::Mock.new
@@ -15,17 +15,17 @@ class MetadataResolverTestCase < Minitest::Test
   def test_android_resolved
     @mock_webdriver.expect(:capabilities, { 'platformName' => 'Android' })
     @mock_webdriver.expect(:capabilities, { 'platformName' => 'Android' })
-    resolved_metadata = MetadataResolver.resolve(@mock_webdriver)
+    resolved_metadata = Percy::MetadataResolver.resolve(@mock_webdriver)
 
-    assert_instance_of(AndroidMetadata, resolved_metadata)
+    assert_instance_of(Percy::AndroidMetadata, resolved_metadata)
     @mock_webdriver.verify
   end
 
   def test_ios_resolved
     @mock_webdriver.expect(:capabilities, { 'platformName' => 'iOS' })
-    resolved_metadata = MetadataResolver.resolve(@mock_webdriver)
+    resolved_metadata = Percy::MetadataResolver.resolve(@mock_webdriver)
 
-    assert_instance_of(IOSMetadata, resolved_metadata)
+    assert_instance_of(Percy::IOSMetadata, resolved_metadata)
     @mock_webdriver.verify
   end
 
@@ -33,7 +33,7 @@ class MetadataResolverTestCase < Minitest::Test
     @mock_webdriver.expect(:capabilities, { 'platformName' => 'Something Random' })
 
     assert_raises(Exception) do
-      MetadataResolver.resolve(@mock_webdriver)
+      Percy::MetadataResolver.resolve(@mock_webdriver)
     end
 
     @mock_webdriver.verify

data/specs/mocks/mock_methods.rb

@@ -1,5 +1,3 @@
-# frozen_string_literal: true
-
 require 'json'
 
 def get_android_capabilities