kraken-mobile 1.0.2 → 1.0.9

data/bin/kraken_mobile_calabash_android.rb

@@ -0,0 +1,39 @@
+@features_dir = File.join(FileUtils.pwd, 'features')
+@support_dir = File.join(@features_dir, 'support')
+@source_dir = File.join(
+  File.dirname(__FILE__),
+  '..',
+  'calabash-android-features-skeleton'
+)
+
+def handle_calabash_android(config_path, properties_path)
+  require 'kraken-mobile/constants'
+  require 'calabash-android/helpers'
+
+  kraken = KrakenApp.new(
+    apk_path: user_entered_apk_path,
+    properties_path: format_properties(properties_path),
+    config_path: format_config(config_path)
+  )
+  kraken.start
+end
+
+private
+
+def format_properties(properties_path)
+  return if properties_path.nil?
+
+  properties_absolute_path = File.expand_path(properties_path)
+  ensure_properties_is_valid(properties_absolute_path)
+
+  properties_absolute_path
+end
+
+def format_config(config_path)
+  return if config_path.nil?
+
+  config_absolute_path = File.expand_path(config_path)
+  ensure_configuration_is_valid(config_absolute_path)
+
+  config_absolute_path
+end

data/bin/kraken_mobile_helpers.rb

@@ -0,0 +1,107 @@
+require 'rubygems'
+require 'fileutils'
+
+#-------------------------------
+# Helpers
+#-------------------------------
+
+def print_usage
+  puts <<USAGE
+  Usage: kraken-mobile <command-name> [parameters] [options]
+  <command-name> can be one of
+    run <apk>
+      runs Cucumber in the current folder with the environment needed.
+    version
+      prints the gem version.
+    devices
+      prints the list of devices attached.
+    setup
+      creates kraken-settings file specifying in what devices the tests are going to be run.
+    gen
+      generate a features folder structure.
+    resign <apk>
+      resigns the app with the currently configured keystore.
+USAGE
+end
+
+def print_devices
+  puts 'List of devices attached'
+  ADB.connected_devices.each_with_index do |device, index|
+    puts "user#{index + 1} - #{device.to_s.split(K::SEPARATOR).join(' - ')}"
+  end
+end
+
+def apk_file?(file_path)
+  file_path.end_with?('.apk') && File.exist?(file_path)
+end
+
+def relative_to_full_path(file_path)
+  File.expand_path(file_path)
+end
+
+def msg(title, &block)
+  puts "\n" + '-' * 10 + title + '-' * 10
+  block.call
+  puts '-' * 10 + '-------' + '-' * 10 + "\n"
+end
+
+def scaffold_folder_structure
+  if File.exist?(@features_dir)
+    puts 'A features directory already exists. Stopping...'
+    exit 1
+  end
+
+  msg('Question') do
+    puts 'I\'m about to create a subdirectory called features.'
+    puts 'features will contain all your kraken tests.'
+    puts 'Please hit return to confirm that\'s what you want.'
+  end
+  exit 2 unless STDIN.gets.chomp == ''
+
+  FileUtils.cp_r(@source_dir, @features_dir)
+
+  msg('Info') do
+    puts "features subdirectory created. \n"
+  end
+end
+
+def ensure_apk_is_specified
+  return if !ARGV.empty? && apk_file?(ARGV.first)
+
+  puts 'The first parameter must be the path to a valid apk file.'
+  exit 1
+end
+
+def ensure_configuration_is_valid(configuration)
+  return if File.exist?(configuration) &&
+            File.file?(configuration) &&
+            configuration.end_with?('.json')
+
+  puts 'The path of the configuration file is not valid.'
+  exit 1
+end
+
+def ensure_properties_is_valid(properties)
+  return if File.exist?(properties) &&
+            File.file?(properties) &&
+            properties.end_with?('.json')
+
+  puts 'The path of the properties file is not valid.'
+  exit 1
+end
+
+def ensure_android_sdk_installed
+  return unless ENV['ANDROID_HOME'].nil?
+
+  puts 'To use Kraken you need to have installed Android SDK first. '\
+        'Make sure you have the environment variable ANDROID_HOME configured'
+  exit 1
+end
+
+def ensure_java_installed
+  return unless ENV['ANDROID_HOME'].nil?
+
+  puts 'To use Kraken you need to have installed Java first.'\
+        'Make sure you have the environment variable JAVA_HOME configured'
+  exit 1
+end

data/bin/kraken_mobile_setup.rb

@@ -0,0 +1,138 @@
+require 'io/console'
+require 'tty-prompt'
+$LOAD_PATH << File.expand_path('../lib', __dir__)
+require 'kraken-mobile/utils/k.rb'
+
+class KrakenSetup
+  WEB_IDENTIFIER = 'Web'.freeze
+  IS_WEB_AVAILABLE_FOR_SELECTION = true
+
+  attr_accessor :prompt
+  attr_accessor :devices_connected_id
+  attr_accessor :settings
+
+  def initialize
+    @prompt = TTY::Prompt.new
+    @available_devices_ids = available_devices_ids_for_select
+    @settings = {}
+  end
+
+  def run
+    number_of_devices_required.times do |index|
+      user_id = index + 1
+      selected_device_id = select_device_for_user_with_id(user_id)
+      if selected_device_id == WEB_IDENTIFIER
+        handle_web_setup_for_user_with_id(user_id)
+      else
+        handle_mobile_setup_for_user_with_id(user_id, selected_device_id)
+      end
+    end
+    save_user_settings_to_file
+  end
+
+  private
+
+  def handle_web_setup_for_user_with_id(user_id)
+    save_web_device_settings_for_user_with_id(user_id: user_id)
+  end
+
+  def handle_mobile_setup_for_user_with_id(user_id, device_id)
+    selected_apk = select_apk_for_user_with_id(user_id)
+    save_mobile_device_settings_for_user_with_id(
+      user_id: user_id, apk: selected_apk,
+      device_id: device_id
+    )
+    delete_selected_device_id_from_available_devices(device_id)
+  end
+
+  def save_user_settings_to_file
+    open('kraken_mobile_settings.json', 'w') do |f|
+      f.puts @settings.to_json
+    end
+
+    puts 'Saved your settings to .kraken_mobile_settings. You can edit '\
+    'the settings manually or run this setup script again'
+  end
+
+  def number_of_devices_required
+    number_of_devices = -1
+    max_devices = max_number_of_devices
+    while number_of_devices <= 0 || number_of_devices > max_number_of_devices
+      number_of_devices = @prompt.ask(
+        'How many devices do you want to use?', convert: :int
+      )
+
+      if number_of_devices.zero?
+        @prompt.error('Number of devices can\'t be less than 1.')
+      end
+
+      if number_of_devices > max_devices
+        @prompt.error(
+          "You can run Kraken only in #{max_devices} device" \
+          "#{max_devices > 1 ? 's' : ''}"
+        )
+      end
+    end
+    number_of_devices
+  end
+
+  def delete_selected_device_id_from_available_devices(device_id)
+    @available_devices_ids.delete(device_id)
+  end
+
+  def save_mobile_device_settings_for_user_with_id(
+    user_id:, apk:, device_id:
+  )
+    device = ADB.connected_devices.select { |d| d.id == device_id }.first
+    @settings[user_id] = {
+      id: device_id,
+      model: device.model,
+      type: K::ANDROID_DEVICE,
+      config: {
+        apk_path: apk
+      }
+    }
+  end
+
+  def save_web_device_settings_for_user_with_id(user_id:)
+    device = WebDevice.factory_create
+    @settings[user_id] = {
+      id: device.id,
+      model: device.model,
+      type: K::WEB_DEVICE,
+      config: {}
+    }
+  end
+
+  def select_apk_for_user_with_id(id)
+    valid_apk = false
+
+    until valid_apk
+      entered_text = @prompt.ask(
+        "What APK user #{id} is going to run?", required: true
+      )
+      entered_apk_path = File.expand_path(entered_text)
+      valid_apk = apk_file?(File.expand_path(entered_apk_path))
+      @prompt.error('APK path is not valid.') unless valid_apk
+    end
+    entered_apk_path
+  end
+
+  def select_device_for_user_with_id(id)
+    @prompt.select(
+      "Choose your user #{id}", @available_devices_ids
+    )
+  end
+
+  def available_devices_ids_for_select
+    devices_connected_id = ADB.connected_devices.map(&:id)
+    devices_connected_id << WEB_IDENTIFIER if IS_WEB_AVAILABLE_FOR_SELECTION
+    devices_connected_id
+  end
+
+  def max_number_of_devices
+    return 100 if IS_WEB_AVAILABLE_FOR_SELECTION
+
+    ADB.connected_devices.count
+  end
+end

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,130 @@
+require 'fileutils'
+
+# 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 unregister_process_from_directory
+    File.open(K::DIRECTORY_PATH, 'r') do |f|
+      File.open("#{K::DIRECTORY_PATH}.tmp", 'w') do |f2|
+        f.each_line do |line|
+          f2.write(line) unless line.start_with?(
+            "#{id}#{K::SEPARATOR}#{device}"
+          )
+        end
+      end
+    end
+    FileUtils.mv("#{K::DIRECTORY_PATH}.tmp", K::DIRECTORY_PATH)
+  end
+
+  def notify_ready_to_start
+    File.open(K::DIRECTORY_PATH, 'a') do |file|
+      file.puts("#{id}#{K::SEPARATOR}#{device}")
+    end
+  end
+
+  def running_on_windows?
+    RbConfig::CONFIG['host_os'] =~ /cygwin|mswin|mingw|bccwin|wince|emx/
+  end
+
+  def exporting_command_for_environment_variables(variables = {})
+    commands = variables.map do |key, value|
+      if running_on_windows?
+        "(SET \"#{key}=#{value}\")"
+      else
+        "#{key}=#{value};export #{key}"
+      end
+    end
+    commands.join(terminal_command_separator)
+  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
+
+  def terminal_command_separator
+    return ' & ' if running_on_windows?
+
+    ';'
+  end
+end