Merging TeamCityServiceMessageWriter with TeamCityReporter

Author: obtuse-whoosh

src/coverlet.core/Reporters/TeamCityReporter.cs

@@ -22,13 +22,53 @@ public string Report(CoverageResult result)
 
             // Report coverage
             var stringBuilder = new StringBuilder();
-            var teamCityServiceMessageWriter = new TeamCityServiceMessageWriter(s => stringBuilder.AppendLine(s));
-            teamCityServiceMessageWriter.OutputLineCoverage(overallLineCoverage);
-            teamCityServiceMessageWriter.OutputBranchCoverage(overallBranchCoverage);
-            teamCityServiceMessageWriter.OutputMethodCoverage(overallMethodCoverage);
+            OutputLineCoverage(overallLineCoverage, stringBuilder);
+            OutputBranchCoverage(overallBranchCoverage, stringBuilder);
+            OutputMethodCoverage(overallMethodCoverage, stringBuilder);
 
             // Return a placeholder
             return stringBuilder.ToString();
         }
+
+        private void OutputLineCoverage(CoverageDetails coverageDetails, StringBuilder builder)
+        {
+            // The total number of lines
+            OutputTeamCityServiceMessage("CodeCoverageL", coverageDetails.Total, builder);
+
+            // The number of covered lines
+            OutputTeamCityServiceMessage("CodeCoverageAbsLCovered", coverageDetails.Covered, builder);
+
+            // Line-level code coverage
+            OutputTeamCityServiceMessage("CodeCoverageAbsLTotal", coverageDetails.Percent * 100, builder);
+        }
+
+        private void OutputBranchCoverage(CoverageDetails coverageDetails, StringBuilder builder)
+        {
+            // The total number of branches
+            OutputTeamCityServiceMessage("CodeCoverageR", coverageDetails.Total, builder);
+
+            // The number of covered branches
+            OutputTeamCityServiceMessage("CodeCoverageAbsRCovered", coverageDetails.Covered, builder);
+
+            // Branch-level code coverage
+            OutputTeamCityServiceMessage("CodeCoverageAbsRTotal", coverageDetails.Percent * 100, builder);
+        }
+
+        private void OutputMethodCoverage(CoverageDetails coverageDetails, StringBuilder builder)
+        {
+            // The total number of methods
+            OutputTeamCityServiceMessage("CodeCoverageM", coverageDetails.Total, builder);
+
+            // The number of covered methods
+            OutputTeamCityServiceMessage("CodeCoverageAbsMCovered", coverageDetails.Covered, builder);
+
+            // Method-level code coverage
+            OutputTeamCityServiceMessage("CodeCoverageAbsMTotal", coverageDetails.Percent * 100, builder);
+        }
+
+        private void OutputTeamCityServiceMessage(string key, object value, StringBuilder builder)
+        {
+            builder.AppendLine($"##teamcity[buildStatisticValue key='{key}' value='{value}']");
+        }
     }
 }

src/coverlet.core/TeamCityServiceMessageWriter.cs

@@ -1,4 +1,4 @@
-using System;
+using coverlet.core.Reporters;
 using Xunit;
 
 namespace Coverlet.Core.Reporters.Tests
@@ -12,6 +12,7 @@ public void TestCreateReporter()
             Assert.Equal(typeof(LcovReporter), new ReporterFactory("lcov").CreateReporter().GetType());
             Assert.Equal(typeof(OpenCoverReporter), new ReporterFactory("opencover").CreateReporter().GetType());
             Assert.Equal(typeof(CoberturaReporter), new ReporterFactory("cobertura").CreateReporter().GetType());
+            Assert.Equal(typeof(TeamCityReporter), new ReporterFactory("teamcity").CreateReporter().GetType());
             Assert.Null(new ReporterFactory("").CreateReporter());
         }
     }

test/coverlet.core.tests/Reporters/ReporterFactoryTests.cs

@@ -0,0 +1,122 @@
+using coverlet.core.Reporters;
+using System;
+using Xunit;
+
+namespace Coverlet.Core.Reporters.Tests
+{
+    public class TestCreateReporterTests
+    {
+        private readonly CoverageResult _result;
+        private readonly TeamCityReporter _reporter;
+
+        public TestCreateReporterTests()
+        {
+            _reporter = new TeamCityReporter();
+            _result = new CoverageResult();
+            _result.Identifier = Guid.NewGuid().ToString();
+
+            var lines = new Lines { { 1, 1 }, { 2, 0 } };
+
+            var branches = new Branches
+            {
+                new BranchInfo
+                {
+                    Line = 1,
+                    Hits = 1,
+                    Offset = 23,
+                    EndOffset = 24,
+                    Path = 0,
+                    Ordinal = 1
+                },
+                new BranchInfo
+                {
+                    Line = 1,
+                    Hits = 0,
+                    Offset = 23,
+                    EndOffset = 27,
+                    Path = 1,
+                    Ordinal = 2
+                }
+            };
+
+            var methods = new Methods();
+            var methodString = "System.Void Coverlet.Core.Reporters.Tests.CoberturaReporterTests::TestReport()";
+            methods.Add(methodString, new Method());
+            methods[methodString].Lines = lines;
+            methods[methodString].Branches = branches;
+
+            var classes = new Classes { { "Coverlet.Core.Reporters.Tests.CoberturaReporterTests", methods } };
+
+            var documents = new Documents { { "doc.cs", classes } };
+
+            _result.Modules = new Modules { { "module", documents } };
+        }
+
+        [Fact]
+        public void OutputType_IsConsoleOutputType()
+        {
+            // Assert
+            Assert.Equal(ReporterOutputType.Console, _reporter.OutputType);
+        }
+
+        [Fact]
+        public void Format_IsExpectedValue()
+        {
+            // Assert
+            Assert.Equal("teamcity", _reporter.Format);
+        }
+
+        [Fact]
+        public void Format_IsNull()
+        {
+            // Assert
+            Assert.Null(_reporter.Extension);
+        }
+
+        [Fact]
+        public void Report_ReturnsNonNullString()
+        {
+            // Act
+            var output = _reporter.Report(_result);
+
+            // Assert
+            Assert.False(string.IsNullOrWhiteSpace(output), "Output is not null or whitespace");
+        }
+
+        [Fact]
+        public void Report_ReportsLineCoverage()
+        {
+            // Act
+            var output = _reporter.Report(_result);
+
+            // Assert
+            Assert.Contains("##teamcity[buildStatisticValue key='CodeCoverageL' value='2']", output);
+            Assert.Contains("##teamcity[buildStatisticValue key='CodeCoverageAbsLCovered' value='1']", output);
+            Assert.Contains("##teamcity[buildStatisticValue key='CodeCoverageAbsLTotal' value='50']", output);
+        }
+
+        [Fact]
+        public void Report_ReportsBranchCoverage()
+        {
+            // Act
+            var output = _reporter.Report(_result);
+
+            // Assert
+            Assert.Contains("##teamcity[buildStatisticValue key='CodeCoverageR' value='2']", output);
+            Assert.Contains("##teamcity[buildStatisticValue key='CodeCoverageAbsRCovered' value='1']", output);
+            Assert.Contains("##teamcity[buildStatisticValue key='CodeCoverageAbsRTotal' value='50']", output);
+        }
+
+        [Fact]
+        public void Report_ReportsMethodCoverage()
+        {
+            // Act
+            var output = _reporter.Report(_result);
+
+            // Assert
+            Assert.Contains("##teamcity[buildStatisticValue key='CodeCoverageM' value='1']", output);
+            Assert.Contains("##teamcity[buildStatisticValue key='CodeCoverageAbsMCovered' value='1']", output);
+            Assert.Contains("##teamcity[buildStatisticValue key='CodeCoverageAbsMTotal' value='100']", output);
+        }
+    }
+}