fastlane-plugin-automated_test_emulator_run 1.1.0 → 1.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 2beefd49270a753e5f5c58913fb0d613d8674846
-  data.tar.gz: 27d9e176b1f2304c23c410b761b9e3bc442ea629
+  metadata.gz: 2eb526613eca13ae8ef9235ae150146a2016d3a0
+  data.tar.gz: e22231a66a5fe51dbf336a5caf80be1685727cf9
 SHA512:
-  metadata.gz: 80ed06b2e25dd8395e09612a6d5e4af7e9b357e5d6c237352caa665af9fc9c780e85a3b7dcb36fdd1b21be62e9a7781082bd2f21f685482ea3a4b1a504f60c7c
-  data.tar.gz: 5e4d0f8e600d05dadcd96bbcec08339cbc8222fd36fb287cff949f36ee97017001726506ace3f0ff0090bc176f4b36e8de33421587b84ecaa5ec45d8da1ebd31
+  metadata.gz: 0a60cafaef152b7380478860eaad74c412cf2bc792d7c649c984d04c4772aa670bed0f500f7de85e86d0934802b6da2be002a1f4fc7fa50a62563594747dbd5f
+  data.tar.gz: eddb81d99cb8b79512d900e785adc3c6a0027dda1d88b593309879a2306aebae038afe46209ff4dcb3bff8994e416cbe338ba96498afec99004eca1169d6fb6f

data/lib/fastlane/plugin/automated_test_emulator_run/actions/automated_test_emulator_run_action.rb

@@ -16,9 +16,8 @@ module Fastlane
           avd_controllers = []
 
           # Create AVD_Controller class for each AVD_scheme
-          for i in 0..(avd_schemes.length - 1)
-            avd_scheme = avd_schemes[i]
-            avd_controller = Factory::AvdControllerFactory.get_avd_controller(params, avd_scheme)
+          for i in 0...avd_schemes.length 
+            avd_controller = Factory::AvdControllerFactory.get_avd_controller(params, avd_schemes[i])
             avd_controllers << avd_controller
           end
 
@@ -28,23 +27,31 @@ module Fastlane
 
             # Preparation
             UI.message("Configuring environment in order to launch emulators: ".yellow)
-           
             UI.message("Getting avaliable AVDs".yellow)
             devices = Action.sh(adb_controller.command_get_avds)
            
-            for i in 0..(avd_schemes.length - 1)
-              avd_scheme = avd_schemes[i]
-              avd_controller = avd_controllers[i]
-              
-              # Delete existing AVDs
-              if !devices.match(avd_scheme.avd_name).nil?
-                UI.message(["Deleting existing AVD with name:", avd_scheme.avd_name].join(" ").yellow)
-                Action.sh(avd_controller.command_delete_avd)
+            for i in 0...avd_schemes.length           
+              unless devices.match(avd_schemes[i].avd_name).nil?
+                UI.message(["AVD with name '", avd_schemes[i].avd_name, " 'currently exists."].join("").yellow)
+                if params[:AVD_recreate_new]
+                  # Delete existing AVDs
+                  UI.message("AVD_create_new parameter set to true.".yellow)
+                  UI.message(["Deleting existing AVD with name:", avd_schemes[i].avd_name].join(" ").yellow)
+                  Action.sh(avd_controllers[i].command_delete_avd)
+                 
+                  # Re-create AVD
+                  UI.message(["Re-creating new AVD."].join(" ").yellow)
+                  Action.sh(avd_controllers[i].command_create_avd)
+                else 
+                  # Use existing AVD
+                  UI.message("AVD_recreate_new parameter set to false.".yellow)
+                  UI.message("Using existing AVD for tests.".yellow)
+                end
+              else 
+                # Create AVD
+                UI.message(["AVD with name '", avd_schemes[i].avd_name, "' does not exist. Creating new AVD."].join("").yellow)
+                Action.sh(avd_controllers[i].command_create_avd)
               end
-
-              # Re-create deleted AVDs
-              UI.message("Creating new AVD".yellow)
-              Action.sh(avd_controller.command_create_avd)
             end
 
             # Restart ADB
@@ -53,46 +60,43 @@ module Fastlane
             Action.sh(adb_controller.command_start)
 
             # Applying custom configs (it's not done directly after create because 'cat' operation seems to fail overwrite)
-            for i in 0..(avd_schemes.length - 1)
-              avd_scheme = avd_schemes[i]
-              avd_controller = avd_controllers[i]
-            
-              UI.message(["Attemting to apply custom config to ", avd_scheme.avd_name].join("").yellow)
-              if avd_controller.command_apply_config_avd.eql? "" 
-                 UI.message(["No config file found for AVD '", avd_scheme.avd_name, "'. AVD won't have config.ini applied."].join("").yellow)
+            for i in 0...avd_schemes.length
+              UI.message(["Attemting to apply custom config to ", avd_schemes[i].avd_name].join("").yellow)
+              if avd_controllers[i].command_apply_config_avd.eql? "" 
+                 UI.message(["No config file found for AVD '", avd_schemes[i].avd_name, "'. AVD won't have config.ini applied."].join("").yellow)
               else
-                UI.message(["Config file found! Applying custom config to: ", avd_scheme.avd_name].join("").yellow)
-                Action.sh(avd_controller.command_apply_config_avd)
+                UI.message(["Config file found! Applying custom config to: ", avd_schemes[i].avd_name].join("").yellow)
+                Action.sh(avd_controllers[i].command_apply_config_avd)
               end
             end
 
             # Launching AVDs
-            UI.message("Launching all AVDs at the same time".yellow)
-            for i in 0..(avd_schemes.length - 1)
-              avd_scheme = avd_schemes[i]
-              avd_controller = avd_controllers[i]
-
-              Action.sh(avd_controller.command_start_avd)
+            UI.message("Launching all AVDs at the same time.".yellow)
+            for i in 0...avd_controllers.length
+              Action.sh(avd_controllers[i].command_start_avd)
             end
 
             # Wait for AVDs finish booting
-            UI.message("Waiting for AVDs to finish booting".yellow)
+            UI.message("Waiting for AVDs to finish booting.".yellow)
             boot_status = []
-            for i in 0..(avd_schemes.length - 1)
+            for i in 0...avd_schemes.length
               boot_status << false
             end
 
-            UI.message("Performing wait for params: dev.bootcomplete, sys.boot_completed, init.svc.bootanim".yellow)
-            for i in 0..(avd_schemes.length - 1)
-              avd_controller = avd_controllers[i]
-              timeout = "#{params[:AVD_launch_timeout]}"
-              status = wait_for_emulator_boot(adb_controller, avd_controller, timeout)
-              
-              if (!status)
-                all_avd_launched = false
-                break
+            UI.message("Performig wait for ADB boot".yellow)
+            all_avd_launched = wait_for_emulator_boot_by_adb(adb_controller, avd_schemes, "#{params[:AVD_adb_launch_timeout]}")
+
+            if all_avd_launched
+              UI.message("Wait for ADB boot completed with success".yellow)
+              UI.message("Performing wait for params: dev.bootcomplete, sys.boot_completed, init.svc.bootanim.".yellow)
+              for i in 0...avd_schemes.length
+                all_avd_launched = wait_for_emulator_boot_by_params(adb_controller, avd_controllers[i], "#{params[:AVD_param_launch_timeout]}")
+                unless all_avd_launched 
+                  break 
+                end     
               end
-              all_avd_launched = true
+            else 
+              UI.message("Wait for ADB boot failed".yellow)
             end
 
             # Deciding if AVD launch should be restarted
@@ -100,17 +104,12 @@ module Fastlane
             if all_avd_launched
               UI.message("AVDs Booted!".green)
             else
-              for i in 0..(avd_schemes.length - 1)
-                avd_scheme = avd_schemes[i]
-                avd_controller = avd_controllers[i]
-
-                # Kill all emulators
-                if !devices.match(["emulator-", avd_scheme.launch_avd_port].join("")).nil?
-                  Action.sh(avd_controller.command_kill_device)
+              for i in 0...avd_schemes.length
+                unless devices.match(["emulator-", avd_schemes[i].launch_avd_port].join("")).nil?
+                  Action.sh(avd_controllers[i].command_kill_device)
                 end
               end
             end
-
           end
 
           # Launching tests
@@ -122,33 +121,85 @@ module Fastlane
           UI.message("Starting tests".green)
           begin
             unless shell_task.nil?
-              UI.message("Using shell task".green)
+              UI.message("Using shell task.".green)
               Action.sh(shell_task)
             end
 
             unless gradle_task.nil?
-              UI.message("Using gradle task".green)
+              UI.message("Using gradle task.".green)
               gradle.trigger(task: params[:gradle_task], flags: params[:gradle_flags], serial: nil)
             end
           ensure 
             # Clean up
-            for i in 0..(avd_schemes.length - 1)
-              avd_scheme = avd_schemes[i]
-              avd_controller = avd_controllers[i]
-
+            for i in 0...avd_schemes.length
               # Kill all emulators
-              if !devices.match(["emulator-", avd_scheme.launch_avd_port].join("")).nil?
-                Action.sh(avd_controller.command_kill_device)
+              unless devices.match(["emulator-", avd_schemes[i].launch_avd_port].join("")).nil?
+                Action.sh(avd_controllers[i].command_kill_device)
               end
 
               # Delete AVDs
-              Action.sh(avd_controller.command_delete_avd)
+              if params[:AVD_clean_after]
+                UI.message("AVD_clean_after param set to true. Deleting AVDs.".green)
+                Action.sh(avd_controllers[i].command_delete_avd)
+              else
+                UI.message("AVD_clean_after param set to false. Created AVDs won't be deleted.".green)
+              end
             end
           end
+        end
+
+        def self.wait_for_emulator_boot_by_adb(adb_controller, avd_schemes, timeout)
+          timeoutInSeconds= timeout.to_i
+          startTime = Time.now
+
+          launch_status_hash = Hash.new
+          device_visibility_hash = Hash.new
+
+          for i in 0...avd_schemes.length
+            device_name = ["emulator-", avd_schemes[i].launch_avd_port].join("")
+            launch_status_hash.store(device_name, false)
+            device_visibility_hash.store(device_name, false)
+          end
+
+          launch_status = false
+          loop do
+            currentTime = Time.now
+            devices = Action.sh(adb_controller.command_get_devices)
 
+            # Check if device is visible
+            all_devices_visible = true
+            device_visibility_hash.each do |name, is_visible|
+              unless (devices.match(name).nil? || is_visible)
+                device_visibility_hash[name] = true
+              end
+              all_devices_visible = false unless is_visible
+            end
+
+            # Check if device is booted
+            all_devices_booted = true
+            launch_status_hash.each do |name, is_booted|
+              unless (devices.match(name + " device").nil? || is_booted)
+                launch_status_hash[name] = true
+              end
+              all_devices_booted = false unless is_booted
+            end
+
+            if ((currentTime - startTime) >= timeoutInSeconds) 
+              UI.message(["AVD ADB loading took more than ", timeout, ". Attempting to re-launch."].join("").red)
+              launch_status = false
+              break
+            end
+
+            if (all_devices_booted && all_devices_visible)
+              launch_status = true
+              break
+            end
+            sleep(10)
+          end
+          return launch_status
         end
 
-        def self.wait_for_emulator_boot(adb_controller, avd_controller, timeout)
+        def self.wait_for_emulator_boot_by_params(adb_controller, avd_controller, timeout)
             timeoutInSeconds= timeout.to_i
             startTime = Time.now
 
@@ -160,7 +211,7 @@ module Fastlane
               currentTime = Time.now
 
               if (currentTime - startTime) >= timeoutInSeconds
-                UI.message("AVD loading took more than 10 minutes. Restarting launch".red)
+                UI.message(["AVD param loading took more than ", timeout, ". Attempting to re-launch."].join("").red)
                 launch_status = false
                 break
               end
@@ -177,49 +228,67 @@ module Fastlane
         [
           #paths
           FastlaneCore::ConfigItem.new(key: :AVD_path,
-                                     env_name: "AVD_PATH",
-                                     description: "The path to your android AVD directory (root). HOME/.android/avd by default",
-                                     is_string: true,
-                                     default_value: ENV['HOME'] + '/.android/avd',
-                                     optional: true),
+                                       env_name: "AVD_PATH",
+                                       description: "The path to your android AVD directory (root). HOME/.android/avd by default",
+                                       is_string: true,
+                                       default_value: ENV['HOME'] + '/.android/avd',
+                                       optional: true),
           FastlaneCore::ConfigItem.new(key: :AVD_setup_path,
-                                     env_name: "AVD_SETUP_PATH",
-                                     description: "Location to AVD_setup.json file which contains info about how many AVD should be launched and their configs",
-                                     is_string: true,
-                                     optional: false),
+                                       env_name: "AVD_SETUP_PATH",
+                                       description: "Location to AVD_setup.json file which contains info about how many AVD should be launched and their configs",
+                                       is_string: true,
+                                       optional: false),
           FastlaneCore::ConfigItem.new(key: :SDK_path,
-                                     env_name: "SDK_PATH",
-                                     description: "The path to your android sdk directory (root). ANDROID_HOME by default",
-                                     is_string: true,
-                                     default_value: ENV['ANDROID_HOME'],
-                                     optional: true),
-          FastlaneCore::ConfigItem.new(key: :AVD_launch_timeout,
-                                     env_name: "AVD_LAUNCH_TIMEOUT",
-                                     description: "Timeout in seconds - after what time should plugin attempt to re-launch AVD setup. Default 600 seconds",
-                                     is_string: true,
-                                     default_value: 600,
-                                     optional: true),
-
-    
+                                       env_name: "SDK_PATH",
+                                       description: "The path to your android sdk directory (root). ANDROID_HOME by default",
+                                       is_string: true,
+                                       default_value: ENV['ANDROID_HOME'],
+                                       optional: true),
+
+
+          #emulator re-launch config params
+          FastlaneCore::ConfigItem.new(key: :AVD_param_launch_timeout,
+                                       env_name: "AVD_PARAM_LAUNCH_TIMEOUT",
+                                       description: "Timeout in seconds. Even though ADB might find all devices you still might want to wait for animations to finish and system to boot. Default 60 seconds",
+                                       is_string: true,
+                                       default_value: 60,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :AVD_adb_launch_timeout,
+                                       env_name: "AVD_ADB_LAUNCH_TIMEOUT",
+                                       description: "Timeout in seconds. Wait until ADB finds all devices specified in config and sets their value to 'device'. Default 240 seconds",
+                                       is_string: true,
+                                       default_value: 240,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :AVD_recreate_new,
+                                       env_name: "AVD_RECREATE_NEW",
+                                       description: "Allow to decide if AVDs from AVD_setup.json (in case they already exist) should be deleted and created from scratch",
+                                       default_value: true,
+                                       optional: true),
+          FastlaneCore::ConfigItem.new(key: :AVD_clean_after,
+                                       env_name: "AVD_CLEAN_AFTER",
+                                       description: "Allow to decide if AVDs should be deleted from PC after test session ends",
+                                       default_value: true,
+                                       optional: true),
+
           #launch commands
           FastlaneCore::ConfigItem.new(key: :shell_task,
-                                   env_name: "SHELL_TASK",
-                                   description: "The shell command you want to execute",
-                                   is_string: true,
-                                   conflicting_options: [:gradle_task], 
-                                   optional: true),
+                                       env_name: "SHELL_TASK",
+                                       description: "The shell command you want to execute",
+                                       is_string: true,
+                                       conflicting_options: [:gradle_task], 
+                                       optional: true),
           FastlaneCore::ConfigItem.new(key: :gradle_task,
-                                   env_name: "GRADLE_TASK",
-                                   description: "The gradle task you want to execute",
-                                   is_string: true,
-                                   conflicting_options: [:shell_command],
-                                   optional: true),
+                                       env_name: "GRADLE_TASK",
+                                       description: "The gradle task you want to execute",
+                                       is_string: true,
+                                       conflicting_options: [:shell_command],
+                                       optional: true),
           FastlaneCore::ConfigItem.new(key: :gradle_flags,
-                                   env_name: "GRADLE_FLAGS",
-                                   description: "All parameter flags you want to pass to the gradle command, e.g. `--exitcode --xml file.xml`",
-                                   optional: true,
-                                   conflicting_options: [:shell_command],
-                                   is_string: true),
+                                       env_name: "GRADLE_FLAGS",
+                                       description: "All parameter flags you want to pass to the gradle command, e.g. `--exitcode --xml file.xml`",
+                                       optional: true,
+                                       conflicting_options: [:shell_command],
+                                       is_string: true),
         ]
         end
 

data/lib/fastlane/plugin/automated_test_emulator_run/factory/adb_controller_factory.rb

@@ -18,7 +18,7 @@ module Fastlane
           # ADB shell command parts
           sh_stop_adb = "kill-server"
           sh_start_adb = "start-server"
-          sh_devices_adb = "devices"
+          sh_devices_adb = "devices | grep [0-9] | tr -s \"\t\" \" | cut -d\""
           sh_wait_for_device_adb = "wait-for-device"
           sh_list_avd_adb = "list avd"
 

data/lib/fastlane/plugin/automated_test_emulator_run/provider/avd_setup_provider.rb

@@ -22,7 +22,7 @@ module Fastlane
 
           # Create AVD_scheme objects and fill them with data
           avd_scheme_list = []
-          for i in 0..(avd_hash_list.length - 1)
+          for i in 0...avd_hash_list.length
             avd_hash = avd_hash_list[i]
 
             avd_scheme = AVD_scheme.new
@@ -50,7 +50,7 @@ module Fastlane
           avaliable_ports = get_unused_even_tcp_ports(5556, 5586, avd_scheme_list)
 
           # Fill empty AVD_schemes with open ports
-          for i in 0..(avd_scheme_list.length - 1)
+          for i in 0...avd_scheme_list.length
             avd_scheme = avd_scheme_list[i]
             if avd_scheme.launch_avd_port.eql? ""
               avd_scheme.launch_avd_port = avaliable_ports[0]
@@ -74,7 +74,7 @@ module Fastlane
           reserved_ports = []
 
           # Gather ports requested in JSON config
-          for i in 0..(avd_scheme_list.length - 1)
+          for i in 0...avd_scheme_list.length
             avd_scheme = avd_scheme_list[i]
             unless avd_scheme.launch_avd_port.eql? ""
               reserved_ports << avd_scheme.launch_avd_port
@@ -83,13 +83,13 @@ module Fastlane
 
           # Find next open port which wasn't reserved in JSON config
           port = min_port
-          for i in 0..(avd_scheme_list.length - 1)
+          for i in 0...avd_scheme_list.length
             
             while port < max_port  do
               if !system("lsof -i:#{port}", out: '/dev/null')
 
                 is_port_reserved = false
-                for j in 0..(reserved_ports.length - 1) 
+                for j in 0...reserved_ports.length 
                   if reserved_ports[j].eql?(port.to_s)
                     is_port_reserved = true
                     break

data/lib/fastlane/plugin/automated_test_emulator_run/version.rb

@@ -1,5 +1,5 @@
 module Fastlane
   module AutomatedTestEmulatorRun
-    VERSION = "1.1.0"
+    VERSION = "1.2.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-automated_test_emulator_run
 version: !ruby/object:Gem::Version
-  version: 1.1.0
+  version: 1.2.0
 platform: ruby
 authors:
 - Kamil Krzyk
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-25 00:00:00.000000000 Z
+date: 2016-11-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry