kraken-mobile 1.0.4 → 1.0.5

data/calabash-android-features-skeleton/step_definitions/mobile_steps.rb

@@ -0,0 +1 @@
+require 'kraken-mobile/steps/mobile/kraken_steps'

data/calabash-android-features-skeleton/support/app_installation_hooks.rb

@@ -14,6 +14,8 @@ Before do |scenario|
     else
       log 'First scenario in feature - reinstalling apps'
     end
+
+    ensure_app_installed
     clear_app_data
     FeatureMemory.feature = feature
     FeatureMemory.invocation = 1

data/calabash-android-features-skeleton/support/app_life_cycle_hooks.rb

@@ -1,10 +1,9 @@
-require 'kraken-mobile/runners/calabash/android/operations'
+require 'kraken-mobile/hooks/mobile_operations'
 
 Before do |scenario|
-  start_kraken_test_server_in_background scenario
+  start_test_kraken_server_in_background
 end
 
 After do |scenario|
-  shutdown_kraken_test_server scenario
-  uninstall_app_with_calabash
+  shutdown_test_kraken_server
 end

data/calabash-android-features-skeleton/support/env.rb

@@ -1 +1 @@
-require 'kraken-mobile/runners/calabash/android/cucumber'
+require 'kraken-mobile/utils/mobile_cucumber'

data/calabash-android-features-skeleton/web/step_definitions/web_steps.rb

@@ -0,0 +1,3 @@
+if ENV["ADB_DEVICE_ARG"].nil?
+  require 'kraken-mobile/steps/web/kraken_steps'
+end

data/calabash-android-features-skeleton/web/support/app_life_cycle_hooks.rb

@@ -0,0 +1,15 @@
+if ENV["ADB_DEVICE_ARG"].nil?
+  require 'kraken-mobile/hooks/web_operations'
+
+  Before do |scenario|
+    start_test_kraken_server_in_background(
+      scenario: scenario
+    )
+  end
+
+  After do |scenario|
+    shutdown_test_kraken_server(
+      scenario: scenario
+    )
+  end
+end

data/lib/kraken-mobile/device_process.rb

@@ -0,0 +1,94 @@
+# Abstract class
+class DeviceProcess
+  attr_accessor :id
+  attr_accessor :device
+  attr_accessor :test_scenario
+
+  #-------------------------------
+  # Constructors
+  #-------------------------------
+  def initialize(id:, device:, test_scenario:)
+    @id = id
+    @device = device
+    @test_scenario = test_scenario
+  end
+
+  #-------------------------------
+  # Required methods
+  #-------------------------------
+  def before_execute
+    raise 'ERROR: before_execute not implemented.'
+  end
+
+  def execute
+    raise 'ERROR: execute not implemented.'
+  end
+
+  def after_execute
+    raise 'ERROR: after_execute not implemented.'
+  end
+
+  def run
+    before_execute
+    execute
+    after_execute
+  end
+
+  #-------------------------------
+  # Methods
+  #-------------------------------
+  def register_process_to_directory
+    File.open(K::DIRECTORY_PATH, 'a') do |file|
+      file.puts("#{id}#{K::SEPARATOR}#{device}")
+    end
+  end
+
+  def notify_ready_to_start
+    File.open(K::DIRECTORY_PATH, 'a') do |file|
+      file.puts("#{id}#{K::SEPARATOR}#{device}")
+    end
+  end
+
+  def self.directory
+    return [] unless File.exist?(K::DIRECTORY_PATH)
+
+    directory = nil
+    File.open(K::DIRECTORY_PATH, 'r') do |file|
+      directory = file.each_line.map(&:to_s).map(&:strip)
+    end
+
+    directory || []
+  end
+
+  def self.registered_process_ids
+    directory = DeviceProcess.directory
+    directory.map do |entry|
+      info = entry.strip.split(K::SEPARATOR)
+      info[0]
+    end.compact.uniq
+  end
+
+  def self.notify_process_state(process_id:, state:)
+    raise 'ERROR: Process id can\'t be nil.' if process_id.nil?
+
+    file_path = K::PROCESS_STATE_FILE_PATH[state]
+    raise 'ERROR: State does not exist.' if file_path.nil?
+
+    File.open(file_path, 'a') do |file|
+      file.puts(process_id)
+    end
+  end
+
+  def self.processes_in_state(state)
+    file_path = K::PROCESS_STATE_FILE_PATH[state]
+    return [] if file_path.nil?
+    return [] unless File.exist?(file_path)
+
+    devices_ready = nil
+    File.open(file_path, 'r') do |file|
+      devices_ready = file.each_line.map(&:to_s).map(&:strip)
+    end
+
+    devices_ready || []
+  end
+end

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,107 @@
+require 'faker'
+require 'kraken-mobile/utils/k'
+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
+    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