fastlane-plugin-flutter_tests 0.1.1 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7c6b440f953fc91d3c8c62244e2fa370a5627be5bd10fbb1b2b869b51d436173
-  data.tar.gz: 2be21cbbb17644f0389b410b28466c968a8f231d7374c1b5a927907d0ac40435
+  metadata.gz: 42e082a14be1e8489bfcc34fc32ca6863d3d8a4d8d9595d1d2ca52020d600c31
+  data.tar.gz: 2d2987def7370d09cd0f044c8379b18fca146ae7335099604ebc398484307955
 SHA512:
-  metadata.gz: 21f033edbc4738a67cf7348290b3e984ed47c93af3bafa42220a9a0d323e86e2b293fe95d5c2445135d98131a71522dd41c9aa262447349f565ba66099e9cdf3
-  data.tar.gz: c3f07e418887a032153c0a49419a185346c8580f0b5ee9df8b8a5f6ef64185d789e6d45f3e423988956ede7eb6bb849170597b612edf15d0b39dd5d17abaad0c
+  metadata.gz: 167e72db449d86ae77abb6c9cef671fe922967e57a94b9f9b34aea45d19adc3d3a8386b56938d27e75c4b2fd770a6d811dbdd623c62b93efeccb2fd9743e127a
+  data.tar.gz: 1a1c09c0272c465312f03dd25c5bc6448072d3217ce08ffbe6ddc9c882ba18feb783269bfe1e93b54533563a445cd8740e3e937e2dcf51365d977b7077d98e8d

data/lib/fastlane/plugin/flutter_tests/actions/flutter_tests_action.rb

@@ -1,185 +1,36 @@
 require 'fastlane/action'
-require_relative '../helper/flutter_tests_helper'
+require_relative '../helper/flutter_unit_test_helper'
+require_relative '../helper/flutter_integration_test_helper'
 require 'open3'
 require 'json'
+require_relative '../model/test_item'
 
 module Fastlane
   module Actions
     class FlutterTestsAction < Action
-      # Class that represents a single test that has been run
-      class Test
-        def initialize(id, name)
-          @test_id = id
-          @test_name = name
-          @test_done = false
-          @test_successful = ''
-          @test_error = nil
-          @test_stacktrace = nil
-          @test_was_skipped = false
-          @test_was_printed = false
-        end
-
-        def mark_as_done(success, skipped, error, stacktrace)
-          @test_done = true
-          @test_successful = success
-          @test_was_skipped = skipped
-          @test_error = error
-          unless stacktrace.nil?
-            stacktrace = stacktrace.gsub(/ {2,}/, "\n")
-            @test_stacktrace = stacktrace
-          end
-        end
-
-        def get_name
-          @test_name
-        end
-
-        def get_id
-          @test_id
-        end
-
-        def can_print
-          !@test_was_printed
-        end
-
-        def get_status
-          if @test_was_skipped
-            'skipped'
-          else
-            @test_successful
-          end
-        end
-
-        def _generate_message
-          tag = @test_was_skipped ? 'skipped' : @test_successful
-
-          default_message = "[#{tag}] #{@test_name}"
-          if @test_successful != 'success'
-            default_message += "\n[ERROR] -> #{@test_error}\n[STACKTRACE]\n#{@test_stacktrace}"
-          end
-
-          if %w[success error].include?(@test_successful) || @test_was_skipped
-            color = if @test_was_skipped
-                      34 # Skipped tests are displayed in blue
-                    else
-                      # Successful tests are in green and the failed in red
-                      @test_successful == 'success' ? 32 : 31
-                    end
-
-            "\e[#{color}m#{default_message}\e[0m"
-          else
-            default_message
-          end
-        end
-
-        def print
-          UI.message(_generate_message)
-          @test_was_printed = true
-        end
-      end
-
-      class TestRunner
-        def initialize
-          @launched_tests = Hash.new { |hash, key| hash[key] = nil }
-        end
-
-        # Wraps the message to color it
-        #
-        # @param message [String] the message that has to be wrapped
-        # @param color [Integer] the color of the message (34 -> blue, 32 -> green, 31 -> red)
-        def _colorize(message, color)
-          "\e[#{color}m#{message}\e[0m"
+      def self.run(params)
+        test_type = params[:test_type]
+        if %w[all unit].include? test_type
+          Helper::FlutterUnitTestHelper.new.run(params[:flutter_command], params[:print_only_failed], params[:print_stats])
         end
+        if %w[all integration].include? test_type
 
-        # Launches all the unit tests contained in the project
-        # folder
-        def run(flutter_command, print_only_failed, print_stats)
-          Open3.popen3("#{flutter_command} test --machine") do |stdin, stdout, stderr, thread|
-            stdout.each_line do |line|
-              parse_json_output(line, print_only_failed)
-            end
+          if params[:driver_path].nil? || params[:integration_tests].nil?
+            UI.user_error!("If launching integration tests, 'driver_path' and 'integration_tests' parameters must be inserted")
+            exit(1)
           end
 
-          if print_stats
-            stats = Hash.new { |hash, key| hash[key] = 0 }
-            @launched_tests.values.each do |item|
-              unless item.nil?
-                stats[item.get_status] += 1
-              end
-            end
-
-            skipped_tests = stats['skipped'].nil? ? 0 : stats['skipped']
-            failed_tests = stats['error'].nil? ? 0 : stats['error']
-            successful_tests = stats['success'].nil? ? 0 : stats['success']
-            table = [
-              %w[Successful Failed Skipped],
-              [successful_tests, failed_tests, skipped_tests]
-            ]
-
-            messages = ["Ran #{@launched_tests.values.count { |e| !e.nil? }} tests"]
-            colors = { 0 => 32, 1 => 31, 2 => 34 }
-            max_length = 0
-            (0..2).each do |i|
-              msg = "#{table[0][i]}:\t#{table[1][i]}"
-              max_length = [max_length, msg.length].max
-              messages.append(_colorize(msg, colors[i]))
-            end
+          platform = params[:platform]
 
-            UI.message('-' * max_length)
-            messages.each { |m| UI.message(m) }
-            UI.message('-' * max_length)
+          if params[:reuse_build] && platform != 'android'
+            UI.error("If 'reuse_build' is set to true, the platform must be android")
+            platform = 'android'
           end
-        end
 
-        # Parses the json output given by [self.run]
-        def parse_json_output(line, print_only_failed)
-          unless line.to_s.strip.empty?
-            output = JSON.parse(line)
-            unless output.kind_of?(Array)
-              type = output['type']
-              case type
-              when 'testStart'
-                id = output['test']['id']
-                name = output['test']['name']
-                if name.include?('loading')
-                  return
-                end
-
-                test_item = Test.new(id, name)
-                @launched_tests[test_item.get_id] = test_item
-              when 'testDone'
-                test_id = output['testID']
-                test_item = @launched_tests[test_id]
-                if !test_item.nil? && test_item.can_print
-                  was_skipped = output['skipped']
-                  test_item.mark_as_done(output['result'], was_skipped, nil, nil)
-                  if was_skipped || !print_only_failed
-                    test_item.print
-                  end
-                end
-              when 'error'
-                test_id = output['testID']
-                test_item = @launched_tests[test_id]
-                if !test_item.nil? && test_item.can_print
-                  test_item.mark_as_done('error', false, output['error'], output['stackTrace'])
-                  test_item.print
-                end
-              else
-                # ignored
-              end
-            end
-          end
-        rescue StandardError => e
-          UI.error("Got error during parse_json: #{e.message}")
-          UI.error(e.backtrace.join('\n'))
-          exit(1)
+          Helper::FlutterIntegrationTestHelper.new(params[:driver_path], params[:integration_tests], params[:flutter_command]).run(platform, params[:force_launch], params[:reuse_build])
         end
       end
 
-      def self.run(params)
-        TestRunner.new.run(params[:flutter_command], params[:print_only_failed], params[:print_stats])
-      end
-
       def self.description
         "Extension that helps to run flutter tests"
       end
@@ -220,6 +71,57 @@ module Fastlane
             optional: false,
             type: Boolean
           ),
+          FastlaneCore::ConfigItem.new(
+            key: :test_type,
+            default_value: 'all',
+            description: "Specifies which tests should be run. Accepted values",
+            verify_block: proc do |value|
+              UI.user_error!("Wrong value, #{value} not accepted. Should be 'unit','integration' or 'all'.") unless %w[unit integration all].include? value
+            end,
+            optional: false,
+            type: String,
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :driver_path,
+            description: "Specifies the path of the driver file",
+            optional: true,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("Driver file doesn't exists") unless File.file?(value)
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :integration_tests,
+            description: "Specifies the path of the folder containing all the integration tests",
+            optional: true,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("Integration test folder doesn't exists") unless File.exist?(value) && File.directory?(value)
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :platform,
+            description: "Specifies the os on which the tests should run on",
+            optional: false,
+            type: String,
+            verify_block: proc do |value|
+              UI.user_error!("Platform #{value} is not supported") unless %w[android ios].include? value.to_s.downcase
+            end
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :force_launch,
+            description: "If true, the plugin will try to launch an emulator in case it's not already running",
+            optional: false,
+            type: Boolean,
+            default_value: true,
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :reuse_build,
+            description: "If true, builds the app only for the first time then the other integration tests are run on the same build (much faster)",
+            default_value: false,
+            optional: false,
+            type: Boolean,
+          )
         ]
       end
 

data/lib/fastlane/plugin/flutter_tests/helper/flutter_integration_test_helper.rb

@@ -0,0 +1,136 @@
+require 'fastlane/action'
+require 'open3'
+
+module Fastlane
+  module Helper
+    class FlutterIntegrationTestHelper
+      # Initialize the helper that launches the integration tests
+      #
+      # @param driver [String] the path to the file that will be used as driver
+      # @param test_folder [String] the path to the folder that contains the
+      # @param flutter_command [String] the command to launch flutter
+      # integration tests
+      def initialize(driver, test_folder, flutter_command)
+        @driver = driver
+        @integration_tests = _load_files(test_folder)
+        @flutter_command = flutter_command
+      end
+
+      # Loads all the integration test files
+      #
+      # @param test_folder [String] the path that contains the test files
+      # @return [Array] An array containing all the paths to the files found
+      def _load_files(test_folder)
+        test_files = Dir.glob("#{test_folder}/**/*").reject do |f|
+          File.directory?(f) || !f.end_with?('_test.dart')
+        end
+        UI.message("Found #{test_files.length} test files")
+        test_files
+      end
+
+      # Launches the tests sequentially
+      #
+      # @param platform [String] Specifies on which platform the tests should be run
+      # @param force_launch [Boolean] If it's true and there aren't any devices ready, the plugin will try to start one for the given platform
+      # @param reuse_build [Boolean] If it's true, it will run the build only for the first integration test
+      def run(platform, force_launch, reuse_build)
+        UI.message("Checking for running devices")
+        device_id = _run_test_device(platform, force_launch)
+        if !device_id.nil?
+          _launch_tests(device_id, reuse_build)
+        else
+          UI.error("Failed to find a device to launch the tests on")
+          exit(1)
+        end
+      end
+
+      # Executes the tests found on the device_id
+      #
+      # @param device_id [String] the id of the device previously found
+      # @param reuse_build [Boolean] If it's true, it will run the build only for the first integration test
+      def _launch_tests(device_id, reuse_build)
+        apk_path = nil
+        if reuse_build
+          UI.message("Building apk")
+          out, err, status = Open3.capture3("#{@flutter_command} build apk")
+          if _get_exit_code(status) != '0'
+            UI.error("Failed to build apk")
+            puts err
+            exit(1)
+          else
+            apk_path = _get_apk_path(out)
+            if !apk_path.nil? && File.file?(apk_path)
+              UI.message("Build apk at path #{apk_path}")
+              #TODO
+            else
+              UI.error("Apk path not found or it's not accessible")
+              exit(1)
+            end
+
+          end
+        end
+
+        count = 0
+        @integration_tests.each do |test|
+          UI.message("Launching test #{count}/#{@integration_tests.length}: #{test.split("/").last}")
+          _, __, status = Open3.capture3("#{@flutter_command} drive --target #{@driver} --driver #{test} -d #{device_id} #{reuse_build ? "--use-application-binary #{apk_path}" : ''}")
+          UI.message("Test #{count} ended with code '#{_get_exit_code(status)}'")
+          count += 1
+        end
+      end
+
+      # Returns the exit code of a process
+      #
+      # @param exit_status [String] status given back by [Open3]
+      # @return The exit code (0|1) as string
+      def _get_exit_code(exit_status)
+        exit_status.to_s.split(' ').last
+      end
+
+      # Parse the flutter build output looking for a .apk path
+      #
+      # @param message [String] the stdout of flutter build process
+      # @return the path to the apk that has been built
+      def _get_apk_path(message)
+        components = message.split(/\n/).last.split(' ')
+        if components.any? { |line| line.end_with? '.apk' }
+          components.detect { |c| c.end_with? '.apk' }
+        else
+          UI.warn('Apk path not found in the stdout')
+          nil
+        end
+      end
+
+      # Checks if there's a device running and gets its id
+      # @param platform [String] Specifies the type of device that should be found
+      # @param force_launch [Boolean] If it's true and there aren't any devices ready, the plugin will try to start one for the given platform
+      # @return The deviceId if the device exists or [nil]
+      def _run_test_device(platform, force_launch)
+        out, _ = Open3.capture2("#{@flutter_command} devices | grep #{platform}")
+        device_id = nil
+        if out.to_s.strip.empty? && force_launch
+          out, _ = Open3.capture2("#{@flutter_command} emulators | grep #{platform}")
+          if out.to_s.strip.empty?
+            UI.error("No emulators found for platform #{platform}")
+            exit(1)
+          end
+
+          emulator_id = out.to_s.split('•')[0]
+          Open3.capture2("#{@flutter_command} emulators --launch #{emulator_id}")
+
+          out, _ = Open3.capture2("#{@flutter_command} devices | grep #{platform}")
+        else
+          device_id = (out.to_s.split("•")[1]).strip
+          UI.message("Found already running device: #{device_id}")
+        end
+
+        unless out.to_s.strip.empty?
+          device_id = (out.to_s.split("•")[1]).strip
+          UI.message("Got device id #{device_id}")
+        end
+
+        device_id.nil? ? nil : device_id
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/flutter_tests/helper/flutter_unit_test_helper.rb

@@ -0,0 +1,114 @@
+require 'fastlane/action'
+
+module Fastlane
+
+  module Helper
+    class FlutterUnitTestHelper
+      def initialize
+        @launched_tests = Hash.new { |hash, key| hash[key] = nil }
+      end
+
+      # Wraps the message to color it
+      #
+      # @param message [String] the message that has to be wrapped
+      # @param color [Integer] the color of the message (34 -> blue, 32 -> green, 31 -> red)
+      #
+      # @return [String] the colorized message ready to be printed
+      def _colorize(message, color)
+        "\e[#{color}m#{message}\e[0m"
+      end
+
+      # Launches all the unit tests contained in the project
+      # folder
+      #
+      # @param flutter_command [String] Contains the command to launch flutter
+      # @param print_only_failed [Boolean] If true, prints only skipped and failed tests
+      # @param print_stats [Boolean] If true, it prints a table containing the info about
+      # the launched tests
+      def run(flutter_command, print_only_failed, print_stats)
+        Open3.popen3("#{flutter_command} test --machine") do |stdin, stdout, stderr, thread|
+          stdout.each_line do |line|
+            parse_json_output(line, print_only_failed)
+          end
+        end
+
+        if print_stats
+          stats = Hash.new { |hash, key| hash[key] = 0 }
+          @launched_tests.values.each do |item|
+            unless item.nil?
+              stats[item.get_status] += 1
+            end
+          end
+
+          skipped_tests = stats['skipped'].nil? ? 0 : stats['skipped']
+          failed_tests = stats['error'].nil? ? 0 : stats['error']
+          successful_tests = stats['success'].nil? ? 0 : stats['success']
+          table = [
+            %w[Successful Failed Skipped],
+            [successful_tests, failed_tests, skipped_tests]
+          ]
+
+          messages = ["Ran #{@launched_tests.values.count { |e| !e.nil? }} tests"]
+          colors = { 0 => 32, 1 => 31, 2 => 34 }
+          max_length = 0
+          (0..2).each do |i|
+            msg = "#{table[0][i]}:\t#{table[1][i]}"
+            max_length = [max_length, msg.length].max
+            messages.append(_colorize(msg, colors[i]))
+          end
+
+          UI.message('-' * max_length)
+          messages.each { |m| UI.message(m) }
+          UI.message('-' * max_length)
+        end
+      end
+
+      # Parses the json output given by [self.run]
+      #
+      # @param line [String] The json as string that has to be parsed
+      # @param print_only_failed [Boolean] See definition on run
+      def parse_json_output(line, print_only_failed)
+        unless line.to_s.strip.empty?
+          output = JSON.parse(line)
+          unless output.kind_of?(Array)
+            type = output['type']
+            case type
+            when 'testStart'
+              id = output['test']['id']
+              name = output['test']['name']
+              if name.include?('loading')
+                return
+              end
+
+              test_item = Test.new(id, name)
+              @launched_tests[test_item.get_id] = test_item
+            when 'testDone'
+              test_id = output['testID']
+              test_item = @launched_tests[test_id]
+              if !test_item.nil? && test_item.can_print
+                was_skipped = output['skipped']
+                test_item.mark_as_done(output['result'], was_skipped, nil, nil)
+                if was_skipped || !print_only_failed
+                  UI.message(test_item.generate_message)
+                end
+              end
+            when 'error'
+              test_id = output['testID']
+              test_item = @launched_tests[test_id]
+              if !test_item.nil? && test_item.can_print
+                test_item.mark_as_done('error', false, output['error'], output['stackTrace'])
+                UI.message(test_item.generate_message)
+              end
+            else
+              # ignored
+            end
+          end
+        end
+      rescue StandardError => e
+        UI.error("Got error during parse_json: #{e.message}")
+        UI.error(e.backtrace.join('\n'))
+        exit(1)
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/flutter_tests/model/test_item.rb

@@ -0,0 +1,71 @@
+# Class that represents a single test that has been run
+class Test
+  def initialize(id, name)
+    @test_id = id
+    @test_name = name
+    @test_done = false
+    @test_successful = ''
+    @test_error = nil
+    @test_stacktrace = nil
+    @test_was_skipped = false
+    @test_was_printed = false
+  end
+
+  def mark_as_done(success, skipped, error, stacktrace)
+    @test_done = true
+    @test_successful = success
+    @test_was_skipped = skipped
+    @test_error = error
+    unless stacktrace.nil?
+      stacktrace = stacktrace.gsub(/ {2,}/, "\n")
+      @test_stacktrace = stacktrace
+    end
+  end
+
+  def get_name
+    @test_name
+  end
+
+  def get_id
+    @test_id
+  end
+
+  def can_print
+    !@test_was_printed
+  end
+
+  def get_status
+    if @test_was_skipped
+      'skipped'
+    else
+      @test_successful
+    end
+  end
+
+  # Generates a loggable message for the given test
+  #
+  # @return message [String] the message to print
+  def generate_message
+    @test_was_printed = true
+    tag = @test_was_skipped ? 'skipped' : @test_successful
+
+    default_message = "[#{tag}] #{@test_name}"
+    if @test_successful != 'success'
+      default_message += "\n[ERROR] -> #{@test_error}\n[STACKTRACE]\n#{@test_stacktrace}"
+    end
+
+    if %w[success error].include?(@test_successful) || @test_was_skipped
+      color = if @test_was_skipped
+                34 # Skipped tests are displayed in blue
+              else
+                # Successful tests are in green and the failed in red
+                @test_successful == 'success' ? 32 : 31
+              end
+
+      "\e[#{color}m#{default_message}\e[0m"
+    else
+      default_message
+    end
+  end
+
+end

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

@@ -1,5 +1,5 @@
 module Fastlane
   module FlutterTests
-    VERSION = "0.1.1"
+    VERSION = "0.2.0"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-flutter_tests
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.2.0
 platform: ruby
 authors:
 - smaso
@@ -160,7 +160,9 @@ files:
 - README.md
 - lib/fastlane/plugin/flutter_tests.rb
 - lib/fastlane/plugin/flutter_tests/actions/flutter_tests_action.rb
-- lib/fastlane/plugin/flutter_tests/helper/flutter_tests_helper.rb
+- lib/fastlane/plugin/flutter_tests/helper/flutter_integration_test_helper.rb
+- lib/fastlane/plugin/flutter_tests/helper/flutter_unit_test_helper.rb
+- lib/fastlane/plugin/flutter_tests/model/test_item.rb
 - lib/fastlane/plugin/flutter_tests/version.rb
 homepage: https://github.com/smsimone/fastlane_flutter_tests.git
 licenses:

data/lib/fastlane/plugin/flutter_tests/helper/flutter_tests_helper.rb

@@ -1,16 +0,0 @@
-require 'fastlane_core/ui/ui'
-
-module Fastlane
-  UI = FastlaneCore::UI unless Fastlane.const_defined?(:UI)
-
-  module Helper
-    class FlutterTestsHelper
-      # class methods that you define here become available in your action
-      # as `Helper::FlutterTestsHelper.your_method`
-      #
-      def self.show_message
-        UI.message("Hello from the flutter_tests plugin helper!")
-      end
-    end
-  end
-end