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()); }