public void CalculatePackagesToRemove(RetentionRule rule)
{
// Console.WriteLine($"Rule : Id={rule.Id}, Version={rule.Version}, Stable={rule.Stable}, Prerelease={rule.Prerelease}");
List <string> versions = new List <string>();
if (rule.Version != null)
{
versions.Add(rule.Version);
}
if (rule.Versions != null)
{
versions.AddRange(rule.Versions);
}
foreach (var version in versions)
{
VersionRange range = VersionRange.Parse(version);
IEnumerable <PackageIdentity> stablePackages =
from pkg in _allPackages
where pkg.Id == rule.Id && pkg.Version.IsPrerelease == false && range.Satisfies(pkg.Version)
orderby pkg.Version descending
select pkg;
IEnumerable <PackageIdentity> prereleasePackages =
from pkg in _allPackages
where pkg.Id == rule.Id && pkg.Version.IsPrerelease == true && range.Satisfies(pkg.Version)
orderby pkg.Version descending
select pkg;
int cnt;
cnt = 0;
foreach (var pkg in stablePackages)
{
cnt++;
if (cnt > rule.Stable)
{
_packagesToRemove.Add(pkg);
}
}
cnt = 0;
foreach (var pkg in prereleasePackages)
{
cnt++;
if (cnt > rule.Prerelease)
{
_packagesToRemove.Add(pkg);
}
}
}
}
public static bool IsItemRangeRequired(VersionRange dependencyRange, NuGetVersion catalogItemLower, NuGetVersion catalogItemUpper)
{
VersionRange catalogItemVersionRange = new VersionRange(minVersion: catalogItemLower, includeMinVersion: true,
maxVersion: catalogItemUpper, includeMaxVersion: true, includePrerelease: true);
if (dependencyRange.HasLowerAndUpperBounds) // Mainly to cover the '!dependencyRange.IsMaxInclusive && !dependencyRange.IsMinInclusive' case
{
return(catalogItemVersionRange.Satisfies(dependencyRange.MinVersion) || catalogItemVersionRange.Satisfies(dependencyRange.MaxVersion));
}
else
{
return(dependencyRange.Satisfies(catalogItemLower) || dependencyRange.Satisfies(catalogItemUpper));
}
}
public static bool DoesRangeSatisfy(this VersionRange dependencyRange, NuGetVersion catalogItemLower, NuGetVersion catalogItemUpper)
{
if (dependencyRange.HasLowerAndUpperBounds) // Mainly to cover the '!dependencyRange.IsMaxInclusive && !dependencyRange.IsMinInclusive' case
{
var catalogItemVersionRange = new VersionRange(minVersion: catalogItemLower, includeMinVersion: true,
maxVersion: catalogItemUpper, includeMaxVersion: true);
return(catalogItemVersionRange.Satisfies(dependencyRange.MinVersion) || catalogItemVersionRange.Satisfies(dependencyRange.MaxVersion));
}
else
{
return(dependencyRange.Satisfies(catalogItemLower) || dependencyRange.Satisfies(catalogItemUpper));
}
}
/// <summary>
/// Retrieve the <see cref="RemoteSourceDependencyInfo" /> for a registration.
/// </summary>
/// <returns>Returns an empty sequence if the package does not exist.</returns>
public static async Task <IEnumerable <RemoteSourceDependencyInfo> > GetDependencies(
HttpSource httpClient,
Uri registrationUri,
VersionRange range,
ILogger log,
CancellationToken token)
{
var ranges = await RegistrationUtility.LoadRanges(httpClient, registrationUri, range, log, token);
var results = new HashSet <RemoteSourceDependencyInfo>();
foreach (var rangeObj in ranges)
{
if (rangeObj == null)
{
throw new InvalidDataException(registrationUri.AbsoluteUri);
}
foreach (JObject packageObj in rangeObj["items"])
{
var catalogEntry = (JObject)packageObj["catalogEntry"];
var version = NuGetVersion.Parse(catalogEntry["version"].ToString());
if (range.Satisfies(version))
{
results.Add(ProcessPackageVersion(packageObj, version));
}
}
}
return(results);
}
private static IEnumerable <Package> GetUpdates(
IEnumerable <Package> packages,
ILookup <string, Tuple <NuGetVersion, VersionRange> > versionLookup,
IEnumerable <NuGetFramework> targetFrameworkValues,
bool includeAllVersions)
{
var updates = from p in packages.AsEnumerable()
let version = NuGetVersion.Parse(p.Version)
where versionLookup[p.PackageRegistration.Id]
.Any(versionTuple =>
{
NuGetVersion clientVersion = versionTuple.Item1;
var supportedPackageFrameworks = p.SupportedFrameworks.Select(f => f.FrameworkName);
VersionRange versionConstraint = versionTuple.Item2;
return((version > clientVersion) &&
(targetFrameworkValues == null ||
!supportedPackageFrameworks.Any() ||
targetFrameworkValues.Any(s => supportedPackageFrameworks.Any(supported => NuGetFrameworkUtility.IsCompatibleWithFallbackCheck(s, supported)))) &&
(versionConstraint == null || versionConstraint.Satisfies(version)));
})
select p;
if (!includeAllVersions)
{
updates = updates.GroupBy(p => p.PackageRegistration.Id)
.Select(g => g.OrderByDescending(p => NuGetVersion.Parse(p.Version)).First());
}
return(updates);
}
public static async Task <IPackageSearchMetadata> GetLatestPackageMetadataAsync(
this SourceRepository sourceRepository, string packageId, bool includePrerelease, CancellationToken cancellationToken, VersionRange allowedVersions)
{
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(
packageId,
includePrerelease,
false,
sourceCacheContext,
Common.NullLogger.Instance,
cancellationToken);
// filter packages based on allowed versions
var updatedPackages = packages.Where(p => allowedVersions.Satisfies(p.Identity.Version));
var highest = updatedPackages
.OrderByDescending(e => e.Identity.Version, VersionComparer.VersionRelease)
.FirstOrDefault();
return(highest?.WithVersions(ToVersionInfo(packages, includePrerelease)));
}
}
public async Task <NuGetVersion> LookupMatchingVersion(
SourceRepository sourceRepository,
string packageId,
VersionRange versionRange = null,
NuGetFramework framework = null,
CancellationToken cancellationToken = default)
{
try
{
var dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>(cancellationToken);
using (var sourceCacheContext = new SourceCacheContext())
{
var dependencyInfo =
await dependencyInfoResource
.ResolvePackages(packageId, framework ?? _currentFramework, sourceCacheContext, _logger, cancellationToken);
return(dependencyInfo
.Select(x => x.Version)
.Where(x => x != null && (versionRange == null || versionRange.Satisfies(x)))
.DefaultIfEmpty()
.Max());
}
}
catch (Exception ex)
{
LogTo.Warning($"Could not get latest version for package {packageId} from source {sourceRepository}: {ex.Message}");
return(null);
}
}
internal static string GetPath(string name, VersionRange versionRange, out string version)
{
// var nuGetVersion = versionRange.FindBestMatch(GetAvailableVersions(name));
var nuGetVersion = (NuGetVersion)null;
foreach (var availableVersion in GetAvailableVersions(name))
{
if (versionRange.Satisfies(availableVersion))
{
if (nuGetVersion is null || availableVersion > nuGetVersion)
{
nuGetVersion = availableVersion;
}
}
}
if (nuGetVersion is null)
{
version = null;
return(null);
}
version = nuGetVersion.ToNormalizedString();
return(Path.Combine(_globalPackagesPath, name, version));
}
public async Task DependencyInfo_RetrieveDependencies()
{
// Arrange
var serviceAddress = TestUtility.CreateServiceAddress();
var responses = new Dictionary <string, string>();
responses.Add(serviceAddress + "FindPackagesById()?id='xunit'&semVerLevel=2.0.0",
TestUtility.GetResource("NuGet.Protocol.Core.v3.Tests.compiler.resources.XunitFindPackagesById.xml", GetType()));
responses.Add(serviceAddress, string.Empty);
var repo = StaticHttpHandler.CreateSource(serviceAddress, Repository.Provider.GetCoreV3(), responses);
var dependencyInfoResource = await repo.GetResourceAsync <DependencyInfoResource>();
var package = new PackageIdentity("xunit", NuGetVersion.Parse("2.1.0-beta1-build2945"));
// filter to keep this test consistent
var filterRange = new VersionRange(NuGetVersion.Parse("2.0.0-rc4-build2924"), true, NuGetVersion.Parse("2.1.0-beta1-build2945"), true);
// Act
var results = await dependencyInfoResource.ResolvePackages("xunit", NuGetFramework.Parse("net45"), Common.NullLogger.Instance, CancellationToken.None);
var filtered = results.Where(result => filterRange.Satisfies(result.Version));
var target = filtered.Single(p => PackageIdentity.Comparer.Equals(p, package));
// Assert
Assert.Equal(3, filtered.Count());
Assert.Equal(2, target.Dependencies.Count());
Assert.Equal("[2.1.0-beta1-build2945, 2.1.0-beta1-build2945]", target.Dependencies.Single(dep => dep.Id == "xunit.core").VersionRange.ToNormalizedString());
Assert.Equal("[2.1.0-beta1-build2945, 2.1.0-beta1-build2945]", target.Dependencies.Single(dep => dep.Id == "xunit.assert").VersionRange.ToNormalizedString());
}
public void VersionRange_Exact()
{
// Act
var versionInfo = new VersionRange(new NuGetVersion(4, 3, 0), true, new NuGetVersion(4, 3, 0), true);
// Assert
Assert.True(versionInfo.Satisfies(NuGetVersion.Parse("4.3.0")));
}
public bool CheckIfVersionIsValid(string versionToCheck)
{
if (NuGetVersion.TryParse(versionToCheck, out NuGetVersion nuGetVersion2))
{
return(_versionRange.Satisfies(nuGetVersion2));
}
return(false);
}
public void VersionRange_Exact()
{
// Act
var versionInfo = new VersionRange(new NuGetVersion(4, 3, 0), true, new NuGetVersion(4, 3, 0), true, false);
// Assert
Assert.True(versionInfo.Satisfies(NuGetVersion.Parse("4.3.0")));
}
private VersionRange NeededRange(VersionRange alreadySearched, VersionRange possibleSubSet)
{
if (alreadySearched == null || _versionRangeComparer.Equals(alreadySearched, EmptyRange))
{
return(possibleSubSet);
}
if (_versionRangeComparer.Equals(possibleSubSet, EmptyRange))
{
return(EmptyRange);
}
// full overlap scenarios
if (possibleSubSet.IsSubSetOrEqualTo(alreadySearched))
{
return(EmptyRange);
}
else if (possibleSubSet.IsSubSetOrEqualTo(alreadySearched))
{
return(possibleSubSet);
}
// we need a partial range
// [ ]
// [ ]
if (possibleSubSet.HasLowerBound && alreadySearched.Satisfies(possibleSubSet.MinVersion))
{
// already searched the lower set
return(new VersionRange(possibleSubSet.MinVersion, possibleSubSet.IsMinInclusive,
alreadySearched.MaxVersion, alreadySearched.IsMaxInclusive,
possibleSubSet.IncludePrerelease || alreadySearched.IncludePrerelease));
}
else if (possibleSubSet.HasUpperBound && alreadySearched.Satisfies(possibleSubSet.MaxVersion))
{
// already searched the higher set
return(new VersionRange(alreadySearched.MinVersion, alreadySearched.IsMinInclusive,
possibleSubSet.MaxVersion, possibleSubSet.IsMaxInclusive,
possibleSubSet.IncludePrerelease || alreadySearched.IncludePrerelease));
}
else
{
// TODO: improve this
return(VersionRange.Combine(new VersionRange[] { alreadySearched, possibleSubSet }));
}
}
private static bool IsItemRangeRequired(VersionRange preFilterRange, NuGetVersion lower, NuGetVersion upper)
{
VersionRange itemRange = new VersionRange(lower, true, upper, true, true);
if (preFilterRange.HasLowerAndUpperBounds)
{
return(itemRange.Satisfies(preFilterRange.MinVersion) || itemRange.Satisfies(preFilterRange.MaxVersion));
}
else if (preFilterRange.HasLowerBound)
{
return(upper > preFilterRange.MinVersion);
}
else if (preFilterRange.HasUpperBound)
{
return(lower < preFilterRange.MaxVersion);
}
return(false);
}
private List <IPackageSearchMetadata> FindDependenciesFromSource(IPackageSearchMetadata pkg, PackageMetadataResource pkgMetadataResource, SourceCacheContext srcContext)
{
/// dependency resolver
///
/// this function will be recursively called
///
/// call the findpackages from source helper (potentially generalize this so it's finding packages from source or cache)
///
List <IPackageSearchMetadata> foundDependencies = new List <IPackageSearchMetadata>();
// 1) check the dependencies of this pkg
// 2) for each dependency group, search for the appropriate name and version
// a dependency group are all the dependencies for a particular framework
foreach (var dependencyGroup in pkg.DependencySets)
{
//dependencyGroup.TargetFramework
//dependencyGroup.
foreach (var pkgDependency in dependencyGroup.Packages)
{
// 2.1) check that the appropriate pkg dependencies exist
// returns all versions from a single package id.
var dependencies = pkgMetadataResource.GetMetadataAsync(pkgDependency.Id, _prerelease, true, srcContext, NullLogger.Instance, cancellationToken).GetAwaiter().GetResult();
// then 2.2) check if the appropriate verion range exists (if version exists, then add it to the list to return)
VersionRange versionRange = null;
try
{
versionRange = VersionRange.Parse(pkgDependency.VersionRange.OriginalString);
}
catch
{
Console.WriteLine("Error parsing version range");
}
// if no version/version range is specified the we just return the latest version
IPackageSearchMetadata depPkgToReturn = (versionRange == null ?
dependencies.FirstOrDefault() :
dependencies.Where(v => versionRange.Satisfies(v.Identity.Version)).FirstOrDefault());
foundDependencies.Add(depPkgToReturn);
// 3) search for any dependencies the pkg has
foundDependencies.AddRange(FindDependenciesFromSource(depPkgToReturn, pkgMetadataResource, srcContext));
}
}
// flatten after returning
return(foundDependencies);
}
public static async Task <IPackageSearchMetadata> GetLatestMetadataAsync(this SourceRepository repository, string id, VersionRange version, bool includePrerelease, SourceCacheContext cacheContext, CancellationToken token = default)
{
var packageMetadataResource = await repository.GetResourceAsync <PackageMetadataResource>(token);
var packages = await packageMetadataResource.GetMetadataAsync(id, includePrerelease, includeUnlisted : false, cacheContext, NullLogger.Instance, token);
return(packages
.Where(package => version.Satisfies(package.Identity.Version))
.OrderByDescending(package => package.Identity.Version, VersionComparer.VersionRelease)
.FirstOrDefault());
}
private static JToken ExtractLatestVersion(JObject resolverBlob, bool includePrerelease, VersionRange range = null)
{
// sort by version
JToken candidateLatest = resolverBlob["packages"]
.Where(p => includePrerelease || (new NuGetVersion(p["version"].ToString()).IsPrerelease == false))
.Where(p => range == null || range.Satisfies(new NuGetVersion(p["version"].ToString())))
.OrderByDescending(p => new NuGetVersion(p["version"].ToString()), VersionComparer.VersionRelease)
.FirstOrDefault();
return(candidateLatest);
}
static async Task GetPackageDependencies(
string packageId,
VersionRange versionRange,
NuGetFramework projectFramework,
SourceCacheContext cacheContext,
IEnumerable<SourceRepository> repositories,
IDictionary<PackageIdentity, SourcePackageDependencyInfo> availablePackages,
ILogger logger,
bool ignoreDependencies,
CancellationToken token)
{
var dependencyInfo = default(SourcePackageDependencyInfo);
foreach (var sourceRepository in repositories)
{
var dependencyInfoResource = await sourceRepository.GetResourceAsync<DependencyInfoResource>(token);
var dependencyPackages = await dependencyInfoResource.ResolvePackages(packageId, projectFramework, cacheContext, NullLogger.Instance, token);
foreach (var package in dependencyPackages)
{
if (!versionRange.Satisfies(package.Version)) continue;
if (dependencyInfo == null || package.Version < dependencyInfo.Version)
{
dependencyInfo = package;
}
}
if (dependencyInfo != null)
{
if (availablePackages.ContainsKey(dependencyInfo)) return;
availablePackages.Add(dependencyInfo, dependencyInfo);
if (!ignoreDependencies)
{
logger.LogInformation($"Attempting to resolve dependencies for '{dependencyInfo.Id} {dependencyInfo.Version}'.");
foreach (var dependency in dependencyInfo.Dependencies)
{
await GetPackageDependencies(
dependency.Id, dependency.VersionRange,
projectFramework, cacheContext, repositories, availablePackages, logger, ignoreDependencies, token);
}
}
break;
}
}
// dependency was not found in any repository
if (dependencyInfo == null)
{
var message = $"The package '{packageId} {versionRange}' could not be found.";
throw new InvalidOperationException(message);
}
}
private static string FindBestVersionMatch(VersionRange versionRange, IEnumerable <string> versions)
{
var bundleVersions = versions.Select(p =>
{
var dirName = Path.GetFileName(p);
NuGetVersion.TryParse(dirName, out NuGetVersion version);
if (version != null)
{
version = versionRange.Satisfies(version) ? version : null;
}
return(version);
}).Where(v => v != null);
return(bundleVersions.OrderByDescending(version => version.Version).FirstOrDefault()?.ToString());
}
public async Task <IEnumerable <SourcePackageDependencyInfo> > ResolvePackagesWithVersionSatisfyRangeAsync(PackageIdentity package, VersionRange versionRange, NuGetFramework projectFramework, SourceCacheContext cacheContext,
ILogger log, CancellationToken token)
{
var singlePackage = await ResolvePackageAsync(package, projectFramework, cacheContext, log, token);
// Check is this package satisfy requirements, if not, retrieve all dependency infos and find required package
if (singlePackage is not null && versionRange.Satisfies(singlePackage.Version))
{
Log.Debug($"Found package {package} satisfying version range {versionRange}. Going to skip request of package with same identity");
return(new[] { singlePackage });
}
var packagesInRange = (await ResolvePackagesAsync(package, projectFramework, cacheContext, log, token)).Where(package => versionRange.Satisfies(package.Version)).ToList();
return(packagesInRange);
}
/// <summary>
/// Returns inlined catalog entry items for each registration blob
/// </summary>
/// <remarks>The inlined entries are potentially going away soon</remarks>
public virtual async Task <IEnumerable <JObject> > GetPackageMetadata(
string packageId,
VersionRange range,
bool includePrerelease,
bool includeUnlisted,
SourceCacheContext cacheContext,
Common.ILogger log,
CancellationToken token)
{
var results = new List <JObject>();
var registrationUri = GetUri(packageId);
var ranges = await RegistrationUtility.LoadRanges(_client, registrationUri, packageId, range, cacheContext, log, token);
foreach (var rangeObj in ranges)
{
if (rangeObj == null)
{
throw new InvalidDataException(registrationUri.AbsoluteUri);
}
foreach (JObject packageObj in rangeObj["items"])
{
var catalogEntry = (JObject)packageObj["catalogEntry"];
var version = NuGetVersion.Parse(catalogEntry["version"].ToString());
var listed = catalogEntry.GetBoolean("listed") ?? true;
if (range.Satisfies(version) &&
(includePrerelease || !version.IsPrerelease) &&
(includeUnlisted || listed))
{
// add in the download url
if (packageObj["packageContent"] != null)
{
catalogEntry["packageContent"] = packageObj["packageContent"];
}
results.Add(catalogEntry);
}
}
}
return(results);
}
private static DependencyPackageKeys GetDependencyPackageKeys(
IReadOnlyDictionary <NuGetVersion, PackageEntity> versionToPackage,
VersionRange parsedVersionRange)
{
parsedVersionRange = parsedVersionRange ?? VersionRange.All;
var minimumMatch = versionToPackage
.Keys
.Where(x => parsedVersionRange.Satisfies(x))
.OrderBy(x => x)
.FirstOrDefault();
var bestMatch = parsedVersionRange
.FindBestMatch(versionToPackage.Keys);
var minimumKey = minimumMatch != null ? versionToPackage[minimumMatch].PackageKey : (long?)null;
var bestKey = bestMatch != null ? versionToPackage[bestMatch].PackageKey : (long?)null;
return(new DependencyPackageKeys(minimumKey, bestKey));
}
public void ResolverSort_HighestMinorPreferUpgrade()
{
HashSet <PackageIdentity> installed = new HashSet <PackageIdentity>();
installed.Add(new PackageIdentity("packageA", NuGetVersion.Parse("2.0.0")));
var newPackages = new HashSet <string>();
var comparer = new ResolverComparer(DependencyBehavior.HighestMinor, installed, newPackages);
VersionRange removeRange = new VersionRange(NuGetVersion.Parse("2.0.0"), true, NuGetVersion.Parse("2.0.0"), true);
var packages = new List <ResolverPackage>(VersionList.Where(e => !removeRange.Satisfies(e)).Select(e => new ResolverPackage("packageA", e)));
packages.Sort(comparer);
// take the upgrade of the highest minor
Assert.Equal("2.5.0", packages.First().Version.ToNormalizedString());
}
public static async Task <IPackageSearchMetadata> GetLatestPackageMetadataAsync(
this SourceRepository sourceRepository, string packageId, bool includePrerelease, CancellationToken cancellationToken, VersionRange allowedVersions)
{
var metadataResource = await sourceRepository.GetResourceAsync <PackageMetadataResource>(cancellationToken);
var packages = await metadataResource?.GetMetadataAsync(
packageId,
includePrerelease,
false,
Common.NullLogger.Instance,
cancellationToken);
// filter packages based on allowed versions
var updatedPackages = packages.Where(p => allowedVersions.Satisfies(p.Identity.Version));
var highest = updatedPackages
.MaxValueOrDefault(e => e.Identity.Version, VersionComparer.VersionRelease);
return(highest?.WithVersions(ToVersionInfo(packages, includePrerelease)));
}
public void ResolverSort_HighestUpgrade()
{
HashSet <PackageIdentity> installed = new HashSet <PackageIdentity>();
installed.Add(new PackageIdentity("packageA", NuGetVersion.Parse("2.0.0")));
var newPackages = new HashSet <string>();
var comparer = new ResolverComparer(DependencyBehavior.Highest, installed, newPackages);
VersionRange removeRange = new VersionRange(NuGetVersion.Parse("2.0.0"), true, NuGetVersion.Parse("2.0.1"), true);
var packages = new List <ResolverPackage>(VersionList.Where(e => !removeRange.Satisfies(e)).Select(e => new ResolverPackage("packageA", e)));
packages.Sort(comparer);
// ignore the installed package if it is not in allowed
Assert.Equal("3.0.9", packages.First().Version.ToNormalizedString());
Assert.Equal("0.1.0", packages.Last().Version.ToNormalizedString());
}
private static async Task <NuGetVersion> GetLatestMatchingVersion(string packageId, NuGetFramework currentFramework, VersionRange versionRange, SourceRepository sourceRepository, ILogger logger)
{
try
{
DependencyInfoResource dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>();
var dependencyInfo = await dependencyInfoResource.ResolvePackages(
packageId, NullSourceCacheContext.Instance, logger, CancellationToken.None);
return(dependencyInfo
.Select(x => x.Identity.Version)
.Where(x => x != null && (versionRange == null || versionRange.Satisfies(x)))
.DefaultIfEmpty()
.Max());
}
catch (Exception ex)
{
Trace.TraceWarning($"Could not get latest version for package {packageId} from source {sourceRepository}: {ex.Message}");
return(null);
}
}
private async Task <NuGetVersion> GetLatestMatchingVersion(SourceRepository sourceRepository, ILogger logger)
{
try
{
DependencyInfoResource dependencyInfoResource = await sourceRepository.GetResourceAsync <DependencyInfoResource>();
IEnumerable <SourcePackageDependencyInfo> dependencyInfo = await dependencyInfoResource.ResolvePackages(
_packageId, _currentFramework, logger, CancellationToken.None);
return(dependencyInfo
.Select(x => x.Version)
.Where(x => x != null && (_versionRange == null || _versionRange.Satisfies(x)))
.DefaultIfEmpty()
.Max());
}
catch (Exception ex)
{
Trace.Warning($"Could not get latest version for package {_packageId} from source {sourceRepository}: {ex.Message}");
return(null);
}
}
/// <summary>
/// Returns inlined catalog entry items for each registration blob
/// </summary>
/// <remarks>The inlined entries are potentially going away soon</remarks>
public virtual async Task <IEnumerable <JObject> > GetPackageMetadata(string packageId, VersionRange range, bool includePrerelease, bool includeUnlisted, CancellationToken token)
{
List <JObject> results = new List <JObject>();
var entries = await GetPackageEntries(packageId, includeUnlisted, token);
foreach (var entry in entries)
{
JToken catalogEntry = entry["catalogEntry"];
if (catalogEntry != null)
{
NuGetVersion version = null;
if (catalogEntry["version"] != null && NuGetVersion.TryParse(catalogEntry["version"].ToString(), out version))
{
if (range.Satisfies(version) && (includePrerelease || !version.IsPrerelease))
{
if (catalogEntry["published"] != null)
{
DateTime published = catalogEntry["published"].ToObject <DateTime>();
if ((published != null && published.Year > 1901) || includeUnlisted)
{
// add in the download url
if (entry["packageContent"] != null)
{
catalogEntry["packageContent"] = entry["packageContent"];
}
results.Add(entry["catalogEntry"] as JObject);
}
}
}
}
}
}
return(results);
}
/// <summary>
/// Process RegistrationPage
/// </summary>
/// <param name="registrationPage">Nuget registration page.</param>
/// <param name="results">Used to return nuget result.</param>
/// <param name="range">Nuget version range.</param>
/// <param name="includePrerelease">Whether to include PreRelease versions into result.</param>
/// <param name="includeUnlisted">Whether to include Unlisted versions into result.</param>
private void ProcessRegistrationPage(
RegistrationPage registrationPage,
List <PackageSearchMetadataRegistration> results,
VersionRange range, bool includePrerelease,
bool includeUnlisted,
MetadataReferenceCache metadataCache)
{
foreach (RegistrationLeafItem registrationLeaf in registrationPage.Items)
{
PackageSearchMetadataRegistration catalogEntry = registrationLeaf.CatalogEntry;
NuGetVersion version = catalogEntry.Version;
bool listed = catalogEntry.IsListed;
if (range.Satisfies(catalogEntry.Version) &&
(includePrerelease || !version.IsPrerelease) &&
(includeUnlisted || listed))
{
catalogEntry.ReportAbuseUrl = _reportAbuseResource?.GetReportAbuseUrl(catalogEntry.PackageId, catalogEntry.Version);
catalogEntry.PackageDetailsUrl = _packageDetailsUriResource?.GetUri(catalogEntry.PackageId, catalogEntry.Version);
catalogEntry = metadataCache.GetObject(catalogEntry);
results.Add(catalogEntry);
}
}
}
// semver ranges specification
// as used by NuGet
//
// 1.0 x >= 1.0
// (1.0,) x > 1.0
// [1.0] x == 1.0
// (,1.0] x ≤ 1.0
// (,1.0) x< 1.0
// [1.0, 2.0] 1.0 ≤ x ≤ 2.0
// (1.0,2.0) 1.0 < x< 2.0
// [1.0, 2.0) 1.0 ≤ x < 2.0
// (1.0) invalid
/// <inheritdoc />
public void ApplyToTest(Test test)
{
if (test.RunState == RunState.NotRunnable)
{
return;
}
var methodInfo = test.Method;
var fixtureInfo = test.TypeInfo;
NuGetVersion serverVersion = null;
if (methodInfo != null)
{
serverVersion = methodInfo.GetCustomAttributes <ServerVersionAttribute>(true).FirstOrDefault()?.Version;
}
if (serverVersion == null && fixtureInfo != null)
{
serverVersion = fixtureInfo.GetCustomAttributes <ServerVersionAttribute>(true).FirstOrDefault()?.Version;
}
if (serverVersion == null)
{
var assemblyServerVersion = fixtureInfo?.Assembly.GetCustomAttributes <ServerVersionAttribute>().FirstOrDefault()?.Version;
serverVersion = ServerVersion.GetVersion(assemblyServerVersion);
}
if (_range.Satisfies(serverVersion))
{
return;
}
test.RunState = RunState.Ignored;
var reason = $"Server version {serverVersion} outside range {_range}.";
test.Properties.Set(PropertyNames.SkipReason, reason);
}
public async Task DependencyInfo_XunitRetrieveDependencies()
{
// Arrange
var repo = Repository.Factory.GetCoreV2("https://www.nuget.org/api/v2/");
var resource = await repo.GetResourceAsync <DependencyInfoResource>();
var package = new PackageIdentity("xunit", NuGetVersion.Parse("2.1.0-beta1-build2945"));
// filter to keep this test consistent
var filterRange = new VersionRange(NuGetVersion.Parse("2.0.0-rc4-build2924"), true, NuGetVersion.Parse("2.1.0-beta1-build2945"), true);
// Act
var results = await resource.ResolvePackages("xunit", NuGetFramework.Parse("net45"), CancellationToken.None);
var filtered = results.Where(result => filterRange.Satisfies(result.Version));
var target = filtered.Single(p => PackageIdentity.Comparer.Equals(p, package));
// Assert
Assert.Equal(3, filtered.Count());
Assert.Equal(2, target.Dependencies.Count());
Assert.Equal("[2.1.0-beta1-build2945, 2.1.0-beta1-build2945]", target.Dependencies.Single(dep => dep.Id == "xunit.core").VersionRange.ToNormalizedString());
Assert.Equal("[2.1.0-beta1-build2945, 2.1.0-beta1-build2945]", target.Dependencies.Single(dep => dep.Id == "xunit.assert").VersionRange.ToNormalizedString());
}
