public void HasCompileTimePlaceholderChecksAllCompileTimeAssets()
{
var provider = new PackageDependencyProvider("/foo/packages", new FrameworkReferenceResolver("/foo/references"));
var package = new LockFilePackageLibrary();
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);
}
public void GetDescriptionShouldNotModifyTarget()
{
var provider = new PackageDependencyProvider("/foo/packages", new FrameworkReferenceResolver("/foo/references"));
var package = new LockFilePackageLibrary();
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("netstandardapp1.5"), package, target);
var p2 = provider.GetDescription(NuGetFramework.Parse("netstandardapp1.5"), 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 CommandSpec CreateCommandSpecFromLibrary(
LockFileTargetLibrary toolLibrary,
string commandName,
IEnumerable<string> commandArguments,
IEnumerable<string> allowedExtensions,
string nugetPackagesRoot,
CommandResolutionStrategy commandResolutionStrategy,
string depsFilePath)
{
var toolAssembly = toolLibrary?.RuntimeAssemblies
.FirstOrDefault(r => Path.GetFileNameWithoutExtension(r.Path) == commandName);
if (toolAssembly == null)
{
return null;
}
var commandPath = GetCommandFilePath(nugetPackagesRoot, toolLibrary, toolAssembly);
if (!File.Exists(commandPath))
{
return null;
}
var isPortable = IsPortableApp(commandPath);
return CreateCommandSpecWrappingWithCorehostIfDll(
commandPath,
commandArguments,
depsFilePath,
commandResolutionStrategy,
nugetPackagesRoot,
isPortable);
}
private void PopulateDependencies(
List<LibraryRange> dependencies,
LockFileTargetLibrary targetLibrary,
NuGetFramework targetFramework)
{
foreach (var dependency in targetLibrary.Dependencies)
{
dependencies.Add(new LibraryRange(
dependency.Id,
dependency.VersionRange,
LibraryType.Unspecified,
LibraryDependencyType.Default));
}
if (!targetFramework.IsPackageBased)
{
// Only add framework assemblies for non-package based frameworks.
foreach (var frameworkAssembly in targetLibrary.FrameworkAssemblies)
{
dependencies.Add(new LibraryRange(
frameworkAssembly,
LibraryType.ReferenceAssembly,
LibraryDependencyType.Default));
}
}
}
public MSBuildProjectDescription GetDescription(NuGetFramework targetFramework, LockFileProjectLibrary projectLibrary, LockFileTargetLibrary targetLibrary)
{
var compatible = targetLibrary.FrameworkAssemblies.Any() ||
targetLibrary.CompileTimeAssemblies.Any() ||
targetLibrary.RuntimeAssemblies.Any();
var dependencies = new List<LibraryRange>(targetLibrary.Dependencies.Count + targetLibrary.FrameworkAssemblies.Count);
PopulateDependencies(dependencies, targetLibrary, targetFramework);
var msbuildProjectFilePath = GetMSBuildProjectFilePath(projectLibrary);
var msbuildProjectDirectoryPath = Path.GetDirectoryName(msbuildProjectFilePath);
var exists = Directory.Exists(msbuildProjectDirectoryPath);
var projectFile = projectLibrary.Path == null ? null : _projectResolver(projectLibrary.Path);
var msbuildPackageDescription = new MSBuildProjectDescription(
msbuildProjectDirectoryPath,
msbuildProjectFilePath,
projectLibrary,
targetLibrary,
projectFile,
dependencies,
compatible,
resolved: compatible && exists);
return msbuildPackageDescription;
}
public PackageDescription GetDescription(LockFilePackageLibrary 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
.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<LibraryRange>(targetLibrary.Dependencies.Count + targetLibrary.FrameworkAssemblies.Count);
PopulateDependencies(dependencies, targetLibrary);
var path = _packagePathResolver.GetInstallPath(package.Name, package.Version);
var packageDescription = new PackageDescription(
path,
package,
targetLibrary,
dependencies,
compatible);
return packageDescription;
}
public PackageDescription GetDescription(NuGetFramework targetFramework, LockFilePackageLibrary 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
.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<LibraryRange>(targetLibrary.Dependencies.Count + targetLibrary.FrameworkAssemblies.Count);
PopulateDependencies(dependencies, targetLibrary, targetFramework);
var path = _packagePathResolver.GetInstallPath(package.Name, package.Version);
// Remove place holders
targetLibrary.CompileTimeAssemblies = targetLibrary.CompileTimeAssemblies.Where(item => !IsPlaceholderFile(item.Path)).ToList();
targetLibrary.RuntimeAssemblies = targetLibrary.RuntimeAssemblies.Where(item => !IsPlaceholderFile(item.Path)).ToList();
// 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,
package,
targetLibrary,
dependencies,
compatible);
return packageDescription;
}
private PackageDescription CreateDescription(LockFileTargetLibrary target = null, LockFilePackageLibrary package = null)
{
return new PackageDescription(PackagePath,
package ?? new LockFilePackageLibrary(),
target ?? new LockFileTargetLibrary(),
new List<LibraryRange>(), compatible: true, resolved: true);
}
private static void Patch(LockFileTargetLibrary libraryToPatch, LockFileTargetLibrary export)
{
libraryToPatch.CompileTimeAssemblies = export.CompileTimeAssemblies;
libraryToPatch.ContentFiles = export.ContentFiles;
libraryToPatch.FrameworkAssemblies = export.FrameworkAssemblies;
libraryToPatch.NativeLibraries = export.NativeLibraries;
libraryToPatch.ResourceAssemblies = export.ResourceAssemblies;
libraryToPatch.RuntimeAssemblies = export.RuntimeAssemblies;
}
private string GetCommandFilePath(string nugetPackagesRoot, LockFileTargetLibrary toolLibrary, LockFileItem runtimeAssembly)
{
var packageDirectory = new VersionFolderPathResolver(nugetPackagesRoot)
.GetInstallPath(toolLibrary.Name, toolLibrary.Version);
var filePath = Path.Combine(packageDirectory, runtimeAssembly.Path);
return filePath;
}
public ProjectDescription GetDescription(string name, string path, LockFileTargetLibrary targetLibrary)
{
Project project;
// Can't find a project file with the name so bail
if (!ProjectReader.TryGetProject(path, out project))
{
return new ProjectDescription(name, path);
}
return GetDescription(targetLibrary.TargetFramework, project);
}
public ProjectDescription GetDescription(NuGetFramework targetFramework, Project project, LockFileTargetLibrary targetLibrary)
{
// This never returns null
var targetFrameworkInfo = project.GetTargetFramework(targetFramework);
var dependencies = new List<LibraryRange>(targetFrameworkInfo.Dependencies);
// Add all of the project's dependencies
dependencies.AddRange(project.Dependencies);
if (targetFramework != null && targetFramework.IsDesktop())
{
dependencies.Add(new LibraryRange("mscorlib", LibraryType.ReferenceAssembly, LibraryDependencyType.Build));
dependencies.Add(new LibraryRange("System", LibraryType.ReferenceAssembly, LibraryDependencyType.Build));
if (targetFramework.Version >= new Version(3, 5))
{
dependencies.Add(new LibraryRange("System.Core", LibraryType.ReferenceAssembly, LibraryDependencyType.Build));
if (targetFramework.Version >= new Version(4, 0))
{
if (!dependencies.Any(dep => string.Equals(dep.Name, "Microsoft.CSharp", StringComparison.OrdinalIgnoreCase)))
{
dependencies.Add(new LibraryRange("Microsoft.CSharp", LibraryType.ReferenceAssembly, LibraryDependencyType.Build));
}
}
}
}
if (targetLibrary != null)
{
// The lock file entry might have a filtered set of dependencies
var lockFileDependencies = targetLibrary.Dependencies.ToDictionary(d => d.Id);
// Remove all non-framework dependencies that don't appear in the lock file entry
dependencies.RemoveAll(m => !lockFileDependencies.ContainsKey(m.Name) && m.Target != LibraryType.ReferenceAssembly);
}
// Mark the library as unresolved if there were specified frameworks
// and none of them resolved
bool unresolved = targetFrameworkInfo.FrameworkName == null;
return new ProjectDescription(
new LibraryRange(project.Name, LibraryType.Unspecified),
project,
dependencies,
targetFrameworkInfo,
!unresolved);
}
public ProjectDescription GetDescription(string name,
string path,
LockFileTargetLibrary targetLibrary,
Func<string, Project> projectCacheResolver)
{
var project = _resolveProject(Path.GetDirectoryName(path));
if (project != null)
{
return GetDescription(targetLibrary.TargetFramework, project);
}
else
{
return new ProjectDescription(name, path);
}
}
private void PopulateLegacyPortableDependencies(NuGetFramework targetFramework, List<LibraryRange> dependencies, string packagePath, LockFileTargetLibrary targetLibrary)
{
var seen = new HashSet<string>();
foreach (var assembly in targetLibrary.CompileTimeAssemblies)
{
if (IsPlaceholderFile(assembly))
{
continue;
}
// (ref/lib)/{tfm}/{assembly}
var pathParts = assembly.Path.Split(Path.DirectorySeparatorChar);
if (pathParts.Length != 3)
{
continue;
}
var assemblyTargetFramework = NuGetFramework.Parse(pathParts[1]);
if (!assemblyTargetFramework.IsPCL)
{
continue;
}
var assemblyPath = Path.Combine(packagePath, assembly.Path);
foreach (var dependency in GetDependencies(assemblyPath))
{
if (seen.Add(dependency))
{
string path;
Version version;
// If there exists a reference assembly on the requested framework with the same name then turn this into a
// framework assembly dependency
if (_frameworkReferenceResolver.TryGetAssembly(dependency, targetFramework, out path, out version))
{
dependencies.Add(new LibraryRange(dependency,
LibraryType.ReferenceAssembly,
LibraryDependencyType.Build));
}
}
}
}
}
public void HasCompileTimePlaceholderReturnsFalseIfEmpty()
{
var provider = new PackageDependencyProvider("/foo/packages", new FrameworkReferenceResolver("/foo/references"));
var package = new LockFilePackageLibrary();
package.Name = "Something";
package.Version = NuGetVersion.Parse("1.0.0");
var target = new LockFileTargetLibrary();
target.Name = "Something";
target.Version = package.Version;
var p1 = provider.GetDescription(NuGetFramework.Parse("net46"), package, target);
Assert.False(p1.HasCompileTimePlaceholder);
Assert.Equal(0, p1.CompileTimeAssemblies.Count());
Assert.Equal(0, p1.RuntimeAssemblies.Count());
}
public PackageDescription(
string path,
LockFilePackageLibrary package,
LockFileTargetLibrary lockFileLibrary,
IEnumerable<LibraryRange> dependencies,
bool compatible)
: base(new LibraryIdentity(package.Name, package.Version, LibraryType.Package),
"sha512-" + package.Sha512,
path,
dependencies: dependencies,
framework: null,
resolved: compatible,
compatible: compatible)
{
Library = package;
Target = lockFileLibrary;
}
private void PopulateDependencies(List<LibraryRange> dependencies, LockFileTargetLibrary targetLibrary)
{
foreach (var dependency in targetLibrary.Dependencies)
{
dependencies.Add(new LibraryRange(
dependency.Id,
dependency.VersionRange,
LibraryType.Unspecified,
LibraryDependencyType.Default));
}
foreach (var frameworkAssembly in targetLibrary.FrameworkAssemblies)
{
dependencies.Add(new LibraryRange(
frameworkAssembly,
LibraryType.ReferenceAssembly,
LibraryDependencyType.Default));
}
}
private static void AssertTargetLibrary(Microsoft.DotNet.ProjectModel.Graph.LockFileTargetLibrary library)
{
var libraryNumber = LibraryNumberFromName(library);
library.Type.Should().Be("project");
library.Name.Should().Be("ClassLibrary" + libraryNumber);
library.Version.ToNormalizedString().Should().Be("1.0.0");
var dll = $"bin/Debug/ClassLibrary{libraryNumber}.dll";
dll = dll.Replace('/', Path.DirectorySeparatorChar);
library.CompileTimeAssemblies.Count.Should().Be(1);
library.CompileTimeAssemblies.ElementAt(0).Path.Should().Be(dll);
library.RuntimeAssemblies.Count.Should().Be(1);
library.RuntimeAssemblies.ElementAt(0).Path.Should().Be(dll);
}
public TargetLibraryWithAssets(
LibraryIdentity libraryIdentity,
string sha512,
string path,
LockFileTargetLibrary lockFileLibrary,
IEnumerable<LibraryRange> dependencies,
bool compatible,
bool resolved,
NuGetFramework framework = null)
: base(
libraryIdentity,
sha512,
path,
dependencies: dependencies,
framework: null,
resolved: resolved,
compatible: compatible)
{
TargetLibrary = lockFileLibrary;
}
private LockFileTargetLibrary ReadTargetLibrary(string property, JToken json)
{
var jobject = json as JObject;
if (jobject == null)
{
throw FileFormatException.Create("The value type is not an object.", json);
}
var library = new LockFileTargetLibrary();
var parts = property.Split(new[] { '/' }, 2);
library.Name = _symbols.GetString(parts[0]);
if (parts.Length == 2)
{
library.Version = _symbols.GetVersion(parts[1]);
}
library.Type = _symbols.GetString(jobject.Value <string>("type"));
var framework = jobject.Value <string>("framework");
if (framework != null)
{
library.TargetFramework = _symbols.GetFramework(framework);
}
library.Dependencies = ReadObject(jobject.Value <JObject>("dependencies"), ReadPackageDependency);
library.FrameworkAssemblies = new HashSet <string>(ReadArray(jobject["frameworkAssemblies"], ReadFrameworkAssemblyReference), StringComparer.OrdinalIgnoreCase);
library.RuntimeAssemblies = ReadObject(jobject.Value <JObject>("runtime"), ReadFileItem);
library.CompileTimeAssemblies = ReadObject(jobject.Value <JObject>("compile"), ReadFileItem);
library.ResourceAssemblies = ReadObject(jobject.Value <JObject>("resource"), ReadFileItem);
library.NativeLibraries = ReadObject(jobject.Value <JObject>("native"), ReadFileItem);
library.ContentFiles = ReadObject(jobject.Value <JObject>("contentFiles"), ReadContentFile);
library.RuntimeTargets = ReadObject(jobject.Value <JObject>("runtimeTargets"), ReadRuntimeTarget);
return(library);
}
public MSBuildProjectDescription(
string path,
string msbuildProjectPath,
LockFileProjectLibrary projectLibrary,
LockFileTargetLibrary lockFileLibrary,
Project projectFile,
IEnumerable<LibraryRange> dependencies,
bool compatible,
bool resolved)
: base(
new LibraryIdentity(projectLibrary.Name, projectLibrary.Version, LibraryType.MSBuildProject),
string.Empty, //msbuild projects don't have hashes
path,
lockFileLibrary,
dependencies,
resolved: resolved,
compatible: compatible,
framework: null)
{
MSBuildProjectPath = msbuildProjectPath;
ProjectFile = projectFile;
ProjectLibrary = projectLibrary;
}
private static int LibraryNumberFromName(Microsoft.DotNet.ProjectModel.Graph.LockFileTargetLibrary library)
{
var libraryName = library.Name;
return((int)char.GetNumericValue(libraryName[libraryName.Length - 1]));
}
private CommandSpec ResolveFromDependencyLibrary(
LockFileTargetLibrary toolLibrary,
string depsFilePath,
string commandName,
IEnumerable<string> allowedExtensions,
IEnumerable<string> commandArguments,
ProjectContext projectContext)
{
return _packagedCommandSpecFactory.CreateCommandSpecFromLibrary(
toolLibrary,
commandName,
commandArguments,
allowedExtensions,
projectContext.PackagesDirectory,
s_commandResolutionStrategy,
depsFilePath);
}
public ProjectDescription GetDescription(string name, string path, LockFileTargetLibrary targetLibrary)
{
return GetDescription(name, path, targetLibrary, projectCacheResolver: null);
}
private static string GetTargetLibraryKey(LockFileTargetLibrary library)
{
return library.Name + "/" + library.Version;
}
private static object TypeName(LockFileTargetLibrary library)
{
return(library.Name + "/" + library.Version + "/" + library.Type);
}
private static string GetTargetLibraryKey(LockFileTargetLibrary library)
{
return(library.Name + "/" + library.Version);
}
private static object TypeName(LockFileTargetLibrary library)
{
return library.Name + "/" + library.Version + "/" + library.Type;
}
