fastlane-plugin-stream_actions 0.4.12 → 0.4.13

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 7e20315e989110210371734616854eb1cf055d2318fe8c1c7031ee5642eb95cf
-  data.tar.gz: 87fab4f22f00b8771fdede017075a4df012942c24baae580613313e781e55745
+  metadata.gz: 637f0d12b17b61c738e37e6530202c347d45776ec6281591c1b6ea94e162d501
+  data.tar.gz: fc3494f5e33aa0e6cde00c3bb741880e709338f670742a4a1697774f8fcd36af
 SHA512:
-  metadata.gz: cf84b704871864755de8317c4e0e9aef2ffd38275f6a8ab8903e3e1f7289c7fdf7563e77aed2aa27f2a61e26621f84c9a9587d659683ae86b1b8550134ec9288
-  data.tar.gz: e784f17eb5d31bb15d53209d69e58135a07f7d87d3a6ea03461ca8b627e63da6cda99b80655a97f62bba9417e8d7c49496edc8c61314ada0eeca797808ed4fa5
+  metadata.gz: 9fe31f2ee1e876d9bab6e7e434d06b74f9de6f9bf70124afda534638d8c6eb96e88c49f06c05669f432bdcfdbcf6024e4317cf4646202d53c78e82c2d58093a1
+  data.tar.gz: df42ca37cabdb7c533379f407aa3dfd21898214eb1206ca61cfad635f082562e91cc9bd35153ba06c7f736181151369c06e8b7aafd80df7a3a1bd2e118742ece

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

@@ -89,8 +89,26 @@ module Fastlane
         }
       end
 
-      # A failed test stops early, so its fresh coverage can miss code it normally runs.
+      # A failed test stops early, so its fresh coverage can miss code it normally runs. Without its previous
+      # coverage the test leaves the map, and select_impacted_tests runs tests that are not in the map every time.
       def self.carry_over_failed_tests(tests, sources, params)
+        previous = previous_map(params)
+        params[:failed_tests].to_a.each do |failed_test|
+          test = failed_test.split('/').last(2).join('/')
+          previous_files = previous && previous['tests'][test]
+          if previous_files.nil?
+            tests.delete(test)
+            UI.important("No previous coverage of the failed #{test}, so it runs on every pull request until it passes")
+            next
+          end
+
+          tests[test] = (tests[test].to_a | previous_files)
+          sources.concat(previous_files - sources)
+          UI.message("Kept the previous coverage of the failed #{test}")
+        end
+      end
+
+      def self.previous_map(params)
         path = params[:previous_map]
         if path.nil? && params[:previous_map_artifact]
           path = Helper::TestCoverageMapHelper.download_map(
@@ -99,18 +117,12 @@ module Fastlane
             github_repository: params[:github_repository]
           )
         end
-        return if path.nil? || !File.exist?(path)
+        return nil if path.nil? || !File.exist?(path)
 
-        previous = Helper::TestCoverageMapHelper.read_map(path)
-        params[:failed_tests].to_a.each do |failed_test|
-          test = failed_test.split('/').last(2).join('/')
-          previous_files = previous['tests'][test]
-          next if previous_files.nil?
-
-          tests[test] = (tests[test].to_a | previous_files)
-          sources.concat(previous_files - sources)
-          UI.message("Kept the previous coverage of the failed #{test}")
-        end
+        Helper::TestCoverageMapHelper.read_map(path)
+      rescue StandardError => e
+        UI.important("Could not read the previous coverage map: #{e.message}")
+        nil
       end
 
       # Keeps sources the repository tracks, dropping e.g. package checkouts cloned inside it.
@@ -207,7 +219,8 @@ module Fastlane
           ),
           FastlaneCore::ConfigItem.new(
             key: :failed_tests,
-            description: 'Tests that failed in this run, as Class/test or Target/Class/test',
+            description: 'Tests that failed in this run, as Class/test or Target/Class/test. Each takes its previous coverage, ' \
+                         'or leaves the map when there is none',
             type: Array,
             optional: true,
             default_value: []

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

@@ -7,7 +7,7 @@ module Fastlane
     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
+      DECLARATION = /^\s*(?:@\w+(?:\([^)\n]*\))?\s+)*#{MODIFIERS}(class|struct|enum|protocol|actor|typealias|extension|interface|object)\s+([A-Za-z_]\w*)/.freeze
 
       def self.run(params)
         source_root = File.expand_path(params[:source_root] || Dir.pwd)
@@ -35,7 +35,7 @@ module Fastlane
         map = load_map(params)
         return run_all(all_tests, 'no coverage map') if map.nil?
 
-        age_days = (Time.now.utc - Time.parse(map['generated_at'])) / 86_400
+        age_days = (Time.now.utc - map['generated_at']) / 86_400
         return run_all(all_tests, "the coverage map is #{age_days.round(1)} days old") if age_days > params[:max_map_age_days]
 
         tests_by_file = Hash.new { |hash, key| hash[key] = [] }
@@ -60,18 +60,23 @@ module Fastlane
           elsif matches_any?(file, params[:source_paths])
             return run_all(all_tests, "#{file} is not in the coverage map") unless CODE_EXTENSIONS.include?(File.extname(file))
 
-            if status == 'A' || status == 'D'
-              reasons << "#{file}: #{status == 'A' ? 'added' : 'deleted'}, so the files using it changed too"
+            if status == 'D'
+              reasons << "#{file}: deleted, so the files using it changed too"
               next
             end
 
             # Declaration-only files (models, protocols, constants) have no executable regions, so coverage
             # never lists them. Their declarations still matter, e.g. a Codable key, so run the tests of the
             # mapped files that reference the declared types.
-            names = declared_names(file, source_root, params)
+            names = declared_names(file, source_root, params, added: status == 'A')
+            users = names.empty? ? [] : referencing_files(names, known_sources - [file], source_root, params)
+            if status == 'A' && users.empty?
+              reasons << "#{file}: added, so the files using it changed too"
+              next
+            end
             return run_all(all_tests, "#{file} is not in the coverage map and declares no types") if names.empty?
+            return run_all(all_tests, "#{file} is not in the coverage map and no mapped file uses #{names.join(', ')}") if users.empty?
 
-            users = referencing_files(names, known_sources - [file], source_root)
             tests = users.flat_map { |user| tests_by_file[user] }.uniq
             selected.concat(impacted(tests, all_tests, mapped_count, params))
             reasons << "#{file}: #{describe(tests, mapped_count, params)} of the #{users.size} mapped files using #{names.join(', ')}"
@@ -125,8 +130,9 @@ module Fastlane
 
         regexes = patterns.map { |pattern| Regexp.new(pattern) }
         lines = Helper::TestCoverageMapHelper.command('git', 'diff', '-U0', diff_range(params), '--', file).lines.map(&:chomp)
-        changed = lines.select { |line| line.match?(/^[+-]/) && !line.match?(/^(\+\+\+|---) /) }.map { |line| line[1..-1] }
-        changed.all? { |line| regexes.any? { |regex| line.match?(regex) } }
+        hunks = lines.drop_while { |line| !line.start_with?('@@') }
+        changed = hunks.grep(/^[+-]/).map { |line| line[1..-1] }
+        !changed.empty? && changed.all? { |line| regexes.any? { |regex| line.match?(regex) } }
       rescue StandardError => e
         UI.important("Could not read the diff of #{file}: #{e.message}")
         false
@@ -145,49 +151,56 @@ module Fastlane
 
       def self.test_classes(file, source_root)
         path = File.join(source_root, file)
-        classes = File.exist?(path) ? File.read(path).scan(/^\s*(?:(?:public|open|final|internal)\s+)*class\s+(\w+)/).flatten : []
+        classes = File.exist?(path) ? File.read(path).scan(/^\s*(?:@\w+(?:\([^)\n]*\))?\s+)*(?:(?:public|open|final|internal)\s+)*(?:class|extension)\s+(\w+)/).flatten : []
         classes.empty? ? [File.basename(file, '.*')] : classes
       end
 
       # Code nearly every test runs (app start, login, the main screen) would select everything. With
       # hot_test_ratio such a change runs one test per class instead, leaving the rest to the full nightly run.
       def self.impacted(tests, all_tests, mapped_count, params)
-        return smoke_tests(all_tests) if hot?(tests, mapped_count, params)
-
-        all_tests.select { |id| tests.include?(test_key(id)) }
+        running = all_tests.select { |id| tests.include?(test_key(id)) }
+        hot?(tests, mapped_count, params) ? smoke_tests(running) : running
       end
 
       def self.hot?(tests, mapped_count, params)
         params[:hot_test_ratio] && mapped_count.positive? && tests.size >= params[:hot_test_ratio] * mapped_count
       end
 
-      def self.smoke_tests(all_tests)
-        all_tests.group_by { |id| test_key(id).split('/').first }.values.map(&:first)
+      def self.smoke_tests(tests)
+        tests.group_by { |id| test_key(id).split('/').first }.values.map(&:first)
       end
 
       def self.describe(tests, mapped_count, params)
         hot?(tests, mapped_count, params) ? "run by #{tests.size} tests, so one test per class" : "#{tests.size} tests"
       end
 
-      def self.declared_names(file, source_root, params)
+      # A new type does nothing until a changed file uses it, so an added file counts only the existing types it extends.
+      def self.declared_names(file, source_root, params, added: false)
         content = begin
           params[:changed_files] ? File.read(File.join(source_root, file)) : Helper::TestCoverageMapHelper.command('git', 'show', "#{params[:diff_head]}:#{file}")
         rescue StandardError
           ''
         end
-        content.scan(DECLARATION).flatten.uniq
+        extended, declared = content.scan(DECLARATION).partition { |kind, _| kind == 'extension' }.map { |list| list.map(&:last).uniq }
+        added ? extended - declared : (declared + extended).uniq
       end
 
-      def self.referencing_files(names, files, source_root)
+      # Reads the files at diff_head, like declared_names, so the lookup does not depend on what is checked out.
+      def self.referencing_files(names, files, source_root, params)
+        return Helper::TestCoverageMapHelper.files_containing(names, params[:diff_head], files) unless params[:changed_files]
+
         pattern = /\b(?:#{names.map { |name| Regexp.escape(name) }.join('|')})\b/
         files.select do |file|
           path = File.join(source_root, file)
           File.exist?(path) && File.read(path).match?(pattern)
         end
+      rescue StandardError => e
+        UI.important("Could not search for #{names.join(', ')}: #{e.message}")
+        []
       end
 
       def self.matches_any?(file, patterns)
-        patterns.to_a.any? do |pattern|
+        patterns.to_a.map(&:to_s).any? do |pattern|
           if pattern.include?('*')
             File.fnmatch?(pattern, file, File::FNM_PATHNAME | File::FNM_EXTGLOB | File::FNM_DOTMATCH)
           else
@@ -225,12 +238,14 @@ module Fastlane
           it cannot prove a test is unaffected:
           - the changed files or the map are unavailable, or the map is older than `max_map_age_days`;
           - a changed file matches `run_all_paths` (test infrastructure, build settings, CI config);
-          - a changed file under `source_paths` is not in the map and is not code (e.g. resources).
-          A changed code file that is not in the map and was not added or deleted is declaration-only (coverage
-          lists only files with executable code): it selects the tests of the mapped files that reference the
-          types it declares.
-          A changed file under `test_paths` selects every test of the classes it declares, and tests that are not
+          - a changed file under `source_paths` is not in the map and is not code (e.g. resources), or is a
+            declaration-only code file that no mapped file references.
+          A modified code file that is not in the map is declaration-only (coverage lists only files with executable
+          code): it selects the tests of the mapped files that reference the types it declares. An added file only counts
+          the existing types it extends, as its new types run through the changed files using them.
+          A changed file under `test_paths` selects every test of the classes it declares or extends, and tests that are not
           in the map yet (added after it was built) always run. Files outside all paths are ignored.
+          A changed file is matched against run_all_paths first, then ignore_paths, then test_paths, then the map.
           With `hot_test_ratio`, a file that (nearly) every test runs selects one test per class instead of all tests;
           use it only when a full run on the base branch catches what that sample misses.
         DETAILS
@@ -298,7 +313,8 @@ module Fastlane
           ),
           FastlaneCore::ConfigItem.new(
             key: :ignore_paths,
-            description: 'Path prefixes or globs that never affect tests, e.g. code generation configs inside source_paths',
+            description: 'Path prefixes or globs that do not affect tests, e.g. code generation configs inside source_paths. ' \
+                         'run_all_paths takes precedence, so a run_all file inside an ignored glob still runs all tests',
             type: Array,
             default_value: []
           ),

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

@@ -1,5 +1,6 @@
 require 'json'
 require 'open3'
+require 'time'
 require 'tmpdir'
 
 module Fastlane
@@ -45,12 +46,28 @@ module Fastlane
         output
       end
 
+      # Files of the list that contain one of the words at the given revision.
+      def self.files_containing(words, revision, files)
+        patterns = words.flat_map { |word| ['-e', word] }
+        prefix = /\A#{Regexp.escape(revision)}:/
+        files.each_slice(500).flat_map do |slice|
+          output, status = Open3.capture2e('git', 'grep', '-l', '-w', '-F', *patterns, revision, '--', *slice)
+          raise "`git grep` failed: #{output}" unless status.success? || status.exitstatus == 1
+
+          output.split("\n").map { |line| line.sub(prefix, '') }
+        end
+      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
+        generated_at = Time.iso8601(map['generated_at'].to_s)
 
         sources = map['sources']
-        map.merge('tests' => map['tests'].transform_values { |indices| indices.map { |i| sources.fetch(i) } })
+        map.merge(
+          'generated_at' => generated_at,
+          'tests' => map['tests'].transform_values { |indices| indices.map { |i| sources.fetch(i) } }
+        )
       end
     end
   end

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

@@ -1,5 +1,5 @@
 module Fastlane
   module StreamActions
-    VERSION = '0.4.12'
+    VERSION = '0.4.13'
   end
 end

metadata

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