fastlane 2.226.0 → 2.227.0

data/trainer/lib/trainer/xcresult/test_case_attributes.rb

@@ -0,0 +1,49 @@
+module Trainer
+  module XCResult
+    # Mixin for shared attributes between TestCase and Repetition
+    module TestCaseAttributes
+      def self.included(base)
+        base.extend(ClassMethods)
+      end
+
+      def passed?
+        @result == 'Passed'
+      end
+
+      def failed?
+        @result == 'Failed'
+      end
+
+      def skipped?
+        @result == 'Skipped'
+      end
+
+      module ClassMethods
+        def parse_duration(duration_str)
+          return 0.0 if duration_str.nil?
+
+          # Handle comma-separated duration, and remove 's' suffix
+          duration_str.gsub(',', '.').chomp('s').to_f
+        end
+
+        def extract_failure_messages(node)
+          node['children']
+            &.select { |child| child['nodeType'] == 'Failure Message' }
+            &.map { |msg| msg['name'] } || []
+        end
+
+        def extract_source_references(node)
+          node['children']
+            &.select { |child| child['nodeType'] == 'Source Code Reference' }
+            &.map { |ref| ref['name'] } || []
+        end
+
+        def extract_attachments(node)
+          node['children']
+            &.select { |child| child['nodeType'] == 'Attachment' }
+            &.map { |attachment| attachment['name'] } || []
+        end
+      end
+    end
+  end
+end

data/trainer/lib/trainer/xcresult/test_plan.rb

@@ -0,0 +1,91 @@
+require_relative 'test_suite'
+
+module Trainer
+  module XCResult
+    # Represents a collection of test suites + the configuration, and device used to run them
+    class TestPlan
+      attr_reader :test_suites, :name, :configurations, :devices
+      attr_accessor :output_remove_retry_attempts
+
+      def initialize(test_suites:, configurations: [], devices: [], output_remove_retry_attempts: false)
+        @test_suites = test_suites
+        @configurations = configurations
+        @devices = devices
+        @output_remove_retry_attempts = output_remove_retry_attempts
+      end
+
+      def self.from_json(json:)
+        # Extract configurations and devices
+        configurations = json['testPlanConfigurations'] || []
+        devices = json['devices'] || []
+
+        # Find the test plan node (root of test results)
+        test_plan_node = json['testNodes']&.find { |node| node['nodeType'] == 'Test Plan' }
+        return new(test_suites: []) if test_plan_node.nil?
+
+        # Convert test plan node's children (test bundles) to TestSuite objects
+        test_suites = test_plan_node['children']&.map do |test_bundle|
+          TestSuite.from_json(
+            node: test_bundle
+          )
+        end || []
+
+        new(
+          test_suites: test_suites,
+          configurations: configurations,
+          devices: devices
+        )
+      end
+
+      # Allows iteration over test suites. Used by TestParser to collect test results
+      include Enumerable
+      def each(&block)
+        test_suites.map(&:to_hash).each(&block)
+      end
+
+      # Generates a JUnit-compatible XML representation of the test plan
+      # See https://github.com/testmoapp/junitxml/
+      def to_xml
+        # Create the root testsuites element with calculated summary attributes
+        testsuites = Helper.create_xml_element('testsuites',
+          tests: test_suites.sum(&:test_cases_count).to_s,
+          failures: test_suites.sum(&:failures_count).to_s,
+          skipped: test_suites.sum(&:skipped_count).to_s,
+          time: test_suites.sum(&:duration).to_s)
+
+        # Create <properties> node for configuration and device, to be applied to each suite node
+        properties = Helper.create_xml_element('properties').tap do |node|
+          @configurations.each do |config|
+            config_prop = Helper.create_xml_element('property', name: 'Configuration', value: config['configurationName'])
+            node.add_element(config_prop)
+          end
+
+          @devices.each do |device|
+            device_prop = Helper.create_xml_element('property', name: 'device', value: "#{device.fetch('modelName', 'Unknown Device')} (#{device.fetch('osVersion', 'Unknown OS Version')})")
+            node.add_element(device_prop)
+          end
+        end
+
+        # Add each test suite to the root
+        test_suites.each do |suite|
+          suite_node = suite.to_xml(output_remove_retry_attempts: output_remove_retry_attempts)
+          # In JUnit conventions, the <testsuites> root element can't have properties
+          # So we add the <properties> node to each child <testsuite> node instead
+          suite_node.add_element(properties.dup) if properties.elements.any?
+          testsuites.add_element(suite_node)
+        end
+
+        # Convert to XML string with prologue
+        doc = REXML::Document.new
+        doc << REXML::XMLDecl.new('1.0', 'UTF-8')
+
+        doc.add(testsuites)
+
+        formatter = REXML::Formatters::Pretty.new
+        output = String.new
+        formatter.write(doc, output)
+        output
+      end
+    end
+  end
+end

data/trainer/lib/trainer/xcresult/test_suite.rb

@@ -0,0 +1,134 @@
+require_relative 'test_case'
+
+module Trainer
+  module XCResult
+    # Represents a test suite, including its test cases and sub-suites
+    class TestSuite
+      attr_reader :name
+      attr_reader :identifier
+      attr_reader :type
+      attr_reader :result
+      attr_reader :test_cases
+      attr_reader :sub_suites
+      attr_reader :tags
+
+      def initialize(name:, identifier:, type:, result:, tags: [], test_cases: [], sub_suites: [])
+        @name = name
+        @identifier = identifier
+        @type = type
+        @result = result
+        @tags = tags
+        @test_cases = test_cases
+        @sub_suites = sub_suites
+      end
+
+      def self.from_json(node:)
+        # Create initial TestSuite with basic attributes
+        test_suite = new(
+          name: node['name'],
+          identifier: node['nodeIdentifier'],
+          type: node['nodeType'],
+          result: node['result'],
+          tags: node['tags'] || []
+        )
+
+        # Process children to populate test_cases and sub_suites
+        test_suite.process_children(node['children'] || [])
+
+        test_suite
+      end
+
+      def passed?
+        @result == 'Passed'
+      end
+
+      def failed?
+        @result == 'Failed'
+      end
+
+      def skipped?
+        @result == 'Skipped'
+      end
+
+      def duration
+        @duration ||= @test_cases.sum(&:duration) + @sub_suites.sum(&:duration)
+      end
+
+      def test_cases_count
+        @test_cases_count ||= @test_cases.count + @sub_suites.sum(&:test_cases_count)
+      end
+
+      def failures_count
+        @failures_count ||= @test_cases.count(&:failed?) + @sub_suites.sum(&:failures_count)
+      end
+
+      def skipped_count
+        @skipped_count ||= @test_cases.count(&:skipped?) + @sub_suites.sum(&:skipped_count)
+      end
+
+      def total_tests_count
+        @test_cases.sum(&:total_tests_count) +
+          @sub_suites.sum(&:total_tests_count)
+      end
+
+      def total_failures_count
+        @test_cases.sum(&:total_failures_count) +
+          @sub_suites.sum(&:total_failures_count)
+      end
+
+      def total_retries_count
+        @test_cases.sum(&:retries_count) +
+          @sub_suites.sum(&:total_retries_count)
+      end
+
+      # Hash representation used by TestParser to collect test results
+      def to_hash
+        {
+          number_of_tests: total_tests_count,
+          number_of_failures: total_failures_count,
+          number_of_tests_excluding_retries: test_cases_count,
+          number_of_failures_excluding_retries: failures_count,
+          number_of_retries: total_retries_count,
+          number_of_skipped: skipped_count
+        }
+      end
+
+      # Generates a JUnit-compatible XML representation of the test suite
+      # See https://github.com/testmoapp/junitxml/
+      def to_xml(output_remove_retry_attempts: false)
+        testsuite = Helper.create_xml_element('testsuite',
+          name: @name,
+          time: duration.to_s,
+          tests: test_cases_count.to_s,
+          failures: failures_count.to_s,
+          skipped: skipped_count.to_s)
+
+        # Add test cases
+        @test_cases.each do |test_case|
+          runs = test_case.to_xml_nodes
+          runs = runs.last(1) if output_remove_retry_attempts
+          runs.each { |node| testsuite.add_element(node) }
+        end
+
+        # Add sub-suites
+        @sub_suites.each do |sub_suite|
+          testsuite.add_element(sub_suite.to_xml(output_remove_retry_attempts: output_remove_retry_attempts))
+        end
+
+        testsuite
+      end
+
+      def process_children(children)
+        children.each do |child|
+          case child['nodeType']
+          when 'Test Case'
+            # Use from_json to generate multiple test cases if needed
+            @test_cases.concat(TestCase.from_json(node: child))
+          when 'Test Suite', 'Unit test bundle', 'UI test bundle'
+            @sub_suites << TestSuite.from_json(node: child)
+          end
+        end
+      end
+    end
+  end
+end