Implement Cobertura coverage format

src/Main.ps1

@@ -382,6 +382,7 @@ function Invoke-Pester {
     Default value is: JaCoCo.
     Currently supported formats are:
     - JaCoCo - this XML file format is compatible with Azure Devops, VSTS/TFS
+    - Cobertura - this XML file format is compatible with Azure Devops, VSTS/TFS
 
     The ReportGenerator tool can be used to consolidate multiple reports and provide code coverage reporting.
     https://github.com/danielpalme/ReportGenerator
@@ -1154,10 +1155,13 @@ function Invoke-Pester {
                 $configuration = $run.PluginConfiguration.Coverage
 
                 if ("JaCoCo" -eq $configuration.OutputFormat -or "CoverageGutters" -eq $configuration.OutputFormat) {
-                    [xml] $jaCoCoReport = [xml] (Get-JaCoCoReportXml -CommandCoverage $breakpoints -TotalMilliseconds $totalMilliseconds -CoverageReport $coverageReport -Format $configuration.OutputFormat)
+                    [xml] $coverageXmlReport = [xml] (Get-JaCoCoReportXml -CommandCoverage $breakpoints -TotalMilliseconds $totalMilliseconds -CoverageReport $coverageReport -Format $configuration.OutputFormat)
+                }
+                elseif ("Cobertura" -eq $configuration.OutputFormat) {
+                    [xml] $coverageXmlReport = [xml] (Get-CoberturaReportXml -CommandCoverage $breakpoints -TotalMilliseconds $totalMilliseconds -CoverageReport $coverageReport)
                 }
                 else {
-                    throw "CodeCoverage.CoverageFormat must be 'JaCoCo' or 'CoverageGutters', but it was $($configuration.OutputFormat), please review your configuration."
+                    throw "CodeCoverage.CoverageFormat must be 'JaCoCo', 'CoverageGutters', or 'Cobertura' but it was $($configuration.OutputFormat), please review your configuration."
                 }
 
                 $settings = [Xml.XmlWriterSettings] @{
@@ -1172,7 +1176,7 @@ function Invoke-Pester {
                     $stringWriter = [Pester.Factory]::CreateStringWriter()
                     $xmlWriter = [Xml.XmlWriter]::Create($stringWriter, $settings)
 
-                    $jaCocoReport.WriteContentTo($xmlWriter)
+                    $coverageXmlReport.WriteContentTo($xmlWriter)
 
                     $xmlWriter.Flush()
                     $stringWriter.Flush()

src/Pester.RSpec.ps1

@@ -335,7 +335,7 @@ function New-PesterConfiguration {
       Enabled: Enable CodeCoverage.
       Default value: $false
 
-      OutputFormat: Format to use for code coverage report. Possible values: JaCoCo, CoverageGutters
+      OutputFormat: Format to use for code coverage report. Possible values: JaCoCo, CoverageGutters, Cobertura
       Default value: 'JaCoCo'
 
       OutputPath: Path relative to the current directory where code coverage report is saved.

src/csharp/Pester/CodeCoverageConfiguration.cs

@@ -42,7 +42,7 @@ public static CodeCoverageConfiguration ShallowClone(CodeCoverageConfiguration c
         public CodeCoverageConfiguration() : base("CodeCoverage configuration.")
         {
             Enabled = new BoolOption("Enable CodeCoverage.", false);
-            OutputFormat = new StringOption("Format to use for code coverage report. Possible values: JaCoCo, CoverageGutters", "JaCoCo");
+            OutputFormat = new StringOption("Format to use for code coverage report. Possible values: JaCoCo, CoverageGutters, Cobertura", "JaCoCo");
             OutputPath = new StringOption("Path relative to the current directory where code coverage report is saved.", "coverage.xml");
             OutputEncoding = new StringOption("Encoding of the output file.", "UTF8");
             Path = new StringArrayOption("Directories or files to be used for code coverage, by default the Path(s) from general settings are used, unless overridden here.", new string[0]);

src/functions/Coverage.ps1

@@ -1043,6 +1043,229 @@ function Get-JaCoCoReportXml {
     return $xml
 }
 
+function Get-CoberturaReportXml {
+    param (
+        [parameter(Mandatory = $true)]
+        $CommandCoverage,
+        [parameter(Mandatory = $true)]
+        [object] $CoverageReport,
+        [parameter(Mandatory = $true)]
+        [long] $TotalMilliseconds
+    )
+
+    if ($null -eq $CoverageReport -or ($pester.Show -eq [Pester.OutputTypes]::None) -or $CoverageReport.NumberOfCommandsAnalyzed -eq 0) {
+        return [string]::Empty
+    }
+
+    $now = & $SafeCommands['Get-Date']
+    $nineteenSeventy = & $SafeCommands['Get-Date'] -Date "01/01/1970"
+    [long] $endTime = [math]::Floor((New-TimeSpan -start $nineteenSeventy -end $now).TotalMilliseconds)
+    [long] $startTime = [math]::Floor($endTime - $TotalMilliseconds)
+
+    $commonRoot = Get-CommonParentPath -Path $CoverageReport.AnalyzedFiles
+
+    $allLines = @()
+    foreach ($line in $CoverageReport.HitCommands) {
+        $allLines += $line
+    }
+    foreach ($line in $CoverageReport.MissedCommands) {
+        $allLines += $line
+    }
+
+    $parentDirSelector = { & $SafeCommands["Split-Path"] $_.File -Parent }
+
+    $packageGroups = $CommandCoverage | & $SafeCommands["Group-Object"] -Property $parentDirSelector
+    $packages = foreach ($packageGroup in $packageGroups) {
+        $classGroups = $packageGroup.Group | & $SafeCommands["Group-Object"] -Property File
+        $classes = foreach ($classGroup in $classGroups) {
+            $methodGroups = $classGroup.Group | & $SafeCommands["Group-Object"] -Property Function
+            $methods = foreach ($methodGroup in $methodGroups) {
+                if (!$methodGroup.Name) {
+                    continue
+                }
+
+                $methodLineFilter = { $_.File -eq $classGroup.Name -and $_.Function -eq $methodGroup.Name }
+
+                $coveredLines = $CoverageReport.HitCommands `
+                | & $SafeCommands["Where-Object"] $methodLineFilter `
+                | & $SafeCommands["Group-Object"] -Property Line `
+                | New-LineNode
+
+                $lines = $allLines `
+                | & $SafeCommands["Where-Object"] $methodLineFilter `
+                | & $SafeCommands["Group-Object"] -Property Line `
+                | New-LineNode
+
+                $hits = [int](
+                    $lines.attributes.hits | & $SafeCommands["Measure-Object"] -Sum
+                ).Sum
+
+                $method = [ordered]@{
+                    name         = 'method'
+                    attributes   = [ordered]@{
+                        name = $methodGroup.Name
+                        hits = $hits
+                    }
+                    children     = [ordered]@{
+                        lines = $lines | & $SafeCommands["Sort-Object"] { [int]$_.attributes.number }
+                    }
+                    totalLines   = $lines.Length
+                    coveredLines = $coveredLines.Length
+                }
+
+                $method
+            }
+
+            $methodsTotalLines = ($methods.totalLines | & $SafeCommands["Measure-Object"] -Sum).Sum
+            $methodsCoveredLines = ($methods.coveredLines | & $SafeCommands["Measure-Object"] -Sum).Sum
+
+            $classLineFilter = { $_.File -eq $classGroup.Name -and -not $_.Function }
+
+            $coveredLines = $CoverageReport.HitCommands `
+            | & $SafeCommands["Where-Object"] $classLineFilter `
+            | & $SafeCommands["Group-Object"] -Property Line `
+            | New-LineNode
+
+            $lines = $allLines `
+            | & $SafeCommands["Where-Object"] $classLineFilter `
+            | & $SafeCommands["Group-Object"] -Property Line `
+            | New-LineNode
+
+            $totalLines = $lines.Length + $methodsTotalLines
+            $coveredLines = $coveredLines.Length + $methodsCoveredLines
+            $lineRate = Get-LineRate -CoveredLines $coveredLines -TotalLines $totalLines
+
+            $class = [ordered]@{
+                name         = 'class'
+                attributes   = [ordered]@{
+                    name          = (& $SafeCommands["Split-Path"] $classGroup.Name -Leaf)
+                    filename      = $classGroup.Name.Substring($commonRoot.Length)
+                    'line-rate'   = $lineRate
+                    'branch-rate' = 1
+                }
+                children     = [ordered]@{
+                    methods = $methods
+                    lines   = $lines | & $SafeCommands["Sort-Object"] { [int]$_.attributes.number }
+                }
+                totalLines   = $totalLines
+                coveredLines = $coveredLines
+            }
+
+            $class
+        }
+
+        $totalLines = ($classes.totalLines | & $SafeCommands["Measure-Object"] -Sum).Sum
+        $coveredLines = ($classes.coveredLines | & $SafeCommands["Measure-Object"] -Sum).Sum
+        $lineRate = Get-LineRate -CoveredLines $coveredLines -TotalLines $totalLines
+
+        $package = [ordered]@{
+            name         = 'package'
+            attributes   = [ordered]@{
+                name          = $packageGroup.Name.Substring($commonRoot.Length)
+                'line-rate'   = $lineRate
+                'branch-rate' = 0
+            }
+            children     = [ordered]@{
+                classes = $classes
+            }
+            totalLines   = $totalLines
+            coveredLines = $coveredLines
+        }
+
+        $package
+    }
+
+    $totalLines = ($packages.totalLines | & $SafeCommands["Measure-Object"] -Sum).Sum
+    $coveredLines = ($packages.coveredLines | & $SafeCommands["Measure-Object"] -Sum).Sum
+    $lineRate = Get-LineRate -CoveredLines $coveredLines -TotalLines $totalLines
+
+    $coverage = [ordered]@{
+        name       = 'coverage'
+        attributes = [ordered]@{
+            'lines-valid'      = $totalLines
+            'lines-covered'    = $coveredLines
+            'line-rate'        = $lineRate
+            'branches-valid'   = 0
+            'branches-covered' = 0
+            'branch-rate'      = 1
+            timestamp          = $startTime
+        }
+        children   = [ordered]@{
+            sources  = [ordered]@{
+                name  = 'source'
+                value = $commonRoot
+            }
+            packages = $packages
+        }
+    }
+
+    $xmlDeclaration = '<?xml version="1.0" ?>'
+    $docType = '<!DOCTYPE coverage SYSTEM "http://cobertura.sourceforge.net/xml/coverage-04.dtd">'
+    $coverageXml = ConvertTo-XElement -Node $coverage
+    $document = "$xmlDeclaration`n$docType`n$coverageXml"
+
+    $document
+}
+
+function New-LineNode {
+    param(
+        [parameter(Mandatory = $true, ValueFromPipeline = $true)] [object] $LineGroup
+    )
+
+    process {
+        [ordered]@{
+            name       = 'line'
+            attributes = [ordered]@{
+                number = [int]$LineGroup.Name
+                hits   = [int]($LineGroup.Group.HitCount | & $SafeCommands["Measure-Object"] -Sum).Sum
+            }
+        }
+    }
+}
+
+function Get-LineRate {
+    param(
+        [parameter(Mandatory = $true)] [int] $CoveredLines,
+        [parameter(Mandatory = $true)] [int] $TotalLines
+    )
+
+    [double]$denominator = if ($TotalLines) { $TotalLines } else { 1 }
+
+    $CoveredLines / $denominator
+}
+
+function ConvertTo-XElement {
+    param(
+        [parameter(Mandatory = $true)] [object] $Node
+    )
+
+    $element = [System.Xml.Linq.XElement]"<$($Node.name)/>"
+    if ($node.attributes) {
+        $attributes = $node.attributes
+        foreach ($attribute in $attributes.GetEnumerator()) {
+            $element.SetAttributeValue($attribute.Name, $attribute.Value)
+        }
+    }
+    if ($node.children) {
+        $children = $node.children
+        foreach ($child in $children.GetEnumerator()) {
+            $childElement = [System.Xml.Linq.XElement]"<$($child.Name)/>"
+            if ($child.Value.value) {
+                $childElement.SetValue($child.Value.value)
+            }
+            else {
+                $child.Value | & $SafeCommands["ForEach-Object"] {
+                    $childXml = ConvertTo-XElement $_
+                    $childElement.Add($childXml)
+                }
+            }
+            $element.Add($childElement)
+        }
+    }
+
+    $element
+}
+
 function Add-XmlElement {
     param (
         [parameter(Mandatory = $true)] [System.Xml.XmlNode] $Parent,
@@ -1051,14 +1274,23 @@ function Add-XmlElement {
     )
     $element = $Parent.AppendChild($Parent.OwnerDocument.CreateElement($Name))
     if ($Attributes) {
-        foreach ($key in $Attributes.Keys) {
-            $attribute = $element.Attributes.Append($Parent.OwnerDocument.CreateAttribute($key))
-            $attribute.Value = $Attributes.$key
-        }
+        Add-XmlAttribute -Element $element -Attributes $Attributes
     }
     return $element
 }
 
+function Add-XmlAttribute {
+    param(
+        [parameter(Mandatory = $true)] [System.Xml.XmlNode] $Element,
+        [parameter(Mandatory = $true)] [System.Collections.IDictionary] $Attributes
+    )
+
+    foreach ($key in $Attributes.Keys) {
+        $attribute = $Element.Attributes.Append($Element.OwnerDocument.CreateAttribute($key))
+        $attribute.Value = $Attributes.$key
+    }
+}
+
 function Add-JaCoCoCounter {
     param (
         [parameter(Mandatory = $true)] [ValidateSet('Instruction', 'Line', 'Method', 'Class')] [string] $Type,