예제 #1
0
 private static ResolvePackageDependencies GetExecutedTaskFromContents(string lockFileContents, out LockFile lockFile, bool emitLegacyAssetsFileItems = true, string target = null)
 {
     lockFile = TestLockFiles.CreateLockFile(lockFileContents);
     return(GetExecutedTask(lockFile, emitLegacyAssetsFileItems, target));
 }
예제 #2
0
        public void ItFiltersAnalyzersByProjectLanguage()
        {
            string projectLanguage = "C#";

            // expected included analyzers
            string[] expectIncluded = new string[] {
                "analyzers/dotnet/IncludedAlpha.dll",
                "analyzers/dotnet/cs/IncludedBeta.dll",
                "analyzers/dotnet/cs/vb/IncludedChi.dll",
            };

            // expected excluded files
            string[] expectExcluded = new string[] {
                "analyzers/dotnet/vb/ExcludedAlpha.dll",
                "analyzers/dotnet/ExcludedBeta.txt",
                "analyzers/dotnet/cs/ExcludedChi.txt",
                "dotnet/ExcludedDelta.dll",
                "dotnet/cs/ExcludedEpsilon.dll"
            };

            var libCFiles = new List <string>()
            {
                "lib/file/G.dll", "lib/file/H.dll", "lib/file/I.dll"
            };

            libCFiles.AddRange(expectIncluded);
            libCFiles.AddRange(expectExcluded);

            string libCDefn = CreateLibrary("LibC/1.2.3", "package", libCFiles.ToArray());

            string lockFileContent = CreateLockFileSnippet(
                targets: new string[] {
                CreateTarget(".NETCoreApp,Version=v1.0", TargetLibA, TargetLibB, TargetLibC),
                CreateTarget(".NETCoreApp,Version=v1.0/osx.10.11-x64", TargetLibB, TargetLibC),
            },
                libraries: new string[] {
                LibADefn, LibBDefn, libCDefn
            },
                projectFileDependencyGroups: new string[] { ProjectGroup, NETCoreGroup, NETCoreOsxGroup }
                );

            LockFile lockFile = TestLockFiles.CreateLockFile(lockFileContent);
            var      task     = new ResolvePackageDependencies(lockFile, new MockPackageResolver())
            {
                ProjectAssetsFile         = lockFile.Path,
                ProjectPath               = null,
                ProjectLanguage           = projectLanguage, // set language
                EmitLegacyAssetsFileItems = true
            };

            task.Execute().Should().BeTrue();

            IEnumerable <ITaskItem> fileDefns;

            fileDefns = task.FileDefinitions
                        .Where(t => t.GetMetadata(MetadataKeys.Type) == "AnalyzerAssembly");
            fileDefns.Count().Should().Be(3);

            var expectedTargets = new string[] {
                "netcoreapp1.0",
                "netcoreapp1.0/osx.10.11-x64"
            };

            foreach (var analyzer in expectIncluded)
            {
                var fileKey = $"LibC/1.2.3/{analyzer}";
                var item    = task.FileDefinitions.Where(t => t.ItemSpec == fileKey).First();
                item.GetMetadata(MetadataKeys.Type).Should().Be("AnalyzerAssembly");
                item.GetMetadata(MetadataKeys.Path).Should().Be(analyzer);

                // expect two file dependencies for each, one per target
                var fileDeps = task.FileDependencies.Where(t => t.ItemSpec == fileKey);

                fileDeps.Count().Should().Be(2);

                fileDeps.Select(f => f.GetMetadata(MetadataKeys.ParentTarget))
                .Should().Contain(expectedTargets);

                fileDeps.All(f => f.GetMetadata(MetadataKeys.ParentPackage) == "LibC/1.2.3");
            }

            foreach (var otherFile in expectExcluded)
            {
                var fileKey = $"LibC/1.2.3/{otherFile}";
                var item    = task.FileDefinitions.Where(t => t.ItemSpec == fileKey).First();
                item.GetMetadata(MetadataKeys.Type).Should().NotBe("AnalyzerAssembly");

                // expect no file dependencies for each
                task.FileDependencies.Where(t => t.ItemSpec == fileKey)
                .Should().BeEmpty();
            }
        }
 private ResolvePackageDependencies GetExecutedTaskFromContents(string lockFileContents, out LockFile lockFile)
 {
     lockFile = TestLockFiles.CreateLockFile(lockFileContents);
     return(GetExecutedTask(lockFile));
 }
예제 #4
0
        public void ItAddsAnalyzerMetadataAndFileDependencies()
        {
            string projectLanguage = "VB";

            string libCDefn = CreateLibrary("LibC/1.2.3", "package",
                                            "lib/file/G.dll", "lib/file/H.dll", "lib/file/I.dll",
                                            "analyzers/dotnet/cs/Microsoft.CodeAnalysis.Analyzers.dll",
                                            "analyzers/dotnet/cs/Microsoft.CodeAnalysis.CSharp.Analyzers.dll",
                                            "analyzers/dotnet/vb/Microsoft.CodeAnalysis.Analyzers.dll",
                                            "analyzers/dotnet/vb/Microsoft.CodeAnalysis.VisualBasic.Analyzers.dll",
                                            "analyzers/dotnet/cs/Microsoft.CodeAnalysis.CSharp.Analyzers.txt", // not analyzer
                                            "lib/file/Microsoft.CodeAnalysis.VisualBasic.Analyzers.dll"        // not analyzer
                                            );

            string lockFileContent = CreateLockFileSnippet(
                targets: new string[] {
                CreateTarget(".NETCoreApp,Version=v1.0", TargetLibA, TargetLibB, TargetLibC),
                CreateTarget(".NETCoreApp,Version=v1.0/osx.10.11-x64", TargetLibB, TargetLibC),
            },
                libraries: new string[] {
                LibADefn, LibBDefn, libCDefn
            },
                projectFileDependencyGroups: new string[] { ProjectGroup, NETCoreGroup, NETCoreOsxGroup }
                );

            LockFile lockFile = TestLockFiles.CreateLockFile(lockFileContent);
            var      task     = new ResolvePackageDependencies(lockFile, new MockPackageResolver())
            {
                ProjectAssetsFile         = lockFile.Path,
                ProjectPath               = null,
                ProjectLanguage           = projectLanguage, // set language
                EmitLegacyAssetsFileItems = true
            };

            task.Execute().Should().BeTrue();

            IEnumerable <ITaskItem> fileDefns;

            fileDefns = task.FileDefinitions
                        .Where(t => t.GetMetadata(MetadataKeys.Type) == "AnalyzerAssembly");
            fileDefns.Count().Should().Be(2);

            var analyzers = new string[] {
                "analyzers/dotnet/vb/Microsoft.CodeAnalysis.Analyzers.dll",
                "analyzers/dotnet/vb/Microsoft.CodeAnalysis.VisualBasic.Analyzers.dll",
            };
            var expectedTargets = new string[] {
                "netcoreapp1.0",
                "netcoreapp1.0/osx.10.11-x64"
            };

            foreach (var analyzer in analyzers)
            {
                var fileKey = $"LibC/1.2.3/{analyzer}";
                var item    = task.FileDefinitions.Where(t => t.ItemSpec == fileKey).First();
                item.GetMetadata(MetadataKeys.Type).Should().Be("AnalyzerAssembly");
                item.GetMetadata(MetadataKeys.Path).Should().Be(analyzer);

                // expect two file dependencies for each, one per target
                var fileDeps = task.FileDependencies.Where(t => t.ItemSpec == fileKey);

                fileDeps.Count().Should().Be(2);

                fileDeps.Select(f => f.GetMetadata(MetadataKeys.ParentTarget))
                .Should().Contain(expectedTargets);

                fileDeps.All(f => f.GetMetadata(MetadataKeys.ParentPackage) == "LibC/1.2.3");
            }
        }
예제 #5
0
        private ReportAssetsLogMessages GetExecutedTaskFromContents(string lockFileContents, MockLog logger)
        {
            var lockFile = TestLockFiles.CreateLockFile(lockFileContents);

            return(GetExecutedTask(lockFile, logger));
        }