private LockFileTarget ReadTarget(string property, JToken json) { var target = new LockFileTarget(); var parts = property.Split(new[] { '/' }, 2); target.TargetFramework = new FrameworkName(parts[0]); if (parts.Length == 2) { target.RuntimeIdentifier = parts[1]; } target.Libraries = ReadObject(json as JObject, ReadTargetLibrary); return(target); }
public void GivenATargetGraphVerifyLibraryReturned() { var graph = new LockFileTarget() { TargetFramework = NuGetFramework.Parse("net45"), }; graph.Libraries.Add(new LockFileTargetLibrary() { Name = "x", Version = NuGetVersion.Parse("1.0.0") }); graph.GetTargetLibrary("x").Version.ToNormalizedString().Should().Be("1.0.0"); }
public ProjectContext(LockFile lockFile, LockFileTarget lockFileTarget, LockFileTargetLibrary platformLibrary, bool isFrameworkDependent) { Debug.Assert(lockFile != null); Debug.Assert(lockFileTarget != null); if (isFrameworkDependent) { Debug.Assert(platformLibrary != null); } _lockFile = lockFile; _lockFileTarget = lockFileTarget; PlatformLibrary = platformLibrary; IsFrameworkDependent = isFrameworkDependent; }
private static void ReportDependency(LockFileTargetLibrary projectLibrary, LockFileTarget lockFileTargetFramework, int indentLevel) { // First indent Console.Write(String.Concat(Enumerable.Repeat("| ", (indentLevel - 1) * 2))); // Then use the last two character to make the heriarchy identifier Console.Write("|-"); Console.WriteLine($"{projectLibrary.Name}, v{projectLibrary.Version}{(projectLibrary.Framework != string.Empty ? COMMA_SEPARATOR + projectLibrary.Framework : string.Empty)}"); foreach (var childDependency in projectLibrary.Dependencies) { var childLibrary = lockFileTargetFramework.Libraries.FirstOrDefault(library => library.Name == childDependency.Id); ReportDependency(childLibrary, lockFileTargetFramework, indentLevel + 1); } }
private void ScanLibraries(LockFileTarget target, LockFileLookup lockFileLookup, Dictionary <LibraryKey, LibraryDescription> libraries, MSBuildDependencyProvider msbuildResolver, PackageDependencyProvider packageResolver, ProjectDependencyProvider projectResolver) { foreach (var library in target.Libraries) { LibraryDescription description = null; var type = LibraryType.Unspecified; if (string.Equals(library.Type, "project")) { var projectLibrary = lockFileLookup.GetProject(library.Name); if (projectLibrary != null) { if (MSBuildDependencyProvider.IsMSBuildProjectLibrary(projectLibrary)) { description = msbuildResolver.GetDescription(TargetFramework, projectLibrary, library, IsDesignTime); type = LibraryType.MSBuildProject; } else { var path = Path.GetFullPath(Path.Combine(ProjectDirectory, projectLibrary.Path)); description = projectResolver.GetDescription(library.Name, path, library, ProjectResolver); type = LibraryType.Project; } } } else { var packageEntry = lockFileLookup.GetPackage(library.Name, library.Version); if (packageEntry != null) { description = packageResolver.GetDescription(TargetFramework, packageEntry, library); } type = LibraryType.Package; } description = description ?? UnresolvedDependencyProvider.GetDescription(new LibraryRange(library.Name, type), target.TargetFramework); libraries.Add(new LibraryKey(library.Name), description); } }
public void BuildIntegratedNuGetProject_SortDependenciesWithProjects() { // Arrange var lockFile = new LockFile(); var target = new LockFileTarget(); lockFile.Targets.Add(target); var targetA = new LockFileTargetLibrary() { Name = "a", Version = NuGetVersion.Parse("1.0.0"), Type = "package" }; targetA.Dependencies.Add(new PackageDependency("b")); var targetB = new LockFileTargetLibrary() { Name = "b", Version = NuGetVersion.Parse("1.0.0"), Type = "project" }; targetA.Dependencies.Add(new PackageDependency("c")); var targetC = new LockFileTargetLibrary() { Name = "c", Version = NuGetVersion.Parse("1.0.0"), Type = "package" }; target.Libraries.Add(targetA); target.Libraries.Add(targetC); target.Libraries.Add(targetB); // Act var ordered = BuildIntegratedProjectUtility.GetOrderedLockFileDependencies(lockFile) .OrderBy(lib => lib.Name, StringComparer.Ordinal) .ToList(); // Assert Assert.Equal(3, ordered.Count); Assert.Equal("a", ordered[0].Name); Assert.Equal("b", ordered[1].Name); Assert.Equal("c", ordered[2].Name); }
private CompilationLibrary GetProjectCompilationLibrary( SingleProjectInfo projectInfo, LockFile lockFile, LockFileTarget lockFileTarget, Dictionary <string, Dependency> dependencyLookup) { List <Dependency> dependencies = GetProjectDependencies(lockFile, lockFileTarget, dependencyLookup); return(new CompilationLibrary( type: "project", name: projectInfo.Name, version: projectInfo.Version, hash: string.Empty, assemblies: new[] { projectInfo.GetOutputName() }, dependencies: dependencies.ToArray(), serviceable: false)); }
public CacheWriter(ResolvePackageAssets task) { var targetFramework = NuGetUtils.ParseFrameworkName(task.TargetFrameworkMoniker); _task = task; _lockFile = new LockFileCache(task).GetLockFile(task.ProjectAssetsFile); _packageResolver = NuGetPackageResolver.CreateResolver(_lockFile, _task.ProjectPath); _compileTimeTarget = _lockFile.GetTargetAndThrowIfNotFound(targetFramework, runtime: null); _runtimeTarget = _lockFile.GetTargetAndThrowIfNotFound(targetFramework, _task.RuntimeIdentifier); _stringTable = new Dictionary <string, int>(InitialStringTableCapacity, StringComparer.Ordinal); _metadataStrings = new List <string>(InitialStringTableCapacity); _bufferedMetadata = new List <int>(); var stream = File.Open(task.ProjectAssetsCacheFile, FileMode.Create, FileAccess.ReadWrite, FileShare.None); _writer = new BinaryWriter(stream, TextEncoding, leaveOpen: false); }
public ToolRestoreResult( string toolName, bool success, LockFileTarget lockFileTarget, LockFileTargetLibrary fileTargetLibrary, string lockFilePath, LockFile lockFile, LockFile previousLockFile) { ToolName = toolName; Success = success; LockFileTarget = lockFileTarget; FileTargetLibrary = fileTargetLibrary; LockFilePath = lockFilePath; LockFile = lockFile; PreviousLockFile = previousLockFile; }
public ProjectReferenceModel Analyze(PackageSpec project) { var frameworkModels = new List <ProjectReferenceModel>(); LockFile lockFile = GetLockFile(project.FilePath, project.RestoreMetadata.OutputPath); foreach (TargetFrameworkInformation targetFramework in project.TargetFrameworks) { LockFileTarget lockFileTargetFramework = lockFile.Targets.FirstOrDefault(t => t.TargetFramework.Equals(targetFramework.FrameworkName)); if (lockFileTargetFramework != null) { var framework = frameworkTargetAnalyzer.Analyze(targetFramework, lockFileTargetFramework); frameworkModels.Add(framework); } } return(new ProjectReferenceModel(project.Name, project.Version.ToString(), frameworkModels)); }
private static ITaskItem[] RaiseFrameworkAssemblies(LockFileTarget target, Action <string, ITaskItem> setup) { var items = new List <ITaskItem>(); foreach (var library in target.Libraries) { if (library.IsPackage()) { foreach (string frameworkAssembly in library.FrameworkAssemblies) { var item = CreatePackageAssetItem(library, frameworkAssembly); items.Add(item); setup?.Invoke(frameworkAssembly, item); } } } return(items.ToArray()); }
public ToolRestoreResult( string toolName, bool success, LockFileTarget lockFileTarget, LockFileTargetLibrary fileTargetLibrary, string lockFilePath, LockFile lockFile, LockFile previousLockFile) { ToolName = toolName; Success = success; LockFileTarget = lockFileTarget; FileTargetLibrary = fileTargetLibrary; LockFilePath = lockFilePath; LockFile = lockFile; PreviousLockFile = previousLockFile; // "locked" property is not supported on tools RelockFile = false; }
private IEnumerable <string> ExtractDependencies(LockFile lockFile) { // Get the libraries to import for targeting netstandard2.0 LockFileTarget netstandardTarget = lockFile.Targets .First(p => p.TargetFramework.Framework == NetStandardFramework && p.TargetFramework.Version == NetStandard20); // Collect all DLL files from CompileTimeAssemblies from that target // Note that we apply File.Exists since there may be muliple paths we're searching for each file listed List <string> dependencies = netstandardTarget.Libraries .SelectMany(p => p.CompileTimeAssemblies.Select(q => new { Library = p, Path = q.Path.Replace('/', Path.DirectorySeparatorChar) })) .Where(p => Path.GetExtension(p.Path) == ".dll") .SelectMany( _ => lockFile.PackageFolders.Select(p => p.Path), (dependency, folder) => Path.Combine(folder, dependency.Library.Name, dependency.Library.Version.ToString(), dependency.Path) ) .Where(File.Exists) .ToList(); // NETStandard.Library is a bit different, it has reference assemblies in the build/netstandard2.0/ref directory // which are imported via a MSBuild target file in the package. So we need to emulate that behavior here. LockFileTargetLibrary netstandardLibrary = netstandardTarget.Libraries.First(p => p.Name == NetStandardLibrary); string refDirectory = lockFile.PackageFolders.Select(p => p.Path) .Select(p => Path.Combine(p, netstandardLibrary.Name, netstandardLibrary.Version.ToString())) .First(Directory.Exists); refDirectory = Path.Combine(refDirectory, @"build\netstandard2.0\ref"); dependencies.AddRange(Directory.EnumerateFiles(refDirectory, "*.dll")); return(dependencies); }
public ProjectContext(LockFile lockFile, LockFileTarget lockFileTarget, // Trimmed from publish output, and if there are no runtimeFrameworks, written to runtimeconfig.json LockFileTargetLibrary platformLibrary, // Written to runtimeconfig.json RuntimeFramework[] runtimeFrameworks, bool isFrameworkDependent) { Debug.Assert(lockFile != null); Debug.Assert(lockFileTarget != null); if (isFrameworkDependent) { Debug.Assert(platformLibrary != null || (runtimeFrameworks != null && runtimeFrameworks.Any())); } _lockFile = lockFile; _lockFileTarget = lockFileTarget; PlatformLibrary = platformLibrary; RuntimeFrameworks = runtimeFrameworks; IsFrameworkDependent = isFrameworkDependent; }
public void Equals_WithTargetFramework(string left, string right, bool expected) { var leftSide = new LockFileTarget() { TargetFramework = NuGetFramework.Parse(left) }; var rightSide = new LockFileTarget() { TargetFramework = NuGetFramework.Parse(right) }; // Act & Assert if (expected) { leftSide.Should().Be(rightSide); } else { leftSide.Should().NotBe(rightSide); } }
public void Equals_WithRuntimeIdentifier(string left, string right, bool expected) { var leftSide = new LockFileTarget() { RuntimeIdentifier = left }; var rightSide = new LockFileTarget() { RuntimeIdentifier = right }; // Act & Assert if (expected) { leftSide.Should().Be(rightSide); } else { leftSide.Should().NotBe(rightSide); } }
private static IReadOnlyList <PackageDependency> GetTransitivePackagesForLibrary(LockFileTargetLibrary library, NuGetFramework targetFramework, IReadOnlyList <LockFileTarget> targets) { // PERF: Intentionally avoiding LINQ and foreach to avoid allocating capture classes and enumerators if (targets != null) { LockFileTarget target = default; for (int i = 0; i < targets.Count; ++i) { LockFileTarget t = targets[i]; if (t.TargetFramework.Equals(targetFramework) && string.IsNullOrEmpty(t.RuntimeIdentifier)) { target = t; break; } } if (target != null && target.Libraries != null) { var packageDependencies = new List <PackageDependency>(); for (int i = 0; i < target.Libraries.Count; ++i) { LockFileTargetLibrary lib = target.Libraries[i]; if (lib.Name.Equals(library.Name, StringComparison.OrdinalIgnoreCase)) { if (lib.Dependencies != null) { packageDependencies.AddRange(lib.Dependencies); } } } return(packageDependencies); } } return(null); }
// Collect C# source generators from the direct NuGet dependencies (ignores transitive dependencies) public List <ISourceGenerator> GetSourceGenerators(RestoreCommandProviders dependencyProviders, RestoreResult result, NuGetFramework targetFramework, AssemblyLoadContext assemblyLoadContext) { var generators = new List <ISourceGenerator>(); LockFileTarget lockFileTarget = result.LockFile.Targets .First(p => p.TargetFramework == targetFramework); foreach (var directDependency in _packageSpec.Dependencies .Concat(_packageSpec.TargetFrameworks .Where(p => p.FrameworkName == targetFramework) .SelectMany(framework => framework.Dependencies))) { // Get the exact version we restored var version = lockFileTarget.Libraries .FirstOrDefault(p => string.Equals(p.Name, directDependency.Name, StringComparison.OrdinalIgnoreCase))? .Version; if (version is not null) { NuGet.Repositories.LocalPackageInfo localPackageInfo = dependencyProviders.GlobalPackages.FindPackage(directDependency.Name, version); // For now, we explicitly only handle Roslyn 4.0 analyzers or unversioned analyzers // The regex also excludes resource assemblies in nested directories foreach (Match file in localPackageInfo.Files .Select(p => Regex.Match(p, @"^(analyzers/dotnet/(?:roslyn4\.0/)?cs/[^/]+\.dll$)")) .Where(p => p.Success)) { generators.AddRange(GetSourceGenerators( Path.Join(localPackageInfo.ExpandedPath, file.Groups[1].Value), assemblyLoadContext)); } } } return(generators); }
private void GetPackageAndFileDependencies(LockFileTarget target) { var resolvedPackageVersions = target.Libraries .ToDictionary(pkg => pkg.Name, pkg => pkg.Version.ToNormalizedString(), StringComparer.OrdinalIgnoreCase); string frameworkAlias = _targetNameToAliasMap[target.Name]; var transitiveProjectRefs = new HashSet <string>( target.Libraries .Where(lib => lib.IsTransitiveProjectReference(LockFile, ref _projectFileDependencies, frameworkAlias)) .Select(pkg => pkg.Name), StringComparer.OrdinalIgnoreCase); foreach (var package in target.Libraries) { string packageId = $"{package.Name}/{package.Version.ToNormalizedString()}"; if (_projectFileDependencies.Contains(package.Name)) { TaskItem item = new TaskItem(packageId); item.SetMetadata(MetadataKeys.ParentTarget, frameworkAlias); // Foreign Key item.SetMetadata(MetadataKeys.ParentPackage, string.Empty); // Foreign Key _packageDependencies.Add(item); } // get sub package dependencies GetPackageDependencies(package, target.Name, resolvedPackageVersions, transitiveProjectRefs); if (EmitLegacyAssetsFileItems) { // get file dependencies on this package GetFileDependencies(package, target.Name); } } }
protected IEnumerable <RuntimeLibrary> GetNugetReferences(string projectFilePath, Project project) { Logger.WriteInfo("Adding nuget references."); ICollection <RuntimeLibrary> runtimeLibraries = new List <RuntimeLibrary>(); LockFileFormat lockFileFormat = new LockFileFormat(); string lockFileFilePath = Path.Combine(Path.GetDirectoryName(projectFilePath), project.GetPropertyValue(PropertyNames.ProjectAssetsFile)); if (!File.Exists(lockFileFilePath)) { Logger.WriteError($"Lock file {lockFileFilePath} not found. Run dotnet restore before executing Automaty."); throw new AutomatyException(); } LockFile lockFile = lockFileFormat.Read(lockFileFilePath); string targetFramework = project.GetPropertyValue(PropertyNames.TargetFramework); if (string.IsNullOrEmpty(targetFramework)) { Logger.WriteDebug("Multi targeting project assembly detected."); targetFramework = GetSuitableTargetFramework(project.GetPropertyValue(PropertyNames.TargetFrameworks)); Logger.WriteDebug($"Using target framework {targetFramework}."); } LockFileTarget lockFileTarget = lockFile.GetTarget(NuGetUtils.ParseFrameworkName(targetFramework), string.Empty); NuGetPackageResolver nuGetPackageResolver = NuGetPackageResolver.CreateResolver(lockFile, Path.GetDirectoryName(projectFilePath)); // Add nuget references foreach (LockFileTargetLibrary library in lockFileTarget.Libraries) { if (library.Type != LibraryType.Package) { continue; } string packageDirectory = nuGetPackageResolver.GetPackageDirectory(library.Name, library.Version); foreach (LockFileItem file in library.RuntimeAssemblies.Where(file => !NuGetUtils.IsPlaceholderFile(file.Path))) { string filePath = Path.GetFullPath(Path.Combine(packageDirectory, file.Path)); Logger.WriteDebug($"Adding \"{filePath}\"."); runtimeLibraries.Add(new RuntimeLibrary { Name = library.Name, DirectoryName = Path.GetDirectoryName(filePath), FileName = Path.GetFileName(filePath) }); } } return(runtimeLibraries); }
public LockFile CreateLockFile(LockFile previousLockFile, PackageSpec project, IEnumerable <RestoreTargetGraph> targetGraphs, IReadOnlyList <NuGetv3LocalRepository> localRepositories, RemoteWalkContext context) { var lockFile = new LockFile() { Version = _lockFileVersion }; var previousLibraries = previousLockFile?.Libraries.ToDictionary(l => Tuple.Create(l.Name, l.Version)); if (project.RestoreMetadata?.ProjectStyle == ProjectStyle.PackageReference || project.RestoreMetadata?.ProjectStyle == ProjectStyle.DotnetToolReference) { AddProjectFileDependenciesForPackageReference(project, lockFile, targetGraphs); } else { AddProjectFileDependenciesForSpec(project, lockFile); } // Record all libraries used foreach (var item in targetGraphs.SelectMany(g => g.Flattened).Distinct() .OrderBy(x => x.Data.Match.Library)) { var library = item.Data.Match.Library; if (project.Name.Equals(library.Name, StringComparison.OrdinalIgnoreCase)) { // Do not include the project itself as a library. continue; } if (library.Type == LibraryType.Project || library.Type == LibraryType.ExternalProject) { // Project var localMatch = (LocalMatch)item.Data.Match; var projectLib = new LockFileLibrary() { Name = library.Name, Version = library.Version, Type = LibraryType.Project, }; // Set the relative path if a path exists // For projects without project.json this will be empty if (!string.IsNullOrEmpty(localMatch.LocalLibrary.Path)) { projectLib.Path = PathUtility.GetRelativePath( project.FilePath, localMatch.LocalLibrary.Path, '/'); } // The msbuild project path if it exists object msbuildPath; if (localMatch.LocalLibrary.Items.TryGetValue(KnownLibraryProperties.MSBuildProjectPath, out msbuildPath)) { var msbuildRelativePath = PathUtility.GetRelativePath( project.FilePath, (string)msbuildPath, '/'); projectLib.MSBuildProject = msbuildRelativePath; } lockFile.Libraries.Add(projectLib); } else if (library.Type == LibraryType.Package) { // Packages var packageInfo = NuGetv3LocalRepositoryUtility.GetPackage(localRepositories, library.Name, library.Version); // Add the library if it was resolved, unresolved packages are not added to the assets file. if (packageInfo != null) { var package = packageInfo.Package; var resolver = packageInfo.Repository.PathResolver; var sha512 = package.Sha512; var path = PathUtility.GetPathWithForwardSlashes(resolver.GetPackageDirectory(package.Id, package.Version)); LockFileLibrary lockFileLib = null; LockFileLibrary previousLibrary = null; if (previousLibraries?.TryGetValue(Tuple.Create(package.Id, package.Version), out previousLibrary) == true) { // Check that the previous library is still valid if (previousLibrary != null && StringComparer.Ordinal.Equals(path, previousLibrary.Path) && StringComparer.Ordinal.Equals(sha512, previousLibrary.Sha512)) { // We mutate this previous library so we must take a clone of it. This is // important because later, when deciding whether the lock file has changed, // we compare the new lock file to the previous (in-memory) lock file. lockFileLib = previousLibrary.Clone(); } } // Create a new lock file library if one doesn't exist already. if (lockFileLib == null) { lockFileLib = CreateLockFileLibrary(package, sha512, path); } // Create a new lock file library lockFile.Libraries.Add(lockFileLib); } } } var libraries = lockFile.Libraries.ToDictionary(lib => Tuple.Create(lib.Name, lib.Version)); var librariesWithWarnings = new HashSet <LibraryIdentity>(); var rootProjectStyle = project.RestoreMetadata?.ProjectStyle ?? ProjectStyle.Unknown; // Cache package data and selection criteria across graphs. var builderCache = new LockFileBuilderCache(); // Add the targets foreach (var targetGraph in targetGraphs .OrderBy(graph => graph.Framework.ToString(), StringComparer.Ordinal) .ThenBy(graph => graph.RuntimeIdentifier, StringComparer.Ordinal)) { var target = new LockFileTarget { TargetFramework = targetGraph.Framework, RuntimeIdentifier = targetGraph.RuntimeIdentifier }; var flattenedFlags = IncludeFlagUtils.FlattenDependencyTypes(_includeFlagGraphs, project, targetGraph); // Check if warnings should be displayed for the current framework. var tfi = project.GetTargetFramework(targetGraph.Framework); bool warnForImportsOnGraph = tfi.Warn && (target.TargetFramework is FallbackFramework || target.TargetFramework is AssetTargetFallbackFramework); foreach (var graphItem in targetGraph.Flattened.OrderBy(x => x.Key)) { var library = graphItem.Key; // include flags LibraryIncludeFlags includeFlags; if (!flattenedFlags.TryGetValue(library.Name, out includeFlags)) { includeFlags = ~LibraryIncludeFlags.ContentFiles; } if (library.Type == LibraryType.Project || library.Type == LibraryType.ExternalProject) { if (project.Name.Equals(library.Name, StringComparison.OrdinalIgnoreCase)) { // Do not include the project itself as a library. continue; } var projectLib = LockFileUtils.CreateLockFileTargetProject( graphItem, library, includeFlags, targetGraph, rootProjectStyle); target.Libraries.Add(projectLib); continue; } else if (library.Type == LibraryType.Package) { var packageInfo = NuGetv3LocalRepositoryUtility.GetPackage(localRepositories, library.Name, library.Version); if (packageInfo == null) { continue; } var package = packageInfo.Package; var targetLibrary = LockFileUtils.CreateLockFileTargetLibrary( libraries[Tuple.Create(library.Name, library.Version)], package, targetGraph, dependencyType: includeFlags, targetFrameworkOverride: null, dependencies: graphItem.Data.Dependencies, cache: builderCache); target.Libraries.Add(targetLibrary); // Log warnings if the target library used the fallback framework if (warnForImportsOnGraph && !librariesWithWarnings.Contains(library)) { var nonFallbackFramework = new NuGetFramework(target.TargetFramework); var targetLibraryWithoutFallback = LockFileUtils.CreateLockFileTargetLibrary( libraries[Tuple.Create(library.Name, library.Version)], package, targetGraph, targetFrameworkOverride: nonFallbackFramework, dependencyType: includeFlags, dependencies: graphItem.Data.Dependencies, cache: builderCache); if (!targetLibrary.Equals(targetLibraryWithoutFallback)) { var libraryName = DiagnosticUtility.FormatIdentity(library); var message = string.Format(CultureInfo.CurrentCulture, Strings.Log_ImportsFallbackWarning, libraryName, GetFallbackFrameworkString(target.TargetFramework), nonFallbackFramework); var logMessage = RestoreLogMessage.CreateWarning( NuGetLogCode.NU1701, message, library.Name, targetGraph.TargetGraphName); _logger.Log(logMessage); // only log the warning once per library librariesWithWarnings.Add(library); } } } } lockFile.Targets.Add(target); } PopulatePackageFolders(localRepositories.Select(repo => repo.RepositoryRoot).Distinct(), lockFile); AddCentralTransitiveDependencyGroupsForPackageReference(project, lockFile, targetGraphs); // Add the original package spec to the lock file. lockFile.PackageSpec = project; return(lockFile); }
public ProjectContext Build() { ProjectDirectory = Project?.ProjectDirectory ?? ProjectDirectory; if (GlobalSettings == null) { RootDirectory = ProjectRootResolver.ResolveRootDirectory(ProjectDirectory); GlobalSettings globalSettings; if (GlobalSettings.TryGetGlobalSettings(RootDirectory, out globalSettings)) { GlobalSettings = globalSettings; } } RootDirectory = GlobalSettings?.DirectoryPath ?? RootDirectory; PackagesDirectory = PackagesDirectory ?? PackageDependencyProvider.ResolvePackagesPath(RootDirectory, GlobalSettings); ReferenceAssembliesPath = ReferenceAssembliesPath ?? GetDefaultReferenceAssembliesPath(); LockFileLookup lockFileLookup = null; EnsureProjectLoaded(); LockFile = LockFile ?? LockFileResolver(ProjectDirectory); var validLockFile = true; string lockFileValidationMessage = null; if (LockFile != null) { validLockFile = LockFile.IsValidForProject(Project, out lockFileValidationMessage); lockFileLookup = new LockFileLookup(LockFile); } var libraries = new Dictionary <LibraryKey, LibraryDescription>(); var projectResolver = new ProjectDependencyProvider(Settings); var mainProject = projectResolver.GetDescription(TargetFramework, Project); // Add the main project libraries.Add(new LibraryKey(mainProject.Identity.Name), mainProject); LockFileTarget target = null; if (lockFileLookup != null) { target = SelectTarget(LockFile); if (target != null) { var packageResolver = new PackageDependencyProvider(PackagesDirectory); ScanLibraries(target, lockFileLookup, libraries, packageResolver, projectResolver); } } var frameworkReferenceResolver = new FrameworkReferenceResolver(ReferenceAssembliesPath); var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(frameworkReferenceResolver); bool requiresFrameworkAssemblies; // Resolve the dependencies ResolveDependencies(libraries, referenceAssemblyDependencyResolver, out requiresFrameworkAssemblies); var diagnostics = new List <DiagnosticMessage>(); // REVIEW: Should this be in NuGet (possibly stored in the lock file?) if (LockFile == null) { diagnostics.Add(new DiagnosticMessage( ErrorCodes.NU1009, $"The expected lock file doesn't exist. Please run \"dotnet restore\" to generate a new lock file.", Path.Combine(Project.ProjectDirectory, LockFile.FileName), DiagnosticMessageSeverity.Error)); } if (!validLockFile) { diagnostics.Add(new DiagnosticMessage( ErrorCodes.NU1006, $"{lockFileValidationMessage}. Please run \"dotnet restore\" to generate a new lock file.", Path.Combine(Project.ProjectDirectory, LockFile.FileName), DiagnosticMessageSeverity.Warning)); } if (requiresFrameworkAssemblies) { var frameworkInfo = Project.GetTargetFramework(TargetFramework); if (string.IsNullOrEmpty(ReferenceAssembliesPath)) { // If there was an attempt to use reference assemblies but they were not installed // report an error diagnostics.Add(new DiagnosticMessage( ErrorCodes.DOTNET1012, $"The reference assemblies directory was not specified. You can set the location using the DOTNET_REFERENCE_ASSEMBLIES_PATH environment variable.", filePath: Project.ProjectFilePath, severity: DiagnosticMessageSeverity.Error, startLine: frameworkInfo.Line, startColumn: frameworkInfo.Column )); } else if (!frameworkReferenceResolver.IsInstalled(TargetFramework)) { // If there was an attempt to use reference assemblies but they were not installed // report an error diagnostics.Add(new DiagnosticMessage( ErrorCodes.DOTNET1011, $"Framework not installed: {TargetFramework.DotNetFrameworkName} in {ReferenceAssembliesPath}", filePath: Project.ProjectFilePath, severity: DiagnosticMessageSeverity.Error, startLine: frameworkInfo.Line, startColumn: frameworkInfo.Column )); } } // Create a library manager var libraryManager = new LibraryManager(libraries.Values.ToList(), diagnostics, Project.ProjectFilePath); return(new ProjectContext( GlobalSettings, mainProject, TargetFramework, target?.RuntimeIdentifier, PackagesDirectory, libraryManager)); }
public void LibrariesAreResolvedCorrectly(string packageName, string framework, bool resolved) { var net45Target = new LockFileTarget { TargetFramework = new FrameworkName(".NETFramework,Version=v4.5"), Libraries = new List <LockFileTargetLibrary> { new LockFileTargetLibrary { Name = "MetaPackage", Version = SemanticVersion.Parse("1.0.0"), }, new LockFileTargetLibrary { Name = "Net451LibPackage", Version = SemanticVersion.Parse("1.0.0"), }, new LockFileTargetLibrary { Name = "Net451RefPackage", Version = SemanticVersion.Parse("1.0.0"), }, new LockFileTargetLibrary { Name = "AssemblyPlaceholderPackage", Version = SemanticVersion.Parse("1.0.0"), CompileTimeAssemblies = new List <LockFileItem> { Path.Combine("ref", "net45", "_._") }, RuntimeAssemblies = new List <LockFileItem> { Path.Combine("lib", "net45", "_._") } } } }; var dnx451Target = new LockFileTarget { TargetFramework = new FrameworkName("DNX,Version=v4.5.1"), Libraries = new List <LockFileTargetLibrary> { new LockFileTargetLibrary { Name = "MetaPackage", Version = SemanticVersion.Parse("1.0.0") }, new LockFileTargetLibrary { Name = "Net451LibPackage", Version = SemanticVersion.Parse("1.0.0"), CompileTimeAssemblies = new List <LockFileItem> { Path.Combine("lib", "net451", "Net451LibPackage.dll") }, RuntimeAssemblies = new List <LockFileItem> { Path.Combine("lib", "net451", "Net451LibPackage.dll") } }, new LockFileTargetLibrary { Name = "Net451RefPackage", Version = SemanticVersion.Parse("1.0.0"), CompileTimeAssemblies = new List <LockFileItem> { Path.Combine("ref", "net451", "Net451LibPackage.dll") } }, new LockFileTargetLibrary { Name = "AssemblyPlaceholderPackage", Version = SemanticVersion.Parse("1.0.0") } } }; var metaPackageLibrary = new LockFilePackageLibrary { Name = "MetaPackage", Version = SemanticVersion.Parse("1.0.0") }; var net451LibPackageLibrary = new LockFilePackageLibrary { Name = "Net451LibPackage", Version = SemanticVersion.Parse("1.0.0"), Files = new List <string> { Path.Combine("lib", "net451", "Net451LibPackage.dll"), Path.Combine("lib", "net451", "Net451LibPackage.xml") } }; var net451RefPackageLibrary = new LockFilePackageLibrary { Name = "Net451RefPackage", Version = SemanticVersion.Parse("1.0.0"), Files = new List <string> { Path.Combine("ref", "net451", "Net451LibPackage.dll") } }; var assemblyPlaceholderPackageLibrary = new LockFilePackageLibrary { Name = "AssemblyPlaceholderPackage", Version = SemanticVersion.Parse("1.0.0"), Files = new List <string> { Path.Combine("lib", "net45", "_._"), Path.Combine("ref", "net45", "_._"), } }; var lockFile = new LockFile() { Targets = new List <LockFileTarget> { net45Target, dnx451Target }, PackageLibraries = new List <LockFilePackageLibrary> { metaPackageLibrary, net451LibPackageLibrary, net451RefPackageLibrary, assemblyPlaceholderPackageLibrary } }; var resolver = new PackageDependencyProvider("/path/to/packages"); var lockFileLookup = new LockFileLookup(lockFile); var targetFramework = new FrameworkName(framework); var libToLookup = lockFile.Targets.First(t => t.TargetFramework == targetFramework) .Libraries .First(l => l.Name == packageName); var description = resolver.GetDescription(lockFileLookup.GetPackage(libToLookup.Name, libToLookup.Version), libToLookup); Assert.Equal(resolved, description.Compatible); Assert.NotNull(description); }
private static void ReportDependency(List <Dependency> dependencies, LockFileTargetLibrary projectLibrary, LockFileTarget lockFileTargetFramework, bool AutoReferenced, List <string> packageCollection) { Dependency targetDependency = new Dependency(); dependencies.Add(targetDependency); targetDependency.name = projectLibrary.Name; targetDependency.key = $"netcore:{projectLibrary.Name}"; targetDependency.versions.Add(projectLibrary.Version.ToNormalizedString()); //targetDependency.checksum = ""; //targetDependency.homepageUrl = ""; //targetDependency.repoUrl = ""; //targetDependency.description = projectLibrary.Version.ToFullString(); //targetDependency.licences.Add(new licence() { name = projectLibrary.Version.ToFullString(), url = "" }); if (!AutoReferenced) { packageCollection.Add(projectLibrary.Name); foreach (var childDependency in projectLibrary.Dependencies) { var childLibrary = lockFileTargetFramework.Libraries.FirstOrDefault(library => library.Name == childDependency.Id); bool SystemReferenced = MetaPackagesSkipper.MetaPackages.Any(x => x == childLibrary.Name) || packageCollection.Any(x => x == childLibrary.Name); ReportDependency(targetDependency.dependencies, childLibrary, lockFileTargetFramework, SystemReferenced, packageCollection); } } }
private void AddDependencies(TargetFramework targetFramework, LockFileTargetLibrary parentLibrary, LockFileTarget target, int level, int transitiveDepth) { if (parentLibrary?.Dependencies != null) { foreach (var packageDependency in parentLibrary.Dependencies) { var childLibrary = target.Libraries.FirstOrDefault(library => library.Name == packageDependency.Id); // Only add library and process child dependencies if we have not come across this dependency before if (!targetFramework.Dependencies.Any(dependency => dependency.Name == packageDependency.Id)) { var childDependency = new Dependency(packageDependency.Id, packageDependency.VersionRange, childLibrary?.Version, false, true, false); targetFramework.Dependencies.Add(childDependency); // Process the dependency for this project depency if (level < transitiveDepth) { AddDependencies(targetFramework, childLibrary, target, level + 1, transitiveDepth); } } } } }
public void LibrariesAreResolvedCorrectly(string packageName, string framework, bool resolved) { var net45Target = new LockFileTarget { TargetFramework = new FrameworkName(".NETFramework,Version=v4.5"), Libraries = new List<LockFileTargetLibrary> { new LockFileTargetLibrary { Name = "MetaPackage", Version = SemanticVersion.Parse("1.0.0"), }, new LockFileTargetLibrary { Name = "Net451LibPackage", Version = SemanticVersion.Parse("1.0.0"), }, new LockFileTargetLibrary { Name = "Net451RefPackage", Version = SemanticVersion.Parse("1.0.0"), }, new LockFileTargetLibrary { Name = "AssemblyPlaceholderPackage", Version = SemanticVersion.Parse("1.0.0"), CompileTimeAssemblies = new List<LockFileItem> { Path.Combine("ref", "net45", "_._") }, RuntimeAssemblies = new List<LockFileItem> { Path.Combine("lib", "net45", "_._") } } } }; var dnx451Target = new LockFileTarget { TargetFramework = new FrameworkName("DNX,Version=v4.5.1"), Libraries = new List<LockFileTargetLibrary> { new LockFileTargetLibrary { Name = "MetaPackage", Version = SemanticVersion.Parse("1.0.0") }, new LockFileTargetLibrary { Name = "Net451LibPackage", Version = SemanticVersion.Parse("1.0.0"), CompileTimeAssemblies = new List<LockFileItem> { Path.Combine("lib", "net451", "Net451LibPackage.dll") }, RuntimeAssemblies = new List<LockFileItem> { Path.Combine("lib", "net451", "Net451LibPackage.dll") } }, new LockFileTargetLibrary { Name = "Net451RefPackage", Version = SemanticVersion.Parse("1.0.0"), CompileTimeAssemblies = new List<LockFileItem> { Path.Combine("ref", "net451", "Net451LibPackage.dll") } }, new LockFileTargetLibrary { Name = "AssemblyPlaceholderPackage", Version = SemanticVersion.Parse("1.0.0") } } }; var metaPackageLibrary = new LockFilePackageLibrary { Name = "MetaPackage", Version = SemanticVersion.Parse("1.0.0") }; var net451LibPackageLibrary = new LockFilePackageLibrary { Name = "Net451LibPackage", Version = SemanticVersion.Parse("1.0.0"), Files = new List<string> { Path.Combine("lib", "net451", "Net451LibPackage.dll"), Path.Combine("lib", "net451", "Net451LibPackage.xml") } }; var net451RefPackageLibrary = new LockFilePackageLibrary { Name = "Net451RefPackage", Version = SemanticVersion.Parse("1.0.0"), Files = new List<string> { Path.Combine("ref", "net451", "Net451LibPackage.dll") } }; var assemblyPlaceholderPackageLibrary = new LockFilePackageLibrary { Name = "AssemblyPlaceholderPackage", Version = SemanticVersion.Parse("1.0.0"), Files = new List<string> { Path.Combine("lib", "net45", "_._"), Path.Combine("ref", "net45", "_._"), } }; var lockFile = new LockFile() { Targets = new List<LockFileTarget> { net45Target, dnx451Target }, PackageLibraries = new List<LockFilePackageLibrary> { metaPackageLibrary, net451LibPackageLibrary, net451RefPackageLibrary, assemblyPlaceholderPackageLibrary } }; var resolver = new PackageDependencyProvider("/path/to/packages"); var lockFileLookup = new LockFileLookup(lockFile); var targetFramework = new FrameworkName(framework); var libToLookup = lockFile.Targets.First(t => t.TargetFramework == targetFramework) .Libraries .First(l => l.Name == packageName); var description = resolver.GetDescription(lockFileLookup.GetPackage(libToLookup.Name, libToLookup.Version), libToLookup); Assert.Equal(resolved, description.Compatible); Assert.NotNull(description); }
private static Dependency ReportDependency(LockFileTargetLibrary projectLibrary, LockFileTarget lockFileTargetFramework, int indentLevel, Dependency dependency = null) { if (projectLibrary == null) return null; if (indentLevel == 1) dependency = new Dependency(projectLibrary.Name, projectLibrary.Version.OriginalVersion); // stringBuilder.Append(new string(' ', indentLevel * 2)); // stringBuilder.AppendLine($"{projectLibrary.Name}, v{projectLibrary.Version}"); foreach (var childDependency in projectLibrary.Dependencies) { var childLibrary = lockFileTargetFramework.Libraries.FirstOrDefault(library => library.Name == childDependency.Id); dependency.Children.Add(new Dependency(childDependency.Id, childDependency.VersionRange.MinVersion.OriginalVersion) { Parent = dependency.Name }); ReportDependency(childLibrary, lockFileTargetFramework, indentLevel + 1, dependency); } return dependency; }
private void AddDependencies(Project.Dependency parentDependency, LockFileTargetLibrary parentLibrary, LockFileTarget target, int level, int transitiveDepth) { if (parentLibrary?.Dependencies != null) { foreach (var packageDependency in parentLibrary.Dependencies) { var childLibrary = target.Libraries.FirstOrDefault(library => library.Name == packageDependency.Id); var childDependency = new Project.Dependency { Name = packageDependency.Id, VersionRange = packageDependency.VersionRange, ResolvedVersion = childLibrary?.Version }; parentDependency.Dependencies.Add(childDependency); // Process the dependency for this project depency if (level < transitiveDepth) { AddDependencies(childDependency, childLibrary, target, level + 1, transitiveDepth); } } } }
static public IEnumerable <string> GetTopLevelDependencies(LockFile lockFile, LockFileTarget lockFileTarget) { Dictionary <string, LockFileTargetLibrary> libraryLookup = lockFileTarget.Libraries.ToDictionary(l => l.Name, StringComparer.OrdinalIgnoreCase); return(lockFile .ProjectFileDependencyGroups .Where(dg => dg.FrameworkName == string.Empty || dg.FrameworkName == lockFileTarget.TargetFramework.DotNetFrameworkName) .SelectMany(g => g.Dependencies) .Select(projectFileDependency => { int separatorIndex = projectFileDependency.IndexOf(' '); string libraryName = separatorIndex > 0 ? projectFileDependency.Substring(0, separatorIndex) : projectFileDependency; if (!string.IsNullOrEmpty(libraryName) && libraryLookup.ContainsKey(libraryName)) { return libraryName; } return null; }) .Where(libraryName => libraryName != null) .ToArray()); }
public LockFile CreateLockFile( LockFile previousLockFile, PackageSpec project, IEnumerable <RestoreTargetGraph> targetGraphs, IReadOnlyList <NuGetv3LocalRepository> localRepositories, RemoteWalkContext context) { var lockFile = new LockFile(); lockFile.Version = _lockFileVersion; var previousLibraries = previousLockFile?.Libraries.ToDictionary(l => Tuple.Create(l.Name, l.Version)); if (project.RestoreMetadata?.ProjectStyle == ProjectStyle.PackageReference) { AddProjectFileDependenciesForNETCore(project, lockFile, targetGraphs); } else { AddProjectFileDependenciesForSpec(project, lockFile); } // Record all libraries used foreach (var item in targetGraphs.SelectMany(g => g.Flattened).Distinct() .OrderBy(x => x.Data.Match.Library)) { var library = item.Data.Match.Library; if (project.Name.Equals(library.Name, StringComparison.OrdinalIgnoreCase)) { // Do not include the project itself as a library. continue; } if (library.Type == LibraryType.Project || library.Type == LibraryType.ExternalProject) { // Project LocalMatch localMatch = (LocalMatch)item.Data.Match; var projectLib = new LockFileLibrary() { Name = library.Name, Version = library.Version, Type = LibraryType.Project, }; // Set the relative path if a path exists // For projects without project.json this will be empty if (!string.IsNullOrEmpty(localMatch.LocalLibrary.Path)) { projectLib.Path = PathUtility.GetRelativePath( project.FilePath, localMatch.LocalLibrary.Path, '/'); } // The msbuild project path if it exists object msbuildPath; if (localMatch.LocalLibrary.Items.TryGetValue(KnownLibraryProperties.MSBuildProjectPath, out msbuildPath)) { var msbuildRelativePath = PathUtility.GetRelativePath( project.FilePath, (string)msbuildPath, '/'); projectLib.MSBuildProject = msbuildRelativePath; } lockFile.Libraries.Add(projectLib); } else if (library.Type == LibraryType.Package) { // Packages var packageInfo = NuGetv3LocalRepositoryUtility.GetPackage(localRepositories, library.Name, library.Version); if (packageInfo == null) { continue; } var package = packageInfo.Package; var resolver = packageInfo.Repository.PathResolver; LockFileLibrary previousLibrary = null; if (previousLibraries?.TryGetValue(Tuple.Create(package.Id, package.Version), out previousLibrary) == true) { // We mutate this previous library so we must take a clone of it. This is // important because later, when deciding whether the lock file has changed, // we compare the new lock file to the previous (in-memory) lock file. previousLibrary = previousLibrary.Clone(); } var sha512 = File.ReadAllText(resolver.GetHashPath(package.Id, package.Version)); var path = PathUtility.GetPathWithForwardSlashes( resolver.GetPackageDirectory(package.Id, package.Version)); var lockFileLib = previousLibrary; // If we have the same library in the lock file already, use that. if (previousLibrary == null || previousLibrary.Sha512 != sha512 || previousLibrary.Path != path) { lockFileLib = CreateLockFileLibrary( package, sha512, path); } else if (Path.DirectorySeparatorChar != LockFile.DirectorySeparatorChar) { // Fix slashes for content model patterns lockFileLib.Files = lockFileLib.Files .Select(p => p.Replace(Path.DirectorySeparatorChar, LockFile.DirectorySeparatorChar)) .ToList(); } lockFile.Libraries.Add(lockFileLib); var packageIdentity = new PackageIdentity(lockFileLib.Name, lockFileLib.Version); context.PackageFileCache.TryAdd(packageIdentity, lockFileLib.Files); } } var libraries = lockFile.Libraries.ToDictionary(lib => Tuple.Create(lib.Name, lib.Version)); var warnForImports = project.TargetFrameworks.Any(framework => framework.Warn); var librariesWithWarnings = new HashSet <LibraryIdentity>(); var rootProjectStyle = project.RestoreMetadata?.ProjectStyle ?? ProjectStyle.Unknown; // Add the targets foreach (var targetGraph in targetGraphs .OrderBy(graph => graph.Framework.ToString(), StringComparer.Ordinal) .ThenBy(graph => graph.RuntimeIdentifier, StringComparer.Ordinal)) { var target = new LockFileTarget(); target.TargetFramework = targetGraph.Framework; target.RuntimeIdentifier = targetGraph.RuntimeIdentifier; var flattenedFlags = IncludeFlagUtils.FlattenDependencyTypes(_includeFlagGraphs, project, targetGraph); var fallbackFramework = target.TargetFramework as FallbackFramework; var warnForImportsOnGraph = warnForImports && fallbackFramework != null; foreach (var graphItem in targetGraph.Flattened.OrderBy(x => x.Key)) { var library = graphItem.Key; // include flags LibraryIncludeFlags includeFlags; if (!flattenedFlags.TryGetValue(library.Name, out includeFlags)) { includeFlags = ~LibraryIncludeFlags.ContentFiles; } if (library.Type == LibraryType.Project || library.Type == LibraryType.ExternalProject) { if (project.Name.Equals(library.Name, StringComparison.OrdinalIgnoreCase)) { // Do not include the project itself as a library. continue; } var projectLib = LockFileUtils.CreateLockFileTargetProject( graphItem, library, includeFlags, targetGraph, rootProjectStyle); target.Libraries.Add(projectLib); continue; } else if (library.Type == LibraryType.Package) { var packageInfo = NuGetv3LocalRepositoryUtility.GetPackage(localRepositories, library.Name, library.Version); if (packageInfo == null) { continue; } var package = packageInfo.Package; var targetLibrary = LockFileUtils.CreateLockFileTargetLibrary( libraries[Tuple.Create(library.Name, library.Version)], package, targetGraph, dependencyType: includeFlags, targetFrameworkOverride: null, dependencies: graphItem.Data.Dependencies); target.Libraries.Add(targetLibrary); // Log warnings if the target library used the fallback framework if (warnForImportsOnGraph && !librariesWithWarnings.Contains(library)) { var nonFallbackFramework = new NuGetFramework(fallbackFramework); var targetLibraryWithoutFallback = LockFileUtils.CreateLockFileTargetLibrary( libraries[Tuple.Create(library.Name, library.Version)], package, targetGraph, targetFrameworkOverride: nonFallbackFramework, dependencyType: includeFlags, dependencies: graphItem.Data.Dependencies); if (!targetLibrary.Equals(targetLibraryWithoutFallback)) { var libraryName = $"{library.Name} {library.Version}"; _logger.LogWarning(string.Format(CultureInfo.CurrentCulture, Strings.Log_ImportsFallbackWarning, libraryName, String.Join(", ", fallbackFramework.Fallback), nonFallbackFramework)); // only log the warning once per library librariesWithWarnings.Add(library); } } } } lockFile.Targets.Add(target); } PopulatePackageFolders(localRepositories.Select(repo => repo.RepositoryRoot).Distinct(), lockFile); // Add the original package spec to the lock file. lockFile.PackageSpec = project; return(lockFile); }
public void LockFileFormat_WritesLockFileWithTools() { // Arrange string lockFileContent = @"{ ""version"": 2, ""targets"": {}, ""libraries"": {}, ""projectFileDependencyGroups"": {}, ""tools"": { "".NETPlatform,Version=v5.0"": { ""System.Runtime/4.0.20-beta-22927"": { ""type"": ""package"", ""dependencies"": { ""Frob"": ""4.0.20"" }, ""compile"": { ""ref/dotnet/System.Runtime.dll"": {} } } } }, ""projectFileToolGroups"": { """": [ ""System.Runtime [4.0.10-beta-*, )"" ], "".NETPlatform,Version=v5.0"": [] } }"; var lockFile = new LockFile(); lockFile.Version = 2; var target = new LockFileTarget() { TargetFramework = FrameworkConstants.CommonFrameworks.DotNet }; var targetLib = new LockFileTargetLibrary() { Name = "System.Runtime", Version = NuGetVersion.Parse("4.0.20-beta-22927"), Type = LibraryType.Package }; targetLib.Dependencies.Add(new NuGet.Packaging.Core.PackageDependency("Frob", new VersionRange(NuGetVersion.Parse("4.0.20")))); targetLib.CompileTimeAssemblies.Add(new LockFileItem("ref/dotnet/System.Runtime.dll")); target.Libraries.Add(targetLib); lockFile.Tools.Add(target); lockFile.ProjectFileToolGroups.Add( new ProjectFileDependencyGroup("", new string[] { "System.Runtime [4.0.10-beta-*, )" })); lockFile.ProjectFileToolGroups.Add( new ProjectFileDependencyGroup(FrameworkConstants.CommonFrameworks.DotNet.DotNetFrameworkName, new string[0])); // Act var lockFileFormat = new LockFileFormat(); var output = JObject.Parse(lockFileFormat.Render(lockFile)); var expected = JObject.Parse(lockFileContent); // Assert Assert.Equal(expected.ToString(), output.ToString()); }
public void LibrariesAreResolvedCorrectly(string packageName, string framework, bool resolved) { var repo = new PackageRepository("path/to/packages"); var resolver = new NuGetDependencyResolver(repo); var net45Target = new LockFileTarget { TargetFramework = new FrameworkName(".NETFramework,Version=v4.5"), Libraries = new List<LockFileTargetLibrary> { new LockFileTargetLibrary { Name = "MetaPackage", Version = SemanticVersion.Parse("1.0.0"), }, new LockFileTargetLibrary { Name = "Net451LibPackage", Version = SemanticVersion.Parse("1.0.0"), }, new LockFileTargetLibrary { Name = "Net451RefPackage", Version = SemanticVersion.Parse("1.0.0"), }, new LockFileTargetLibrary { Name = "AssemblyPlaceholderPackage", Version = SemanticVersion.Parse("1.0.0"), CompileTimeAssemblies = new List<LockFileItem> { Path.Combine("ref", "net45", "_._") }, RuntimeAssemblies = new List<LockFileItem> { Path.Combine("lib", "net45", "_._") } } } }; var dnx451Target = new LockFileTarget { TargetFramework = new FrameworkName("DNX,Version=v4.5.1"), Libraries = new List<LockFileTargetLibrary> { new LockFileTargetLibrary { Name = "MetaPackage", Version = SemanticVersion.Parse("1.0.0") }, new LockFileTargetLibrary { Name = "Net451LibPackage", Version = SemanticVersion.Parse("1.0.0"), CompileTimeAssemblies = new List<LockFileItem> { Path.Combine("lib", "net451", "Net451LibPackage.dll") }, RuntimeAssemblies = new List<LockFileItem> { Path.Combine("lib", "net451", "Net451LibPackage.dll") } }, new LockFileTargetLibrary { Name = "Net451RefPackage", Version = SemanticVersion.Parse("1.0.0"), CompileTimeAssemblies = new List<LockFileItem> { Path.Combine("ref", "net451", "Net451LibPackage.dll") } }, new LockFileTargetLibrary { Name = "AssemblyPlaceholderPackage", Version = SemanticVersion.Parse("1.0.0") } } }; var metaPackageLibrary = new LockFilePackageLibrary { Name = "MetaPackage", Version = SemanticVersion.Parse("1.0.0") }; var net451LibPackageLibrary = new LockFilePackageLibrary { Name = "Net451LibPackage", Version = SemanticVersion.Parse("1.0.0"), Files = new List<string> { Path.Combine("lib", "net451", "Net451LibPackage.dll"), Path.Combine("lib", "net451", "Net451LibPackage.xml") } }; var net451RefPackageLibrary = new LockFilePackageLibrary { Name = "Net451RefPackage", Version = SemanticVersion.Parse("1.0.0"), Files = new List<string> { Path.Combine("ref", "net451", "Net451LibPackage.dll") } }; var assemblyPlaceholderPackageLibrary = new LockFilePackageLibrary { Name = "AssemblyPlaceholderPackage", Version = SemanticVersion.Parse("1.0.0"), Files = new List<string> { Path.Combine("lib", "net45", "_._"), Path.Combine("ref", "net45", "_._"), } }; var lockFile = new LockFile() { Targets = new List<LockFileTarget> { net45Target, dnx451Target }, PackageLibraries = new List<LockFilePackageLibrary> { metaPackageLibrary, net451LibPackageLibrary, net451RefPackageLibrary, assemblyPlaceholderPackageLibrary } }; resolver.ApplyLockFile(lockFile); var libToLookup = new LibraryRange(packageName, frameworkReference: false); Assert.Equal(resolved, resolver.GetDescription(libToLookup, new FrameworkName(framework)).Resolved); }