fastlane-plugin-stream_actions 0.4.14 → 0.4.16

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ea8c0b10a707aea52e96abb115d761a08518379e8030df3f2f6ea8def3cf089f
-  data.tar.gz: 2cb6310cc1474349e591a1967efa8e5ba980fb095fe280eb13db43f5d78ca3ef
+  metadata.gz: 026ec8f8ee8ff9ab781bd947a48ce316225ca8f933f86e1870e095cd44c1ab18
+  data.tar.gz: 83ed49f3b21c9ca683823b56c8e71b067211d01de73a5f9fffcf41b27c03f02f
 SHA512:
-  metadata.gz: 19f9d221bdb58b9ba68276cb9aea3049003bd0d25b7c62ee8fb02917c18cc7e6099cf34017520f0e26d2df0dcba7f731d15ce7751cc5842ba22757599d66b63f
-  data.tar.gz: 28562ca0b51a398fa1c8117c847f2f3c1dab3b481b127a6f16b7718753d6fad4673fe37894393a04901e31d37ef295998c3849a25f0272a97e0809913535eddc
+  metadata.gz: 3c73fcd00f53e169c3708a7f0205528175806fc739385f99a1ed3a5ccf0c90e7b25f218f556bced3bf3c54c59f8cf887e7200e492249f109b29f6e312d72c98f
+  data.tar.gz: c0bd2912bd7414870a310a4b20236b548adb0a35f23d05efa7e731052087cfe2549583d5c437ca70eff6346938a4248596cc9cd62e52ab49b24eb1e41128af1b

data/lib/fastlane/plugin/stream_actions/actions/build_test_coverage_map.rb

@@ -2,12 +2,39 @@ require 'json'
 require 'open3'
 require 'set'
 require 'time'
+require 'tmpdir'
 
 module Fastlane
   module Actions
     class BuildTestCoverageMapAction < Action
       def self.run(params)
         source_root = File.expand_path(params[:source_root] || Dir.pwd)
+        sources, tests =
+          if params[:class_dirs]
+            jacoco_coverage(params, source_root)
+          elsif params[:binaries]
+            llvm_coverage(params, source_root)
+          else
+            lcov_coverage(params, source_root)
+          end
+
+        carry_over_failed_tests(tests, sources, params) unless params[:failed_tests].to_a.empty?
+        drop_untracked(tests, sources, source_root)
+
+        map = {
+          'version' => Helper::TestCoverageMapHelper::MAP_VERSION,
+          'generated_at' => Time.now.utc.iso8601,
+          'commit' => params[:commit],
+          'sources' => sources.sort,
+          'tests' => tests.sort.to_h
+        }
+        write(map, params[:output_path])
+        UI.success("Coverage map of #{tests.size} tests and #{map['sources'].size} sources saved to #{params[:output_path]}")
+        map
+      end
+
+      # iOS: one folder of .profraw files per test, `<coverage_dir>/<TestClass>/<testMethod>/`.
+      def self.llvm_coverage(params, source_root)
         test_dirs = Dir.glob(File.join(params[:coverage_dir], '*', '*')).select { |dir| File.directory?(dir) }
         UI.user_error!("No per-test coverage found in '#{params[:coverage_dir]}'") if test_dirs.empty?
 
@@ -41,20 +68,99 @@ module Fastlane
           end
         end
         workers.each(&:join)
+        [sources, tests]
+      end
 
-        carry_over_failed_tests(tests, sources, params) unless params[:failed_tests].to_a.empty?
-        drop_untracked(tests, sources, source_root)
+      # Android: one JaCoCo `.ec` file per test, named `<package>.<TestClass>#<testMethod>.ec` by the test orchestrator.
+      def self.jacoco_coverage(params, source_root)
+        exec_files = Dir.glob(File.join(params[:coverage_dir], '**', '*.ec'))
+        UI.user_error!("No per-test coverage found in '#{params[:coverage_dir]}'") if exec_files.empty?
 
-        map = {
-          'version' => Helper::TestCoverageMapHelper::MAP_VERSION,
-          'generated_at' => Time.now.utc.iso8601,
-          'commit' => params[:commit],
-          'sources' => sources.sort,
-          'tests' => tests.sort.to_h
-        }
-        write(map, params[:output_path])
-        UI.success("Coverage map of #{tests.size} tests and #{map['sources'].size} sources saved to #{params[:output_path]}")
-        map
+        class_dirs = params[:class_dirs].select { |dir| File.directory?(dir) }
+        UI.user_error!('None of the class_dirs exist') if class_dirs.empty?
+
+        UI.message("Building the coverage map of #{exec_files.size} tests ⌛️")
+        cli = params[:jacoco_cli] || download_jacoco_cli
+        paths = kotlin_and_java_paths(source_root)
+        source_of_class = jacoco_class_sources(cli, class_dirs).transform_values { |key| paths[key] }.compact
+
+        tests = {}
+        jacoco_executed_classes(cli, exec_files).each do |file, classes|
+          test_class, method = File.basename(file, '.ec').split('#', 2)
+          next UI.important("#{File.basename(file)} is not named <TestClass>#<testMethod>.ec, skipping") if method.nil?
+
+          tests["#{test_class.split('.').last}/#{method}"] = classes.flat_map { |name| source_of_class[name].to_a }.uniq
+        end
+        [source_of_class.values.flatten.uniq, tests]
+      end
+
+      # Flutter: one folder of lcov files per test, `<coverage_dir>/<TestFile>/<test description>/`, e.g. from
+      # `flutter test --coverage --coverage-path <dir>/lcov.info --name <test>`. lcov lists every library the app loaded,
+      # so a file counts as executed when one of its lines has hits.
+      def self.lcov_coverage(params, source_root)
+        reports = Helper::TestCoverageMapHelper.lcov_reports(params[:coverage_dir])
+        UI.user_error!("No per-test coverage found in '#{params[:coverage_dir]}'") if reports.empty?
+
+        UI.message("Building the coverage map of #{reports.size} tests ⌛️")
+        base_dir = File.expand_path(params[:lcov_base_dir] || source_root)
+        sources = []
+        tests = reports.transform_values do |files|
+          files = files.map { |file, executed| [relative_path(File.expand_path(file, base_dir), source_root), executed] }.reject { |file, _| file.nil? }
+          sources |= files.map(&:first)
+          files.select(&:last).map(&:first).uniq
+        end
+        [sources, tests]
+      end
+
+      # Class name => `<package path>/<source file name>`, from an XML report of the class files without execution data.
+      # Classes without code (interfaces, annotations, constants) are empty `<class/>` elements and stay out, like
+      # declaration-only files in llvm-cov. One report per folder, as JaCoCo fails on a class name that two folders
+      # define differently (e.g. a stale build).
+      def self.jacoco_class_sources(cli, class_dirs)
+        Dir.mktmpdir('jacoco') do |dir|
+          xml = File.join(dir, 'classes.xml')
+          class_dirs.each_with_object({}) do |class_dir, sources|
+            Helper::TestCoverageMapHelper.command('java', '-jar', cli, 'report', '--classfiles', class_dir, '--xml', xml, '--quiet')
+            File.read(xml).scan(/<class name="([^"]+)" sourcefilename="([^"]+)">/).each do |name, source|
+              sources[name] ||= "#{File.dirname(name)}/#{source}"
+            end
+          end
+        end
+      end
+
+      # Exec file => names of the classes with at least one executed probe.
+      def self.jacoco_executed_classes(cli, exec_files)
+        exec_files.each_slice(100).with_object({}) do |slice, result|
+          current = nil
+          Helper::TestCoverageMapHelper.command('java', '-jar', cli, 'execinfo', *slice).each_line do |line|
+            if (loaded = line[/\[INFO\] Loading exec file (.+)\.$/, 1])
+              current = result[loaded] = []
+            elsif current && (hit = line.match(/^\h+\s+(\d+) of\s+\d+\s+(\S+)$/)) && hit[1].to_i.positive?
+              current << hit[2]
+            end
+          end
+        end
+      end
+
+      # `<package path>/<file name>` => repository paths of the tracked Kotlin and Java files. The package comes from the
+      # file, as a Kotlin file does not have to sit in the folder of its package.
+      def self.kotlin_and_java_paths(source_root)
+        files = Helper::TestCoverageMapHelper.command('git', '-C', source_root, 'ls-files', '*.kt', '*.java').split("\n")
+        files.each_with_object({}) do |file, paths|
+          package = File.foreach(File.join(source_root, file)).lazy.map { |line| line[/^\s*package\s+([\w.]+)/, 1] }.find(&:itself)
+          (paths["#{package.to_s.tr('.', '/')}/#{File.basename(file)}".delete_prefix('/')] ||= []) << file
+        end
+      end
+
+      def self.download_jacoco_cli
+        version = '0.8.13'
+        path = File.join(Dir.tmpdir, "jacococli-#{version}.jar")
+        return path if File.exist?(path)
+
+        url = "https://repo1.maven.org/maven2/org/jacoco/org.jacoco.cli/#{version}/org.jacoco.cli-#{version}-nodeps.jar"
+        Helper::TestCoverageMapHelper.command('curl', '-sSfL', '-o', "#{path}.part", url)
+        File.rename("#{path}.part", path)
+        path
       end
 
       # Returns the instrumented files (`all`) and the files with at least one executed line (`covered`).
@@ -152,15 +258,24 @@ module Fastlane
       #####################################################
 
       def self.description
-        'Builds a map of which source files every test executes, from per-test LLVM coverage profiles'
+        'Builds a map of which source files every test executes, from per-test LLVM, JaCoCo or lcov coverage'
       end
 
       def self.details
         <<~DETAILS
-          Expects one folder per test, `<coverage_dir>/<TestClass>/<testMethod>/`, holding the `.profraw` files
+          iOS: expects one folder per test, `<coverage_dir>/<TestClass>/<testMethod>/`, holding the `.profraw` files
           the app wrote while that test ran (e.g. via `LLVM_PROFILE_FILE=<dir>/<TestClass>/<testMethod>/%m_%p%c.profraw`
           in the app's launch environment). Each folder is merged with `llvm-profdata` and exported with `llvm-cov`
-          against the instrumented `binaries`. The resulting JSON map feeds `select_impacted_tests`.
+          against the instrumented `binaries`.
+
+          Android: pass `class_dirs` instead of `binaries`, and a `coverage_dir` holding one JaCoCo `.ec` file per test,
+          `<package>.<TestClass>#<testMethod>.ec`, which the test orchestrator writes with `-e coverage true
+          -e coverageFilePath <dir>/`. A source file counts as executed when one of its classes ran a probe.
+
+          Flutter: pass neither, and a `coverage_dir` with one folder of lcov `.info` files per test, `<TestFile>/<test>/`,
+          e.g. from `flutter test --coverage --name <test>`. A source file counts as executed when one of its lines has hits.
+
+          The resulting JSON map feeds `select_impacted_tests`.
         DETAILS
       end
 
@@ -172,13 +287,31 @@ module Fastlane
         [
           FastlaneCore::ConfigItem.new(
             key: :coverage_dir,
-            description: 'Folder with per-test profiles, laid out as <TestClass>/<testMethod>/*.profraw',
+            description: 'Folder with per-test coverage: <TestClass>/<testMethod>/*.profraw (iOS), *.ec files (Android) ' \
+                         'or <TestFile>/<test>/*.info (Flutter)',
             verify_block: proc { |path| UI.user_error!("Coverage folder '#{path}' does not exist") unless File.directory?(path) }
           ),
           FastlaneCore::ConfigItem.new(
             key: :binaries,
             description: 'Instrumented binaries the profiles belong to, e.g. the app executable (or its .debug.dylib) and every SDK framework',
-            type: Array
+            type: Array,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :class_dirs,
+            description: 'Android: folders with the compiled classes of the app and its modules. Switches to JaCoCo coverage',
+            type: Array,
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :jacoco_cli,
+            description: 'Android: path to the JaCoCo CLI jar (org.jacoco.cli nodeps). Downloaded when not set',
+            optional: true
+          ),
+          FastlaneCore::ConfigItem.new(
+            key: :lcov_base_dir,
+            description: 'Flutter: folder that relative lcov SF paths start from (the package that ran the tests), source_root by default',
+            optional: true
           ),
           FastlaneCore::ConfigItem.new(
             key: :source_root,
@@ -240,6 +373,11 @@ module Fastlane
             coverage_dir: "test_output/coverage",
             binaries: ["App.app/App.debug.dylib", "App.app/Frameworks/SDK.framework/SDK"],
             output_path: "test_output/e2e_coverage_map.json"
+          )',
+          'build_test_coverage_map(
+            coverage_dir: "coverage",
+            class_dirs: Dir.glob("*/build/intermediates/classes/debug/**/dirs"),
+            output_path: "e2e_coverage_map.json"
           )'
         ]
       end
@@ -249,7 +387,7 @@ module Fastlane
       end
 
       def self.is_supported?(platform)
-        [:ios, :mac].include?(platform)
+        [:ios, :mac, :android].include?(platform)
       end
     end
   end

data/lib/fastlane/plugin/stream_actions/actions/select_impacted_tests.rb

@@ -6,8 +6,10 @@ module Fastlane
   module Actions
     class SelectImpactedTestsAction < Action
       CODE_EXTENSIONS = %w[.swift .m .mm .h .kt .java .dart .js .jsx .ts .tsx].freeze
-      MODIFIERS = '(?:(?:public|open|internal|fileprivate|private|final|indirect|nonisolated|data|sealed|abstract|export|default)\\s+)*'
-      DECLARATION = /^\s*(?:@\w+(?:\([^)\n]*\))?\s+)*#{MODIFIERS}(class|struct|enum|protocol|actor|typealias|extension|interface|object)\s+([A-Za-z_]\w*)/.freeze
+      # Kotlin's `enum class` and `fun interface`, and Dart's `interface class` and `mixin class`, name the type after the second keyword.
+      MODIFIERS = '(?:(?:public|open|internal|fileprivate|private|protected|final|indirect|nonisolated|data|sealed|abstract|base|annotation|value|inline|inner|enum(?=\\s+class\\b)|fun(?=\\s+interface\\b)|interface(?=\\s+class\\b)|mixin(?=\\s+class\\b)|export|default)\\s+)*'
+      # Dart's `extension type` declares a new type, unlike an `extension`.
+      DECLARATION = /^\s*(?:@\w+(?:\([^)\n]*\))?\s+)*#{MODIFIERS}(class|struct|enum|protocol|actor|typealias|typedef|mixin|extension\s+type(?:\s+const)?|extension|interface|object)\s+([A-Za-z_]\w*)/.freeze
 
       def self.run(params)
         source_root = File.expand_path(params[:source_root] || Dir.pwd)

data/lib/fastlane/plugin/stream_actions/helper/test_coverage_map_helper.rb

@@ -58,6 +58,26 @@ module Fastlane
         end
       end
 
+      # `TestFile/test` => [[source file, executed?], ...] of the lcov reports in `<coverage_dir>/<TestFile>/<test>/`.
+      def self.lcov_reports(coverage_dir)
+        Dir.glob(File.join(coverage_dir, '*', '*', '*.info'))
+           .group_by { |report| File.dirname(report).split('/').last(2).join('/') }
+           .transform_values { |reports| reports.flat_map { |report| lcov_files(report) } }
+      end
+
+      # [[source file, executed?], ...] of an lcov report, in the order it lists them.
+      def self.lcov_files(report)
+        files = []
+        File.foreach(report) do |line|
+          if line.start_with?('SF:')
+            files << [line[3..-1].strip, false]
+          elsif line.start_with?('DA:') && !files.empty? && line.split(',')[1].to_i.positive?
+            files.last[1] = true
+          end
+        end
+        files
+      end
+
       def self.read_map(path)
         map = JSON.parse(File.read(path))
         UI.user_error!("Unsupported coverage map version #{map['version']}") unless map['version'] == MAP_VERSION

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

@@ -1,5 +1,5 @@
 module Fastlane
   module StreamActions
-    VERSION = '0.4.14'
+    VERSION = '0.4.16'
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-stream_actions
 version: !ruby/object:Gem::Version
-  version: 0.4.14
+  version: 0.4.16
 platform: ruby
 authors:
 - GetStream
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2026-10-14 00:00:00.000000000 Z
+date: 2026-10-21 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: xctest_list