public void AnalysisConfig_Serialization_SaveAndReload() { // 0. Setup string testFolder = TestUtils.CreateTestSpecificFolder(this.TestContext); AnalysisConfig originalConfig = new AnalysisConfig(); originalConfig.SonarConfigDir = @"c:\config"; originalConfig.SonarOutputDir = @"c:\output"; originalConfig.SonarProjectKey = @"key.1.2"; originalConfig.SonarProjectName = @"My project"; originalConfig.SonarProjectVersion = @"1.0"; originalConfig.LocalSettings = new AnalysisProperties(); originalConfig.LocalSettings.Add(new Property() { Id = "local.key", Value = "local.value" }); originalConfig.ServerSettings = new AnalysisProperties(); originalConfig.ServerSettings.Add(new Property() { Id = "server.key", Value = "server.value" }); originalConfig.AnalyzerSettings = new AnalyzerSettings(); originalConfig.AnalyzerSettings.RuleSetFilePath = "ruleset path"; originalConfig.AnalyzerSettings.AdditionalFilePaths = new List<string>(); originalConfig.AnalyzerSettings.AdditionalFilePaths.Add("additional path1"); originalConfig.AnalyzerSettings.AdditionalFilePaths.Add("additional path2"); originalConfig.AnalyzerSettings.AnalyzerAssemblyPaths = new List<string>(); originalConfig.AnalyzerSettings.AnalyzerAssemblyPaths.Add("analyzer path1"); originalConfig.AnalyzerSettings.AnalyzerAssemblyPaths.Add("analyzer path2"); string fileName = Path.Combine(testFolder, "config1.xml"); SaveAndReloadConfig(originalConfig, fileName); }
public void ConfigExt_GetAnalysisSettings_ServerOnly() { // Check that local settings are only retrieved by GetAnalysisSettings // if includeServerSettings is true // 0. Setup AnalysisConfig config = new AnalysisConfig(); config.ServerSettings = new AnalysisProperties(); config.ServerSettings.Add(new Property() { Id = "server.1", Value = "server.value.1" }); config.ServerSettings.Add(new Property() { Id = "server.2", Value = "server.value.2" }); // 1. Local only IAnalysisPropertyProvider localProperties = config.GetAnalysisSettings(false); localProperties.AssertExpectedPropertyCount(0); localProperties.AssertPropertyDoesNotExist("server.1"); localProperties.AssertPropertyDoesNotExist("server.2"); // 2. Local and server IAnalysisPropertyProvider allProperties = config.GetAnalysisSettings(true); allProperties.AssertExpectedPropertyCount(2); allProperties.AssertExpectedPropertyValue("server.1", "server.value.1"); allProperties.AssertExpectedPropertyValue("server.2", "server.value.2"); }
public void AnalysisConfig_Serialization_SaveAndReload_EmptySettings() { // Arrange string testFolder = TestUtils.CreateTestSpecificFolder(this.TestContext); AnalysisConfig originalConfig = new AnalysisConfig(); string fileName = Path.Combine(testFolder, "empty_config.xml"); // Act and assert SaveAndReloadConfig(originalConfig, fileName); }
public void AnalysisConfig_Serialization_InvalidFileName() { // 0. Setup AnalysisConfig config = new AnalysisConfig(); // 1a. Missing file name - save AssertException.Expects<ArgumentNullException>(() => config.Save(null)); AssertException.Expects<ArgumentNullException>(() => config.Save(string.Empty)); AssertException.Expects<ArgumentNullException>(() => config.Save("\r\t ")); // 1b. Missing file name - load AssertException.Expects<ArgumentNullException>(() => ProjectInfo.Load(null)); AssertException.Expects<ArgumentNullException>(() => ProjectInfo.Load(string.Empty)); AssertException.Expects<ArgumentNullException>(() => ProjectInfo.Load("\r\t ")); }
public void ConfigExt_GetAndSet() { // 0. Setup AnalysisConfig config = new AnalysisConfig(); string result; // 1. Get missing setting -> default returned result = config.GetConfigValue("missing", "123"); Assert.AreEqual("123", result, "Unexpected config value returned"); // 2. Set and get a new setting config.SetConfigValue("id1", "value1"); Assert.AreEqual("value1", config.GetConfigValue("id1", "XXX"), "Unexpected config value returned"); // 3. Update an existing setting config.SetConfigValue("id1", "value2"); Assert.AreEqual("value2", config.GetConfigValue("id1", "XXX"), "Unexpected config value returned"); }
public void AnalysisConfig_Serialization_AdditionalConfig() { // 0. Setup string testFolder = TestUtils.CreateTestSpecificFolder(this.TestContext); AnalysisConfig originalConfig = new AnalysisConfig(); // 1. Null list SaveAndReloadConfig(originalConfig, Path.Combine(testFolder, "AnalysisConfig_NullAdditionalSettings.xml")); // 2. Empty list originalConfig.AdditionalConfig = new List<ConfigSetting>(); SaveAndReloadConfig(originalConfig, Path.Combine(testFolder, "AnalysisConfig_EmptyAdditionalSettings.xml")); // 3. Non-empty list originalConfig.AdditionalConfig.Add(new ConfigSetting() { Id = string.Empty, Value = string.Empty }); // empty item originalConfig.AdditionalConfig.Add(new ConfigSetting() { Id = "Id1", Value = "http://www.foo.xxx" }); originalConfig.AdditionalConfig.Add(new ConfigSetting() { Id = "Id2", Value = "value 2" }); SaveAndReloadConfig(originalConfig, Path.Combine(testFolder, "AnalysisConfig_NonEmptyList.xml")); }
public void ConfigExt_GetAnalysisSettings_LocalOnly() { // Check that local settings are always retrieved by GetAnalysisSettings // 0. Setup AnalysisConfig config = new AnalysisConfig(); config.LocalSettings = new AnalysisProperties(); config.LocalSettings.Add(new Property() { Id = "local.1", Value = "local.value.1" }); config.LocalSettings.Add(new Property() { Id = "local.2", Value = "local.value.2" }); // 1. Local only IAnalysisPropertyProvider localProperties = config.GetAnalysisSettings(false); localProperties.AssertExpectedPropertyCount(2); localProperties.AssertExpectedPropertyValue("local.1", "local.value.1"); localProperties.AssertExpectedPropertyValue("local.2", "local.value.2"); // 2. Local and server IAnalysisPropertyProvider allProperties = config.GetAnalysisSettings(true); allProperties.AssertExpectedPropertyCount(2); allProperties.AssertExpectedPropertyValue("local.1", "local.value.1"); allProperties.AssertExpectedPropertyValue("local.2", "local.value.2"); }
public void AnalysisConfig_Serialization_SaveAndReload() { // 0. Setup string testFolder = TestUtils.CreateTestSpecificFolder(this.TestContext); Guid projectGuid = Guid.NewGuid(); AnalysisConfig originalConfig = new AnalysisConfig(); originalConfig.SonarConfigDir = @"c:\config"; originalConfig.SonarOutputDir = @"c:\output"; originalConfig.SonarProjectKey = @"key.1.2"; originalConfig.SonarProjectName = @"My project"; originalConfig.SonarProjectVersion = @"1.0"; originalConfig.LocalSettings = new AnalysisProperties(); originalConfig.LocalSettings.Add(new Property() { Id = "local.key", Value = "local.value" }); originalConfig.ServerSettings = new AnalysisProperties(); originalConfig.ServerSettings.Add(new Property() { Id = "server.key", Value = "server.value" }); string fileName = Path.Combine(testFolder, "config1.xml"); SaveAndReloadConfig(originalConfig, fileName); }
public void FileGen_AdditionalProperties() { // 0. Arrange string analysisRootDir = TestUtils.CreateTestSpecificFolder(this.TestContext); TestLogger logger = new TestLogger(); CreateProjectWithFiles("project1", analysisRootDir); AnalysisConfig config = CreateValidConfig(analysisRootDir); // Add additional properties config.LocalSettings = new AnalysisProperties(); config.LocalSettings.Add(new Property() { Id = "key1", Value = "value1" }); config.LocalSettings.Add(new Property() { Id = "key.2", Value = "value two" }); config.LocalSettings.Add(new Property() { Id = "key.3", Value = " " }); // Sensitive data should not be written config.LocalSettings.Add(new Property() { Id = SonarProperties.DbPassword, Value = "secret db pwd" }); config.LocalSettings.Add(new Property() { Id = SonarProperties.SonarPassword, Value = "secret pwd" }); // Server properties should not be added config.ServerSettings = new AnalysisProperties(); config.ServerSettings.Add(new Property() { Id = "server.key", Value = "should not be added" }); // Act ProjectInfoAnalysisResult result = PropertiesFileGenerator.GenerateFile(config, logger); // Assert AssertExpectedProjectCount(1, result); // One valid project info file -> file created AssertPropertiesFilesCreated(result, logger); SQPropertiesFileReader provider = new SQPropertiesFileReader(result.FullPropertiesFilePath); provider.AssertSettingExists("key1", "value1"); provider.AssertSettingExists("key.2", "value two"); provider.AssertSettingExists("key.3", " "); provider.AssertSettingDoesNotExist("server.key"); provider.AssertSettingDoesNotExist(SonarProperties.DbPassword); provider.AssertSettingDoesNotExist(SonarProperties.SonarPassword); }
public void ConfigExt_GetAnalysisSettings_FileSettings() { // Check that file settings are always retrieved by GetAnalysisSettings // and that the file name config property is set and retrieved correctly // 0. Setup string testDir = TestUtils.CreateTestSpecificFolder(this.TestContext); AnalysisConfig config = new AnalysisConfig(); // File settings AnalysisProperties fileSettings = new AnalysisProperties(); fileSettings.Add(new Property() { Id = "file.1", Value = "file.value.1" }); fileSettings.Add(new Property() { Id = "file.2", Value = "file.value.2" }); string settingsFilePath = Path.Combine(testDir, "settings.txt"); fileSettings.Save(settingsFilePath); // 1. Get path when not set -> null Assert.IsNull(config.GetSettingsFilePath(), "Expecting the settings file path to be null"); // 2. Set and get config.SetSettingsFilePath(settingsFilePath); Assert.AreEqual(settingsFilePath, config.GetSettingsFilePath(), "Unexpected settings file path value returned"); // 3. Check file properties are retrieved IAnalysisPropertyProvider provider = config.GetAnalysisSettings(false); provider.AssertExpectedPropertyCount(2); provider.AssertExpectedPropertyValue("file.1", "file.value.1"); provider.AssertExpectedPropertyValue("file.2", "file.value.2"); }
public PropertiesWriter(AnalysisConfig config) { this.config = config ?? throw new ArgumentNullException("config"); sb = new StringBuilder(); projects = new List <ProjectInfo>(); }
public void ConfigExt_GetAnalysisSettings_NoSettings() { // 0. Setup AnalysisConfig config = new AnalysisConfig(); // 1. No server settings IAnalysisPropertyProvider provider = config.GetAnalysisSettings(false); Assert.IsNotNull(provider, "Returned provider should not be null"); provider.AssertExpectedPropertyCount(0); // 2. With server settings provider = config.GetAnalysisSettings(true); Assert.IsNotNull(provider, "Returned provider should not be null"); provider.AssertExpectedPropertyCount(0); }
public PropertiesFileGenerator(AnalysisConfig analysisConfig, ILogger logger) : this(analysisConfig, logger, new RoslynV1SarifFixer(logger), new RuntimeInformationWrapper()) { }
/// <summary> /// Returns all of the command line arguments to pass to sonar-scanner /// </summary> private static IEnumerable <string> GetAllCmdLineArgs(string projectSettingsFilePath, IEnumerable <string> userCmdLineArguments, AnalysisConfig config, ILogger logger) { // We don't know what all of the valid command line arguments are so we'll // just pass them on for the sonar-scanner to validate. var args = new List <string>(userCmdLineArguments); // Add any sensitive arguments supplied in the config should be passed on the command line args.AddRange(GetSensitiveFileSettings(config, userCmdLineArguments)); // Add the project settings file and the standard options. // Experimentation suggests that the sonar-scanner won't error if duplicate arguments // are supplied - it will just use the last argument. // So we'll set our additional properties last to make sure they take precedence. args.Add(string.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}{1}={2}", CmdLineArgPrefix, ProjectSettingsFileArgName, projectSettingsFilePath)); // Let the scanner cli know it has been ran from this MSBuild Scanner. (allows to tweak the behavior) // See https://jira.sonarsource.com/browse/SQSCANNER-65 args.Add("--from=ScannerMSBuild/" + Utilities.ScannerVersion); // For debug mode, we need to pass the debug option to the scanner cli in order to see correctly stack traces. // Note that in addition to this change, the sonar.verbose=true was removed from the config file. // See: https://github.com/SonarSource/sonar-scanner-msbuild/issues/543 if (logger.Verbosity == LoggerVerbosity.Debug) { args.Add("--debug"); } return(args); }
public /* for test */ static ProjectInfoAnalysisResult GenerateFile(AnalysisConfig config, ILogger logger, IRoslynV1SarifFixer fixer) { if (config == null) { throw new ArgumentNullException("config"); } if (logger == null) { throw new ArgumentNullException("logger"); } string fileName = Path.Combine(config.SonarOutputDir, ProjectPropertiesFileName); logger.LogDebug(Resources.MSG_GeneratingProjectProperties, fileName); IEnumerable <ProjectInfo> projects = ProjectLoader.LoadFrom(config.SonarOutputDir).ToArray(); if (projects == null || !projects.Any()) { logger.LogError(Resources.ERR_NoProjectInfoFilesFound); return(new ProjectInfoAnalysisResult()); } TryFixSarifReports(logger, projects, fixer); string rootProjectBaseDir = ComputeRootProjectBaseDir(config, projects); PropertiesWriter writer = new PropertiesWriter(config); AnalysisProperties properties = GetAnalysisProperties(config); var globalSourceEncoding = GetSourceEncoding(properties, new EncodingProvider()); ProjectInfoAnalysisResult result = ProcessProjectInfoFiles(projects, writer, logger, rootProjectBaseDir, globalSourceEncoding); writer.WriteSonarProjectInfo(rootProjectBaseDir, result.SharedFiles); IEnumerable <ProjectInfo> validProjects = result.GetProjectsByStatus(ProjectInfoValidity.Valid); if (validProjects.Any() || result.SharedFiles.Any()) { // Handle global settings properties = GetAnalysisPropertiesToWrite(properties, logger); writer.WriteGlobalSettings(properties); string contents = writer.Flush(); result.FullPropertiesFilePath = fileName; File.WriteAllText(result.FullPropertiesFilePath, contents, Encoding.ASCII); } else { // if the user tries to build multiple configurations at once there will be duplicate projects if (result.GetProjectsByStatus(ProjectInfoValidity.DuplicateGuid).Any()) { logger.LogError(Resources.ERR_NoValidButDuplicateProjects); } else { logger.LogError(Resources.ERR_NoValidProjectInfoFiles); } } return(result); }
public BinaryToXmlCoverageReportConverter(ILogger logger, AnalysisConfig config) : this(new VisualStudioSetupConfigurationFactory(), logger, config) { }
protected abstract bool TryGetBinaryReportFile(AnalysisConfig config, ITeamBuildSettings settings, ILogger logger, out string binaryFilePath);
private static void AssertExpectedServerSetting(string key, string expectedValue, AnalysisConfig actualConfig) { var found = Property.TryGetProperty(key, actualConfig.ServerSettings, out Property actualProperty); Assert.IsTrue(found, "Failed to find the expected server setting: {0}", key); Assert.AreEqual(expectedValue, actualProperty.Value, "Unexpected property value. Key: {0}", key); }
public static AnalysisConfig GenerateFile(ProcessedArgs args, TeamBuildSettings settings, IDictionary <string, string> serverProperties, ILogger logger) { if (args == null) { throw new ArgumentNullException("args"); } if (settings == null) { throw new ArgumentNullException("settings"); } if (serverProperties == null) { throw new ArgumentNullException("serverProperties"); } if (logger == null) { throw new ArgumentNullException("logger"); } AnalysisConfig config = new AnalysisConfig(); config.SonarProjectKey = args.ProjectKey; config.SonarProjectName = args.ProjectName; config.SonarProjectVersion = args.ProjectVersion; config.SonarQubeHostUrl = args.GetSetting(SonarProperties.HostUrl); config.SetBuildUri(settings.BuildUri); config.SetTfsUri(settings.TfsUri); config.SonarConfigDir = settings.SonarConfigDirectory; config.SonarOutputDir = settings.SonarOutputDirectory; config.SonarBinDir = settings.SonarBinDirectory; config.SonarRunnerWorkingDirectory = settings.SonarRunnerWorkingDirectory; // Add the server properties to the config config.ServerSettings = new AnalysisProperties(); foreach (var property in serverProperties) { if (!IsSecuredServerProperty(property.Key)) { AddSetting(config.ServerSettings, property.Key, property.Value); } } // Add command line arguments config.LocalSettings = new AnalysisProperties(); foreach (var property in args.LocalProperties.GetAllProperties()) { AddSetting(config.LocalSettings, property.Id, property.Value); } // Set the pointer to the properties file if (args.PropertiesFileName != null) { config.SetSettingsFilePath(args.PropertiesFileName); } config.Save(settings.AnalysisConfigFilePath); return(config); }
protected abstract bool TryGetTrxFiles(AnalysisConfig config, ITeamBuildSettings settings, out IEnumerable <string> trxFilePaths);
protected abstract bool TryGetVsCoverageFiles(AnalysisConfig config, ITeamBuildSettings settings, out IEnumerable <string> binaryFilePaths);
protected override bool TryGetBinaryReportFile(AnalysisConfig config, TeamBuildSettings settings, ILogger logger, out string binaryFilePath) { binaryFilePath = TrxFileReader.LocateCodeCoverageFile(settings.BuildDirectory, logger); return(true); // there aren't currently any conditions under which we'd want to stop processing }
public void Roslyn_Settings_ValidSetup() { // Arrange // Set the config directory so the targets know where to look for the analysis config file var confDir = TestUtils.CreateTestSpecificFolder(TestContext, "config"); // Create a valid config file containing analyzer settings var expectedAssemblies = new string[] { "c:\\data\\config.analyzer1.dll", "c:\\config2.dll" }; var analyzerAdditionalFiles = new string[] { "c:\\config.1.txt", "c:\\config.2.txt" }; var config = new AnalysisConfig(); var analyzerSettings = new AnalyzerSettings { Language = "cs", RuleSetFilePath = "d:\\my.ruleset", AnalyzerAssemblyPaths = expectedAssemblies.ToList(), AdditionalFilePaths = analyzerAdditionalFiles.ToList() }; config.AnalyzersSettings = new List <AnalyzerSettings> { analyzerSettings }; var configFilePath = Path.Combine(confDir, FileConstants.ConfigFileName); config.Save(configFilePath); // Create the project var properties = new WellKnownProjectProperties { SonarQubeConfigPath = confDir, ResolvedCodeAnalysisRuleset = "c:\\should.be.overridden.ruleset" }; var projectRoot = CreateValidProjectSetup(properties); projectRoot.AddItem(TargetProperties.AnalyzerItemType, "should.be.removed.analyzer1.dll"); projectRoot.AddItem(TargetProperties.AnalyzerItemType, "c:\\should.be.removed.analyzer2.dll"); var notRemovedAdditionalFiles = new string[] { "should.not.be.removed.additional1.txt", "should.not.be.removed.additional2.txt" }; foreach (var notRemovedAdditionalFile in notRemovedAdditionalFiles) { projectRoot.AddItem(TargetProperties.AdditionalFilesItemType, notRemovedAdditionalFile); } projectRoot.Save(); // re-save the modified project // Act var result = BuildRunner.BuildTargets(TestContext, projectRoot.FullPath, TargetConstants.OverrideRoslynAnalysisTarget); var projectSpecificConfFilePath = result.GetCapturedPropertyValue(TargetProperties.ProjectConfFilePath); var expectedRoslynAdditionalFiles = new string[] { projectSpecificConfFilePath } .Concat(analyzerAdditionalFiles) .Concat(notRemovedAdditionalFiles) .ToArray(); // Assert result.AssertTargetExecuted(TargetConstants.OverrideRoslynAnalysisTarget); result.AssertTargetExecuted(TargetConstants.SetRoslynAnalysisPropertiesTarget); result.BuildSucceeded.Should().BeTrue(); // Check the error log and ruleset properties are set AssertErrorLogIsSetBySonarQubeTargets(result); AssertExpectedResolvedRuleset(result, "d:\\my.ruleset"); AssertExpectedItemValuesExists(result, TargetProperties.AdditionalFilesItemType, expectedRoslynAdditionalFiles); AssertExpectedItemValuesExists(result, TargetProperties.AnalyzerItemType, expectedAssemblies); AssertWarningsAreNotTreatedAsErrorsNorIgnored(result); }
public bool Initialise(AnalysisConfig context, ITeamBuildSettings settings, ILogger logger) { Assert.IsFalse(this.initalisedCalled, "Expecting Initialise to be called only once"); this.initalisedCalled = true; return(InitialiseValueToReturn); }
/// <summary> /// Returns all of the command line arguments to pass to sonar-scanner /// </summary> private static IEnumerable <string> GetAllCmdLineArgs(string projectSettingsFilePath, IEnumerable <string> userCmdLineArguments, AnalysisConfig config) { // We don't know what all of the valid command line arguments are so we'll // just pass them on for the sonar-scanner to validate. List <string> args = new List <string>(userCmdLineArguments); // Add any sensitive arguments supplied in the config should be passed on the command line args.AddRange(GetSensitiveFileSettings(config, userCmdLineArguments)); // Add the project settings file and the standard options. // Experimentation suggests that the sonar-scanner won't error if duplicate arguments // are supplied - it will just use the last argument. // So we'll set our additional properties last to make sure they take precedence. args.Add(string.Format(System.Globalization.CultureInfo.InvariantCulture, "{0}{1}={2}", CmdLineArgPrefix, ProjectSettingsFileArgName, projectSettingsFilePath)); return(args); }
[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.CreateNonTeamBuildSettings(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 // SONARMSBRU-136: TODO - delete the following code: // v1.0.1 back-compat: check sensitive data is written to the config file AssertExpectedLocalSetting(SonarProperties.DbPassword, "secret db password", config); AssertExpectedLocalSetting(SonarProperties.DbUserName, "secret db user", config); AssertExpectedServerSetting(SonarProperties.SonarUserName, "secret user", config); AssertExpectedServerSetting(SonarProperties.SonarPassword, "secret pwd", config); }
/// <summary> /// Locates the ProjectInfo.xml files and uses the information in them to generate /// a sonar-scanner properties file /// </summary> /// <returns>Information about each of the project info files that was processed, together with /// the full path to generated file. /// Note: the path to the generated file will be null if the file could not be generated.</returns> public static ProjectInfoAnalysisResult GenerateFile(AnalysisConfig config, ILogger logger) { return(GenerateFile(config, logger, new RoslynV1SarifFixer())); }
public void AnalysisConfig_ExpectedXmlFormat() { // Arrange string xml = @"<?xml version=""1.0"" encoding=""utf-8""?> <AnalysisConfig xmlns:xsi=""http://www.w3.org/2001/XMLSchema-instance"" xmlns:xsd=""http://www.w3.org/2001/XMLSchema"" xmlns=""http://www.sonarsource.com/msbuild/integration/2015/1""> <SonarConfigDir>c:\config</SonarConfigDir> <SonarOutputDir>c:\output</SonarOutputDir> <SonarProjectKey>key.1.2</SonarProjectKey> <SonarProjectVersion>1.0</SonarProjectVersion> <SonarProjectName>My project</SonarProjectName> <ServerSettings> <Property Name=""server.key"">server.value</Property> </ServerSettings> <!-- Unexpected additional elements should be silently ignored --> <UnexpectedElement1 /> <LocalSettings> <Property Name=""local.key"">local.value</Property> </LocalSettings> <AnalyzerSettings> <RuleSetFilePath>d:\ruleset path.ruleset</RuleSetFilePath> <AnalyzerAssemblyPaths> <Path>c:\analyzer1.dll</Path> </AnalyzerAssemblyPaths> <AdditionalFilePaths> <MoreUnexpectedData><Foo /></MoreUnexpectedData> <Path>c:\additional1.txt</Path> </AdditionalFilePaths> </AnalyzerSettings> </AnalysisConfig>"; string testDir = TestUtils.CreateTestSpecificFolder(this.TestContext); string fullPath = TestUtils.CreateTextFile(testDir, "input.txt", xml); // Act AnalysisConfig actual = AnalysisConfig.Load(fullPath); // Assert AnalysisConfig expected = new AnalysisConfig(); expected.SonarConfigDir = "c:\\config"; expected.SonarOutputDir = "c:\\output"; expected.SonarProjectKey = "key.1.2"; expected.SonarProjectVersion = "1.0"; expected.SonarProjectName = "My project"; expected.ServerSettings = new AnalysisProperties(); expected.ServerSettings.Add(new Property() { Id = "server.key", Value = "server.value" }); expected.LocalSettings = new AnalysisProperties(); expected.LocalSettings.Add(new Property() { Id = "local.key", Value = "local.value" }); expected.AnalyzerSettings = new AnalyzerSettings(); expected.AnalyzerSettings.RuleSetFilePath = "d:\\ruleset path.ruleset"; expected.AnalyzerSettings.AdditionalFilePaths = new List<string>(); expected.AnalyzerSettings.AdditionalFilePaths.Add("c:\\additional1.txt"); expected.AnalyzerSettings.AnalyzerAssemblyPaths = new List<string>(); expected.AnalyzerSettings.AnalyzerAssemblyPaths.Add("c:\\analyzer1.dll"); AssertExpectedValues(expected, actual); }
public void ConfigExt_GetAnalysisSettings_Precedence() { // Expected precedence: local -> file -> server // 0. Setup string testDir = TestUtils.CreateTestSpecificFolder(this.TestContext); AnalysisConfig config = new AnalysisConfig(); // File settings AnalysisProperties fileSettings = new AnalysisProperties(); fileSettings.Add(new Property() { Id = "file.1", Value = "file.value.1" }); fileSettings.Add(new Property() { Id = "shared.property", Value = "shared value from file - should never be returned" }); fileSettings.Add(new Property() { Id = "shared.property2", Value = "shared value 2 from file" }); string settingsFilePath = Path.Combine(testDir, "settings.txt"); fileSettings.Save(settingsFilePath); config.SetSettingsFilePath(settingsFilePath); // Local settings config.LocalSettings = new AnalysisProperties(); config.LocalSettings.Add(new Property() { Id = "local.1", Value = "local.value.1" }); config.LocalSettings.Add(new Property() { Id = "local.2", Value = "local.value.2" }); config.LocalSettings.Add(new Property() { Id = "shared.property", Value = "shared value from local" }); // Server settings config.ServerSettings = new AnalysisProperties(); config.ServerSettings.Add(new Property() { Id = "server.1", Value = "server.value.1" }); config.ServerSettings.Add(new Property() { Id = "server.2", Value = "server.value.2" }); config.ServerSettings.Add(new Property() { Id = "shared.property", Value = "shared value from server - should never be returned" }); config.ServerSettings.Add(new Property() { Id = "shared.property2", Value = "shared value 2 from server - should never be returned" }); // 1. Precedence - local should win over file IAnalysisPropertyProvider provider = config.GetAnalysisSettings(false); provider.AssertExpectedPropertyCount(5); provider.AssertExpectedPropertyValue("local.1", "local.value.1"); provider.AssertExpectedPropertyValue("local.2", "local.value.2"); provider.AssertExpectedPropertyValue("file.1", "file.value.1"); provider.AssertExpectedPropertyValue("shared.property", "shared value from local"); provider.AssertExpectedPropertyValue("shared.property2", "shared value 2 from file"); provider.AssertPropertyDoesNotExist("server.1"); provider.AssertPropertyDoesNotExist("server.2"); // 2. Server and non-server provider = config.GetAnalysisSettings(true); provider.AssertExpectedPropertyCount(7); provider.AssertExpectedPropertyValue("local.1", "local.value.1"); provider.AssertExpectedPropertyValue("local.2", "local.value.2"); provider.AssertExpectedPropertyValue("file.1", "file.value.1"); provider.AssertExpectedPropertyValue("shared.property", "shared value from local"); provider.AssertExpectedPropertyValue("shared.property2", "shared value 2 from file"); provider.AssertExpectedPropertyValue("server.1", "server.value.1"); provider.AssertExpectedPropertyValue("server.2", "server.value.2"); }
private static void AssertExpectedValues(AnalysisConfig expected, AnalysisConfig actual) { Assert.AreEqual(expected.SonarProjectKey, actual.SonarProjectKey, "Unexpected project key"); Assert.AreEqual(expected.SonarProjectName, actual.SonarProjectName, "Unexpected project name"); Assert.AreEqual(expected.SonarProjectVersion, actual.SonarProjectVersion, "Unexpected project version"); Assert.AreEqual(expected.SonarConfigDir, actual.SonarConfigDir, "Unexpected config directory"); Assert.AreEqual(expected.SonarOutputDir, actual.SonarOutputDir, "Unexpected output directory"); CompareAdditionalSettings(expected, actual); CompareAnalyzerSettings(expected.AnalyzerSettings, actual.AnalyzerSettings); }
/// <summary> /// Combines the various configuration options into the AnalysisConfig file /// used by the build and post-processor. Saves the file and returns the config instance. /// </summary> /// <param name="localSettings">Processed local settings, including command line arguments supplied the user</param> /// <param name="buildSettings">Build environment settings</param> /// <param name="serverProperties">Analysis properties downloaded from the SonarQube server</param> /// <param name="analyzerSettings">Specifies the Roslyn analyzers to use. Can be empty</param> public static AnalysisConfig GenerateFile(ProcessedArgs localSettings, TeamBuildSettings buildSettings, IDictionary <string, string> serverProperties, List <AnalyzerSettings> analyzersSettings, ISonarQubeServer sonarQubeServer, ILogger logger) { if (localSettings == null) { throw new ArgumentNullException(nameof(localSettings)); } if (buildSettings == null) { throw new ArgumentNullException(nameof(buildSettings)); } if (serverProperties == null) { throw new ArgumentNullException(nameof(serverProperties)); } if (sonarQubeServer == null) { throw new ArgumentNullException(nameof(sonarQubeServer)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } var config = new AnalysisConfig { SonarProjectKey = localSettings.ProjectKey, SonarProjectName = localSettings.ProjectName, SonarProjectVersion = localSettings.ProjectVersion, SonarQubeHostUrl = localSettings.SonarQubeUrl, HasBeginStepCommandLineCredentials = localSettings.CmdLineProperties.HasProperty(SonarProperties.SonarUserName), SonarQubeVersion = sonarQubeServer.GetServerVersion().Result.ToString() }; config.SetBuildUri(buildSettings.BuildUri); config.SetTfsUri(buildSettings.TfsUri); config.SetVsCoverageConverterToolPath(buildSettings.CoverageToolUserSuppliedPath); config.SonarConfigDir = buildSettings.SonarConfigDirectory; config.SonarOutputDir = buildSettings.SonarOutputDirectory; config.SonarBinDir = buildSettings.SonarBinDirectory; config.SonarScannerWorkingDirectory = buildSettings.SonarScannerWorkingDirectory; config.SourcesDirectory = buildSettings.SourcesDirectory; // Add the server properties to the config config.ServerSettings = new AnalysisProperties(); foreach (var property in serverProperties) { if (!Utilities.IsSecuredServerProperty(property.Key)) { AddSetting(config.ServerSettings, property.Key, property.Value); } } config.LocalSettings = new AnalysisProperties(); // From the local settings, we only write the ones coming from the cmd line foreach (var property in localSettings.CmdLineProperties.GetAllProperties()) { AddSetting(config.LocalSettings, property.Id, property.Value); } if (!string.IsNullOrEmpty(localSettings.Organization)) { AddSetting(config.LocalSettings, SonarProperties.Organization, localSettings.Organization); } // Set the pointer to the properties file if (localSettings.PropertiesFileName != null) { config.SetSettingsFilePath(localSettings.PropertiesFileName); } config.AnalyzersSettings = analyzersSettings ?? throw new ArgumentNullException(nameof(analyzersSettings)); config.Save(buildSettings.AnalysisConfigFilePath); return(config); }
private static void AssertExpectedLocalSetting(string key, string expectedValue, AnalysisConfig acutalConfig) { Property property; bool found = Property.TryGetProperty(key, acutalConfig.LocalSettings, out property); Assert.IsTrue(found, "Expected local property was not found. Key: {0}", key); Assert.AreEqual(expectedValue, property.Value, "Unexpected local value. Key: {0}", key); }
private static bool InternalExecute(AnalysisConfig config, ILogger logger, IEnumerable <string> userCmdLineArguments, String fullPropertiesFilePath) { var exeFileName = FindProcessorExe(); return(ExecuteProcessorRunner(config, logger, exeFileName, userCmdLineArguments, fullPropertiesFilePath, new ProcessRunner(logger))); }
private string CreateProjectFile(AnalysisConfig analysisConfig, string testSpecificProjectXml, string sonarQubeOutputPath) { var projectDirectory = TestUtils.CreateTestSpecificFolder(TestContext); if (analysisConfig != null) { var configFilePath = Path.Combine(projectDirectory, FileConstants.ConfigFileName); analysisConfig.Save(configFilePath); } var sqTargetFile = TestUtils.EnsureAnalysisTargetsExists(TestContext); File.Exists(sqTargetFile).Should().BeTrue("Test error: the SonarQube analysis targets file could not be found. Full path: {0}", sqTargetFile); TestContext.AddResultFile(sqTargetFile); var template = @"<?xml version='1.0' encoding='utf-8'?> <Project ToolsVersion='Current' xmlns='http://schemas.microsoft.com/developer/msbuild/2003'> <!-- Boilerplate --> <!-- All of these boilerplate properties can be overridden by setting the value again in the test-specific XML snippet --> <PropertyGroup> <ImportByWildcardBeforeMicrosoftCommonTargets>false</ImportByWildcardBeforeMicrosoftCommonTargets> <ImportByWildcardAfterMicrosoftCommonTargets>false</ImportByWildcardAfterMicrosoftCommonTargets> <ImportUserLocationsByWildcardBeforeMicrosoftCommonTargets>false</ImportUserLocationsByWildcardBeforeMicrosoftCommonTargets> <ImportUserLocationsByWildcardAfterMicrosoftCommonTargets>false</ImportUserLocationsByWildcardAfterMicrosoftCommonTargets> <OutputPath>bin\</OutputPath> <OutputType>library</OutputType> <ProjectGuid>ffdb93c0-2880-44c7-89a6-bbd4ddab034a</ProjectGuid> <Language>C#</Language> </PropertyGroup> <PropertyGroup> <!-- Standard values that need to be set for each/most tests --> <SonarQubeBuildTasksAssemblyFile>SONARSCANNER_MSBUILD_TASKS_DLL</SonarQubeBuildTasksAssemblyFile> <SonarQubeConfigPath>PROJECT_DIRECTORY_PATH</SonarQubeConfigPath> <SonarQubeTempPath>PROJECT_DIRECTORY_PATH</SonarQubeTempPath> <SonarQubeOutputPath>SQ_OUTPUT_PATH</SonarQubeOutputPath> <!-- Ensure the project is isolated from environment variables that could be picked up when running on a TeamBuild build agent--> <TF_BUILD_BUILDDIRECTORY /> <AGENT_BUILDDIRECTORY /> </PropertyGroup> <!-- Test-specific data --> TEST_SPECIFIC_XML <!-- Standard boilerplate closing imports --> <Import Project='$([MSBuild]::GetDirectoryNameOfFileAbove($(MSBuildThisFileDirectory), SonarQube.Integration.targets))SonarQube.Integration.targets' /> <Import Project='$(MSBuildToolsPath)\Microsoft.CSharp.targets' /> </Project> "; var projectData = template.Replace("PROJECT_DIRECTORY_PATH", projectDirectory) .Replace("SONARSCANNER_MSBUILD_TASKS_DLL", typeof(WriteProjectInfoFile).Assembly.Location) .Replace("TEST_SPECIFIC_XML", testSpecificProjectXml ?? "<!-- none -->") .Replace("SQ_OUTPUT_PATH", sonarQubeOutputPath); var projectFilePath = Path.Combine(projectDirectory, TestContext.TestName + ".proj.txt"); File.WriteAllText(projectFilePath, projectData); TestContext.AddResultFile(projectFilePath); return(projectFilePath); }
public TfsLegacyCoverageReportProcessor(ILogger logger, AnalysisConfig config) : this(new CoverageReportUrlProvider(logger), new CoverageReportDownloader(logger), new BinaryToXmlCoverageReportConverter(logger, config), logger) { }
/// <summary> /// Combines the various configuration options into the AnalysisConfig file /// used by the build and post-processor. Saves the file and returns the config instance. /// </summary> /// <param name="localSettings">Processed local settings, including command line arguments supplied the user</param> /// <param name="buildSettings">Build environment settings</param> /// <param name="serverProperties">Analysis properties downloaded from the SonarQube server</param> /// <param name="analyzerSettings">Specifies the Roslyn analyzers to use</param> public static AnalysisConfig GenerateFile(ProcessedArgs localSettings, TeamBuildSettings buildSettings, IDictionary <string, string> serverProperties, List <AnalyzerSettings> analyzersSettings, ILogger logger) { if (localSettings == null) { throw new ArgumentNullException(nameof(localSettings)); } if (buildSettings == null) { throw new ArgumentNullException(nameof(buildSettings)); } if (serverProperties == null) { throw new ArgumentNullException(nameof(serverProperties)); } if (analyzersSettings == null) { throw new ArgumentNullException(nameof(analyzersSettings)); } if (logger == null) { throw new ArgumentNullException(nameof(logger)); } AnalysisConfig config = new AnalysisConfig(); config.SonarProjectKey = localSettings.ProjectKey; config.SonarProjectName = localSettings.ProjectName; config.SonarProjectVersion = localSettings.ProjectVersion; config.SonarQubeHostUrl = localSettings.SonarQubeUrl; config.SetBuildUri(buildSettings.BuildUri); config.SetTfsUri(buildSettings.TfsUri); config.SonarConfigDir = buildSettings.SonarConfigDirectory; config.SonarOutputDir = buildSettings.SonarOutputDirectory; config.SonarBinDir = buildSettings.SonarBinDirectory; config.SonarScannerWorkingDirectory = buildSettings.SonarScannerWorkingDirectory; config.SourcesDirectory = buildSettings.SourcesDirectory; // Add the server properties to the config config.ServerSettings = new AnalysisProperties(); foreach (var property in serverProperties) { if (!Utilities.IsSecuredServerProperty(property.Key)) { AddSetting(config.ServerSettings, property.Key, property.Value); } } config.LocalSettings = new AnalysisProperties(); // From the local settings, we only write the ones coming from the cmd line foreach (var property in localSettings.CmdLineProperties.GetAllProperties()) { AddSetting(config.LocalSettings, property.Id, property.Value); } // Set the pointer to the properties file if (localSettings.PropertiesFileName != null) { config.SetSettingsFilePath(localSettings.PropertiesFileName); } config.AnalyzersSettings = analyzersSettings; config.Save(buildSettings.AnalysisConfigFilePath); return(config); }
[WorkItem(120)] // Regression test for http://jira.sonarsource.com/browse/SONARMSBRU-120 public void AnalysisConfig_SharedReadAllowed() { // 0. Setup string testFolder = TestUtils.CreateTestSpecificFolder(this.TestContext); string filePath = Path.Combine(testFolder, "config.txt"); AnalysisConfig config = new AnalysisConfig(); config.Save(filePath); using (FileStream lockingStream = File.Open(filePath, FileMode.Open, FileAccess.Read, FileShare.Read)) { AnalysisConfig.Load(filePath); } }
protected override bool TryGetTrxFiles(AnalysisConfig config, ITeamBuildSettings settings, out IEnumerable <string> trxFilePaths) { trxFilePaths = Enumerable.Empty <string>(); return(false); }
private AnalysisConfig SaveAndReloadConfig(AnalysisConfig original, string outputFileName) { Assert.IsFalse(File.Exists(outputFileName), "Test error: file should not exist at the start of the test. File: {0}", outputFileName); original.Save(outputFileName); Assert.IsTrue(File.Exists(outputFileName), "Failed to create the output file. File: {0}", outputFileName); this.TestContext.AddResultFile(outputFileName); AnalysisConfig reloaded = AnalysisConfig.Load(outputFileName); Assert.IsNotNull(reloaded, "Reloaded analysis config should not be null"); AssertExpectedValues(original, reloaded); return reloaded; }
public void PropertiesWriterToString() { var productBaseDir = TestUtils.CreateTestSpecificFolder(TestContext, "PropertiesWriterTest_ProductBaseDir"); var productProject = CreateEmptyFile(productBaseDir, "MyProduct.csproj"); var productFile = CreateEmptyFile(productBaseDir, "File.cs"); var productChineseFile = CreateEmptyFile(productBaseDir, "你好.cs"); var productCoverageFilePath = CreateEmptyFile(productBaseDir, "productCoverageReport.txt"); var productFileListFilePath = Path.Combine(productBaseDir, "productManagedFiles.txt"); var otherDir = TestUtils.CreateTestSpecificFolder(TestContext, "PropertiesWriterTest_OtherDir"); var missingFileOutsideProjectDir = Path.Combine(otherDir, "missing.cs"); var productFiles = new List <string> { productFile, productChineseFile, missingFileOutsideProjectDir }; var productCS = new ProjectData(CreateProjectInfo("你好", "DB2E5521-3172-47B9-BA50-864F12E6DFFF", productProject, false, productFiles, productFileListFilePath, productCoverageFilePath, ProjectLanguages.CSharp, "UTF-8")); productCS.SonarQubeModuleFiles.Add(productFile); productCS.SonarQubeModuleFiles.Add(productChineseFile); productCS.SonarQubeModuleFiles.Add(missingFileOutsideProjectDir); var productVB = new ProjectData(CreateProjectInfo("vbProject", "B51622CF-82F4-48C9-9F38-FB981FAFAF3A", productProject, false, productFiles, productFileListFilePath, productCoverageFilePath, ProjectLanguages.VisualBasic, "UTF-8")); productVB.SonarQubeModuleFiles.Add(productFile); var testBaseDir = TestUtils.CreateTestSpecificFolder(TestContext, "PropertiesWriterTest_TestBaseDir"); var testProject = CreateEmptyFile(testBaseDir, "MyTest.csproj"); var testFile = CreateEmptyFile(testBaseDir, "File.cs"); var testFileListFilePath = Path.Combine(testBaseDir, "testManagedFiles.txt"); var testFiles = new List <string> { testFile }; var test = new ProjectData(CreateProjectInfo("my_test_project", "DA0FCD82-9C5C-4666-9370-C7388281D49B", testProject, true, testFiles, testFileListFilePath, null, ProjectLanguages.VisualBasic, "UTF-8")); test.SonarQubeModuleFiles.Add(testFile); var config = new AnalysisConfig() { SonarProjectKey = "my_project_key", SonarProjectName = "my_project_name", SonarProjectVersion = "1.0", SonarOutputDir = @"C:\my_folder", SourcesDirectory = @"d:\source_files\" }; string actual = null; using (new AssertIgnoreScope()) // expecting the property writer to complain about the missing file { var writer = new PropertiesWriter(config); writer.WriteSettingsForProject(productCS, productCoverageFilePath); writer.WriteSettingsForProject(productVB, null); writer.WriteSettingsForProject(test, null); actual = writer.Flush(); } var expected = string.Format(System.Globalization.CultureInfo.InvariantCulture, @"DB2E5521-3172-47B9-BA50-864F12E6DFFF.sonar.projectKey=my_project_key:DB2E5521-3172-47B9-BA50-864F12E6DFFF DB2E5521-3172-47B9-BA50-864F12E6DFFF.sonar.projectName=\u4F60\u597D DB2E5521-3172-47B9-BA50-864F12E6DFFF.sonar.projectBaseDir={0} DB2E5521-3172-47B9-BA50-864F12E6DFFF.sonar.sourceEncoding=utf-8 DB2E5521-3172-47B9-BA50-864F12E6DFFF.sonar.cs.vscoveragexml.reportsPaths={1} DB2E5521-3172-47B9-BA50-864F12E6DFFF.sonar.sources=\ {0}\\File.cs,\ {0}\\\u4F60\u597D.cs,\ {3} B51622CF-82F4-48C9-9F38-FB981FAFAF3A.sonar.projectKey=my_project_key:B51622CF-82F4-48C9-9F38-FB981FAFAF3A B51622CF-82F4-48C9-9F38-FB981FAFAF3A.sonar.projectName=vbProject B51622CF-82F4-48C9-9F38-FB981FAFAF3A.sonar.projectBaseDir={0} B51622CF-82F4-48C9-9F38-FB981FAFAF3A.sonar.sourceEncoding=utf-8 B51622CF-82F4-48C9-9F38-FB981FAFAF3A.sonar.sources=\ {0}\\File.cs DA0FCD82-9C5C-4666-9370-C7388281D49B.sonar.projectKey=my_project_key:DA0FCD82-9C5C-4666-9370-C7388281D49B DA0FCD82-9C5C-4666-9370-C7388281D49B.sonar.projectName=my_test_project DA0FCD82-9C5C-4666-9370-C7388281D49B.sonar.projectBaseDir={2} DA0FCD82-9C5C-4666-9370-C7388281D49B.sonar.sourceEncoding=utf-8 DA0FCD82-9C5C-4666-9370-C7388281D49B.sonar.sources= DA0FCD82-9C5C-4666-9370-C7388281D49B.sonar.tests=\ {2}\\File.cs sonar.modules=DB2E5521-3172-47B9-BA50-864F12E6DFFF,B51622CF-82F4-48C9-9F38-FB981FAFAF3A,DA0FCD82-9C5C-4666-9370-C7388281D49B ", PropertiesWriter.Escape(productBaseDir), PropertiesWriter.Escape(productCoverageFilePath), PropertiesWriter.Escape(testBaseDir), PropertiesWriter.Escape(missingFileOutsideProjectDir), PropertiesWriter.Escape(config.SourcesDirectory)); SaveToResultFile(productBaseDir, "Expected.txt", expected.ToString()); SaveToResultFile(productBaseDir, "Actual.txt", actual); Assert.AreEqual(expected, actual); }
private static void CompareAdditionalSettings(AnalysisConfig expected, AnalysisConfig actual) { // The XmlSerializer should create an empty list Assert.IsNotNull(actual.AdditionalConfig, "Not expecting the AdditionalSettings to be null for a reloaded file"); if (expected.AdditionalConfig == null || expected.AdditionalConfig.Count == 0) { Assert.AreEqual(0, actual.AdditionalConfig.Count, "Not expecting any additional items. Count: {0}", actual.AdditionalConfig.Count); return; } foreach(ConfigSetting expectedSetting in expected.AdditionalConfig) { AssertSettingExists(expectedSetting.Id, expectedSetting.Value, actual); } Assert.AreEqual(expected.AdditionalConfig.Count, actual.AdditionalConfig.Count, "Unexpected number of additional settings"); }
public void GenerateReports(ITeamBuildSettings settings, AnalysisConfig config, ProjectInfoAnalysisResult result, ILogger logger) { Assert.IsFalse(methodCalled, "Generate reports has already been called"); methodCalled = true; }
private static void AssertSettingExists(string settingId, string expectedValue, AnalysisConfig actual) { Assert.IsNotNull(actual.AdditionalConfig, "Not expecting the additional settings to be null"); ConfigSetting actualSetting = actual.AdditionalConfig.FirstOrDefault(s => string.Equals(settingId, s.Id, StringComparison.InvariantCultureIgnoreCase)); Assert.IsNotNull(actualSetting, "Expected setting not found: {0}", settingId); Assert.AreEqual(expectedValue, actualSetting.Value, "Setting does not have the expected value. SettingId: {0}", settingId); }
public void Roslyn_Settings_ValidSetup_LegacyServer_Override_Analyzers() { // Arrange // Create a valid config containing analyzer settings var config = new AnalysisConfig { SonarQubeVersion = "6.7", // legacy version AnalyzersSettings = new List <AnalyzerSettings> { new AnalyzerSettings { Language = "cs", RuleSetFilePath = "d:\\my.ruleset", AnalyzerAssemblyPaths = new List <string> { "c:\\data\\new.analyzer1.dll", "c:\\new.analyzer2.dll" }, AdditionalFilePaths = new List <string> { "c:\\config.1.txt", "c:\\config.2.txt" } } } }; var testSpecificProjectXml = @" <PropertyGroup> <ResolvedCodeAnalysisRuleSet>c:\should.be.overridden.ruleset</ResolvedCodeAnalysisRuleSet> <Language>C#</Language> </PropertyGroup> <ItemGroup> <!-- all analyzers specified in the project file should be removed --> <Analyzer Include='c:\should.be.removed.analyzer2.dll' /> <Analyzer Include='should.be.removed.analyzer1.dll' /> </ItemGroup> <ItemGroup> <!-- These additional files don't match ones in the config and should be preserved --> <AdditionalFiles Include='should.not.be.removed.additional1.txt' /> <AdditionalFiles Include='should.not.be.removed.additional2.txt' /> <!-- This additional file matches one in the config and should be replaced --> <AdditionalFiles Include='should.be.removed/CONFIG.1.TXT' /> <AdditionalFiles Include='should.be.removed\CONFIG.2.TXT' /> </ItemGroup> "; var projectFilePath = CreateProjectFile(config, testSpecificProjectXml); // Act var result = BuildRunner.BuildTargets(TestContext, projectFilePath, TargetConstants.OverrideRoslynAnalysisTarget); // Assert result.AssertTargetExecuted(TargetConstants.CreateProjectSpecificDirs); result.AssertTargetExecuted(TargetConstants.OverrideRoslynAnalysisTarget); result.AssertTargetExecuted(TargetConstants.SetRoslynAnalysisPropertiesTarget); result.BuildSucceeded.Should().BeTrue(); // Check the error log and ruleset properties are set AssertErrorLogIsSetBySonarQubeTargets(result); AssertExpectedResolvedRuleset(result, "d:\\my.ruleset"); AssertExpectedAdditionalFiles(result, result.GetCapturedPropertyValue(TargetProperties.ProjectConfFilePath), "should.not.be.removed.additional1.txt", "should.not.be.removed.additional2.txt", "c:\\config.1.txt", "c:\\config.2.txt"); AssertExpectedAnalyzers(result, "c:\\data\\new.analyzer1.dll", "c:\\new.analyzer2.dll"); AssertWarningsAreNotTreatedAsErrorsNorIgnored(result); }
public void Roslyn_Settings_ValidSetup_NonLegacyServer_MergeSettings() { // Arrange var dir = TestUtils.CreateTestSpecificFolder(TestContext); var dummyQpRulesetPath = TestUtils.CreateValidEmptyRuleset(dir, "dummyQp"); // Create a valid config containing analyzer settings var config = new AnalysisConfig { SonarQubeVersion = "7.5", // non-legacy version ServerSettings = new AnalysisProperties { new Property { Id = "sonar.cs.roslyn.ignoreIssues", Value = "false" } }, AnalyzersSettings = new List <AnalyzerSettings> { new AnalyzerSettings { Language = "cs", RuleSetFilePath = dummyQpRulesetPath, AnalyzerAssemblyPaths = new List <string> { "c:\\data\\new\\analyzer1.dll", "c:\\new.analyzer2.dll" }, AdditionalFilePaths = new List <string> { "c:\\config\\duplicate.1.txt", "c:\\duplicate.2.txt" } } } }; var testSpecificProjectXml = @" <PropertyGroup> <ResolvedCodeAnalysisRuleSet>c:\original.ruleset</ResolvedCodeAnalysisRuleSet> <Language>C#</Language> </PropertyGroup> <ItemGroup> <!-- all analyzers specified in the project file should be preserved --> <Analyzer Include='c:\original\should.be.removed\analyzer1.dll' /> <Analyzer Include='original\should.be.preserved\analyzer3.dll' /> </ItemGroup> <ItemGroup> <!-- These additional files don't match ones in the config and should be preserved --> <AdditionalFiles Include='should.not.be.removed.additional1.txt' /> <AdditionalFiles Include='should.not.be.removed.additional2.txt' /> <!-- This additional file matches one in the config and should be replaced --> <AdditionalFiles Include='d:/should.be.removed/DUPLICATE.1.TXT' /> <AdditionalFiles Include='d:\should.be.removed\duplicate.2.TXT' /> </ItemGroup> "; var projectFilePath = CreateProjectFile(config, testSpecificProjectXml); // Act var result = BuildRunner.BuildTargets(TestContext, projectFilePath, TargetConstants.OverrideRoslynAnalysisTarget); // Assert result.AssertTargetExecuted(TargetConstants.CreateProjectSpecificDirs); result.AssertTargetExecuted(TargetConstants.OverrideRoslynAnalysisTarget); result.AssertTargetExecuted(TargetConstants.SetRoslynAnalysisPropertiesTarget); result.BuildSucceeded.Should().BeTrue(); // Check the error log and ruleset properties are set AssertErrorLogIsSetBySonarQubeTargets(result); var actualProjectSpecificConfFolder = result.GetCapturedPropertyValue(TargetProperties.ProjectSpecificConfDir); Directory.Exists(actualProjectSpecificConfFolder).Should().BeTrue(); var expectedMergedRuleSetFilePath = Path.Combine(actualProjectSpecificConfFolder, "merged.ruleset"); AssertExpectedResolvedRuleset(result, expectedMergedRuleSetFilePath); RuleSetAssertions.CheckMergedRulesetFile(actualProjectSpecificConfFolder, @"c:\original.ruleset"); AssertExpectedAdditionalFiles(result, result.GetCapturedPropertyValue(TargetProperties.ProjectConfFilePath), "should.not.be.removed.additional1.txt", "should.not.be.removed.additional2.txt", "c:\\config\\duplicate.1.txt", "c:\\duplicate.2.txt"); AssertExpectedAnalyzers(result, "c:\\data\\new\\analyzer1.dll", "c:\\new.analyzer2.dll", "original\\should.be.preserved\\analyzer3.dll"); AssertWarningsAreNotTreatedAsErrorsNorIgnored(result); }
[TestMethod] //https://jira.codehaus.org/browse/SONARMSBRU-13: Analysis fails if a content file referenced in the MSBuild project does not exist public void FileGen_MissingFilesAreSkipped() { // Create project info with a managed file list and a content file list. // Each list refers to a file that does not exist on disk. // The missing files should not appear in the generated properties file. // Arrange string testDir = TestUtils.CreateTestSpecificFolder(this.TestContext); string projectBaseDir = TestUtils.CreateTestSpecificFolder(TestContext, "Project1"); string projectFullPath = CreateEmptyFile(projectBaseDir, "project1.proj"); string existingManagedFile = CreateEmptyFile(projectBaseDir, "File1.cs"); string existingContentFile = CreateEmptyFile(projectBaseDir, "Content1.txt"); string missingManagedFile = Path.Combine(projectBaseDir, "MissingFile1.cs"); string missingContentFile = Path.Combine(projectBaseDir, "MissingContent1.txt"); ProjectInfo projectInfo = new ProjectInfo() { FullPath = projectFullPath, AnalysisResults = new List <AnalysisResult>(), IsExcluded = false, ProjectGuid = Guid.NewGuid(), ProjectName = "project1.proj", ProjectType = ProjectType.Product }; string analysisFileList = CreateFileList(projectBaseDir, "filesToAnalyze.txt", existingManagedFile, missingManagedFile, existingContentFile, missingContentFile); projectInfo.AddAnalyzerResult(AnalysisType.FilesToAnalyze, analysisFileList); string projectInfoDir = TestUtils.CreateTestSpecificFolder(this.TestContext, "ProjectInfo1Dir"); string projectInfoFilePath = Path.Combine(projectInfoDir, FileConstants.ProjectInfoFileName); projectInfo.Save(projectInfoFilePath); TestLogger logger = new TestLogger(); AnalysisConfig config = new AnalysisConfig() { SonarProjectKey = "my_project_key", SonarProjectName = "my_project_name", SonarProjectVersion = "1.0", SonarOutputDir = testDir }; // Act ProjectInfoAnalysisResult result = PropertiesFileGenerator.GenerateFile(config, logger); string actual = File.ReadAllText(result.FullPropertiesFilePath); // Assert AssertFileIsReferenced(existingContentFile, actual); AssertFileIsReferenced(existingManagedFile, actual); AssertFileIsNotReferenced(missingContentFile, actual); AssertFileIsNotReferenced(missingManagedFile, actual); logger.AssertSingleWarningExists(missingManagedFile); logger.AssertSingleWarningExists(missingContentFile); }