fastlane-plugin-xcodetestcoverage 0.1.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: e68ffd67a7f11a0b779a70476d4cbe289171e17e85c65df4309c362a7e73c5ad
-  data.tar.gz: 2b0813c7cad6cae46c4994f73ec1b606d40b11d49ea520a7c3f2bfa22433e8d8
+  metadata.gz: 3f505a1904cbee1d299c96a6546ccba7b5fb0ca24793c743d91513ee31979d34
+  data.tar.gz: 91a090e60bb6510e6af7ed52850ea30177faa3b87b58c46842a3193e04af3387
 SHA512:
-  metadata.gz: 81f082e137ff49aeaef9b6c27e0bb62aa5fa0bf1ab5b60c9c4bd6d0ce1ee3628ae4d9fddcbcc00152d0258c6befd6d4a4e14b489519fa59a6c7d5942de9ed700
-  data.tar.gz: c3cc441fe110227dfc37442f69ef4cdaac32bad0fe0f466dd30a0ee2d0acb880d64cdcd3d282db4f4ab88c3484edb62abd1012ef51341abd6a1d7a2f9da715aa
+  metadata.gz: 66d5f90ab84f727386d65764df76464a9ac0a5d3e6647ee5ecc358a87050fc7e84a7280bc741fc74a54fc4f72172ce706d506717b97a0509b452cc08b9f0cbe9
+  data.tar.gz: 50d6728b59803e3cbeb9783b64483fd9fcf80b2d86f7952a1ffd4d2ce23f17ee39cffbf6c5e197cb397f6199e2cffa1fb763d8c0b728d16323a6c24c46384fd1

data/README.md

@@ -14,23 +14,56 @@ fastlane add_plugin xcodetestcoverage
 
 Plugin for getting test data from Xcode
 
-## Example
+It has to be run after tests.
+Returns hash contains keys: coverage, coveredLines, executableLines:
 
-Check out the [example `Fastfile`](fastlane/Fastfile) to see how to use this plugin. Try it by cloning the repo, running `fastlane install_plugins` and `bundle exec fastlane test`.
+```bash
+run_tests()
+result = xcodetestcoverage()
+puts(result["coverage"])
+puts(result["coveredLines"])
+puts(result["executableLines"])	
+```
 
-## Run tests for this plugin
+parameters: 
 
-To run both the tests, and code style validation, run
+minimumCoveragePercentage - Minimum acceptable coverage percentage. Call coverageExceptionCallback. Then raise error if overall coverage percentage is under this value and the option enableDefaultCoverageException is enabled", type: Float, optional: true.
 
-```
-rake
-```
+enableDefaultCoverageException - Raise error if overall coverage percentage is under this minimumCoveragePercentage and this option is enabled, optional: true, default_value: true
 
-To automatically fix many of the styling issues, use
+enableDataFailedException - Raise error if can not read the test data and this option is enabled optional: true, default_value: false
+
+dataFailedExceptionCallback - Optional data failed exception callback argument, optional: true,
+type: Proc
+
+coverageExceptionCallback - Optional coverage exception callback argument" optional: true, type: Proc
+
+## Example
+
+Check out the [example `Fastfile`](fastlane/Fastfile) to see how to use this plugin. Try it by cloning the repo, running `fastlane install_plugins` and `bundle exec fastlane tests`.
+
+If you need to throw an exception on coverage percantage, set the parameter minimumCoveragePercentage. If you want to call your code in this case set coverageExceptionCallback. 
+You can disable defaultException if you set enableDefaultCoverageException = false.
+
+```bash
+xcodetestcoverage(minimumCoveragePercentage: 40.0,
+                  coverageExceptionCallback: ->(value) { 
+                  	UI.message("Test coverage failed #{value}") 
+                  })
 ```
-rubocop -a
+
+If you need to throw an exception on test data read error, set the parameter enableDataFailedException = true. If you want to call your code in this case set dataFailedExceptionCallback.
+
+```bash
+xcodetestcoverage(minimumCoveragePercentage: 45.0,
+                  enableDataFailedException: true,
+                  dataFailedExceptionCallback: ->() { 
+			UI.message("Data reading error")
+		  }
+)
 ```
 
+
 ## Issues and Feedback
 
 For any other issues and feedback about this plugin, please submit it to this repository.

data/lib/fastlane/plugin/xcodetestcoverage/actions/xcodetestcoverage_action.rb

@@ -5,42 +5,108 @@ module Fastlane
   module Actions
     class XcodetestcoverageAction < Action
       def self.run(params)
-        UI.message("The xcodetestcoverage plugin is working!")
+        enableDataFailedException = params[:enableDataFailedException]
+	      minimumCoveragePercentage = params[:minimumCoveragePercentage]
+        enableDefaultCoverageException = params[:enableDefaultCoverageException]
+        lineCoverage = nil
+        coveredLines = nil
+        executableLines = nil
+        
+        filePath = lane_context[SharedValues::SCAN_DERIVED_DATA_PATH]   
+
+        if filePath && File.exists?(filePath)
+          jsonResult = sh "xcrun xccov view --only-targets --report #{filePath} --json"
+          if lineCoverageMatch = jsonResult.match('.*lineCoverage":(\d+.\d+).*')
+            lineCoverage = lineCoverageMatch.captures[0].to_f * 100
+            UI.message("Xcodetestcoverage: coverage: #{lineCoverage}")
+          end
+
+          if coveredLinesMatch = jsonResult.match('.*coveredLines":(\d+).*')
+            coveredLines = coveredLinesMatch.captures[0].to_i
+            UI.message("Xcodetestcoverage: coveredLines: #{coveredLines}")
+          end
+
+          if executableLineMatch = jsonResult.match('.*executableLines":(\d+).*')
+            executableLines = executableLineMatch.captures[0].to_i
+            UI.message("Xcodetestcoverage: executableLines: #{executableLines}")
+          end
+        end
+        
+        if !lineCoverage
+          params[:dataFailedExceptionCallback].call() if params[:dataFailedExceptionCallback]
+          UI.user_error!("Xcodetestcoverage: Test data reading error!") if enableDataFailedException
+          return
+        end
+
+        if minimumCoveragePercentage && lineCoverage < minimumCoveragePercentage
+          params[:coverageExceptionCallback].call(minimumCoveragePercentage) if params[:coverageExceptionCallback]
+          UI.user_error!("Xcodetestcoverage: Coverage percentage is less than #{minimumCoveragePercentage} (minimumCoveragePercentage)") if enableDefaultCoverageException
+        end
+        
+        return {
+          "coverage" => lineCoverage,
+          "coveredLines" => coveredLines,
+          "executableLines" => executableLines,
+        }
       end
 
       def self.description
-        "plugin for getting test data from Xcode"
+        "plugin for getting coverage test data from Xcode"
       end
 
       def self.authors
         ["Yury Savitsky"]
       end
 
-      def self.return_value
-        # If your method provides a return value, you can describe here what it does
+      def self.return_value        
+	      "returns hash contains keys: coverage, coveredLines, executableLines"
       end
 
       def self.details
-        # Optional:
         "plugin for getting test data from Xcode"
       end
 
       def self.available_options
-        [
-          # FastlaneCore::ConfigItem.new(key: :your_option,
-          #                         env_name: "XCODETESTCOVERAGE_YOUR_OPTION",
-          #                      description: "A description of your option",
-          #                         optional: false,
-          #                             type: String)
+	      [
+	      FastlaneCore::ConfigItem.new(
+          key: :minimumCoveragePercentage,
+	        env_name: "XCODETESTCOVERAGE_MINIMUM_COVERAGE_PERCENTAGE",
+	        description: "Minimum acceptable coverage percentage. Call coverageExceptionCallback. Then raise error if overall coverage percentage is under this value and the option enableDefaultCoverageException is enabled",
+	        type: Float,
+	        optional: true),
+
+        FastlaneCore::ConfigItem.new(
+	        key: :enableDefaultCoverageException,
+	        env_name: "XCODETESTCOVERAGE_ENABLE_DEFAULT_COVERAGE_EXCEPTION",
+	        description: "Raise error if overall coverage percentage is under this minimumCoveragePercentage and this option is enabled",
+          optional: true,
+          default_value: true,
+          is_string: false),
+
+	      FastlaneCore::ConfigItem.new(
+	        key: :enableDataFailedException,
+	        env_name: "XCODETESTCOVERAGE_ENABLE_DATA_FAILED_EXCEPTION",
+	        description: "Raise error if can not read the test data and this option is enabled",
+          optional: true,
+          default_value: false,
+          is_string: false),
+
+	      FastlaneCore::ConfigItem.new(
+	        key: :dataFailedExceptionCallback,
+	        description: "Optional data failed exception callback argument",
+	        optional: true,
+	        type: Proc),
+        
+        FastlaneCore::ConfigItem.new(
+	        key: :coverageExceptionCallback,
+	        description: "Optional coverage exception callback argument",
+	        optional: true,
+	        type: Proc)
         ]
       end
 
       def self.is_supported?(platform)
-        # Adjust this if your plugin only works for a particular platform (iOS vs. Android, for example)
-        # See: https://docs.fastlane.tools/advanced/#control-configuration-by-lane-and-by-platform
-        #
-        # [:ios, :mac, :android].include?(platform)
-        true
+        [:ios, :mac].include?(platform)
       end
     end
   end

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

@@ -1,5 +1,5 @@
 module Fastlane
   module Xcodetestcoverage
-    VERSION = "0.1.0"
+    VERSION = "1.0.0"
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: fastlane-plugin-xcodetestcoverage
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 1.0.0
 platform: ruby
 authors:
 - Yury Savitsky
 autorequire:
 bindir: bin
 cert_chain: []
-date: 2023-02-18 00:00:00.000000000 Z
+date: 2023-02-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler