public static AnalysisConfig GenerateFile(ProcessedArgs args, TeamBuildSettings settings, IDictionary<string, string> serverProperties, ILogger logger)
{
if (args == null)
{
throw new ArgumentNullException("args");
}
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if (serverProperties == null)
{
throw new ArgumentNullException("serverProperties");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
AnalysisConfig config = new AnalysisConfig();
config.SonarProjectKey = args.ProjectKey;
config.SonarProjectName = args.ProjectName;
config.SonarProjectVersion = args.ProjectVersion;
config.SonarQubeHostUrl = args.GetSetting(SonarProperties.HostUrl);
config.SetBuildUri(settings.BuildUri);
config.SetTfsUri(settings.TfsUri);
config.SonarConfigDir = settings.SonarConfigDirectory;
config.SonarOutputDir = settings.SonarOutputDirectory;
config.SonarBinDir = settings.SonarBinDirectory;
config.SonarRunnerWorkingDirectory = settings.SonarRunnerWorkingDirectory;
// Add the server properties to the config
config.ServerSettings = new AnalysisProperties();
foreach (var property in serverProperties)
{
if (!IsSecuredServerProperty(property.Key))
{
AddSetting(config.ServerSettings, property.Key, property.Value);
}
}
// Add command line arguments
config.LocalSettings = new AnalysisProperties();
foreach (var property in args.LocalProperties.GetAllProperties())
{
AddSetting(config.LocalSettings, property.Id, property.Value);
}
// Set the pointer to the properties file
if (args.PropertiesFileName != null)
{
config.SetSettingsFilePath(args.PropertiesFileName);
}
config.Save(settings.AnalysisConfigFilePath);
return config;
}
/// <summary>
/// Generates summary reports for LegacyTeamBuild and for Build Vnext
/// </summary>
public void GenerateReports(TeamBuildSettings settings, AnalysisConfig config, ProjectInfoAnalysisResult result, ILogger logger)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if (config == null)
{
throw new ArgumentNullException("config");
}
if (result == null)
{
throw new ArgumentNullException("result");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
this.settings = settings;
this.config = config;
this.result = result;
this.logger = logger;
this.GenerateReports();
}
public void GetAnalyzerSettings_ConfigExists_DataReturned()
{
// Arrange
string testDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
GetAnalyzerSettings testSubject = new GetAnalyzerSettings();
string[] expectedAnalyzers = new string[] { "c:\\analyzer1.DLL", "c:\\analyzer2.dll" };
string[] expectedAdditionalFiles = new string[] { "c:\\add1.txt", "d:\\add2.txt" };
// SONARMSBRU-216: non-assembly files should be filtered out
List<string> filesInConfig = new List<string>(expectedAnalyzers);
filesInConfig.Add("c:\\not_an_assembly.exe");
filesInConfig.Add("c:\\not_an_assembly.zip");
filesInConfig.Add("c:\\not_an_assembly.txt");
filesInConfig.Add("c:\\not_an_assembly.dll.foo");
filesInConfig.Add("c:\\not_an_assembly.winmd");
AnalysisConfig config = new AnalysisConfig();
config.AnalyzerSettings = new AnalyzerSettings();
config.AnalyzerSettings.RuleSetFilePath = "f:\\yyy.ruleset";
config.AnalyzerSettings.AnalyzerAssemblyPaths = filesInConfig;
config.AnalyzerSettings.AdditionalFilePaths = expectedAdditionalFiles.ToList();
string fullPath = Path.Combine(testDir, FileConstants.ConfigFileName);
config.Save(fullPath);
testSubject.AnalysisConfigDir = testDir;
// Act
ExecuteAndCheckSuccess(testSubject);
// Assert
Assert.AreEqual("f:\\yyy.ruleset", testSubject.RuleSetFilePath);
CollectionAssert.AreEquivalent(expectedAnalyzers, testSubject.AnalyzerFilePaths);
CollectionAssert.AreEquivalent(expectedAdditionalFiles, testSubject.AdditionalFiles);
}
public void SummaryReport_AllTypesOfProjects()
{
// Arrange
string hostUrl = "http://mySonarQube:9000";
ProjectInfoAnalysisResult result = new ProjectInfoAnalysisResult() { RanToCompletion = true };
AnalysisConfig config = new AnalysisConfig() { SonarProjectKey = "", SonarQubeHostUrl = hostUrl };
AddProjectInfoToResult(result, ProjectInfoValidity.DuplicateGuid, count: 3);
AddProjectInfoToResult(result, ProjectInfoValidity.ExcludeFlagSet, type: ProjectType.Product, count: 4);
AddProjectInfoToResult(result, ProjectInfoValidity.ExcludeFlagSet, type: ProjectType.Test , count: 1);
AddProjectInfoToResult(result, ProjectInfoValidity.InvalidGuid, type: ProjectType.Product, count: 7);
AddProjectInfoToResult(result, ProjectInfoValidity.InvalidGuid, type: ProjectType.Test , count: 8);
AddProjectInfoToResult(result, ProjectInfoValidity.NoFilesToAnalyze, count: 11);
AddProjectInfoToResult(result, ProjectInfoValidity.Valid, type: ProjectType.Product, count: 13);
AddProjectInfoToResult(result, ProjectInfoValidity.Valid, type: ProjectType.Test, count: 17);
// Act
var summaryReportData = SummaryReportBuilder.CreateSummaryData(config, result);
// Assert
VerifySummaryReportData(summaryReportData, result, hostUrl, config);
VerifySummaryProjectCounts(
summaryReportData,
expectedExcludedProjects: 5, // ExcludeFlagSet
expectedInvalidProjects: 18, // InvalidGuid + DuplicateGuid
expectedSkippedProjects: 11, // No files to analyze
expectedProductProjects: 13,
expectedTestProjects: 17);
}
public void GetAnalyzerSettings_ConfigExists_DataReturned()
{
// Arrange
string testDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
GetAnalyzerSettings testSubject = new GetAnalyzerSettings();
string[] expectedAnalyzers = new string[] { "c:\\analyzer1.dll", "c:\\analyzer2.dll" };
string[] expectedAdditionalFiles = new string[] { "c:\\add1.txt", "d:\\add2.txt" };
AnalysisConfig config = new AnalysisConfig();
config.AnalyzerSettings = new AnalyzerSettings();
config.AnalyzerSettings.RuleSetFilePath = "f:\\yyy.ruleset";
config.AnalyzerSettings.AnalyzerAssemblyPaths = expectedAnalyzers.ToList();
config.AnalyzerSettings.AdditionalFilePaths = expectedAdditionalFiles.ToList();
string fullPath = Path.Combine(testDir, FileConstants.ConfigFileName);
config.Save(fullPath);
testSubject.AnalysisConfigDir = testDir;
// Act
ExecuteAndCheckSuccess(testSubject);
// Assert
Assert.AreEqual("f:\\yyy.ruleset", testSubject.RuleSetFilePath);
CollectionAssert.AreEquivalent(expectedAnalyzers, testSubject.AnalyzerFilePaths);
CollectionAssert.AreEquivalent(expectedAdditionalFiles, testSubject.AdditionalFiles);
}
public ProjectInfoAnalysisResult Execute(AnalysisConfig config, IEnumerable<string> userCmdLineArguments, ILogger logger)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
if (userCmdLineArguments == null)
{
throw new ArgumentNullException("userCmdLineArguments");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
ProjectInfoAnalysisResult result = PropertiesFileGenerator.GenerateFile(config, logger);
Debug.Assert(result != null, "Not expecting the file generator to return null");
result.RanToCompletion = false;
SonarProjectPropertiesValidator.Validate(
config.SonarRunnerWorkingDirectory,
result.Projects,
onValid: () =>
{
InternalExecute(config, userCmdLineArguments, logger, result);
},
onInvalid: (invalidFolders) =>
{
// LOG error message
logger.LogError(Resources.ERR_ConflictingSonarProjectProperties, string.Join(", ", invalidFolders));
});
return result;
}
private ProjectInfoReportBuilder(AnalysisConfig config, ProjectInfoAnalysisResult result, ILogger logger)
{
this.config = config;
this.analysisResult = result;
this.logger = logger;
this.sb = new StringBuilder();
}
/* for test purposes */
public static SummaryReportData CreateSummaryData(
AnalysisConfig config,
ProjectInfoAnalysisResult result)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
if (result == null)
{
throw new ArgumentNullException("result");
}
SummaryReportData summaryData = new SummaryReportData();
summaryData.SkippedProjects = GetProjectsByStatus(result, ProjectInfoValidity.NoFilesToAnalyze).Count();
summaryData.InvalidProjects = GetProjectsByStatus(result, ProjectInfoValidity.InvalidGuid).Count();
summaryData.InvalidProjects += GetProjectsByStatus(result, ProjectInfoValidity.DuplicateGuid).Count();
summaryData.ExcludedProjects = GetProjectsByStatus(result, ProjectInfoValidity.ExcludeFlagSet).Count();
IEnumerable<ProjectInfo> validProjects = GetProjectsByStatus(result, ProjectInfoValidity.Valid);
summaryData.ProductProjects = validProjects.Count(p => p.ProjectType == ProjectType.Product);
summaryData.TestProjects = validProjects.Count(p => p.ProjectType == ProjectType.Test);
summaryData.Succeeded = result.RanToCompletion;
summaryData.DashboardUrl = GetSonarDashboadUrl(config);
summaryData.ProjectDescription = string.Format(System.Globalization.CultureInfo.CurrentCulture,
Resources.Report_SonarQubeProjectDescription, config.SonarProjectName, config.SonarProjectKey, config.SonarProjectVersion);
return summaryData;
}
/* for test purposes */
public static bool ExecuteJavaRunner(AnalysisConfig config, IEnumerable<string> userCmdLineArguments, ILogger logger, string exeFileName, string propertiesFileName)
{
Debug.Assert(File.Exists(exeFileName), "The specified exe file does not exist: " + exeFileName);
Debug.Assert(File.Exists(propertiesFileName), "The specified properties file does not exist: " + propertiesFileName);
IgnoreSonarRunnerHome(logger);
IEnumerable<string> allCmdLineArgs = GetAllCmdLineArgs(propertiesFileName, userCmdLineArguments, config);
IDictionary<string, string> envVarsDictionary = GetAdditionalEnvVariables(logger);
Debug.Assert(envVarsDictionary != null);
logger.LogInfo(Resources.MSG_CallingSonarRunner);
ProcessRunnerArguments runnerArgs = new ProcessRunnerArguments(exeFileName, logger)
{
CmdLineArgs = allCmdLineArgs,
WorkingDirectory = Path.GetDirectoryName(exeFileName),
EnvironmentVariables = envVarsDictionary
};
ProcessRunner runner = new ProcessRunner();
bool success = runner.Execute(runnerArgs);
success = success && !runner.ErrorsLogged;
if (success)
{
logger.LogInfo(Resources.MSG_SonarRunnerCompleted);
}
else
{
logger.LogError(Resources.ERR_SonarRunnerExecutionFailed);
}
return success;
}
public ProjectInfoAnalysisResult Execute(AnalysisConfig config, IEnumerable<string> userCmdLineArguments, ILogger logger)
{
Assert.IsFalse(this.methodCalled, "Runner should only be called once");
this.methodCalled = true;
this.SuppliedCommandLineArgs = userCmdLineArguments;
return this.ValueToReturn;
}
public PropertiesWriter(AnalysisConfig config)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
this.config = config;
this.sb = new StringBuilder();
this.projects = new List<ProjectInfo>();
}
public /* for test */ static ProjectInfoAnalysisResult GenerateFile(AnalysisConfig config, ILogger logger, IRoslynV1SarifFixer fixer)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
string fileName = Path.Combine(config.SonarOutputDir, ProjectPropertiesFileName);
logger.LogDebug(Resources.MSG_GeneratingProjectProperties, fileName);
IEnumerable<ProjectInfo> projects = ProjectLoader.LoadFrom(config.SonarOutputDir);
if (projects == null || !projects.Any())
{
logger.LogError(Resources.ERR_NoProjectInfoFilesFound);
return new ProjectInfoAnalysisResult();
}
FixSarifReport(logger, projects, fixer);
PropertiesWriter writer = new PropertiesWriter(config);
ProjectInfoAnalysisResult result = ProcessProjectInfoFiles(projects, writer, logger);
IEnumerable<ProjectInfo> validProjects = result.GetProjectsByStatus(ProjectInfoValidity.Valid);
if (validProjects.Any())
{
// Handle global settings
AnalysisProperties properties = GetAnalysisPropertiesToWrite(config, logger);
writer.WriteGlobalSettings(properties);
string contents = writer.Flush();
result.FullPropertiesFilePath = fileName;
File.WriteAllText(result.FullPropertiesFilePath, contents, Encoding.ASCII);
}
else
{
// if the user tries to build multiple configurations at once there will be duplicate projects
if (result.GetProjectsByStatus(ProjectInfoValidity.DuplicateGuid).Any())
{
logger.LogError(Resources.ERR_NoValidButDuplicateProjects);
}
else
{
logger.LogError(Resources.ERR_NoValidProjectInfoFiles);
}
}
return result;
}
public bool Initialise(AnalysisConfig config, TeamBuildSettings settings, ILogger logger)
{
if (settings == null)
{
throw new ArgumentNullException("settings");
}
this.TryCreateCoverageReportProcessor(settings);
this.initialisedSuccesfully = (this.processor != null && this.processor.Initialise(config, settings, logger));
return this.initialisedSuccesfully;
}
public void SonarRunner_StandardAdditionalArgumentsPassed()
{
// Arrange
TestLogger logger = new TestLogger();
string exePath = CreateDummarySonarRunnerBatchFile();
string propertiesFilePath = CreateDummySonarRunnerPropertiesFile();
AnalysisConfig config = new AnalysisConfig() { SonarRunnerWorkingDirectory = this.TestContext.DeploymentDirectory };
// Act
bool success = SonarRunnerWrapper.ExecuteJavaRunner(config, Enumerable.Empty<string>(), logger, exePath, propertiesFilePath);
// Assert
VerifyProcessRunOutcome(logger, this.TestContext.DeploymentDirectory, success, true);
}
private string TryGetRegularExpression(AnalysisConfig config)
{
Debug.Assert(config != null, "Not expecting the supplied config to be null");
string regEx;
config.GetAnalysisSettings(true).TryGetValue(TestRegExSettingId, out regEx);
if (!string.IsNullOrWhiteSpace(regEx))
{
this.Log.LogMessage(MessageImportance.Low, Resources.IsTest_UsingRegExFromConfig, regEx);
}
return regEx;
}
public void Roslyn_Settings_ValidSetup()
{
// Arrange
BuildLogger logger = new BuildLogger();
// Set the config directory so the targets know where to look for the analysis config file
string confDir = TestUtils.CreateTestSpecificFolder(this.TestContext, "config");
// Create a valid config file containing analyzer settings
string[] expectedAssemblies = new string[] { "c:\\data\\config.analyzer1.dll", "c:\\config2.dll" };
string[] expectedAdditionalFiles = new string[] { "c:\\config.1.txt", "c:\\config.2.txt" };
AnalysisConfig config = new AnalysisConfig();
config.AnalyzerSettings = new AnalyzerSettings();
config.AnalyzerSettings.RuleSetFilePath = "d:\\my.ruleset";
config.AnalyzerSettings.AnalyzerAssemblyPaths = expectedAssemblies.ToList();
config.AnalyzerSettings.AdditionalFilePaths = expectedAdditionalFiles.ToList();
string configFilePath = Path.Combine(confDir, FileConstants.ConfigFileName);
config.Save(configFilePath);
// Create the project
WellKnownProjectProperties properties = new WellKnownProjectProperties();
properties.SonarQubeConfigPath = confDir;
properties.ResolvedCodeAnalysisRuleset = "c:\\should.be.overridden.ruleset";
ProjectRootElement projectRoot = CreateValidProjectSetup(properties);
projectRoot.AddItem(TargetProperties.AnalyzerItemType, "should.be.removed.analyzer1.dll");
projectRoot.AddItem(TargetProperties.AnalyzerItemType, "c:\\should.be.removed.analyzer2.dll");
projectRoot.AddItem(TargetProperties.AdditionalFilesItemType, "should.be.removed.additional1.txt");
projectRoot.AddItem(TargetProperties.AdditionalFilesItemType, "should.be.removed.additional2.txt");
// Act
BuildResult result = BuildUtilities.BuildTargets(projectRoot, logger, TargetConstants.OverrideRoslynAnalysisTarget);
// Assert
logger.AssertTargetExecuted(TargetConstants.OverrideRoslynAnalysisTarget);
logger.AssertTargetExecuted(TargetConstants.SetRoslynAnalysisPropertiesTarget);
BuildAssertions.AssertTargetSucceeded(result, TargetConstants.OverrideRoslynAnalysisTarget);
// Check the error log and ruleset properties are set
AssertErrorLogIsSetBySonarQubeTargets(result);
AssertExpectedResolvedRuleset(result, "d:\\my.ruleset");
AssertExpectedItemValuesExists(result, TargetProperties.AdditionalFilesItemType, expectedAdditionalFiles);
AssertExpectedItemValuesExists(result, TargetProperties.AnalyzerItemType, expectedAssemblies);
BuildAssertions.AssertWarningsAreNotTreatedAsErrorsNorIgnored(result);
}
/// <summary>
/// Attempts to load the config file, suppressing any IO errors that occur.
/// This method is expected to be called inside a "retry"
/// </summary>
private static bool DoLoadConfig(string filePath, ILogger logger, out AnalysisConfig config)
{
Debug.Assert(File.Exists(filePath), "Expecting the config file to exist: " + filePath);
config = null;
try
{
config = AnalysisConfig.Load(filePath);
}
catch (IOException e)
{
// Log this as a message for info. We'll log an error if all of the re-tries failed
logger.LogDebug(Resources.Shared_ErrorReadingConfigFile, e.Message);
return false;
}
return true;
}
public bool Execute(string[] args, AnalysisConfig config, TeamBuildSettings settings, ILogger logger)
{
if (args == null)
{
throw new ArgumentNullException("args");
}
if (config == null)
{
throw new ArgumentNullException("config");
}
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
IAnalysisPropertyProvider provider;
if (!ArgumentProcessor.TryProcessArgs(args, logger, out provider))
{
return false;
}
logger.Verbosity = VerbosityCalculator.ComputeVerbosity(config.GetAnalysisSettings(true), logger);
LogStartupSettings(config, settings, logger);
if (!CheckEnvironmentConsistency(config, settings, logger))
{
return false;
}
// if initialisation fails a warning will have been logged at the source of the failure
bool initialised = this.codeCoverageProcessor.Initialise(config, settings, logger);
if (initialised && !this.codeCoverageProcessor.ProcessCoverageReports())
{
// if processing fails, stop the workflow
return false;
}
ProjectInfoAnalysisResult result = InvokeSonarRunner(provider, config, logger);
this.reportBuilder.GenerateReports(settings, config, result, logger);
return result.RanToCompletion;
}
public static void WriteSummaryReport(AnalysisConfig config, ProjectInfoAnalysisResult result, ILogger logger)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
if (result == null)
{
throw new ArgumentNullException("result");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
ProjectInfoReportBuilder builder = new ProjectInfoReportBuilder(config, result, logger);
builder.Generate();
}
public void GetAnalyzerSettings_ConfigExistsButNoAnalyzerSettings_NoError()
{
// Arrange
string testDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
GetAnalyzerSettings testSubject = new GetAnalyzerSettings();
AnalysisConfig config = new AnalysisConfig();
string fullPath = Path.Combine(testDir, FileConstants.ConfigFileName);
config.Save(fullPath);
testSubject.AnalysisConfigDir = testDir;
// Act
ExecuteAndCheckSuccess(testSubject);
// Assert
CheckNoAnalyzerSettings(testSubject);
}
public void SonarRunnerHome_MessageLoggedIfAlreadySet()
{
using (EnvironmentVariableScope scope = new EnvironmentVariableScope())
{
scope.SetVariable(SonarRunnerWrapper.SonarRunnerHomeVariableName, "some_path");
// Arrange
TestLogger testLogger = new TestLogger();
string exePath = CreateDummarySonarRunnerBatchFile();
string propertiesFilePath = CreateDummySonarRunnerPropertiesFile();
AnalysisConfig config = new AnalysisConfig() { SonarRunnerWorkingDirectory = this.TestContext.DeploymentDirectory };
// Act
bool success = SonarRunnerWrapper.ExecuteJavaRunner(config, Enumerable.Empty<string>(), testLogger, exePath, propertiesFilePath);
// Assert
VerifySuccessfullRun(testLogger, success , this.TestContext.DeploymentDirectory);
}
}
public void SonarRunnerHome_NoMessageIfNotAlreadySet()
{
// Arrange
TestLogger testLogger = new TestLogger();
string exePath = CreateDummarySonarRunnerBatchFile();
string propertiesFilePath = CreateDummySonarRunnerPropertiesFile();
using (EnvironmentVariableScope scope = new EnvironmentVariableScope())
{
scope.SetVariable(SonarRunnerWrapper.SonarRunnerHomeVariableName, null);
AnalysisConfig config = new AnalysisConfig() { SonarRunnerWorkingDirectory = this.TestContext.DeploymentDirectory };
// Act
bool success = SonarRunnerWrapper.ExecuteJavaRunner(config, Enumerable.Empty<string>(), testLogger, exePath, propertiesFilePath);
// Assert
VerifyProcessRunOutcome(testLogger, this.TestContext.DeploymentDirectory, success, true);
testLogger.AssertMessageNotLogged(SonarRunner.Shim.Resources.MSG_SonarRunnerHomeIsSet);
}
}
public void SummaryReport_NoProjects()
{
// Arrange
string hostUrl = "http://mySonarQube:9000";
ProjectInfoAnalysisResult result = new ProjectInfoAnalysisResult() { RanToCompletion = false };
AnalysisConfig config = new AnalysisConfig() { SonarProjectKey = "Foo" , SonarQubeHostUrl = hostUrl };
// Act
var summaryReportData = SummaryReportBuilder.CreateSummaryData(config, result);
// Assert
VerifySummaryReportData(summaryReportData, result, hostUrl, config);
VerifySummaryProjectCounts(
summaryReportData,
expectedExcludedProjects: 0,
expectedInvalidProjects: 0,
expectedSkippedProjects: 0,
expectedProductProjects: 0,
expectedTestProjects: 0);
}
/* for test purposes */
public static bool ExecuteJavaRunner(AnalysisConfig config, IEnumerable<string> userCmdLineArguments, ILogger logger, string exeFileName, string propertiesFileName)
{
Debug.Assert(File.Exists(exeFileName), "The specified exe file does not exist: " + exeFileName);
Debug.Assert(File.Exists(propertiesFileName), "The specified properties file does not exist: " + propertiesFileName);
IgnoreSonarScannerHome(logger);
IEnumerable<string> allCmdLineArgs = GetAllCmdLineArgs(propertiesFileName, userCmdLineArguments, config);
IDictionary<string, string> envVarsDictionary = GetAdditionalEnvVariables(logger);
Debug.Assert(envVarsDictionary != null);
logger.LogInfo(Resources.MSG_SonarScannerCalling);
Debug.Assert(!String.IsNullOrWhiteSpace(config.SonarRunnerWorkingDirectory), "The working dir should have been set in the analysis config");
Debug.Assert(Directory.Exists(config.SonarRunnerWorkingDirectory), "The working dir should exist");
ProcessRunnerArguments runnerArgs = new ProcessRunnerArguments(exeFileName, logger)
{
CmdLineArgs = allCmdLineArgs,
WorkingDirectory = config.SonarRunnerWorkingDirectory,
EnvironmentVariables = envVarsDictionary
};
ProcessRunner runner = new ProcessRunner();
// SONARMSBRU-202 Note that the Sonar Scanner may write warnings to stderr so
// we should only rely on the exit code when deciding if it ran successfully
bool success = runner.Execute(runnerArgs);
if (success)
{
logger.LogInfo(Resources.MSG_SonarScannerCompleted);
}
else
{
logger.LogError(Resources.ERR_SonarScannerExecutionFailed);
}
return success;
}
public void FileGen_NoProjectInfoFiles()
{
// Properties file should not be generated if there are no project info files.
// Arrange - two sub-directories, neither containing a ProjectInfo.xml
string testDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
string subDir1 = TestUtils.EnsureTestSpecificFolder(this.TestContext, "dir1");
string subDir2 = TestUtils.EnsureTestSpecificFolder(this.TestContext, "dir2");
CreateEmptyFile(subDir1, "file1.txt");
CreateEmptyFile(subDir2, "file2.txt");
TestLogger logger = new TestLogger();
AnalysisConfig config = new AnalysisConfig() { SonarOutputDir = testDir };
// Act
ProjectInfoAnalysisResult result = PropertiesFileGenerator.GenerateFile(config, logger);
// Assert
AssertFailedToCreatePropertiesFiles(result, logger);
AssertExpectedProjectCount(0, result);
}
public bool Initialise(AnalysisConfig config, TeamBuildSettings settings, ILogger logger)
{
if (config == null)
{
throw new ArgumentNullException("config");
}
if (settings == null)
{
throw new ArgumentNullException("settings");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
this.config = config;
this.settings = settings;
this.logger = logger;
this.succesfullyInitialised = this.converter.Initialize(logger);
return succesfullyInitialised;
}
protected override bool TryGetBinaryReportFile(AnalysisConfig config, TeamBuildSettings settings, ILogger logger, out string binaryFilePath)
{
IEnumerable<string> urls = this.urlProvider.GetCodeCoverageReportUrls(config.GetTfsUri(), config.GetBuildUri(), logger);
Debug.Assert(urls != null, "Not expecting the returned list of urls to be null");
bool continueProcessing = true;
binaryFilePath = null;
switch (urls.Count())
{
case 0:
logger.LogInfo(Resources.PROC_DIAG_NoCodeCoverageReportsFound);
break;
case 1:
string url = urls.First();
string targetFileName = Path.Combine(config.SonarOutputDir, DownloadFileName);
bool result = this.downloader.DownloadReport(config.GetTfsUri(), url, targetFileName, logger);
if (result)
{
binaryFilePath = targetFileName;
}
else
{
continueProcessing = false;
logger.LogError(Resources.PROC_ERROR_FailedToDownloadReport);
}
break;
default: // More than one
continueProcessing = false;
logger.LogError(Resources.PROC_ERROR_MultipleCodeCoverageReportsFound);
break;
}
return continueProcessing;
}
public void SummaryReport_WithBranch()
{
// Arrange
string hostUrl = "http://mySonarQube:9000";
ProjectInfoAnalysisResult result = new ProjectInfoAnalysisResult { RanToCompletion = false };
AnalysisConfig config = new AnalysisConfig() { SonarProjectKey = "Foo", SonarQubeHostUrl = hostUrl };
config.LocalSettings = new AnalysisProperties();
config.LocalSettings.Add(new Property() { Id = SonarProperties.Branch, Value = "master" });
AddProjectInfoToResult(result, ProjectInfoValidity.Valid, type: ProjectType.Product, count: 4);
// Act
var summaryReportData = SummaryReportBuilder.CreateSummaryData(config, result);
// Assert
VerifySummaryReportData(summaryReportData, result, hostUrl, config);
VerifySummaryProjectCounts(
summaryReportData,
expectedExcludedProjects: 0,
expectedInvalidProjects: 0,
expectedSkippedProjects: 0,
expectedProductProjects: 4,
expectedTestProjects: 0);
}
/// <summary>
/// Attempts to load the config file, suppressing any IO errors that occur.
/// This method is expected to be called inside a "retry"
/// </summary>
private bool DoLoadConfig(string filePath, out AnalysisConfig config)
{
Debug.Assert(File.Exists(filePath), "Expecting the config file to exist: " + filePath);
config = null;
try
{
config = AnalysisConfig.Load(filePath);
}
catch (IOException e)
{
// Log this as a message for info. We'll log an error if all of the re-tries failed
this.Log.LogMessage(MessageImportance.Low, Resources.IsTest_ErrorReadingConfigFile, e.Message);
return false;
}
return true;
}
private static void AssertExpectedServerSetting(string key, string expectedValue, AnalysisConfig actualConfig)
{
Property actualProperty;
bool found = Property.TryGetProperty(key, actualConfig.ServerSettings, out actualProperty);
Assert.IsTrue(found, "Failed to find the expected server setting: {0}", key);
Assert.AreEqual(expectedValue, actualProperty.Value, "Unexpected property value. Key: {0}", key);
}
/// <summary>
/// Sets the value of the additional setting. The setting will be added if it does not already exist.
/// </summary>
public static void SetConfigValue(this AnalysisConfig config, string settingId, string value)
{
SetValue(config, settingId, value);
}
