percy-appium-app 0.0.1

data/specs/app_percy.rb

@@ -0,0 +1,175 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/MethodLength
+
+require 'minitest/autorun'
+# require 'webmock/minitest'
+require_relative '../percy/lib/app_percy'
+require_relative '../percy/metadata/android_metadata'
+require_relative '../percy/metadata/ios_metadata'
+require_relative '../percy/providers/app_automate'
+require_relative '../percy/providers/generic_provider'
+require_relative '../percy/lib/cli_wrapper'
+require_relative 'mocks/mock_methods'
+
+# Test suite for the AppPercy class
+class TestAppPercy < Minitest::Test
+  COMPARISON_RESPONSE = { 'link' => 'https://snapshot_url', 'success' => true }.freeze
+
+  def setup
+    @mock_android_webdriver = Minitest::Mock.new
+    @mock_ios_webdriver = Minitest::Mock.new
+    @bridge = Minitest::Mock.new
+    @http = Minitest::Mock.new
+    @server_url = Minitest::Mock.new
+  end
+
+  def test_android_on_app_automate
+    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, 'url-of-browserstack-cloud')
+    end
+    @mock_android_webdriver.expect(:is_a?, true, [Appium::Core::Base::Driver])
+    5.times do
+      @mock_android_webdriver.expect(:capabilities, get_android_capabilities)
+    end
+
+    ENV['PERCY_DISABLE_REMOTE_UPLOADS'] = 'true'
+
+    app_percy = AppPercy.new(@mock_android_webdriver)
+
+    assert_instance_of(AndroidMetadata, app_percy.metadata)
+    assert_instance_of(AppAutomate, app_percy.provider)
+  end
+
+  def test_android_on_non_app_automate
+    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, 'some-remote-url')
+    end
+    2.times do
+      @mock_android_webdriver.expect(:is_a?, true, [Appium::Core::Base::Driver])
+    end
+    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)
+  end
+
+  def test_ios_on_app_automate
+    mock_driver_remote_url(@mock_ios_webdriver, 'url-of-browserstack-cloud')
+    @mock_ios_webdriver.expect(:is_a?, true, [Appium::Core::Base::Driver])
+    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)
+  end
+
+  def test_ios_on_non_app_automate
+    2.times do
+      @mock_ios_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')
+    end
+    @mock_ios_webdriver.expect(:is_a?, true, [Appium::Core::Base::Driver])
+    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)
+  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)
+    assert_nil app_percy.screenshot('screenshot 1')
+  end
+
+  def test_screenshot_with_percyoptions_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)
+    assert_nil app_percy.screenshot('screenshot 1')
+  end
+
+  def test_percy_options_ignore_errors
+    @mock_android_webdriver.expect(:capabilities, {
+                                     'platformName': 'android',
+                                     'percy:options' => { 'ignoreErrors' => false }
+                                   })
+
+    assert_raises(Exception) do
+      AppPercy.screenshot(@mock_android_webdriver, 'screenshot')
+    end
+  end
+
+  def test_invalid_provider
+    url = 'some-cloud-url'
+    mock_driver_remote_url(@mock_android_webdriver, url, 2)
+    @mock_android_webdriver.expect(:is_a?, true, [Appium::Core::Base::Driver])
+    caps = get_android_capabilities
+    4.times do
+      @mock_android_webdriver.expect(:capabilities, caps)
+    end
+
+    GenericProvider.stub(:supports, false) do
+      assert_raises(UnknownProvider) do
+        _provider = AppPercy.new(@mock_android_webdriver).provider
+      end
+    end
+  end
+
+  def test_invalid_driver
+    assert_raises(DriverNotSupported) do
+      AppPercy.new(Object.new)
+    end
+  end
+
+  private
+
+  def disable_percy_options(mock_webdriver, num = 1)
+    num.times do
+      mock_webdriver.expect(:capabilities, {
+                              'platformName' => 'android',
+                              'percy:options' => { 'enabled' => false }
+                            })
+    end
+  end
+
+  def mock_driver_remote_url(mock_webdriver, url, num = 1)
+    num.times do
+      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, url)
+    end
+  end
+
+  def make_mock_driver_appium(mock_driver)
+    mock_driver.expect(:is_a?, true, [Appium::Core::Base::Driver])
+  end
+
+  def ignore_errors_test(mock_webdriver)
+    mock_webdriver.expect(:capabilities, {
+                            'platformName': 'android',
+                            'percy:options' => { 'ignoreErrors' => false }
+                          })
+
+    assert_raises(Exception) do
+      AppPercy.screenshot(mock_webdriver, 'screenshot')
+    end
+  end
+end

data/specs/cache.rb

@@ -0,0 +1,56 @@
+# frozen_string_literal: true
+
+require 'minitest/autorun'
+require 'minitest/mock'
+require 'time'
+require_relative '../percy/lib/cache'
+
+# Test suite for the Cache class
+class TestCache < Minitest::Test
+  def setup
+    @cache = Cache.new
+    @session_id = 'session_id_123'
+    @prop = 'window_size'
+    @value = { 'top' => 'Top Value' }
+    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_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) }
+  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)
+      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)
+
+    cache_timeout = Cache::CACHE_TIMEOUT
+    sleep(cache_timeout + 1)
+    assert_includes @cache.cache, @session_id
+    Cache.cleanup_cache
+    refute_includes @cache.cache, @session_id
+
+    Cache.send(:remove_const, :CACHE_TIMEOUT)
+    Cache.const_set(:CACHE_TIMEOUT, previous_value)
+  end
+end

data/specs/cli_wrapper.rb

@@ -0,0 +1,135 @@
+# frozen_string_literal: true
+
+# rubocop:disable Metrics/MethodLength
+
+require 'minitest/autorun'
+require 'webmock/minitest'
+require 'json'
+require_relative '../percy/lib/cli_wrapper'
+require_relative '../percy/lib/tile'
+
+def mock_screenshot(fail: false)
+  stub_request(:post, 'http://localhost:5338/percy/comparison')
+    .to_return(body: '{"link": "snapshot-url-link", "success": true}', status: (fail ? 500 : 200))
+end
+
+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 CLIWrapper class
+class TestCLIWrapper < Minitest::Test
+  def setup
+    @cli_wrapper = CLIWrapper.new
+    @ignored_elements_data = {
+      'ignore_elements_data' => {
+        'selector' => 'xpath: some_xpath',
+        'coOrdinates' => { 'top' => 123, 'bottom' => 234, 'left' => 234, 'right' => 455 }
+      }
+    }
+    @considered_elements_data = {
+      'consider_elements_data' => {
+        'selector' => 'xpath: some_xpath',
+        'coOrdinates' => { 'top' => 50, 'bottom' => 100, 'left' => 0, 'right' => 100 }
+      }
+    }
+    WebMock.enable!
+  end
+
+  def teardown
+    WebMock.disable!
+  end
+
+  def test_post_screenshot_throws_error
+    mock_screenshot(fail: true)
+
+    assert_raises(CLIException) do
+      @cli_wrapper.post_screenshots('some-name', {}, [], 'some-debug-url')
+    end
+  end
+
+  def test_post_failed_event
+    mock_poa_screenshot(fail: true)
+    @snapshot_name = 'test_snapshot'
+    @session_id = 'test_session_id'
+    @command_executor_url = 'http://example.com'
+    @capabilities = { 'browser' => 'chrome' }
+    @desired_capabilities = { 'platform' => 'Windows' }
+    @options = { 'option_key' => 'option_value' }
+
+    expected_request_body = {
+      'sessionId' => @session_id,
+      'commandExecutorUrl' => @command_executor_url,
+      'capabilities' => @capabilities,
+      'sessionCapabilities' => @desired_capabilities,
+      'snapshotName' => @snapshot_name,
+      'options' => @options,
+      'client_info' => 'your_mocked_client_info',
+      'environment_info' => 'your_mocked_environment_info'
+    }
+
+    assert_raises(CLIException, 'TestError') do
+      @cli_wrapper.post_poa_screenshots(
+        @snapshot_name,
+        @session_id,
+        @command_executor_url,
+        @capabilities,
+        @desired_capabilities,
+        @options
+      )
+    end
+  end
+
+  def test_post_screenshot_with_ignore_region_null
+    mock_screenshot
+
+    assert_equal(
+      @cli_wrapper.post_screenshots('some-name', {}, [Tile.new(10, 10, 20, 20, filepath: 'some-file-path')],
+                                    'some-debug-url'),
+      { 'link' => 'snapshot-url-link', 'success' => true }
+    )
+  end
+
+  def test_post_screenshot_with_ignore_region_present
+    mock_screenshot
+
+    assert_equal(
+      @cli_wrapper.post_screenshots('some-name', {}, [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')
+    tag = { 'name' => 'Tag' }
+    name = 'some-name'
+    debug_url = 'debug-url'
+    response = @cli_wrapper.request_body(name, tag, [tile], debug_url, @ignored_elements_data,
+                                         @considered_elements_data)
+    assert_equal response['name'], name
+    assert_equal response['external_debug_url'], debug_url
+    assert_equal response['tag'], tag
+    assert_equal response['tiles'], [tile.to_h]
+    assert_equal response['ignored_elements_data'], @ignored_elements_data
+    assert_equal response['considered_elements_data'], @considered_elements_data
+  end
+
+  def test_request_body_when_optional_values_are_null
+    tile = Tile.new(10, 10, 20, 20, filepath: 'some-file-path')
+    tag = { 'name' => 'Tag' }
+    name = 'some-name'
+    debug_url = nil
+    ignored_elements_data = nil
+    considered_elements_data = nil
+    response = @cli_wrapper.send(:request_body, name, tag, [tile], debug_url, ignored_elements_data,
+                                 considered_elements_data)
+    assert_equal response['name'], name
+    assert_equal response['external_debug_url'], debug_url
+    assert_equal response['tag'], tag
+    assert_equal response['tiles'], [tile.to_h]
+    assert_nil response['ignored_elements_data']
+    assert_nil response['considered_elements_data']
+  end
+end

data/specs/driver_metadata.rb

@@ -0,0 +1,71 @@
+# 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
+class TestDriverMetadata < Minitest::Test
+  def setup
+    @mock_webdriver = Minitest::Mock.new
+    @http = Minitest::Mock.new
+    @bridge = Minitest::Mock.new
+    @server_url = Minitest::Mock.new
+
+    @metadata = DriverMetadata.new(@mock_webdriver)
+  end
+
+  def test_session_id
+    session_id = 'session_id_123'
+    @mock_webdriver.expect(:session_id, session_id)
+
+    assert(session_id, @metadata.session_id)
+  end
+
+  def test_command_executor_url
+    url = 'https://example-hub:4444/wd/hub'
+    session_id = 'session_id_123'
+    2.times do
+      @mock_webdriver.expect(:session_id, session_id)
+    end
+    @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, url)
+
+    assert(url, @metadata.command_executor_url)
+  end
+
+  def test_capabilities
+    session_id = 'session_id_123'
+    2.times do
+      @mock_webdriver.expect(:session_id, session_id)
+    end
+    capabilities = { 'platform' => 'chrome_android', 'browserVersion' => '115.0.1' }
+    @mock_webdriver.expect(:capabilities, capabilities)
+
+    assert(capabilities, @metadata.capabilities)
+  end
+
+  def test_session_capabilities
+    session_id = 'session_id_123'
+    @mock_webdriver.expect(:session_id, session_id)
+    @mock_webdriver.expect(:session_id, session_id)
+    @mock_webdriver.expect(:desired_capabilities, {
+                             'platform' => 'chrome_android',
+                             'browserVersion' => '115.0.1',
+                             'session_name' => 'abc'
+                           })
+    session_caps = {
+      'platform' => 'chrome_android',
+      'browserVersion' => '115.0.1',
+      'session_name' => 'abc'
+    }
+
+    assert(session_caps, @metadata.session_capabilities)
+  end
+end