percy-appium-app 0.0.1

data/specs/generic_providers.rb

@@ -0,0 +1,370 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/MethodLength
+# rubocop:disable Metrics/AbcSize
+
+require 'minitest/autorun'
+require 'securerandom'
+require 'appium_lib'
+require_relative '../percy/providers/generic_provider'
+require_relative '../percy/metadata/android_metadata'
+require_relative '../percy/lib/region'
+require_relative 'mocks/mock_methods'
+
+# Test suite for the GenericProvider class
+class TestGenericProvider < Minitest::Test
+  include Appium
+  COMPARISON_RESPONSE = { 'comparison' => { 'id' => 123, 'url' => 'https://percy-build-url' } }.freeze
+
+  def setup
+    @existing_dir = 'existing-dir'
+    Dir.mkdir(@existing_dir)
+
+    @mock_webdriver = Minitest::Mock.new
+    @mock_webdriver.expect(:capabilities, get_android_capabilities)
+    @mock_webdriver.expect(:orientation, 'PorTrait')
+    @mock_webdriver.expect(:get_system_bars, {
+                             'statusBar' => { 'height' => 10, 'width' => 20 },
+                             'navigationBar' => { 'height' => 10, 'width' => 20 }
+                           })
+
+    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)
+  end
+
+  def teardown
+    FileUtils.remove_entry_secure(@existing_dir)
+  end
+
+  def test_get_dir_without_env_variable
+    ENV.delete('PERCY_TMP_DIR')
+    result = @generic_provider._get_dir
+    assert File.directory?(result), 'Directory should exist'
+  end
+
+  def test_get_dir_with_env_variable
+    ENV['PERCY_TMP_DIR'] = '/tmp/percy-apps'
+    result = @generic_provider._get_dir
+    assert_equal '/tmp/percy-apps', result
+    assert File.directory?(result), 'Directory should exist'
+    Dir.rmdir(result)
+    ENV.delete('PERCY_TMP_DIR')
+  end
+
+  def test_get_path
+    count = 1000
+    png_paths = Array.new(count) { @generic_provider._get_path(@existing_dir) }
+    assert_equal png_paths.uniq.length, count
+  end
+
+  def test_write_screenshot
+    png_bytes = 'some random bytes'
+    filepath = @generic_provider._write_screenshot(png_bytes, @existing_dir)
+    assert(File.exist?(filepath))
+  end
+
+  def test_get_debug_url
+    assert_equal @generic_provider.get_debug_url, ''
+  end
+
+  def test_get_tag
+    10.times do
+      @mock_webdriver.expect(:capabilities, get_android_capabilities)
+    end
+    tag = @generic_provider._get_tag
+    assert_includes tag, 'name'
+    assert_equal tag['name'], @android_metadata.device_name
+    assert_includes tag, 'os_name'
+    assert_equal tag['os_name'], @android_metadata.os_name
+    assert_includes tag, 'os_version'
+    assert_equal tag['os_version'], @android_metadata.os_version
+    assert_includes tag, 'width'
+    assert_equal tag['width'], @android_metadata.device_screen_size['width']
+    assert_includes tag, 'height'
+    assert_equal tag['height'], @android_metadata.device_screen_size['height']
+    assert_includes tag, 'orientation'
+    assert_equal tag['orientation'], @android_metadata.get_orientation.downcase
+  end
+
+  def test_get_tag_kwargs
+    10.times do
+      @mock_webdriver.expect(:capabilities, get_android_capabilities)
+    end
+    device_name = 'some-device-name'
+    tag = @generic_provider._get_tag(device_name: device_name)
+    assert_includes tag, 'name'
+    assert_equal tag['name'], device_name
+
+    orientation = 'Some-Orientation'
+    tag = @generic_provider._get_tag(orientation: orientation)
+    assert_includes tag, 'orientation'
+    assert_equal tag['orientation'], orientation.downcase
+  end
+
+  def test_get_tiles
+    session_id = 'session_id_123'
+    10.times do
+      @mock_webdriver.expect(:session_id, session_id)
+    end
+    10.times do
+      @mock_webdriver.expect(:get_system_bars, {
+                               'statusBar' => { 'height' => 10, 'width' => 20 },
+                               'navigationBar' => { 'height' => 10, 'width' => 20 }
+                             })
+    end
+    tile = @generic_provider._get_tiles[0]
+    dict_tile = tile.to_h
+    assert_includes dict_tile, 'filepath'
+    assert_instance_of String, dict_tile['filepath']
+    assert(File.exist?(dict_tile['filepath']))
+    assert_includes dict_tile, 'status_bar_height'
+    assert_equal dict_tile['status_bar_height'], @android_metadata.status_bar_height
+    assert_includes dict_tile, 'nav_bar_height'
+    assert_equal dict_tile['nav_bar_height'], @android_metadata.navigation_bar_height
+    assert_includes dict_tile, 'header_height'
+    assert_equal dict_tile['header_height'], 0
+    assert_includes dict_tile, 'footer_height'
+    assert_equal dict_tile['footer_height'], 0
+    assert_includes dict_tile, 'fullscreen'
+    assert_equal dict_tile['fullscreen'], false
+    File.delete(tile.filepath)
+  end
+
+  def test_get_tiles_kwargs
+    status_bar_height = 135
+    nav_bar_height = 246
+    tile = @generic_provider._get_tiles(
+      status_bar_height: status_bar_height,
+      nav_bar_height: nav_bar_height,
+      full_screen: true
+    )[0]
+    dict_tile = tile.to_h
+    assert_includes dict_tile, 'status_bar_height'
+    assert_equal dict_tile['status_bar_height'], status_bar_height
+    assert_includes dict_tile, 'nav_bar_height'
+    assert_equal dict_tile['nav_bar_height'], nav_bar_height
+    assert_includes dict_tile, 'fullscreen'
+    assert_equal dict_tile['fullscreen'], true
+  end
+
+  def test_post_screenshots
+    session_id = 'session_id_123'
+
+    mock = Minitest::Mock.new
+    mock.expect(:post_screenshots, COMPARISON_RESPONSE, [String, Hash, Hash, String, Array, Array])
+    mock.expect(:session_id, session_id)
+    10.times do
+      mock.expect(:get_system_bars, {
+                    'statusBar' => { 'height' => 10, 'width' => 20 },
+                    'navigationBar' => { 'height' => 10, 'width' => 20 }
+                  })
+    end
+    6.times do
+      @mock_webdriver.expect(:capabilities, get_android_capabilities)
+    end
+
+    Metadata.class_eval do
+      define_method(:session_id) do
+        mock.session_id
+      end
+    end
+
+    AndroidMetadata.class_eval do
+      6.times do
+        define_method(:get_system_bars) do
+          mock.get_system_bars
+        end
+      end
+    end
+
+    tag = @generic_provider._get_tag
+    tiles = @generic_provider._get_tiles
+
+    @generic_provider.stub(:_post_screenshots, COMPARISON_RESPONSE) do
+      response = @generic_provider._post_screenshots(
+        'screenshot 1', tag, tiles, '', [], []
+      )
+      assert_equal response, COMPARISON_RESPONSE
+    end
+  end
+
+  def test_supports
+    assert GenericProvider.supports('some-dummy-url')
+  end
+
+  def test_non_app_automate
+    session_id = 'session_id_123'
+    mock = Minitest::Mock.new
+    4.times do
+      mock.expect(:session_id, session_id)
+    end
+
+    Metadata.class_eval do
+      4.times do
+        define_method(:session_id) do
+          mock.session_id
+        end
+      end
+    end
+
+    7.times do
+      @mock_webdriver.expect(:capabilities, get_android_capabilities)
+    end
+    6.times do
+      @mock_webdriver.expect(:get_system_bars, {
+                               'statusBar' => { 'height' => 10, 'width' => 20 },
+                               'navigationBar' => { 'height' => 10, 'width' => 20 }
+                             })
+    end
+
+    @generic_provider.stub(:_post_screenshots, COMPARISON_RESPONSE) do
+      response = @generic_provider.screenshot('screenshot 1')
+      assert_equal response, COMPARISON_RESPONSE
+    end
+  end
+
+  def test_get_device_name
+    device_name = @generic_provider.get_device_name
+    assert_equal device_name, ''
+  end
+
+  def test_get_region_object
+    mock_element = Minitest::Mock.new
+    mock_element.expect(:location, { 'x' => 10, 'y' => 20 })
+    mock_element.expect(:size, { 'width' => 100, 'height' => 200 })
+
+    result = @generic_provider.get_region_object('my-selector', mock_element)
+    expected_result = {
+      'selector' => 'my-selector',
+      'coOrdinates' => { 'top' => 20, 'bottom' => 220, 'left' => 10, 'right' => 110 }
+    }
+
+    assert_equal result, expected_result
+    mock_element.verify
+  end
+
+  def test_get_regions_by_xpath
+    mock_element = Minitest::Mock.new
+    mock_element.expect(:location, { 'x' => 10, 'y' => 20 })
+    mock_element.expect(:size, { 'width' => 100, 'height' => 200 })
+
+    @mock_webdriver.expect(:find_element, mock_element,
+                           [Appium::Core::Base::SearchContext::FINDERS[:xpath], '//path/to/element'])
+
+    elements_array = []
+    xpaths = ['//path/to/element']
+    @generic_provider.get_regions_by_xpath(elements_array, xpaths)
+
+    expected_elements_array = [{
+      'selector' => 'xpath: //path/to/element',
+      'coOrdinates' => { 'top' => 20, 'bottom' => 220, 'left' => 10, 'right' => 110 }
+    }]
+
+    assert_equal elements_array, expected_elements_array
+  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
+      raise Appium::Core::Error::NoSuchElementError, 'Test error'
+    end
+    elements_array = []
+    xpaths = ['//path/to/element']
+    @generic_provider.get_regions_by_xpath(elements_array, xpaths)
+
+    assert_empty elements_array
+  end
+
+  def test_get_regions_by_ids
+    mock_element = Minitest::Mock.new
+    mock_element.expect(:location, { 'x' => 10, 'y' => 20 })
+    mock_element.expect(:size, { 'width' => 100, 'height' => 200 })
+
+    @mock_webdriver.expect(:find_element, mock_element,
+                           [Appium::Core::Base::SearchContext::FINDERS[:accessibility_id], 'some_id'])
+
+    elements_array = []
+    ids = ['some_id']
+    @generic_provider.get_regions_by_ids(elements_array, ids)
+
+    expected_elements_array = [{
+      'selector' => 'id: some_id',
+      'coOrdinates' => { 'top' => 20, 'bottom' => 220, 'left' => 10, 'right' => 110 }
+    }]
+
+    assert_equal elements_array, expected_elements_array
+  end
+
+  def test_get_regions_by_ids_with_non_existing_element
+    mock_element = Minitest::Mock.new
+    mock_element.expect(:location, { 'x' => 10, 'y' => 20 })
+    mock_element.expect(:size, { 'width' => 100, 'height' => 200 })
+
+    @mock_webdriver.expect(:find_element, [Appium::Core::Base::SearchContext::FINDERS[:accessibility_id], 'id1']) do
+      raise Appium::Core::Error::NoSuchElementError, 'Test error'
+    end
+
+    elements_array = []
+    ids = ['id1']
+    @generic_provider.get_regions_by_ids(elements_array, ids)
+
+    assert_empty elements_array
+  end
+
+  def test_get_regions_by_elements
+    mock_element = Minitest::Mock.new
+    mock_element.expect(:location, { 'x' => 10, 'y' => 20 })
+    mock_element.expect(:size, { 'width' => 100, 'height' => 200 })
+    mock_element.expect(:attribute, 'textView', ['class'])
+
+    elements_array = []
+    elements = [mock_element]
+    @generic_provider.get_regions_by_elements(elements_array, elements)
+
+    expected_elements_array = [{
+      'selector' => 'element: 0 textView',
+      'coOrdinates' => { 'top' => 20, 'bottom' => 220, 'left' => 10, 'right' => 110 }
+    }]
+
+    assert_equal elements_array, expected_elements_array
+    mock_element.verify
+  end
+
+  def test_get_regions_by_elements_with_non_existing_element
+    element_mock = Minitest::Mock.new
+    element_mock.expect(:attribute, 'class') do
+      raise Appium::Core::Error::NoSuchElementError, 'Test error'
+    end
+
+    elements_array = []
+    elements = [element_mock]
+
+    @generic_provider.get_regions_by_elements(elements_array, elements)
+
+    assert_equal 0, elements_array.length
+  end
+
+  def test_get_regions_by_location
+    @mock_webdriver.expect(:capabilities, get_android_capabilities)
+    @mock_webdriver.expect(:capabilities, get_android_capabilities)
+    @mock_webdriver.expect(:capabilities, get_android_capabilities)
+    @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)
+
+    elements_array = []
+    custom_locations = [valid_ignore_region, invalid_ignore_region]
+    @generic_provider.get_regions_by_location(elements_array, custom_locations)
+
+    expected_elements_array = [{
+      selector: 'custom ignore region: 0',
+      coOrdinates: { top: 100, bottom: 200, left: 200, right: 300 }
+    }]
+
+    assert_equal elements_array, expected_elements_array
+  end
+end

data/specs/ignore_regions.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/MethodLength
+
+require 'minitest/autorun'
+require_relative '../percy/lib/ignore_region'
+
+# Test suite for the IgnoreRegions class
+class TestIgnoreRegion < Minitest::Test
+  def test_ignore_region_valid_input
+    top = 10
+    bottom = 20
+    left = 30
+    right = 40
+    ignore_region = IgnoreRegion.new(top, bottom, left, right)
+
+    assert_equal ignore_region.top, top
+    assert_equal ignore_region.bottom, bottom
+    assert_equal ignore_region.left, left
+    assert_equal ignore_region.right, right
+  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) }
+  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
+  end
+
+  def test_ignore_region_is_valid
+    ignore_region = 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)
+    height = 100
+    width = 200
+    assert_equal false, ignore_region.valid?(height, width)
+
+    ignore_region = IgnoreRegion.new(10, 20, 30, 40)
+    screen_height = 5
+    screen_width = 10
+    assert_equal false, ignore_region.valid?(screen_height, screen_width)
+  end
+end

data/specs/ios_metadata.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'minitest/mock'
+require_relative 'mocks/mock_methods'
+require_relative '../percy/metadata/ios_metadata'
+
+# Test suite for the 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)
+  end
+
+  def test_ios_execute_script
+    command = 'some dummy command'
+    output = 'some output'
+    @mock_webdriver.expect(:execute_script, output, [command])
+
+    response = @ios_metadata.execute_script(command)
+    assert_equal(output, response)
+  end
+
+  def test_remote_url
+    @mock_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, 'some-remote-url')
+
+    assert_equal('some-remote-url', @ios_metadata.remote_url)
+  end
+
+  def test_get_window_size
+    height = 100
+    width = 100
+    window_size = { 'height' => height, 'width' => width }
+    @mock_webdriver.expect(:get_window_size, window_size)
+    session_id = 'session_id_123'
+    @mock_webdriver.expect(:session_id, session_id)
+    @mock_webdriver.expect(:session_id, session_id)
+
+    assert_equal({}, @ios_metadata._window_size)
+    fetched_window_size = @ios_metadata.get_window_size
+    assert_equal(window_size, fetched_window_size)
+  end
+
+  def test_device_screen_size
+    session_id = 'session_id_123'
+    5.times do
+      @mock_webdriver.expect(:session_id, session_id)
+    end
+    @mock_webdriver.expect(:capabilities, { 'deviceName' => 'iPhone 6' })
+    @mock_webdriver.expect(:get_window_size, { 'height' => 100, 'width' => 100 })
+    device_screen_size = @ios_metadata.device_screen_size
+    assert_equal({ 'height' => 200, 'width' => 200 }, device_screen_size)
+  end
+
+  def test_status_bar
+    @mock_webdriver.expect(:capabilities, { 'deviceName' => 'iPhone 6' })
+    session_id = 'session_id_123'
+    @mock_webdriver.expect(:session_id, session_id)
+    @mock_webdriver.expect(:session_id, session_id)
+
+    status_bar = @ios_metadata.status_bar
+    assert_equal({ 'height' => 40 }, status_bar)
+  end
+
+  def test_scale_factor_present_in_devices_json
+    @mock_webdriver.expect(:capabilities, { 'deviceName' => 'iPhone 6' })
+    assert_equal(2, @ios_metadata.scale_factor)
+  end
+
+  def test_scale_factor_not_present_in_devices_json
+    window_size = { 'height' => 100, 'width' => 100 }
+    session_id = 'session_id_123'
+    4.times do
+      @mock_webdriver.expect(:session_id, session_id)
+    end
+    @mock_webdriver.expect(:capabilities, { 'deviceName' => 'iPhone 14' })
+    @mock_webdriver.expect(:get_window_size, window_size)
+    @mock_webdriver.expect(:execute_script, { 'height' => 100, 'width' => 200 }, ['mobile: viewportRect'])
+
+    assert_equal(2, @ios_metadata.scale_factor)
+  end
+end

data/specs/metadata.rb

@@ -0,0 +1,105 @@
+# 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
+class TestMetadata < Minitest::Test
+  def setup
+    @mock_webdriver = Minitest::Mock.new
+    @metadata = Metadata.new(@mock_webdriver)
+  end
+
+  def test_metadata_properties
+    assert_raises(NotImplementedError) { @metadata._device_name }
+    assert_raises(NotImplementedError) { @metadata.device_screen_size }
+    assert_raises(NotImplementedError) { @metadata.navigation_bar }
+    assert_raises(NotImplementedError) { @metadata.navigation_bar_height }
+    assert_raises(NotImplementedError) { @metadata.status_bar }
+    assert_raises(NotImplementedError) { @metadata.status_bar_height }
+    assert_raises(NotImplementedError) { @metadata.viewport }
+
+    assert_equal({}, @metadata.device_info)
+
+    device_config = @metadata.get_device_info('iPhone 6')
+    refute_equal({}, @metadata.device_info)
+    assert_equal(device_config, @metadata.get_device_info('iPhone 6'))
+
+    ENV['PERCY_LOGLEVEL'] = 'debug'
+  end
+
+  def test_get_device_info_device_not_present
+    device_name = 'Some Phone 123'
+    assert_output(/#{Regexp.escape(device_name.downcase)} does not exist in config\./) do
+      @metadata.get_device_info(device_name)
+    end
+  end
+
+  def test_metadata_get_orientation
+    orientation = 'PRTRT'
+    @mock_webdriver.expect(:get_orientation, orientation, [{ "orientation": orientation }])
+    assert(orientation, @metadata.get_orientation(orientation: orientation))
+
+    orientation = 'prtrt'
+    @mock_webdriver.expect(:get_orientation, orientation, [{ "orientation": orientation }])
+    assert_equal(orientation.upcase, @metadata.get_orientation(orientation: orientation))
+
+    orientation = 'OriENTation'
+    @mock_webdriver.expect(:get_orientation, orientation, [{ "orientation": 'AUTO' }])
+
+    @mock_webdriver.expect(:orientation, orientation)
+    assert(orientation.upcase, @metadata.get_orientation(orientation: 'AUTO'))
+
+    @mock_webdriver.expect(:orientation, orientation)
+    assert(orientation.upcase, @metadata.get_orientation(orientation: 'auto'))
+
+    @mock_webdriver.expect(:orientation, orientation)
+    assert(orientation.upcase, @metadata.get_orientation(orientation: 'Auto'))
+
+    orientation = 'OriEntaTion'
+    @mock_webdriver.expect(:capabilities, { 'orientation' => orientation })
+    assert_equal(orientation.upcase, @metadata.get_orientation)
+
+    @mock_webdriver.expect(:capabilities, {})
+    assert_equal('PORTRAIT', @metadata.get_orientation)
+  end
+
+  def test_metadata_session_id
+    session_id = 'Some Totally random session ID'
+    @mock_webdriver.expect(:session_id, session_id)
+    assert_equal(session_id, @metadata.session_id)
+    @mock_webdriver.verify
+  end
+
+  def test_metadata_os_version
+    capabilities = { 'os_version' => '10' }
+    @mock_webdriver.expect(:capabilities, capabilities)
+    @mock_webdriver.expect(:capabilities, capabilities)
+    @mock_webdriver.expect(:capabilities, capabilities)
+    os_ver = @metadata.os_version
+    assert_equal('10', os_ver)
+  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' } }
+
+    @metadata.instance_variable_set(:@device_name, nil)
+    assert_equal(android_device_info['13']['status_bar'].to_i,
+                 @metadata.value_from_devices_info('status_bar', android_device, '13'))
+  end
+
+  def test_metadata_value_from_devices_info_for_ios
+    ios_device = 'iphone 12 pro max'
+    ios_device_info = { 'scale_factor' => '3', 'status_bar' => '47' }
+
+    @metadata.instance_variable_set(:@device_name, nil)
+    assert_equal(
+      ios_device_info['scale_factor'].to_i,
+      @metadata.value_from_devices_info('scale_factor', ios_device)
+    )
+  end
+end

data/specs/metadata_resolver.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'minitest/mock'
+require_relative '../percy/metadata/android_metadata'
+require_relative '../percy/metadata/ios_metadata'
+require_relative '../percy/metadata/metadata_resolver'
+
+# Test suite for the MetadataResolver class
+class MetadataResolverTestCase < Minitest::Test
+  def setup
+    @mock_webdriver = Minitest::Mock.new
+  end
+
+  def test_android_resolved
+    @mock_webdriver.expect(:capabilities, { 'platformName' => 'Android' })
+    @mock_webdriver.expect(:capabilities, { 'platformName' => 'Android' })
+    resolved_metadata = MetadataResolver.resolve(@mock_webdriver)
+
+    assert_instance_of(AndroidMetadata, resolved_metadata)
+    @mock_webdriver.verify
+  end
+
+  def test_ios_resolved
+    @mock_webdriver.expect(:capabilities, { 'platformName' => 'iOS' })
+    resolved_metadata = MetadataResolver.resolve(@mock_webdriver)
+
+    assert_instance_of(IOSMetadata, resolved_metadata)
+    @mock_webdriver.verify
+  end
+
+  def test_unknown_platform_exception
+    @mock_webdriver.expect(:capabilities, { 'platformName' => 'Something Random' })
+
+    assert_raises(Exception) do
+      MetadataResolver.resolve(@mock_webdriver)
+    end
+
+    @mock_webdriver.verify
+  end
+end