fastlane-plugin-instrumented_tests 0.1.4 → 0.1.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 940ec4433c1df442e35d5050bb2d3aa82bae4719
-  data.tar.gz: 3381230229cb7da664882bf7a00ef6b9c12839a6
+  metadata.gz: c9e9a7c06de1ecb1e2c9e3a49502c732a443d2e7
+  data.tar.gz: 075c09f81e6f2255d43dd940af521298777e7b16
 SHA512:
-  metadata.gz: ea24336c202ffd7e089b8ae208b326a0796115f32feb2139f987b8b69032471de4656465bae010000de9fe83caa455897f3cf42373363038b917f84f0e790ea1
-  data.tar.gz: bafb909c9ad4771c7948e3f5aee98e6d3943ce972f64228567f3ce8135b92b91f13bafa42ebe5b58e9e350a9b8e5298d255165d9863da1fed6c2dadfc7104ab0
+  metadata.gz: d2bebfa09dacfb126242ad06433fa3184181de33cab3b10fb7f4222a59f3333c20da862628e021080916fd157db9ca2cefca2d0891ea7858fbcab061df3101f0
+  data.tar.gz: e929001e275d809ca7fb32edefc98bb3044c84ac5509f0e2fd4230e827a0149f576821291957a72b669860ab9d44608acf640fb664f06baace08096ccca1f659

data/lib/fastlane/plugin/instrumented_tests/actions/instrumented_tests_action.rb

@@ -9,20 +9,23 @@ module Fastlane
     class InstrumentedTestsAction < Action
       def self.run(params)
         setup_parameters(params)
+        delete_old_emulators(params)
         begin
-          delete_old_emulators(params)
-          create_emulator(params)
-          start_emulator(params)
-
           begin
+            create_emulator(params)
+            start_emulator(params)
+
             wait_emulator_boot(params)
             execute_gradle(params)
           ensure
             stop_emulator(params)
           end
+
+        rescue Exception => e
+          print_emulator_output(params)
+          raise e
         ensure
-          @emulator_output.close
-          @emulator_output.unlink
+          close_emulator_streams(params)
         end
       end
 
@@ -36,8 +39,6 @@ module Fastlane
         params[:avd_hide]=Helper.is_ci? if params[:avd_hide].nil?
 
         @android_serial="emulator-#{params[:avd_port]}"
-        # maybe create this in a way that the creation and destruction are in the same method
-        @emulator_output = Tempfile.new('emulator_output')
       end
 
       def self.delete_old_emulators(params)
@@ -55,7 +56,6 @@ module Fastlane
         avd_abi = "--abi #{params[:avd_abi]}" unless params[:avd_abi].nil?
         avd_tag = "--tag #{params[:avd_tag]}" unless params[:avd_tag].nil?
         create_avd = ["#{params[:sdk_path]}/tools/android", "create avd", avd_name, target_id, avd_abi, avd_tag, avd_options].join(" ")
-
         UI.important("Creating AVD...")
         Action.sh(create_avd)
       end
@@ -63,18 +63,35 @@ module Fastlane
       def self.start_emulator(params)
         UI.important("Starting AVD...")
         ui_args="-gpu on"
-        ui_args="-no-audio -no-window" if params[:avd_hide]
-        start_avd = ["#{params[:sdk_path]}/tools/emulator", "-avd #{params[:avd_name]}", "#{ui_args}", "-port #{params[:avd_port]} &>#{@emulator_output.path} &"]
-        Action.sh(start_avd)
+        ui_args="-no-window" if params[:avd_hide]
+        ui_args=params[:avd_emulator_options] if params[:avd_emulator_options] != nil
+        start_avd = ["#{params[:sdk_path]}/tools/emulator", "-avd #{params[:avd_name]}", "#{ui_args}", "-port #{params[:avd_port]}" ].join(" ")
+
+        UI.command(start_avd)
+        stdin, @emulator_output, @emulator_thread = Open3.popen2e(start_avd)
+        stdin.close
       end
 
       def self.wait_emulator_boot(params)
+        timeout = Time.now + params[:boot_timeout]
         UI.important("Waiting for emulator to finish booting... May take a few minutes...")
-        adb = Helper::AdbHelper.new(adb_path: "#{params[:sdk_path]}/platform-tools/adb")
+
+        adb_path = "#{params[:sdk_path]}/platform-tools/adb"
+        raise "Unable to find adb in #{adb_path}" unless File.file?(adb_path)
         loop do
-          boot_complete_cmd = "ANDROID_SERIAL=#{@android_serial} #{params[:sdk_path]}/platform-tools/adb shell getprop sys.boot_completed" 
+          boot_complete_cmd = "ANDROID_SERIAL=#{@android_serial} #{adb_path} shell getprop sys.boot_completed" 
           stdout, _stdeerr, _status = Open3.capture3(boot_complete_cmd)
 
+          if @emulator_thread != nil && (@emulator_thread.status == false || @emulator_thread.status == true)
+            UI.error("Emulator unexpectedly quit!")
+            raise "Emulator unexpectedly quit"
+          end
+
+          if (Time.now > timeout)
+            UI.error("Waited #{params[:boot_timeout]} seconds for emulator to boot without success")
+            raise "Emulator didn't boot"
+          end
+
           if stdout.strip == "1"
             UI.success("Emulator Booted!")
             break
@@ -83,20 +100,42 @@ module Fastlane
         end
       end
 
-      def self.execute_gradle(params)
-        Fastlane::Actions::GradleAction.run(task: params[:task], flags: params[:flags], project_dir: params[:project_dir], 
-          serial: @android_serial, print_command: true, print_command_output: true)
-      end
-
       def self.stop_emulator(params)
-        UI.important("Shutting down emulator...")
-        adb = Helper::AdbHelper.new(adb_path: "#{params[:sdk_path]}/platform-tools/adb")
-        adb.trigger(command: "emu kill", serial: @android_serial)
+        begin
+          UI.important("Shutting down emulator...")
+          adb = Helper::AdbHelper.new(adb_path: "#{params[:sdk_path]}/platform-tools/adb")
+          adb.trigger(command: "emu kill", serial: @android_serial)
+        rescue
+          UI.message("Emulator is not listening for our commands...")
+          UI.message("Current status of emulator process is: #{@emulator_thread.status}")
+
+          if @emulator_thread != nil && @emulator_thread.status != true && @emulator_thread.status != false
+            UI.important("Emulator still running... Killing PID #{@emulator_thread.pid}!")
+            Process.kill("KILL", @emulator_thread.pid)
+          end
 
-        UI.success("Deleting emulator...")
+        end
+
+        UI.important("Deleting emulator...")
         Action.sh("#{params[:sdk_path]}/tools/android delete avd -n #{params[:avd_name]}")
       end
 
+      def self.print_emulator_output(params)
+        UI.error("Error while trying to execute instrumentation tests. Output from emulator:")
+        @emulator_output.readlines.each do |line|
+          UI.error(line.gsub(/\r|\n/, " "))
+        end
+      end
+
+      def self.close_emulator_streams(params)
+        @emulator_output.close
+      end
+
+      def self.execute_gradle(params)
+        Fastlane::Actions::GradleAction.run(task: params[:task], flags: params[:flags], project_dir: params[:project_dir],
+                                            serial: @android_serial, print_command: true, print_command_output: true)
+      end
+
       def self.description
         "Run android instrumented tests via a gradle command againts a newly created avd"
       end
@@ -123,7 +162,7 @@ module Fastlane
                                        optional: false),
           FastlaneCore::ConfigItem.new(key: :avd_options,
                                        env_name: "AVD_OPTIONS",
-                                       description: "Other avd options in the form of a <option>=<value> list, i.e \"--scale 96dpi --dpi-device 160\"",
+                                       description: "Other avd command line options passed to 'android create avd ...'. i.e. \"--scale 96dpi --dpi-device 160\"",
                                        is_string: true,
                                        optional: true),
           FastlaneCore::ConfigItem.new(key: :avd_abi,
@@ -141,11 +180,24 @@ module Fastlane
                                        description: "The port used for communication with the emulator. If not set it is randomly selected",
                                        is_string: false,
                                        optional: true),
+          FastlaneCore::ConfigItem.new(key: :boot_timeout,
+                                       env_name: "BOOT_TIMEOUT",
+                                       description: "Number of seconds to wait for the emulator to boot",
+                                       is_string: false,
+                                       optional: true,
+                                       default_value: 500),
           FastlaneCore::ConfigItem.new(key: :avd_hide,
                                        env_name: "AVD_HIDE",
                                        description: "Hide the avd interface, required for CI. Default true if on CI, false if not on CI",
                                        is_string: false,
                                        optional: true),
+          FastlaneCore::ConfigItem.new(key: :avd_emulator_options,
+                                       env_name: "AVD_EMULATOR_OPTIONS",
+                                       description: "Other options passed to the emulator command ('emulator -avd AVD_NAME ...')." +
+                                           "Defaults are '-gpu on' when AVD_HIDE is false and '-no-window' otherwise. " +
+                                           "For macs running the CI you might want to use '-no-audio -no-window'",
+                                       is_string: true,
+                                       optional: true),
           FastlaneCore::ConfigItem.new(key: :sdk_path,
                                        env_name: "ANDROID_HOME",
                                        description: "The path to your android sdk directory",

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

@@ -1,5 +1,5 @@
 module Fastlane
   module InstrumentedTests
-    VERSION = "0.1.4"
+    VERSION = "0.1.5"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-instrumented_tests
 version: !ruby/object:Gem::Version
-  version: 0.1.4
+  version: 0.1.5
 platform: ruby
 authors:
 - Silviu Paragina
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-08-01 00:00:00.000000000 Z
+date: 2016-11-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: pry
@@ -126,11 +126,11 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 2.5.1
+rubygems_version: 2.6.7
 signing_key: 
 specification_version: 4
-summary: New action to run instrumented tests for android. This basically creates
-  and boots an emulator before running an gradle commands so that you can run instrumented
+summary: New action to run instrumented tests for android. This plugin creates and
+  boots an emulator before running a gradle command so that you can run instrumented
   tests against that emulator. After the gradle command is executed, the avd gets
   shut down and deleted. This is really helpful on CI services, keeping them clean
   and always having a fresh avd for testing.