aaet 0.1.0

data/lib/aaet/common/locators.rb

@@ -0,0 +1,180 @@
+module Aaet
+  class Locators
+
+    def activity
+      count = 0
+      begin
+        JSON.parse(`curl -s #{caps_url}/session/#{driver.session_id}/appium/device/current_activity`)['value']
+      rescue
+        count+=1
+        return if count > 3
+        retry
+      end
+    end
+
+    def get_center(element)
+      location   = element.location
+      location_x = location.x.to_f
+      location_y = location.y.to_f
+      size = element.size
+      size_width  = size.width.to_f
+      size_height = size.height.to_f
+      x = location_x + (size_width / 2.0)
+      y = location_y + (size_height / 2.0)
+      {x: x, y: y}
+    end
+    
+    def element_center(location, size)
+      location_x = location.x.to_f
+      location_y = location.y.to_f
+      size_width  = size.width.to_f
+      size_height = size.height.to_f
+      x = location_x + (size_width / 2.0)
+      y = location_y + (size_height / 2.0)
+      {x: x, y: y}
+    end
+
+    def long_press element
+      center = get_center(element)
+      center.merge!(fingers: 1, duration: 550)
+      action = Appium::TouchAction.new.long_press center
+      action.release.perform
+    end
+
+    def press coords
+      coords.merge!(fingers: 1, duration: 550)
+      action = Appium::TouchAction.new.long_press coords
+      begin action.release.perform rescue nil end
+    end
+
+    def tap args = {}
+      begin
+        Appium::TouchAction.new.tap(args).release.perform
+      rescue
+        nil
+      end
+    end
+
+    def tap2 coords
+      begin
+        Appium::TouchAction.new.tap(coords).release.perform
+      rescue
+        nil
+      end
+    end
+
+    def random_tap
+      x = rand(0..@window_size[0])
+      y = rand(0..@window_size[1])
+      puts "\nRandom Tap Location: { x: #{x}, y: #{y} }\n".yellow
+      tap({:x=>x, :y=>y})
+    end
+
+    def pull_to_refresh
+      size = get_window_size
+      start_x = size[:width] / 2
+      start_y = size[:height] / 2
+      end_x = size[:width] / 2
+      end_y = size[:height] - 100
+      Appium::TouchAction.new.press({x:start_x,y:start_y}).wait(200).move_to({x:end_x,y:end_y}).release.perform
+    end
+
+    def get_window_size
+      window_size.to_h
+    end
+
+    def swipe_down
+      size = @window_size
+      start_x = size[0] / 2
+      start_y = size[1] / 2
+      end_x = size[0] / 2
+      end_y = size[1] - 200
+      Appium::TouchAction.new.press({x:start_x,y:start_y}).wait(200).move_to({x:end_x,y:end_y}).release.perform
+    end
+
+    def swipe_up
+      size = @window_size
+      start_x = size[0] / 2
+      start_y = size[1] / 2
+      end_x = size[0] / 2
+      end_y = 100
+      Appium::TouchAction.new.press({x:start_x,y:start_y}).wait(200).move_to({x:end_x,y:end_y}).release.perform
+    end
+
+    def swipe_left
+      size = @window_size
+      start_x = (size[0] - 60).to_f
+      start_y = (size[1] / 2).to_f
+      end_x = 60.to_f
+      end_y = (size[1] / 2).to_f
+      Appium::TouchAction.new.press({x:start_x,y:start_y}).wait(200).move_to({x:end_x,y:end_y}).release.perform
+      #swipe({start_x:63,end_y:326})
+    end
+
+    def swipe_right
+      size = @window_size
+      start_x = 60.to_f
+      start_y = (size[1] / 2).to_f
+      end_x = (size[0] - 60).to_f
+      end_y = (size[1] / 2).to_f
+      Appium::TouchAction.new.press({x:start_x,y:start_y}).wait(200).move_to({x:end_x,y:end_y}).release.perform
+    end
+
+    def fe locator
+      begin
+        find_element(locator)
+      rescue
+        nil
+      end
+    end
+
+    def fa locator
+      begin
+        find_elements(locator)
+      rescue
+        []
+      end
+    end
+
+    def get_text string
+      begin
+        text string
+      rescue
+        nil
+      end
+    end
+
+    def displayed? locator
+      begin
+        fe(locator).displayed?
+      rescue
+        false
+      end
+    end
+
+    def click locator, *optional
+      begin
+        locator.click
+      rescue
+        nil
+      end
+    end
+
+    def type string
+      begin
+        driver.keyboard.send_keys string
+      rescue
+        nil
+      end
+    end
+
+    ###For Login Method
+    def enter locator, string
+      begin
+        locator.send_keys string
+      rescue
+        nil
+      end
+    end
+  end
+end

data/lib/aaet/common/redis.rb

@@ -0,0 +1,108 @@
+module Aaet
+  class Redis
+
+    attr_accessor :redis, :process
+
+    def initialize process
+      self.redis = Redic.new
+      self.process = process
+      update_list("crashed", false)
+    end
+
+    def del_list list
+      redis.call "DEL", "#{list}-#{process}" rescue nil
+    end
+
+    def update_applitools list, body
+      redis.call "LPUSH", list, JSON.generate(body)
+    end
+
+    def update_list list, body
+      redis.call "LPUSH", "#{list}-#{process}", JSON.generate(body)
+    end
+
+    def activity_exists? act
+      activities.any? { |a| a.include? act }
+    end
+
+    def remove_activity activity
+      redis.call "LREM", "activities", -1, activity
+    end
+
+    def activities
+      redis.call("LRANGE", "activities", 0, -1)
+    end
+
+    def found_activities
+      redis.call("LRANGE", "found_activities-#{process}", 0, -1)
+    end
+
+    def found_activity_exists? act
+      found_activities.any? { |a| a.include? act }
+    end
+
+    def add_found_activity act
+      redis.call "LPUSH", "found_activities-#{process}", act
+    end
+
+    def update_activity_count act
+      unless found_activity_exists? act
+        checkmark = "\u2713"
+        puts ""
+        puts "\nNew Activity Found! #{checkmark}".green
+        add_found_activity act
+        remaining = (activities.count - found_activities.count)
+        puts "Remaining Activities: #{remaining}\n"
+        puts ""
+      end
+    end
+
+    def get_list list
+      redis_list = redis.call("LRANGE", "#{list}-#{process}", 0, -1).map { |x| JSON.parse(x) }.uniq.flatten rescue []
+      unless redis_list.empty?
+        redis_list = symbolize(redis_list)
+      end
+      redis_list
+    end
+
+    def symbolize(obj)
+      return obj.reduce({}) do |memo, (k, v)|
+        memo.tap { |m| m[k.to_sym] = symbolize(v) }
+      end if obj.is_a? Hash
+
+      return obj.reduce([]) do |memo, v|
+        memo << symbolize(v); memo
+      end if obj.is_a? Array
+
+      obj
+    end
+
+    def list_includes_value list, value
+      redis.call("LRANGE", "#{list}-#{process}", 0, -1).any? { |a| a.include? value }
+    end
+
+    def list_includes_applitools_value list, value
+      redis.call("LRANGE", list, 0, -1).any? { |a| a.include? value }
+    end
+
+    def app_crashed boolean
+      redis.call "LPUSH", "crashed-#{process}", boolean
+    end
+
+    def lpop list
+      redis.call "LPOP", "#{list}-#{process}"
+    end
+
+    def hincr(key, field)
+      redis.call("HINCRBY", "#{key}-#{process}", field, 1)
+    end
+
+    def hset(key, field, value)
+      redis.call("HSET", "#{key}-#{process}", field, value)
+    end
+
+    def hget(key, field)
+      redis.call("HGET", "#{key}-#{process}", field)
+    end
+  end
+end

data/lib/aaet/ios/ios.rb

@@ -0,0 +1,18 @@
+#iOS Placeholder
+module Aaet
+  class Ios
+
+    # include Appium::Ios
+    # include Appium::Common
+    # include Appium::Device
+
+    def keyboard_open?
+      begin
+        #driver.driver.manage.timeouts.implicit_wait = 0.1
+        fe({xpath: '//UIAKeyboard'}).displayed?
+      rescue Selenium::WebDriver::Error::NoSuchElementError
+        false
+      end
+    end
+  end
+end

data/lib/aaet/ios/parser.rb

@@ -0,0 +1 @@
+#iOS Placeholder

data/lib/version.rb

@@ -0,0 +1,3 @@
+module Aaet
+  VERSION = "0.1.0"
+end

data/run.rb

@@ -0,0 +1,294 @@
+require_relative 'lib/aaet'
+require 'parallel'
+require_relative 'generate_reports'
+require_relative 'setup/common_setup_methods'
+require_relative "setup/android_setup_methods"
+require_relative "setup/ios_setup_methods"
+require 'pry'
+require 'uri'
+
+class Executer < ReportBuilder
+
+  attr_accessor :program_opts, :appium_reset, :platform_setup, :appium_arg, :uuid_arg, :setup
+  attr_writer :run
+
+  def initialize settings
+    self.program_opts = settings
+    generate_instance_variables nil, settings
+    if caps_platform == 'android'
+      self.platform_setup = AndroidSetup.new settings
+      avd = caps_avd rescue nil
+      uuid = caps_udid rescue nil
+      if avd
+        platform_setup.check_emulator caps_avd
+        self.appium_arg = "--avd #{caps_avd}"
+      elsif uuid
+        platform_setup.check_uuid caps_udid
+        self.appium_arg = "--udid #{caps_udid}"
+      end
+    elsif caps_platform == 'ios'
+      #placeholder for iOS
+      self.platform_setup = IosSetup.new settings
+    end
+
+    if options[:resetAppium]
+      self.appium_reset = nil
+    else
+      self.appium_reset = '--no-reset'
+    end
+
+    if options_debug
+      self.instance_variables.each { |var| puts "#{var}: #{self.instance_variable_get(var)}" }
+    end
+    self.setup = CommonSetup.new
+  end
+
+  def generate_instance_variables(parent, hash)
+    #turn options/settings nested hash into instance variables
+    hash.each do |key, value|
+      if value.is_a?(Hash)
+        generate_instance_variables(key, value)
+        self.class.send(:attr_accessor, key.to_sym)
+        self.instance_variable_set("@#{key}", value)
+      else
+        if parent.nil?
+          self.class.send(:attr_accessor, "#{key}".to_sym)
+          self.instance_variable_set("@#{key}", value)
+        else
+          self.class.send(:attr_accessor, "#{parent}_#{key}".to_sym)
+          self.instance_variable_set("@#{parent}_#{key}", value)
+        end
+      end
+    end
+  end
+
+  def driver_alive?
+    @run.current_activity["message"] != "A session is either terminated or not started"
+  end
+
+  def kill_everything
+    if caps_platform == "android" and !options_cloud
+      Process.kill("HUP", program_opts[:logcat_pid])
+      #binding.pry
+      setup.kill_processes "'#{@uuid} logcat'"
+      %x(adb -s #{@uuid} shell settings put global policy_control null*) #put status bar back...
+      system("adb -s #{@uuid} emu kill") if options_emulator and !options_keepEmulatorAlive
+      sleep 1
+    end
+    driver.quit rescue nil
+    unless options_cloud
+      pid = Process.getpgid(Process.pid)
+      Signal.trap('TERM') { Process.kill('TERM', -pid); exit }
+      Signal.trap('INT' ) { Process.kill('INT',  -pid); exit }
+      Process.kill("HUP", program_opts[:appium_pid])
+    end
+  end
+
+  def runner time
+    require 'timeout'
+    begin
+      Timeout.timeout(time) { go }
+    rescue Timeout::Error
+      puts "\n#{time} Seconds Exceeded!!!\nKilling Driver for #{@uuid}...".red
+    end
+  end
+
+  def force_device_orientation(orientation)
+    desired_orientation = orientation.downcase.to_sym
+    begin
+      if desired_orientation != driver.orientation.to_sym
+        puts "Current orientation: #{driver.orientation.to_sym}"
+        puts "Setting device to orientation: #{desired_orientation}"
+        driver.rotate desired_orientation
+      end
+    rescue
+      puts "\n#{@uuid}: Cannot rotate device to desired orientation: #{desired_orientation}".red
+      puts "Keeping Current orientation: #{driver.orientation}\n".yellow
+    end
+    driver.orientation.to_s.upcase
+  end
+
+  def initialize_driver
+    if options_cloud #only do once for crawler, reply will have these settings already.
+      local_app_path = caps[:caps][:app]
+      caps[:caps][:app] = caps_cloud_app
+      if ["crawler", "monkey"].include? options[:mode]
+        cloud_url = caps[:appium_lib][:server_url].insert(7, "#{cloud_user}:#{cloud_key}")
+        caps[:caps][:url] = cloud_url
+        caps[:appium_lib][:server_url] = cloud_url
+      end
+    else
+      old_url = URI(caps[:caps][:url])
+      old_port = old_url.port.to_s
+      new_url = old_url.to_s.gsub(old_port, program_opts[:appium_port].to_s) #replace port with parallel process port
+      caps[:caps][:url] = new_url
+      caps[:appium_lib][:server_url] = new_url
+    end
+    Appium::Driver.new(caps, true).start_driver
+    Appium.promote_appium_methods Object
+    caps[:caps][:app] = local_app_path if options_cloud #set app back to local app file for activity parsing later...
+    sleep 5
+    #update program data...
+    @uuid = driver.capabilities["deviceUDID"]
+    caps[:caps][:udid] = @uuid
+    program_opts[:app_and_device_data] = platform_setup.app_and_device_data @uuid
+    @resolution = driver.capabilities["deviceScreenSize"]
+    program_opts[:app_and_device_data][:device][:resolution] = @resolution
+    program_opts[:app_and_device_data][:activities] = program_opts[:activities] #will need to figure out how to parse iOS activities
+  end
+
+  def generate_output_dir
+    dir_array = [
+        run_time,
+        "#{program_opts[:app_and_device_data][:app_package]}-v#{program_opts[:app_and_device_data][:app_version]}",
+        @resolution,
+        "#{@uuid}-#{process}",
+        program_opts[:app_and_device_data][:device][:os],
+        caps_language,
+        @orientation
+    ]
+    dir = setup.create_directories dir_array
+    program_opts[:output_dir] = dir
+  end
+
+  def go
+    unless options_cloud
+      appium_info = setup.start_appium_server(program_opts[:process], appium_reset, appium_arg, run_time)
+      program_opts[:appium_pid] = appium_info[:appium_pid]
+      program_opts[:appium_port] = appium_info[:appium_port]
+      program_opts[:appium_log] = appium_info[:appium_log]
+    end
+    initialize_driver
+    caps[:caps][:desired_orientation] = caps[:caps][:orientation] #set this ignored capabilitiy for reporting later...
+    @orientation = force_device_orientation(caps[:caps][:orientation]) #setting in caps does not always change orientation so I'm forcing it...
+    options[:orientation] = @orientation
+    caps[:caps][:orientation] = @orientation
+    generate_output_dir
+    @run = Aaet::Runner.new program_opts
+    unless options_cloud
+      if caps_platform == 'android'
+        program_opts[:logcat_pid] = @run.monitor_log_start
+      elsif caps_platform == 'ios'
+        #placeholder for iOS
+        #TODO: do something with iOS...
+      end
+    end
+    begin
+      if ["crawler", "monkey"].include? options_mode
+        loop { @run.instance_eval(options_mode) }
+      else
+        @run.instance_eval(options_mode)
+      end
+    rescue Interrupt
+      puts "\nGot Interrupted. Stopping...".red
+    ensure
+      kill_everything
+      if options_mode == "crawler"
+        ReportBuilder.new(options_translate, process, program_opts).generate_reports
+      end
+    end
+  end
+end
+
+def crawler options
+  setup = CommonSetup.new
+  setup.prep_environment
+  settings = setup.format_options options
+  settings[:run_time] = Time.now.strftime("%Y.%m.%d.%H.%M")
+  output_dir_base = setup.create_output_directory "output", settings[:run_time]
+  settings[:output_dir_base] = output_dir_base
+
+  if options[:applitools] and settings[:config][:applitools][0][:key].empty?
+    if ENV['APPLITOOLS_API_KEY'].nil?
+      puts "\nYou must provide and Applitools Key in the config file or add APPLITOOLS_API_KEY environment variable\n".red
+      abort
+    else
+      settings[:config][:applitools][0][:key] = ENV['APPLITOOLS_API_KEY']
+    end
+  end
+
+  #TODO: https://github.com/celluloid/celluloid #maybe look into replacing parallel gem with this...
+  Parallel.each(settings[:caps], in_processes: settings[:caps].count, interrupt_signal: 'TERM') do |caps|
+    settings[:process] = Parallel.worker_number #set the current process running...
+    settings[:config][:caps] = caps
+    if settings[:options][:bothOrientations] and settings[:caps].count > 1
+      if settings[:process].even?
+        settings[:config][:caps][:caps][:orientation] = "PORTRAIT"
+      else
+        settings[:config][:caps][:caps][:orientation] = "LANDSCAPE"
+      end
+    end
+    settings.delete :caps
+    puts "Testing Languages: #{settings[:options][:language]}"
+    settings[:options][:language].shuffle.each do |language|
+      puts "Running Language: #{language}"
+      settings[:config][:caps][:caps][:language] = language
+      Executer.new(settings).runner(settings[:options][:seconds])
+      puts "Finished language: #{language}\n"
+    end
+  end
+end
+
+def monkey options
+  setup = CommonSetup.new
+  setup.prep_environment
+  settings = setup.format_options options
+  settings[:run_time] = Time.now.strftime("%Y.%m.%d.%H.%M")
+  output_dir_base = setup.create_output_directory "output", settings[:run_time]
+  settings[:output_dir_base] = output_dir_base
+
+  Parallel.each(settings[:caps], in_processes: settings[:caps].count, interrupt_signal: 'TERM') do |caps|
+    settings[:process] = Parallel.worker_number #set the current process running...
+    settings[:config][:caps] = caps
+    if settings[:options][:bothOrientations] and settings[:caps].count > 1
+      if settings[:process].even?
+        settings[:config][:caps][:caps][:orientation] = "PORTRAIT"
+      else
+        settings[:config][:caps][:caps][:orientation] = "LANDSCAPE"
+      end
+    end
+    settings.delete :caps
+    settings[:config][:caps][:caps][:language] = settings[:options][:language]
+    Executer.new(settings).runner(settings[:options][:seconds])
+  end
+end
+
+def replay options
+  puts "\nREPLAY Mode is Experimental. Not 100% to work every time...\n".yellow
+  #TODO: create a report with images highlighting each step clicked with ImageMagik in case replay does not work.
+
+  setup = CommonSetup.new
+  setup.prep_environment
+
+  config = TomlRB.load_file(options[:config], symbolize_keys: true)
+  package_name = config[:caps][:appPackage]
+  file = setup.select_run(package_name)
+  last_run = setup.symbolize(eval(open(file).read))
+
+  if options[:applitools] and last_run[:options][:config][:applitools][0][:key].empty?
+    if ENV['APPLITOOLS_API_KEY'].nil?
+      puts "\nYou must provide and Applitools Key in the config file or add APPLITOOLS_API_KEY environment variable\n".red
+      abort
+    else
+      settings[:config][:applitools][0][:key] = ENV['APPLITOOLS_API_KEY']
+    end
+  end
+
+  #override last crawl run options with current replay options.
+  options.each { |k,v| last_run[:options][:options][k] = v }
+
+  setup.load_activities last_run[:activities]
+
+  settings = {
+      activities: last_run[:activities],
+      options: last_run[:options][:options],
+      config: last_run[:options][:config]
+  }
+  settings[:run_time] = Time.now.strftime("%Y.%m.%d.%H.%M")
+  output_dir_base = setup.create_output_directory "output", settings[:run_time]
+  settings[:output_dir_base] = output_dir_base
+  settings[:last_run_steps] = last_run[:data]
+  settings[:process] = 0
+
+  Executer.new(settings).runner(settings[:options][:seconds])
+end