fastlane-plugin-retry_tests 1.2.9 → 1.3.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 32bf848c6f9dedbbc10b83eb2c3a0b494e54ce27
-  data.tar.gz: f588d58c28cf698efedb32332897020f59f5db54
+  metadata.gz: ad6db1868ae50026fe22c693857fb1a1a78f61fb
+  data.tar.gz: 103f996af1ed6c2ee7bb026ef53731233648f1e1
 SHA512:
-  metadata.gz: 95b16cd8a9c88160821a2206e853fdadb62ac7419da7b94d866ff0d12daed2cb6d4972a5cc3ee1357c3e7a6a11a9f4466bdb37c278d6564567b99ea9756b35ca
-  data.tar.gz: 1993130eea75cd9111e02643f9ad33a29b114b87a8dee41c08a55fa09ee8d06a6264da5fa066f743033eb937ce61d477def7ffacbd5e1592ccf8c632491e0cc1
+  metadata.gz: 6f5106da53a539dcd50e7e3136e8a4bad77226e3d7d7cb5e3884e8206cb9bbef2f2072df341383feb574cb1a447aa5722b1ca7de40de3ebc6fac462cc9415eb1
+  data.tar.gz: 7e1f5374483038c240082c79dab5ad1597001ceb3d0d51c674b285005a2b770933ced8463780b02c1a329952f6587561207d8cf2d057146a6a3569d333b9bb2b

data/lib/fastlane/plugin/retry_tests.rb

@@ -1,7 +1,7 @@
-#require 'fastlane/plugin/retry_tests/version'
+require 'fastlane/plugin/retry_tests/version'
 
 module Fastlane
-  module TestCenter
+  module RetryTests
     # Return all .rb files inside the "actions" and "helper" directory
     def self.all_classes
       Dir[File.expand_path('**/{actions,helper}/*.rb', File.dirname(__FILE__))]
@@ -11,6 +11,6 @@ end
 
 # By default we want to import all available actions and helpers
 # A plugin can contain any number of actions and plugins
-Fastlane::TestCenter.all_classes.each do |current|
+Fastlane::RetryTests.all_classes.each do |current|
   require current
 end

data/lib/fastlane/plugin/retry_tests/actions/collate_junit_reports.rb

@@ -1,3 +1,4 @@
+#Adapted from the "fastlane-plugin-test_center" plugin
 
 require 'nokogiri'
 require 'nokogiri-plist'
@@ -11,9 +12,12 @@ module Fastlane
         if report_filepaths.size == 1
           FileUtils.cp(report_filepaths[0], params[:collated_report])
         else
+          #Convert .plist reports to Nokogiri XML objects
           target_report = File.open(report_filepaths.shift) {|f| Nokogiri::XML(f)}
           file_name = params[:collated_report] + "/#{params[:scheme]}.test_result/1_Test/action_TestSummaries.plist"
           reports = report_filepaths.map { |report_filepath| Nokogiri::XML(Nokogiri::PList(open(report_filepath)).to_plist_xml) }
+
+          #Merge .plist reports
           reports.each do |retry_report|
             mergeLists(target_report, retry_report, params)
           end
@@ -22,24 +26,15 @@ module Fastlane
         copy_log(params[:logs], params[:collated_report] + "/")
       end
 
-      def self.clean_report(report)
-        report = report.gsub(/<(\w+): 0x(\w+)>/, '(\1: 0x\2)')
-        report = report.gsub(/<XCAccessibilityElement:\/>0x(\w+)/, '(XCAccessibilityElement): 0x\1')
-        report
-      end
-
-      def self.copy_log(log_files, logs_folder)
-        target_log = log_files.shift
-        FileUtils.cp_r(target_log, logs_folder)
-      end
-
       def self.mergeLists(target_report, retry_report, params)
         retry_report = clean_report(retry_report)
-        UI.verbose("Merging retried results...")
         Dir.mkdir(params[:collated_report]) unless File.exists?(params[:collated_report])
         file_name = params[:collated_report] + "/action_TestSummaries.plist"
         retried_tests = retry_report.xpath("//key[contains(.,'TestSummaryGUID')]/..")
+
         current_node = retried_tests.shift
+
+        #Copy retried test results into the base report
         while (current_node != nil)
           testName = get_test_name(current_node)
           matching_node = target_report.at_xpath("//string[contains(.,'#{testName}')]/..")
@@ -52,28 +47,37 @@ module Fastlane
         end
       end
 
+      def self.clean_report(report)
+        report = report.gsub(/<(\w+): 0x(\w+)>/, '(\1: 0x\2)')
+        report = report.gsub(/<XCAccessibilityElement:\/>0x(\w+)/, '(XCAccessibilityElement): 0x\1')
+        report
+      end
+
       def self.merge_assets(asset_files, assets_folder)
-        UI.verbose ("Merging screenshot folders...")
+        #copy screenshots from all retries into the results folder
         Dir.mkdir(assets_folder) unless File.exists?(assets_folder)
         asset_files.each do |folder|
           FileUtils.cp_r(Dir[folder + '/*'], assets_folder)
         end
       end
 
+      def self.copy_log(log_files, logs_folder)
+        target_log = log_files.shift
+        FileUtils.cp_r(target_log, logs_folder)
+      end
+
       def self.merge_logs(log_files, logs_folder)
         UI.verbose("Merging console logs...")
+        all = ""
         target_log = log_files.shift
         log_files.each do |log|
-          to_append = File.read(log)
-          File.open(target_log, "a") do |handle|
-            handle.puts to_append
-          end
-          FileUtils.cp_r(target_log, logs_folder)
+          all = all + log + " "
         end
+        sh("cat #{all}> #{target_log}")
+        FileUtils.cp_r(target_log, logs_folder)
       end
 
       def self.write_report_to_file(report, file_name)
-        UI.verbose("Writing merged results to file...")
         File.new(file_name, 'w')
         File.open(file_name, 'w') do |f|
           f.write(report.to_xml)
@@ -167,6 +171,7 @@ module Fastlane
       end
 
       def self.authors
+        #Adapted from the "fastlane-plugin-test_center" plugin by:
         ["lyndsey-ferguson/@lyndseydf"]
       end
 

data/lib/fastlane/plugin/retry_tests/actions/multi_scan.rb

@@ -1,3 +1,5 @@
+#Adapted from the "fastlane-plugin-test_center" plugin
+
 module Fastlane
   module Actions
     require 'fastlane/actions/scan'
@@ -23,7 +25,8 @@ module Fastlane
           config = FastlaneCore::Configuration.create(Fastlane::Actions::ScanAction.available_options, scan_options)
           Fastlane::Actions::ScanAction.run(config)
         rescue FastlaneCore::Interface::FastlaneTestFailure => e
-          UI.verbose("Scan failed with #{e}")
+          FastlaneCore::UI.verbose("Scan failed with error #{e}")
+          #Retry for the specified number of times if there were failed tests
           if try_count < params[:try_count]
             report_filepath = junit_report_filepath(scan_options)
             failed_tests = other_action.tests_from_junit(junit: report_filepath)[:failed]
@@ -40,7 +43,6 @@ module Fastlane
         asset_files = Dir.glob("#{folder}*/#{scan_options[:scheme]}.test_result/1_Test/Attachments")
         log_files = Dir.glob("#{folder}*/#{scan_options[:scheme]}.test_result/1_Test/action.xcactivitylog")
         #Merge all reports, screenshots, and logs if there were retried tests
-
         if report_files.size > 1
           other_action.collate_junit_reports(
             scheme: scan_options[:scheme],
@@ -132,6 +134,7 @@ module Fastlane
       end
 
       def self.authors
+        #Adapted from the "fastlane-plugin-test_center" plugin by:
         ["lyndsey-ferguson/@lyndseydf"]
       end
 

data/lib/fastlane/plugin/retry_tests/actions/tests_from_xctestrun.rb

@@ -0,0 +1,65 @@
+require 'plist'
+
+module Fastlane
+  module Actions
+    class TestsFromXctestrunAction < Action
+      def self.run(params)
+        return xctestrun_tests(params[:xctestrun])
+      end
+
+      def self.xctestrun_tests(xctestrun_path)
+        xctestrun = Plist.parse_xml(xctestrun_path)
+        xctestrun_rootpath = File.dirname(xctestrun_path)
+        tests = Hash.new([])
+        xctestrun.each do |testable_name, xctestrun_config|
+          test_identifiers = XCTestList.tests(xctest_bundle_path(xctestrun_rootpath, xctestrun_config))
+          if xctestrun_config.key?('SkipTestIdentifiers')
+            test_identifiers.reject! { |test_identifier| xctestrun_config['SkipTestIdentifiers'].include?(test_identifier) }
+          end
+          tests[testable_name] = test_identifiers.map do |test_identifier|
+            "#{testable_name.shellescape}/#{test_identifier}"
+          end
+        end
+        tests
+      end
+
+      def self.xctest_bundle_path(xctestrun_rootpath, xctestrun_config)
+        xctest_host_path = xctestrun_config['TestHostPath'].sub('__TESTROOT__', xctestrun_rootpath)
+        xctestrun_config['TestBundlePath'].sub('__TESTHOST__', xctest_host_path).sub('__TESTROOT__', xctestrun_rootpath)
+      end
+
+      #####################################################
+      # @!group Documentation
+      #####################################################
+
+      def self.description
+        "Retrieves all of the tests from xctest bundles referenced by the xctestrun file"
+      end
+
+      def self.available_options
+        [
+          FastlaneCore::ConfigItem.new(
+            key: :xctestrun,
+            env_name: "FL_SUPPRESS_TESTS_FROM_XCTESTRUN_FILE",
+            description: "The xctestrun file to use to find where the xctest bundle file is for test retrieval",
+            verify_block: proc do |path|
+              UI.user_error!("Error: cannot find the xctestrun file '#{path}'") unless File.exist?(path)
+            end
+          )
+        ]
+      end
+
+      def self.return_value
+        "A Hash of testable => tests, where testable is the name of the test target and tests is an array of test identifiers"
+      end
+
+      def self.authors
+        ["lyndsey-ferguson/lyndseydf"]
+      end
+
+      def self.is_supported?(platform)
+        platform == :ios
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/retry_tests/helper/correcting_scan_helper.rb

@@ -0,0 +1,164 @@
+module TestCenter
+  module Helper
+    require 'fastlane_core/ui/ui.rb'
+    require 'plist'
+
+    class CorrectingScanHelper
+      attr_reader :retry_total_count
+
+      def initialize(multi_scan_options)
+        @batch_count = multi_scan_options[:batch_count] || 1
+        @output_directory = multi_scan_options[:output_directory] || 'test_results'
+        @try_count = multi_scan_options[:try_count]
+        @retry_total_count = 0
+        @testrun_completed_block = multi_scan_options[:testrun_completed_block]
+        @given_custom_report_file_name = multi_scan_options[:custom_report_file_name]
+        @given_output_types = multi_scan_options[:output_types]
+        @given_output_files = multi_scan_options[:output_files]
+        @scan_options = multi_scan_options.reject do |option, _|
+          %i[
+            output_directory
+            only_testing
+            skip_testing
+            clean
+            try_count
+            batch_count
+            custom_report_file_name
+            fail_build
+            testrun_completed_block
+          ].include?(option)
+        end
+        @test_collector = TestCollector.new(multi_scan_options)
+      end
+
+      def scan
+        tests_passed = true
+        @testables_count = @test_collector.testables.size
+        @test_collector.testables.each do |testable|
+          tests_passed = scan_testable(testable) && tests_passed
+        end
+        tests_passed
+      end
+
+      def scan_testable(testable)
+        tests_passed = true
+        reportnamer = ReportNameHelper.new(
+          @given_output_types,
+          @given_output_files,
+          @given_custom_report_file_name
+        )
+        output_directory = @output_directory
+        testable_tests = @test_collector.testables_tests[testable]
+        if @batch_count > 1 || @testables_count > 1
+          current_batch = 1
+          testable_tests.each_slice((testable_tests.length / @batch_count.to_f).round).to_a.each do |tests_batch|
+            if @testables_count > 1
+              output_directory = File.join(@output_directory, "results-#{testable}")
+            end
+            FastlaneCore::UI.header("Starting test run on testable '#{testable}'")
+            tests_passed = correcting_scan(
+              {
+                only_testing: tests_batch,
+                output_directory: output_directory
+              },
+              current_batch,
+              reportnamer
+            ) && tests_passed
+            current_batch += 1
+            reportnamer.increment
+          end
+        else
+          options = {
+            output_directory: output_directory,
+            only_testing: testable_tests
+          }
+          tests_passed = correcting_scan(options, 1, reportnamer) && tests_passed
+        end
+        collate_reports(output_directory, reportnamer)
+        tests_passed
+      end
+
+      def collate_reports(output_directory, reportnamer)
+        report_files = Dir.glob("#{output_directory}/*#{reportnamer.junit_filextension}").map do |relative_filepath|
+          File.absolute_path(relative_filepath)
+        end
+        if report_files.size > 1
+          config = FastlaneCore::Configuration.create(
+            Fastlane::Actions::CollateJunitReportsAction.available_options,
+            {
+              reports: report_files.sort { |f1, f2| File.mtime(f1) <=> File.mtime(f2) },
+              collated_report: File.absolute_path(File.join(output_directory, reportnamer.junit_reportname))
+            }
+          )
+          Fastlane::Actions::CollateJunitReportsAction.run(config)
+        end
+        retried_junit_reportfiles = Dir.glob("#{output_directory}/**/*-[1-9]*#{reportnamer.junit_filextension}")
+        FileUtils.rm_f(retried_junit_reportfiles)
+      end
+
+      def correcting_scan(scan_run_options, batch, reportnamer)
+        scan_options = @scan_options.merge(scan_run_options)
+        try_count = 0
+        tests_passed = true
+        begin
+          try_count += 1
+          config = FastlaneCore::Configuration.create(
+            Fastlane::Actions::ScanAction.available_options,
+            scan_options.merge(reportnamer.scan_options)
+          )
+          quit_simulators
+          Fastlane::Actions::ScanAction.run(config)
+          @testrun_completed_block && @testrun_completed_block.call(
+            testrun_info(batch, try_count, reportnamer, scan_options[:output_directory])
+          )
+          tests_passed = true
+        rescue FastlaneCore::Interface::FastlaneTestFailure => e
+          FastlaneCore::UI.verbose("Scan failed with #{e}")
+          if try_count < @try_count
+            @retry_total_count += 1
+
+            info = testrun_info(batch, try_count, reportnamer, scan_options[:output_directory])
+            @testrun_completed_block && @testrun_completed_block.call(
+              info
+            )
+            scan_options[:only_testing] = info[:failed].map(&:shellescape)
+            FastlaneCore::UI.message('Re-running scan on only failed tests')
+            reportnamer.increment
+            retry
+          end
+          tests_passed = false
+        end
+        tests_passed
+      end
+
+      def testrun_info(batch, try_count, reportnamer, output_directory)
+        report_filepath = File.join(output_directory, reportnamer.junit_last_reportname)
+        config = FastlaneCore::Configuration.create(
+          Fastlane::Actions::TestsFromJunitAction.available_options,
+          {
+            junit: File.absolute_path(report_filepath)
+          }
+        )
+        junit_results = Fastlane::Actions::TestsFromJunitAction.run(config)
+
+        {
+          failed: junit_results[:failed],
+          passing: junit_results[:passing],
+          batch: batch,
+          try_count: try_count,
+          report_filepath: report_filepath
+        }
+      end
+
+      def quit_simulators
+        Fastlane::Actions.sh("killall -9 'iPhone Simulator' 'Simulator' 'SimulatorBridge' &> /dev/null || true", log: false)
+        launchctl_list_count = 0
+        while Fastlane::Actions.sh('launchctl list | grep com.apple.CoreSimulator.CoreSimulatorService || true', log: false) != ''
+          break if (launchctl_list_count += 1) > 10
+          Fastlane::Actions.sh('launchctl remove com.apple.CoreSimulator.CoreSimulatorService &> /dev/null || true', log: false)
+          sleep(1)
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/retry_tests/helper/junit_helper.rb

@@ -0,0 +1,94 @@
+require_relative 'xcodebuild_string'
+
+module TestCenter
+  module Helper
+    module XcodeJunit
+      require 'xcodeproj'
+
+      class Report
+        def initialize(junit_report_filepath)
+          report_file = File.open(junit_report_filepath) { |f| REXML::Document.new(f) }
+          UI.user_error!("Malformed XML test report file given") if report_file.root.nil?
+          UI.user_error!("Valid XML file is not an Xcode test report") if report_file.get_elements('testsuites').empty?
+
+          @testables = []
+          report_file.elements.each('testsuites') do |testsuites_element|
+            @testables << Testable.new(testsuites_element)
+          end
+        end
+
+        def testables
+          return @testables
+        end
+      end
+
+      class Testable
+        def initialize(xml_element)
+          @root = xml_element
+          @testsuites = []
+          @root.elements.each('testsuite') do |testsuite_element|
+            @testsuites << TestSuite.new(testsuite_element)
+          end
+        end
+
+        def name
+          return @root.attributes['name']
+        end
+
+        def testsuites
+          return @testsuites
+        end
+      end
+
+      class TestSuite
+        def initialize(xml_element)
+          @root = xml_element
+          @testcases = []
+          @root.elements.each('testcase') do |testcase_element|
+            @testcases << TestCase.new(testcase_element)
+          end
+        end
+
+        def name
+          return @root.attributes['name']
+        end
+
+        def identifier
+          name.testsuite
+        end
+
+        def is_swift?
+          return name.include?('.')
+        end
+
+        def testcases
+          return @testcases
+        end
+      end
+
+      class TestCase
+        attr_reader :identifier
+        attr_reader :skipped_test
+
+        def initialize(xml_element)
+          @root = xml_element
+          name = xml_element.attributes['name']
+          full_testsuite = xml_element.parent.attributes['name']
+          testsuite = full_testsuite.testsuite
+          is_swift = full_testsuite.testsuite_swift?
+
+          testable_filename = xml_element.parent.parent.attributes['name']
+          testable = File.basename(testable_filename, '.xctest')
+          @identifier = "#{testable}/#{testsuite}/#{name}"
+          @skipped_test = Xcodeproj::XCScheme::TestAction::TestableReference::SkippedTest.new
+          @skipped_test.identifier = "#{testsuite}/#{name}#{'()' if is_swift}"
+          @passed = xml_element.get_elements('failure').size.zero?
+        end
+
+        def passed?
+          @passed
+        end
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/retry_tests/helper/reportname_helper.rb

@@ -0,0 +1,70 @@
+module TestCenter
+  module Helper
+    require 'fastlane_core/ui/ui.rb'
+
+    class ReportNameHelper
+      def initialize(output_types = nil, output_files = nil, custom_report_file_name = nil)
+        @output_types = output_types || 'junit'
+        @output_files = output_files || custom_report_file_name
+        @report_count = 0
+
+        if @output_types && @output_files.nil?
+          @output_files = @output_types.split(',').map { |type| "report.#{type}" }.join(',')
+        end
+        unless @output_types.include?('junit')
+          FastlaneCore::UI.important('Scan output types missing \'junit\', adding it')
+          @output_types = @output_types.split(',').push('junit').join(',')
+          if @output_types.split(',').size == @output_files.split(',').size + 1
+            @output_files = @output_files.split(',').push('report.xml').join(',')
+            FastlaneCore::UI.message('As output files has one less than the new number of output types, assumming the filename for the junit was missing and added it')
+          end
+        end
+
+        types = @output_types.split(',').each(&:chomp)
+        files = @output_files.split(',').each(&:chomp)
+        unless files.size == types.size
+          raise ArgumentError, "Error: count of :output_types, #{types}, does not match the output filename(s) #{files}"
+        end
+      end
+
+      def numbered_filename(filename)
+        if @report_count > 0
+          basename = File.basename(filename, '.*')
+          extension = File.extname(filename)
+          filename = "#{basename}-#{@report_count + 1}#{extension}"
+        end
+        filename
+      end
+
+      def scan_options
+        files = @output_files.split(',').each(&:chomp)
+        files.map! do |filename|
+          filename.chomp
+          numbered_filename(filename)
+        end
+        {
+          output_types: @output_types,
+          output_files: files.join(',')
+        }
+      end
+
+      def junit_last_reportname
+        junit_index = @output_types.split(',').find_index('junit')
+        numbered_filename(@output_files.to_s.split(',')[junit_index])
+      end
+
+      def junit_reportname
+        junit_index = @output_types.split(',').find_index('junit')
+        @output_files.to_s.split(',')[junit_index]
+      end
+
+      def junit_filextension
+        File.extname(junit_reportname)
+      end
+
+      def increment
+        @report_count += 1
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/retry_tests/helper/test_collector.rb

@@ -0,0 +1,60 @@
+module TestCenter
+  module Helper
+    require 'fastlane_core/ui/ui.rb'
+    require 'plist'
+
+    class TestCollector
+      def initialize(options)
+        @xctestrun_path = options[:xctestrun] || derived_testrun_path(options[:derived_data_path], options[:scheme])
+        @only_testing = options[:only_testing]
+        @skip_testing = options[:skip_testing]
+      end
+
+      def derived_testrun_path(derived_data_path, scheme)
+        Dir.glob("#{derived_data_path}/Build/Products/#{scheme}*.xctestrun").first
+      end
+
+      def testables
+        unless @testables
+          if @only_testing
+            @testables ||= only_testing_to_testables_tests.keys
+          else
+            @testables ||= Plist.parse_xml(@xctestrun_path).keys
+          end
+        end
+        @testables
+      end
+
+      def only_testing_to_testables_tests
+        tests = Hash.new { |h, k| h[k] = [] }
+        @only_testing.sort.each do |test_identifier|
+          testable = test_identifier.split('/', 2)[0]
+          tests[testable] << test_identifier
+        end
+        tests
+      end
+
+      def testables_tests
+        unless @testables_tests
+          if @only_testing
+            @testables_tests = only_testing_to_testables_tests
+          else
+            config = FastlaneCore::Configuration.create(::Fastlane::Actions::TestsFromXctestrunAction.available_options, xctestrun: @xctestrun_path)
+            @testables_tests = ::Fastlane::Actions::TestsFromXctestrunAction.run(config)
+            if @skip_testing
+              skipped_testable_tests = Hash.new { |h, k| h[k] = [] }
+              @skip_testing.sort.each do |skipped_test_identifier|
+                testable = skipped_test_identifier.split('/', 2)[0]
+                skipped_testable_tests[testable] << skipped_test_identifier
+              end
+              @testables_tests.each_key do |testable|
+                @testables_tests[testable] -= skipped_testable_tests[testable]
+              end
+            end
+          end
+        end
+        @testables_tests
+      end
+    end
+  end
+end

data/lib/fastlane/plugin/retry_tests/helper/xcodebuild_string.rb

@@ -0,0 +1,14 @@
+
+class String
+  def testsuite_swift?
+    self.include?('.')
+  end
+
+  def testsuite
+    if self.testsuite_swift?
+      self.split('.')[1]
+    else
+      self
+    end
+  end
+end

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

@@ -0,0 +1,5 @@
+module Fastlane
+  module TestCenter
+    VERSION = "3.0.6"
+  end
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-retry_tests
 version: !ruby/object:Gem::Version
-  version: 1.2.9
+  version: 1.3.0
 platform: ruby
 authors:
 - Gloria Chow
@@ -187,6 +187,13 @@ files:
 - lib/fastlane/plugin/retry_tests/actions/suppress_tests_from_junit.rb
 - lib/fastlane/plugin/retry_tests/actions/suppressed_tests.rb
 - lib/fastlane/plugin/retry_tests/actions/tests_from_junit.rb
+- lib/fastlane/plugin/retry_tests/actions/tests_from_xctestrun.rb
+- lib/fastlane/plugin/retry_tests/helper/correcting_scan_helper.rb
+- lib/fastlane/plugin/retry_tests/helper/junit_helper.rb
+- lib/fastlane/plugin/retry_tests/helper/reportname_helper.rb
+- lib/fastlane/plugin/retry_tests/helper/test_collector.rb
+- lib/fastlane/plugin/retry_tests/helper/xcodebuild_string.rb
+- lib/fastlane/plugin/retry_tests/version.rb
 homepage: https://github.com/kouzoh/fastlane-plugin-retry_tests
 licenses:
 - MIT
@@ -210,5 +217,5 @@ rubyforge_project:
 rubygems_version: 2.6.14
 signing_key: 
 specification_version: 4
-summary: Makes testing your iOS app easier.
+summary: Makes testing your iOS app easier
 test_files: []