/// <summary>
/// Run the coverage tool
/// </summary>
/// <returns></returns>
protected override StageCompletionStatusEnum ExecuteProcess()
{
if (!CISession.SlugCIConfigObj.UseCodeCoverage)
{
Logger.Info("Code Coverage is not enabled for this solution.");
return(StageCompletionStatusEnum.Skipped);
}
FileSystemTasks.EnsureExistingDirectory(CISession.CoveragePath);
ReportGeneratorSettings settings = new ReportGeneratorSettings()
{
ProcessWorkingDirectory = CISession.CoveragePath,
TargetDirectory = CISession.CoveragePath,
ProcessToolPath = "reportgenerator",
ReportsInternal = new List <string>()
{
"coverage.cobertura.xml"
},
ReportTypesInternal = new List <ReportTypes>()
{
ReportTypes.Badges,
ReportTypes.HtmlInline
},
};
AbsolutePath coverageFile = CISession.CoveragePath / "index.html";
SlugCmdProcess slugCmdProcess = new SlugCmdProcess("Code Coverage", SlugCmdProcess.GetDefaultProcessSettings());
Process.Start(@"cmd.exe ", @"/c " + coverageFile);
// TODO Await completion
return(StageCompletionStatusEnum.Success);
}
public override void Run(BuildContext context)
{
string rootDir = context.RootDirectory;
//string solutionPath = Path.Combine(rootDir, "XUnit.Coverage.sln"); ;
//context.DotNetBuild(solutionPath, new DotNetBuildSettings { Configuration = "Release", NoLogo = true });
string testResultsDir = System.IO.Path.Combine(rootDir, $@"build\testResults_{nameof(testCoverletXPlatCollector)}");
if (Directory.Exists(testResultsDir))
{
Directory.Delete(testResultsDir, true);
}
if (!Directory.Exists(testResultsDir))
{
Directory.CreateDirectory(testResultsDir);
}
string coverageRunsettings = System.IO.Path.Combine(rootDir, "coverlet.runsettings");;
string projectPath = System.IO.Path.Combine(rootDir, @"XUnit.Coverlet.Collector\XUnit.Coverlet.Collector.csproj");;
var testSettings = new DotNetCoreTestSettings
{
Settings = coverageRunsettings,
Collectors = new[] { "XPlat Code Coverage" },
Configuration = "Release",
ResultsDirectory = testResultsDir,
};
context.DotNetCoreTest(projectPath, testSettings);
string coverageHtml = System.IO.Path.Combine(testResultsDir, "html");
LogInfo($"Generating report in {coverageHtml}");
var repSettings = new ReportGeneratorSettings();
//repSettings.ReportTypes.Add(ReportGeneratorReportType.HtmlSummary);
context.ReportGenerator(
new GlobPattern($@"{testResultsDir}\**\*.xml"),
new DirectoryPath(coverageHtml), repSettings);
}
public static void MergeReports(this BuildContext context, string pattern, ReportGeneratorReportType type, string subFolder)
{
var ReportGeneratorSettings = new ReportGeneratorSettings()
{
AssemblyFilters = new[]
{
"-MvvmScarletToolkit.Tests*",
"-nunit3*",
},
ClassFilters = new[]
{
"-System*",
"-Microsoft*",
},
ReportTypes = new[]
{
type
},
};
context.ReportGenerator(new GlobPattern(pattern), context.ReportsFolder.Combine(subFolder), ReportGeneratorSettings);
}
public override void Run(BuildContext context)
{
string rootDir = context.RootDirectory;
string testResultsDir = System.IO.Path.Combine(rootDir, $@"build\testResults_{nameof(testCoverletEnableCoverage)}");
if (Directory.Exists(testResultsDir))
{
Directory.Delete(testResultsDir, true);
}
if (!Directory.Exists(testResultsDir))
{
Directory.CreateDirectory(testResultsDir);
}
string coverageRunsettings = Path.Combine(rootDir, ".runsettings");;
string projectPath = Path.Combine(rootDir, @"XUnit.Coverlet.MSBuild\XUnit.Coverlet.MSBuild.csproj");;
var coverletSettings = new CoverletSettings
{
CollectCoverage = true,
CoverletOutputFormat = CoverletOutputFormat.opencover,
CoverletOutputDirectory = testResultsDir,
CoverletOutputName = "coverage.xml"
};
var testSettings = new DotNetCoreTestSettings
{
//NoBuild = true,
Settings = coverageRunsettings,
ArgumentCustomization = args =>
{
//args.Append(new TextArgument("/p:SolutionName=XUnit.Coverage"));
//args.Append(new TextArgument($"/p:SolutionDir={rootDir}\\src\\"));
return(args);
},
Configuration = "Release",
ResultsDirectory = testResultsDir,
//Verbosity = DotNetCoreVerbosity.Detailed,
//OutputDirectory - is from where to take dll.
//OutputDirectory = testResultsDir
};
context.DotNetCoreTest(projectPath, testSettings, coverletSettings);
string coverageHtml = System.IO.Path.Combine(testResultsDir, "html");
if (Directory.Exists(coverageHtml))
{
Directory.Delete(coverageHtml, true);
}
string coverageXml = System.IO.Path.Combine(testResultsDir, "coverage.xml");
LogInfo($"Generating report in {coverageHtml}");
var repSettings = new ReportGeneratorSettings();
//repSettings.ReportTypes.Add(ReportGeneratorReportType.HtmlSummary);
context.ReportGenerator(
new Cake.Core.IO.GlobPattern(coverageXml),
new Cake.Core.IO.DirectoryPath(coverageHtml), repSettings);
}
public async Task Get_ShouldValidatePerformanceWith4Threads()
{
List <Bill> bills = new List <Bill>()
{
new Bill()
{
DueDate = new DateTime(2021, 03, 15), PersonId = "89971312069", Value = 33
},
new Bill()
{
DueDate = new DateTime(2021, 03, 15), PersonId = "30254863094", Value = 44
},
new Bill()
{
DueDate = new DateTime(2021, 03, 15), PersonId = "89971312069", Value = 55
},
new Bill()
{
DueDate = new DateTime(2021, 03, 15), PersonId = "30254863094", Value = 78.4
},
new Bill()
{
DueDate = new DateTime(2021, 03, 15), PersonId = "89971312069", Value = 89.3
},
new Bill()
{
DueDate = new DateTime(2021, 03, 15), PersonId = "88873823017", Value = 1
},
};
Dictionary <string, string> personIdToState = new Dictionary <string, string>()
{
{ "89971312069", "SP" },
{ "30254863094", "RJ" },
{ "88873823017", "SP" }
};
int numberOfThreads = 4;
DateTime startTime;
DateTime endTime;
int month = 3;
Moq.Mock <IBillingApiService> mockBillingApiService = new Moq.Mock <IBillingApiService>();
mockBillingApiService.Setup(billsService => billsService.GetByMonthAsync(It.IsAny <int>()))
.ReturnsAsync(bills);
Moq.Mock <ICustomerApiService> mockCustomerApiService = new Moq.Mock <ICustomerApiService>();
mockCustomerApiService.Setup(customersService => customersService.GetCustomerAsync(It.IsAny <string>()))
.ReturnsAsync((string personId) => new Customer()
{
Cpf = personId,
Name = String.Empty,
State = personIdToState[personId]
});
Moq.Mock <ILogger <ReportController> > mockLogger = new Moq.Mock <ILogger <ReportController> >();
ReportGeneratorSettings reportGeneratorSettings = new ReportGeneratorSettings()
{
MaxNumberOfConcurrentTasks = numberOfThreads
};
ReportController reportController = new ReportController(mockLogger.Object, reportGeneratorSettings,
mockBillingApiService.Object, mockCustomerApiService.Object);
startTime = DateTime.Now;
StateBillingReport response = await reportController.GetStatesBillingByMonth(month);
endTime = DateTime.Now;
double expectedTiming = 350;
double actualTiming = (int)(endTime - startTime).TotalMilliseconds;
Assert.True(actualTiming <= expectedTiming, $"Actual timing is {actualTiming} milliseconds. Expected {expectedTiming} milliseconds");
}
public async Task Get_ShouldValidateBillValueByState()
{
bool isCalculatedRight = true;
List <Bill> bills = new List <Bill>()
{
new Bill()
{
DueDate = new DateTime(2021, 03, 15), PersonId = "89971312069", Value = 33
},
new Bill()
{
DueDate = new DateTime(2021, 03, 15), PersonId = "30254863094", Value = 44
},
new Bill()
{
DueDate = new DateTime(2021, 03, 15), PersonId = "89971312069", Value = 55
},
new Bill()
{
DueDate = new DateTime(2021, 03, 15), PersonId = "30254863094", Value = 78.4
},
new Bill()
{
DueDate = new DateTime(2021, 03, 15), PersonId = "89971312069", Value = 89.3
},
new Bill()
{
DueDate = new DateTime(2021, 03, 15), PersonId = "88873823017", Value = 1
},
};
Dictionary <string, string> personIdToState = new Dictionary <string, string>()
{
{ "89971312069", "SP" },
{ "30254863094", "RJ" },
{ "88873823017", "SP" }
};
int month = 3;
Moq.Mock <IBillingApiService> mockBillingApiService = new Moq.Mock <IBillingApiService>();
mockBillingApiService.Setup(billsService => billsService.GetByMonthAsync(It.IsAny <int>()))
.ReturnsAsync(bills);
Moq.Mock <ICustomerApiService> mockCustomerApiService = new Moq.Mock <ICustomerApiService>();
mockCustomerApiService.Setup(customersService => customersService.GetCustomerAsync(It.IsAny <string>()))
.ReturnsAsync((string personId) => new Customer()
{
Cpf = personId, Name = String.Empty,
State = personIdToState[personId]
});
Moq.Mock <ILogger <ReportController> > mockLogger = new Moq.Mock <ILogger <ReportController> >();
ReportGeneratorSettings reportGeneratorSettings = new ReportGeneratorSettings()
{
MaxNumberOfConcurrentTasks = 4
};
ReportController reportController = new ReportController(mockLogger.Object, reportGeneratorSettings,
mockBillingApiService.Object, mockCustomerApiService.Object);
StateBillingReport response = await reportController.GetStatesBillingByMonth(month);
foreach (StateBilling stateBilling in response.StateBillingList)
{
if (bills.Where(b => b.DueDate.Month == month && personIdToState[b.PersonId] == stateBilling.State)
.Sum(b => b.Value) != stateBilling.Value)
{
isCalculatedRight = false;
break;
}
}
Assert.True(isCalculatedRight);
}
public override void Run(BuildContext context)
{
bool enableCodeCoverage = (context.cmdArgs.codecoverage.HasValue) ? context.cmdArgs.codecoverage.Value : false;
if (!enableCodeCoverage)
{
LogInfo($"--{nameof(CommandLineArgs.codecoverage)} not selected, skipping");
return;
}
string rootDir = context.RootDirectory;
string testResultsDir = context.TestResultsDirectory;
ReportGeneratorSettings coverageSettings = new ReportGeneratorSettings();
foreach (string covFormatStr in helpers.split(context.cmdArgs.coverageFormats))
{
var covFormat = (ReportGeneratorReportType)Enum.Parse(typeof(ReportGeneratorReportType), covFormatStr);
coverageSettings.ReportTypes.Add(covFormat);
}
string coverageHtml = System.IO.Path.Combine(rootDir, @"build_output\build_artifacts\codecoverage\Html");
if (Directory.Exists(coverageHtml))
{
Directory.Delete(coverageHtml, true);
}
switch (context.cmdArgs.coverageMethod)
{
case "vs":
{
string coveragePath = Directory.GetFiles(testResultsDir, "*.coverage", SearchOption.AllDirectories).First();
string coverageXml = Path.Combine(testResultsDir, "vs_coverage.xml");
if (File.Exists(coverageXml))
{
File.Delete(coverageXml);
}
LogInfo($"Converting *.coverage to vs_coverage.xml file format...");
context.ConvertCoverageReport(coveragePath, coverageXml);
LogInfo($"Generating report in {coverageHtml}...");
context.ReportGenerator(
new Cake.Core.IO.GlobPattern(coverageXml),
new Cake.Core.IO.DirectoryPath(coverageHtml),
coverageSettings);
}
break;
case "coverlet":
{
LogInfo($"Generating report in {coverageHtml}...");
context.ReportGenerator(
new Cake.Core.IO.GlobPattern($@"{testResultsDir}\**\*.opencover.xml"),
new Cake.Core.IO.DirectoryPath(coverageHtml),
coverageSettings);
}
break;
default:
throw new Exception($"Unknown coverage method: --{nameof(CommandLineArgs.coverageMethod)} {context.cmdArgs.coverageMethod}");
}
// Upload to report to GitHub if running in there.
if (context.BuildSystem().IsRunningOnGitHubActions)
{
// Coverage summary
string htmlSummaryPath = Path.Combine(coverageHtml, "summary.html");
if (File.Exists(htmlSummaryPath))
{
LogInfo($"Uploading code coverage test results, 1 ({htmlSummaryPath})...");
context.BuildSystem().GitHubActions.Commands.UploadArtifact(new Cake.Core.IO.FilePath(htmlSummaryPath), "CoverageShortSummary").GetAwaiter().GetResult();
File.Delete(htmlSummaryPath);
htmlSummaryPath = Path.Combine(coverageHtml, "summary.htm");
if (File.Exists(htmlSummaryPath))
{
File.Delete(htmlSummaryPath);
}
}
//Entire coverage report
LogInfo($"Uploading code coverage test results, 2 ({coverageHtml})...");
context.BuildSystem().GitHubActions.Commands.UploadArtifact(new Cake.Core.IO.DirectoryPath(coverageHtml), "CoverageFullReport").GetAwaiter().GetResult();
}
}
