public void The_default_configuration_can_be_set_to_release() { TestProject project = new TestProject() { Name = "DirectoryBuildPropsTest", TargetFrameworks = "netstandard1.4", IsSdkProject = true }; var testAsset = _testAssetsManager.CreateTestProject(project); string directoryBuildPropsPath = Path.Combine(testAsset.Path, "Directory.Build.props"); var directoryBuildPropsContent = @" <Project> <PropertyGroup> <Configuration Condition="" '$(Configuration)' == '' "">Release</Configuration> </PropertyGroup> </Project> "; File.WriteAllText(directoryBuildPropsPath, directoryBuildPropsContent); var restoreCommand = testAsset.GetRestoreCommand(Log, project.Name); restoreCommand .Execute() .Should() .Pass(); string projectFolder = Path.Combine(testAsset.Path, project.Name); var buildCommand = new BuildCommand(Log, projectFolder); buildCommand .Execute() .Should() .Pass(); string GetPropertyValue(string propertyName) { var getValuesCommand = new GetValuesCommand(Log, projectFolder, project.TargetFrameworks, propertyName, GetValuesCommand.ValueType.Property) { Configuration = "Release" }; getValuesCommand .Execute() .Should() .Pass(); var values = getValuesCommand.GetValues(); values.Count.Should().Be(1); return(values[0]); } GetPropertyValue("Configuration").Should().Be("Release"); GetPropertyValue("Optimize").Should().Be("true"); }
public void When_TargetPlatformVersion_is_set_higher_than_10_It_can_reference_cswinrt_api() { const string ProjectName = "WindowsDesktopSdkTest_without_ProjectSdk_set"; const string tfm = "net5.0"; var testProject = new TestProject() { Name = ProjectName, TargetFrameworks = tfm, IsWinExe = true, }; testProject.SourceFiles.Add("Program.cs", _useCsWinrtApi); testProject.AdditionalProperties.Add("TargetPlatformIdentifier", "Windows"); testProject.AdditionalProperties.Add("TargetPlatformVersion", "10.0.17763"); var asset = _testAssetsManager.CreateTestProject(testProject); var buildCommand = new BuildCommand(Log, Path.Combine(asset.Path, ProjectName)); buildCommand.Execute() .Should() .Pass(); void Assert(DirectoryInfo outputDir) { outputDir.File("Microsoft.Windows.SDK.NET.dll").Exists.Should().BeTrue("The output has cswinrt dll"); outputDir.File("WinRT.Runtime.dll").Exists.Should().BeTrue("The output has cswinrt dll"); var runtimeconfigjson = File.ReadAllText(outputDir.File(ProjectName + ".runtimeconfig.json").FullName); runtimeconfigjson.Contains(@"""name"": ""Microsoft.NETCore.App""").Should().BeTrue("runtimeconfig.json only reference Microsoft.NETCore.App"); runtimeconfigjson.Contains("Microsoft.Windows.SDK.NET").Should().BeFalse("runtimeconfig.json does not reference windows SDK"); } Assert(buildCommand.GetOutputDirectory(tfm)); var publishCommand = new PublishCommand(asset); var runtimeIdentifier = "win-x64"; publishCommand.Execute("-p:SelfContained=true", $"-p:RuntimeIdentifier={runtimeIdentifier}") .Should() .Pass(); Assert(publishCommand.GetOutputDirectory(tfm, runtimeIdentifier: runtimeIdentifier)); var filesCopiedToPublishDirCommand = new GetValuesCommand( Log, Path.Combine(asset.Path, testProject.Name), testProject.TargetFrameworks, "FilesCopiedToPublishDir", GetValuesCommand.ValueType.Item) { DependsOnTargets = "ComputeFilesCopiedToPublishDir", MetadataNames = { "RelativePath" }, }; filesCopiedToPublishDirCommand.Execute().Should().Pass(); var filesCopiedToPublishDircommandItems = from item in filesCopiedToPublishDirCommand.GetValuesWithMetadata() select new { Identity = item.value, RelativePath = item.metadata["RelativePath"] }; filesCopiedToPublishDircommandItems .Should().Contain(i => i.RelativePath == "Microsoft.Windows.SDK.NET.dll" && Path.GetFileName(i.Identity) == "Microsoft.Windows.SDK.NET.dll", because: "wapproj should copy cswinrt dlls"); filesCopiedToPublishDircommandItems .Should() .Contain(i => i.RelativePath == "WinRT.Runtime.dll" && Path.GetFileName(i.Identity) == "WinRT.Runtime.dll", because: "wapproj should copy cswinrt dlls"); var publishItemsOutputGroupOutputsCommand = new GetValuesCommand( Log, Path.Combine(asset.Path, testProject.Name), testProject.TargetFrameworks, "PublishItemsOutputGroupOutputs", GetValuesCommand.ValueType.Item) { DependsOnTargets = "Publish", MetadataNames = { "OutputPath" }, }; publishItemsOutputGroupOutputsCommand.Execute().Should().Pass(); var publishItemsOutputGroupOutputsItems = from item in publishItemsOutputGroupOutputsCommand.GetValuesWithMetadata() select new { FullAssetPath = Path.GetFullPath(Path.Combine(asset.Path, testProject.Name, item.metadata["OutputPath"])) }; publishItemsOutputGroupOutputsItems .Should().Contain(i => Path.GetFileName(Path.GetFullPath(i.FullAssetPath)) == "WinRT.Runtime.dll" && File.Exists(i.FullAssetPath), because: (string)"as the replacement for FilesCopiedToPublishDir, wapproj should copy cswinrt dlls"); publishItemsOutputGroupOutputsItems .Should() .Contain(i => Path.GetFileName(Path.GetFullPath(i.FullAssetPath)) == "WinRT.Runtime.dll" && File.Exists(i.FullAssetPath), because: "as the replacement for FilesCopiedToPublishDir, wapproj should copy cswinrt dlls"); // ready to run is supported publishCommand.Execute("-p:SelfContained=true", $"-p:RuntimeIdentifier={runtimeIdentifier}", $"-p:PublishReadyToRun=true") .Should() .Pass(); // PublishSingleFile is supported publishCommand.Execute("-p:SelfContained=true", $"-p:RuntimeIdentifier={runtimeIdentifier}", $"-p:PublishSingleFile=true") .Should() .Pass(); }
public void It_uses_hintpath_when_replacing_simple_name_references(bool useFacades) { TestProject project = new TestProject() { Name = "NETFrameworkLibrary", TargetFrameworks = "net462", IsSdkProject = true }; if (useFacades) { var netStandard2Project = new TestProject() { Name = "NETStandard20Project", TargetFrameworks = "netstandard2.0", IsSdkProject = true }; project.ReferencedProjects.Add(netStandard2Project); } var testAsset = _testAssetsManager.CreateTestProject(project, "SimpleNamesWithHintPaths", identifier: useFacades ? "_useFacades" : "") .WithProjectChanges((path, p) => { if (Path.GetFileNameWithoutExtension(path) == project.Name) { var ns = p.Root.Name.Namespace; var itemGroup = new XElement(ns + "ItemGroup"); p.Root.Add(itemGroup); if (!useFacades) { itemGroup.Add(new XElement(ns + "PackageReference", new XAttribute("Include", "System.Net.Http"), new XAttribute("Version", "4.3.2"))); } itemGroup.Add(new XElement(ns + "Reference", new XAttribute("Include", "System.Net.Http"))); } }) .Restore(Log, project.Name); string projectFolder = Path.Combine(testAsset.Path, project.Name); var getValuesCommand = new GetValuesCommand(Log, projectFolder, project.TargetFrameworks, "Reference", GetValuesCommand.ValueType.Item); getValuesCommand.MetadataNames.Add("HintPath"); getValuesCommand .Execute() .Should() .Pass(); string correctHttpReference; if (useFacades) { string microsoftNETBuildExtensionsPath = TestContext.Current.ToolsetUnderTest.GetMicrosoftNETBuildExtensionsPath(Log); correctHttpReference = Path.Combine(microsoftNETBuildExtensionsPath, @"net461\lib\System.Net.Http.dll"); } else { correctHttpReference = Path.Combine(TestContext.Current.NuGetCachePath, "system.net.http", "4.3.2", "ref", "net46", "System.Net.Http.dll"); } var valuesWithMetadata = getValuesCommand.GetValuesWithMetadata(); // There shouldn't be a Reference item where the ItemSpec is the path to the System.Net.Http.dll from a NuGet package valuesWithMetadata.Should().NotContain(v => v.value == correctHttpReference); // There should be a Reference item where the ItemSpec is the simple name System.Net.Http valuesWithMetadata.Should().ContainSingle(v => v.value == "System.Net.Http"); // The Reference item with the simple name should have a HintPath to the DLL in the NuGet package valuesWithMetadata.Single(v => v.value == "System.Net.Http") .metadata["HintPath"] .Should().Be(correctHttpReference); }
public void It_provides_runtime_configuration_and_shadow_copy_files_via_outputgroup(string targetFramework) { if (targetFramework == "net5.0-windows" && !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { // net5.0-windows is windows only scenario return; } var projectRef = new TestProject { Name = "ReferencedProject", TargetFrameworks = targetFramework, }; var project = new TestProject { Name = "DesignerTest", IsExe = true, TargetFrameworks = targetFramework, PackageReferences = { new TestPackageReference("NewtonSoft.Json", "13.0.1") }, ReferencedProjects = { projectRef } }; var asset = _testAssetsManager .CreateTestProject(project, identifier: targetFramework); var command = new GetValuesCommand( Log, Path.Combine(asset.Path, project.Name), targetFramework, "DesignerRuntimeImplementationProjectOutputGroupOutput", GetValuesCommand.ValueType.Item) { DependsOnTargets = "DesignerRuntimeImplementationProjectOutputGroup", MetadataNames = { "TargetPath" }, }; command.Execute().Should().Pass(); var items = from item in command.GetValuesWithMetadata() select new { Identity = item.value, TargetPath = item.metadata["TargetPath"] }; string depsFile = null; string runtimeConfig = null; var otherFiles = new List <string>(); foreach (var item in items) { Path.IsPathFullyQualified(item.Identity).Should().BeTrue(); Path.GetFileName(item.Identity).Should().Be(item.TargetPath); switch (item.TargetPath) { case "DesignerTest.designer.deps.json": depsFile = item.Identity; break; case "DesignerTest.designer.runtimeconfig.json": runtimeConfig = item.Identity; break; default: otherFiles.Add(item.TargetPath); break; } } switch (targetFramework) { case "netcoreapp3.0": case "net5.0-windows": var depsFileLibraries = GetRuntimeLibraryFileNames(depsFile); depsFileLibraries.Should().BeEquivalentTo(new[] { "Newtonsoft.Json.dll" }); var options = GetRuntimeOptions(runtimeConfig); options["configProperties"]["Microsoft.NETCore.DotNetHostPolicy.SetAppPaths"].Value <bool>().Should().BeTrue(); // runtimeconfiguration should not have platform. // it should be net5.0 instead of net5.0-windows options["tfm"].Value <string>().Should().Be(targetFramework.Split('-')[0]); options["additionalProbingPaths"].Value <JArray>().Should().NotBeEmpty(); otherFiles.Should().BeEquivalentTo(new[] { "ReferencedProject.dll", "ReferencedProject.pdb" }); break; case "net46": depsFile.Should().BeNull(); runtimeConfig.Should().BeNull(); otherFiles.Should().BeEquivalentTo(new[] { "Newtonsoft.Json.dll", "ReferencedProject.dll", "ReferencedProject.pdb" }); break; } }
public void It_publishes_the_project_with_a_refs_folder_and_correct_deps_file(string appTargetFramework, string libraryTargetFramework, bool withoutCopyingRefs) { if (appTargetFramework == "net46" && !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { return; } var testLibraryProject = new TestProject() { Name = "TestLibrary", IsSdkProject = true, TargetFrameworks = libraryTargetFramework }; var testProject = new TestProject() { Name = "TestApp", IsSdkProject = true, IsExe = true, TargetFrameworks = appTargetFramework, RuntimeIdentifier = "win7-x86" }; testProject.AdditionalProperties["PreserveCompilationContext"] = "true"; if (withoutCopyingRefs) { testProject.AdditionalProperties["PreserveCompilationReferences"] = "false"; } testProject.ReferencedProjects.Add(testLibraryProject); testProject.PackageReferences.Add(new TestPackageReference("Newtonsoft.Json", "9.0.1")); testProject.PackageReferences.Add(new TestPackageReference("System.Data.SqlClient", "4.4.3")); var testAsset = _testAssetsManager.CreateTestProject(testProject, identifier: appTargetFramework + withoutCopyingRefs); var appProjectDirectory = Path.Combine(testAsset.TestRoot, "TestApp"); var getValuesCommand = new GetValuesCommand(Log, appProjectDirectory, testProject.TargetFrameworks, "LangVersion"); getValuesCommand.Execute().Should().Pass(); var langVersion = getValuesCommand.GetValues().FirstOrDefault() ?? string.Empty; var publishCommand = new PublishCommand(Log, appProjectDirectory); publishCommand .Execute() .Should() .Pass(); var publishDirectory = publishCommand.GetOutputDirectory(appTargetFramework, runtimeIdentifier: "win7-x86"); publishDirectory.Should().HaveFiles(new[] { appTargetFramework == "net46" ? "TestApp.exe" : "TestApp.dll", "TestLibrary.dll", "Newtonsoft.Json.dll" }); var refsDirectory = new DirectoryInfo(Path.Combine(publishDirectory.FullName, "refs")); if (withoutCopyingRefs) { refsDirectory.Should().NotExist(); } else { // Should have compilation time assemblies refsDirectory.Should().HaveFile("System.IO.dll"); // Libraries in which lib==ref should be deduped refsDirectory.Should().NotHaveFile("TestLibrary.dll"); refsDirectory.Should().NotHaveFile("Newtonsoft.Json.dll"); } using (var depsJsonFileStream = File.OpenRead(Path.Combine(publishDirectory.FullName, "TestApp.deps.json"))) { var dependencyContext = new DependencyContextJsonReader().Read(depsJsonFileStream); string[] expectedDefines; if (appTargetFramework == "net46") { expectedDefines = new[] { "DEBUG", "TRACE", "NETFRAMEWORK", "NET46" }; } else { expectedDefines = new[] { "DEBUG", "TRACE", "NETCOREAPP", appTargetFramework.ToUpperInvariant().Replace('.', '_') }; } dependencyContext.CompilationOptions.Defines.Should().BeEquivalentTo(expectedDefines); dependencyContext.CompilationOptions.LanguageVersion.Should().Be(langVersion); dependencyContext.CompilationOptions.Platform.Should().Be("x86"); dependencyContext.CompilationOptions.Optimize.Should().Be(false); dependencyContext.CompilationOptions.KeyFile.Should().Be(""); dependencyContext.CompilationOptions.EmitEntryPoint.Should().Be(true); dependencyContext.CompilationOptions.DebugType.Should().Be("portable"); var compileLibraryAssemblyNames = dependencyContext.CompileLibraries.SelectMany(cl => cl.Assemblies) .Select(a => a.Split('/').Last()) .Distinct().ToList(); var expectedCompileLibraryNames = CompileLibraryNames[appTargetFramework].Split(new char[] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries); var extraCompileLibraryNames = compileLibraryAssemblyNames.Except(expectedCompileLibraryNames).ToList(); var missingCompileLibraryNames = expectedCompileLibraryNames.Except(compileLibraryAssemblyNames).ToList(); if (extraCompileLibraryNames.Any()) { Log.WriteLine("Unexpected compile libraries: " + string.Join(' ', extraCompileLibraryNames)); } if (missingCompileLibraryNames.Any()) { Log.WriteLine("Missing compile libraries: " + string.Join(' ', missingCompileLibraryNames)); } compileLibraryAssemblyNames.Should().BeEquivalentTo(expectedCompileLibraryNames); // Ensure P2P references are specified correctly var testLibrary = dependencyContext .CompileLibraries .FirstOrDefault(l => string.Equals(l.Name, "testlibrary", StringComparison.OrdinalIgnoreCase)); testLibrary.Assemblies.Count.Should().Be(1); testLibrary.Assemblies[0].Should().Be("TestLibrary.dll"); // Ensure framework references are specified correctly if (appTargetFramework == "net46") { var mscorlibLibrary = dependencyContext .CompileLibraries .FirstOrDefault(l => string.Equals(l.Name, "mscorlib", StringComparison.OrdinalIgnoreCase)); mscorlibLibrary.Assemblies.Count.Should().Be(1); mscorlibLibrary.Assemblies[0].Should().Be(".NETFramework/v4.6/mscorlib.dll"); var systemCoreLibrary = dependencyContext .CompileLibraries .FirstOrDefault(l => string.Equals(l.Name, "system.core", StringComparison.OrdinalIgnoreCase)); systemCoreLibrary.Assemblies.Count.Should().Be(1); systemCoreLibrary.Assemblies[0].Should().Be(".NETFramework/v4.6/System.Core.dll"); var systemCollectionsLibrary = dependencyContext .CompileLibraries .FirstOrDefault(l => string.Equals(l.Name, "system.collections.reference", StringComparison.OrdinalIgnoreCase)); systemCollectionsLibrary.Assemblies.Count.Should().Be(1); systemCollectionsLibrary.Assemblies[0].Should().Be(".NETFramework/v4.6/Facades/System.Collections.dll"); } } }
public void It_implicitly_defines_compilation_constants_for_the_target_framework(string targetFramework, string[] expectedDefines, bool buildOnlyOnWindows) { bool shouldCompile = true; var testAsset = _testAssetsManager .CopyTestAsset("AppWithLibrary", "ImplicitFrameworkConstants", targetFramework) .WithSource() .WithProjectChanges(project => { // Update target framework in project var ns = project.Root.Name.Namespace; var targetFrameworkProperties = project.Root .Elements(ns + "PropertyGroup") .Elements(ns + "TargetFramework") .ToList(); targetFrameworkProperties.Count.Should().Be(1); if (targetFramework.Contains(",Version=")) { // We use the full TFM for frameworks we don't have built-in support for targeting, so we don't want to run the Compile target shouldCompile = false; var frameworkName = new FrameworkName(targetFramework); var targetFrameworkProperty = targetFrameworkProperties.Single(); targetFrameworkProperty.AddBeforeSelf(new XElement(ns + "TargetFrameworkIdentifier", frameworkName.Identifier)); targetFrameworkProperty.AddBeforeSelf(new XElement(ns + "TargetFrameworkVersion", "v" + frameworkName.Version.ToString())); if (!string.IsNullOrEmpty(frameworkName.Profile)) { targetFrameworkProperty.AddBeforeSelf(new XElement(ns + "TargetFrameworkProfile", frameworkName.Profile)); } // For the NuGet restore task to work with package references, it needs the TargetFramework property to be set. // Otherwise we would just remove the property. targetFrameworkProperty.SetValue(targetFramework); } else { shouldCompile = true; targetFrameworkProperties.Single().SetValue(targetFramework); } }) .Restore(Log, relativePath: "TestLibrary"); if (buildOnlyOnWindows && !RuntimeInformation.IsOSPlatform(OSPlatform.Windows)) { shouldCompile = false; } var libraryProjectDirectory = Path.Combine(testAsset.TestRoot, "TestLibrary"); var getValuesCommand = new GetValuesCommand(Log, libraryProjectDirectory, targetFramework, "DefineConstants") { ShouldCompile = shouldCompile }; getValuesCommand .Execute() .Should() .Pass(); var definedConstants = getValuesCommand.GetValues(); definedConstants.Should().BeEquivalentTo(new[] { "DEBUG", "TRACE" }.Concat(expectedDefines).ToArray()); }
public void ResolvedFrameworkReferences_are_generated() { var testProject = new TestProject() { Name = "ResolvedFrameworkReferenceTest", IsSdkProject = true, IsExe = true, TargetFrameworks = "netcoreapp3.0", RuntimeIdentifier = EnvironmentInfo.GetCompatibleRid() }; testProject.FrameworkReferences.Add("Microsoft.AspNetCore.App"); testProject.FrameworkReferences.Add("Microsoft.WindowsDesktop.App"); var testAsset = _testAssetsManager.CreateTestProject(testProject) .Restore(Log, testProject.Name); var projectFolder = Path.Combine(testAsset.TestRoot, testProject.Name); var buildCommand = new BuildCommand(Log, projectFolder); var expectedMetadata = new[] { "OriginalItemSpec", "IsImplicitlyDefined", "TargetingPackName", "TargetingPackVersion", "TargetingPackPath", "RuntimePackName", "RuntimePackVersion", "RuntimePackPath" }; var getValuesCommand = new GetValuesCommand(Log, projectFolder, testProject.TargetFrameworks, "ResolvedFrameworkReference", GetValuesCommand.ValueType.Item); getValuesCommand.DependsOnTargets = "ResolveFrameworkReferences"; getValuesCommand.MetadataNames.AddRange(expectedMetadata); getValuesCommand.Execute().Should().Pass(); var resolvedFrameworkReferences = getValuesCommand.GetValuesWithMetadata(); resolvedFrameworkReferences.Select(rfr => rfr.value) .Should() .BeEquivalentTo( "Microsoft.NETCore.App", "Microsoft.AspNetCore.App", "Microsoft.WindowsDesktop.App"); foreach (var resolvedFrameworkReference in resolvedFrameworkReferences) { foreach (var expectedMetadataName in expectedMetadata) { if (expectedMetadataName == "IsImplicitlyDefined" && resolvedFrameworkReference.value != "Microsoft.NETCore.App") { continue; } resolvedFrameworkReference.metadata[expectedMetadataName] .Should() .NotBeNullOrEmpty(because: $"ResolvedFrameworkReference for {resolvedFrameworkReference.value} should have " + $"{expectedMetadataName} metadata"); } } }
public void TestPreviewFeatures(bool enablePreviewFeatures, bool generateRequiresPreviewFeaturesAttribute, string targetFramework) { var testAsset = _testAssetsManager .CopyTestAsset("HelloWorld", identifier: $"{enablePreviewFeatures}${generateRequiresPreviewFeaturesAttribute}${targetFramework}") .WithSource() .WithTargetFramework(targetFramework) .WithProjectChanges((path, project) => { var ns = project.Root.Name.Namespace; project.Root.Add( new XElement(ns + "PropertyGroup", new XElement(ns + "EnablePreviewFeatures", $"{enablePreviewFeatures}"))); if (enablePreviewFeatures && !generateRequiresPreviewFeaturesAttribute) { project.Root.Add( new XElement(ns + "PropertyGroup", new XElement(ns + "GenerateRequiresPreviewFeaturesAttribute", $"False"))); } }); var buildCommand = new BuildCommand(testAsset); buildCommand.Execute().Should().Pass(); var assemblyPath = Path.Combine(buildCommand.GetOutputDirectory(targetFramework).FullName, "HelloWorld.dll"); var parameterlessAttributes = AssemblyInfo.GetParameterlessAttributes(assemblyPath); bool contains = false; foreach (var attribute in parameterlessAttributes) { if (attribute.Equals("RequiresPreviewFeaturesAttribute", System.StringComparison.Ordinal)) { contains = true; break; } } var getValuesCommand = new GetValuesCommand(testAsset, "LangVersion", targetFramework: targetFramework); getValuesCommand.Execute().Should().Pass(); var values = getValuesCommand.GetValues(); var langVersion = values.FirstOrDefault() ?? string.Empty; if (enablePreviewFeatures && generateRequiresPreviewFeaturesAttribute) { if (targetFramework == ToolsetInfo.CurrentTargetFramework) { Assert.Equal("Preview", langVersion); Assert.True(contains); } else { // The assembly level attribute is generated only for the latest TFM for the given sdk Assert.False(contains); Assert.NotEqual("Preview", langVersion); } } if (!generateRequiresPreviewFeaturesAttribute) { Assert.False(contains); } }
public void It_resolves_runtimepack_from_packs_folder() { var testProject = new TestProject() { IsExe = true, TargetFrameworks = "net6.0", RuntimeIdentifier = EnvironmentInfo.GetCompatibleRid() }; // Use separate packages download folder for this project so that we can verify whether it had to download runtime packs testProject.AdditionalProperties["RestorePackagesPath"] = @"$(MSBuildProjectDirectory)\packages"; var testAsset = _testAssetsManager.CreateTestProject(testProject); var getValuesCommand = new GetValuesCommand(testAsset, "RuntimePack", GetValuesCommand.ValueType.Item); getValuesCommand.MetadataNames = new List <string>() { "NuGetPackageId", "NuGetPackageVersion" }; getValuesCommand.DependsOnTargets = "ProcessFrameworkReferences"; getValuesCommand.ShouldRestore = false; getValuesCommand.Execute() .Should() .Pass(); var runtimePacks = getValuesCommand.GetValuesWithMetadata(); var packageDownloadProject = new TestProject() { Name = "PackageDownloadProject", TargetFrameworks = testProject.TargetFrameworks }; // Add PackageDownload items for runtime packs which will be needed foreach (var runtimePack in runtimePacks) { packageDownloadProject.AddItem("PackageDownload", new Dictionary <string, string>() { { "Include", runtimePack.metadata["NuGetPackageId"] }, { "Version", "[" + runtimePack.metadata["NuGetPackageVersion"] + "]" } }); } // Download runtime packs into separate folder under test assets packageDownloadProject.AdditionalProperties["RestorePackagesPath"] = @"$(MSBuildProjectDirectory)\packs"; var packageDownloadAsset = _testAssetsManager.CreateTestProject(packageDownloadProject); new RestoreCommand(packageDownloadAsset) .Execute() .Should() .Pass(); // Package download folders use lowercased package names, but pack folders use mixed case // So change casing of the downloaded runtime pack folders to match what is expected // for packs folders foreach (var runtimePack in runtimePacks) { string oldCasing = Path.Combine(packageDownloadAsset.TestRoot, packageDownloadProject.Name, "packs", runtimePack.metadata["NuGetPackageId"].ToLowerInvariant()); string newCasing = Path.Combine(packageDownloadAsset.TestRoot, packageDownloadProject.Name, "packs", runtimePack.metadata["NuGetPackageId"]); Directory.Move(oldCasing, newCasing); } // Now build the original test project with the packs folder with the runtime packs we just downloaded var buildCommand = new BuildCommand(testAsset) .WithEnvironmentVariable(EnvironmentVariableNames.WORKLOAD_PACK_ROOTS, Path.Combine(packageDownloadAsset.TestRoot, packageDownloadProject.Name)); buildCommand .Execute() .Should() .Pass(); // Verify that runtime packs weren't downloaded to test project's packages folder var packagesFolder = Path.Combine(testAsset.TestRoot, testProject.Name, "packages"); foreach (var runtimePack in runtimePacks) { var path = Path.Combine(packagesFolder, runtimePack.metadata["NuGetPackageId"].ToLowerInvariant()); new DirectoryInfo(path).Should().NotExist("Runtime Pack should have been resolved from packs folder"); } }
public void It_resolves_analyzers_correctly(string language, string testAssetName) { var asset = _testAssetsManager .CopyTestAsset(testAssetName, identifier: language) .WithSource() .WithProjectChanges(project => { var ns = project.Root.Name.Namespace; project.Root.Add( new XElement(ns + "ItemGroup", new XElement(ns + "PackageReference", new XAttribute("Include", "Microsoft.DependencyValidation.Analyzers"), new XAttribute("Version", "0.9.0")), new XElement(ns + "PackageReference", new XAttribute("Include", "Microsoft.CodeQuality.Analyzers"), new XAttribute("Version", "2.6.0")))); }); var command = new GetValuesCommand( Log, Path.Combine(asset.Path, "TestApp"), "netcoreapp1.1", "Analyzer", GetValuesCommand.ValueType.Item); command.Execute().Should().Pass(); var analyzers = command.GetValues(); List <string> nugetRoots = new List <string>() { TestContext.Current.NuGetCachePath, Path.Combine(FileConstants.UserProfileFolder, ".dotnet", "NuGetFallbackFolder") }; string RelativeNuGetPath(string absoluteNuGetPath) { foreach (var nugetRoot in nugetRoots) { if (absoluteNuGetPath.StartsWith(nugetRoot + Path.DirectorySeparatorChar)) { return(absoluteNuGetPath.Substring(nugetRoot.Length + 1) .Replace(Path.DirectorySeparatorChar, '/')); } } throw new InvalidDataException("Expected path to be under a NuGet root: " + absoluteNuGetPath); } switch (language) { case "C#": analyzers.Select(RelativeNuGetPath).Should().BeEquivalentTo( "microsoft.codeanalysis.analyzers/1.1.0/analyzers/dotnet/cs/Microsoft.CodeAnalysis.Analyzers.dll", "microsoft.codeanalysis.analyzers/1.1.0/analyzers/dotnet/cs/Microsoft.CodeAnalysis.CSharp.Analyzers.dll", "microsoft.codequality.analyzers/2.6.0/analyzers/dotnet/cs/Microsoft.CodeQuality.Analyzers.dll", "microsoft.codequality.analyzers/2.6.0/analyzers/dotnet/cs/Microsoft.CodeQuality.CSharp.Analyzers.dll", "microsoft.dependencyvalidation.analyzers/0.9.0/analyzers/dotnet/Microsoft.DependencyValidation.Analyzers.dll" ); break; case "VB": analyzers.Select(RelativeNuGetPath).Should().BeEquivalentTo( "microsoft.codeanalysis.analyzers/1.1.0/analyzers/dotnet/vb/Microsoft.CodeAnalysis.Analyzers.dll", "microsoft.codeanalysis.analyzers/1.1.0/analyzers/dotnet/vb/Microsoft.CodeAnalysis.VisualBasic.Analyzers.dll", "microsoft.codequality.analyzers/2.6.0/analyzers/dotnet/vb/Microsoft.CodeQuality.Analyzers.dll", "microsoft.codequality.analyzers/2.6.0/analyzers/dotnet/vb/Microsoft.CodeQuality.VisualBasic.Analyzers.dll", "microsoft.dependencyvalidation.analyzers/0.9.0/analyzers/dotnet/Microsoft.DependencyValidation.Analyzers.dll" ); break; case "F#": analyzers.Should().BeEmpty(); break; default: throw new ArgumentOutOfRangeException(nameof(language)); } }