예제 #1
0
        public void ProjectLoader_NonRecursive()
        {
            // 0. Setup
            var rootTestDir = TestUtils.CreateTestSpecificFolder(TestContext);
            var childDir    = Path.Combine(rootTestDir, "Child1");

            // Create a valid project in the child directory
            var validNonTestProject = new ProjectDescriptor()
            {
                ParentDirectoryPath = childDir,
                ProjectFolderName   = "validNonTestProjectDir",
                ProjectFileName     = "validNonTestproject.proj",
                ProjectGuid         = Guid.NewGuid(),
                IsTestProject       = false
            };

            validNonTestProject.AddCompileInputFile("ASourceFile.vb", true);
            validNonTestProject.AddCompileInputFile("AnotherSourceFile.vb", true);
            CreateFilesFromDescriptor(validNonTestProject, "CompileList.txt", null);

            // 1. Run against the root dir -> not expecting the project to be found
            IEnumerable <ProjectInfo> projects = SonarScanner.MSBuild.Shim.ProjectLoader.LoadFrom(rootTestDir);

            projects.Should().BeEmpty();

            // 2. Run against the child dir -> project should be found
            projects = SonarScanner.MSBuild.Shim.ProjectLoader.LoadFrom(childDir);
            projects.Should().ContainSingle();
        }
        public void ProjectLoader_NonRecursive()
        {
            // 0. Setup
            string rootTestDir = Path.Combine(this.TestContext.DeploymentDirectory, "ProjectLoader_NonRecursive");
            string childDir    = Path.Combine(rootTestDir, "Child1");

            // Create a valid project in the child directory
            ProjectDescriptor validNonTestProject = new ProjectDescriptor()
            {
                ParentDirectoryPath = childDir,
                ProjectFolderName   = "validNonTestProjectDir",
                ProjectFileName     = "validNonTestproject.proj",
                ProjectGuid         = Guid.NewGuid(),
                IsTestProject       = false
            };

            validNonTestProject.AddCompileInputFile("ASourceFile.vb", true);
            validNonTestProject.AddCompileInputFile("AnotherSourceFile.vb", true);
            CreateFilesFromDescriptor(validNonTestProject, "CompileList.txt", null);

            // 1. Run against the root dir -> not expecting the project to be found
            IEnumerable <ProjectInfo> projects = SonarScanner.Shim.ProjectLoader.LoadFrom(rootTestDir);

            Assert.AreEqual(0, projects.Count());

            // 2. Run against the child dir -> project should be found
            projects = SonarScanner.Shim.ProjectLoader.LoadFrom(childDir);
            Assert.AreEqual(1, projects.Count());
        }
        public void ProjectLoader()
        {
            // Arrange
            var testSourcePath = TestUtils.CreateTestSpecificFolder(TestContext);

            // Create sub-directories, some with project info XML files and some without
            TestUtils.EnsureTestSpecificFolder(TestContext, "EmptyDir1");

            var validTestProject = new ProjectDescriptor()
            {
                ParentDirectoryPath = testSourcePath,
                ProjectFolderName = "validTestProjectDir",
                ProjectFileName = "validTestProject.csproj",
                ProjectGuid = Guid.NewGuid(),
                IsTestProject = true
            };
            validTestProject.AddCompileInputFile("TestFile1.cs", true);
            validTestProject.AddCompileInputFile("TestFile1.cs", true);
            validTestProject.AddContentFile("contentFile1.js", true);
            CreateFilesFromDescriptor(validTestProject, "testCompileListFile", "testVisualStudioCodeCoverageReport");

            TestUtils.EnsureTestSpecificFolder(TestContext, "EmptyDir2");

            var validNonTestProject = new ProjectDescriptor()
            {
                ParentDirectoryPath = testSourcePath,
                ProjectFolderName = "validNonTestProjectDir",
                ProjectFileName = "validNonTestproject.proj",
                ProjectGuid = Guid.NewGuid(),
                IsTestProject = false
            };
            validNonTestProject.AddContentFile("ASourceFile.vb", true);
            validNonTestProject.AddContentFile("AnotherSourceFile.vb", true);
            CreateFilesFromDescriptor(validNonTestProject, "list.txt", "visualstudio-codecoverage.xml");

            var validNonTestNoReportsProject = new ProjectDescriptor()
            {
                ParentDirectoryPath = testSourcePath,
                ProjectFolderName = "validNonTestNoReportsProjectDir",
                ProjectFileName = "validNonTestNoReportsProject.proj",
                ProjectGuid = Guid.NewGuid(),
                IsTestProject = false
            };
            validNonTestNoReportsProject.AddContentFile("SomeFile.cs", true);
            CreateFilesFromDescriptor(validNonTestNoReportsProject, "SomeList.txt", null);

            // Act
            IEnumerable<ProjectInfo> projects = SonarScanner.MSBuild.Shim.ProjectLoader.LoadFrom(testSourcePath);

            // Assert
            Assert.AreEqual(3, projects.Count());

            AssertProjectResultExists(validTestProject.ProjectName, projects);

            AssertProjectResultExists(validNonTestProject.ProjectName, projects);

            AssertProjectResultExists(validNonTestNoReportsProject.ProjectName, projects);
        }
예제 #4
0
        private string AddEmptyAnalysedCodeFile(ProjectDescriptor descriptor, string projectFolder, string extension = "cs")
        {
            string filePath = CreateEmptyFile(projectFolder, extension);

            descriptor.AddCompileInputFile(filePath, true);
            return(filePath);
        }
예제 #5
0
        [TestCategory("E2E"), TestCategory("Targets")] // SONARMSBRU-104: files under the obj folder should be excluded from analysis
        public void E2E_IntermediateOutputFilesAreExcluded()
        {
            // Arrange
            string rootInputFolder  = TestUtils.CreateTestSpecificFolder(this.TestContext, "Inputs");
            string rootOutputFolder = TestUtils.CreateTestSpecificFolder(this.TestContext, "Outputs");

            // Create a new project
            ProjectDescriptor descriptor    = BuildUtilities.CreateValidProjectDescriptor(rootInputFolder);
            string            projectFolder = descriptor.FullDirectoryPath;

            // Add files that should be analysed
            string nonObjFolder = Path.Combine(projectFolder, "foo");

            Directory.CreateDirectory(nonObjFolder);
            AddEmptyAnalysedCodeFile(descriptor, rootInputFolder);
            AddEmptyAnalysedCodeFile(descriptor, nonObjFolder);

            // Add files under the obj folder that should not be analysed
            string objFolder     = Path.Combine(projectFolder, "obj");
            string objSubFolder1 = Path.Combine(objFolder, "debug");
            string objSubFolder2 = Path.Combine(objFolder, "xxx"); // any folder under obj should be ignored

            Directory.CreateDirectory(objSubFolder1);
            Directory.CreateDirectory(objSubFolder2);

            // File in obj
            string filePath = CreateEmptyFile(objFolder, "cs");

            descriptor.AddCompileInputFile(filePath, false);

            // File in obj\debug
            filePath = CreateEmptyFile(objSubFolder1, "cs");
            descriptor.AddCompileInputFile(filePath, false);

            // File in obj\xxx
            filePath = CreateEmptyFile(objSubFolder2, "vb");
            descriptor.AddCompileInputFile("obj\\xxx\\" + Path.GetFileName(filePath), false); // reference the file using a relative path

            WellKnownProjectProperties preImportProperties = CreateDefaultAnalysisProperties(rootInputFolder, rootOutputFolder);

            // Act
            string projectDir = CreateAndBuildSonarProject(descriptor, rootOutputFolder, preImportProperties);

            AssertFileExists(projectDir, ExpectedAnalysisFilesListFileName);

            CheckProjectOutputFolder(descriptor, projectDir);
        }