public void TBSettings_LegacyTeamBuild()
{
// Arrange
TestLogger logger = new TestLogger();
TeamBuildSettings settings;
using (EnvironmentVariableScope scope = new EnvironmentVariableScope())
{
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.IsInTeamBuild, "TRUE");
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.BuildUri_Legacy, "http://legacybuilduri");
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.TfsCollectionUri_Legacy, "http://legacycollectionUri");
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.BuildDirectory_Legacy, "legacy build dir");
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.SourcesDirectory_Legacy, @"c:\build\1234");;
// Act
settings = TeamBuildSettings.GetSettingsFromEnvironment(logger);
}
// Assert
Assert.IsNotNull(settings, "Failed to create the TeamBuildSettings");
logger.AssertErrorsLogged(0);
logger.AssertWarningsLogged(0);
// Check the environment properties
CheckExpectedSettings(
settings,
BuildEnvironment.LegacyTeamBuild,
Directory.GetCurrentDirectory(),
"http://legacybuilduri",
"http://legacycollectionUri",
"legacy build dir",
@"c:\build\1234");
}
public void PreProc_NonEmptySonarRunnerProperties()
{
// Checks the ruleset generator is called with the expected arguments
// Arrange
string testDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
string propertiesFile = CreatePropertiesFile(testDir, "my url", "my user name", "my password");
MockPropertiesFetcher mockPropertiesFetcher = new MockPropertiesFetcher();
MockRulesetGenerator mockRulesetGenerator = new MockRulesetGenerator();
TestLogger logger = new TestLogger();
string expectedConfigFileName;
using (PreprocessTestUtils.CreateValidLegacyTeamBuildScope("tfs uri", "build uri", testDir))
{
TeamBuildSettings settings = TeamBuildSettings.GetSettingsFromEnvironment(new ConsoleLogger());
Assert.IsNotNull(settings, "Test setup error: TFS environment variables have not been set correctly");
expectedConfigFileName = settings.AnalysisConfigFilePath;
TeamBuildPreProcessor preProcessor = new TeamBuildPreProcessor(mockPropertiesFetcher, mockRulesetGenerator);
// Act
preProcessor.Execute(logger, "key", "name", "ver", propertiesFile);
}
// Assert
mockPropertiesFetcher.AssertFetchPropertiesCalled();
mockPropertiesFetcher.CheckFetcherArguments("my url", "key");
mockRulesetGenerator.AssertGenerateCalled();
mockRulesetGenerator.CheckGeneratorArguments("my url", "key");
logger.AssertErrorsLogged(0);
logger.AssertWarningsLogged(0);
}
public void TBSettings_NonLegacyTeamBuild()
{
// Arrange
var logger = new TestLogger();
TeamBuildSettings settings;
using (var scope = new EnvironmentVariableScope())
{
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.IsInTeamFoundationBuild, "TRUE");
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.BuildUri_TFS2015, "http://builduri");
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.TfsCollectionUri_TFS2015, "http://collectionUri");
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.BuildDirectory_TFS2015, "non-legacy team build");
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.SourcesDirectory_TFS2015, @"c:\agent\_work\1");
// Act
settings = TeamBuildSettings.GetSettingsFromEnvironment(logger);
}
// Assert
settings.Should().NotBeNull("Failed to create the TeamBuildSettings");
logger.AssertErrorsLogged(0);
logger.AssertWarningsLogged(0);
// Check the environment properties
CheckExpectedSettings(
settings,
BuildEnvironment.TeamBuild,
Directory.GetCurrentDirectory(),
"http://builduri",
"http://collectionUri",
"non-legacy team build",
@"c:\agent\_work\1");
}
private int PostProcess()
{
this.logger.IncludeTimestamp = true;
if (!Directory.Exists(this.bootstrapSettings.TempDirectory))
{
this.logger.LogError(Resources.ERROR_TempDirDoesNotExist);
return(ErrorCode);
}
Directory.SetCurrentDirectory(this.bootstrapSettings.TempDirectory);
ITeamBuildSettings teamBuildSettings = TeamBuildSettings.GetSettingsFromEnvironment(this.logger);
var config = GetAnalysisConfig(teamBuildSettings.AnalysisConfigFilePath);
bool succeeded;
if (config == null)
{
succeeded = false;
}
else
{
var postProcessor = this.processorFactory.CreatePostProcessor();
succeeded = postProcessor.Execute(this.bootstrapSettings.ChildCmdLineArgs.ToArray(), config, teamBuildSettings);
}
return(succeeded ? SuccessCode : ErrorCode);
}
private static int Main(string[] args)
{
ConsoleLogger logger = new ConsoleLogger(includeTimestamp: true);
TeamBuildSettings settings = TeamBuildSettings.GetSettingsFromEnvironment(logger);
Debug.Assert(settings != null, "Settings should not be null");
AnalysisConfig config = GetAnalysisConfig(settings, logger);
bool succeeded;
if (config == null)
{
succeeded = false;
}
else
{
MSBuildPostProcessor postProcessor = new MSBuildPostProcessor(new CoverageReportProcessor(), new SonarRunnerWrapper(), new SummaryReportBuilder());
succeeded = postProcessor.Execute(args, config, settings, logger);
}
return(succeeded ? SuccessCode : ErrorCode);
}
private async Task <bool> DoExecute(ProcessedArgs localSettings)
{
Debug.Assert(localSettings != null, "Not expecting the process arguments to be null");
this.logger.Verbosity = VerbosityCalculator.ComputeVerbosity(localSettings.AggregateProperties, this.logger);
this.logger.ResumeOutput();
InstallLoaderTargets(localSettings);
var teamBuildSettings = TeamBuildSettings.GetSettingsFromEnvironment(this.logger);
// We're checking the args and environment variables so we can report all config errors to the user at once
if (teamBuildSettings == null)
{
this.logger.LogError(Resources.ERROR_CannotPerformProcessing);
return(false);
}
// Create the directories
this.logger.LogDebug(Resources.MSG_CreatingFolders);
if (!Utilities.TryEnsureEmptyDirectories(this.logger,
teamBuildSettings.SonarConfigDirectory,
teamBuildSettings.SonarOutputDirectory))
{
return(false);
}
var server = this.factory.CreateSonarQubeServer(localSettings);
//TODO: fail fast after release of 6.0
//Deprecation notice for SQ < 7.9
await server.WarnIfSonarQubeVersionIsDeprecated();
try
{
if (!await server.IsServerLicenseValid())
{
this.logger.LogError(Resources.ERR_UnlicensedServer, localSettings.SonarQubeUrl);
return(false);
}
}
catch (Exception ex)
{
this.logger.LogError(ex.Message);
return(false);
}
var argumentsAndRuleSets = await FetchArgumentsAndRulesets(server, localSettings, teamBuildSettings);
if (!argumentsAndRuleSets.IsSuccess)
{
return(false);
}
Debug.Assert(argumentsAndRuleSets.AnalyzersSettings != null, "Not expecting the analyzers settings to be null");
// analyzerSettings can be empty
AnalysisConfigGenerator.GenerateFile(localSettings, teamBuildSettings, argumentsAndRuleSets.ServerSettings, argumentsAndRuleSets.AnalyzersSettings, server, this.logger);
return(true);
}
public void TBSettings_NotTeamBuild()
{
// 0. Setup
TestLogger logger;
TeamBuildSettings settings;
// 1. No environment vars set
using (EnvironmentVariableScope scope = new EnvironmentVariableScope())
{
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.IsInTeamBuild, null);
logger = new TestLogger();
settings = TeamBuildSettings.GetSettingsFromEnvironment(logger);
// Check the environment properties
CheckExpectedSettings(settings, BuildEnvironment.NotTeamBuild, Directory.GetCurrentDirectory(), null, null, null);
}
// 2. Some Team build settings provided, but not marked as in team build
using (EnvironmentVariableScope scope = new EnvironmentVariableScope())
{
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.IsInTeamBuild, null);
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.BuildUri_Legacy, "build uri");
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.TfsCollectionUri_Legacy, "collection uri");
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.BuildDirectory_Legacy, "should be ignored");
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.BuildDirectory_TFS2015, "should be ignored");
logger = new TestLogger();
settings = TeamBuildSettings.GetSettingsFromEnvironment(logger);
CheckExpectedSettings(settings, BuildEnvironment.NotTeamBuild, Directory.GetCurrentDirectory(), null, null, null);
}
}
private int PostProcess()
{
Utilities.LogAssemblyVersion(Logger, typeof(Program).Assembly, Resources.AssemblyDescription);
Logger.IncludeTimestamp = true;
if (!Directory.Exists(BootstrapSettings.TempDirectory))
{
Logger.LogError(Resources.ERROR_TempDirDoesNotExist);
return(ErrorCode);
}
Directory.SetCurrentDirectory(BootstrapSettings.TempDirectory);
ITeamBuildSettings teamBuildSettings = TeamBuildSettings.GetSettingsFromEnvironment(Logger);
AnalysisConfig config = GetAnalysisConfig(teamBuildSettings.AnalysisConfigFilePath);
bool succeeded;
if (config == null)
{
succeeded = false;
}
else
{
IMSBuildPostProcessor postProcessor = ProcessorFactory.CreatePostProcessor();
succeeded = postProcessor.Execute(BootstrapSettings.ChildCmdLineArgs.ToArray(), config, teamBuildSettings);
}
return(succeeded ? SuccessCode : ErrorCode);
}
public void TBSettings_NonLegacyTeamBuild()
{
// Arrange
TestLogger logger = new TestLogger();
TeamBuildSettings settings;
using (EnvironmentVariableScope scope = new EnvironmentVariableScope())
{
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.IsInTeamBuild, "TRUE");
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.BuildDirectory_TFS2015, "build dir");
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.BuildUri_TFS2015, "http://builduri");
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.TfsCollectionUri_TFS2015, "http://collectionUri");
// Act
settings = TeamBuildSettings.GetSettingsFromEnvironment(logger);
}
// Assert
Assert.IsNotNull(settings, "Failed to create the TeamBuildSettings");
logger.AssertErrorsLogged(0);
logger.AssertWarningsLogged(0);
// Check the environment properties
CheckExpectedSettings(settings, BuildEnvironment.TeamBuild, "build dir", "http://builduri", "http://collectionUri");
}
private static int Main(string[] args)
{
var logger = new ConsoleLogger(includeTimestamp: false);
Utilities.LogAssemblyVersion(logger, typeof(Program).Assembly, Resources.AssemblyDescription);
logger.IncludeTimestamp = true;
var settings = TeamBuildSettings.GetSettingsFromEnvironment(logger);
Debug.Assert(settings != null, "Settings should not be null");
var config = GetAnalysisConfig(settings, logger);
bool succeeded;
if (config == null)
{
succeeded = false;
}
else
{
var postProcessor = new MSBuildPostProcessor(
new CoverageReportProcessor(),
new SonarScannerWrapper(),
new SummaryReportBuilder(),
logger,
new TargetsUninstaller());
succeeded = postProcessor.Execute(args, config, settings);
}
return(succeeded ? SuccessCode : ErrorCode);
}
public void PreProc_NoPlugin()
{
// Arrange
string workingDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
TestLogger logger = new TestLogger();
// Configure the server
MockSonarQubeServer mockServer = new MockSonarQubeServer();
ServerDataModel data = mockServer.Data;
data.ServerProperties.Add("server.key", "server value 1");
data.Languages.Add("invalid_plugin");
MockRoslynAnalyzerProvider mockAnalyzerProvider = new MockRoslynAnalyzerProvider
{
SettingsToReturn = new AnalyzerSettings
{
RuleSetFilePath = "c:\\xxx.ruleset"
}
};
Mock <ITargetsInstaller> mockTargetsInstaller = new Mock <ITargetsInstaller>();
MockObjectFactory mockFactory = new MockObjectFactory(mockServer, mockTargetsInstaller.Object, mockAnalyzerProvider);
TeamBuildSettings settings;
using (PreprocessTestUtils.CreateValidNonTeamBuildScope())
using (new WorkingDirectoryScope(workingDir))
{
settings = TeamBuildSettings.GetSettingsFromEnvironment(new TestLogger());
Assert.IsNotNull(settings, "Test setup error: TFS environment variables have not been set correctly");
Assert.AreEqual(BuildEnvironment.NotTeamBuild, settings.BuildEnvironment, "Test setup error: build environment was not set correctly");
TeamBuildPreProcessor preProcessor = new TeamBuildPreProcessor(mockFactory, logger);
// Act
bool success = preProcessor.Execute(CreateValidArgs("key", "name", "1.0"));
Assert.IsTrue(success, "Expecting the pre-processing to complete successfully");
}
// Assert
AssertDirectoriesCreated(settings);
mockTargetsInstaller.Verify(x => x.InstallLoaderTargets(logger, workingDir), Times.Once());
mockServer.AssertMethodCalled("GetProperties", 1);
mockServer.AssertMethodCalled("GetAllLanguages", 1);
mockServer.AssertMethodCalled("TryGetQualityProfile", 0); // No valid plugin
mockServer.AssertMethodCalled("GetActiveRules", 0); // No valid plugin
mockServer.AssertMethodCalled("GetInactiveRules", 0); // No valid plugin
AssertAnalysisConfig(settings.AnalysisConfigFilePath, 0, logger);
// only contains SonarQubeAnalysisConfig (no rulesets or aditional files)
AssertDirectoryContains(settings.SonarConfigDirectory, Path.GetFileName(settings.AnalysisConfigFilePath));
}
public void TBSettings_NotTeamBuild()
{
// 0. Setup
TestLogger logger;
TeamBuildSettings settings;
// 1. No environment vars set -> use the temp path
using (EnvironmentVariableScope scope = new EnvironmentVariableScope())
{
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.SQAnalysisRootPath, null);
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.IsInTeamBuild, null);
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.BuildDirectory_Legacy, null);
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.BuildDirectory_TFS2015, null);
logger = new TestLogger();
settings = TeamBuildSettings.GetSettingsFromEnvironment(logger);
// Check the environment properties
CheckExpectedSettings(settings, BuildEnvironment.NotTeamBuild, Path.GetTempPath(), null, null);
}
// 2. SQ analysis dir set
using (EnvironmentVariableScope scope = new EnvironmentVariableScope())
{
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.SQAnalysisRootPath, "d:\\sqdir");
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.IsInTeamBuild, null);
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.BuildDirectory_Legacy, null);
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.BuildDirectory_TFS2015, null);
logger = new TestLogger();
settings = TeamBuildSettings.GetSettingsFromEnvironment(logger);
CheckExpectedSettings(settings, BuildEnvironment.NotTeamBuild, "d:\\sqdir", null, null);
}
// 3. Some Team build settings provided, but not marked as in team build
using (EnvironmentVariableScope scope = new EnvironmentVariableScope())
{
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.SQAnalysisRootPath, "x:\\a");
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.IsInTeamBuild, null);
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.BuildUri_Legacy, "build uri");
scope.SetVariable(TeamBuildSettings.EnvironmentVariables.TfsCollectionUri_Legacy, "collection uri");
logger = new TestLogger();
settings = TeamBuildSettings.GetSettingsFromEnvironment(logger);
CheckExpectedSettings(settings, BuildEnvironment.NotTeamBuild, "x:\\a", null, null);
}
}
public void PreProc_EmptySonarRunnerProperties()
{
// Checks the pre-processor creates a valid config file
// Arrange
string testDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
string propertiesFile = CreateEmptyPropertiesFile(testDir);
MockPropertiesFetcher mockPropertiesFetcher = new MockPropertiesFetcher();
MockRulesetGenerator mockRulesetGenerator = new MockRulesetGenerator();
TestLogger logger = new TestLogger();
string expectedConfigFileName;
using (PreprocessTestUtils.CreateValidLegacyTeamBuildScope("tfs uri", "http://builduri", testDir))
{
TeamBuildSettings settings = TeamBuildSettings.GetSettingsFromEnvironment(new ConsoleLogger());
Assert.IsNotNull(settings, "Test setup error: TFS environment variables have not been set correctly");
expectedConfigFileName = settings.AnalysisConfigFilePath;
TeamBuildPreProcessor preProcessor = new TeamBuildPreProcessor(mockPropertiesFetcher, mockRulesetGenerator);
// Act
preProcessor.Execute(logger, "key", "name", "ver", propertiesFile);
}
// Assert
Assert.IsTrue(File.Exists(expectedConfigFileName), "Config file does not exist: {0}", expectedConfigFileName);
AnalysisConfig config = AnalysisConfig.Load(expectedConfigFileName);
Assert.IsTrue(Directory.Exists(config.SonarOutputDir), "Output directory was not created: {0}", config.SonarOutputDir);
Assert.IsTrue(Directory.Exists(config.SonarConfigDir), "Config directory was not created: {0}", config.SonarConfigDir);
Assert.AreEqual("key", config.SonarProjectKey);
Assert.AreEqual("name", config.SonarProjectName);
Assert.AreEqual("ver", config.SonarProjectVersion);
Assert.AreEqual("http://builduri", config.GetBuildUri());
Assert.AreEqual("tfs uri", config.GetTfsUri());
Assert.AreEqual(propertiesFile, config.SonarRunnerPropertiesPath);
mockPropertiesFetcher.AssertFetchPropertiesCalled();
mockPropertiesFetcher.CheckFetcherArguments("http://localhost:9000", "key");
mockRulesetGenerator.AssertGenerateCalled();
mockRulesetGenerator.CheckGeneratorArguments("http://localhost:9000", "key");
}
public static int Execute(string[] args, ILogger logger)
{
try
{
/* Expected Arguments :
* Method : 0
* SonarQubeAnalysisConfig.xml path : 1
* sonar-project.properties : 2
* ranToCompletion : 3
*/
if (args.Length < 1)
{
logger.LogError("No argument found. Exiting...");
return(1);
}
CommandLineArgs commandLineArgs = new CommandLineArgs(logger);
if (!commandLineArgs.ParseArguments(args))
{
return(1);
}
var teamBuildSettings = TeamBuildSettings.GetSettingsFromEnvironment(logger);
AnalysisConfig config = AnalysisConfig.Load(commandLineArgs.SonarQubeAnalysisConfigPath);
var legacyTeamBuildFactory = new LegacyTeamBuildFactory(logger, config);
switch (commandLineArgs.ProcessToExecute)
{
case Method.ConvertCoverage:
ExecuteCoverageConverter(logger, config, legacyTeamBuildFactory, teamBuildSettings, commandLineArgs.SonarProjectPropertiesPath);
break;
case Method.SummaryReportBuilder:
ExecuteReportBuilder(logger, config, legacyTeamBuildFactory, teamBuildSettings, commandLineArgs.RanToCompletion, commandLineArgs.SonarProjectPropertiesPath);
break;
}
}
catch (Exception ex)
{
logger.LogError("An exception occured while executing the process : " + ex.Message);
logger.LogError(ex.StackTrace);
}
return(0);
}
private bool DoExecute(ProcessedArgs args, ILogger logger)
{
if (args == null)
{
throw new ArgumentNullException("args");
}
if (logger == null)
{
throw new ArgumentNullException("logger");
}
logger.Verbosity = VerbosityCalculator.ComputeVerbosity(args.AggregateProperties, logger);
InstallLoaderTargets(args, logger);
TeamBuildSettings teamBuildSettings = TeamBuildSettings.GetSettingsFromEnvironment(logger);
// We're checking the args and environment variables so we can report all
// config errors to the user at once
if (teamBuildSettings == null)
{
logger.LogError(Resources.ERROR_CannotPerformProcessing);
return(false);
}
// Create the directories
logger.LogDebug(Resources.MSG_CreatingFolders);
if (!Utilities.TryEnsureEmptyDirectories(logger,
teamBuildSettings.SonarConfigDirectory,
teamBuildSettings.SonarOutputDirectory))
{
return(false);
}
IDictionary <string, string> serverSettings;
if (!FetchArgumentsAndRulesets(args, teamBuildSettings.SonarConfigDirectory, logger, out serverSettings))
{
return(false);
}
AnalysisConfigGenerator.GenerateFile(args, teamBuildSettings, serverSettings, logger);
return(true);
}
private bool DoExecute(ProcessedArgs localSettings)
{
Debug.Assert(localSettings != null, "Not expecting the process arguments to be null");
this.logger.Verbosity = VerbosityCalculator.ComputeVerbosity(localSettings.AggregateProperties, this.logger);
logger.ResumeOutput();
InstallLoaderTargets(localSettings);
TeamBuildSettings teamBuildSettings = TeamBuildSettings.GetSettingsFromEnvironment(this.logger);
// We're checking the args and environment variables so we can report all config errors to the user at once
if (teamBuildSettings == null)
{
this.logger.LogError(Resources.ERROR_CannotPerformProcessing);
return(false);
}
// Create the directories
this.logger.LogDebug(Resources.MSG_CreatingFolders);
if (!Utilities.TryEnsureEmptyDirectories(this.logger,
teamBuildSettings.SonarConfigDirectory,
teamBuildSettings.SonarOutputDirectory))
{
return(false);
}
ISonarQubeServer server = this.factory.CreateSonarQubeServer(localSettings, this.logger);
IDictionary <string, string> serverSettings;
List <AnalyzerSettings> analyzersSettings;
if (!FetchArgumentsAndRulesets(server, localSettings, teamBuildSettings, out serverSettings, out analyzersSettings))
{
return(false);
}
Debug.Assert(analyzersSettings != null, "Not expecting the analyzers settings to be null");
// analyzerSettings can be empty
AnalysisConfigGenerator.GenerateFile(localSettings, teamBuildSettings, serverSettings, analyzersSettings, this.logger);
return(true);
}
static int Main()
{
ILogger logger = new ConsoleLogger(includeTimestamp: true);
TeamBuildSettings settings = TeamBuildSettings.GetSettingsFromEnvironment(logger);
Debug.Assert(settings != null, "Settings should not be null");
AnalysisConfig config = GetAnalysisConfig(settings, logger);
if (config == null)
{
logger.LogError(Resources.ERROR_MissingSettings);
return(ErrorCode);
}
if (!CheckEnvironmentConsistency(config, settings, logger))
{
return(ErrorCode);
}
ICoverageReportProcessor coverageReportProcessor = TryCreateCoverageReportProcessor(settings);
// Handle code coverage reports
if (!coverageReportProcessor.ProcessCoverageReports(config, settings, logger))
{
return(ErrorCode);
}
ProjectInfoAnalysisResult result = InvokeSonarRunner(config, logger);
// Write summary report
if (settings.BuildEnvironment == BuildEnvironment.LegacyTeamBuild &&
!TeamBuildSettings.SkipLegacyCodeCoverageProcessing)
{
UpdateTeamBuildSummary(config, result, logger);
}
return(result.RanToCompletion ? SuccessCode : ErrorCode);
}
public void PreProc_NoProject()
{
// Arrange
string workingDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
TestLogger logger = new TestLogger();
// Configure the server
MockSonarQubeServer mockServer = new MockSonarQubeServer();
ServerDataModel data = mockServer.Data;
data.ServerProperties.Add("server.key", "server value 1");
data.InstalledPlugins.Add("csharp");
data.InstalledPlugins.Add("vbnet");
data.InstalledPlugins.Add("another_plugin");
data.AddQualityProfile("qp1", "cs")
.AddProject("invalid")
.AddRule(new ActiveRule("fxcop", "cs.rule1"))
.AddRule(new ActiveRule("fxcop", "cs.rule2"));
data.AddQualityProfile("qp2", "vbnet")
.AddProject("invalid")
.AddRule(new ActiveRule("fxcop-vbnet", "vb.rule1"))
.AddRule(new ActiveRule("fxcop-vbnet", "vb.rule2"));
MockRoslynAnalyzerProvider mockAnalyzerProvider = new MockRoslynAnalyzerProvider();
mockAnalyzerProvider.SettingsToReturn = new AnalyzerSettings();
mockAnalyzerProvider.SettingsToReturn.RuleSetFilePath = "c:\\xxx.ruleset";
MockTargetsInstaller mockTargetsInstaller = new MockTargetsInstaller();
MockObjectFactory mockFactory = new MockObjectFactory(mockServer, mockTargetsInstaller, mockAnalyzerProvider, new RulesetGenerator());
TeamBuildSettings settings;
using (PreprocessTestUtils.CreateValidNonTeamBuildScope())
using (new WorkingDirectoryScope(workingDir))
{
settings = TeamBuildSettings.GetSettingsFromEnvironment(new TestLogger());
Assert.IsNotNull(settings, "Test setup error: TFS environment variables have not been set correctly");
Assert.AreEqual(BuildEnvironment.NotTeamBuild, settings.BuildEnvironment, "Test setup error: build environment was not set correctly");
TeamBuildPreProcessor preProcessor = new TeamBuildPreProcessor(mockFactory, logger);
// Act
bool success = preProcessor.Execute(CreateValidArgs("key", "name", "1.0"));
Assert.IsTrue(success, "Expecting the pre-processing to complete successfully");
}
// Assert
AssertDirectoriesCreated(settings);
mockTargetsInstaller.AssertsTargetsCopied();
mockServer.AssertMethodCalled("GetProperties", 1);
mockServer.AssertMethodCalled("GetInstalledPlugins", 1);
mockServer.AssertMethodCalled("TryGetQualityProfile", 2); // C# and VBNet
mockServer.AssertMethodCalled("GetActiveRules", 0); // no quality profile assigned to project
mockServer.AssertMethodCalled("GetInactiveRules", 0);
AssertAnalysisConfig(settings.AnalysisConfigFilePath, 0, logger);
// only contains SonarQubeAnalysisConfig (no rulesets or aditional files)
AssertDirectoryContains(settings.SonarConfigDirectory, Path.GetFileName(settings.AnalysisConfigFilePath));
}
public void PreProc_EndToEnd_SuccessCase()
{
// Checks end-to-end happy path for the pre-processor i.e.
// * arguments are parsed
// * targets are installed
// * server properties are fetched
// * rulesets are generated
// * config file is created
// Arrange
string workingDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
TestLogger logger = new TestLogger();
// Configure the server
MockSonarQubeServer mockServer = new MockSonarQubeServer();
ServerDataModel data = mockServer.Data;
data.ServerProperties.Add("server.key", "server value 1");
data.Languages.Add("cs");
data.Languages.Add("vbnet");
data.Languages.Add("another_plugin");
data.AddQualityProfile("qp1", "cs", null)
.AddProject("key")
.AddRule(new ActiveRule("csharpsquid", "cs.rule3"));
data.AddQualityProfile("qp2", "vbnet", null)
.AddProject("key")
.AddRule(new ActiveRule("vbnet", "vb.rule3"));
MockRoslynAnalyzerProvider mockAnalyzerProvider = new MockRoslynAnalyzerProvider
{
SettingsToReturn = new AnalyzerSettings
{
RuleSetFilePath = "c:\\xxx.ruleset"
}
};
Mock <ITargetsInstaller> mockTargetsInstaller = new Mock <ITargetsInstaller>();
MockObjectFactory mockFactory = new MockObjectFactory(mockServer, mockTargetsInstaller.Object, mockAnalyzerProvider);
TeamBuildSettings settings;
using (PreprocessTestUtils.CreateValidNonTeamBuildScope())
using (new WorkingDirectoryScope(workingDir))
{
settings = TeamBuildSettings.GetSettingsFromEnvironment(new TestLogger());
Assert.IsNotNull(settings, "Test setup error: TFS environment variables have not been set correctly");
Assert.AreEqual(BuildEnvironment.NotTeamBuild, settings.BuildEnvironment, "Test setup error: build environment was not set correctly");
TeamBuildPreProcessor preProcessor = new TeamBuildPreProcessor(mockFactory, logger);
// Act
bool success = preProcessor.Execute(CreateValidArgs("key", "name", "1.0"));
Assert.IsTrue(success, "Expecting the pre-processing to complete successfully");
}
// Assert
AssertDirectoriesCreated(settings);
mockTargetsInstaller.Verify(x => x.InstallLoaderTargets(logger, workingDir), Times.Once());
mockServer.AssertMethodCalled("GetProperties", 1);
mockServer.AssertMethodCalled("GetAllLanguages", 1);
mockServer.AssertMethodCalled("TryGetQualityProfile", 2); // C# and VBNet
mockServer.AssertMethodCalled("GetActiveRules", 2); // C# and VBNet
mockServer.AssertMethodCalled("GetInactiveRules", 2); // C# and VBNet
AssertAnalysisConfig(settings.AnalysisConfigFilePath, 2, logger);
}
public void PreProc_EndToEnd_SuccessCase()
{
// Checks end-to-end happy path for the pre-processor i.e.
// * arguments are parsed
// * targets are installed
// * server properties are fetched
// * rulesets are generated
// * config file is created
// Arrange
string workingDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
MockRulesetGenerator mockRulesetGenerator = new MockRulesetGenerator();
TestLogger logger = new TestLogger();
MockPropertiesFetcher mockPropertiesFetcher = new MockPropertiesFetcher();
mockPropertiesFetcher.PropertiesToReturn = new Dictionary <string, string>();
MockTargetsInstaller mockTargetsInstaller = new MockTargetsInstaller();
// The set of server properties to return
mockPropertiesFetcher.PropertiesToReturn.Add("server.key", "server value 1");
string[] validArgs = new string[] {
"/k:key", "/n:name", "/v:1.0",
"/d:cmd.line1=cmdline.value.1",
"/d:sonar.host.url=http://host",
"/d:sonar.log.level=INFO|DEBUG"
};
TeamBuildSettings settings;
using (PreprocessTestUtils.CreateValidNonTeamBuildScope())
using (new WorkingDirectoryScope(workingDir))
{
settings = TeamBuildSettings.GetSettingsFromEnvironment(new TestLogger());
Assert.IsNotNull(settings, "Test setup error: TFS environment variables have not been set correctly");
Assert.AreEqual(BuildEnvironment.NotTeamBuild, settings.BuildEnvironment, "Test setup error: build environment was not set correctly");
TeamBuildPreProcessor preProcessor = new TeamBuildPreProcessor(mockPropertiesFetcher, mockRulesetGenerator, mockTargetsInstaller);
// Act
bool success = preProcessor.Execute(validArgs, logger);
Assert.IsTrue(success, "Expecting the pre-processing to complete successfully");
}
// Assert
AssertDirectoryExists(settings.AnalysisBaseDirectory);
AssertDirectoryExists(settings.SonarConfigDirectory);
AssertDirectoryExists(settings.SonarOutputDirectory);
// The bootstrapper is responsible for creating the bin directory
mockTargetsInstaller.AssertsTargetsCopied();
mockPropertiesFetcher.AssertFetchPropertiesCalled();
mockRulesetGenerator.AssertGenerateCalled(2); // C# and VB
logger.AssertErrorsLogged(0);
logger.AssertWarningsLogged(0);
logger.AssertVerbosity(LoggerVerbosity.Debug);
AssertConfigFileExists(settings.AnalysisConfigFilePath);
AnalysisConfig actualConfig = AnalysisConfig.Load(settings.AnalysisConfigFilePath);
Assert.AreEqual("key", actualConfig.SonarProjectKey, "Unexpected project key");
Assert.AreEqual("name", actualConfig.SonarProjectName, "Unexpected project name");
Assert.AreEqual("1.0", actualConfig.SonarProjectVersion, "Unexpected project version");
AssertExpectedLocalSetting(SonarProperties.HostUrl, "http://host", actualConfig);
AssertExpectedLocalSetting("cmd.line1", "cmdline.value.1", actualConfig);
AssertExpectedServerSetting("server.key", "server value 1", actualConfig);
}
public bool Execute(ILogger logger, string projectKey, string projectName, string projectVersion, string propertiesPath)
{
if (logger == null)
{
throw new ArgumentNullException("logger");
}
if (string.IsNullOrWhiteSpace(projectKey))
{
throw new ArgumentNullException("projectKey");
}
if (string.IsNullOrWhiteSpace(projectName))
{
throw new ArgumentNullException("projectName");
}
if (string.IsNullOrWhiteSpace(projectVersion))
{
throw new ArgumentNullException("projectVersion");
}
if (string.IsNullOrWhiteSpace(propertiesPath))
{
throw new ArgumentNullException("propertiesPath");
}
AnalysisConfig config = new AnalysisConfig();
config.SonarProjectKey = projectKey;
config.SonarProjectName = projectName;
config.SonarProjectVersion = projectVersion;
config.SonarRunnerPropertiesPath = propertiesPath;
TeamBuildSettings teamBuildSettings = TeamBuildSettings.GetSettingsFromEnvironment(logger);
// We're checking the args and environment variables so we can report all
// config errors to the user at once
if (teamBuildSettings == null)
{
logger.LogError(Resources.ERROR_CannotPerformProcessing);
return(false);
}
config.SetBuildUri(teamBuildSettings.BuildUri);
config.SetTfsUri(teamBuildSettings.TfsUri);
config.SonarConfigDir = teamBuildSettings.SonarConfigDirectory;
config.SonarOutputDir = teamBuildSettings.SonarOutputDirectory;
// Create the directories
logger.LogMessage(Resources.DIAG_CreatingFolders);
EnsureEmptyDirectory(logger, config.SonarConfigDir);
EnsureEmptyDirectory(logger, config.SonarOutputDir);
using (SonarWebService ws = GetSonarWebService(config))
{
// Fetch the SonarQube project properties
FetchSonarQubeProperties(config, ws);
// Generate the FxCop ruleset
GenerateFxCopRuleset(config, ws, logger);
}
// Save the config file
logger.LogMessage(Resources.DIAG_SavingConfigFile, teamBuildSettings.AnalysisConfigFilePath);
config.Save(teamBuildSettings.AnalysisConfigFilePath);
return(true);
}
// Regression test for https://github.com/SonarSource/sonar-scanner-msbuild/issues/699
public void PreProc_EndToEnd_Success_LocalSettingsAreUsedInSonarLintXML()
{
// Checks that local settings are used when creating the SonarLint.xml file,
// overriding
// Arrange
var workingDir = TestUtils.CreateTestSpecificFolderWithSubPaths(TestContext);
var logger = new TestLogger();
// Configure the server
var mockServer = new MockSonarQubeServer();
var data = mockServer.Data;
data.Languages.Add("cs");
data.AddQualityProfile("qp1", "cs", null)
.AddProject("key")
.AddRule(new SonarRule("csharpsquid", "cs.rule3"));
// Server-side settings
data.ServerProperties.Add("server.key", "server value 1");
data.ServerProperties.Add("shared.key1", "server shared value 1");
data.ServerProperties.Add("shared.CASING", "server upper case value");
// Local settings that should override matching server settings
var args = new List <string>(CreateValidArgs("key", "name", "1.0"));
args.Add("/d:local.key=local value 1");
args.Add("/d:shared.key1=local shared value 1 - should override server value");
args.Add("/d:shared.casing=local lower case value");
var mockAnalyzerProvider = new MockRoslynAnalyzerProvider
{
SettingsToReturn = new AnalyzerSettings
{
RuleSetFilePath = "c:\\xxx.ruleset"
}
};
var mockTargetsInstaller = new Mock <ITargetsInstaller>();
var mockFactory = new MockObjectFactory(mockServer, mockTargetsInstaller.Object, mockAnalyzerProvider);
TeamBuildSettings settings;
using (PreprocessTestUtils.CreateValidNonTeamBuildScope())
using (new WorkingDirectoryScope(workingDir))
{
settings = TeamBuildSettings.GetSettingsFromEnvironment(new TestLogger());
settings.Should().NotBeNull("Test setup error: TFS environment variables have not been set correctly");
settings.BuildEnvironment.Should().Be(BuildEnvironment.NotTeamBuild, "Test setup error: build environment was not set correctly");
var preProcessor = new TeamBuildPreProcessor(mockFactory, logger);
// Act
var success = preProcessor.Execute(args.ToArray()).Result;
success.Should().BeTrue("Expecting the pre-processing to complete successfully");
}
// Assert
// Check the settings used when creating the SonarLint file - local and server settings should be merged
mockAnalyzerProvider.SuppliedSonarProperties.Should().NotBeNull();
mockAnalyzerProvider.SuppliedSonarProperties.AssertExpectedPropertyValue("server.key", "server value 1");
mockAnalyzerProvider.SuppliedSonarProperties.AssertExpectedPropertyValue("local.key", "local value 1");
mockAnalyzerProvider.SuppliedSonarProperties.AssertExpectedPropertyValue("shared.key1", "local shared value 1 - should override server value");
// Keys are case-sensitive so differently cased values should be preserved
mockAnalyzerProvider.SuppliedSonarProperties.AssertExpectedPropertyValue("shared.CASING", "server upper case value");
mockAnalyzerProvider.SuppliedSonarProperties.AssertExpectedPropertyValue("shared.casing", "local lower case value");
// Check the settings used when creating the config file - settings should be separate
var actualConfig = AssertAnalysisConfig(settings.AnalysisConfigFilePath, 1, logger);
AssertExpectedLocalSetting("local.key", "local value 1", actualConfig);
AssertExpectedLocalSetting("shared.key1", "local shared value 1 - should override server value", actualConfig);
AssertExpectedLocalSetting("shared.casing", "local lower case value", actualConfig);
AssertExpectedServerSetting("server.key", "server value 1", actualConfig);
AssertExpectedServerSetting("shared.key1", "server shared value 1", actualConfig);
AssertExpectedServerSetting("shared.CASING", "server upper case value", actualConfig);
}
public void PreProc_NoProject()
{
// Arrange
var workingDir = TestUtils.CreateTestSpecificFolderWithSubPaths(TestContext);
var logger = new TestLogger();
// Configure the server
var mockServer = new MockSonarQubeServer();
var data = mockServer.Data;
data.ServerProperties.Add("server.key", "server value 1");
data.Languages.Add("cs");
data.Languages.Add("vbnet");
data.Languages.Add("another_plugin");
data.AddQualityProfile("qp1", "cs", null)
.AddProject("invalid")
.AddRule(new SonarRule("fxcop", "cs.rule1"))
.AddRule(new SonarRule("fxcop", "cs.rule2"));
data.AddQualityProfile("qp2", "vbnet", null)
.AddProject("invalid")
.AddRule(new SonarRule("fxcop-vbnet", "vb.rule1"))
.AddRule(new SonarRule("fxcop-vbnet", "vb.rule2"));
var mockAnalyzerProvider = new MockRoslynAnalyzerProvider
{
SettingsToReturn = new AnalyzerSettings
{
RuleSetFilePath = "c:\\xxx.ruleset"
}
};
var mockTargetsInstaller = new Mock <ITargetsInstaller>();
var mockFactory = new MockObjectFactory(mockServer, mockTargetsInstaller.Object, mockAnalyzerProvider);
TeamBuildSettings settings;
using (PreprocessTestUtils.CreateValidNonTeamBuildScope())
using (new WorkingDirectoryScope(workingDir))
{
settings = TeamBuildSettings.GetSettingsFromEnvironment(new TestLogger());
settings.Should().NotBeNull("Test setup error: TFS environment variables have not been set correctly");
settings.BuildEnvironment.Should().Be(BuildEnvironment.NotTeamBuild, "Test setup error: build environment was not set correctly");
var preProcessor = new TeamBuildPreProcessor(mockFactory, logger);
// Act
var success = preProcessor.Execute(CreateValidArgs("key", "name", "1.0", null)).Result;
success.Should().BeTrue("Expecting the pre-processing to complete successfully");
}
// Assert
AssertDirectoriesCreated(settings);
mockTargetsInstaller.Verify(x => x.InstallLoaderTargets(workingDir), Times.Once());
mockServer.AssertMethodCalled("GetProperties", 1);
mockServer.AssertMethodCalled("GetAllLanguages", 1);
mockServer.AssertMethodCalled("TryGetQualityProfile", 2); // C# and VBNet
mockServer.AssertMethodCalled("GetActiveRules", 0); // no quality profile assigned to project
mockServer.AssertMethodCalled("GetInactiveRules", 0);
AssertAnalysisConfig(settings.AnalysisConfigFilePath, 0, logger);
// only contains SonarQubeAnalysisConfig (no rulesets or additional files)
AssertDirectoryContains(settings.SonarConfigDirectory, Path.GetFileName(settings.AnalysisConfigFilePath));
}
public void PreProc_EndToEnd_ShouldWarnOrNot_SonarQubeDeprecatedVersion(string sqVersion, bool shouldWarn)
{
// Arrange
var workingDir = TestUtils.CreateTestSpecificFolderWithSubPaths(TestContext);
var logger = new TestLogger();
// Configure the server
var mockServer = new MockSonarQubeServer();
var data = mockServer.Data;
data.ServerProperties.Add("server.key", "server value 1");
data.SonarQubeVersion = new Version(sqVersion);
data.Languages.Add("cs");
data.Languages.Add("vbnet");
data.Languages.Add("another_plugin");
data.AddQualityProfile("qp1", "cs", "organization")
.AddProject("key")
.AddRule(new SonarRule("csharpsquid", "cs.rule3"));
data.AddQualityProfile("qp2", "vbnet", "organization")
.AddProject("key")
.AddRule(new SonarRule("vbnet", "vb.rule3"));
var mockAnalyzerProvider = new MockRoslynAnalyzerProvider
{
SettingsToReturn = new AnalyzerSettings
{
RulesetPath = "c:\\xxx.ruleset"
}
};
var mockTargetsInstaller = new Mock <ITargetsInstaller>();
var mockFactory = new MockObjectFactory(mockServer, mockTargetsInstaller.Object, mockAnalyzerProvider);
TeamBuildSettings settings;
using (PreprocessTestUtils.CreateValidNonTeamBuildScope())
using (new WorkingDirectoryScope(workingDir))
{
settings = TeamBuildSettings.GetSettingsFromEnvironment(new TestLogger());
settings.Should().NotBeNull("Test setup error: TFS environment variables have not been set correctly");
settings.BuildEnvironment.Should().Be(BuildEnvironment.NotTeamBuild, "Test setup error: build environment was not set correctly");
var preProcessor = new TeamBuildPreProcessor(mockFactory, logger);
// Act
var success = preProcessor.Execute(CreateValidArgs("key", "name", "1.0", "organization")).Result;
success.Should().BeTrue("Expecting the pre-processing to complete successfully");
}
mockTargetsInstaller.Verify(x => x.InstallLoaderTargets(workingDir), Times.Once());
if (shouldWarn)
{
mockServer.AssertWarningWritten("version is below supported");
}
else
{
mockServer.AssertNoWarningWritten();
}
}
public void PreProc_EndToEnd_SuccessCase()
{
// Checks end-to-end happy path for the pre-processor i.e.
// * arguments are parsed
// * targets are installed
// * server properties are fetched
// * rulesets are generated
// * config file is created
// Arrange
string workingDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
TestLogger logger = new TestLogger();
// Configure the server
MockSonarQubeServer mockServer = new MockSonarQubeServer();
ServerDataModel data = mockServer.Data;
data.ServerProperties.Add("server.key", "server value 1");
data.InstalledPlugins.Add("csharp");
data.InstalledPlugins.Add("vbnet");
data.AddRepository("fxcop", "cs")
.AddRule("cs.rule1", "cs.rule1.internal")
.AddRule("cs.rule2", "cs.rule2.internal");
data.AddRepository("fxcop-vbnet", "vbnet")
.AddRule("vb.rule1", "vb.rule1.internal")
.AddRule("vb.rule2", "vb.rule2.internal");
data.AddQualityProfile("test.profile", "cs")
.AddProject("key");
data.AddRuleToProfile("cs.rule1", "test.profile");
data.AddQualityProfile("test.profile", "vbnet")
.AddProject("key");
data.AddRuleToProfile("vb.rule2", "test.profile");
MockRoslynAnalyzerProvider mockAnalyzerProvider = new MockRoslynAnalyzerProvider();
mockAnalyzerProvider.SettingsToReturn = new AnalyzerSettings();
mockAnalyzerProvider.SettingsToReturn.RuleSetFilePath = "c:\\xxx.ruleset";
MockTargetsInstaller mockTargetsInstaller = new MockTargetsInstaller();
MockObjectFactory mockFactory = new MockObjectFactory(mockServer, mockTargetsInstaller, mockAnalyzerProvider);
string[] validArgs = new string[] {
"/k:key", "/n:name", "/v:1.0",
"/d:cmd.line1=cmdline.value.1",
"/d:sonar.host.url=http://host",
"/d:sonar.log.level=INFO|DEBUG"
};
TeamBuildSettings settings;
using (PreprocessTestUtils.CreateValidNonTeamBuildScope())
using (new WorkingDirectoryScope(workingDir))
{
settings = TeamBuildSettings.GetSettingsFromEnvironment(new TestLogger());
Assert.IsNotNull(settings, "Test setup error: TFS environment variables have not been set correctly");
Assert.AreEqual(BuildEnvironment.NotTeamBuild, settings.BuildEnvironment, "Test setup error: build environment was not set correctly");
TeamBuildPreProcessor preProcessor = new TeamBuildPreProcessor(mockFactory, logger);
// Act
bool success = preProcessor.Execute(validArgs);
Assert.IsTrue(success, "Expecting the pre-processing to complete successfully");
}
// Assert
AssertDirectoryExists(settings.AnalysisBaseDirectory);
AssertDirectoryExists(settings.SonarConfigDirectory);
AssertDirectoryExists(settings.SonarOutputDirectory);
// The bootstrapper is responsible for creating the bin directory
mockTargetsInstaller.AssertsTargetsCopied();
mockServer.AssertMethodCalled("GetProperties", 1);
mockServer.AssertMethodCalled("GetInternalKeys", 2); // C# and VB
logger.AssertErrorsLogged(0);
logger.AssertWarningsLogged(0);
logger.AssertVerbosity(LoggerVerbosity.Debug);
AssertConfigFileExists(settings.AnalysisConfigFilePath);
AnalysisConfig actualConfig = AnalysisConfig.Load(settings.AnalysisConfigFilePath);
Assert.AreEqual("key", actualConfig.SonarProjectKey, "Unexpected project key");
Assert.AreEqual("name", actualConfig.SonarProjectName, "Unexpected project name");
Assert.AreEqual("1.0", actualConfig.SonarProjectVersion, "Unexpected project version");
Assert.IsNotNull(actualConfig.AnalyzerSettings, "Analyzer settings should not be null");
Assert.AreEqual("c:\\xxx.ruleset", actualConfig.AnalyzerSettings.RuleSetFilePath, "Unexpected ruleset path");
AssertExpectedLocalSetting(SonarProperties.HostUrl, "http://host", actualConfig);
AssertExpectedLocalSetting("cmd.line1", "cmdline.value.1", actualConfig);
AssertExpectedServerSetting("server.key", "server value 1", actualConfig);
string fxCopFilePath = AssertFileExists(settings.SonarConfigDirectory, TeamBuildPreProcessor.FxCopCSharpRuleset);
PreProcessAsserts.AssertRuleSetContainsRules(fxCopFilePath, "cs.rule1");
fxCopFilePath = AssertFileExists(settings.SonarConfigDirectory, TeamBuildPreProcessor.FxCopVBNetRuleset);
PreProcessAsserts.AssertRuleSetContainsRules(fxCopFilePath, "vb.rule2");
}
