public IEnumerable <MetricsResult> Run(MetricsCommandArguments args)
{
var buildArgs = new ProjectBuildArguments(args.ProjectName, args.ProjectFile, args.RepositorySourceType, args.BuildOutputFolder);
projectBuilder.Build(buildArgs);
return(MetricsResult.Empty());
}
public void SetUp()
{
metricsTaskFactory = CreateMock <ICollectionStepFactory>();
codebaseService = CreateMock <ICodebaseService>();
metricsCommand = CreateMock <ICollectionStep>();
analyzerFactory = CreateMock <IAnalyzerFactory>();
analyzer = CreateMock <ICodebaseAnalyzer>();
fileSystem = CreateMock <IFileSystem>();
fileDeserializer = CreateMock <IYamlFileDeserializer <MetricsCommandArguments> >();
details = new MetricsCommandArguments
{
RepositorySourceType = RepositorySourceType.Java,
ProjectName = "test",
SourceDirectory = @"c:\mySourceCode\JavaProject",
MetricsOutputFolder = @"c:\myMetricsOutput",
BuildOutputFolder = @"C:\roaming\buildoutput\test",
};
projectFile = $@"{ProjectPath}\{details.ProjectName}.project";
fileSystem.Setup(x => x.MetricsOutputFolder).Returns(@"C:\roaming\metrics");
fileSystem.Setup(x => x.CreateFolder(fileSystem.Object.MetricsOutputFolder));
analysisServices = new AnalysisServices(metricsTaskFactory.Object, codebaseService.Object, analyzerFactory.Object, fileSystem.Object,
fileDeserializer.Object);
}
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 CodeBase Analyze(MetricsCommandArguments details)
{
var command = collectionStepFactory.GetStep(details.RepositorySourceType);
details.MetricsOutputFolder = fileSystem.MetricsOutputFolder;
details.BuildOutputFolder = fileSystem.GetProjectBuildFolder(details.ProjectName);
fileSystem.CreateFolder(details.BuildOutputFolder);
var metricsResults = command.Run(details);
var codeBase = CodeBase.Empty();
foreach (var x in metricsResults)
{
var filename = x.MetricsFile;
var cb = codebaseService.Get(fileSystem.OpenFileStream(filename), x.ParseType);
codeBase.Enrich(new CodeGraph(cb.AllInstances));
}
var codebase = analyzerFactory.For(details.RepositorySourceType).Analyze(codeBase.AllInstances);
codebase.SourceType = details.RepositorySourceType;
codebase.Name = details.ProjectName;
return(codebase);
}
public IEnumerable <MetricsResult> Run(MetricsCommandArguments args)
{
var results = new List <MetricsResult>();
assemblyCollection.GatherAssemblies(args).AsParallel().ForAll(x => results.Add(metricsTask.Run(args, x)));
return(results);
}
private IEnumerable <MetricsResult> RunInParallel(MetricsCommandArguments args)
{
var results = new List <MetricsResult>();
Commands.AsParallel().ForAll(x => results.AddRange(x.Run(args)));
return(results);
}
public IEnumerable <string> GatherAssemblies(MetricsCommandArguments args)
{
var assembliesToIgnore = filesystem.ReadIgnoreFile(args.IgnoreFile);
var toDoList = filesystem.GetFiles(args.BuildOutputFolder, "*.dll")
.Union(filesystem.GetFiles(args.BuildOutputFolder, "*.exe"))
.Where(file => !assembliesToIgnore.Any(file.EndsWith)).ToList();
return(toDoList);
}
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);
}
private static bool ComparesTo(ProjectDetailsViewModel viewModel, MetricsCommandArguments actual)
{
Validate.Begin()
.IsNotNull(viewModel, "viewModel")
.IsNotNull(actual, "actual")
.IsEqual(viewModel.RepositorySourceType, actual.RepositorySourceType, "SourceType")
.IsEqual(viewModel.ProjectName, actual.ProjectName, "projectName")
.Check();
return(true);
}
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 void CanCollectFxCopMetrics()
{
var args = new MetricsCommandArguments();
const string assembly = "myAssembly.dll";
assemblyCollection.Setup(x => x.GatherAssemblies(args)).Returns(new[] { assembly });
metricsTask.Setup(x => x.Run(args, assembly)).Returns(new MetricsResult());
var results = step.Run(args);
results.Should().NotBeEmpty();
results.Count().Should().Be(1);
}
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);
}
public void BeforeEachTest()
{
step = new CollectionStepForTesting();
args = new MetricsCommandArguments
{
ProjectName = "Test", IgnoreFile = null,
MetricsOutputFolder = $"{AppDomain.CurrentDomain.BaseDirectory}",
RepositorySourceType = RepositorySourceType.CSharp, SourceDirectory = $"{AppDomain.CurrentDomain.BaseDirectory}"
};
expectedCommandFile = $"{args.MetricsOutputFolder}\\{args.ProjectName}_{step.MetricsType}_command.ps1";
expectedCommandFile.RemoveFileIfExists();
}
private void SaveAndExecuteCommand(MetricsCommandArguments args, string command)
{
try
{
Logger.Info($"Command: {command} {args}");
SaveMetricsCommand(args, command);
InvokeCommand(command);
}
catch (Exception e)
{
Logger.Error(e, "Error occurred trying to exeucte an external process");
throw new ApplicationException("Error occurred trying to exeucte an external process", e);
}
}
public IEnumerable <MetricsResult> Run(MetricsCommandArguments args)
{
var result = MetricResultFor(args);
var command = PrepareCommand(args, result);
SaveAndExecuteCommand(args, command);
var validationResult = ValidateMetricResults(GetOutputFile(args));
if (validationResult != string.Empty)
{
Logger.Error("Step Validation Error for " + validationResult);
throw new ApplicationException("Step Validation Error for " + validationResult);
}
return(new[] { result });
}
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 void Should_Run_Both_Steps()
{
var args = new MetricsCommandArguments();
step1.Setup(x => x.Run(args)).Returns(new[] { new MetricsResult {
MetricsFile = "one"
} });
step2.Setup(x => x.Run(args)).Returns(new[] { new MetricsResult {
MetricsFile = "two"
} });
compositeStep = new CompositeCollectionStep(new[] { step1.Object, step2.Object }, false);
var results = compositeStep.Run(args);
results.Should().NotBeNull();
results.Count().Should().Be(2);
}
public void SetUp()
{
fileSystem = CreateMock <IFileSystem>();
args = new MetricsCommandArguments
{
IgnoreFile = Path.Combine(Environment.CurrentDirectory, ".metropolisignore"),
SourceDirectory = @"c:\sourceDir",
BuildOutputFolder = @"c:\buildoutput"
};
dllFiles = new[] { "Assembly1.dll", "Assembly2.dll", "Assembly3.dll", "Assembly4.dll", "Assembly5.dll", "Assembly6.dll" };
exeFiles = new[] { "program.exe" };
fileSystem.Setup(x => x.GetFiles(args.BuildOutputFolder, "*.dll")).Returns(dllFiles);
fileSystem.Setup(x => x.GetFiles(args.BuildOutputFolder, "*.exe")).Returns(exeFiles);
collectAssemblies = new CollectAssemblies(fileSystem.Object);
}
public override string PrepareCommand(MetricsCommandArguments args, MetricsResult result)
{
return(runBadCommand? "this should fail" : $"dir | Out-File '{result.MetricsFile}'");
}
private string GetMetricsOutputFileName(MetricsCommandArguments args, string targetdll)
{
var assemblyName = fileSystem.GetFileName(targetdll).Replace(".dll", string.Empty);
return(Path.Combine(args.MetricsOutputFolder, $"{args.ProjectName}_{assemblyName}_metrics.xml"));
}
public override string PrepareCommand(MetricsCommandArguments args, MetricsResult result)
{
return(SlocCommand.FormatWith(GetNodeBinPath(), args.SourceDirectory, result.MetricsFile));
}
public IEnumerable <MetricsResult> Run(MetricsCommandArguments args)
{
return(runParallel ? RunInParallel(args) : Commands.SelectMany(each => each.Run(args)));
}
private string GetOutputFile(MetricsCommandArguments args)
{
var fileName = $"{args.ProjectName}_{MetricsType}{Extension}".Replace(' ', '_');
return(Path.Combine(args.MetricsOutputFolder, fileName));
}
private MetricsResult MetricResultFor(MetricsCommandArguments args)
{
return(new MetricsResult {
ParseType = ParseType, MetricsFile = GetOutputFile(args)
});
}
private void SaveMetricsCommand(MetricsCommandArguments args, string cmd)
{
var fileName = Path.Combine(args.MetricsOutputFolder, $"{args.ProjectName}_{MetricsType}_command.ps1");
File.WriteAllText(fileName, cmd);
}
public abstract string PrepareCommand(MetricsCommandArguments args, MetricsResult result);
