Merge pull request #94 from evandcoleman/feature/collapse-parallelized-tests

Add option to collapse parallel test runs

Author: diogot

.rubocop.yml

@@ -24,7 +24,7 @@ Style/ClassAndModuleChildren:
   Enabled: false
 
 Metrics/AbcSize:
-  Max: 60
+  Max: 66
 
 # The %w might be confusing for new users
 Style/WordArray:

README.md

@@ -107,6 +107,10 @@ xcode_summary.ignored_results { |result|
 }
 
 xcode_summary.report 'MyApp.xcresult'
+
+# When `true`, collapses parallelized test runs of the same target into one line.
+# Defaults to `false`.
+xcode_summary.collapse_parallelized_tests = true
 ```
 
 You can use `ignores_warnings` to supress warnings and shows only errors.

lib/xcode_summary/plugin.rb

@@ -82,6 +82,12 @@ class DangerXcodeSummary < Plugin
     # @return   [Boolean]
     attr_accessor :strict
 
+    # Defines if parallelized test runs from the same target should be collapsed into one message.
+    # Defaults to `false`
+    # @param    [Boolean] value
+    # @return   [Boolean]
+    attr_accessor :collapse_parallelized_tests
+
     # rubocop:disable Lint/DuplicateMethods
     def project_root
       root = @project_root || Dir.pwd
@@ -121,6 +127,10 @@ def strict
       @strict.nil? || @strict
     end
 
+    def collapse_parallelized_tests
+      @collapse_parallelized_tests || false
+    end
+
     # Pick a Dangerfile plugin for a chosen request_source and cache it
     # based on https://github.com/danger/danger/blob/master/lib/danger/plugin_support/plugin.rb#L31
     #
@@ -211,26 +221,63 @@ def sort_and_log_warnings(all_warnings)
 
     def messages(xcode_summary)
       if test_summary
-        test_messages = xcode_summary.action_test_plan_summaries.map do |test_plan_summaries|
+        test_runs = xcode_summary.action_test_plan_summaries.map do |test_plan_summaries|
           test_plan_summaries.summaries.map do |summary|
             summary.testable_summaries.map do |test_summary|
               test_summary.tests.filter_map do |action_test_object|
                 if action_test_object.instance_of? XCResult::ActionTestSummaryGroup
                   subtests = action_test_object.all_subtests
                   subtests_duration = subtests.map(&:duration).sum
-                  test_text_infix = subtests.count == 1 ? 'test' : 'tests'
+
                   failed_tests_count = subtests.reject { |test| test.test_status == 'Success' }.count
                   expected_failed_tests_count = subtests.select { |test| test.test_status == 'Expected Failure' }.count
 
-                  "#{test_summary.target_name}: Executed #{subtests.count} #{test_text_infix}, " \
-                    "with #{failed_tests_count} failures (#{expected_failed_tests_count} expected) in " \
-                    "#{subtests_duration.round(3)} (#{action_test_object.duration.round(3)}) seconds"
+                  {
+                    target_name: test_summary.target_name,
+                    test_count: subtests.count,
+                    failed_tests_count: failed_tests_count,
+                    expected_failed_tests_count: expected_failed_tests_count,
+                    tests_duration: subtests_duration,
+                    action_duration: action_test_object.duration
+                  }
                 end
               end
             end
           end
         end
-        test_messages.flatten.uniq.compact.map(&:strip)
+
+        flattened_test_runs = test_runs.flatten.uniq.compact
+
+        if collapse_parallelized_tests
+          test_runs_by_target = flattened_test_runs.group_by { |test_run| test_run[:target_name] }
+          flattened_test_runs = test_runs_by_target.map do |target_name, test_runs|
+            test_runs.reduce do |acc, test_run|
+              acc.merge(
+                test_count: acc[:test_count] + test_run[:test_count],
+                failed_tests_count: acc[:failed_tests_count] + test_run[:failed_tests_count],
+                expected_failed_tests_count: acc[:expected_failed_tests_count] + test_run[:expected_failed_tests_count],
+                tests_duration: acc[:tests_duration] + test_run[:tests_duration],
+                action_duration: acc[:action_duration] + test_run[:action_duration]
+              )
+            end
+          end
+        end
+
+        test_messages = flattened_test_runs.map do |test_run|
+          target_name = test_run[:target_name]
+          test_count = test_run[:test_count]
+          failed_tests_count = test_run[:failed_tests_count]
+          expected_failed_tests_count = test_run[:expected_failed_tests_count]
+          subtests_duration = test_run[:tests_duration]
+          action_duration = test_run[:action_duration]
+          test_text_infix = test_count == 1 ? 'test' : 'tests'
+
+          "#{target_name}: Executed #{test_count} #{test_text_infix}, " \
+            "with #{failed_tests_count} failures (#{expected_failed_tests_count} expected) in " \
+            "#{subtests_duration.round(3)} (#{action_duration.round(3)}) seconds"
+        end
+
+        test_messages.map(&:strip)
       else
         []
       end

spec/xcode_summary_spec.rb

@@ -257,6 +257,60 @@ module Danger
             expect(result).to eq '{"warnings":21,"errors":3}'
           end
         end
+
+        context 'with collapse_parallelized_tests' do
+          context 'enabled' do
+            before do
+              @xcode_summary.collapse_parallelized_tests = true
+            end
+
+            it 'collapses test runs from the same target' do
+              # Allow for message receiving testing
+              allow(@xcode_summary).to receive(:message).and_call_original
+              @xcode_summary.report('spec/fixtures/swiftlint.xcresult')
+
+              # Ensure that the plugin received a call to message with the combined test results
+              expect(@xcode_summary).to have_received(:message).with(/SwiftLintFrameworkTests: Executed .* tests/m, sticky: false)
+
+              # The standard test case should only show one message per target, even with parallelized tests
+              expect(@dangerfile.status_report[:messages].length).to eq(1)
+            end
+          end
+
+          context 'disabled' do
+            before do
+              @xcode_summary.collapse_parallelized_tests = false
+            end
+
+            it 'shows individual test runs for each target' do
+              @xcode_summary.report('spec/fixtures/swiftlint.xcresult')
+
+              # We know from the existing tests that the standard behavior should match
+              # the test in the "summary" context, with one test run per message
+              expect(@dangerfile.status_report[:messages]).to eq [
+                'SwiftLintFrameworkTests: Executed 540 tests, with 1 failures (0 expected) in 114.029 (27.922) seconds'
+              ]
+            end
+          end
+
+          context 'with default value' do
+            it 'defaults to disabled behavior' do
+              # Don't set collapse_parallelized_tests to test the default
+              # Reset any test_summary setting to ensure clean state
+              @xcode_summary.test_summary = true
+
+              @xcode_summary.report('spec/fixtures/swiftlint.xcresult')
+
+              # Default should match the disabled behavior
+              expect(@dangerfile.status_report[:messages]).to eq [
+                'SwiftLintFrameworkTests: Executed 540 tests, with 1 failures (0 expected) in 114.029 (27.922) seconds'
+              ]
+
+              # Verify the default value is false
+              expect(@xcode_summary.collapse_parallelized_tests).to eq(false)
+            end
+          end
+        end
       end
     end