kraken-mobile 1.0.2 → 1.0.9

data/lib/kraken-mobile/helpers/devices_helper/adb_helper.rb

@@ -2,156 +2,151 @@ require 'kraken-mobile/models/device'
 require 'kraken-mobile/constants'
 
 module KrakenMobile
-	module DevicesHelper
-		class AdbHelper
-      # ADB command that returns all phones and emulators connected to the computer.
-			def adb_devices_l
-				`adb devices -l`
-			end
-
-      def file_content file_name, device_id
+  module DevicesHelper
+    class AdbHelper
+      # ADB command that returns all phones and
+      # emulators connected to the computer.
+
+      def adb_devices_l
+        `adb devices -l`
+      end
+
+      def file_content(file_name, device_id)
         `adb -s #{device_id} shell "cat /sdcard/#{file_name} 2> /dev/null"`
       end
 
-      def write_content_to_device content, file_name, device_id
+      def write_content_to_device(content, file_name, device_id)
         `adb -s #{device_id} shell "echo "#{content}" > /sdcard/#{file_name}"`
       end
 
-      def create_file_in_device file_name, device_id
+      def create_file_in_device(file_name, device_id)
         `adb -s #{device_id} shell "> /sdcard/#{file_name}"`
       end
 
-      def delete_file_in_device file_name, device_id
+      def delete_file_in_device(file_name, device_id)
         `adb -s #{device_id} shell "rm -rf /sdcard/#{file_name}"`
       end
 
-      def device_screen_size device_id
+      def device_screen_size(device_id)
         `adb -s #{device_id} shell wm size`
       end
 
-      def device_sdk_version device_id
+      def device_sdk_version(device_id)
         `adb -s #{device_id} shell getprop ro.build.version.sdk`
       end
 
-      def device_orientation device_id
+      def device_orientation(device_id)
         `adb -s #{device_id} shell dumpsys input | grep 'SurfaceOrientation' | awk '{ print $2 }'`
       end
 
-      def is_device_connected device_id
-        begin
-         adb_devices_l.include?(device_id)
-        rescue
-          false
+      def device_connected?(device_id)
+        adb_devices_l.include?(device_id)
+      rescue StandardError => _e
+        false
+      end
+
+      # Returns an array with all the devices and emulators
+      # connected to the computer.
+      def connected_devices
+        devices = []
+        adb_devices_l.split("\n").each do |line|
+          line_id = extract_device_id(line)
+          line_model = extract_device_model(line)
+          if line_id && line_model
+            device = Models::Device.new(line_id, line_model, devices.size + 1)
+            devices << device
+          end
         end
+        devices
+      rescue StandardError => _e
+        []
       end
 
-      # Returns an array with all the devices and emulators connected to the computer.
-			def connected_devices
-				begin
-					devices = []
-					list =
-						adb_devices_l.split("\n").each do |line|
-							line_id = extract_device_id(line)
-							line_model = extract_device_model(line)
-							if line_id && line_model
-								device = Models::Device.new(line_id, line_model, devices.size + 1)
-								devices << device
-							end
-						end
-					devices
-				rescue
-					[]
-				end
-			end
-
-      def read_file_content file_name, device_id
-        begin
-          raise "Device #{device_id} not found" unless is_device_connected(device_id)
-          content = file_content("#{file_name}.txt", device_id)
-          content.strip
-        rescue
-          ""
+      def read_file_content(file_name, device_id)
+        unless device_connected?(device_id)
+          raise "Device #{device_id} not found"
         end
+
+        content = file_content("#{file_name}.txt", device_id)
+        content.strip
+      rescue StandardError => _e
+        ''
       end
 
-      def write_content_to_file content, file_name, device_id
-        begin
-          raise "Device #{device_id} not found" unless is_device_connected(device_id)
-          write_content_to_device(content, "#{file_name}.txt", device_id)
-          true
-        rescue
-          false
+      def write_content_to_file(content, file_name, device_id)
+        unless device_connected?(device_id)
+          raise "Device #{device_id} not found"
         end
+
+        write_content_to_device(content, "#{file_name}.txt", device_id)
+        true
+      rescue StandardError => _e
+        false
       end
 
-      def create_file file_name, device_id
-        begin
-          raise "Device #{device_id} not found" unless is_device_connected(device_id)
-          create_file_in_device("#{file_name}.txt", device_id)
-          true
-        rescue
-          false
+      def create_file(file_name, device_id)
+        unless device_connected?(device_id)
+          raise "Device #{device_id} not found"
         end
+
+        create_file_in_device("#{file_name}.txt", device_id)
+        true
+      rescue StandardError => _e
+        false
       end
 
-      def delete_file file_name, device_id
-        begin
-          raise "Device #{device_id} not found" unless is_device_connected(device_id)
-          delete_file_in_device("#{file_name}.txt", device_id)
-          true
-        rescue
-          false
+      def delete_file(file_name, device_id)
+        unless device_connected?(device_id)
+          raise "Device #{device_id} not found"
         end
+
+        delete_file_in_device("#{file_name}.txt", device_id)
+        true
+      rescue StandardError => _e
+        false
       end
 
       # Returns height, width
-      def screen_size device_id
-        begin
-          adb_size = device_screen_size device_id
-          parts = adb_size.strip!.split(" ")
-          size = parts[parts.count-1]
-          return 0,0 if !size.include?("x")
-          size_parts = size.split("x")
-          if orientation(device_id) == KrakenMobile::Constants::PORTRAIT
-            return size_parts[1].to_i, size_parts[0].to_i
-          else
-            return size_parts[0].to_i, size_parts[1].to_i
-          end
-        rescue
-          return 0,0
+      def screen_size(device_id)
+        adb_size = device_screen_size device_id
+        parts = adb_size.strip!.split(' ')
+        size = parts[parts.count - 1]
+        return [0, 0] unless size.include?('x')
+
+        size_parts = size.split('x')
+        if orientation(device_id) == KrakenMobile::Constants::PORTRAIT
+          return size_parts[1].to_i, size_parts[0].to_i
         end
+
+        [size_parts[0].to_i, size_parts[1].to_i]
+      rescue StandardError => _e
+        [0, 0]
       end
 
-      def sdk_version device_id
-        begin
-          return device_sdk_version device_id
-        rescue
-          return "N/A"
-        end
+      def sdk_version(device_id)
+        device_sdk_version device_id
+      rescue StandardError => _e
+        'N/A'
       end
 
-      def orientation device_id
-        begin
-          adb_orientation = device_orientation(device_id).strip!
-          return adb_orientation.to_i
-        rescue
-          return KrakenMobile::Constants::PORTRAIT
-        end
+      def orientation(device_id)
+        adb_orientation = device_orientation(device_id).strip!
+        adb_orientation.to_i
+      rescue StandardError => _e
+        KrakenMobile::Constants::PORTRAIT
       end
 
       # Parses the device id from the ADB devices command.
-			def extract_device_id line
-				if line.match(/device(?!s)/)
-					line.split(" ").first
-				end
-			end
+      def extract_device_id(line)
+        return line.split(' ').first if line.match(/device(?!s)/)
+      end
 
       # Parses the device model from the ADB devices command.
-			def extract_device_model line
-				if line.match(/device(?!s)/)
-					line.scan(/model:(.*) device/).flatten.first
-				end
-			end
-		end
-	end
+      def extract_device_model(line)
+        return unless line.match(/device(?!s)/)
+
+        line.scan(/model:(.*) device/).flatten.first
+      end
+    end
+  end
 end

data/lib/kraken-mobile/helpers/kraken_faker.rb

@@ -0,0 +1,108 @@
+require 'faker'
+require 'kraken-mobile/utils/k.rb'
+require 'json'
+
+class KrakenFaker
+  #-------------------------------
+  # Fields
+  #-------------------------------
+  attr_accessor :process_id
+
+  #-------------------------------
+  # Constructors
+  #-------------------------------
+  def initialize(process_id:)
+    raise 'ERROR: Can\'t create faker for null process id' if process_id.nil?
+
+    @process_id = process_id
+  end
+
+  #-------------------------------
+  # Helpers
+  #-------------------------------
+  def generate_value_for_key(key:)
+    value = if key.start_with?('$name')
+              generate_name
+            elsif key.start_with?('$number')
+              generate_number
+            elsif key.start_with?('$email')
+              generate_email
+            elsif key.start_with?('$string')
+              generate_string
+            elsif key.start_with?('$date')
+              generate_date
+            else
+              raise 'ERROR: Faker key not supported'
+            end
+    save_key_value_in_dictionary(key: key, value: value)
+    value
+  end
+
+  def reuse_value_for_key(key:)
+    dictionary = dictionary_json
+    key = key.delete_prefix('$')
+
+    raise 'ERROR: Key does not exist' if dictionary[process_id.to_s].nil?
+    if dictionary[process_id.to_s][key.to_s].nil?
+      raise 'ERROR: Key does not exist'
+    end
+
+    dictionary[process_id.to_s][key.to_s]
+  end
+
+  def dictionary_json
+    create_dictionary_json_file unless dictionary_json_file_exists?
+
+    absolute_dictionary_path = File.expand_path(K::DICTIONARY_PATH)
+    file = open(absolute_dictionary_path)
+    content = file.read
+    file.close
+    JSON.parse(content)
+  end
+
+  def create_dictionary_json_file
+    absolute_dictionary_path = File.expand_path(K::DICTIONARY_PATH)
+    File.open(absolute_dictionary_path, 'w') do |f|
+      f.puts({}.to_json)
+    end
+  end
+
+  def dictionary_json_file_exists?
+    absolute_dictionary_path = File.expand_path(K::DICTIONARY_PATH)
+    File.file?(absolute_dictionary_path)
+  end
+
+  def save_key_value_in_dictionary(key:, value:)
+    current_json = dictionary_json
+    current_json[process_id.to_s] = {} if current_json[process_id.to_s].nil?
+    current_json[process_id.to_s][key.to_s] = value
+
+    absolute_dictionary_path = File.expand_path(K::DICTIONARY_PATH)
+    open(absolute_dictionary_path, 'w') do |f|
+      f.puts(current_json.to_json)
+    end
+  end
+
+  #-------------------------------
+  # Generators
+  #-------------------------------
+  def generate_name
+    Faker::Name.first_name
+  end
+
+  def generate_number
+    Faker::Number.number(digits: rand(10))
+  end
+
+  def generate_email
+    Faker::Internet.email
+  end
+
+  def generate_string
+    Faker::String.random(length: rand(100))
+  end
+
+  def generate_date
+    Faker::Date.in_date_period.to_s
+  end
+end

data/lib/kraken-mobile/helpers/reporter.rb

@@ -26,6 +26,7 @@ module KrakenMobile
       # Variables
       report_file = open("#{KrakenMobile::Constants::REPORT_PATH}/#{@execution_id}/#{KrakenMobile::Constants::REPORT_DEVICES_FILE_NAME}.json")
       content = report_file.read
+      report_file.close
       @devices = JSON.parse(content)
       devices_report = report_by_devices(@devices)
       @features_report = fetures_from_report_by_devices devices_report
@@ -45,6 +46,7 @@ module KrakenMobile
       @apk_path = device.config["apk_path"] ? device.config["apk_path"] : @options[:apk_path]
       report_file = open("#{KrakenMobile::Constants::REPORT_PATH}/#{@execution_id}/#{device.id}/#{KrakenMobile::Constants::REPORT_FILE_NAME}.json")
       content = report_file.read
+      report_file.close
       @features = JSON.parse(content)
       @total_scenarios = total_scenarios @features
       @device = device
@@ -70,6 +72,7 @@ module KrakenMobile
         next if !File.exists?("#{KrakenMobile::Constants::REPORT_PATH}/#{@execution_id}/#{device['id']}/#{KrakenMobile::Constants::REPORT_FILE_NAME}.json")
         report_file = open("#{KrakenMobile::Constants::REPORT_PATH}/#{@execution_id}/#{device['id']}/#{KrakenMobile::Constants::REPORT_FILE_NAME}.json")
         content = report_file.read
+        report_file.close
         devices_report[device['user']] = JSON.parse(content)
         devices_report[device['user']].each do |d| d["device_model"] = device["model"] if !d["device_model"] end
         devices_report[device['user']].each do |d| d["device_id"] = device["id"] if !d["device_id"] end

data/lib/kraken-mobile/hooks/mobile_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/hooks/mobile_operations.rb

@@ -0,0 +1,36 @@
+require 'calabash-android/management/adb'
+require 'calabash-android/operations'
+require 'kraken-mobile/test_scenario'
+
+def start_test_kraken_server_in_background
+  start_test_server_in_background
+
+  DeviceProcess.notify_process_state(
+    process_id: process_id,
+    state: K::PROCESS_STATES[:ready_to_start]
+  )
+
+  Timeout.timeout(K::DEFAULT_START_TIMEOUT_SECONDS, RuntimeError) do
+    sleep(1) until TestScenario.ready_to_start?
+  end
+end
+
+def shutdown_test_kraken_server
+  DeviceProcess.notify_process_state(
+    process_id: process_id,
+    state: K::PROCESS_STATES[:ready_to_finish]
+  )
+
+  Timeout.timeout(K::DEFAULT_FINISH_TIMEOUT_SECONDS, RuntimeError) do
+    sleep(1) until TestScenario.ready_to_finish?
+  end
+
+  shutdown_test_server
+end
+
+private
+
+def process_id
+  tag_process_id = @scenario_tags.grep(/@user/).first
+  tag_process_id.delete_prefix('@user')
+end

data/lib/kraken-mobile/hooks/web_operations.rb

@@ -0,0 +1,33 @@
+require 'kraken-mobile/test_scenario'
+
+def start_test_kraken_server_in_background(scenario:)
+  @scenario_tags = scenario.source_tag_names
+  DeviceProcess.notify_process_state(
+    process_id: process_id(scenario: scenario),
+    state: K::PROCESS_STATES[:ready_to_start]
+  )
+
+  Timeout.timeout(K::DEFAULT_START_TIMEOUT_SECONDS, RuntimeError) do
+    sleep(1) until TestScenario.ready_to_start?
+  end
+end
+
+def shutdown_test_kraken_server(scenario:)
+  @scenario_tags = scenario.source_tag_names
+  DeviceProcess.notify_process_state(
+    process_id: process_id(scenario: scenario),
+    state: K::PROCESS_STATES[:ready_to_finish]
+  )
+
+  Timeout.timeout(K::DEFAULT_FINISH_TIMEOUT_SECONDS, RuntimeError) do
+    sleep(1) until TestScenario.ready_to_finish?
+  end
+end
+
+private
+
+def process_id(scenario:)
+  scenario_tags = scenario.source_tag_names
+  tag_process_id = scenario_tags.grep(/@user/).first
+  tag_process_id.delete_prefix('@user')
+end