public async Task LatestDoesNotIncludeUnpublished()
{
//arrange
var metadata = PackageSearchMetadataBuilder.FromIdentity(new PackageIdentity("test", new NuGetVersion(1, 2, 3))).Build();
var metadataResource = Substitute.For <PackageMetadataResource>();
metadataResource.GetMetadataAsync(Arg.Any <string>(), Arg.Any <bool>(), Arg.Any <bool>(), Arg.Any <SourceCacheContext>(), Arg.Any <ILogger>(), Arg.Any <CancellationToken>())
.Returns(m => new List <IPackageSearchMetadata> {
metadata
}, m => throw new Exception(":("));
var v1 = new VersionInfo(new NuGetVersion(1, 2, 3), new DateTime(2015, 1, 1));
var v2 = new VersionInfo(new NuGetVersion(2, 3, 4), new DateTime(1900, 1, 1));
var versionCache = new Dictionary <string, IList <VersionInfo> > {
{ "test", new List <VersionInfo> {
v1, v2
} }
};
var checker = new PackageVersionChecker(metadataResource, versionCache);
//act
var result = await checker.GetResultTask("test", new NuGetVersion(1, 2, 3));
//assert
var latest = result.Latest.Version.ToString();
Assert.Equal("1.2.3", latest);
}
public void GetPackagesGetsPackages()
{
//arrange
var metadata = PackageSearchMetadataBuilder.FromIdentity(new PackageIdentity("test", new NuGetVersion(1, 2, 3))).Build();
var metadataResource = Substitute.For <PackageMetadataResource>();
metadataResource.GetMetadataAsync(Arg.Any <string>(), Arg.Any <bool>(), Arg.Any <bool>(), Arg.Any <SourceCacheContext>(), Arg.Any <ILogger>(), Arg.Any <CancellationToken>())
.Returns(m => new List <IPackageSearchMetadata> {
metadata
}, m => throw new Exception(":("));
var v1 = new VersionInfo(new NuGetVersion(1, 2, 3), new DateTime(2015, 1, 1));
var v2 = new VersionInfo(new NuGetVersion(2, 3, 4), new DateTime(2016, 1, 1));
var versionCache = new Dictionary <string, IList <VersionInfo> > {
{ "test", new List <VersionInfo> {
v1, v2
} }
};
var checker = new PackageVersionChecker(metadataResource, versionCache);
var project = new TestProjectFile("test", new Dictionary <string, NuGetVersion> {
{ "test", new NuGetVersion(1, 2, 3) }
});
//act
var packages = checker.GetPackages(new[] { project });
//assert
var latest = packages.First().Value.First().Latest.Version.ToString();
Assert.Equal("2.3.4", latest);
}
public async Task GetLocalPackageMetadataAsync_WhenGlobalSourceHasPackage_WithoutDeprecationMetadata()
{
// Arrange
var emptyTestMetadata = PackageSearchMetadataBuilder.FromIdentity(TestPackageIdentity).Build();
Mock.Get(_globalMetadataResource)
.Setup(x => x.GetMetadataAsync(TestPackageIdentity.Id, true, true, It.IsAny <SourceCacheContext>(), It.IsAny <Common.ILogger>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new[] { emptyTestMetadata });
Mock.Get(_metadataResource)
.Setup(x => x.GetMetadataAsync(TestPackageIdentity.Id, true, false, It.IsAny <SourceCacheContext>(), It.IsAny <Common.ILogger>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new[] { emptyTestMetadata });
// Act
var metadata = await _target.GetLocalPackageMetadataAsync(
TestPackageIdentity,
includePrerelease : true,
cancellationToken : CancellationToken.None);
// Assert
Mock.Get(_metadataResource).Verify(
x => x.GetMetadataAsync(TestPackageIdentity.Id, true, false, It.IsAny <SourceCacheContext>(), It.IsAny <Common.ILogger>(), It.IsAny <CancellationToken>()),
Times.Once);
Assert.Equal(new[] { "1.0.0" }, (await metadata.GetVersionsAsync()).Select(v => v.Version.ToString()).OrderBy(v => v));
Assert.Null(await metadata.GetDeprecationMetadataAsync());
}
internal override async Task <IPackageSearchMetadata> GetPackageMetadataAsync <T>(T identity, bool includePrerelease, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (identity is PackageCollectionItem pkgColItem)
{
IEnumerable <ITransitivePackageReferenceContextInfo> transitivePRs = pkgColItem.PackageReferences.OfType <ITransitivePackageReferenceContextInfo>();
ITransitivePackageReferenceContextInfo transitivePR = transitivePRs.OrderByDescending(x => x.Identity.Version).FirstOrDefault();
IReadOnlyCollection <PackageIdentity> transitiveOrigins = transitivePR?.TransitiveOrigins?.Select(to => to.Identity).ToArray() ?? Array.Empty <PackageIdentity>();
if (transitiveOrigins.Any())
{
// Get only local metadata. We don't want Deprecation and Vulnerabilities Metadata on Transitive packages
IPackageSearchMetadata packageMetadata = await _metadataProvider.GetOnlyLocalPackageMetadataAsync(pkgColItem, cancellationToken);
if (packageMetadata == null) // Edge case: local metadata not found
{
packageMetadata = PackageSearchMetadataBuilder.FromIdentity(pkgColItem).Build(); // create metadata object only with ID
}
return(new TransitivePackageSearchMetadata(packageMetadata, transitiveOrigins));
}
}
return(await base.GetPackageMetadataAsync(identity, includePrerelease, cancellationToken));
}
public static async Task <IPackageSearchMetadata> GetPackageMetadataAsync(
this SourceRepository sourceRepository, PackageIdentity identity, bool includePrerelease, CancellationToken cancellationToken)
{
var metadataResource = await sourceRepository.GetResourceAsync <PackageMetadataResource>(cancellationToken);
IEnumerable <IPackageSearchMetadata> packages = null;
if (metadataResource != null)
{
packages = await metadataResource.GetMetadataAsync(
identity.Id,
includePrerelease : true,
includeUnlisted : false,
log : Logging.NullLogger.Instance,
token : cancellationToken);
}
if (packages?.FirstOrDefault() == null)
{
return(null);
}
var packageMetadata = packages
.FirstOrDefault(p => p.Identity.Version == identity.Version)
?? PackageSearchMetadataBuilder.FromIdentity(identity).Build();
return(packageMetadata.WithVersions(ToVersionInfo(packages, includePrerelease)));
}
private static InstalledPackageReference CreateInstalledPackageReference(
bool autoReference = false,
bool isDeprecated = false,
string resolvedPackageVersionString = "1.0.0",
string latestPackageVersionString = "2.0.0")
{
const string packageId = "Package.Id";
var latestPackageVersion = new NuGetVersion(latestPackageVersionString);
var resolvedPackageVersion = new NuGetVersion(resolvedPackageVersionString);
var resolvedPackageMetadata = new Mock <IPackageSearchMetadata>();
resolvedPackageMetadata.Setup(m => m.Identity).Returns(new PackageIdentity(packageId, resolvedPackageVersion));
if (isDeprecated)
{
resolvedPackageMetadata
.Setup(m => m.GetDeprecationMetadataAsync())
.ReturnsAsync(new PackageDeprecationMetadata());
}
var installedPackageReference = new InstalledPackageReference(packageId)
{
AutoReference = autoReference,
LatestPackageMetadata = PackageSearchMetadataBuilder
.FromIdentity(new PackageIdentity(packageId, latestPackageVersion))
.Build(),
ResolvedPackageMetadata = resolvedPackageMetadata.Object
};
return(installedPackageReference);
}
public async Task <IPackageSearchMetadata> GetPackageMetadataAsync(PackageIdentity identity, bool includePrerelease, CancellationToken cancellationToken)
{
var tasks = _sourceRepositories
.Select(r => r.GetPackageMetadataAsync(identity, includePrerelease, cancellationToken))
.ToList();
if (_localRepository != null)
{
tasks.Add(_localRepository.GetPackageMetadataFromLocalSourceAsync(identity, cancellationToken));
}
var ignored = tasks
.Select(task => task.ContinueWith(LogError, TaskContinuationOptions.OnlyOnFaulted))
.ToArray();
var completed = (await Task.WhenAll(tasks))
.Where(m => m != null);
var master = completed.FirstOrDefault(m => !string.IsNullOrEmpty(m.Summary))
?? completed.FirstOrDefault()
?? PackageSearchMetadataBuilder.FromIdentity(identity).Build();
return(master.WithVersions(
asyncValueFactory: () => MergeVersionsAsync(identity, completed)));
}
internal static SourceRepository Create(IEnumerable <PackageDependencyInfo> packages)
{
var dependencyInfo = Substitute.For <DependencyInfoResource>();
var packageSearch = Substitute.For <PackageSearchResource>();
var repository = new SourceRepository(new PackageSource(string.Empty), new INuGetResourceProvider[]
{
new StubNuGetResourceProvider(dependencyInfo),
new StubNuGetResourceProvider(packageSearch),
});
foreach (var package in packages)
{
dependencyInfo.ResolvePackage(package, Arg.Any <NuGetFramework>(), Arg.Any <SourceCacheContext>(), Arg.Any <ILogger>(), Arg.Any <CancellationToken>())
.Returns(Task.FromResult(new SourcePackageDependencyInfo(package.Id, package.Version, package.Dependencies, true, repository)));
packageSearch.SearchAsync(package.Id, Arg.Any <SearchFilter>(), Arg.Any <int>(), Arg.Any <int>(), Arg.Any <ILogger>(), Arg.Any <CancellationToken>())
.Returns(new[] { PackageSearchMetadataBuilder.FromIdentity(package).Build() });
}
packageSearch.SearchAsync(string.Empty, Arg.Any <SearchFilter>(), Arg.Any <int>(), Arg.Any <int>(), Arg.Any <ILogger>(), Arg.Any <CancellationToken>())
.Returns(callInfo =>
packages
.GroupBy(p => p.Id)
.Select(g =>
{
var recentVersion = g.OrderByDescending(p => p.Version).First();
return(new PackageDependencyInfo(g.Key, recentVersion.Version, recentVersion.Dependencies));
})
.Select(package => PackageSearchMetadataBuilder.FromIdentity(package).Build())
.Skip(callInfo.ArgAt <int>(2))
.Take(callInfo.ArgAt <int>(3))
.ToList());
return(repository);
}
public static async Task <IPackageSearchMetadata> GetPackageMetadataAsync(
this SourceRepository sourceRepository, PackageIdentity identity, bool includePrerelease, CancellationToken cancellationToken)
{
var metadataResource = await sourceRepository.GetResourceAsync <PackageMetadataResource>(cancellationToken);
using (var sourceCacheContext = new SourceCacheContext())
{
// Update http source cache context MaxAge so that it can always go online to fetch
// latest version of packages.
sourceCacheContext.MaxAge = DateTimeOffset.UtcNow;
var packages = await metadataResource?.GetMetadataAsync(
identity.Id,
includePrerelease : true,
includeUnlisted : false,
sourceCacheContext : sourceCacheContext,
log : Common.NullLogger.Instance,
token : cancellationToken);
if (packages?.FirstOrDefault() == null)
{
return(null);
}
var packageMetadata = packages
.FirstOrDefault(p => p.Identity.Version == identity.Version)
?? PackageSearchMetadataBuilder.FromIdentity(identity).Build();
return(packageMetadata.WithVersions(ToVersionInfo(packages, includePrerelease)));
}
}
public async Task GetOnlyLocalPackageMetadataAsync_WithLocalSource_SucceedsAsync()
{
Mock.Get(_localMetadataResource)
.Setup(x => x.GetMetadataAsync(TestPackageIdentity.Id, true, true, It.IsAny <SourceCacheContext>(), It.IsAny <Common.ILogger>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new[] { PackageSearchMetadataBuilder.FromIdentity(TestPackageIdentity).Build() });
IPackageSearchMetadata packageSearchMetadata = await _target.GetOnlyLocalPackageMetadataAsync(TestPackageIdentity, CancellationToken.None);
Assert.NotNull(packageSearchMetadata);
}
private void SetupRemotePackageMetadata(string id, params string[] versions)
{
IEnumerable <IPackageSearchMetadata> metadata = versions
.Select(v => PackageSearchMetadataBuilder
.FromIdentity(new PackageIdentity(id, new NuGetVersion(v)))
.Build());
Mock.Get(_metadataResource)
.Setup(x => x.GetMetadataAsync(id, It.IsAny <bool>(), It.IsAny <bool>(), It.IsAny <SourceCacheContext>(), It.IsAny <Common.ILogger>(), It.IsAny <CancellationToken>()))
.Returns(Task.FromResult(metadata));
}
public Task <SearchResult <IPackageSearchMetadata> > ContinueSearchAsync(ContinuationToken continuationToken, CancellationToken cancellationToken)
{
Assert.NotNull(continuationToken);
var packageB = new PackageIdentity("B", new NuGetVersion("2.0.0"));
var metadata = PackageSearchMetadataBuilder.FromIdentity(packageB).Build();
var results = SearchResult.FromItems(metadata);
results.SourceSearchStatus = new Dictionary <string, LoadingStatus> {
{ "test", LoadingStatus.NoMoreItems }
};
return(Task.FromResult(results));
}
public void CreateResults_WithSampleData_ResultAndCollectionAreEqual(string[] packageIds)
{
// Arrange
IPackageSearchMetadata[] meta = packageIds
.Select(id => PackageSearchMetadataBuilder.FromIdentity(new PackageIdentity(id, new NuGetVersion("1.0.0"))).Build())
.ToArray();
// Act
SearchResult <IPackageSearchMetadata> result = InstalledPackageFeed.CreateResult(meta);
// Assert
Assert.Equal(result, meta);
Assert.NotNull(result.SourceSearchStatus);
Assert.NotNull(result.SourceSearchStatus["Installed"]);
}
public Task <SearchResult <IPackageSearchMetadata> > RefreshSearchAsync(RefreshToken refreshToken, CancellationToken cancellationToken)
{
var items = Packages
.Select(package => PackageSearchMetadataBuilder.FromIdentity(package).Build())
.ToArray();
var results = SearchResult.FromItems(items);
results.NextToken = new ContinuationToken {
};
results.SourceSearchStatus = new Dictionary <string, LoadingStatus> {
{ "Test", LoadingStatus.Ready }
};
return(Task.FromResult(results));
}
public void MergeEntries_WithDifferentPackageIds_Throws()
{
var packageA = PackageSearchMetadataBuilder
.FromIdentity(new PackageIdentity("packageA", new Versioning.NuGetVersion("1.0.0")))
.Build();
var packageB = PackageSearchMetadataBuilder
.FromIdentity(new PackageIdentity("packageB", new Versioning.NuGetVersion("1.0.0")))
.Build();
var splicer = new PackageSearchMetadataSplicer();
var error = Assert.Throws <InvalidOperationException>(() => splicer.MergeEntries(packageA, packageB));
Assert.Equal($"Cannot merge packages 'packageA.1.0.0' and 'packageB.1.0.0' because their ids are different.", error.Message);
}
public Task <SearchResult <IPackageSearchMetadata> > RefreshSearchAsync(RefreshToken refreshToken, CancellationToken cancellationToken)
{
Assert.NotNull(refreshToken);
var packageA = new PackageIdentity("A", new NuGetVersion("1.0.0"));
var metadata = PackageSearchMetadataBuilder.FromIdentity(packageA).Build();
var results = SearchResult.FromItems(metadata);
results.NextToken = new ContinuationToken {
};
results.SourceSearchStatus = new Dictionary <string, LoadingStatus> {
{ "test", LoadingStatus.Ready }
};
return(Task.FromResult(results));
}
public void MergeEntries_PicksTheLatest()
{
var older = new PackageIdentity("packageA", new Versioning.NuGetVersion("1.0.0"));
var newer = new PackageIdentity("packageA", new Versioning.NuGetVersion("1.0.2"));
var packageA = PackageSearchMetadataBuilder
.FromIdentity(older)
.Build();
var packageB = PackageSearchMetadataBuilder
.FromIdentity(newer)
.Build();
var splicer = new PackageSearchMetadataSplicer();
var result = splicer.MergeEntries(packageA, packageB);
Assert.NotNull(result);
Assert.Equal(newer, result.Identity);
}
private async Task <IPackageSearchMetadata> GetPackageMetadataAsync(PackageIdentity identity, List <Task <IPackageSearchMetadata> > tasks, CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
if (_localRepository != null)
{
tasks.Add(_localRepository.GetPackageMetadataFromLocalSourceAsync(identity, cancellationToken));
}
IEnumerable <IPackageSearchMetadata> completed = (await Task.WhenAll(tasks))
.Where(m => m != null);
IPackageSearchMetadata master = completed.FirstOrDefault(m => !string.IsNullOrEmpty(m.Summary))
?? completed.FirstOrDefault()
?? PackageSearchMetadataBuilder.FromIdentity(identity).Build();
return(master.WithVersions(
asyncValueFactory: () => MergeVersionsAsync(identity, completed)));
}
public async Task CanGetVersionInfoFromMetadata()
{
//arrange
var metadata = PackageSearchMetadataBuilder.FromIdentity(new PackageIdentity("test", new NuGetVersion(1, 2, 3))).Build();
var metadataResource = Substitute.For <PackageMetadataResource>();
metadataResource.GetMetadataAsync(Arg.Any <string>(), Arg.Any <bool>(), Arg.Any <bool>(), Arg.Any <SourceCacheContext>(), Arg.Any <ILogger>(), Arg.Any <CancellationToken>())
.Returns(new List <IPackageSearchMetadata> {
metadata
});
var checker = new PackageVersionChecker(metadataResource, new Dictionary <string, IList <VersionInfo> >());
//act
var versions = await checker.GetVersions("test");
//assert
Assert.Equal("1.2.3", versions.First().Version.ToString());
}
public void LocalPackageInfo_NotNull()
{
var copy1 = PackageSearchMetadataBuilder
.FromMetadata(_testData.TestData)
.Build();
Assert.True(copy1 is PackageSearchMetadataBuilder.ClonedPackageSearchMetadata);
var clone1 = (PackageSearchMetadataBuilder.ClonedPackageSearchMetadata)copy1;
var copy2 = PackageSearchMetadataBuilder
.FromMetadata(copy1)
.Build();
Assert.True(copy2 is PackageSearchMetadataBuilder.ClonedPackageSearchMetadata);
var clone2 = (PackageSearchMetadataBuilder.ClonedPackageSearchMetadata)copy2;
Assert.NotNull(clone2.PackagePath);
Assert.Equal(clone1.PackagePath, clone2.PackagePath);
}
public async Task GetPackageVersionsAsync_WithProjectAndIsTransitiveAndCacheIsNotPopulatedAsync()
{
using (NuGetPackageSearchService searchService = SetupSearchService())
{
PackageIdentity transitivePackage = new PackageIdentity("microsoft.extensions.logging.abstractions", new Versioning.NuGetVersion("5.0.0-rc.2.20475.5"));
var packageSources = new List <PackageSourceContextInfo> {
PackageSourceContextInfo.Create(_sourceRepository.PackageSource)
};
var metadataProvider = Mock.Of <IPackageMetadataProvider>();
CacheItemPolicy _cacheItemPolicy = new CacheItemPolicy
{
SlidingExpiration = ObjectCache.NoSlidingExpiration,
AbsoluteExpiration = ObjectCache.InfiniteAbsoluteExpiration,
};
Mock.Get(metadataProvider)
.Setup(m => m.GetPackageMetadataAsync(It.IsAny <PackageIdentity>(), It.IsAny <bool>(), It.IsAny <CancellationToken>()))
.Returns(() => Task.FromResult(PackageSearchMetadataBuilder.FromIdentity(new PackageIdentity("microsoft.extensions.logging.abstractions", NuGetVersion.Parse("5.0.0-rc.2.20475.5"))).Build()));
IPackageSearchMetadata packageMetadata = await metadataProvider.GetPackageMetadataAsync(transitivePackage, true, CancellationToken.None);
string cacheId = PackageSearchMetadataCacheItem.GetCacheId(transitivePackage.Id, true, packageSources);
var cacheEntry = new PackageSearchMetadataCacheItem(packageMetadata, metadataProvider);
NuGetPackageSearchService.PackageSearchMetadataMemoryCache.AddOrGetExisting(cacheId, cacheEntry, _cacheItemPolicy);
IReadOnlyCollection <VersionInfoContextInfo> result = await searchService.GetPackageVersionsAsync(
transitivePackage,
packageSources,
includePrerelease : true,
isTransitive : true,
_projects,
CancellationToken.None);
Assert.Equal(60, result.Count);
Assert.True(result.Last().Version.Version.Equals(new Version("1.0.0.0")));
}
}
public async Task GetLocalPackageMetadataAsync_WhenLocalSourceHasPackage_CombinesMetadata()
{
// Arrange
Mock.Get(_localMetadataResource)
.Setup(x => x.GetMetadataAsync(TestPackageIdentity.Id, true, true, It.IsAny <SourceCacheContext>(), It.IsAny <Common.ILogger>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(new[] { PackageSearchMetadataBuilder.FromIdentity(TestPackageIdentity).Build() });
var expectedVersionStrings = new[] { "1.0.0", "2.0.0" };
var deprecationMetadata = new PackageDeprecationMetadata();
Mock.Get(_metadataResource)
.Setup(x => x.GetMetadataAsync(TestPackageIdentity.Id, true, false, It.IsAny <SourceCacheContext>(), It.IsAny <Common.ILogger>(), It.IsAny <CancellationToken>()))
.ReturnsAsync(
new[]
{
PackageSearchMetadataBuilder
.FromIdentity(TestPackageIdentity)
.WithDeprecation(new AsyncLazy <PackageDeprecationMetadata>(() => Task.FromResult(deprecationMetadata)))
.Build(),
PackageSearchMetadataBuilder
.FromIdentity(new PackageIdentity(TestPackageIdentity.Id, new NuGetVersion("2.0.0")))
.Build()
});
// Act
var metadata = await _target.GetLocalPackageMetadataAsync(
TestPackageIdentity,
includePrerelease : true,
cancellationToken : CancellationToken.None);
// Assert
Mock.Get(_metadataResource).Verify(
x => x.GetMetadataAsync(TestPackageIdentity.Id, true, false, It.IsAny <SourceCacheContext>(), It.IsAny <Common.ILogger>(), It.IsAny <CancellationToken>()),
Times.Once);
Assert.Equal(expectedVersionStrings, (await metadata.GetVersionsAsync()).Select(v => v.Version.ToString()).OrderBy(v => v));
Assert.Same(deprecationMetadata, await metadata.GetDeprecationMetadataAsync());
}
/// <summary>
/// Get package metadata from the package folders.
/// </summary>
public async Task <IPackageSearchMetadata> GetLocalPackageMetadataAsync(
PackageIdentity identity,
bool includePrerelease,
CancellationToken cancellationToken)
{
cancellationToken.ThrowIfCancellationRequested();
var sources = new List <SourceRepository>();
if (_localRepository != null)
{
sources.Add(_localRepository);
}
if (_globalLocalRepositories != null)
{
sources.AddRange(_globalLocalRepositories);
}
// Take the package from the first source it is found in
foreach (var source in sources)
{
var result = await source.GetPackageMetadataFromLocalSourceAsync(identity, cancellationToken);
if (result != null)
{
var versionsAndDeprecationMetadataTask = FetchAndMergeVersionsAndDeprecationMetadataAsync(identity, includePrerelease, cancellationToken);
return(PackageSearchMetadataBuilder
.FromMetadata(result)
.WithVersions(AsyncLazy.New(async() => (await versionsAndDeprecationMetadataTask).versions))
.WithDeprecation(AsyncLazy.New(async() => (await versionsAndDeprecationMetadataTask).deprecationMetadata))
.Build());
}
}
return(null);
}
/// <summary>
/// Prepares the dictionary that maps frameworks to packages top-level
/// and transitive.
/// </summary>
/// <param name="projectPath"> Path to the project to get versions for its packages </param>
/// <param name="userInputFrameworks">A list of frameworks</param>
/// <param name="assetsFile">Assets file for all targets and libraries</param>
/// <param name="transitive">Include transitive packages/projects in the result</param>
/// <param name="includeProjects">Include project references in top-level and transitive package lists</param>
/// <returns>FrameworkPackages collection with top-level and transitive package/project
/// references for each framework, or null on error</returns>
internal IEnumerable <FrameworkPackages> GetResolvedVersions(
string projectPath, IEnumerable <string> userInputFrameworks, LockFile assetsFile, bool transitive, bool includeProjects)
{
if (userInputFrameworks == null)
{
throw new ArgumentNullException(nameof(userInputFrameworks));
}
if (projectPath == null)
{
throw new ArgumentNullException(nameof(projectPath));
}
if (assetsFile == null)
{
throw new ArgumentNullException(nameof(assetsFile));
}
var resultPackages = new List <FrameworkPackages>();
var requestedTargetFrameworks = assetsFile.PackageSpec.TargetFrameworks;
var requestedTargets = assetsFile.Targets;
// If the user has entered frameworks, we want to filter
// the targets and frameworks from the assets file
if (userInputFrameworks.Any())
{
//Target frameworks filtering
var parsedUserFrameworks = userInputFrameworks.Select(f =>
NuGetFramework.Parse(f.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()).ToArray()[0]));
requestedTargetFrameworks = requestedTargetFrameworks.Where(tfm => parsedUserFrameworks.Contains(tfm.FrameworkName)).ToList();
//Assets file targets filtering by framework and RID
var filteredTargets = new List <LockFileTarget>();
foreach (var frameworkAndRID in userInputFrameworks)
{
var splitFrameworkAndRID = frameworkAndRID.Split(new char[] { '/' }, StringSplitOptions.RemoveEmptyEntries).Select(s => s.Trim()).ToArray();
// If a / is not present in the string, we get all of the targets that
// have matching framework regardless of RID.
if (splitFrameworkAndRID.Count() == 1)
{
filteredTargets.AddRange(requestedTargets.Where(target => target.TargetFramework.Equals(NuGetFramework.Parse(splitFrameworkAndRID[0]))));
}
else
{
//RID is present in the user input, so we filter using it as well
filteredTargets.AddRange(requestedTargets.Where(target => target.TargetFramework.Equals(NuGetFramework.Parse(splitFrameworkAndRID[0])) &&
target.RuntimeIdentifier != null && target.RuntimeIdentifier.Equals(splitFrameworkAndRID[1], StringComparison.OrdinalIgnoreCase)));
}
}
requestedTargets = filteredTargets;
}
// Filtering the Targets to ignore TargetFramework + RID combination, only keep TargetFramework in requestedTargets.
// So that only one section will be shown for each TFM.
requestedTargets = requestedTargets.Where(target => target.RuntimeIdentifier == null).ToList();
foreach (var target in requestedTargets)
{
// Find the tfminformation corresponding to the target to
// get the top-level dependencies
TargetFrameworkInformation tfmInformation;
try
{
tfmInformation = requestedTargetFrameworks.First(tfm => tfm.FrameworkName.Equals(target.TargetFramework));
}
catch (Exception)
{
Console.WriteLine(string.Format(Strings.ListPkg_ErrorReadingAssetsFile, assetsFile.Path));
return(null);
}
//The packages for the framework that were retrieved with GetRequestedVersions
var frameworkDependencies = tfmInformation.Dependencies;
var projPackages = GetPackageReferencesFromTargets(projectPath, tfmInformation.ToString());
var topLevelPackages = new List <InstalledPackageReference>();
var transitivePackages = new List <InstalledPackageReference>();
foreach (var library in target.Libraries)
{
var matchingPackages = frameworkDependencies.Where(d =>
d.Name.Equals(library.Name, StringComparison.OrdinalIgnoreCase)).ToList();
var resolvedVersion = library.Version.ToString();
//In case we found a matching package in requestedVersions, the package will be
//top level.
if (matchingPackages.Any())
{
var topLevelPackage = matchingPackages.Single();
InstalledPackageReference installedPackage;
//If the package is not auto-referenced, get the version from the project file. Otherwise fall back on the assets file
if (!topLevelPackage.AutoReferenced)
{
try
{ // In case proj and assets file are not in sync and some refs were deleted
installedPackage = projPackages.Where(p => p.Name.Equals(topLevelPackage.Name, StringComparison.Ordinal)).First();
}
catch (Exception)
{
Console.WriteLine(string.Format(CultureInfo.CurrentCulture, Strings.ListPkg_ErrorReadingReferenceFromProject, projectPath));
return(null);
}
}
else
{
var projectFileVersion = topLevelPackage.LibraryRange.VersionRange.ToString();
installedPackage = new InstalledPackageReference(library.Name)
{
OriginalRequestedVersion = projectFileVersion
};
}
installedPackage.ResolvedPackageMetadata = PackageSearchMetadataBuilder
.FromIdentity(new PackageIdentity(library.Name, library.Version))
.Build();
installedPackage.AutoReference = topLevelPackage.AutoReferenced;
if (library.Type != "project" || includeProjects)
{
topLevelPackages.Add(installedPackage);
}
}
// If no matching packages were found, then the package is transitive,
// and include-transitive must be used to add the package
else if (transitive) // be sure to exclude "project" references here as these are irrelevant
{
var installedPackage = new InstalledPackageReference(library.Name)
{
ResolvedPackageMetadata = PackageSearchMetadataBuilder
.FromIdentity(new PackageIdentity(library.Name, library.Version))
.Build()
};
if (library.Type != "project" || includeProjects)
{
transitivePackages.Add(installedPackage);
}
}
}
var frameworkPackages = new FrameworkPackages(
target.TargetFramework.GetShortFolderName(),
topLevelPackages,
transitivePackages);
resultPackages.Add(frameworkPackages);
}
return(resultPackages);
}
private IPackageSearchMetadata GetPackage(PackageIdentity identity) => PackageSearchMetadataBuilder.FromIdentity(identity).Build();
internal static InstalledPackageReference CreateInstalledPackageReference(
string packageId = "Package.Id",
bool autoReference = false,
bool isDeprecated = false,
int vulnerabilityCount = 0,
string resolvedPackageVersionString = "1.0.0",
string latestPackageVersionString = "2.0.0")
{
var latestPackageVersion = new NuGetVersion(latestPackageVersionString);
var resolvedPackageVersion = new NuGetVersion(resolvedPackageVersionString);
var resolvedPackageMetadata = new Mock <IPackageSearchMetadata>();
resolvedPackageMetadata.Setup(m => m.Identity).Returns(new PackageIdentity(packageId, resolvedPackageVersion));
if (isDeprecated)
{
resolvedPackageMetadata
.Setup(m => m.GetDeprecationMetadataAsync())
.ReturnsAsync(new PackageDeprecationMetadata()
{
Reasons = new[] { "Legacy" },
AlternatePackage = new AlternatePackageMetadata()
{
PackageId = "Package.New",
Range = new VersionRange(new NuGetVersion("1.0.0"))
}
});
}
var vulnerabilities = (List <PackageVulnerabilityMetadata>)null;
if (vulnerabilityCount > 0)
{
vulnerabilities = new List <PackageVulnerabilityMetadata>();
for (int i = 0; i < vulnerabilityCount; i++)
{
vulnerabilities.Add(new PackageVulnerabilityMetadata()
{
AdvisoryUrl = new Uri("http://example/advisory" + i),
Severity = i
});
}
}
resolvedPackageMetadata
.Setup(m => m.Vulnerabilities)
.Returns(vulnerabilities);
var installedPackageReference = new InstalledPackageReference(packageId)
{
AutoReference = autoReference,
LatestPackageMetadata = PackageSearchMetadataBuilder
.FromIdentity(new PackageIdentity(packageId, latestPackageVersion))
.Build(),
OriginalRequestedVersion = resolvedPackageVersionString,
ResolvedPackageMetadata = resolvedPackageMetadata.Object
};
return(installedPackageReference);
}
private IObservable <IPackageSearchMetadata> SelectPackageDetails()
{
return(Observable.FromEventPattern <TreeViewEventHandler, TreeViewEventArgs>(
handler => packageView.AfterSelect += handler,
handler => packageView.AfterSelect -= handler)
.Select(evt => Observable.StartAsync(async token =>
{
var selectedRepository = SelectedRepository;
var package = (IPackageSearchMetadata)evt.EventArgs.Node.Tag;
if (package == null)
{
return null;
}
var repositories = selectedRepository == null ? PackageManager.SourceRepositoryProvider.GetRepositories() : new[] { selectedRepository };
using (var cacheContext = new SourceCacheContext())
{
foreach (var repository in repositories)
{
var metadata = await repository.GetMetadataAsync(package.Identity, cacheContext);
if (metadata != null)
{
var result = (PackageSearchMetadataBuilder.ClonedPackageSearchMetadata)PackageSearchMetadataBuilder.FromMetadata(metadata).Build();
result.DownloadCount = package.DownloadCount;
return result;
}
}
return null;
}
})).Switch());
}
