/// <summary>
        /// Creates and returns a mock server that is correctly configured to return
        /// a SonarLint ruleset for the specified project key and profile
        /// </summary>
        private MockSonarQubeServer CreateValidServer(string validProjectKey, string validProfileName)
        {
            ServerDataModel model = new ServerDataModel();

            model.InstalledPlugins.Add(SonarLintAnalyzerProvider.CSharpPluginKey);
            model.InstalledPlugins.Add("unused");

            model.AddQualityProfile(validProfileName, "vb")
            .AddProject(validProjectKey)
            .AddProject(validProfileName);

            model.AddQualityProfile(validProfileName, SonarLintAnalyzerProvider.CSharpLanguage)
            .AddProject(validProjectKey)
            .AddProject("project3")
            .SetExport(SonarLintAnalyzerProvider.SonarLintProfileFormatName,
                       @"<?xml version=""1.0"" encoding=""utf-8""?>
<RuleSet Name=""Rules for SonarLint"" Description=""This rule set was automatically generated from SonarQube."" ToolsVersion=""14.0"">
  <Rules AnalyzerId=""SonarLint"" RuleNamespace=""SonarLint"">
    <Rule Id=""S1656"" Action=""Warning"" />
  </Rules>
</RuleSet>");

            model.AddRepository(SonarLintAnalyzerProvider.CSharpRepositoryKey, SonarLintAnalyzerProvider.CSharpLanguage);

            byte[] sonarLintData = CreateDummySonarLintZip();
            model.AddEmbeddedFile(SonarLintAnalyzerProvider.CSharpPluginKey, SonarLintAnalyzerProvider.EmbeddedSonarLintZipFileName, sonarLintData);

            MockSonarQubeServer server = new MockSonarQubeServer();

            server.Data = model;
            return(server);
        }
Exemplo n.º 2
0
        public void PreProc_NoPlugin()
        {
            // Arrange
            string     workingDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
            TestLogger logger     = new TestLogger();

            // Configure the server
            MockSonarQubeServer mockServer = new MockSonarQubeServer();

            ServerDataModel data = mockServer.Data;

            data.ServerProperties.Add("server.key", "server value 1");

            data.Languages.Add("invalid_plugin");

            MockRoslynAnalyzerProvider mockAnalyzerProvider = new MockRoslynAnalyzerProvider
            {
                SettingsToReturn = new AnalyzerSettings
                {
                    RuleSetFilePath = "c:\\xxx.ruleset"
                }
            };

            Mock <ITargetsInstaller> mockTargetsInstaller = new Mock <ITargetsInstaller>();
            MockObjectFactory        mockFactory          = new MockObjectFactory(mockServer, mockTargetsInstaller.Object, mockAnalyzerProvider);

            TeamBuildSettings settings;

            using (PreprocessTestUtils.CreateValidNonTeamBuildScope())
                using (new WorkingDirectoryScope(workingDir))
                {
                    settings = TeamBuildSettings.GetSettingsFromEnvironment(new TestLogger());
                    Assert.IsNotNull(settings, "Test setup error: TFS environment variables have not been set correctly");
                    Assert.AreEqual(BuildEnvironment.NotTeamBuild, settings.BuildEnvironment, "Test setup error: build environment was not set correctly");

                    TeamBuildPreProcessor preProcessor = new TeamBuildPreProcessor(mockFactory, logger);

                    // Act
                    bool success = preProcessor.Execute(CreateValidArgs("key", "name", "1.0"));
                    Assert.IsTrue(success, "Expecting the pre-processing to complete successfully");
                }

            // Assert
            AssertDirectoriesCreated(settings);

            mockTargetsInstaller.Verify(x => x.InstallLoaderTargets(logger, workingDir), Times.Once());
            mockServer.AssertMethodCalled("GetProperties", 1);
            mockServer.AssertMethodCalled("GetAllLanguages", 1);
            mockServer.AssertMethodCalled("TryGetQualityProfile", 0); // No valid plugin
            mockServer.AssertMethodCalled("GetActiveRules", 0);       // No valid plugin
            mockServer.AssertMethodCalled("GetInactiveRules", 0);     // No valid plugin

            AssertAnalysisConfig(settings.AnalysisConfigFilePath, 0, logger);

            // only contains SonarQubeAnalysisConfig (no rulesets or aditional files)
            AssertDirectoryContains(settings.SonarConfigDirectory, Path.GetFileName(settings.AnalysisConfigFilePath));
        }
Exemplo n.º 3
0
        private MockSonarQubeServer CreateServer(string projectKey, string projectBranch, string profileName, WellKnownProfile profile)
        {
            ServerDataModel model = new ServerDataModel();

            // Add the required C# plugin and repository
            model.InstalledPlugins.Add(RoslynAnalyzerProvider.CSharpPluginKey);
            model.AddRepository(RoslynAnalyzerProvider.CSharpRepositoryKey, RoslynAnalyzerProvider.CSharpLanguage);

            // Add some dummy data
            model.InstalledPlugins.Add("unused");

            MockSonarQubeServer server = new MockSonarQubeServer();

            server.Data = model;

            AddWellKnownProfileToServer(projectKey, projectBranch, profileName, profile, server);

            return(server);
        }
Exemplo n.º 4
0
 public MockSonarQubeServer()
 {
     calledMethods = new List <string>();
     Data          = new ServerDataModel();
 }
        public void RulesetGet_Simple()
        {
            string testDir = TestUtils.CreateTestSpecificFolder(this.TestContext);

            ServerDataModel model = new ServerDataModel();

            model.InstalledPlugins.Add("real.plugin1");
            model.InstalledPlugins.Add("unused.plugin1");

            // Set up the rule repositories
            model.AddRepository("empty.repo", "aaa");

            model.AddRepository("repo1", "languageAAA")
                .AddRule("repo1.aaa.r1", "repo1.aaa.r1.internal")
                .AddRule("repo1.aaa.r2", "repo1.aaa.r2.internal");

            model.AddRepository("repo1", "languageBBB")
                .AddRule("repo1.bbb.r1", "repo1.xxx.r1.internal")
                .AddRule("repo1.bbb.r2", "repo1.xxx.r2.internal")
                .AddRule("repo1.bbb.r3", "repo1.xxx.r3.internal");


            // Set up the quality profiles
            model.AddQualityProfile("profile 1", "languageAAA")
                .AddProject("unused.project")
                .AddProject("project1")
                .AddProject("project2:anotherBranch");

            model.AddQualityProfile("profile 2", "languageBBB")
                .AddProject("project1")
                .AddProject("project2");

            model.AddQualityProfile("profile 3", "languageBBB")
                .AddProject("project2:aBranch")
                .AddProject("project3:aThirdBranch");

            // Add rules to the quality profiles
            model.AddRuleToProfile("repo1.aaa.r1", "profile 1"); // Only one rule in the repo

            model.AddRuleToProfile("repo1.bbb.r1", "profile 2");
            model.AddRuleToProfile("repo1.bbb.r2", "profile 2");
            model.AddRuleToProfile("repo1.bbb.r3", "profile 2");

            model.AddRuleToProfile("repo1.bbb.r1", "profile 3");

            MockSonarQubeServer server = new MockSonarQubeServer();
            server.Data = model;

            // 1. Plugin not installed
            string rulesetFilePath = Path.Combine(testDir, "r1.txt");
            RulesetGenerator.Generate(server, "missing.plugin", "languageAAA", "repo1", "project1", null, rulesetFilePath);
            AssertFileDoesNotExist(rulesetFilePath);

            // 2. Language not handled
            RulesetGenerator.Generate(server, "real.plugin1", "unhandled.language", "repo1", "project1", null, rulesetFilePath);
            AssertFileDoesNotExist(rulesetFilePath);

            // 3. Missing project
            RulesetGenerator.Generate(server, "real.plugin1", "languageBBB", "repo1", "missing.project", null, rulesetFilePath);
            AssertFileDoesNotExist(rulesetFilePath);

            // 4. Missing project (project:branch exists)
            RulesetGenerator.Generate(server, "real.plugin1", "languageBBB", "repo1", "project3", null, rulesetFilePath);
            AssertFileDoesNotExist(rulesetFilePath);

            // 5. Missing project:branch
            RulesetGenerator.Generate(server, "real.plugin1", "languageBBB", "repo1", "missing.project", "missingBranch", rulesetFilePath);
            AssertFileDoesNotExist(rulesetFilePath);

            // 6. b) Missing project:branch (project exists)
            RulesetGenerator.Generate(server, "real.plugin1", "languageBBB", "repo1", "project1", "missingBranch", rulesetFilePath);
            AssertFileDoesNotExist(rulesetFilePath);

            // 5. Valid, aaa (default branch)
            string aaa_RulesetFilePath = Path.Combine(testDir, "aaa_ruleset.txt");
            RulesetGenerator.Generate(server, "real.plugin1", "languageAAA", "repo1", "project1", null, aaa_RulesetFilePath);
            PreProcessAsserts.AssertRuleSetContainsRules(aaa_RulesetFilePath, "repo1.aaa.r1");

            // 6. Valid, bbb (default branch)
            string bbb_RulesetFilePath = Path.Combine(testDir, "bbb_ruleset.txt");
            RulesetGenerator.Generate(server, "real.plugin1", "languageBBB", "repo1", "project1", null, bbb_RulesetFilePath);
            PreProcessAsserts.AssertRuleSetContainsRules(bbb_RulesetFilePath,
                "repo1.bbb.r1", "repo1.bbb.r2", "repo1.bbb.r3");

            // 7. Valid, bbb (aBranch branch) - profile 3
            string bbb_aBranch_RulesetFilePath = Path.Combine(testDir, "bbb_aBranch_ruleset.txt");
            RulesetGenerator.Generate(server, "real.plugin1", "languageBBB", "repo1", "project2", "aBranch", bbb_aBranch_RulesetFilePath);
            PreProcessAsserts.AssertRuleSetContainsRules(bbb_aBranch_RulesetFilePath,
                "repo1.bbb.r1");

            // 8. Valid, aaa (anotherBranch branch) - profile 1
            string bbb_anotherBranch_RulesetFilePath = Path.Combine(testDir, "bbb_anotherBranch_ruleset.txt");
            RulesetGenerator.Generate(server, "real.plugin1", "languageAAA", "repo1", "project2", "anotherBranch", bbb_anotherBranch_RulesetFilePath);
            PreProcessAsserts.AssertRuleSetContainsRules(bbb_anotherBranch_RulesetFilePath,
                "repo1.aaa.r1");
        }
Exemplo n.º 6
0
        public void PreProc_EndToEnd_SuccessCase()
        {
            // Checks end-to-end happy path for the pre-processor i.e.
            // * arguments are parsed
            // * targets are installed
            // * server properties are fetched
            // * rulesets are generated
            // * config file is created

            // Arrange
            string     workingDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
            TestLogger logger     = new TestLogger();

            // Configure the server
            MockSonarQubeServer mockServer = new MockSonarQubeServer();

            ServerDataModel data = mockServer.Data;

            data.ServerProperties.Add("server.key", "server value 1");

            data.Languages.Add("cs");
            data.Languages.Add("vbnet");
            data.Languages.Add("another_plugin");

            data.AddQualityProfile("qp1", "cs", null)
            .AddProject("key")
            .AddRule(new ActiveRule("csharpsquid", "cs.rule3"));

            data.AddQualityProfile("qp2", "vbnet", null)
            .AddProject("key")
            .AddRule(new ActiveRule("vbnet", "vb.rule3"));

            MockRoslynAnalyzerProvider mockAnalyzerProvider = new MockRoslynAnalyzerProvider
            {
                SettingsToReturn = new AnalyzerSettings
                {
                    RuleSetFilePath = "c:\\xxx.ruleset"
                }
            };

            Mock <ITargetsInstaller> mockTargetsInstaller = new Mock <ITargetsInstaller>();
            MockObjectFactory        mockFactory          = new MockObjectFactory(mockServer, mockTargetsInstaller.Object, mockAnalyzerProvider);

            TeamBuildSettings settings;

            using (PreprocessTestUtils.CreateValidNonTeamBuildScope())
                using (new WorkingDirectoryScope(workingDir))
                {
                    settings = TeamBuildSettings.GetSettingsFromEnvironment(new TestLogger());
                    Assert.IsNotNull(settings, "Test setup error: TFS environment variables have not been set correctly");
                    Assert.AreEqual(BuildEnvironment.NotTeamBuild, settings.BuildEnvironment, "Test setup error: build environment was not set correctly");

                    TeamBuildPreProcessor preProcessor = new TeamBuildPreProcessor(mockFactory, logger);

                    // Act
                    bool success = preProcessor.Execute(CreateValidArgs("key", "name", "1.0"));
                    Assert.IsTrue(success, "Expecting the pre-processing to complete successfully");
                }

            // Assert
            AssertDirectoriesCreated(settings);

            mockTargetsInstaller.Verify(x => x.InstallLoaderTargets(logger, workingDir), Times.Once());
            mockServer.AssertMethodCalled("GetProperties", 1);
            mockServer.AssertMethodCalled("GetAllLanguages", 1);
            mockServer.AssertMethodCalled("TryGetQualityProfile", 2); // C# and VBNet
            mockServer.AssertMethodCalled("GetActiveRules", 2);       // C# and VBNet
            mockServer.AssertMethodCalled("GetInactiveRules", 2);     // C# and VBNet

            AssertAnalysisConfig(settings.AnalysisConfigFilePath, 2, logger);
        }
        private MockSonarQubeServer CreateServer(string projectKey, string projectBranch, string profileName, WellKnownProfile profile)
        {
            ServerDataModel model = new ServerDataModel();

            // Add the required C# plugin and repository
            model.InstalledPlugins.Add(RoslynAnalyzerProvider.CSharpPluginKey);
            model.AddRepository(RoslynAnalyzerProvider.CSharpRepositoryKey, RoslynAnalyzerProvider.CSharpLanguage);

            // Add some dummy data
            model.InstalledPlugins.Add("unused");

            MockSonarQubeServer server = new MockSonarQubeServer();
            server.Data = model;

            AddWellKnownProfileToServer(projectKey, projectBranch, profileName, profile, server);

            return server;
        }
        /// <summary>
        /// Creates and returns a mock server that is correctly configured to return
        /// a SonarLint ruleset for the specified project key and profile
        /// </summary>
        private static MockSonarQubeServer CreateValidServer(string validProjectKey, string validProfileName)
        {
            ServerDataModel model = new ServerDataModel();
            model.InstalledPlugins.Add(SonarLintAnalyzerProvider.CSharpPluginKey);
            model.InstalledPlugins.Add("unused");

            model.AddQualityProfile(validProfileName, "vb")
                .AddProject(validProjectKey)
                .AddProject(validProfileName);

            model.AddQualityProfile(validProfileName, SonarLintAnalyzerProvider.CSharpLanguage)
                .AddProject(validProjectKey)
                .AddProject("project3")
                .SetExport(SonarLintAnalyzerProvider.SonarLintProfileFormatName,
            @"<?xml version=""1.0"" encoding=""utf-8""?>
            <RuleSet Name=""Rules for SonarLint"" Description=""This rule set was automatically generated from SonarQube."" ToolsVersion=""14.0"">
              <Rules AnalyzerId=""SonarLint"" RuleNamespace=""SonarLint"">
            <Rule Id=""S1656"" Action=""Warning"" />
              </Rules>
            </RuleSet>");

            model.AddRepository(SonarLintAnalyzerProvider.CSharpRepositoryKey, SonarLintAnalyzerProvider.CSharpLanguage);

            MockSonarQubeServer server = new MockSonarQubeServer();
            server.Data = model;
            return server;
        }
Exemplo n.º 9
0
        public void RulesetGet_Simple()
        {
            string testDir = TestUtils.CreateTestSpecificFolder(this.TestContext);

            ServerDataModel model = new ServerDataModel();

            model.InstalledPlugins.Add("real.plugin1");
            model.InstalledPlugins.Add("unused.plugin1");

            // Set up the rule repositories
            model.AddRepository("empty.repo", "aaa");

            model.AddRepository("repo1", "languageAAA")
            .AddRule("repo1.aaa.r1", "repo1.aaa.r1.internal")
            .AddRule("repo1.aaa.r2", "repo1.aaa.r2.internal");

            model.AddRepository("repo1", "languageBBB")
            .AddRule("repo1.bbb.r1", "repo1.xxx.r1.internal")
            .AddRule("repo1.bbb.r2", "repo1.xxx.r2.internal")
            .AddRule("repo1.bbb.r3", "repo1.xxx.r3.internal");


            // Set up the quality profiles
            model.AddQualityProfile("profile 1", "languageAAA")
            .AddProject("unused.project")
            .AddProject("project1")
            .AddProject("project2:anotherBranch");

            model.AddQualityProfile("profile 2", "languageBBB")
            .AddProject("project1")
            .AddProject("project2");

            model.AddQualityProfile("profile 3", "languageBBB")
            .AddProject("project2:aBranch")
            .AddProject("project3:aThirdBranch");

            // Add rules to the quality profiles
            model.AddRuleToProfile("repo1.aaa.r1", "profile 1"); // Only one rule in the repo

            model.AddRuleToProfile("repo1.bbb.r1", "profile 2");
            model.AddRuleToProfile("repo1.bbb.r2", "profile 2");
            model.AddRuleToProfile("repo1.bbb.r3", "profile 2");

            model.AddRuleToProfile("repo1.bbb.r1", "profile 3");

            MockSonarQubeServer server = new MockSonarQubeServer();

            server.Data = model;

            // 1. Plugin not installed
            string rulesetFilePath = Path.Combine(testDir, "r1.txt");

            RulesetGenerator.Generate(server, "missing.plugin", "languageAAA", "repo1", "project1", null, rulesetFilePath);
            AssertFileDoesNotExist(rulesetFilePath);

            // 2. Language not handled
            RulesetGenerator.Generate(server, "real.plugin1", "unhandled.language", "repo1", "project1", null, rulesetFilePath);
            AssertFileDoesNotExist(rulesetFilePath);

            // 3. Missing project
            RulesetGenerator.Generate(server, "real.plugin1", "languageBBB", "repo1", "missing.project", null, rulesetFilePath);
            AssertFileDoesNotExist(rulesetFilePath);

            // 4. Missing project (project:branch exists)
            RulesetGenerator.Generate(server, "real.plugin1", "languageBBB", "repo1", "project3", null, rulesetFilePath);
            AssertFileDoesNotExist(rulesetFilePath);

            // 5. Missing project:branch
            RulesetGenerator.Generate(server, "real.plugin1", "languageBBB", "repo1", "missing.project", "missingBranch", rulesetFilePath);
            AssertFileDoesNotExist(rulesetFilePath);

            // 6. b) Missing project:branch (project exists)
            RulesetGenerator.Generate(server, "real.plugin1", "languageBBB", "repo1", "project1", "missingBranch", rulesetFilePath);
            AssertFileDoesNotExist(rulesetFilePath);

            // 5. Valid, aaa (default branch)
            string aaa_RulesetFilePath = Path.Combine(testDir, "aaa_ruleset.txt");

            RulesetGenerator.Generate(server, "real.plugin1", "languageAAA", "repo1", "project1", null, aaa_RulesetFilePath);
            PreProcessAsserts.AssertRuleSetContainsRules(aaa_RulesetFilePath, "repo1.aaa.r1");

            // 6. Valid, bbb (default branch)
            string bbb_RulesetFilePath = Path.Combine(testDir, "bbb_ruleset.txt");

            RulesetGenerator.Generate(server, "real.plugin1", "languageBBB", "repo1", "project1", null, bbb_RulesetFilePath);
            PreProcessAsserts.AssertRuleSetContainsRules(bbb_RulesetFilePath,
                                                         "repo1.bbb.r1", "repo1.bbb.r2", "repo1.bbb.r3");

            // 7. Valid, bbb (aBranch branch) - profile 3
            string bbb_aBranch_RulesetFilePath = Path.Combine(testDir, "bbb_aBranch_ruleset.txt");

            RulesetGenerator.Generate(server, "real.plugin1", "languageBBB", "repo1", "project2", "aBranch", bbb_aBranch_RulesetFilePath);
            PreProcessAsserts.AssertRuleSetContainsRules(bbb_aBranch_RulesetFilePath,
                                                         "repo1.bbb.r1");

            // 8. Valid, aaa (anotherBranch branch) - profile 1
            string bbb_anotherBranch_RulesetFilePath = Path.Combine(testDir, "bbb_anotherBranch_ruleset.txt");

            RulesetGenerator.Generate(server, "real.plugin1", "languageAAA", "repo1", "project2", "anotherBranch", bbb_anotherBranch_RulesetFilePath);
            PreProcessAsserts.AssertRuleSetContainsRules(bbb_anotherBranch_RulesetFilePath,
                                                         "repo1.aaa.r1");
        }
Exemplo n.º 10
0
        public void PreProc_NoProject()
        {
            // Arrange
            string     workingDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
            TestLogger logger     = new TestLogger();

            // Configure the server
            MockSonarQubeServer mockServer = new MockSonarQubeServer();

            ServerDataModel data = mockServer.Data;

            data.ServerProperties.Add("server.key", "server value 1");

            data.InstalledPlugins.Add("csharp");
            data.InstalledPlugins.Add("vbnet");
            data.InstalledPlugins.Add("another_plugin");

            data.AddQualityProfile("qp1", "cs")
            .AddProject("invalid")
            .AddRule(new ActiveRule("fxcop", "cs.rule1"))
            .AddRule(new ActiveRule("fxcop", "cs.rule2"));

            data.AddQualityProfile("qp2", "vbnet")
            .AddProject("invalid")
            .AddRule(new ActiveRule("fxcop-vbnet", "vb.rule1"))
            .AddRule(new ActiveRule("fxcop-vbnet", "vb.rule2"));

            MockRoslynAnalyzerProvider mockAnalyzerProvider = new MockRoslynAnalyzerProvider();

            mockAnalyzerProvider.SettingsToReturn = new AnalyzerSettings();
            mockAnalyzerProvider.SettingsToReturn.RuleSetFilePath = "c:\\xxx.ruleset";

            MockTargetsInstaller mockTargetsInstaller = new MockTargetsInstaller();
            MockObjectFactory    mockFactory          = new MockObjectFactory(mockServer, mockTargetsInstaller, mockAnalyzerProvider, new RulesetGenerator());

            TeamBuildSettings settings;

            using (PreprocessTestUtils.CreateValidNonTeamBuildScope())
                using (new WorkingDirectoryScope(workingDir))
                {
                    settings = TeamBuildSettings.GetSettingsFromEnvironment(new TestLogger());
                    Assert.IsNotNull(settings, "Test setup error: TFS environment variables have not been set correctly");
                    Assert.AreEqual(BuildEnvironment.NotTeamBuild, settings.BuildEnvironment, "Test setup error: build environment was not set correctly");

                    TeamBuildPreProcessor preProcessor = new TeamBuildPreProcessor(mockFactory, logger);

                    // Act
                    bool success = preProcessor.Execute(CreateValidArgs("key", "name", "1.0"));
                    Assert.IsTrue(success, "Expecting the pre-processing to complete successfully");
                }

            // Assert
            AssertDirectoriesCreated(settings);

            mockTargetsInstaller.AssertsTargetsCopied();
            mockServer.AssertMethodCalled("GetProperties", 1);
            mockServer.AssertMethodCalled("GetInstalledPlugins", 1);
            mockServer.AssertMethodCalled("TryGetQualityProfile", 2); // C# and VBNet
            mockServer.AssertMethodCalled("GetActiveRules", 0);       // no quality profile assigned to project
            mockServer.AssertMethodCalled("GetInactiveRules", 0);

            AssertAnalysisConfig(settings.AnalysisConfigFilePath, 0, logger);

            // only contains SonarQubeAnalysisConfig (no rulesets or aditional files)
            AssertDirectoryContains(settings.SonarConfigDirectory, Path.GetFileName(settings.AnalysisConfigFilePath));
        }
Exemplo n.º 11
0
        public void PreProc_EndToEnd_SuccessCase()
        {
            // Checks end-to-end happy path for the pre-processor i.e.
            // * arguments are parsed
            // * targets are installed
            // * server properties are fetched
            // * rulesets are generated
            // * config file is created

            // Arrange
            string     workingDir = TestUtils.CreateTestSpecificFolder(this.TestContext);
            TestLogger logger     = new TestLogger();

            // Configure the server
            MockSonarQubeServer mockServer = new MockSonarQubeServer();

            ServerDataModel data = mockServer.Data;

            data.ServerProperties.Add("server.key", "server value 1");

            data.InstalledPlugins.Add("csharp");
            data.InstalledPlugins.Add("vbnet");

            data.AddRepository("fxcop", "cs")
            .AddRule("cs.rule1", "cs.rule1.internal")
            .AddRule("cs.rule2", "cs.rule2.internal");

            data.AddRepository("fxcop-vbnet", "vbnet")
            .AddRule("vb.rule1", "vb.rule1.internal")
            .AddRule("vb.rule2", "vb.rule2.internal");

            data.AddQualityProfile("test.profile", "cs")
            .AddProject("key");
            data.AddRuleToProfile("cs.rule1", "test.profile");

            data.AddQualityProfile("test.profile", "vbnet")
            .AddProject("key");
            data.AddRuleToProfile("vb.rule2", "test.profile");

            MockRoslynAnalyzerProvider mockAnalyzerProvider = new MockRoslynAnalyzerProvider();

            mockAnalyzerProvider.SettingsToReturn = new AnalyzerSettings();
            mockAnalyzerProvider.SettingsToReturn.RuleSetFilePath = "c:\\xxx.ruleset";

            MockTargetsInstaller mockTargetsInstaller = new MockTargetsInstaller();

            MockObjectFactory mockFactory = new MockObjectFactory(mockServer, mockTargetsInstaller, mockAnalyzerProvider);


            string[] validArgs = new string[] {
                "/k:key", "/n:name", "/v:1.0",
                "/d:cmd.line1=cmdline.value.1",
                "/d:sonar.host.url=http://host",
                "/d:sonar.log.level=INFO|DEBUG"
            };

            TeamBuildSettings settings;

            using (PreprocessTestUtils.CreateValidNonTeamBuildScope())
                using (new WorkingDirectoryScope(workingDir))
                {
                    settings = TeamBuildSettings.GetSettingsFromEnvironment(new TestLogger());
                    Assert.IsNotNull(settings, "Test setup error: TFS environment variables have not been set correctly");
                    Assert.AreEqual(BuildEnvironment.NotTeamBuild, settings.BuildEnvironment, "Test setup error: build environment was not set correctly");

                    TeamBuildPreProcessor preProcessor = new TeamBuildPreProcessor(mockFactory, logger);

                    // Act
                    bool success = preProcessor.Execute(validArgs);
                    Assert.IsTrue(success, "Expecting the pre-processing to complete successfully");
                }

            // Assert
            AssertDirectoryExists(settings.AnalysisBaseDirectory);
            AssertDirectoryExists(settings.SonarConfigDirectory);
            AssertDirectoryExists(settings.SonarOutputDirectory);
            // The bootstrapper is responsible for creating the bin directory

            mockTargetsInstaller.AssertsTargetsCopied();
            mockServer.AssertMethodCalled("GetProperties", 1);
            mockServer.AssertMethodCalled("GetInternalKeys", 2); // C# and VB

            logger.AssertErrorsLogged(0);
            logger.AssertWarningsLogged(0);
            logger.AssertVerbosity(LoggerVerbosity.Debug);

            AssertConfigFileExists(settings.AnalysisConfigFilePath);
            AnalysisConfig actualConfig = AnalysisConfig.Load(settings.AnalysisConfigFilePath);

            Assert.AreEqual("key", actualConfig.SonarProjectKey, "Unexpected project key");
            Assert.AreEqual("name", actualConfig.SonarProjectName, "Unexpected project name");
            Assert.AreEqual("1.0", actualConfig.SonarProjectVersion, "Unexpected project version");

            Assert.IsNotNull(actualConfig.AnalyzerSettings, "Analyzer settings should not be null");
            Assert.AreEqual("c:\\xxx.ruleset", actualConfig.AnalyzerSettings.RuleSetFilePath, "Unexpected ruleset path");

            AssertExpectedLocalSetting(SonarProperties.HostUrl, "http://host", actualConfig);
            AssertExpectedLocalSetting("cmd.line1", "cmdline.value.1", actualConfig);
            AssertExpectedServerSetting("server.key", "server value 1", actualConfig);

            string fxCopFilePath = AssertFileExists(settings.SonarConfigDirectory, TeamBuildPreProcessor.FxCopCSharpRuleset);

            PreProcessAsserts.AssertRuleSetContainsRules(fxCopFilePath, "cs.rule1");

            fxCopFilePath = AssertFileExists(settings.SonarConfigDirectory, TeamBuildPreProcessor.FxCopVBNetRuleset);
            PreProcessAsserts.AssertRuleSetContainsRules(fxCopFilePath, "vb.rule2");
        }
        private MockSonarQubeServer CreateServer(string projectKey, string profileName, WellKnownProfile profile)
        {
            ServerDataModel model = new ServerDataModel();

            // Add the required C# plugin and repository
            model.InstalledPlugins.Add(RoslynAnalyzerProvider.CSharpPluginKey);
            model.AddRepository(RoslynAnalyzerProvider.CSharpRepositoryKey, RoslynAnalyzerProvider.CSharpLanguage);

            // Add some dummy data
            model.InstalledPlugins.Add("unused");

            model.AddQualityProfile(profileName, "vb")
                .AddProject(projectKey)
                .AddProject(profileName)
                .SetExport(profile.Format, "Invalid content - this export should not be requested");

            // Create a C# quality profile for the supplied profile
            model.AddQualityProfile(profileName, RoslynAnalyzerProvider.CSharpLanguage)
                .AddProject(projectKey)
                .AddProject("dummy project3") // more dummy data - apply the quality profile to another dummy project
                .SetExport(profile.Format, profile.Content);

            MockSonarQubeServer server = new MockSonarQubeServer();
            server.Data = model;
            return server;
        }