public void GetDescriptionShouldNotModifyTarget()
{
var provider = new PackageDependencyProvider(
NuGetPathContext.Create("/foo/packages"),
new FrameworkReferenceResolver("/foo/references"));
var package = new LockFileLibrary();
package.Name = "Something";
package.Version = NuGetVersion.Parse("1.0.0");
package.Files.Add("lib/dotnet/_._");
package.Files.Add("runtimes/any/native/Microsoft.CSharp.CurrentVersion.targets");
var target = new LockFileTargetLibrary();
target.Name = "Something";
target.Version = package.Version;
target.RuntimeAssemblies.Add("lib/dotnet/_._");
target.CompileTimeAssemblies.Add("lib/dotnet/_._");
target.NativeLibraries.Add("runtimes/any/native/Microsoft.CSharp.CurrentVersion.targets");
var p1 = provider.GetDescription(NuGetFramework.Parse("netcoreapp1.0"), package, target);
var p2 = provider.GetDescription(NuGetFramework.Parse("netcoreapp1.0"), package, target);
Assert.True(p1.Compatible);
Assert.True(p2.Compatible);
Assert.Empty(p1.CompileTimeAssemblies);
Assert.Empty(p1.RuntimeAssemblies);
Assert.Empty(p2.CompileTimeAssemblies);
Assert.Empty(p2.RuntimeAssemblies);
}
public void ConvertLockFileToOriginalCase_ConvertsPackagesPathsInLockFile()
{
// Arrange
var logger = new TestLogger();
var request = GetRestoreRequest("fake", logger);
var packageLibrary = new LockFileLibrary
{
Name = "PackageA",
Version = NuGetVersion.Parse("1.0.0-Beta"),
Path = "packagea/1.0.0-beta",
Type = LibraryType.Package
};
var projectLibrary = new LockFileLibrary
{
Name = "Project",
Version = NuGetVersion.Parse("1.0.0-Beta"),
Path = "project",
Type = LibraryType.Project
};
var lockFile = new LockFile
{
Libraries = { packageLibrary, projectLibrary }
};
var target = new OriginalCaseGlobalPackageFolder(request);
// Act
target.ConvertLockFileToOriginalCase(lockFile);
// Assert
Assert.Equal("PackageA/1.0.0-Beta", packageLibrary.Path);
Assert.Equal("project", projectLibrary.Path);
}
public void HasCompileTimePlaceholderChecksAllCompileTimeAssets()
{
var provider = new PackageDependencyProvider(
NuGetPathContext.Create("/foo/packages"),
new FrameworkReferenceResolver("/foo/references"));
var package = new LockFileLibrary();
package.Name = "Something";
package.Version = NuGetVersion.Parse("1.0.0");
package.Files.Add("lib/net46/_._");
package.Files.Add("lib/net46/Something.dll");
var target = new LockFileTargetLibrary();
target.Name = "Something";
target.Version = package.Version;
target.RuntimeAssemblies.Add("lib/net46/_._");
target.RuntimeAssemblies.Add("lib/net46/Something.dll");
target.CompileTimeAssemblies.Add("lib/net46/_._");
target.CompileTimeAssemblies.Add("lib/net46/Something.dll");
var p1 = provider.GetDescription(NuGetFramework.Parse("net46"), package, target);
Assert.False(p1.HasCompileTimePlaceholder);
Assert.Equal(1, p1.CompileTimeAssemblies.Count());
Assert.Equal(1, p1.RuntimeAssemblies.Count());
Assert.Equal("lib/net46/Something.dll", p1.CompileTimeAssemblies.First().Path);
Assert.Equal("lib/net46/Something.dll", p1.RuntimeAssemblies.First().Path);
}
/// <summary>
/// Get a ContentItemCollection of the package files.
/// </summary>
/// <remarks>Library is optional.</remarks>
public ContentItemCollection GetContentItems(LockFileLibrary library, LocalPackageInfo package)
{
if (package == null)
{
throw new ArgumentNullException(nameof(package));
}
var identity = new PackageIdentity(package.Id, package.Version);
if (!_contentItems.TryGetValue(identity, out var collection))
{
collection = new ContentItemCollection();
if (library == null)
{
// Read folder
collection.Load(package.Files);
}
else
{
// Use existing library
collection.Load(library.Files);
}
_contentItems.Add(identity, collection);
}
return(collection);
}
private Dictionary <string, string> GetPackageReferenceItemMetadata(LockFileLibrary library, LibraryDependency libraryDependency = null)
{
if (library == null)
{
throw new ArgumentNullException(nameof(library));
}
Dictionary <string, string> metadata = new Dictionary <string, string>
{
{ VersionMetadataName, $"[{library.Version}]" },
{ Sha512MetadataName, library.Sha512 },
{ PackagePathMetadataName, library.Path },
{ HashfileMetadataName, library.Files.First(i => i.EndsWith("nupkg.sha512", StringComparison.OrdinalIgnoreCase)).ToLowerInvariant() },
};
if (libraryDependency != null)
{
if (libraryDependency.IncludeType != LibraryIncludeFlags.All)
{
metadata.Add(IncludeAssetsMetadataName, libraryDependency.IncludeType.ToString("F").Replace(", ", ";"));
}
if (libraryDependency.SuppressParent != LibraryIncludeFlagUtils.DefaultSuppressParent)
{
metadata.Add(PrivateAssetsMetdataName, libraryDependency.SuppressParent.ToString("F").Replace(", ", ";"));
}
if (libraryDependency.AutoReferenced)
{
metadata.Add(IsImplicitlyDefinedMetadataName, "true");
}
}
return(metadata);
}
public void LockFileLibrary_CloneIsEqual()
{
// Arrange
var original = new LockFileLibrary
{
Name = "SomeLibrary",
Version = new NuGetVersion("1.0.0"),
Path = "SomeLibrary/1.0.0",
IsServiceable = true,
MSBuildProject = "MSBuildProject",
Sha512 = "FAKE-HASH",
Type = LibraryType.Package,
Files = new List <string>
{
"file/a.txt",
"file/b.txt"
}
};
// Act
var clone = original.Clone();
// Assert
Assert.Equal(original, clone);
}
public void LockFileLibrary_ComparesDifferentCaseFiles()
{
// Arrange
var libraryA = new LockFileLibrary
{
Files = new List <string>
{
"path/a.txt",
"path/b.txt"
}
};
// different case
var libraryB = new LockFileLibrary
{
Files = new List <string>
{
"path/a.txt",
"PATH/b.txt"
}
};
// Act & Assert
Assert.False(libraryA.Equals(libraryB), "The two libraries should not be equal.");
}
// return true if package exists, but retry logic is based on what value is expected so there is enough time for assets file to be updated.
private static bool PackageExistsInLockFile(string pathToAssetsFile, string packageName, string packageVersion, bool expected)
{
var numAttempts = 0;
LockFileLibrary lockFileLibrary = null;
while (numAttempts++ < 3)
{
var version = NuGetVersion.Parse(packageVersion);
var lockFile = GetAssetsFileWithRetry(pathToAssetsFile);
lockFileLibrary = lockFile.Libraries
.SingleOrDefault(p => StringComparer.OrdinalIgnoreCase.Equals(p.Name, packageName) &&
p.Version.Equals(version));
if (expected && lockFileLibrary != null)
{
return(true);
}
if (!expected && lockFileLibrary == null)
{
return(false);
}
Thread.Sleep(2000);
}
return(lockFileLibrary != null);
}
public void LockFileLibrary_CloneIncludesAllProperties()
{
// Arrange
var original = new LockFileLibrary
{
Name = "SomeLibrary",
Version = new NuGetVersion("1.0.0"),
Path = "SomeLibrary/1.0.0",
IsServiceable = true,
MSBuildProject = "MSBuildProject",
Sha512 = "FAKE-HASH",
Type = LibraryType.Package,
Files = new List <string>
{
"file/a.txt",
"file/b.txt"
}
};
// Use Newtonsoft.Json to enumerate all properties.
var originalSerialized = JsonConvert.SerializeObject(original, Formatting.Indented);
// Act
var clone = original.Clone();
// Assert
var cloneSerialized = JsonConvert.SerializeObject(original, Formatting.Indented);
Assert.Equal(originalSerialized, cloneSerialized);
}
private static LockFileLibrary CreateLockFileLibrary(LocalPackageInfo package, string sha512, string path)
{
var lockFileLib = new LockFileLibrary();
lockFileLib.Name = package.Id;
lockFileLib.Version = package.Version;
lockFileLib.Type = LibraryType.Package;
lockFileLib.Sha512 = sha512;
// This is the relative path, appended to the global packages folder path. All
// of the paths in the in the Files property should be appended to this path along
// with the global packages folder path to get the absolute path to each file in the
// package.
lockFileLib.Path = path;
using (var packageReader = new PackageFolderReader(package.ExpandedPath))
{
// Get package files, excluding directory entries and OPC files
// This is sorted before it is written out
lockFileLib.Files = packageReader
.GetFiles()
.Where(file => IsAllowedLibraryFile(file))
.ToList();
}
return(lockFileLib);
}
private static LockFileLibrary CreateLockFileLibrary(LocalPackageInfo package, string sha512, string path)
{
var lockFileLib = new LockFileLibrary
{
Name = package.Id,
Version = package.Version,
Type = LibraryType.Package,
Sha512 = sha512,
// This is the relative path, appended to the global packages folder path. All
// of the paths in the in the Files property should be appended to this path along
// with the global packages folder path to get the absolute path to each file in the
// package.
Path = path
};
foreach (var file in package.Files)
{
if (!lockFileLib.HasTools && HasTools(file))
{
lockFileLib.HasTools = true;
}
lockFileLib.Files.Add(file);
}
return(lockFileLib);
}
public void GetDescriptionShouldGenerateHashFileName()
{
// Arrange
var provider = new PackageDependencyProvider(
NuGetPathContext.Create("/foo/packages"),
new FrameworkReferenceResolver("/foo/references"));
var package = new LockFileLibrary();
package.Name = "Something";
package.Version = NuGetVersion.Parse("1.0.0-Beta");
package.Files.Add("lib/dotnet/_._");
package.Files.Add("runtimes/any/native/Microsoft.CSharp.CurrentVersion.targets");
package.Path = "SomePath";
var target = new LockFileTargetLibrary();
target.Name = "Something";
target.Version = package.Version;
target.RuntimeAssemblies.Add("lib/dotnet/_._");
target.CompileTimeAssemblies.Add("lib/dotnet/_._");
target.NativeLibraries.Add("runtimes/any/native/Microsoft.CSharp.CurrentVersion.targets");
// Act
var p = provider.GetDescription(NuGetFramework.Parse("netcoreapp1.0"), package, target);
// Assert
p.PackageLibrary.Path.Should().Be("SomePath");
p.HashPath.Should().Be("something.1.0.0-beta.nupkg.sha512");
}
private static LockFileLibrary CreateLockFileLibrary(LocalPackageInfo package, string sha512, string path, string correctedPackageName)
{
var lockFileLib = new LockFileLibrary();
// package.Id is read from nuspec and it might be in wrong casing.
// correctedPackageName should be the package name used by dependency graph and
// it has the correct casing that runtime needs during dependency resolution.
lockFileLib.Name = correctedPackageName ?? package.Id;
lockFileLib.Version = package.Version;
lockFileLib.Type = LibraryType.Package;
lockFileLib.Sha512 = sha512;
// This is the relative path, appended to the global packages folder path. All
// of the paths in the in the Files property should be appended to this path along
// with the global packages folder path to get the absolute path to each file in the
// package.
lockFileLib.Path = path;
using (var packageReader = new PackageFolderReader(package.ExpandedPath))
{
// Get package files, excluding directory entries and OPC files
// This is sorted before it is written out
lockFileLib.Files = packageReader
.GetFiles()
.Where(file => IsAllowedLibraryFile(file))
.ToList();
}
return(lockFileLib);
}
public static LockFileTargetLibrary CreateLockFileTargetLibrary(
LockFileLibrary library,
LocalPackageInfo package,
RestoreTargetGraph targetGraph,
LibraryIncludeFlags dependencyType,
NuGetFramework targetFrameworkOverride,
IEnumerable <LibraryDependency> dependencies)
{
LockFileTargetLibrary lockFileLib = null;
var framework = targetFrameworkOverride ?? targetGraph.Framework;
var runtimeIdentifier = targetGraph.RuntimeIdentifier;
// Read files from package
var files = GetPackageFiles(library, package);
var contentItems = new ContentItemCollection();
contentItems.Load(files);
// This will throw an appropriate error if the nuspec is missing
var nuspec = package.Nuspec;
// Create fallback criteria, this will always be one or more.
var orderedCriteriaSets = CreateOrderedCriteriaSets(targetGraph, framework);
for (var i = 0; i < orderedCriteriaSets.Count; i++)
{
// Create a new library each time to avoid
// assets being added from other criteria.
lockFileLib = new LockFileTargetLibrary()
{
Name = package.Id,
Version = package.Version,
Type = LibraryType.Package
};
// Populate assets
AddAssets(library, package, targetGraph, dependencyType, lockFileLib, framework, runtimeIdentifier, files, contentItems, nuspec, orderedCriteriaSets[i]);
// Check if compatile assets were found.
// If no compatible assets were found and this is the last check
// continue on with what was given, this will fail in the normal
// compat verification.
if (CompatibilityChecker.HasCompatibleAssets(lockFileLib))
{
// Stop when compatible assets are found.
break;
}
}
// Add dependencies
AddDependencies(dependencies, lockFileLib, framework, nuspec);
// Exclude items
ExcludeItems(lockFileLib, dependencyType);
return(lockFileLib);
}
public void LockFileLibrary_EqualityEmpty()
{
// Arrange
var library1 = new LockFileLibrary();
var library2 = new LockFileLibrary();
// Act & Assert
Assert.True(library1.Equals(library2));
}
public static LockFileTargetLibrary CreateLockFileTargetLibrary(
LockFileLibrary library,
LocalPackageInfo package,
RestoreTargetGraph targetGraph,
LibraryIncludeFlags dependencyType,
NuGetFramework targetFrameworkOverride,
IEnumerable <LibraryDependency> dependencies,
LockFileBuilderCache cache)
{
return(CreateLockFileTargetLibrary(libraryDependency: null, library, package, targetGraph, dependencyType, targetFrameworkOverride, dependencies, cache));
}
private string GetMSBuildProjectFilePath(LockFileLibrary projectLibrary)
{
if (_rootProject == null)
{
throw new InvalidOperationException("Root xproj project does not exist. Cannot compute the path of its referenced csproj projects.");
}
var rootProjectPath = Path.GetDirectoryName(_rootProject.ProjectFilePath);
var msbuildProjectFilePath = Path.Combine(rootProjectPath, projectLibrary.MSBuildProject);
return(Path.GetFullPath(msbuildProjectFilePath));
}
private PackageDescription CreateDescription(
LockFileTargetLibrary target = null,
LockFileLibrary package = null,
string hashPath = null)
{
return(new PackageDescription(
PackagePath,
hashPath ?? HashPath,
package ?? new LockFileLibrary(),
target ?? new LockFileTargetLibrary(),
new List <ProjectLibraryDependency>(), compatible: true, resolved: true));
}
private void AddPackage(List <PackageIdentityWithPath> packages, LockFileLibrary installedPackage, VersionFolderPathResolver versionFolderPathResolver)
{
string installPath = versionFolderPathResolver.GetInstallPath(installedPackage.Name, installedPackage.Version);
if (!String.IsNullOrWhiteSpace(installPath))
{
packages.Add(new PackageIdentityWithPath(installedPackage.Name, installedPackage.Version, Path.GetFullPath(installPath)));
}
else
{
Log.LogWarning($"The package '{installedPackage.Name}' was not found in the repository.");
}
}
public PackageInfo(
IFileSystem repositoryRoot,
string packageId,
SemanticVersion version,
string versionDir,
LockFileLibrary lockFileLibrary = null)
{
_repositoryRoot = repositoryRoot;
Id = packageId;
Version = version;
_versionDir = versionDir;
LockFileLibrary = lockFileLibrary;
}
public static bool IsMSBuildProjectLibrary(LockFileLibrary projectLibrary)
{
var msbuildProjectPath = projectLibrary.MSBuildProject;
if (msbuildProjectPath == null)
{
return(false);
}
var extension = Path.GetExtension(msbuildProjectPath);
return(!string.Equals(extension, ".xproj", StringComparison.OrdinalIgnoreCase));
}
public static LockFileTargetLibrary CreateLockFileTargetLibrary(
LockFileLibrary library,
LocalPackageInfo package,
RestoreTargetGraph targetGraph,
LibraryIncludeFlags dependencyType)
{
return(CreateLockFileTargetLibrary(
library,
package,
targetGraph,
dependencyType: dependencyType,
targetFrameworkOverride: null,
dependencies: null));
}
public PackageDescription GetDescription(
NuGetFramework targetFramework,
LockFileLibrary package,
LockFileTargetLibrary targetLibrary)
{
// If a NuGet dependency is supposed to provide assemblies but there is no assembly compatible with
// current target framework, we should mark this dependency as unresolved
var containsAssembly = package.Files
.Select(f => f.Replace('/', Path.DirectorySeparatorChar))
.Any(x => x.StartsWith($"ref{Path.DirectorySeparatorChar}") ||
x.StartsWith($"lib{Path.DirectorySeparatorChar}"));
var compatible = targetLibrary.FrameworkAssemblies.Any() ||
targetLibrary.CompileTimeAssemblies.Any() ||
targetLibrary.RuntimeAssemblies.Any() ||
!containsAssembly;
var dependencies =
new List <ProjectLibraryDependency>(targetLibrary.Dependencies.Count + targetLibrary.FrameworkAssemblies.Count);
PopulateDependencies(dependencies, targetLibrary, targetFramework);
var path = _packagePathResolver?.GetPackageDirectory(package.Name, package.Version);
bool exists = path != null;
string hashPath = null;
if (_versionFolderPathResolver != null)
{
hashPath = _versionFolderPathResolver.GetHashFileName(package.Name, package.Version);
}
if (exists)
{
// If the package's compile time assemblies is for a portable profile then, read the assembly metadata
// and turn System.* references into reference assembly dependencies
PopulateLegacyPortableDependencies(targetFramework, dependencies, path, targetLibrary);
}
var packageDescription = new PackageDescription(
path,
hashPath,
package,
targetLibrary,
dependencies,
compatible,
resolved: compatible && exists);
return(packageDescription);
}
private JProperty WriteLibrary(LockFileLibrary library)
{
var json = new JObject();
if (library.IsServiceable)
{
WriteBool(json, "serviceable", library.IsServiceable);
}
json["sha512"] = WriteString(library.Sha512);
WritePathArray(json, "files", library.Files.OrderBy(f => f), WriteString);
return(new JProperty(
library.Name + "/" + library.Version.ToString(),
json));
}
private LockFileLibrary ReadLibrary(string property, JToken json)
{
var library = new LockFileLibrary();
var parts = property.Split(new[] { '/' }, 2);
library.Name = parts[0];
if (parts.Length == 2)
{
library.Version = SemanticVersion.Parse(parts[1]);
}
library.IsServiceable = ReadBool(json, "serviceable", defaultValue: false);
library.Sha512 = ReadString(json["sha512"]);
library.Files = ReadPathArray(json["files"] as JArray, ReadString);
return(library);
}
public bool TryGetLibrary(LockFileTargetLibrary targetLibrary, out LockFileLibrary library)
{
var libraryType = LibraryType.Parse(targetLibrary.Type);
if (libraryType == LibraryType.Package)
{
library = GetPackage(targetLibrary.Name, targetLibrary.Version);
}
else
{
library = GetProject(targetLibrary.Name);
}
return(library != null);
}
public void LockFileLibrary_EqualitySameMSBuildPath()
{
// Arrange
var library1 = new LockFileLibrary()
{
MSBuildProject = "b"
};
var library2 = new LockFileLibrary()
{
MSBuildProject = "b"
};
// Act & Assert
Assert.True(library1.Equals(library2));
}
public void LockFileLibrary_EqualityDiffersOnMSBuildPath()
{
// Arrange
var library1 = new LockFileLibrary()
{
MSBuildProject = "a"
};
var library2 = new LockFileLibrary()
{
MSBuildProject = "b"
};
// Act & Assert
Assert.False(library1.Equals(library2));
}
public static LockFileTargetLibrary CreateLockFileTargetLibrary(
LockFileLibrary library,
LocalPackageInfo package,
RestoreTargetGraph targetGraph,
LibraryIncludeFlags dependencyType)
{
return(CreateLockFileTargetLibrary(
aliases: null,
library,
package,
targetGraph,
dependencyType: dependencyType,
targetFrameworkOverride: null,
dependencies: null,
cache: new LockFileBuilderCache(),
maccatalystFallback: null));
}
public static LockFileLibrary CreateLockFileLibrary(LockFileLibrary previousLibrary, IPackagePathResolver resolver, IPackage package, string correctedPackageName = null)
{
var lockFileLib = new LockFileLibrary();
// package.Id is read from nuspec and it might be in wrong casing.
// correctedPackageName should be the package name used by dependency graph and
// it has the correct casing that runtime needs during dependency resolution.
lockFileLib.Name = correctedPackageName ?? package.Id;
lockFileLib.Version = package.Version;
lockFileLib.Sha512 = File.ReadAllText(resolver.GetHashPath(package.Id, package.Version));
// If the shas are equal then do nothing
if (previousLibrary?.Sha512 == lockFileLib.Sha512)
{
lockFileLib.Files = previousLibrary.Files;
lockFileLib.IsServiceable = previousLibrary.IsServiceable;
}
else
{
lockFileLib.Files = package.GetFiles().Select(p => p.Path).ToList();
var installPath = resolver.GetInstallPath(package.Id, package.Version);
foreach (var filePath in lockFileLib.Files)
{
if (!string.Equals(Path.GetExtension(filePath), ".dll", StringComparison.OrdinalIgnoreCase))
{
continue;
}
var assemblyPath = Path.Combine(installPath, filePath);
try
{
if (IsAssemblyServiceable(assemblyPath))
{
lockFileLib.IsServiceable = true;
break;
}
}
catch
{
// Just move on to the next file
}
}
}
return(lockFileLib);
}
