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); }
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 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); }