fastlane-plugin-flutter_tests 0.1.0 → 0.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 562ded41eefa236b1db186681fe484aec6643c64160107a0e29c9a055e658e7f
-  data.tar.gz: 7c7e8561a0bdd1e80495642c2aad38601371e68a59ab6e3c74c3edab48179e00
+  metadata.gz: e134b3e53ea1a6aa94cb983cfb66ae0843b6f0bc2263eade128e99f979d80639
+  data.tar.gz: 1384cfda230ccfe2e055f9c2801fe90db559c947390c02842dac720c39305c81
 SHA512:
-  metadata.gz: 3b83d6ed1199bd3fecae918e80b0f0b1cf1617e7fb857111344960e91f760ce8c914d920103253d8033ac40c7fda2e5a6f153d8d73ac87ed9e66f3d42b3d5ee4
-  data.tar.gz: 9d8c086f8806dcf94d27b50862cebaa98e780a48795c64f7a0abee02ca1fc870d12a6af0fc4b3e6195e2205fc5dd99815ad98ad5f1e0c3115107f358fa9a2216
+  metadata.gz: c4b7dd57f2ea4d4e3a3b228a1494c6f0d8fad4ac6c2d055523a95f73368441fc04c66f39dfe93ac56c3873edbf21dcdff51be11d26b3d8d2c72a3800c4f3be68
+  data.tar.gz: 07b55a3475e471e8a499d97576f71773b773dd87d992be4f2f87bd158f4663671515370a5a86faaca32479349b3c35ca202fcaa40e75120dbab733d299cad234

data/README.md

@@ -1,6 +1,7 @@
 # flutter_tests plugin
 
 [![fastlane Plugin Badge](https://rawcdn.githack.com/fastlane/fastlane/master/fastlane/assets/plugin-badge.svg)](https://rubygems.org/gems/fastlane-plugin-flutter_tests)
+[![Gem Version](https://badge.fury.io/rb/fastlane-plugin-flutter_tests.svg)](https://badge.fury.io/rb/fastlane-plugin-flutter_tests)
 
 ## Getting Started
 

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

@@ -1,123 +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
-        end
-
-        def mark_as_done(success, error, stacktrace)
-          @test_done = true
-          @test_successful = success
-          @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
+      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
 
-        def _generate_message(print_errors)
-          default_message = "[#{@test_successful}] #{@test_name}"
-          if print_errors and @test_successful != 'success'
-            default_message += "\n[ERROR] -> #{@test_error}\n[STACKTRACE]\n#{@test_stacktrace}"
+          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 %w[success error].include?(@test_successful)
-            color = @test_successful == 'success' ? 32 : 31
+          platform = params[:platform]
 
-            "\e[#{color}m#{default_message}\e[0m"
-          else
-            default_message
+          if params[:reuse_build] && platform != 'android'
+            UI.error("If 'reuse_build' is set to true, the platform must be android")
+            platform = 'android'
           end
-        end
 
-        def print(print_errors)
-          UI.message(_generate_message(print_errors))
+          Helper::FlutterIntegrationTestHelper.new(params[:driver_path], params[:integration_tests], params[:flutter_command]).run(platform, params[:force_launch], params[:reuse_build])
         end
       end
 
-      class TestRunner
-        def initialize
-          @launched_tests = Hash.new { |hash, key| hash[key] = nil }
-        end
-
-        # Launches all the unit tests contained in the project
-        # folder
-        def run(flutter_command, print_errors)
-          Open3.popen3("#{flutter_command} test --machine") do |stdin, stdout, stderr, thread|
-            stdout.each_line do |line|
-              parse_json_output(line, print_errors)
-            end
-          end
-        end
-
-        # Parses the json output given by [self.run]
-        def parse_json_output(line, print_errors)
-          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]
-                unless test_item.nil?
-                  @launched_tests.delete(test_id)
-                  test_item.mark_as_done(output['result'], nil, nil)
-                  test_item.print(print_errors)
-                end
-              when 'error'
-                test_id = output['testID']
-                test_item = @launched_tests[test_id]
-                unless test_item.nil?
-                  @launched_tests.delete(test_id)
-                  test_item.mark_as_done('error', output['error'], output['stackTrace'])
-                  test_item.print(print_errors)
-                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
-
-      def self.run(params)
-        TestRunner.new.run(params[:flutter_command], params[:print_errors])
-      end
-
       def self.description
         "Extension that helps to run flutter tests"
       end
@@ -145,11 +58,69 @@ module Fastlane
             type: String
           ),
           FastlaneCore::ConfigItem.new(
-            key: :print_errors,
+            key: :print_only_failed,
             default_value: true,
-            description: 'Specifies if it should print the error of failed tests',
+            description: 'Specifies if it should only print the failed and the skipped tests',
             optional: false,
             type: Boolean
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :print_stats,
+            default_value: true,
+            description: 'If defined, it will print how many tests were done/skipped/failed',
+            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,153 @@
+require 'fastlane/action'
+require 'open3'
+require_relative '../utils/utilities.rb'
+
+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
+      # @return [Integer] Value 0 or 1 if all tests were run correctly or not
+      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
+      # @return [Integer] Value 0 or 1 if all tests were run correctly or not
+      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
+
+        tests = {
+          "successful" => 0,
+          "failed" => 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}" : ''}")
+          successful = _get_exit_code(status) == '0'
+          color = successful ? 'green' : 'red'
+          tests[successful ? 'successful' : 'failed'] += 1
+
+          UI.message(Utilities.new.colorize("Test #{test.split("/").last} #{successful ? 'terminated correctly' : 'failed'}", color))
+          count += 1
+        end
+
+        unless tests['failed'] == 0
+          UI.user_error!("There are some integration tests that fail")
+        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,109 @@
+require 'fastlane/action'
+require_relative '../utils/utilities'
+
+module Fastlane
+
+  module Helper
+    class FlutterUnitTestHelper
+      def initialize
+        @launched_tests = Hash.new { |hash, key| hash[key] = nil }
+      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 => 'green', 1 => 'red', 2 => 'blue' }
+          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(Utilities.new.colorize(msg, colors[i]))
+          end
+
+          UI.message('-' * max_length)
+          messages.each { |m| UI.message(m) }
+          UI.message('-' * max_length)
+
+          unless failed_tests == 0
+            UI.user_error!("There are some unitTests that fail")
+          end
+        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/utils/utilities.rb

@@ -0,0 +1,26 @@
+class Utilities
+
+  def initialize
+    @colors = {
+      'blue' => 34,
+      'green' => 32,
+      'red' => 31,
+    }
+  end
+
+  # Colorize a message. If the color specified doesn't exists, returns the default
+  # message
+  #
+  # @param message [String] the message that has to be colorized before printing
+  # @param color [String] the name of the color
+  # @return [String] the message wrapped in a new color
+  def colorize(message, color)
+    if @colors.has_key? color
+      color_code = @colors[color]
+      "\e[#{color_code}m#{message}\e[0m"
+    else
+      message
+    end
+  end
+
+end

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

@@ -1,5 +1,5 @@
 module Fastlane
   module FlutterTests
-    VERSION = "0.1.0"
+    VERSION = "0.2.2"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-flutter_tests
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.2
 platform: ruby
 authors:
 - smaso
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2022-02-16 00:00:00.000000000 Z
+date: 2022-02-18 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -160,7 +160,10 @@ 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/utils/utilities.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