kraken-mobile 1.0.0

data/lib/kraken-mobile/models/device.rb

@@ -0,0 +1,32 @@
+module KrakenMobile
+	module Models
+		class Device
+
+      #-------------------------------
+      # Fields
+      #-------------------------------
+			attr_accessor :id
+			attr_accessor :model
+      attr_accessor :position
+      attr_accessor :config
+
+      #-------------------------------
+      # Constructors
+      #-------------------------------
+			def initialize(id, model, position, config = {})
+				@id = id
+				@model = model
+        @position = position
+        @config = config
+			end
+
+      #-------------------------------
+      # Helpers
+      #-------------------------------
+			def screenshot_prefix
+				@id.gsub('.', '_').gsub(/:(.*)/, '').to_s + '_'
+			end
+
+		end
+	end
+end

data/lib/kraken-mobile/protocols/file_protocol.rb

@@ -0,0 +1,126 @@
+require 'kraken-mobile/helpers/devices_helper/manager'
+require 'kraken-mobile/constants'
+require 'calabash-android/operations'
+require 'digest'
+
+module KrakenMobile
+  module Protocol
+    module FileProtocol
+      def readSignal(channel, content, timeout)
+        devices_helper = DevicesHelper::Manager.new({runner: ENV["RUNNER"], config_path: ENV["CONFIG_PATH"]}).device_helper
+        device_id = channel_to_device_id(channel)
+        Timeout::timeout(timeout, RuntimeError) do
+          sleep(1) until devices_helper.read_file_content(KrakenMobile::Constants::DEVICE_INBOX_NAME, device_id) == content
+        end
+      end
+
+      def readLastSignal(channel)
+        devices_helper = DevicesHelper::Manager.new({runner: ENV["RUNNER"], config_path: ENV["CONFIG_PATH"]}).device_helper
+        device_id = channel_to_device_id(channel)
+        devices_helper.read_file_content(KrakenMobile::Constants::DEVICE_INBOX_NAME, device_id)
+      end
+
+      def readAnySignal(channel, timeout)
+        devices_helper = DevicesHelper::Manager.new({runner: ENV["RUNNER"], config_path: ENV["CONFIG_PATH"]}).device_helper
+        device_id = channel_to_device_id(channel)
+        Timeout::timeout(timeout, RuntimeError) do
+          sleep(1) until devices_helper.read_file_content(KrakenMobile::Constants::DEVICE_INBOX_NAME, device_id) != ""
+        end
+      end
+
+      def readSignalWithKeyworkd(channel, keyword, timeout)
+        devices_helper = DevicesHelper::Manager.new({runner: ENV["RUNNER"], config_path: ENV["CONFIG_PATH"]}).device_helper
+        device_id = channel_to_device_id(channel)
+        Timeout::timeout(timeout, RuntimeError) do
+          sleep(1) until devices_helper.read_file_content(KrakenMobile::Constants::DEVICE_INBOX_NAME, device_id).include?(keyword)
+          return devices_helper.read_file_content(KrakenMobile::Constants::DEVICE_INBOX_NAME, device_id)
+        end
+      end
+
+      def writeSignal(channel, content)
+        devices_helper = DevicesHelper::Manager.new({runner: ENV["RUNNER"], config_path: ENV["CONFIG_PATH"]}).device_helper
+        device_id = channel_to_device_id(channel)
+        devices_helper.write_content_to_file(content, KrakenMobile::Constants::DEVICE_INBOX_NAME, device_id)
+      end
+
+      def writeSignalToAll(content)
+        devices_manager = DevicesHelper::Manager.new({runner: ENV["RUNNER"], config_path: ENV["CONFIG_PATH"]})
+        devices_manager.connected_devices.each do |device|
+          devices_manager.device_helper.write_content_to_file(content, KrakenMobile::Constants::DEVICE_INBOX_NAME, device.id)
+        end
+      end
+
+      def writeSignalToAnyDevice(content)
+        devices_manager = DevicesHelper::Manager.new({runner: ENV["RUNNER"], config_path: ENV["CONFIG_PATH"]})
+        device = devices_manager.connected_devices.sample
+        devices_manager.device_helper.write_content_to_file(content, KrakenMobile::Constants::DEVICE_INBOX_NAME, device.id)
+        device
+      end
+
+      def start_setup channel, scenario
+        devices_manager = DevicesHelper::Manager.new({runner: ENV["RUNNER"], config_path: ENV["CONFIG_PATH"]})
+        device_id = channel_to_device_id(channel)
+        scenario_id = build_scenario_id(scenario)
+        devices_manager.device_helper.write_content_to_file "ready_#{scenario_id}", KrakenMobile::Constants::KRAKEN_CONFIGURATION_FILE_NAME, device_id
+        ordered_tags = ordered_feature_tags scenario
+        while true
+          compare_criteria = devices_manager.connected_devices.count >= ordered_tags.count ? ordered_tags.count : devices_manager.connected_devices.count
+          break if devices_ready_start(devices_manager, scenario_id).count >= compare_criteria
+          sleep(1)
+        end
+      end
+
+      def end_setup channel, scenario
+        devices_manager = DevicesHelper::Manager.new({runner: ENV["RUNNER"], config_path: ENV["CONFIG_PATH"]})
+        device_id = channel_to_device_id(channel)
+        scenario_id = build_scenario_id(scenario)
+        devices_manager.device_helper.write_content_to_file "end_#{scenario_id}", KrakenMobile::Constants::KRAKEN_CONFIGURATION_FILE_NAME, device_id
+        ordered_tags = ordered_feature_tags scenario
+        while true
+          compare_criteria = devices_manager.connected_devices.count >= ordered_tags.count ? ordered_tags.count : devices_manager.connected_devices.count
+          break if devices_ready_to_finish(devices_manager, scenario_id).count >= compare_criteria
+          sleep(1)
+        end
+      end
+
+      # helpers
+      def build_scenario_id scenario
+        location = scenario.location.to_s
+        index_of_line_number_start = location.index(":")
+        real_location = location[0..index_of_line_number_start-1]
+        Digest::SHA256.hexdigest(real_location)
+      end
+
+      def feature_tags scenario
+        tag_objects = scenario.feature.children.map { |e| e.tags if e.tags  }.compact
+        tags = []
+        tag_objects.each do |tag_object|
+          names = tag_object.map { |tag| tag.name if tag.name }
+          tags.concat names
+        end
+        tags.uniq.select{ |tag| tag.start_with? "@user" }.sort
+      end
+
+      def ordered_feature_tags scenario
+        tags = feature_tags scenario
+        ordered_tags = []
+        tags.count.times do |index|
+          if tags[index].include? "@user#{index+1}"
+            ordered_tags << tags[index]
+          else
+            break
+          end
+        end
+        ordered_tags
+      end
+
+      def devices_ready_start devices_manager, scenario_id
+        devices_manager.connected_devices.select { |device| devices_manager.device_helper.read_file_content(KrakenMobile::Constants::KRAKEN_CONFIGURATION_FILE_NAME, device.id) == "ready_#{scenario_id}" }
+      end
+
+      def devices_ready_to_finish devices_manager, scenario_id
+        devices_manager.connected_devices.select { |device| devices_manager.device_helper.read_file_content(KrakenMobile::Constants::KRAKEN_CONFIGURATION_FILE_NAME, device.id) == "end_#{scenario_id}" }
+      end
+    end
+  end
+end

data/lib/kraken-mobile/runners/calabash/android/android_runner.rb

@@ -0,0 +1,130 @@
+require 'kraken-mobile/helpers/devices_helper/manager'
+require 'kraken-mobile/helpers/feature_grouper'
+require 'kraken-mobile/helpers/reporter'
+require 'kraken-mobile/runners/runner'
+require 'kraken-mobile/constants'
+require 'kraken-mobile/runners/calabash/android/apk_signer.rb'
+require 'parallel'
+require 'digest'
+require 'fileutils'
+require 'erb'
+
+module KrakenMobile
+	module Runner
+		class CalabashAndroidRunner < KrakenRunner
+			BASE_COMMAND = "calabash-android run"
+
+      def initialize(options)
+        super(options)
+        default_runner = KrakenMobile::Constants::CALABASH_ANDROID
+				@devices_manager = DevicesHelper::Manager.new({runner: default_runner, config_path: @options[:config_path]})
+        @adb_helper = @devices_manager.device_helper
+        @execution_id = Digest::SHA256.hexdigest("#{Time.now.to_f}")
+        @reporter = KrakenMobile::Reporter.new(@execution_id, options)
+			end
+
+      #-------------------------------
+      # Hooks
+      #-------------------------------
+      def before_all
+        Dir.mkdir(KrakenMobile::Constants::REPORT_PATH) unless File.exists?(KrakenMobile::Constants::REPORT_PATH)
+        Dir.mkdir("#{KrakenMobile::Constants::REPORT_PATH}/#{@execution_id}")
+        devices_id_list = []
+        @devices_manager.connected_devices.each_with_index do |device, index|
+          height, width = @adb_helper.screen_size device.id
+          sdk_version = @adb_helper.sdk_version device.id
+          devices_id_list << { user: (index+1), id: device.id, model: device.model, screen_height: height, screen_width: width, sdk: sdk_version }
+          Dir.mkdir("#{KrakenMobile::Constants::REPORT_PATH}/#{@execution_id}/#{device.id}")
+        end
+        file = open("#{KrakenMobile::Constants::REPORT_PATH}/#{@execution_id}/#{KrakenMobile::Constants::REPORT_DEVICES_FILE_NAME}.json", 'w')
+        file.puts(devices_id_list.to_json)
+        file.close
+        source_dir = File.expand_path("../../../../../../reporter/assets/", __FILE__)
+        FileUtils.cp_r(source_dir, "#{KrakenMobile::Constants::REPORT_PATH}/#{@execution_id}/")
+      end
+
+      def before_execution process_number
+        device = @devices_manager.connected_devices[process_number]
+        raise "There is no device for process #{process_number}" unless device
+        @adb_helper.create_file KrakenMobile::Constants::DEVICE_INBOX_NAME, device.id
+        @adb_helper.create_file KrakenMobile::Constants::KRAKEN_CONFIGURATION_FILE_NAME, device.id
+      end
+
+      def after_execution process_number
+        device = @devices_manager.connected_devices[process_number]
+        raise "There is no device for process #{process_number}" unless device
+        @adb_helper.delete_file KrakenMobile::Constants::DEVICE_INBOX_NAME, device.id
+        @adb_helper.delete_file KrakenMobile::Constants::KRAKEN_CONFIGURATION_FILE_NAME, device.id
+      end
+
+      #-------------------------------
+      # Execution
+      #-------------------------------
+      def run_in_parallel
+        ensure_apks_signed
+        before_all
+        feature_folder = @options[:feature_folder]
+        devices_connected = @devices_manager.connected_devices
+        groups = FeatureGrouper.file_groups(feature_folder, devices_connected.size)
+        threads = groups.size
+        puts "Running with #{threads} threads: #{groups}"
+        test_results = Parallel.map_with_index(
+          groups,
+          :in_threads => threads,
+          :start => lambda { |group, index|
+            before_execution(index)
+          },
+          :finish => lambda { |group, index, _|
+            after_execution(index)
+          }
+        ) do |group, index|
+          run_tests(group, index, @options)
+          @reporter.generate_device_report devices_connected[index]
+        end
+        @reporter.generate_general_report
+      end
+
+      def run_tests(test_files, process_number, options)
+				command = build_execution_command(process_number, options[:apk_path], test_files)
+				puts "\n****** PROCESS #{process_number} STARTED ******\n\n"
+				@command_helper.execute_command(process_number, command)
+				puts "\n****** PROCESS #{process_number} COMPLETED ******\n\n"
+			end
+
+      #-------------------------------
+      # Helpers
+      #-------------------------------
+			def build_execution_command process_number, general_apk, test_files
+        device = @devices_manager.connected_devices[process_number]
+        raise "Theres not a device for process #{process_number}" unless device
+        apk_path = device.config["apk_path"] ? device.config["apk_path"] : general_apk
+        raise "Invalid apk path" unless apk_path
+        cucumber_options = "--format pretty --format json -o #{KrakenMobile::Constants::REPORT_PATH}/#{@execution_id}/#{device.id}/#{KrakenMobile::Constants::REPORT_FILE_NAME}.json"
+				execution_command = @command_helper.build_command [BASE_COMMAND, apk_path, cucumber_options, *test_files, "--tags @user#{device.position}"]
+				env_variables = {
+					AUTOTEST: '1',
+					ADB_DEVICE_ARG: device.id,
+					DEVICE_INFO: device.model,
+					TEST_PROCESS_NUMBER: (process_number+1).to_s,
+					SCREENSHOT_PATH: "#{KrakenMobile::Constants::REPORT_PATH}/#{@execution_id}/#{device.id}/#{device.screenshot_prefix}",
+          PROTOCOL: @options[:protocol],
+          RUNNER: KrakenMobile::Constants::CALABASH_ANDROID
+				}
+        env_variables[:CONFIG_PATH] = @options[:config_path] if @options[:config_path]
+        env_variables[:PROPERTIES_PATH] = @options[:properties_path] if @options[:properties_path]
+				exports = @command_helper.build_export_env_command env_variables
+				exports + @command_helper.terminal_command_separator + execution_command
+			end
+
+      def ensure_apks_signed
+        checked_apks = {}
+        @devices_manager.connected_devices.each do |device|
+          apk_path = device.config["apk_path"] ? device.config["apk_path"] : @options[:apk_path]
+          next if checked_apks[apk_path] # Dont check already checked apks
+          raise "APK is not signed, you can resign the app by running kraken-mobile resign #{apk_path}" if !KrakenMobile::CalabashAndroid::ApkSigner.is_apk_signed? apk_path
+          checked_apks[apk_path] = apk_path
+        end
+      end
+		end
+	end
+end

data/lib/kraken-mobile/runners/calabash/android/apk_signer.rb

@@ -0,0 +1,14 @@
+require 'calabash-android/helpers'
+require 'calabash-android/java_keystore'
+
+module KrakenMobile
+  module CalabashAndroid
+    module ApkSigner
+      def self.is_apk_signed? apk_path
+        keystores = JavaKeystore.get_keystores
+        apk_fingerprint = fingerprint_from_apk(apk_path)
+        keystores.select { |k| k.fingerprint == apk_fingerprint}.any?
+      end
+    end
+  end
+end

data/lib/kraken-mobile/runners/calabash/android/cucumber.rb

@@ -0,0 +1,27 @@
+require 'calabash-android/cucumber'
+require 'calabash-android/operations'
+require 'kraken-mobile/runners/calabash/android/kraken_hooks'
+require 'kraken-mobile/runners/calabash/android/operations'
+require 'kraken-mobile/runners/calabash/android/monkey_helper'
+require 'kraken-mobile/constants'
+require 'kraken-mobile/protocols/file_protocol'
+
+def requested_protocol
+  case ENV["PROTOCOL"]
+  when KrakenMobile::Constants::FILE_PROTOCOL
+    KrakenMobile::Protocol::FileProtocol
+  else
+    raise "Invalid Kraken protocol."
+  end
+end
+
+World(Calabash::Android::ColorHelper)
+World(Calabash::Android::Operations)
+World(KrakenMobile::CalabashAndroid::Operations)
+World(KrakenMobile::CalabashAndroid::MonkeyHelper)
+World(requested_protocol())
+
+AfterConfiguration do
+  require 'calabash-android/calabash_steps'
+  require 'kraken-mobile/runners/calabash/android/kraken_steps'
+end

data/lib/kraken-mobile/runners/calabash/android/kraken_hooks.rb

@@ -0,0 +1,15 @@
+require 'calabash-android/management/adb'
+require 'calabash-android/operations'
+
+Before do |scenario|
+  install_app_with_calabash()
+  @scenario_tags = scenario.source_tag_names
+end
+
+After do |scenario|
+  @scenario_tags = scenario.source_tag_names
+end
+
+AfterStep do |scenario|
+  screenshot_embed
+end

data/lib/kraken-mobile/runners/calabash/android/kraken_steps.rb

@@ -0,0 +1,3 @@
+require 'calabash-android/calabash_steps'
+require 'kraken-mobile/constants'
+require 'kraken-mobile/runners/calabash/android/steps/communication_steps'

data/lib/kraken-mobile/runners/calabash/android/monkey_helper.rb

@@ -0,0 +1,139 @@
+require 'calabash-android/monkey_helpers'
+require 'kraken-mobile/constants'
+
+module KrakenMobile
+  module CalabashAndroid
+    module MonkeyHelper
+
+      # Runs inteligent monkey
+      def run_intelligent_monkey channel, number_of_events
+        device_id = channel_to_device_id channel
+        logger = open("./#{device_id}.txt", 'w')
+        number_of_events.times do |i|
+          handle_random_action channel, logger
+        end
+        logger.close
+      end
+
+      # Runs adb monkey
+      def run_monkey channel, number_of_events
+        devices_helper = DevicesHelper::Manager.new({runner: ENV["RUNNER"], config_path: ENV["CONFIG_PATH"]}).device_helper
+        device_id = channel_to_device_id channel
+        height, width = devices_helper.screen_size device_id
+        start_monkey
+        actions = [:move, :down, :up]
+        number_of_events.times do |i|
+          monkey_touch(actions.sample, rand(5..(width-5)) , rand(5..(height-5)))
+        end
+        kill_existing_monkey_processes
+      end
+
+      # Runs monkey in an speciic part of the screen
+      def run_small_monkey channel, number_of_events, height_start, height_end, width_start, width_end
+        devices_helper = DevicesHelper::Manager.new({runner: ENV["RUNNER"], config_path: ENV["CONFIG_PATH"]}).device_helper
+        device_id = channel_to_device_id channel
+        height, width = devices_helper.screen_size device_id
+        start_monkey
+        actions = [:move, :down, :up]
+        numb_height_start = (height*(height_start/100.0)).to_i+5
+        numb_height_end = (height*(height_end/100.0)).to_i-5
+        numb_width_start = (width*(width_start/100.0)).to_i+5
+        numb_width_end = (width*(width_end/100.0)).to_i-5
+        number_of_events.times do |i|
+          pos_x = rand(numb_width_start..numb_width_end)
+          pos_y = rand(numb_height_start..numb_height_end)
+          monkey_touch(actions.sample,pos_x,pos_y)
+        end
+        kill_existing_monkey_processes
+      end
+
+      ###########################################
+      ############## Events #####################
+      ###########################################
+      def handle_random_action channel, logger
+        begin
+          Timeout::timeout(KrakenMobile::Constants::MONKEY_DEFAULT_TIMEOUT, RuntimeError) do
+            arr = [method(:enter_last_signal_in_random_input), method(:send_random_signal), method(:random_click)]
+            arr.sample.call(channel, logger)
+          end
+        rescue => e
+          puts "#{ENV['TEST_PROCESS_NUMBER']}> e"
+          logger.puts(e)
+        end
+      end
+
+      def random_click channel, logger
+        elements = query("*")
+        element = elements.sample if elements
+        return if !element
+        x = element["rect"]["x"]
+        y = element["rect"]["y"]
+        begin
+          perform_action(random_touch_action, x, y)
+          puts "#{ENV['TEST_PROCESS_NUMBER']}> random_click - Coordinates: #{x},#{y}"
+          logger.puts("random_click - Coordinates: #{x},#{y}")
+        rescue => e
+          puts "#{ENV['TEST_PROCESS_NUMBER']}> #{e}"
+          logger.puts(e)
+        end
+      end
+
+      def enter_last_signal_in_random_input channel, logger
+        last_signal = readLastSignal(channel)
+        enter_text_in_random_input last_signal, logger
+        puts "#{ENV['TEST_PROCESS_NUMBER']}> enter_last_signal_in_random_input - Signal: #{last_signal}"
+        logger.puts("enter_last_signal_in_random_input - Signal: #{last_signal}")
+      end
+
+      def enter_text_in_random_input text, logger
+        return if input_texts.count <= 0
+        input = input_texts.sample
+        x = input["rect"]["x"]
+        y = input["rect"]["y"]
+        perform_action(random_touch_action, x, y)
+        enter_text text
+      end
+
+      def send_random_signal channel, logger
+        return if app_texts.count <= 0
+        text = app_texts.sample
+        # TODO Remove all special characters
+        text.slice!("(")
+        text.slice!(")")
+        text.slice!("'")
+        text.slice!("\"")
+        send_signal_method = [method(:writeSignalToAnyDevice), method(:writeSignalToAll)]
+        ans = send_signal_method.sample.call(text)
+        if ans
+          puts "#{ENV['TEST_PROCESS_NUMBER']}> send_random_signal to #{ans.id} - Signal: #{text}"
+          logger.puts("send_random_signal to #{ans.id} - Signal: #{text}")
+        else
+          puts "#{ENV['TEST_PROCESS_NUMBER']}> send_random_signal - Signal: #{text}"
+          logger.puts("send_random_signal - Signal: #{text}")
+        end
+      end
+
+      def random_touch_action
+        actions = ["touch_coordinate"]
+        actions.sample
+      end
+
+      private
+      def app_texts
+        query("*", "text").select{ |e| !e["error"]}
+      end
+
+      def buttons
+        query("android.support.v7.widget.AppCompatButton")
+      end
+
+      def enter_text text
+        perform_action('keyboard_enter_text', text) if keyboard_visible?
+      end
+
+      def input_texts
+        query("android.support.v7.widget.AppCompatEditText")
+      end
+    end
+  end
+end