percy-appium-app 0.0.1

data/percy/providers/app_automate.rb

@@ -0,0 +1,159 @@
+# frozen_string_literal: true
+
+require 'json'
+require_relative '../common/common'
+require_relative '../lib/tile'
+require_relative 'generic_provider'
+require_relative '../environment'
+
+class AppAutomate < GenericProvider
+  def self.supports(remote_url)
+    r_index = remote_url.rindex(ENV['AA_DOMAIN'].nil? ? 'browserstack' : ENV['AA_DOMAIN'])
+    if r_index
+      r_index > -1
+    else
+      false
+    end
+  end
+
+  def screenshot(name, **kwargs)
+    session_details = execute_percy_screenshot_begin(name)
+
+    if session_details
+      metadata.device_name = session_details['deviceName']
+      metadata.os_version = session_details['osVersion']
+      set_debug_url(session_details)
+    end
+
+    begin
+      response = super(name, **kwargs)
+      percy_screenshot_url = response.fetch('link', '')
+      execute_percy_screenshot_end(name, percy_screenshot_url, 'success')
+    rescue StandardError => e
+      execute_percy_screenshot_end(name, percy_screenshot_url, 'failure', e.message)
+      raise e
+    end
+  end
+
+  def set_debug_url(session_details)
+    build_hash = session_details['buildHash'].to_s
+    session_hash = session_details['sessionHash'].to_s
+    @debug_url = "https://app-automate.browserstack.com/dashboard/v2/builds/#{build_hash}/sessions/#{session_hash}"
+  end
+
+  def _get_tiles(**kwargs)
+    fullpage_ss = kwargs[:fullpage] || false
+    if ENV['PERCY_DISABLE_REMOTE_UPLOADS'] == 'true'
+      puts("Full page screenshots are only supported when 'PERCY_DISABLE_REMOTE_UPLOADS' is not set") if fullpage_ss
+      return super(**kwargs) unless fullpage_ss
+    end
+    screenshot_type = fullpage_ss ? 'fullpage' : 'singlepage'
+    screen_lengths = kwargs[:screen_lengths] || 4
+    scrollable_xpath = kwargs[:scollable_xpath]
+    scrollable_id = kwargs[:scrollable_id]
+    top_scrollview_offset = kwargs[:top_scrollview_offset]
+    bottom_scrollview_offset = kwargs[:top_scrollview_offset]
+
+    data = execute_percy_screenshot(
+      metadata.device_screen_size.fetch('height', 1),
+      screenshot_type,
+      screen_lengths,
+      scrollable_xpath,
+      scrollable_id,
+      metadata.scale_factor,
+      top_scrollview_offset,
+      bottom_scrollview_offset
+    )
+    tiles = []
+    status_bar_height = metadata.status_bar_height
+    nav_bar_height = metadata.navigation_bar_height
+
+    JSON.parse(data['result']).each do |tile_data|
+      tiles << Tile.new(
+        status_bar_height,
+        nav_bar_height,
+        tile_data['header_height'],
+        tile_data['footer_height'],
+        sha: tile_data['sha'].split('-')[0]
+      )
+    end
+
+    tiles
+  end
+
+  def execute_percy_screenshot_begin(name)
+    request_body = {
+      action: 'percyScreenshot',
+      arguments: {
+        state: 'begin',
+        percyBuildId: Environment.percy_build_id,
+        percyBuildUrl: Environment.percy_build_url,
+        name: name
+      }
+    }
+    command = "browserstack_executor: #{request_body.to_json}"
+    begin
+      response = metadata.execute_script(command)
+      JSON.parse(response)
+    rescue StandardError => e
+      log('Could not set session as Percy session')
+      log('Error occurred during begin call', on_debug: true)
+      log(e, on_debug: true)
+      nil
+    end
+  end
+
+  def execute_percy_screenshot_end(name, percy_screenshot_url, status, status_message = nil)
+    request_body = {
+      action: 'percyScreenshot',
+      arguments: {
+        state: 'end',
+        percyScreenshotUrl: percy_screenshot_url,
+        name: name,
+        status: status
+      }
+    }
+    request_body[:arguments][:statusMessage] = status_message if status_message
+    command = "browserstack_executor: #{request_body.to_json}"
+    begin
+      metadata.execute_script(command)
+    rescue StandardError => e
+      log('Error occurred during end call', on_debug: true)
+      log(e, on_debug: true)
+    end
+  end
+
+  def execute_percy_screenshot(device_height, screenshotType, screen_lengths, scrollable_xpath = nil,
+                               scrollable_id = nil, scale_factor = 1, top_scrollview_offset = 0,
+                               bottom_scrollview_offset = 0)
+    project_id = ENV['PERCY_ENABLE_DEV'] == 'true' ? 'percy-dev' : 'percy-prod'
+    request_body = {
+      action: 'percyScreenshot',
+      arguments: {
+        state: 'screenshot',
+        percyBuildId: Environment.percy_build_id,
+        screenshotType: screenshotType,
+        projectId: project_id,
+        scaleFactor: scale_factor,
+        options: {
+          numOfTiles: screen_lengths,
+          deviceHeight: device_height,
+          scrollableXpath: scrollable_xpath,
+          scrollableId: scrollable_id,
+          topScrollviewOffset: top_scrollview_offset,
+          bottomScrollviewOffset: bottom_scrollview_offset,
+          'FORCE_FULL_PAGE' => ENV['FORCE_FULL_PAGE'] == 'true'
+        }
+      }
+    }
+    command = "browserstack_executor: #{request_body.to_json}"
+    begin
+      response = metadata.execute_script(command)
+      JSON.parse(response)
+    rescue StandardError => e
+      log('Error occurred during screenshot call', on_debug: true)
+      log(e, on_debug: true)
+      raise e
+    end
+  end
+end

data/percy/providers/generic_provider.rb

@@ -0,0 +1,205 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'tempfile'
+require 'pathname'
+require 'base64'
+require 'fileutils'
+require_relative '../lib/cli_wrapper'
+require_relative '../lib/tile'
+require_relative '../common/common'
+
+class GenericProvider
+  attr_accessor :driver, :metadata, :debug_url
+
+  def initialize(driver, metadata)
+    @driver = driver
+    @metadata = metadata
+    @debug_url = ''
+  end
+
+  def self.supports(_remote_url)
+    true
+  end
+
+  def screenshot(name, **kwargs)
+    tiles = _get_tiles(**kwargs)
+    tag = _get_tag(**kwargs)
+    ignore_regions = {
+      'ignoreElementsData' => _find_regions(
+        xpaths: kwargs.fetch(:ignore_regions_xpaths, []),
+        accessibility_ids: kwargs.fetch(:ignore_region_accessibility_ids, []),
+        appium_elements: kwargs.fetch(:ignore_region_appium_elements, []),
+        custom_locations: kwargs.fetch(:custom_ignore_regions, [])
+      )
+    }
+    consider_regions = {
+      'considerElementsData' => _find_regions(
+        xpaths: kwargs.fetch(:consider_regions_xpaths, []),
+        accessibility_ids: kwargs.fetch(:consider_region_accessibility_ids, []),
+        appium_elements: kwargs.fetch(:consider_region_appium_elements, []),
+        custom_locations: kwargs.fetch(:custom_consider_regions, [])
+      )
+    }
+
+    _post_screenshots(name, tag, tiles, get_debug_url, ignore_regions, consider_regions)
+  end
+
+  def _get_tag(**kwargs)
+    name = kwargs[:device_name] || metadata.device_name
+    os_name = metadata.os_name
+    os_version = metadata.os_version
+    width = metadata.device_screen_size['width'] || 1
+    height = metadata.device_screen_size['height'] || 1
+    orientation = metadata.get_orientation(**kwargs).downcase
+
+    {
+      'name' => name,
+      'os_name' => os_name,
+      'os_version' => os_version,
+      'width' => width,
+      'height' => height,
+      'orientation' => orientation
+    }
+  end
+
+  def _get_tiles(**kwargs)
+    fullpage_ss = kwargs[:fullpage] || false
+    if fullpage_ss
+      log('Full page screenshot is only supported on App Automate. Falling back to single page screenshot.')
+    end
+
+    png_bytes = driver.screenshot_as(:png)
+    directory = _get_dir
+    path = _write_screenshot(png_bytes, directory)
+
+    fullscreen = kwargs[:full_screen] || false
+    status_bar_height = kwargs[:status_bar_height] || metadata.status_bar_height
+    nav_bar_height = kwargs[:nav_bar_height] || metadata.navigation_bar_height
+    header_height = 0
+    footer_height = 0
+    [
+      Tile.new(status_bar_height, nav_bar_height, header_height, footer_height, filepath: path, fullscreen: fullscreen)
+    ]
+  end
+
+  def _find_regions(xpaths:, accessibility_ids:, appium_elements:, custom_locations:)
+    elements_array = []
+    get_regions_by_xpath(elements_array, xpaths)
+    get_regions_by_ids(elements_array, accessibility_ids)
+    get_regions_by_elements(elements_array, appium_elements)
+    get_regions_by_location(elements_array, custom_locations)
+    elements_array
+  end
+
+  def _post_screenshots(name, tag, tiles, debug_url, ignored_regions, considered_regions)
+    CLIWrapper.new.post_screenshots(name, tag, tiles, debug_url, ignored_regions, considered_regions)
+  end
+
+  def _write_screenshot(png_bytes, directory)
+    filepath = _get_path(directory)
+    File.open(filepath, 'wb') { |f| f.write(png_bytes) }
+    filepath
+  end
+
+  def get_region_object(selector, element)
+    scale_factor = metadata.scale_factor
+    location = hashed(element.location)
+    size = hashed(element.size)
+    coordinates = {
+      'top' => location['y'] * scale_factor,
+      'bottom' => (location['y'] + size['height']) * scale_factor,
+      'left' => location['x'] * scale_factor,
+      'right' => (location['x'] + size['width']) * scale_factor
+    }
+    { 'selector' => selector, 'coOrdinates' => coordinates }
+  end
+
+  def get_regions_by_xpath(elements_array, xpaths)
+    xpaths.each do |xpath|
+      element = driver.find_element(Appium::Core::Base::SearchContext::FINDERS[:xpath], xpath)
+      selector = "xpath: #{xpath}"
+      if element
+        region = get_region_object(selector, element)
+        elements_array << region
+      end
+    rescue Appium::Core::Error::NoSuchElementError => e
+      log("Appium Element with xpath: #{xpath} not found. Ignoring this xpath.")
+      log(e, on_debug: true)
+    end
+  end
+
+  def get_regions_by_ids(elements_array, ids)
+    ids.each do |id|
+      element = driver.find_element(Appium::Core::Base::SearchContext::FINDERS[:accessibility_id], id)
+      selector = "id: #{id}"
+      region = get_region_object(selector, element)
+      elements_array << region
+    rescue Appium::Core::Error::NoSuchElementError => e
+      log("Appium Element with id: #{id} not found. Ignoring this id.")
+      log(e, on_debug: true)
+    end
+  end
+
+  def get_regions_by_elements(elements_array, elements)
+    elements.each_with_index do |element, index|
+      class_name = element.attribute('class')
+      selector = "element: #{index} #{class_name}"
+      region = get_region_object(selector, element)
+      elements_array << region
+    rescue Appium::Core::Error::NoSuchElementError => e
+      log("Correct Element not passed at index #{index}")
+      log(e, on_debug: true)
+    end
+  end
+
+  def get_regions_by_location(elements_array, custom_locations)
+    custom_locations.each_with_index do |custom_location, index|
+      screen_width = metadata.device_screen_size['width']
+      screen_height = metadata.device_screen_size['height']
+      if custom_location.valid?(screen_height, screen_width)
+        region = {
+          selector: "custom ignore region: #{index}",
+          coOrdinates: {
+            top: custom_location.top,
+            bottom: custom_location.bottom,
+            left: custom_location.left,
+            right: custom_location.right
+          }
+        }
+        elements_array << region
+      else
+        log("Values passed in custom ignored region at index: #{index} are not valid")
+      end
+    end
+  end
+
+  def log(message, on_debug: false)
+    puts message if on_debug
+  end
+
+  def get_debug_url
+    debug_url
+  end
+
+  def get_device_name
+    ''
+  end
+
+  def _get_dir
+    dir_path = ENV['PERCY_TMP_DIR'] || nil
+    if dir_path
+      Pathname.new(dir_path).mkpath
+      return dir_path
+    end
+    Dir.mktmpdir
+  end
+
+  def _get_path(directory)
+    suffix = '.png'
+    prefix = 'percy-appium-'
+    file = Tempfile.new([prefix, suffix], directory)
+    file.close
+    file.path
+  end
+end

data/percy/providers/provider_resolver.rb

@@ -0,0 +1,17 @@
+# frozen_string_literal: true
+
+require_relative '../exceptions/exceptions'
+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)
+    end
+    raise UnknownProvider
+  end
+end

data/percy/screenshot.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+require_relative 'common/common'
+require_relative 'lib/app_percy'
+require_relative 'lib/percy_automate'
+require_relative 'lib/cli_wrapper'
+require_relative 'environment'
+
+def percy_screenshot(driver, name, **kwargs)
+  return nil unless CLIWrapper.percy_enabled?
+
+  app_percy = nil
+  provider_class = Environment.session_type == 'automate' ? PercyOnAutomate : AppPercy
+  app_percy = provider_class.new(driver)
+  app_percy.screenshot(name, **kwargs)
+rescue StandardError => e
+  CLIWrapper.post_failed_event(e.to_s)
+  log("Could not take screenshot \"#{name}\"")
+  raise e if app_percy && !app_percy.percy_options.ignore_errors
+
+  log(e, on_debug: true)
+  nil
+end

data/percy/version.rb

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

data/percy-appium-app.gemspec

@@ -0,0 +1,37 @@
+# coding: utf-8
+percy = File.expand_path('../percy', __FILE__)
+$LOAD_PATH.unshift(percy) unless $LOAD_PATH.include?(percy)
+require 'version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'percy-appium-app'
+  spec.version       = Percy::VERSION
+  spec.authors       = ['BroswerStack']
+  spec.email         = ['support@browserstack.com']
+  spec.summary       = %q{Percy visual testing for Ruby Appium Mobile Apps}
+  spec.description   = %q{}
+  spec.homepage      = ''
+  spec.license       = 'MIT'
+  spec.required_ruby_version = '>= 2.6.0'
+
+
+  spec.metadata = {
+    'bug_tracker_uri' => 'https://github.com/percy/percy-appium-ruby/issues',
+    'source_code_uri' => 'https://github.com/percy/percy-appium-ruby',
+  }
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['percy']
+
+  spec.add_runtime_dependency 'appium_lib', '~> 12.0'
+
+  spec.add_development_dependency 'bundler', '~> 2.4'
+  spec.add_development_dependency 'minitest', '~> 5.20'
+  spec.add_development_dependency 'rake', '~> 13.0'
+  spec.add_development_dependency 'percy-style', '~> 0.7.0'
+  spec.add_development_dependency 'webmock', '~> 3.18'
+  spec.add_development_dependency 'webrick', '~> 1.3'
+
+end

data/specs/android_metadata.rb

@@ -0,0 +1,79 @@
+# 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
+class TestAndroidMetadata < Minitest::Test
+  def setup
+    @mock_webdriver = Minitest::Mock.new
+    @mock_webdriver.expect(:capabilities, get_android_capabilities)
+    @android_metadata = AndroidMetadata.new(@mock_webdriver)
+  end
+
+  def test_android_execute_script
+    command = 'some dummy command'
+    output = 'some output'
+    @mock_webdriver.expect(:execute_script, output, [command])
+
+    assert_equal(output, @android_metadata.execute_script(command))
+    @mock_webdriver.verify
+  end
+
+  def test_viewport
+    viewport = { 'left' => 0, 'top' => 84, 'width' => 1440, 'height' => 2708 }
+    android_capabilities = get_android_capabilities
+    @mock_webdriver.expect(:capabilities, android_capabilities.merge('viewportRect' => viewport))
+
+    assert(viewport, @android_metadata.viewport)
+
+    @mock_webdriver.verify
+  end
+
+  def test_get_system_bars
+    system_bars = {
+      'statusBar' => { 'height' => 83 },
+      'navigationBar' => { 'height' => 44 }
+    }
+    android_capabilities = get_android_capabilities
+    session_id = 'session_id_123'
+    @mock_webdriver.expect(:session_id, session_id)
+    @mock_webdriver.expect(:session_id, session_id)
+    @mock_webdriver.expect(:capabilities, android_capabilities.merge('viewportRect' => nil))
+    @mock_webdriver.expect(:get_system_bars, system_bars)
+
+    assert(system_bars, @android_metadata.get_system_bars)
+    @mock_webdriver.verify
+  end
+
+  def test_status_bar
+    @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_get_system_bars = { 'statusBar' => { 'height' => 1 } }
+    @android_metadata.stub(:get_system_bars, mock_get_system_bars) do
+      assert_equal(0, @android_metadata.status_bar_height)
+    end
+  end
+
+  def test_navigation_bar
+    @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_get_system_bars = { 'navigationBar' => { 'height' => 1 } }
+    @android_metadata.stub(:get_system_bars, mock_get_system_bars) do
+      assert_equal(0, @android_metadata.navigation_bar_height)
+    end
+  end
+
+  def test_scale_factor
+    assert_equal(1, @android_metadata.scale_factor)
+  end
+end

data/specs/app_automate.rb

@@ -0,0 +1,124 @@
+# 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
+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)
+  end
+
+  def test_app_automate_get_debug_url
+    @app_automate.set_debug_url('deviceName' => 'Google Pixel 4', 'osVersion' => '12.0', 'buildHash' => 'abc',
+                                'sessionHash' => 'def')
+    debug_url = @app_automate.get_debug_url
+    assert_equal 'https://app-automate.browserstack.com/dashboard/v2/builds/abc/sessions/def', debug_url
+  end
+
+  def test_app_automate_supports_with_correct_url
+    app_automate_session = 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')
+    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')
+    assert_equal true, app_automate_session
+    ENV['AA_DOMAIN'] = nil
+  end
+
+  def test_app_automate_execute_percy_screenshot_begin
+    @mock_webdriver.expect(:execute_script, '{}', [String])
+    assert_empty @app_automate.execute_percy_screenshot_begin('Screebshot 1')
+    @mock_webdriver.verify
+  end
+
+  def test_app_automate_execute_percy_screenshot_end
+    @mock_webdriver.expect(:execute_script, '{}', [String])
+    assert_equal '{}',
+                 @app_automate.execute_percy_screenshot_end('Screenshot 1', COMPARISON_RESPONSE['link'], 'success')
+    @mock_webdriver.verify
+  end
+
+  def test_app_automate_execute_percy_screenshot
+    @mock_webdriver.expect(:execute_script, '{"result": "result"}', [String])
+    @app_automate.execute_percy_screenshot(1080, 'singlepage', 5)
+    @mock_webdriver.verify
+  end
+
+  def test_execute_percy_screenshot_end_throws_error
+    @mock_webdriver.expect(:execute_script, proc { raise 'SomeException' }, [String])
+    @app_automate.execute_percy_screenshot_end('Screenshot 1', 'snapshot-url', 'success')
+    @mock_webdriver.verify
+  end
+
+  def test_execute_percy_screenshot_end
+    @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.screenshot('name')
+        end
+      end
+    end
+  end
+
+  def test_get_tiles
+    # Mocking Metadata's session_id method
+    metadata_mock = Minitest::Mock.new
+    metadata_mock.expect(:session_id, 'session_id_123')
+
+    # Mocking 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
+      define_method(:session_id) do
+        metadata_mock.session_id
+      end
+    end
+
+    AndroidMetadata.class_eval do
+      define_method(:device_screen_size) do
+        android_metadata_mock.device_screen_size
+      end
+
+      define_method(:navigation_bar_height) do
+        android_metadata_mock.navigation_bar_height
+      end
+
+      define_method(:status_bar_height) do
+        android_metadata_mock.status_bar_height
+      end
+    end
+
+    @app_automate.stub(:execute_percy_screenshot, {
+                         'result' => '[{"sha":"sha-25568755","status_bar":null,"nav_bar":null,"header_height":120,"footer_height":80,"index":0}]'
+                       }) do
+      result = @app_automate._get_tiles(fullpage: true)[0]
+      assert_equal('sha', result.sha)
+      assert_equal(100, result.status_bar_height)
+      assert_equal(150, result.nav_bar_height)
+      assert_equal(120, result.header_height)
+      assert_equal(80, result.footer_height)
+    end
+  end
+end