private PackageData[] GetPackageDependencies(string targetPackagesPath, NuGetFramework targetFramework)
{
List <PackageData> dependencies = new List <PackageData>();
PackageDependencyGroup group = this.nReader.GetDependencyGroups().GetNearest(targetFramework);
if (group != null)
{
foreach (var pkg in group.Packages)
{
var repository = new NuGetv3LocalRepository(targetPackagesPath);
var dependencyPkgs = repository.FindPackagesById(pkg.Id);
var allVersions = dependencyPkgs.Select(d => d.Version);
NuGetVersion selectedVersion = pkg.VersionRange.FindBestMatch(allVersions);
var selectedPkg = dependencyPkgs.FirstOrDefault(d => d.Version == selectedVersion);
if (selectedPkg != null)
{
var pkgData = PackageData.GetPackageData(selectedPkg.Id, selectedPkg.Version.ToString());
if (pkgData != null)
{
dependencies.Add(pkgData);
}
}
}
}
else
{
Console.WriteLine($"ERROR: Group not found for {this.SourceFileName} TFM {targetFramework}.");
}
return(dependencies.ToArray());
}
private LockFile BuildLockFile(
LockFile existingLockFile,
PackageSpec project,
IEnumerable <RestoreTargetGraph> graphs,
NuGetv3LocalRepository localRepository,
RemoteWalkContext contextForProject,
IEnumerable <ToolRestoreResult> toolRestoreResults,
bool relockFile)
{
// Build the lock file
LockFile lockFile;
if (existingLockFile != null && existingLockFile.IsLocked)
{
// No lock file to write!
lockFile = existingLockFile;
}
else
{
lockFile = new LockFileBuilder(_request.LockFileVersion, _logger, _includeFlagGraphs)
.CreateLockFile(
existingLockFile,
project,
graphs,
localRepository,
contextForProject,
toolRestoreResults);
// If the lock file was locked originally but we are re-locking it, well... re-lock it :)
lockFile.IsLocked = relockFile;
}
return(lockFile);
}
public static RestoreCommandProviders Create(
string globalFolderPath,
IEnumerable <SourceRepository> sources,
SourceCacheContext cacheContext,
ILogger log)
{
var globalPackages = new NuGetv3LocalRepository(globalFolderPath);
var globalPackagesSource = Repository.Factory.GetCoreV3(globalFolderPath);
var localProviders = new List <IRemoteDependencyProvider>()
{
// Do not throw or warn for gloabal cache
new SourceRepositoryDependencyProvider(globalPackagesSource, log, cacheContext, ignoreFailedSources: true, ignoreWarning: true)
};
var remoteProviders = new List <IRemoteDependencyProvider>();
foreach (var source in sources)
{
var provider = new SourceRepositoryDependencyProvider(source, log, cacheContext);
remoteProviders.Add(provider);
}
return(new RestoreCommandProviders(globalPackages, localProviders, remoteProviders, cacheContext));
}
/// <summary>
/// Providers used by the restore command. These can be shared across restores.
/// </summary>
/// <param name="globalPackages">Path to the global packages folder.</param>
/// <param name="localProviders">This is typically just a provider for the global packages folder.</param>
/// <param name="remoteProviders">All dependency providers.</param>
/// <param name="cacheContext">Web cache context.</param>
public RestoreCommandProviders(
NuGetv3LocalRepository globalPackages,
IReadOnlyList <IRemoteDependencyProvider> localProviders,
IReadOnlyList <IRemoteDependencyProvider> remoteProviders,
SourceCacheContext cacheContext)
{
if (globalPackages == null)
{
throw new ArgumentNullException(nameof(globalPackages));
}
if (localProviders == null)
{
throw new ArgumentNullException(nameof(localProviders));
}
if (remoteProviders == null)
{
throw new ArgumentNullException(nameof(remoteProviders));
}
if (cacheContext == null)
{
throw new ArgumentNullException(nameof(cacheContext));
}
GlobalPackages = globalPackages;
LocalProviders = localProviders;
RemoteProviders = remoteProviders;
CacheContext = cacheContext;
}
public async Task NuGetv3LocalRepository_FindPackagesById_LeavesVersionCaseFoundOnFileSystem()
{
// Arrange
using (var workingDir = TestDirectory.Create())
{
var id = "Foo";
var target = new NuGetv3LocalRepository(workingDir);
await SimpleTestPackageUtility.CreateFolderFeedV3(
workingDir,
PackageSaveMode.Defaultv3,
new SimpleTestPackageContext(id, "1.0.0"),
new SimpleTestPackageContext(id, "2.0.0-Beta"));
// Act
var packages = target.FindPackagesById(id);
// Assert
Assert.Equal(2, packages.Count());
packages = packages.OrderBy(x => x.Version);
Assert.Equal(id, packages.ElementAt(0).Id);
Assert.Equal("1.0.0", packages.ElementAt(0).Version.ToNormalizedString());
Assert.Equal(id, packages.ElementAt(1).Id);
Assert.Equal("2.0.0-beta", packages.ElementAt(1).Version.ToNormalizedString());
}
}
private async Task <bool> InstallPackageAsync(RemoteMatch installItem, NuGetv3LocalRepository userPackageFolder, PackageExtractionContext packageExtractionContext, CancellationToken token)
{
var packageIdentity = new PackageIdentity(installItem.Library.Name, installItem.Library.Version);
// Check if the package has already been installed.
if (!userPackageFolder.Exists(packageIdentity.Id, packageIdentity.Version))
{
var versionFolderPathResolver = new VersionFolderPathResolver(_request.PackagesDirectory);
try
{
using (var packageDependency = await installItem.Provider.GetPackageDownloaderAsync(
packageIdentity,
_request.CacheContext,
_logger,
token))
{
// Install, returns true if the package was actually installed.
// Returns false if the package was a noop once the lock
// was acquired.
var installed = await PackageExtractor.InstallFromSourceAsync(
packageIdentity,
packageDependency,
versionFolderPathResolver,
packageExtractionContext,
token,
ParentId);
// 1) If another project in this process installs the package this will return false but userPackageFolder will contain the package.
// 2) If another process installs the package then this will also return false but we still need to update the cache.
// For #2 double check that the cache has the package now otherwise clear
if (installed || !userPackageFolder.Exists(packageIdentity.Id, packageIdentity.Version))
{
// If the package was added, clear the cache so that the next caller can see it.
// Avoid calling this for packages that were not actually installed.
userPackageFolder.ClearCacheForIds(new string[] { packageIdentity.Id });
}
}
}
catch (SignatureException e)
{
if (!string.IsNullOrEmpty(e.Message))
{
await _logger.LogAsync(e.AsLogMessage());
}
// If the package is unsigned and unsigned packages are not allowed a SignatureException
// will be thrown but it won't have results because it didn't went through any
// verification provider.
if (e.Results != null)
{
await _logger.LogMessagesAsync(e.Results.SelectMany(p => p.Issues));
}
return(false);
}
}
return(true);
}
public static RestoreCommandProviders Create(
string globalFolderPath,
IEnumerable <string> fallbackPackageFolderPaths,
IEnumerable <SourceRepository> sources,
SourceCacheContext cacheContext,
ILogger log)
{
var globalPackages = new NuGetv3LocalRepository(globalFolderPath);
var globalPackagesSource = Repository.Factory.GetCoreV3(globalFolderPath, FeedType.FileSystemV3);
var localProviders = new List <IRemoteDependencyProvider>()
{
// Do not throw or warn for global cache
new SourceRepositoryDependencyProvider(
globalPackagesSource,
log,
cacheContext,
ignoreFailedSources: true,
ignoreWarning: true)
};
// Add fallback sources as local providers also
var fallbackPackageFolders = new List <NuGetv3LocalRepository>();
foreach (var path in fallbackPackageFolderPaths)
{
var fallbackRepository = new NuGetv3LocalRepository(path);
var fallbackSource = Repository.Factory.GetCoreV3(path, FeedType.FileSystemV3);
var provider = new SourceRepositoryDependencyProvider(
fallbackSource,
log,
cacheContext,
ignoreFailedSources: false,
ignoreWarning: false);
fallbackPackageFolders.Add(fallbackRepository);
localProviders.Add(provider);
}
var remoteProviders = new List <IRemoteDependencyProvider>();
foreach (var source in sources)
{
var provider = new SourceRepositoryDependencyProvider(
source,
log,
cacheContext,
cacheContext.IgnoreFailedSources,
ignoreWarning: false);
remoteProviders.Add(provider);
}
return(new RestoreCommandProviders(
globalPackages,
fallbackPackageFolders,
localProviders,
remoteProviders));
}
/// <summary>
/// Providers used by the restore command. These can be shared across restores.
/// </summary>
/// <param name="globalPackages">Path to the global packages folder.</param>
/// <param name="fallbackPackageFolders">Path to any fallback package folders.</param>
/// <param name="localProviders">This is typically just a provider for the global packages folder.</param>
/// <param name="remoteProviders">All dependency providers.</param>
public RestoreCommandProviders(
NuGetv3LocalRepository globalPackages,
IReadOnlyList <NuGetv3LocalRepository> fallbackPackageFolders,
IReadOnlyList <IRemoteDependencyProvider> localProviders,
IReadOnlyList <IRemoteDependencyProvider> remoteProviders)
{
if (globalPackages == null)
{
throw new ArgumentNullException(nameof(globalPackages));
}
if (fallbackPackageFolders == null)
{
throw new ArgumentNullException(nameof(fallbackPackageFolders));
}
if (localProviders == null)
{
throw new ArgumentNullException(nameof(localProviders));
}
if (remoteProviders == null)
{
throw new ArgumentNullException(nameof(remoteProviders));
}
GlobalPackages = globalPackages;
LocalProviders = localProviders;
RemoteProviders = remoteProviders;
FallbackPackageFolders = fallbackPackageFolders;
}
private Task <RestoreTargetGraph[]> WalkRuntimeDependenciesAsync(LibraryRange projectRange,
RestoreTargetGraph graph,
IEnumerable <string> runtimeIds,
RemoteDependencyWalker walker,
RemoteWalkContext context,
NuGetv3LocalRepository localRepository,
RuntimeGraph runtimes,
bool writeToLockFile,
CancellationToken token)
{
var resultGraphs = new List <Task <RestoreTargetGraph> >();
foreach (var runtimeName in runtimeIds)
{
_logger.LogVerbose(string.Format(CultureInfo.CurrentCulture, Strings.Log_RestoringPackages, FrameworkRuntimePair.GetName(graph.Framework, runtimeName)));
resultGraphs.Add(WalkDependenciesAsync(projectRange,
graph.Framework,
runtimeName,
runtimes,
walker,
context,
writeToLockFile,
token));
}
return(Task.WhenAll(resultGraphs));
}
public async Task NuGetv3LocalRepository_FindPackage_VerifyNuspecsCached()
{
// Arrange
using (var workingDir = TestDirectory.Create())
{
var id = "Foo";
var target = new NuGetv3LocalRepository(workingDir);
await SimpleTestPackageUtility.CreateFolderFeedV3(
workingDir,
PackageSaveMode.Defaultv3,
new SimpleTestPackageContext(id, "1.0.0"),
new SimpleTestPackageContext(id, "2.0.0-Beta"));
// Act
var package1 = target.FindPackage(id, NuGetVersion.Parse("2.0.0-beta"));
var package2 = target.FindPackage(id, NuGetVersion.Parse("2.0.0-BETA"));
var package3 = target.FindPackage(id, NuGetVersion.Parse("2.0.0-beta"));
// Assert
Assert.True(ReferenceEquals(package1, package3));
Assert.True(ReferenceEquals(package1.Nuspec, package2.Nuspec));
Assert.True(ReferenceEquals(package1.Nuspec, package3.Nuspec));
// These should contain different versions
Assert.False(ReferenceEquals(package1, package2));
}
}
public async Task NuGetv3LocalRepository_FindPackagesById_InstallStress()
{
// Arrange
using (var workingDir = TestDirectory.Create())
{
var id = "a";
var target = new NuGetv3LocalRepository(workingDir);
var packages = new ConcurrentQueue <PackageIdentity>();
var limit = 100;
for (int i = 0; i < limit; i++)
{
packages.Enqueue(new PackageIdentity(id, NuGetVersion.Parse($"{i + 1}.0.0")));
}
var tasks = new List <Task>();
var sem = new ManualResetEventSlim(false);
for (int i = 0; i < 10; i++)
{
tasks.Add(Task.Run(async() =>
{
sem.Wait();
PackageIdentity identity;
while (packages.TryDequeue(out identity))
{
// Fetch
var result = target.FindPackagesById(identity.Id)
.FirstOrDefault(f => f.Version == identity.Version);
Assert.Null(result);
// Create package
await SimpleTestPackageUtility.CreateFolderFeedV3(workingDir,
PackageSaveMode.Defaultv3,
identity);
// Clear
target.ClearCacheForIds(new[] { identity.Id });
result = target.FindPackagesById(identity.Id)
.FirstOrDefault(f => f.Version == identity.Version);
// Assert the package was found
Assert.NotNull(result);
}
}));
}
sem.Set();
await Task.WhenAll(tasks);
// Assert
var results2 = target.FindPackagesById(id);
Assert.Equal(limit, results2.Count());
}
}
private static IList <CompatibilityCheckResult> VerifyCompatibility(
PackageSpec project,
Dictionary <RestoreTargetGraph, Dictionary <string, LibraryIncludeFlags> > includeFlagGraphs,
NuGetv3LocalRepository localRepository,
LockFile lockFile,
IEnumerable <RestoreTargetGraph> graphs,
ILogger logger)
{
// Scan every graph for compatibility, as long as there were no unresolved packages
var checkResults = new List <CompatibilityCheckResult>();
if (graphs.All(g => !g.Unresolved.Any()))
{
var checker = new CompatibilityChecker(localRepository, lockFile, logger);
foreach (var graph in graphs)
{
logger.LogVerbose(string.Format(CultureInfo.CurrentCulture, Strings.Log_CheckingCompatibility, graph.Name));
var includeFlags = IncludeFlagUtils.FlattenDependencyTypes(includeFlagGraphs, project, graph);
var res = checker.Check(graph, includeFlags);
checkResults.Add(res);
if (res.Success)
{
logger.LogVerbose(string.Format(CultureInfo.CurrentCulture, Strings.Log_PackagesAndProjectsAreCompatible, graph.Name));
}
else
{
// Get error counts on a project vs package basis
var projectCount = res.Issues.Count(issue => issue.Type == CompatibilityIssueType.ProjectIncompatible);
var packageCount = res.Issues.Count(issue => issue.Type != CompatibilityIssueType.ProjectIncompatible);
// Log a summary with compatibility error counts
if (projectCount > 0)
{
logger.LogError(
string.Format(CultureInfo.CurrentCulture,
Strings.Log_ProjectsIncompatible,
graph.Name));
logger.LogDebug($"Incompatible projects: {projectCount}");
}
if (packageCount > 0)
{
logger.LogError(
string.Format(CultureInfo.CurrentCulture,
Strings.Log_PackagesIncompatible,
graph.Name));
logger.LogDebug($"Incompatible packages: {packageCount}");
}
}
}
}
return(checkResults);
}
public LocalPackageHelper()
{
var settings = Settings.LoadDefaultSettings(Directory.GetCurrentDirectory());
m_globalPackagesFolder = SettingsUtility.GetGlobalPackagesFolder(settings);
m_localRepository = new NuGetv3LocalRepository(m_globalPackagesFolder);
var psp = new PackageSourceProvider(settings);
var sources = psp.LoadPackageSources();
m_repositories = sources.Select(x => Repository.Factory.GetCoreV3(x.Source));
}
public async Task NuGetv3LocalRepository_Exists_WorksForAllCases(string id)
{
using (var workingDir = TestDirectory.Create())
{
var target = new NuGetv3LocalRepository(workingDir);
await SimpleTestPackageUtility.CreateFolderFeedV3(
workingDir,
PackageSaveMode.Defaultv3,
new SimpleTestPackageContext("foo", "1.0.0"));
target.Exists(id, NuGetVersion.Parse("1.0.0")).Should().BeTrue();
}
}
/// <summary>
/// Providers used by the restore command. These can be shared across restores.
/// </summary>
/// <param name="globalPackages">Path to the global packages folder.</param>
/// <param name="fallbackPackageFolders">Path to any fallback package folders.</param>
/// <param name="localProviders">This is typically just a provider for the global packages folder.</param>
/// <param name="remoteProviders">All dependency providers.</param>
/// <param name="packageFileCache">Nuspec and package file cache.</param>
public RestoreCommandProviders(
NuGetv3LocalRepository globalPackages,
IReadOnlyList <NuGetv3LocalRepository> fallbackPackageFolders,
IReadOnlyList <IRemoteDependencyProvider> localProviders,
IReadOnlyList <IRemoteDependencyProvider> remoteProviders,
LocalPackageFileCache packageFileCache)
{
GlobalPackages = globalPackages ?? throw new ArgumentNullException(nameof(globalPackages));
LocalProviders = localProviders ?? throw new ArgumentNullException(nameof(localProviders));
RemoteProviders = remoteProviders ?? throw new ArgumentNullException(nameof(remoteProviders));
FallbackPackageFolders = fallbackPackageFolders ?? throw new ArgumentNullException(nameof(fallbackPackageFolders));
PackageFileCache = packageFileCache ?? throw new ArgumentNullException(nameof(packageFileCache));
}
public NuGetv3PackageFolder(
string physicalPath,
bool ignoreFailure,
ILogger logger)
{
_logger = logger;
// We need to help "kpm restore" to ensure case-sensitivity here
// Turn on the flag to get package ids in accurate casing
_repository = new NuGetv3LocalRepository(physicalPath, checkPackageIdCase: true);
Source = physicalPath;
_ignored = false;
_ignoreFailure = ignoreFailure;
}
public async Task NuGetv3LocalRepository_FindPackagesById_Stress()
{
// Arrange
using (var workingDir = TestDirectory.Create())
{
var id = "a";
var target = new NuGetv3LocalRepository(workingDir);
var packages = new List <PackageIdentity>();
for (int i = 0; i < 100; i++)
{
packages.Add(new PackageIdentity(id, NuGetVersion.Parse($"{i + 1}.0.0")));
}
await SimpleTestPackageUtility.CreateFolderFeedV3(workingDir, packages.ToArray());
var tasks = new List <Task>();
var sem = new ManualResetEventSlim(false);
for (int i = 0; i < 10; i++)
{
tasks.Add(Task.Run(() =>
{
sem.Wait();
for (int j = 0; j < 100; j++)
{
// Fetch
var result = target.FindPackagesById(id);
// Assert
Assert.Equal(100, result.Count());
// Clear
for (int k = 0; k < 100; k++)
{
target.ClearCacheForIds(new[] { id });
}
}
}));
}
sem.Set();
await Task.WhenAll(tasks);
// Assert
var results2 = target.FindPackagesById(id);
Assert.Equal(100, results2.Count());
}
}
public async Task NuGetv3LocalRepository_Exists_DoesNotExist()
{
using (var workingDir = TestDirectory.Create())
{
var target = new NuGetv3LocalRepository(workingDir);
await SimpleTestPackageUtility.CreateFolderFeedV3(
workingDir,
PackageSaveMode.Defaultv3,
new SimpleTestPackageContext("foo", "1.0.0"));
target.Exists("foo", NuGetVersion.Parse("2.0.0")).Should().BeFalse();
target.Exists("bar", NuGetVersion.Parse("1.0.0")).Should().BeFalse();
}
}
public void NuGetv3LocalRepository_FindPackagesById_ReturnsEmptySequenceWithIdNotFound()
{
// Arrange
using (var workingDir = TestDirectory.Create())
{
var target = new NuGetv3LocalRepository(workingDir);
// Act
var packages = target.FindPackagesById("Foo");
// Assert
Assert.Empty(packages);
}
}
public void NuGetv3LocalRepository_FindPackage_ReturnsNullWithIdNotFound()
{
// Arrange
using (var workingDir = TestDirectory.Create())
{
var target = new NuGetv3LocalRepository(workingDir);
// Act
var package = target.FindPackage("Foo", NuGetVersion.Parse("2.0.0-BETA"));
// Assert
Assert.Null(package);
}
}
private async Task <bool> InstallPackagesAsync(
HashSet <LibraryIdentity> uniquePackages,
IEnumerable <RestoreTargetGraph> graphs,
IList <DownloadDependencyResolutionResult> downloadDependencyInformations,
NuGetv3LocalRepository userPackageFolder,
CancellationToken token)
{
var packagesToInstall = graphs
.SelectMany(g => g.Install.Where(match => uniquePackages.Add(match.Library))).ToList();
packagesToInstall.AddRange(
downloadDependencyInformations.
SelectMany(ddi => ddi.Install.Where(match => uniquePackages.Add(match.Library))));
var success = true;
if (packagesToInstall.Count > 0)
{
// Use up to MaxDegreeOfConcurrency, create less threads if less packages exist.
var threadCount = Math.Min(packagesToInstall.Count, _request.MaxDegreeOfConcurrency);
if (threadCount <= 1)
{
foreach (var match in packagesToInstall)
{
success &= (await InstallPackageAsync(match, userPackageFolder, _request.PackageExtractionContext, token));
}
}
else
{
var bag = new ConcurrentBag <RemoteMatch>(packagesToInstall);
var tasks = Enumerable.Range(0, threadCount)
.Select(async _ =>
{
RemoteMatch match;
var result = true;
while (bag.TryTake(out match))
{
result &= await InstallPackageAsync(match, userPackageFolder, _request.PackageExtractionContext, token);
}
return(result);
});
success = (await Task.WhenAll(tasks)).All(p => p);
}
}
return(success);
}
private RuntimeGraph GetRuntimeGraph(RestoreTargetGraph graph, NuGetv3LocalRepository localRepository)
{
// TODO: Caching!
RuntimeGraph runtimeGraph;
if (_request.RuntimeGraphCache.TryGetValue(graph.Framework, out runtimeGraph))
{
return(runtimeGraph);
}
_logger.LogVerbose(Strings.Log_ScanningForRuntimeJson);
runtimeGraph = RuntimeGraph.Empty;
graph.Graphs.ForEach(node =>
{
var match = node?.Item?.Data?.Match;
if (match == null)
{
return;
}
// Ignore runtime.json from rejected nodes
if (node.Disposition == Disposition.Rejected)
{
return;
}
// Locate the package in the local repository
var package = localRepository.FindPackagesById(match.Library.Name)
.FirstOrDefault(p => p.Version == match.Library.Version);
if (package != null)
{
var nextGraph = LoadRuntimeGraph(package);
if (nextGraph != null)
{
_logger.LogVerbose(string.Format(CultureInfo.CurrentCulture, Strings.Log_MergingRuntimes, match.Library));
runtimeGraph = RuntimeGraph.Merge(runtimeGraph, nextGraph);
}
}
});
_request.RuntimeGraphCache[graph.Framework] = runtimeGraph;
return(runtimeGraph);
}
public async Task NuGetv3LocalRepository_GenerateNupkgMetadataFile()
{
using (var workingDir = TestDirectory.Create())
{
var target = new NuGetv3LocalRepository(workingDir);
await SimpleTestPackageUtility.CreateFolderFeedV3Async(
workingDir,
PackageSaveMode.Defaultv3,
new SimpleTestPackageContext("foo", "1.0.0"));
var pathResolver = new VersionFolderPathResolver(workingDir);
File.Delete(pathResolver.GetNupkgMetadataPath("foo", new NuGetVersion("1.0.0")));
// Assert
target.Exists("foo", NuGetVersion.Parse("1.0.0")).Should().BeTrue();
File.Exists(pathResolver.GetNupkgMetadataPath("foo", new NuGetVersion("1.0.0")));
}
}
public async Task NuGetv3LocalRepository_FindPackage_ReturnsNullWithVersionNotFound()
{
// Arrange
using (var workingDir = TestDirectory.Create())
{
var id = "Foo";
var target = new NuGetv3LocalRepository(workingDir);
await SimpleTestPackageUtility.CreateFolderFeedV3(
workingDir,
PackageSaveMode.Defaultv3,
new SimpleTestPackageContext(id, "1.0.0"),
new SimpleTestPackageContext(id, "2.0.0-Beta"));
// Act
var package = target.FindPackage(id, NuGetVersion.Parse("3.0.0-BETA"));
// Assert
Assert.Null(package);
}
}
public async Task NuGetv3LocalRepository_FindPackage_VerifyRuntimeGraphCached()
{
// Arrange
using (var workingDir = TestDirectory.Create())
{
var id = "packageX";
var runtimeJsonX1 = @"{
""runtimes"": {
""unix"": {
""packageX"": {
""runtime.packageX"": ""1.0.0""
}
}
},
""supports"": {
""x1.app"": {
""uap10.0"": [
""win10-x86""
]
}
}
}";
var package = new SimpleTestPackageContext(id, "1.0.0");
package.RuntimeJson = runtimeJsonX1;
var target = new NuGetv3LocalRepository(workingDir);
await SimpleTestPackageUtility.CreateFolderFeedV3(
workingDir,
PackageSaveMode.Defaultv3,
package);
// Act
var packageResultA = target.FindPackage(id, NuGetVersion.Parse("1.0.0"));
var packageResultB = target.FindPackage(id, NuGetVersion.Parse("1.0.0"));
// Assert
Assert.True(ReferenceEquals(packageResultA.RuntimeGraph, packageResultB.RuntimeGraph));
}
}
public async Task NuGetv3LocalRepository_FindPackagesById_UsesProvidedIdCase()
{
// Arrange
using (var workingDir = TestDirectory.Create())
{
var id = "Foo";
var target = new NuGetv3LocalRepository(workingDir);
await SimpleTestPackageUtility.CreateFolderFeedV3(
workingDir,
PackageSaveMode.Defaultv3,
new SimpleTestPackageContext("foo", "1.0.0"));
// Act
var packages = target.FindPackagesById(id);
// Assert
Assert.Equal(1, packages.Count());
Assert.Equal(id, packages.ElementAt(0).Id);
Assert.Equal("1.0.0", packages.ElementAt(0).Version.ToNormalizedString());
}
}
public async Task NuGetv3LocalRepository_FindPackage_VerifyRuntimeGraphIsNullForNonExistantFile()
{
// Arrange
using (var workingDir = TestDirectory.Create())
{
var id = "packageX";
var package = new SimpleTestPackageContext(id, "1.0.0");
var target = new NuGetv3LocalRepository(workingDir);
await SimpleTestPackageUtility.CreateFolderFeedV3(
workingDir,
PackageSaveMode.Defaultv3,
package);
// Act
var packageResultA = target.FindPackage(id, NuGetVersion.Parse("1.0.0"));
// Assert
packageResultA.RuntimeGraph.Should().BeNull();
}
}
public async Task NuGetv3LocalRepository_FindPackage_UsesProvidedVersionCase()
{
// Arrange
using (var workingDir = TestDirectory.Create())
{
var id = "Foo";
var target = new NuGetv3LocalRepository(workingDir);
await SimpleTestPackageUtility.CreateFolderFeedV3(
workingDir,
PackageSaveMode.Defaultv3,
new SimpleTestPackageContext(id, "1.0.0"),
new SimpleTestPackageContext(id, "2.0.0-Beta"));
// Act
var package = target.FindPackage(id, NuGetVersion.Parse("2.0.0-BETA"));
// Assert
Assert.NotNull(package);
Assert.Equal(id, package.Id);
Assert.Equal("2.0.0-BETA", package.Version.ToNormalizedString());
}
}
private void GenerateImportsFile(NuGetv3LocalRepository repository, string path, List <string> imports)
{
var ns = XNamespace.Get("http://schemas.microsoft.com/developer/msbuild/2003");
var doc = new XDocument(
new XDeclaration("1.0", "utf-8", "no"),
new XElement(ns + "Project",
new XAttribute("ToolsVersion", "14.0"),
new XElement(ns + "PropertyGroup",
new XAttribute("Condition", "'$(NuGetPackageRoot)' == ''"),
new XElement(ns + "NuGetPackageRoot", repository.RepositoryRoot)),
new XElement(ns + "ImportGroup", imports.Select(i =>
new XElement(ns + "Import",
new XAttribute("Project", Path.Combine("$(NuGetPackageRoot)", i)),
new XAttribute("Condition", $"Exists('{Path.Combine("$(NuGetPackageRoot)", i)}')"))))));
using (var output = new FileStream(path, FileMode.Create, FileAccess.ReadWrite, FileShare.None))
{
doc.Save(output);
}
}
private async Task InstallPackageAsync(RemoteMatch installItem, NuGetv3LocalRepository userPackageFolder, CancellationToken token)
{
var packageIdentity = new PackageIdentity(installItem.Library.Name, installItem.Library.Version);
// Check if the package has already been installed.
if (!userPackageFolder.Exists(packageIdentity.Id, packageIdentity.Version))
{
var versionFolderPathContext = new VersionFolderPathContext(
packageIdentity,
_request.PackagesDirectory,
_logger,
_request.PackageSaveMode,
_request.XmlDocFileSaveMode);
using (var packageDependency = await installItem.Provider.GetPackageDownloaderAsync(
packageIdentity,
_request.CacheContext,
_logger,
token))
{
// Install, returns true if the package was actually installed.
// Returns false if the package was a noop once the lock
// was acquired.
var installed = await PackageExtractor.InstallFromSourceAsync(
packageDependency,
versionFolderPathContext,
token);
if (installed)
{
// If the package was added, clear the cache so that the next caller can see it.
// Avoid calling this for packages that were not actually installed.
userPackageFolder.ClearCacheForIds(new string[] { packageIdentity.Id });
}
}
}
}
