public void CanAnalyzeCodeBase_WithMultipleMetricsResults()
{
details.RepositorySourceType = RepositorySourceType.ECMA;
var eslintMetricsFile = $"{details.MetricsOutputFolder}\\{details.ProjectName}_eslint.xml";
var slocMetricsFile = $"{details.MetricsOutputFolder}\\{details.ProjectName}_sloc.csv";
fileSystem.Setup(x => x.GetProjectBuildFolder(details.ProjectName)).Returns(details.BuildOutputFolder);
fileSystem.Setup(x => x.CreateFolder(details.BuildOutputFolder));
var eslintResult = new MetricsResult {
MetricsFile = eslintMetricsFile, ParseType = ParseType.EsLint
};
var slocResult = new MetricsResult {
MetricsFile = slocMetricsFile, ParseType = ParseType.SlocEcma
};
metricsTaskFactory.Setup(x => x.GetStep(RepositorySourceType.ECMA)).Returns(metricsCommand.Object);
metricsCommand.Setup(x => x.Run(details)).Returns(new[] { eslintResult, slocResult });
var stringReader = new StringReader("foo");
fileSystem.Setup(x => x.OpenFileStream(eslintMetricsFile)).Returns(stringReader);
fileSystem.Setup(x => x.OpenFileStream(slocMetricsFile)).Returns(stringReader);
codebaseService.Setup(x => x.Get(stringReader, ParseType.EsLint)).Returns(CodeBase.Empty);
codebaseService.Setup(x => x.Get(stringReader, ParseType.SlocEcma)).Returns(CodeBase.Empty);
analyzerFactory.Setup(x => x.For(RepositorySourceType.ECMA)).Returns(analyzer.Object);
analyzer.Setup(x => x.Analyze(CodeBase.Empty().AllInstances)).Returns(CodeBase.Empty);
var results = analysisServices.Analyze(details);
results.Should().NotBeNull();
}
public IEnumerable <MetricsResult> Run(MetricsCommandArguments args)
{
var buildArgs = new ProjectBuildArguments(args.ProjectName, args.ProjectFile, args.RepositorySourceType, args.BuildOutputFolder);
projectBuilder.Build(buildArgs);
return(MetricsResult.Empty());
}
private CodeBase SetupSingleMetricAnalysis()
{
var codeBase = CodeBase.Empty();
var expectedMetricsFile = $"{details.MetricsOutputFolder}\\{details.ProjectName}_CheckStyles.xml";
var result = new MetricsResult {
MetricsFile = expectedMetricsFile, ParseType = ParseType.PuppyCrawler
};
fileSystem.Setup(x => x.GetProjectBuildFolder(details.ProjectName)).Returns(details.BuildOutputFolder);
fileSystem.Setup(x => x.CreateFolder(details.BuildOutputFolder));
metricsTaskFactory.Setup(x => x.GetStep(RepositorySourceType.Java)).Returns(metricsCommand.Object);
metricsCommand.Setup(x => x.Run(details)).Returns(new[] { result });
var stringReader = new StringReader("foo");
fileSystem.Setup(x => x.OpenFileStream(expectedMetricsFile)).Returns(stringReader);
codebaseService.Setup(x => x.Get(stringReader, ParseType.PuppyCrawler)).Returns(CodeBase.Empty);
analyzerFactory.Setup(x => x.For(RepositorySourceType.Java)).Returns(analyzer.Object);
analyzer.Setup(x => x.Analyze(codeBase.AllInstances)).Returns(codeBase);
return(codeBase);
}
public override string PrepareCommand(MetricsCommandArguments args, MetricsResult result)
{
var tokenThreshold = GetThreshold();
var languageToken = GetLanguageToken();
return(CpdCommand.FormatWith(LocateBinaries(ClassPath), languageToken, tokenThreshold, args.SourceDirectory, result.MetricsFile));
}
public void Send_NullObject_ReturnsArgumentNullException(IOutputFormatter formatter)
{
MetricsResult result = null;
formatter.Invoking(x => x.Format(result))
.Should().Throw <ArgumentNullException>();
}
/// <summary>
///
/// </summary>
protected override void Execute()
{
string filter = Tools.GenerateFilter(MetricNames, StartTime, EndTime, TimeGrain);
bool fullDetails = this.DetailedOutput.IsPresent;
MetricsResult metrics = GetMetricsResult(filter);
var result = metrics.Metrics.Select(_ => fullDetails ? new PSMetric(_) : new PSMetricNoDetails(_));
WriteObject(result, true);
}
public MetricsResult Run(MetricsCommandArguments args, string targetdll)
{
var result = new MetricsResult {
ParseType = ParseType.FxCop, MetricsFile = GetMetricsOutputFileName(args, targetdll)
};
var command = CommandTemplate.FormatWith(userPreferences.FxCopPath, targetdll, result.MetricsFile);
powerShell.Invoke(command);
return(result);
}
public override string PrepareCommand(MetricsCommandArguments args, MetricsResult result)
{
var cmd = CheckstyleCommand.FormatWith(
LocateBinaries("checkstyle-6.18-all.jar"), // include all jars into the class path
LocateSettings("metropolis_checkstyle_metrics.xml"), // metropolis collection settings for checkstyle
result.MetricsFile, // output xml file
args.SourceDirectory // source directory to scan
);
return(cmd);
}
public static List <MetricsResult> FilterMetricsResult(IQueryable <MetricElement> metrics,
GetSingleElementMetricRequest input)
{
var result = new List <MetricsResult>();
if (input.EndDate.HasValue && input.StartDate.HasValue)
{
metrics = DateHelper <MetricElement> .GetDateFilteredResult(metrics, input.StartDate.Value,
input.EndDate.Value, input.ByDay);
}
if (input.ByDay)
{
var query = metrics.GroupBy(a => new { a.CreationTime.Year, a.CreationTime.Month, a.CreationTime.Day })
.Select(i => new
{
i.Key.Year,
i.Key.Month,
i.Key.Day,
i
});
foreach (var element in query.ToList())
{
var metricsResult = new MetricsResult
{
Date = new DateTime(element.Year, element.Month, element.Day).ToString("dd-MMMM-yyyy"),
ElementsDtos = element.i.Select(a => a.MapTo <MetricDto>()).ToList()
};
result.Add(metricsResult);
}
return(result);
}
else
{
var query = metrics.GroupBy(a => new { a.CreationTime.Year, a.CreationTime.Month })
.Select(i => new
{
i.Key.Year,
i.Key.Month,
i
});
foreach (var element in query.ToList())
{
var metricsResult = new MetricsResult
{
Date = new DateTime(element.Year, element.Month, 1).ToString("MMMM-yyyy"),
ElementsDtos = element.i.Select(a => a.MapTo <MetricDto>()).ToList()
};
result.Add(metricsResult);
}
return(result);
}
}
public override string PrepareCommand(MetricsCommandArguments args, MetricsResult result)
{
var eslintConfigFile = GetEcmaDialect(args.EcmaScriptDialect);
var cmd = EsLintCommand.FormatWith(GetNodeBinPath(), LocateSettings(eslintConfigFile), args.SourceDirectory, result.MetricsFile);
if (args.IgnoreFile.IsNotEmpty())
{
cmd = string.Concat(cmd, IgnorePathPart.FormatWith(args.IgnoreFile));
}
return(cmd);
}
private void CompareMetric(MetricsResult result)
{
Assert.True(result.Metrics.Count > 0);
Assert.Equal(result.Metrics[0].Name.Value, "Availability");
Assert.Equal(result.Metrics[0].Name.LocalizedValue, "Availability");
Assert.Equal(result.Metrics[0].MetricUnit, MetricUnit.Count);
Assert.Equal(result.Metrics[0].StartTime.Date, DateTime.Parse("2015-3-16").Date);
Assert.Equal(result.Metrics[0].TimeGrain, TimeSpan.FromHours(1));
}
public void SetUp()
{
Args = new MetricsCommandArguments
{
IgnoreFile = @"C:\ignore",
ProjectName = "Test",
MetricsOutputFolder = $"{Environment.CurrentDirectory}",
SourceDirectory = @"C:\Source",
RepositorySourceType = RepositorySourceType.ECMA
};
Result = new MetricsResult {
ParseType = ParseType.SlocEcma, MetricsFile = @"C:\metrics_result.xml"
};
}
public async Task <MetricsResult> SaveMetricsResult(MetricsResult metricsResultEntity)
{
var existingEntity = await this.Context.MetricsResults.FindAsync(metricsResultEntity.MetricsResultId);
if (existingEntity == null)
{
this.Context.MetricsResults.Add(metricsResultEntity);
}
else
{
this.Context.MetricsResults.Update(metricsResultEntity);
}
await this.Context.SaveChangesAsync();
return(await this.Context.MetricsResults.FindAsync(metricsResultEntity.MetricsResultId));
}
static OutputFormatterTest()
{
JsonFormatter = new();
YamlFormatter = new();
CsvFormatter = new();
DateTime date = new(2021, 11, 21);
string sha = "da39a3ee5e6b4b0d3255bfef95601890afd80709";
LibYearResult libYearResult = new();
libYearResult.Add(new LibYearPackageResult("polyglot", "0.3.3", new DateTime(2011, 11, 01), "0.3.3", new DateTime(2011, 11, 01), 0.0, false, false));
s_metricsResultTestData = new(date, sha, libYearResult);
s_metricsResultListTestData = new List <MetricsResult>()
{
s_metricsResultTestData, s_metricsResultTestData
};
}
private static async Task MeasureRequest(SemaphoreSlim semaphore, WebServiceMetricsRequest request, WebServiceMetricsResponse response)
{
try
{
var httpClient = new HttpClient();
var uri = new Uri(request.RequestUrl);
var sw = new Stopwatch();
sw.Start();
var wsResponse = await httpClient.PostAsync(uri, new StringContent(request.RequestBody, Encoding.Unicode, "application/json"));
sw.Stop();
var metricsResultEntity = new MetricsResult()
{
MetricsRunId = response.WebServiceMetricsRunId,
TimeElapsedInMilliseconds = (int)sw.ElapsedMilliseconds,
Result = wsResponse.StatusCode.ToString()
};
//use separate repository each time since .NET/EF Core cannot multi-thread the same DbContext...
using (var repository = new MetricsRepository())
{
await repository.SaveMetricsResult(metricsResultEntity);
}
response.WebServiceMetricsResults.Add(new WebServiceMetricsResultDto
{
TimeElapsedInMilliseconds = metricsResultEntity.TimeElapsedInMilliseconds.ToString()
});
}
catch (Exception ex)
{
response.WebServiceMetricsResults.Add(new WebServiceMetricsResultDto()
{
ErrorMessage = ex.Message
});
}
finally
{
semaphore.Release();
}
}
/// <summary>
///
/// </summary>
protected override void Execute()
{
// Set the default start time and end time to last 24hours
if (EndTimeInUtc == DateTime.MinValue)
{
EndTimeInUtc = DateTime.UtcNow;
}
if (StartTimeInUtc == DateTime.MinValue)
{
StartTimeInUtc = EndTimeInUtc.AddDays(-1);
}
string filter = Tools.GenerateFilter(MetricNames, StartTimeInUtc, EndTimeInUtc, TimeGrain);
bool fullDetails = this.DetailedOutput.IsPresent;
MetricsResult metrics = GetMetricsResult(filter);
var result = metrics.Metrics.Select(_ => fullDetails ? new PSMetric(_) : new PSMetricNoDetails(_));
WriteObject(result, true);
}
static OutputFormatterTest()
{
JsonFormatter = new JsonOutputFormatter();
YamlFormatter = new YamlOutputFormatter();
CsvFormatter = new CsvOutputFormatter();
var date = new DateTime(2021, 11, 21);
var sha = "da39a3ee5e6b4b0d3255bfef95601890afd80709";
var libYearResult = new LibYearResult
{
new("polyglot", "0.3.3", new DateTime(2011, 11, 01), "0.3.3", new DateTime(2011, 11, 01), 0.0, false,
false)
};
s_metricsResultTestData = new MetricsResult(date, sha, libYearResult);
s_metricsResultListTestData = new List <MetricsResult>
{
s_metricsResultTestData,
s_metricsResultTestData
};
}
public void CanAnalyzeCodeBase_WithSingleMetricsResult()
{
var expectedMetricsFile = $"{details.MetricsOutputFolder}\\{details.ProjectName}_CheckStyles.xml";
var result = new MetricsResult {
MetricsFile = expectedMetricsFile, ParseType = ParseType.PuppyCrawler
};
metricsTaskFactory.Setup(x => x.GetStep(RepositorySourceType.Java)).Returns(metricsCommand.Object);
metricsCommand.Setup(x => x.Run(details)).Returns(new[] { result });
var stringReader = new StringReader("foo");
fileSystem.Setup(x => x.OpenFileStream(expectedMetricsFile)).Returns(stringReader);
codebaseService.Setup(x => x.Get(stringReader, ParseType.PuppyCrawler)).Returns(CodeBase.Empty);
analyzerFactory.Setup(x => x.For(RepositorySourceType.Java)).Returns(analyzer.Object);
analyzer.Setup(x => x.Analyze(CodeBase.Empty().AllInstances)).Returns(CodeBase.Empty);
var results = analysisServices.Analyze(details);
results.Should().NotBeNull();
}
private void CompareMetric(MetricsResult result)
{
Assert.True(result.Metrics.Count > 0);
Assert.Equal(result.Metrics[0].Name.Value, "Availability");
Assert.Equal(result.Metrics[0].Name.LocalizedValue, "Availability");
Assert.Equal(result.Metrics[0].MetricUnit, MetricUnit.Count);
Assert.Equal(result.Metrics[0].StartTime.Date, DateTime.Parse("2015-3-16").Date);
Assert.Equal(result.Metrics[0].TimeGrain, TimeSpan.FromHours(1));
}
public abstract string PrepareCommand(MetricsCommandArguments args, MetricsResult result);
public override string PrepareCommand(MetricsCommandArguments args, MetricsResult result)
{
return(runBadCommand? "this should fail" : $"dir | Out-File '{result.MetricsFile}'");
}
public override string PrepareCommand(MetricsCommandArguments args, MetricsResult result)
{
return(SlocCommand.FormatWith(GetNodeBinPath(), args.SourceDirectory, result.MetricsFile));
}
