public void ProcArgs_TryGetSetting()
{
// 0. Setup
ListPropertiesProvider cmdLineProps = new ListPropertiesProvider();
cmdLineProps.AddProperty("cmd.key.1", "cmd value 1");
cmdLineProps.AddProperty("shared.key.1", "shared cmd value");
ListPropertiesProvider fileProps = new ListPropertiesProvider();
fileProps.AddProperty("file.key.1", "file value 1");
fileProps.AddProperty("shared.key.1", "shared file value");
ProcessedArgs args = new ProcessedArgs("key", "name", "ver", false, cmdLineProps, fileProps);
// 1. Missing key -> null
string result;
Assert.IsFalse(args.TryGetSetting("missing.property", out result), "Expecting false when the specified key does not exist");
Assert.IsNull(result, "Expecting the value to be null when the specified key does not exist");
// 2. Returns existing values
Assert.IsTrue(args.TryGetSetting("cmd.key.1", out result));
Assert.AreEqual("cmd value 1", result);
// 3. Precedence - command line properties should win
Assert.AreEqual("shared cmd value", args.GetSetting("shared.key.1"));
// 4. Preprocessor only settings
Assert.AreEqual(false, args.InstallLoaderTargets);
}
public void AnalysisConfGen_AnalysisConfigDoesNotContainSensitiveData()
{
// Arrange
string analysisDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
TestLogger logger = new TestLogger();
ListPropertiesProvider cmdLineArgs = new ListPropertiesProvider();
// Public args - should be written to the config file
cmdLineArgs.AddProperty("sonar.host.url", "http://host");
cmdLineArgs.AddProperty("public.key", "public value");
// Sensitive values - should not be written to the config file
cmdLineArgs.AddProperty(SonarProperties.DbPassword, "secret db password");
cmdLineArgs.AddProperty(SonarProperties.DbUserName, "secret db user");
// Create a settings file with public and sensitive data
AnalysisProperties fileSettings = new AnalysisProperties();
fileSettings.Add(new Property() { Id = "file.public.key", Value = "file public value" });
fileSettings.Add(new Property() {Id = SonarProperties.DbUserName, Value = "secret db user"});
fileSettings.Add(new Property() { Id = SonarProperties.DbPassword, Value = "secret db password"});
string fileSettingsPath = Path.Combine(analysisDir, "fileSettings.txt");
fileSettings.Save(fileSettingsPath);
FilePropertyProvider fileProvider = FilePropertyProvider.Load(fileSettingsPath);
ProcessedArgs args = new ProcessedArgs("key", "name", "1.0", false, cmdLineArgs, fileProvider);
IDictionary<string, string> serverProperties = new Dictionary<string, string>();
// Public server settings
serverProperties.Add("server.key.1", "server value 1");
// Sensitive server settings
serverProperties.Add(SonarProperties.SonarUserName, "secret user");
serverProperties.Add(SonarProperties.SonarPassword, "secret pwd");
TeamBuildSettings settings = TeamBuildSettings.CreateNonTeamBuildSettingsForTesting(analysisDir);
Directory.CreateDirectory(settings.SonarConfigDirectory); // config directory needs to exist
// Act
AnalysisConfig config = AnalysisConfigGenerator.GenerateFile(args, settings, serverProperties, logger);
// Assert
AssertConfigFileExists(config);
logger.AssertErrorsLogged(0);
logger.AssertWarningsLogged(0);
// Check the config
// "Public" arguments should be in the file
Assert.AreEqual("key", config.SonarProjectKey, "Unexpected project key");
Assert.AreEqual("name", config.SonarProjectName, "Unexpected project name");
Assert.AreEqual("1.0", config.SonarProjectVersion, "Unexpected project version");
AssertExpectedLocalSetting(SonarProperties.HostUrl, "http://host", config);
AssertExpectedServerSetting("server.key.1", "server value 1", config);
AssertFileDoesNotContainText(config.FileName, "file.public.key"); // file settings values should not be in the config
// SONARMSBRU-136: TODO - uncomment the following code:
AssertFileDoesNotContainText(config.FileName, "secret"); // sensitive data should not be in config
}
public void ProcArgs_GetSetting()
{
// 0. Setup
ListPropertiesProvider cmdLineProps = new ListPropertiesProvider();
cmdLineProps.AddProperty("cmd.key.1", "cmd value 1");
cmdLineProps.AddProperty("shared.key.1", "shared cmd value");
ListPropertiesProvider fileProps = new ListPropertiesProvider();
fileProps.AddProperty("file.key.1", "file value 1");
fileProps.AddProperty("shared.key.1", "shared file value");
ProcessedArgs args = new ProcessedArgs("key", "name", "ver", true, cmdLineProps, fileProps);
// 1. Throws on missing value
AssertException.Expects<InvalidOperationException>(() => args.GetSetting("missing.property"));
// 2. Returns existing values
Assert.AreEqual("cmd value 1", args.GetSetting("cmd.key.1"));
Assert.AreEqual("file value 1", args.GetSetting("file.key.1"));
// 3. Precedence - command line properties should win
Assert.AreEqual("shared cmd value", args.GetSetting("shared.key.1"));
// 4. Preprocessor only settings
Assert.AreEqual(true, args.InstallLoaderTargets);
}
public ISonarQubeServer CreateSonarQubeServer(ProcessedArgs args, ILogger logger)
{
Assert.IsNotNull(args);
Assert.IsNotNull(logger);
return this.server;
}
public ISonarQubeServer Create(ProcessedArgs args)
{
if (args == null)
{
throw new ArgumentNullException("args");
}
return this.server;
}
public void AnalysisConfGen_Simple()
{
// Arrange
string analysisDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
TestLogger logger = new TestLogger();
ListPropertiesProvider propertyProvider = new ListPropertiesProvider();
propertyProvider.AddProperty(SonarProperties.HostUrl, "http://foo");
ProcessedArgs args = new ProcessedArgs("valid.key", "valid.name", "1.0", false, EmptyPropertyProvider.Instance, propertyProvider);
TeamBuildSettings tbSettings = TeamBuildSettings.CreateNonTeamBuildSettingsForTesting(analysisDir);
Dictionary<string, string> serverSettings = new Dictionary<string, string>();
serverSettings.Add("server.key.1", "server.value.1");
AnalyzerSettings analyzerSettings = new AnalyzerSettings();
analyzerSettings.RuleSetFilePath = "c:\\xxx.ruleset";
analyzerSettings.AdditionalFilePaths = new List<string>();
analyzerSettings.AdditionalFilePaths.Add("f:\\additionalPath1.txt");
analyzerSettings.AnalyzerAssemblyPaths = new List<string>();
analyzerSettings.AnalyzerAssemblyPaths.Add("f:\\temp\\analyzer1.dll");
Directory.CreateDirectory(tbSettings.SonarConfigDirectory); // config directory needs to exist
// Act
AnalysisConfig actualConfig = AnalysisConfigGenerator.GenerateFile(args, tbSettings, serverSettings, analyzerSettings, logger);
// Assert
AssertConfigFileExists(actualConfig);
logger.AssertErrorsLogged(0);
logger.AssertWarningsLogged(0);
Assert.AreEqual("valid.key", actualConfig.SonarProjectKey);
Assert.AreEqual("valid.name", actualConfig.SonarProjectName);
Assert.AreEqual("1.0", actualConfig.SonarProjectVersion);
Assert.AreEqual("http://foo", actualConfig.SonarQubeHostUrl);
Assert.AreEqual(tbSettings.SonarBinDirectory, actualConfig.SonarBinDir);
Assert.AreEqual(tbSettings.SonarConfigDirectory, actualConfig.SonarConfigDir);
Assert.AreEqual(tbSettings.SonarOutputDirectory, actualConfig.SonarOutputDir);
Assert.AreEqual(tbSettings.SonarRunnerWorkingDirectory, actualConfig.SonarRunnerWorkingDirectory);
Assert.AreEqual(tbSettings.BuildUri, actualConfig.GetBuildUri());
Assert.AreEqual(tbSettings.TfsUri, actualConfig.GetTfsUri());
Assert.IsNotNull(actualConfig.ServerSettings);
Property serverProperty = actualConfig.ServerSettings.SingleOrDefault(s => string.Equals(s.Id, "server.key.1", System.StringComparison.Ordinal));
Assert.IsNotNull(serverProperty);
Assert.AreEqual("server.value.1", serverProperty.Value);
Assert.AreSame(analyzerSettings, actualConfig.AnalyzerSettings);
}
private static void AssertExpectedInstallTargets(bool expected, ProcessedArgs actual)
{
Assert.AreEqual(expected, actual.InstallLoaderTargets);
}
public void PreArgProc_DefaultHostUrl()
{
ProcessedArgs args = CheckProcessingSucceeds("/k:key");
Assert.AreEqual(args.SonarQubeUrl, "http://localhost:9000");
}
private static void CheckProjectKeyIsValid(string projectKey)
{
ProcessedArgs result = CheckProcessingSucceeds("/key:" + projectKey, "/name:valid name", "/version:1.0", "/d:sonar.host.url=http://valid");
Assert.AreEqual(projectKey, result.ProjectKey, "Unexpected project key");
}
private static void AssertExpectedValues(string key, string name, string version, ProcessedArgs actual)
{
Assert.AreEqual(key, actual.ProjectKey, "Unexpected project key");
Assert.AreEqual(name, actual.ProjectName, "Unexpected project name");
Assert.AreEqual(version, actual.ProjectVersion, "Unexpected project version");
}
public void AnalysisConfGen_Simple()
{
// Arrange
var analysisDir = TestUtils.CreateTestSpecificFolderWithSubPaths(TestContext);
var logger = new TestLogger();
var propertyProvider = new ListPropertiesProvider();
propertyProvider.AddProperty(SonarProperties.HostUrl, "http://foo");
var args = new ProcessedArgs("valid.key", "valid.name", "1.0", null, false, EmptyPropertyProvider.Instance, propertyProvider, EmptyPropertyProvider.Instance, logger);
var tbSettings = TeamBuildSettings.CreateNonTeamBuildSettingsForTesting(analysisDir);
var serverSettings = new Dictionary <string, string>
{
{ "server.key.1", "server.value.1" }
};
var analyzerSettings = new AnalyzerSettings
{
RuleSetFilePath = "c:\\xxx.ruleset",
AdditionalFilePaths = new List <string>()
};
analyzerSettings.AdditionalFilePaths.Add("f:\\additionalPath1.txt");
analyzerSettings.AnalyzerPlugins = new List <AnalyzerPlugin>
{
new AnalyzerPlugin
{
AssemblyPaths = new List <string> {
"f:\\temp\\analyzer1.dll"
}
}
};
var analyzersSettings = new List <AnalyzerSettings>
{
analyzerSettings
};
Directory.CreateDirectory(tbSettings.SonarConfigDirectory); // config directory needs to exist
// Act
var actualConfig = AnalysisConfigGenerator.GenerateFile(args, tbSettings, serverSettings, analyzersSettings, new MockSonarQubeServer(), logger);
// Assert
AssertConfigFileExists(actualConfig);
logger.AssertErrorsLogged(0);
logger.AssertWarningsLogged(0);
actualConfig.SonarProjectKey.Should().Be("valid.key");
actualConfig.SonarProjectName.Should().Be("valid.name");
actualConfig.SonarProjectVersion.Should().Be("1.0");
actualConfig.SonarQubeHostUrl.Should().Be("http://foo");
actualConfig.SonarBinDir.Should().Be(tbSettings.SonarBinDirectory);
actualConfig.SonarConfigDir.Should().Be(tbSettings.SonarConfigDirectory);
actualConfig.SonarOutputDir.Should().Be(tbSettings.SonarOutputDirectory);
actualConfig.SonarScannerWorkingDirectory.Should().Be(tbSettings.SonarScannerWorkingDirectory);
actualConfig.GetBuildUri().Should().Be(tbSettings.BuildUri);
actualConfig.GetTfsUri().Should().Be(tbSettings.TfsUri);
actualConfig.ServerSettings.Should().NotBeNull();
var serverProperty = actualConfig.ServerSettings.SingleOrDefault(s => string.Equals(s.Id, "server.key.1", System.StringComparison.Ordinal));
serverProperty.Should().NotBeNull();
serverProperty.Value.Should().Be("server.value.1");
actualConfig.AnalyzersSettings[0].Should().Be(analyzerSettings);
}
public void ProcArgs_CmdLinePropertiesOverrideFileSettings()
{
// Checks command line properties override those from files
// Arrange
// The set of command line properties to supply
ListPropertiesProvider cmdLineProperties = new ListPropertiesProvider();
cmdLineProperties.AddProperty("shared.key1", "cmd line value1 - should override server value");
cmdLineProperties.AddProperty("cmd.line.only", "cmd line value4 - only on command line");
cmdLineProperties.AddProperty("xxx", "cmd line value XXX - lower case");
cmdLineProperties.AddProperty(SonarProperties.HostUrl, "http://host");
// The set of file properties to supply
ListPropertiesProvider fileProperties = new ListPropertiesProvider();
fileProperties.AddProperty("shared.key1", "file value1 - should be overridden");
fileProperties.AddProperty("file.only", "file value3 - only in file");
fileProperties.AddProperty("XXX", "file line value XXX - upper case");
// Act
ProcessedArgs args = new ProcessedArgs("key", "name", "version", false, cmdLineProperties, fileProperties);
AssertExpectedValue("shared.key1", "cmd line value1 - should override server value", args);
AssertExpectedValue("cmd.line.only", "cmd line value4 - only on command line", args);
AssertExpectedValue("file.only", "file value3 - only in file", args);
AssertExpectedValue("xxx", "cmd line value XXX - lower case", args);
AssertExpectedValue("XXX", "file line value XXX - upper case", args);
AssertExpectedValue(SonarProperties.HostUrl, "http://host", args);
}
private ProcessedArgs CreateValidArguments()
{
Common.ListPropertiesProvider cmdLineArgs = new Common.ListPropertiesProvider();
cmdLineArgs.AddProperty(Common.SonarProperties.HostUrl, "http://foo");
ProcessedArgs validArgs = new ProcessedArgs("key", "name", "verions", false,
cmdLineArgs,
new Common.ListPropertiesProvider());
return validArgs;
}
private static void AssertExpectedPropertyValue(string key, string value, ProcessedArgs actual)
{
// Test the GetSetting method
string actualValue = actual.GetSetting(key);
Assert.IsNotNull(actualValue, "Expected dynamic settings does not exist. Key: {0}", key);
Assert.AreEqual(value, actualValue, "Dynamic setting does not have the expected value");
// Check the public list of properties
Property match;
bool found = Property.TryGetProperty(key, actual.GetAllProperties(), out match);
Assert.IsTrue(found, "Failed to find the expected property. Key: {0}", key);
Assert.IsNotNull(match, "Returned property should not be null. Key: {0}", key);
Assert.AreEqual(value, match.Value, "Property does not have the expected value");
}
public void ProcArgs_GetSettingOrDefault()
{
// 0. Setup
ListPropertiesProvider cmdLineProps = new ListPropertiesProvider();
cmdLineProps.AddProperty("cmd.key.1", "cmd value 1");
cmdLineProps.AddProperty("shared.key.1", "shared cmd value");
ListPropertiesProvider fileProps = new ListPropertiesProvider();
fileProps.AddProperty("file.key.1", "file value 1");
fileProps.AddProperty("shared.key.1", "shared file value");
ProcessedArgs args = new ProcessedArgs("key", "name", "ver", true, cmdLineProps, fileProps);
// 1. Missing key -> default returned
string result = args.GetSetting("missing.property", "default value");
Assert.AreEqual("default value", result);
// 2. Returns existing values
result = args.GetSetting("file.key.1", "default value");
Assert.AreEqual("file value 1", result);
// 3. Precedence - command line properties should win
Assert.AreEqual("shared cmd value", args.GetSetting("shared.key.1", "default ValueType"));
// 4. Preprocessor only settings
Assert.AreEqual(true, args.InstallLoaderTargets);
}
private static void AssertExpectedValues(string key, string name, string version, string path, ProcessedArgs actual)
{
Assert.AreEqual(key, actual.ProjectKey, "Unexpected project key");
Assert.AreEqual(name, actual.ProjectName, "Unexpected project name");
Assert.AreEqual(version, actual.ProjectVersion, "Unexpected project version");
Assert.AreEqual(path, actual.RunnerPropertiesPath, "Unexpected runner properties path version");
}
public bool Generate(ProcessedArgs args)
{
if (args == null)
{
throw new ArgumentNullException(nameof(args));
}
IPackage targetPackage = packageHandler.FetchPackage(args.PackageId, args.PackageVersion);
if (targetPackage == null)
{
return(false);
}
IEnumerable <IPackage> dependencyPackages = packageHandler.GetInstalledDependencies(targetPackage);
// Check that there are analyzers in the target package from which information can be extracted
// Create a mapping of packages to analyzers to avoid having to search for analyzers more than once
Dictionary <IPackage, IEnumerable <DiagnosticAnalyzer> > analyzersByPackage = new Dictionary <IPackage, IEnumerable <DiagnosticAnalyzer> >();
IEnumerable <DiagnosticAnalyzer> targetAnalyzers = GetAnalyzers(targetPackage, args.Language);
if (targetAnalyzers.Any())
{
analyzersByPackage.Add(targetPackage, targetAnalyzers);
}
else
{
logger.LogWarning(UIResources.APG_NoAnalyzersFound, targetPackage.Id);
if (!args.RecurseDependencies)
{
logger.LogWarning(UIResources.APG_NoAnalyzersInTargetSuggestRecurse);
return(false);
}
}
if (args.RecurseDependencies)
{
// Possible sub-case - target package has dependencies that contain analyzers
foreach (IPackage dependencyPackage in dependencyPackages)
{
IEnumerable <DiagnosticAnalyzer> dependencyAnalyzers = GetAnalyzers(dependencyPackage, args.Language);
if (dependencyAnalyzers.Any())
{
analyzersByPackage.Add(dependencyPackage, dependencyAnalyzers);
}
else
{
logger.LogWarning(UIResources.APG_NoAnalyzersFound, dependencyPackage.Id);
}
}
if (!analyzersByPackage.Any())
{
return(false);
}
}
// Check for packages that require the user to accept a license
IEnumerable <IPackage> licenseAcceptancePackages = GetPackagesRequiringLicenseAcceptance(targetPackage);
if (licenseAcceptancePackages.Any() && !args.AcceptLicenses)
{
// NB: This warns for all packages under the target that require license acceptance
// (even if they aren't related to the packages from which plugins were generated)
logger.LogError(UIResources.APG_NGPackageRequiresLicenseAcceptance, targetPackage.Id, targetPackage.Version.ToString());
ListPackagesRequiringLicenseAcceptance(licenseAcceptancePackages);
return(false);
}
List <string> generatedJarFiles = new List <string>();
// Initial run with the user-targeted package and arguments
if (analyzersByPackage.ContainsKey(targetPackage))
{
string generatedJarPath = GeneratePluginForPackage(args.OutputDirectory, args.Language, args.RuleFilePath, targetPackage, analyzersByPackage[targetPackage]);
if (generatedJarPath == null)
{
return(false);
}
generatedJarFiles.Add(generatedJarPath);
analyzersByPackage.Remove(targetPackage);
}
// Dependent package generation changes the arguments
if (args.RecurseDependencies)
{
logger.LogWarning(UIResources.APG_RecurseEnabled_RuleCustomizationNotEnabled);
foreach (IPackage currentPackage in analyzersByPackage.Keys)
{
// No way to specify the rules xml files for any but the user-targeted package at this time
string generatedJarPath = GeneratePluginForPackage(args.OutputDirectory, args.Language, null, currentPackage, analyzersByPackage[currentPackage]);
if (generatedJarPath == null)
{
return(false);
}
generatedJarFiles.Add(generatedJarPath);
}
}
LogAcceptedPackageLicenses(licenseAcceptancePackages);
foreach (string generatedJarFile in generatedJarFiles)
{
logger.LogInfo(UIResources.APG_PluginGenerated, generatedJarFile);
}
return(true);
}
[WorkItem(127)] // Do not store the db and server credentials in the config files: http://jira.sonarsource.com/browse/SONARMSBRU-127
public void AnalysisConfGen_AnalysisConfigDoesNotContainSensitiveData()
{
// Arrange
string analysisDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
TestLogger logger = new TestLogger();
ListPropertiesProvider cmdLineArgs = new ListPropertiesProvider();
// Public args - should be written to the config file
cmdLineArgs.AddProperty("sonar.host.url", "http://host");
cmdLineArgs.AddProperty("public.key", "public value");
// Sensitive values - should not be written to the config file
cmdLineArgs.AddProperty(SonarProperties.DbPassword, "secret db password");
cmdLineArgs.AddProperty(SonarProperties.DbUserName, "secret db user");
// Create a settings file with public and sensitive data
AnalysisProperties fileSettings = new AnalysisProperties();
fileSettings.Add(new Property()
{
Id = "file.public.key", Value = "file public value"
});
fileSettings.Add(new Property()
{
Id = SonarProperties.DbUserName, Value = "secret db user"
});
fileSettings.Add(new Property()
{
Id = SonarProperties.DbPassword, Value = "secret db password"
});
string fileSettingsPath = Path.Combine(analysisDir, "fileSettings.txt");
fileSettings.Save(fileSettingsPath);
FilePropertyProvider fileProvider = FilePropertyProvider.Load(fileSettingsPath);
ProcessedArgs args = new ProcessedArgs("key", "name", "1.0", false, cmdLineArgs, fileProvider);
IDictionary <string, string> serverProperties = new Dictionary <string, string>();
// Public server settings
serverProperties.Add("server.key.1", "server value 1");
// Sensitive server settings
serverProperties.Add(SonarProperties.SonarUserName, "secret user");
serverProperties.Add(SonarProperties.SonarPassword, "secret pwd");
TeamBuildSettings settings = TeamBuildSettings.CreateNonTeamBuildSettingsForTesting(analysisDir);
Directory.CreateDirectory(settings.SonarConfigDirectory); // config directory needs to exist
// Act
AnalysisConfig config = AnalysisConfigGenerator.GenerateFile(args, settings, serverProperties, logger);
// Assert
AssertConfigFileExists(config);
logger.AssertErrorsLogged(0);
logger.AssertWarningsLogged(0);
// Check the config
// "Public" arguments should be in the file
Assert.AreEqual("key", config.SonarProjectKey, "Unexpected project key");
Assert.AreEqual("name", config.SonarProjectName, "Unexpected project name");
Assert.AreEqual("1.0", config.SonarProjectVersion, "Unexpected project version");
AssertExpectedLocalSetting(SonarProperties.HostUrl, "http://host", config);
AssertExpectedServerSetting("server.key.1", "server value 1", config);
AssertFileDoesNotContainText(config.FileName, "file.public.key"); // file settings values should not be in the config
// SONARMSBRU-136: TODO - uncomment the following code:
AssertFileDoesNotContainText(config.FileName, "secret"); // sensitive data should not be in config
}
private static void AssertExpectedValue(string key, string expectedValue, ProcessedArgs args)
{
string actualValue;
bool found = args.TryGetSetting(key, out actualValue);
Assert.IsTrue(found, "Expected setting was not found. Key: {0}", key);
Assert.AreEqual(expectedValue, actualValue, "Setting does not have the expected value. Key: {0}", key);
}
[WorkItem(127)] // Do not store the db and server credentials in the config files: http://jira.sonarsource.com/browse/SONARMSBRU-127
public void AnalysisConfGen_AnalysisConfigDoesNotContainSensitiveData()
{
// Arrange
var analysisDir = TestUtils.CreateTestSpecificFolder(TestContext);
var logger = new TestLogger();
var cmdLineArgs = new ListPropertiesProvider();
// Public args - should be written to the config file
cmdLineArgs.AddProperty("sonar.host.url", "http://host");
cmdLineArgs.AddProperty("public.key", "public value");
cmdLineArgs.AddProperty("sonar.user.license.secured", "user input license");
cmdLineArgs.AddProperty("server.key.secured.xxx", "not really secure");
cmdLineArgs.AddProperty("sonar.value", "value.secured");
// Sensitive values - should not be written to the config file
cmdLineArgs.AddProperty(SonarProperties.DbPassword, "secret db password");
// Create a settings file with public and sensitive data
var fileSettings = new AnalysisProperties
{
new Property()
{
Id = "file.public.key", Value = "file public value"
},
new Property()
{
Id = SonarProperties.DbUserName, Value = "secret db user"
},
new Property()
{
Id = SonarProperties.DbPassword, Value = "secret db password"
}
};
var fileSettingsPath = Path.Combine(analysisDir, "fileSettings.txt");
fileSettings.Save(fileSettingsPath);
var fileProvider = FilePropertyProvider.Load(fileSettingsPath);
var args = new ProcessedArgs("key", "name", "1.0", null, false, cmdLineArgs, fileProvider, EmptyPropertyProvider.Instance);
IDictionary <string, string> serverProperties = new Dictionary <string, string>
{
// Public server settings
{ "server.key.1", "server value 1" },
// Sensitive server settings
{ SonarProperties.SonarUserName, "secret user" },
{ SonarProperties.SonarPassword, "secret pwd" },
{ "sonar.vbnet.license.secured", "secret license" },
{ "sonar.cpp.License.Secured", "secret license 2" }
};
var settings = TeamBuildSettings.CreateNonTeamBuildSettingsForTesting(analysisDir);
Directory.CreateDirectory(settings.SonarConfigDirectory); // config directory needs to exist
// Act
var config = AnalysisConfigGenerator.GenerateFile(args, settings, serverProperties, new List <AnalyzerSettings>(), logger);
// Assert
AssertConfigFileExists(config);
logger.AssertErrorsLogged(0);
logger.AssertWarningsLogged(0);
// Check the config
// "Public" arguments should be in the file
Assert.AreEqual("key", config.SonarProjectKey, "Unexpected project key");
Assert.AreEqual("name", config.SonarProjectName, "Unexpected project name");
Assert.AreEqual("1.0", config.SonarProjectVersion, "Unexpected project version");
AssertExpectedLocalSetting(SonarProperties.HostUrl, "http://host", config);
AssertExpectedLocalSetting("sonar.user.license.secured", "user input license", config); // we only filter out *.secured server settings
AssertExpectedLocalSetting("sonar.value", "value.secured", config);
AssertExpectedLocalSetting("server.key.secured.xxx", "not really secure", config);
AssertExpectedServerSetting("server.key.1", "server value 1", config);
AssertFileDoesNotContainText(config.FileName, "file.public.key"); // file settings values should not be in the config
AssertFileDoesNotContainText(config.FileName, "secret"); // sensitive data should not be in config
}
public void ProcArgs_Organization()
{
Assert.IsNull(args.Organization);
args = new ProcessedArgs("key", "branch", "ver", "organization", true, new ListPropertiesProvider(), new ListPropertiesProvider(), new ListPropertiesProvider());
Assert.AreEqual("organization", args.Organization);
}
private static void AssertExpectedInstallTargets(bool expected, ProcessedArgs actual)
{
Assert.AreEqual(expected, actual.InstallLoaderTargets);
}
public void ProcArgs_Organization()
{
this.args.Organization.Should().BeNull();
this.args = new ProcessedArgs("key", "branch", "ver", "organization", true, new ListPropertiesProvider(), new ListPropertiesProvider(), new ListPropertiesProvider(), logger);
this.args.Organization.Should().Be("organization");
}
private static void AssertExpectedValues(string key, string name, string version, ProcessedArgs actual)
{
Assert.AreEqual(key, actual.ProjectKey, "Unexpected project key");
Assert.AreEqual(name, actual.ProjectName, "Unexpected project name");
Assert.AreEqual(version, actual.ProjectVersion, "Unexpected project version");
}
private static void AssertArgumentsNotProcessed(ProcessedArgs actualArgs, TestLogger logger)
{
actualArgs.Should().BeNull("Not expecting the arguments to have been processed successfully");
logger.AssertErrorsLogged();
}
private static void AssertExpectedValues(string key, string name, string version, ProcessedArgs actual)
{
actual.ProjectKey.Should().Be(key, "Unexpected project key");
actual.ProjectName.Should().Be(name, "Unexpected project name");
actual.ProjectVersion.Should().Be(version, "Unexpected project version");
}
public void AnalysisConfGen_CommandLineAndProgrammaticProperties()
{
// Arrange
TestLogger logger = new TestLogger();
string analysisDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
TeamBuildSettings tbSettings = TeamBuildSettings.CreateNonTeamBuildSettingsForTesting(analysisDir);
Dictionary<string, string> emptyServerProperties = new Dictionary<string, string>();
AnalyzerSettings emptyAnalyzerSettings = new AnalyzerSettings();
Directory.CreateDirectory(tbSettings.SonarConfigDirectory); // config directory needs to exist
// Define a set of user properties
ListPropertiesProvider userProperties = new ListPropertiesProvider();
userProperties.AddProperty("sonar.host.url", "http://host"); // required
userProperties.AddProperty("user1", "user value 1");
userProperties.AddProperty("shared.key.1", "user value for shared.key.1");
ProcessedArgs cmdLineArgs = new ProcessedArgs("key", "name", "version", false, userProperties, EmptyPropertyProvider.Instance);
// Define a set of programmatic properties
AnalysisProperties programmaticProperties = new AnalysisProperties();
programmaticProperties.Add(new Property() { Id = "prog1", Value = "prog value 1" });
programmaticProperties.Add(new Property() { Id = "shared.key.1", Value = "prog value for shared.key.1" });
// Act
AnalysisConfig actualConfig = AnalysisConfigGenerator.GenerateFile(cmdLineArgs, tbSettings, emptyServerProperties, emptyAnalyzerSettings, programmaticProperties, logger);
// Assert
AssertConfigFileExists(actualConfig);
logger.AssertErrorsLogged(0);
logger.AssertWarningsLogged(0);
// Check that user properties take precedence over the programmatic ones
AssertExpectedLocalSetting("sonar.host.url", "http://host", actualConfig);
AssertExpectedLocalSetting("user1", "user value 1", actualConfig);
AssertExpectedLocalSetting("shared.key.1", "user value for shared.key.1", actualConfig);
AssertExpectedLocalSetting("prog1", "prog value 1", actualConfig);
}
public void AnalysisConfGen_FileProperties()
{
// File properties should not be copied to the file.
// Instead, a pointer to the file should be created.
// Arrange
string analysisDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
TestLogger logger = new TestLogger();
// The set of file properties to supply
AnalysisProperties fileProperties = new AnalysisProperties();
fileProperties.Add(new Property() { Id = SonarProperties.HostUrl, Value = "http://myserver" });
fileProperties.Add(new Property() { Id = "file.only", Value = "file value" });
string settingsFilePath = Path.Combine(analysisDir, "settings.txt");
fileProperties.Save(settingsFilePath);
FilePropertyProvider fileProvider = FilePropertyProvider.Load(settingsFilePath);
ProcessedArgs args = new ProcessedArgs("key", "name", "version", false, EmptyPropertyProvider.Instance, fileProvider);
TeamBuildSettings settings = TeamBuildSettings.CreateNonTeamBuildSettingsForTesting(analysisDir);
Directory.CreateDirectory(settings.SonarConfigDirectory); // config directory needs to exist
// Act
AnalysisConfig actualConfig = AnalysisConfigGenerator.GenerateFile(args, settings, new Dictionary<string, string>(), logger);
// Assert
AssertConfigFileExists(actualConfig);
logger.AssertErrorsLogged(0);
logger.AssertWarningsLogged(0);
string actualSettingsFilePath = actualConfig.GetSettingsFilePath();
Assert.AreEqual(settingsFilePath, actualSettingsFilePath, "Unexpected settings file path");
// Check the file setting value do not appear in the config file
AssertFileDoesNotContainText(actualConfig.FileName, "file.only");
Assert.AreEqual(settings.SonarRunnerWorkingDirectory, actualConfig.SonarRunnerWorkingDirectory);
}
private static void AssertExpectedInstallTargets(bool expected, ProcessedArgs actual)
{
actual.InstallLoaderTargets.Should().Be(expected);
}
public void Generate_LicenseAcceptanceRequired_NoAnalysersInTarget()
{
// If there are:
// Required licenses
// No analyzers in the targeted package, but analyzers in the dependencies
// We should fail due to the absence of analyzers if we are only generating a plugin for the targeted package
// We should fail with an error due to licenses if we are generating plugins for the targeted package and dependencies
// Arrange
string outputDir = TestUtils.CreateTestDirectory(TestContext, ".out");
string dummyContentFile = TestUtils.CreateTextFile("dummy.txt", outputDir, "non-analyzer content file");
RemoteRepoBuilder remoteRepoBuilder = new RemoteRepoBuilder(TestContext);
// Multi-level: parent and some but not all dependencies require license acceptance
// Parent has no analyzers, but dependencies do
IPackage child1 = CreatePackageWithAnalyzer(remoteRepoBuilder, "child1.requiredAccept.id", "2.1", License.Required);
IPackage child2 = CreatePackageWithAnalyzer(remoteRepoBuilder, "child2.id", "2.2", License.NotRequired);
remoteRepoBuilder.CreatePackage("non-analyzer.parent.requireAccept.id", "1.0", dummyContentFile, License.Required, child1, child2);
TestLogger logger = new TestLogger();
AnalyzerPluginGenerator apg = CreateTestSubjectWithFakeRemoteRepo(remoteRepoBuilder, logger);
// 1. a) Only target package. User does not accept, but no analyzers so no license prompt -> fails due to absence of analyzers
ProcessedArgs args = CreateArgs("non-analyzer.parent.requireAccept.id", "1.0", "cs", false /* accept licenses */,
false, outputDir);
bool result = apg.Generate(args);
result.Should().BeFalse("Expecting generator to fail");
logger.AssertSingleWarningExists(String.Format(UIResources.APG_NoAnalyzersFound, "non-analyzer.parent.requireAccept.id"));
logger.AssertSingleWarningExists(UIResources.APG_NoAnalyzersInTargetSuggestRecurse);
logger.AssertWarningsLogged(2);
logger.AssertErrorsLogged(0);
// 1. b) Target package and dependencies. User does not accept.
// No analyzers in the target package, but analyzers in the dependencies -> fails with error
logger.Reset();
args = CreateArgs("non-analyzer.parent.requireAccept.id", "1.0", "cs", false /* accept licenses */,
true /* generate plugins for dependencies */, outputDir);
result = apg.Generate(args);
result.Should().BeFalse("Generator should fail because license has not been accepted");
logger.AssertSingleWarningExists(String.Format(UIResources.APG_NoAnalyzersFound, "non-analyzer.parent.requireAccept.id"));
logger.AssertSingleWarningExists("non-analyzer.parent.requireAccept.id", "1.0"); // warning for each licensed package
logger.AssertSingleWarningExists(child1.Id, child1.Version.ToString());
logger.AssertWarningsLogged(3);
logger.AssertSingleErrorExists("non-analyzer.parent.requireAccept.id", "1.0"); // error listing the main package
logger.AssertErrorsLogged(1);
// 2. b) Target package and dependencies. User accepts.
// No analyzers in the target package, but analyzers in the dependencies -> succeeds with warnings
logger.Reset();
args = CreateArgs("non-analyzer.parent.requireAccept.id", "1.0", "cs", true /* accept licenses */,
true /* generate plugins for dependencies */, outputDir);
result = apg.Generate(args);
result.Should().BeTrue("Generator should succeed if licenses are accepted");
logger.AssertSingleWarningExists(String.Format(UIResources.APG_NoAnalyzersFound, "non-analyzer.parent.requireAccept.id"));
logger.AssertSingleWarningExists(UIResources.APG_NGAcceptedPackageLicenses); // warning that licenses have been accepted
logger.AssertSingleWarningExists("non-analyzer.parent.requireAccept.id", "1.0"); // warning for each licensed package
logger.AssertSingleWarningExists(child1.Id, child1.Version.ToString());
logger.AssertWarningsLogged(5);
logger.AssertErrorsLogged(0);
}
public ISonarQubeServer CreateSonarQubeServer(ProcessedArgs args)
{
args.Should().NotBeNull();
return(this.server);
}
