public static void AllReferencesHaveCorrectIsFrameworkReferenceProperty()
{
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.FluentAssertions,
targetMoniker: ".NETFramework,Version=v4.5.2",
runtimeIdentifier: "");
var references = result.References.ToDictionary(
r => r.ItemSpec,
r => r.GetMetadata(ResolveNuGetPackageAssets.NuGetIsFrameworkReference)
);
AssertHelpers.AssertCountOf(4, result.References);
var corePath = Path.Combine(result.ReferenceTemporaryPath, @"FluentAssertions\3.4.1\lib\net45\FluentAssertions.Core.dll");
Assert.True(references.ContainsKey(corePath));
Assert.Equal("false", references[corePath]);
var mainPath = Path.Combine(result.ReferenceTemporaryPath, @"FluentAssertions\3.4.1\lib\net45\FluentAssertions.dll");
Assert.True(references.ContainsKey(mainPath));
Assert.Equal("false", references[mainPath]);
Assert.Equal("true", references["System.Xml"]);
Assert.Equal("true", references["System.Xml.Linq"]);
}
public static void TestTargetPathCollisionsFound2()
{
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.Win10_xunit,
targetMoniker: ".NETCore,Version=v5.0",
runtimeIdentifier: "win10-x86");
AssertHelpers.AssertConsistentTargetPaths(result.CopyLocalItems);
}
public static void ProjectsNotIncludedInReferences()
{
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.ProjectDependency,
targetMoniker: ".NETFramework,Version=v4.5.2",
runtimeIdentifier: "win");
Assert.DoesNotContain("ClassLibrary1", result.ReferencedPackages.Select(t => t.ItemSpec));
}
public static void TestAnalyzerResolutionVisualBasic()
{
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.analyzers,
targetMoniker: ".NETCore,Version=v5.0",
runtimeIdentifier: "",
projectLanguage: "vb");
AssertHelpers.AssertCountOf(8, result.Analyzers);
}
public void ResolveWithLockFileWithPackageFolders()
{
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.LockFileWithWithSpecifiedPackageFolders,
".NETFramework,Version=v4.5",
runtimeIdentifier: null,
createTemporaryFolderForPackages: false);
Assert.Equal(@"C:\PackageFolder\Newtonsoft.Json\8.0.3\lib\net45\Newtonsoft.Json.dll", result.References.Single().ItemSpec);
}
public static void TestReferenceResolutionWithNoRuntimeID()
{
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.Win10,
targetMoniker: ".NETCore,Version=v5.0",
runtimeIdentifier: "");
// We should still have references, but no copy local
AssertHelpers.AssertCountOf(101, result.References);
AssertHelpers.AssertCountOf(0, result.CopyLocalItems);
}
public static void TestReferenceResolutionWithRuntimeIDWin10X64Aot()
{
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.Win10,
targetMoniker: ".NETCore,Version=v5.0",
runtimeIdentifier: "win10-x64-aot");
AssertHelpers.AssertCountOf(101, result.References);
AssertHelpers.AssertCountOf(141, result.CopyLocalItems);
AssertHelpers.AssertNoTargetPaths(result.CopyLocalItems);
}
public static void PackagesHaveMetadataWithPackageIdAndVersion()
{
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.Win10,
targetMoniker: ".NETCore,Version=v5.0",
runtimeIdentifier: "win10-x86");
var immutableCopyLocalitem = result.CopyLocalItems.Single(i => i.ItemSpec.EndsWith("System.Collections.Immutable.dll"));
Assert.Equal("System.Collections.Immutable", immutableCopyLocalitem.GetMetadata(ResolveNuGetPackageAssets.NuGetPackageIdMetadata));
Assert.Equal("1.1.36", immutableCopyLocalitem.GetMetadata(ResolveNuGetPackageAssets.NuGetPackageVersionMetadata));
}
public static void TestReferenceResolutionWithMissingTargetFrameworkAndFallback()
{
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.Win10,
targetMoniker: "MissingFrameworkMoniker,Version=v42.0",
runtimeIdentifier: "",
allowFallbackOnTargetSelection: true);
// We should still have references. Since we have no runtime ID, we should have no copy local items
AssertHelpers.AssertCountOf(101, result.References);
AssertHelpers.AssertCountOf(0, result.CopyLocalItems);
}
public static void AllPackageReferencesAreMarkedAsSuch()
{
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.FluentAssertions,
targetMoniker: ".NETFramework,Version=v4.5.2",
runtimeIdentifier: "",
includeFrameworkReferences: true);
// We should have references to the package itself plus framework packages
AssertHelpers.AssertCountOf(4, result.References);
Assert.All(result.References, r => Assert.Equal(ResolveNuGetPackageAssets.NuGetSourceType_Package, r.GetMetadata(ResolveNuGetPackageAssets.NuGetSourceType)));
}
public static void TestReferenceResolutionWithMissingRuntimeIDAndNoFallback()
{
var exception = Assert.Throws <ExceptionFromResource>(() =>
NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.Win10,
targetMoniker: ".NETCore,Version=v5.0",
runtimeIdentifier: "missing-runtime-identifier",
allowFallbackOnTargetSelection: false));
Assert.Equal(nameof(Strings.MissingRuntimeInRuntimesSection), exception.ResourceName);
Assert.Equal(new[] { "missing-runtime-identifier", "\"missing-runtime-identifier\": { }" }, exception.MessageArgs);
}
public static void FrameworkReferencesAreNotProvidedIfAlreadyProvidedByAnotherPackage()
{
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.FluentAssertionsAndWin10,
targetMoniker: "UAP,Version=v10.0",
runtimeIdentifier: "",
includeFrameworkReferences: true);
// There should be exactly one reference to System.Xml.dll, and no other references
Assert.Single(result.References.Where(r => r.ItemSpec.EndsWith("System.Xml.dll")));
Assert.Empty(result.References.Where(r => r.ItemSpec == "System.Xml"));
}
public static void TestReferenceResolutionWithMissingRuntimeIDAndFallback()
{
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.Win10,
targetMoniker: ".NETCore,Version=v5.0",
runtimeIdentifier: "missing-runtime-identifier",
allowFallbackOnTargetSelection: true);
// We should still have references. We'll assert that CopyLocalItems contains something, but it's purely best
// effort and so there's no promise that it'll ever contain any specific items
AssertHelpers.AssertCountOf(101, result.References);
Assert.NotEmpty(result.CopyLocalItems);
}
public static void AllNuGetReferencesHaveValidIsFrameworkReferenceProperty()
{
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.FluentAssertions,
targetMoniker: ".NETFramework,Version=v4.5.2",
runtimeIdentifier: "");
var key = ResolveNuGetPackageAssets.NuGetIsFrameworkReference;
var values = result.References.Select(r => r.GetMetadata(key));
Assert.All(result.References, r => Assert.Contains(key, r.MetadataNames.Cast <string>()));
Assert.All(values, v => Assert.Contains(v, new [] { "true", "false" }));
}
public static void CopyLocalContentsIncludePdbsIfAvailable()
{
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.FluentAssertionsAndWin10,
targetMoniker: "UAP,Version=v10.0",
runtimeIdentifier: "win10-x86",
includeFrameworkReferences: true);
Assert.Single(result.CopyLocalItems, r => r.ItemSpec.EndsWithPath("FluentAssertions.dll"));
Assert.Single(result.CopyLocalItems, r => r.ItemSpec.EndsWithPath("FluentAssertions.pdb"));
Assert.Single(result.CopyLocalItems, r => r.ItemSpec.EndsWithPath("FluentAssertions.Core.dll"));
Assert.Single(result.CopyLocalItems, r => r.ItemSpec.EndsWithPath("FluentAssertions.Core.pdb"));
}
public static void ReferencedPackagesCorrectlyParsed()
{
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.Win10,
targetMoniker: ".NETCore,Version=v5.0",
runtimeIdentifier: "");
// We should still have references, but no copy local
AssertHelpers.AssertCountOf(5, result.ReferencedPackages);
var packageNames = result.ReferencedPackages.Select(t => t.ItemSpec);
Assert.Contains("Microsoft.NETCore.UniversalWindowsPlatform", packageNames);
}
public static void TestReferenceResolutionWithMissingTargets(bool isProjectJsonBased, string errorResourceName)
{
using (var tempRoot = new TempRoot())
using (var disposableFile = new DisposableFile(tempRoot.CreateFile(extension: "assets.json").Path))
{
var exception = Assert.Throws <ExceptionFromResource>(() =>
NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Encoding.UTF8.GetString(Json.Json.WithoutTargets_assets, 0, Json.Json.WithoutTargets_assets.Length),
targetMoniker: "MissingFrameworkMoniker,Version=v42.0",
runtimeIdentifier: "",
allowFallbackOnTargetSelection: true,
isLockFileProjectJsonBased: isProjectJsonBased));
Assert.Equal(errorResourceName, exception.ResourceName);
}
}
public static void TestReferenceResolutionWithAliases()
{
using (var tempRoot = new TempRoot())
using (var disposableFile = new DisposableFile(tempRoot.CreateFile(extension: "assets.json").Path))
{
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Encoding.UTF8.GetString(Json.Json.WithTargets_assets, 0, Json.Json.WithTargets_assets.Length),
targetMoniker: ".NETFramework,Version=v4.5",
runtimeIdentifier: "",
allowFallbackOnTargetSelection: true,
isLockFileProjectJsonBased: false);
// We should still have references. Since we have no runtime ID, we should have no copy local items
AssertHelpers.AssertCountOf(1, result.References);
Assert.Equal("Core", result.References.Single().GetMetadata("Aliases"));
}
}
public static void TestReferenceResolutionWithMissingTargetFrameworkAndFallbackInProjectCsproj()
{
using (var tempRoot = new TempRoot())
using (var disposableFile = new DisposableFile(tempRoot.CreateFile(extension: "assets.json").Path))
{
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Encoding.UTF8.GetString(Json.Json.WithTargets_assets, 0, Json.Json.WithTargets_assets.Length),
targetMoniker: "MissingFrameworkMoniker,Version=v42.0",
runtimeIdentifier: "",
allowFallbackOnTargetSelection: true,
isLockFileProjectJsonBased: false);
// We should still have references. Since we have no runtime ID, we should have no copy local items
AssertHelpers.AssertCountOf(1, result.References);
AssertHelpers.AssertCountOf(0, result.CopyLocalItems);
}
}
public static void ExcludingFrameworkReferencesActuallyExcludesFrameworkReferences()
{
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.FluentAssertions,
targetMoniker: ".NETFramework,Version=v4.5.2",
runtimeIdentifier: "",
includeFrameworkReferences: false);
// We should only have references from the core package
AssertHelpers.AssertCountOf(2, result.References);
Assert.True(result.References.All(r => r.ItemSpec.Contains("FluentAssertions")));
// This should still count as the reference to a package
var packageNames = result.ReferencedPackages.Select(t => t.ItemSpec);
Assert.Contains("FluentAssertions", packageNames);
}
public static void TestReferenceResolutionWithMissingTargetFrameworkAndNoFallbackInProjectCsproj()
{
using (var tempRoot = new TempRoot())
using (var disposableFile = new DisposableFile(tempRoot.CreateFile(extension: "assets.json").Path))
{
var exception = Assert.Throws <ExceptionFromResource>(() =>
NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Encoding.UTF8.GetString(Json.Json.WithoutTargets_assets, 0, Json.Json.WithoutTargets_assets.Length),
targetMoniker: "Missing,Version=1.0",
runtimeIdentifier: "missing-runtime-identifier",
allowFallbackOnTargetSelection: false,
isLockFileProjectJsonBased: false));
Assert.Equal(nameof(Strings.MissingFrameworkInProjectFile), exception.ResourceName);
Assert.Equal(new[] { "Missing,Version=1.0" }, exception.MessageArgs);
}
}
public static void BogusWinMDDoesNotSetImplementation()
{
string imageRuntimeVersion = "BogusRuntime 1.4;C1R v4.0.30319";
TryGetRuntimeVersion tryGetRuntimeVersion = p => imageRuntimeVersion;
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.nativeWinMD,
targetMoniker: ".NETCore,Version=v5.0",
runtimeIdentifier: "win10-x86",
tryGetRuntimeVersion: tryGetRuntimeVersion);
var winmd = result.CopyLocalItems.FirstOrDefault(c =>
Path.GetExtension(c.ItemSpec).Equals(".winmd", StringComparison.OrdinalIgnoreCase));
Assert.NotNull(winmd);
Assert.Equal(imageRuntimeVersion, winmd.GetMetadata("ImageRuntime"));
Assert.True(string.IsNullOrEmpty(winmd.GetMetadata("WinMDFile")));
Assert.True(string.IsNullOrEmpty(winmd.GetMetadata("WinMDFileType")));
Assert.True(string.IsNullOrEmpty(winmd.GetMetadata("Implementation")), "implementation should not be set for bogus winmd");
}
public static void IncludingFrameworkReferencesActuallyIncludesFrameworkReferences()
{
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.FluentAssertions,
targetMoniker: ".NETFramework,Version=v4.5.2",
runtimeIdentifier: "",
includeFrameworkReferences: true);
// We should have references to the package itself plus framework packages
AssertHelpers.AssertCountOf(4, result.References);
Assert.True(result.References.All(r => r.ItemSpec.Contains("FluentAssertions") ||
r.ItemSpec == "System.Xml" ||
r.ItemSpec == "System.Xml.Linq"));
// This should still count as the reference to a package
var packageNames = result.ReferencedPackages.Select(t => t.ItemSpec);
Assert.Contains("FluentAssertions", packageNames);
}
public static void NativeWinMDSetsMetadata()
{
string imageRuntimeVersion = "WindowsRuntime 1.3";
TryGetRuntimeVersion tryGetRuntimeVersion = p => imageRuntimeVersion;
var result = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.nativeWinMD,
targetMoniker: ".NETCore,Version=v5.0",
runtimeIdentifier: "win10-x86",
tryGetRuntimeVersion: tryGetRuntimeVersion);
var winmd = result.CopyLocalItems.FirstOrDefault(c =>
Path.GetExtension(c.ItemSpec).Equals(".winmd", StringComparison.OrdinalIgnoreCase));
Assert.NotNull(winmd);
Assert.Equal(imageRuntimeVersion, winmd.GetMetadata("ImageRuntime"));
Assert.Equal("true", winmd.GetMetadata("WinMDFile"));
Assert.Equal("Native", winmd.GetMetadata("WinMDFileType"));
Assert.False(string.IsNullOrEmpty(winmd.GetMetadata("Implementation")), "implementation should be set for native winmd");
Assert.Equal(Path.GetFileNameWithoutExtension(winmd.ItemSpec) + ".dll", winmd.GetMetadata("Implementation"), StringComparer.OrdinalIgnoreCase);
}
public static void MultipleProjectFileDependencyGroups_MismatchedCases()
{
var resultFor45 = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.MultipleProjectFileDependencyGroups_CaseMismatch,
targetMoniker: ".NETFramework,Version=v4.5",
runtimeIdentifier: "win",
allowFallbackOnTargetSelection: true);
var packageNames = resultFor45.ReferencedPackages.Select(t => t.ItemSpec);
Assert.Equal("Newtonsoft.Json", packageNames.Single(), ignoreCase: true);
var resultFor46 = NuGetTestHelpers.ResolvePackagesWithJsonFileContents(
Json.Json.MultipleProjectFileDependencyGroups,
targetMoniker: ".NETFramework,Version=v4.6",
runtimeIdentifier: "win",
allowFallbackOnTargetSelection: true);
AssertHelpers.AssertCountOf(1, resultFor46.ReferencedPackages);
packageNames = resultFor46.ReferencedPackages.Select(t => t.ItemSpec);
Assert.Equal("FluentAssertions", packageNames.Single(), ignoreCase: true);
}
