public static List <PackageSearchMedatadata> VersionsFor(VersionChange change)
{
switch (change)
{
case VersionChange.Major:
return(NewMajorVersion()
.Concat(MinorVersions())
.Concat(PatchVersions())
.ToList());
case VersionChange.Minor:
return(MinorVersions()
.Concat(PatchVersions())
.ToList());
case VersionChange.Patch:
return(PatchVersions());
case VersionChange.None:
return(CurrentVersionOnly());
default:
throw new Exception($"Invalid version change {change}");
}
}
public async Task <PackageLookupResult> FindVersionUpdate(
PackageIdentity package, VersionChange allowedChange)
{
var foundVersions = await _packageVersionsLookup.Lookup(package.Id);
return(VersionChanges.MakeVersions(package.Version, foundVersions, allowedChange));
}
public async Task <IDictionary <string, PackageLookupResult> > FindVersionUpdates(
IEnumerable <PackageIdentity> packages,
NuGetSources sources,
VersionChange allowedChange,
UsePrerelease usePrerelease)
{
var latestOfEach = packages
.GroupBy(pi => pi.Id.ToUpperInvariant())
.Select(HighestVersion);
var lookupTasks = latestOfEach
.Select(id => _packageLookup.FindVersionUpdate(id, sources, allowedChange, usePrerelease))
.ToList();
await Task.WhenAll(lookupTasks);
var result = new Dictionary <string, PackageLookupResult>(StringComparer.OrdinalIgnoreCase);
foreach (var lookupTask in lookupTasks)
{
var serverVersions = lookupTask.Result;
ProcessLookupResult(serverVersions, result);
}
return(result);
}
public async Task WhenFromPrereleaseIsAlwaysAllowedAndCurrentVersionIsPrerelease(
bool latestPackageIsPrerelease,
VersionChange dataRange,
int expectedMajor, int expectedMinor, int expectedPatch, string expectedReleaseLabel)
{
var expectedUpdate = new NuGetVersion(expectedMajor, expectedMinor, expectedPatch, expectedReleaseLabel);
var resultPackages = PackageVersionTestData.VersionsFor(dataRange);
if (latestPackageIsPrerelease)
{
// Only grab updated prerelease packages for this test - otherwise we'll upgrade to 2.3.4 instead of 2.3.4-prerelease
resultPackages = resultPackages.Where(x => x.Identity.Version.IsPrerelease).ToList();
}
var allVersionsLookup = MockVersionLookup(resultPackages);
IApiPackageLookup lookup = new ApiPackageLookup(allVersionsLookup);
var updates = await lookup.FindVersionUpdate(
CurrentVersion123Prerelease("TestPackage"),
NuGetSources.GlobalFeed,
VersionChange.Major,
UsePrerelease.Always);
AssertPackagesIdentityIs(updates, "TestPackage");
Assert.That(updates.Selected().Identity.Version, Is.EqualTo(expectedUpdate));
Assert.That(updates.Major.Identity.Version, Is.EqualTo(HighestVersion(resultPackages)));
}
private static PackageSearchMetadata FirstMatch(
IList <PackageSearchMetadata> candidates,
NuGetVersion current,
VersionChange allowedChange)
{
return(candidates.FirstOrDefault(p => Filter(current, p.Identity.Version, allowedChange)));
}
public async Task <IDictionary <PackageIdentity, PackageLookupResult> > FindVersionUpdates(
IEnumerable <PackageIdentity> packages,
NuGetSources sources,
VersionChange allowedChange,
UsePrerelease usePrerelease
)
{
var lookupTasks = packages
.Distinct()
.GroupBy(pi => (pi.Id, MaxVersion: GetMaxVersion(pi, allowedChange)))
.Select(HighestVersion)
.Select(id => new { Package = id, Update = _packageLookup.FindVersionUpdate(id, sources, allowedChange, usePrerelease) })
.ToList();
await Task.WhenAll(lookupTasks.Select(l => l.Update));
var result = new Dictionary <PackageIdentity, PackageLookupResult>();
foreach (var lookupTask in lookupTasks)
{
ProcessLookupResult(lookupTask.Package, lookupTask.Update.Result, result);
}
return(result);
}
public async Task <IReadOnlyCollection <PackageUpdateSet> > FindUpdatesForPackages(
IReadOnlyCollection <PackageInProject> packages,
NuGetSources sources,
VersionChange allowedChange)
{
var packageIds = packages
.Select(p => p.Identity)
.Distinct();
var latestVersions = await _bulkPackageLookup.FindVersionUpdates(
packageIds, sources, allowedChange);
var results = new List <PackageUpdateSet>();
foreach (var packageId in latestVersions.Keys)
{
var latestPackage = latestVersions[packageId];
var matchVersion = latestPackage.Selected().Identity.Version;
var updatesForThisPackage = packages
.Where(p => p.Id == packageId && p.Version < matchVersion)
.ToList();
if (updatesForThisPackage.Count > 0)
{
var updateSet = new PackageUpdateSet(latestPackage, updatesForThisPackage);
results.Add(updateSet);
}
}
return(results);
}
private void SetUpdateText()
{
VersionHelper helper = new VersionHelper();
VersionChange change = helper.GetChanges(helper.CurrentVersion);
this.Text = $"Neuigkeiten zu Version {helper.CurrentVersion}";
lbNews.Text = change.GetChanges();
}
private static string GetMaxVersion(PackageIdentity pi, VersionChange allowedChange)
{
return(allowedChange switch
{
VersionChange.Major => "X.X.X",
VersionChange.Minor => $"{pi.Version.Major}.X.X",
VersionChange.Patch => $"{pi.Version.Major}.{pi.Version.Minor}.X",
VersionChange.None => $"{pi.Version.Major}.{pi.Version.Minor}.{pi.Version.Patch}",
_ => throw new ArgumentOutOfRangeException(nameof(allowedChange)),
});
public async Task <PackageLookupResult> FindVersionUpdate(
PackageIdentity package,
NuGetSources sources,
VersionChange allowedChange)
{
var allowBetas = package.Version.IsPrerelease;
var foundVersions = await _packageVersionsLookup.Lookup(package.Id, allowBetas, sources);
return(VersionChanges.MakeVersions(package.Version, foundVersions, allowedChange));
}
private async Task<IReadOnlyCollection<PackageUpdateSet>> GetSortedUpdates(
IFolder folder,
NuGetSources sources,
VersionChange allowedChange)
{
var updates = await _updateFinder.FindPackageUpdateSets(
folder, sources, allowedChange);
return _sorter.Sort(updates)
.ToList();
}
public PackageLookupResult(
VersionChange allowedChange,
PackageSearchMetadata major,
PackageSearchMetadata minor,
PackageSearchMetadata patch)
{
AllowedChange = allowedChange;
Major = major;
Minor = minor;
Patch = patch;
}
public async Task <PackageLookupResult> FindVersionUpdate(
PackageIdentity package,
NuGetSources sources,
VersionChange allowedChange,
UsePrerelease usePrerelease)
{
var includePrerelease = ShouldAllowPrerelease(package, usePrerelease);
var foundVersions = await _packageVersionsLookup.Lookup(package.Id, includePrerelease, sources);
return(VersionChanges.MakeVersions(package.Version, foundVersions, allowedChange));
}
private async Task <IReadOnlyCollection <PackageUpdateSet> > GetSortedUpdates(
IFolder folder,
NuGetSources sources,
VersionChange allowedChange,
UsePrerelease usePrerelease,
Regex includes,
Regex excludes)
{
var updates = await _updateFinder.FindPackageUpdateSets(
folder, sources, allowedChange, usePrerelease, includes, excludes);
return(_sorter.Sort(updates)
.ToList());
}
public static PackageLookupResult MakeVersions(
NuGetVersion current,
IEnumerable <PackageSearchMetadata> candidateVersions,
VersionChange allowedChange)
{
var orderedCandidates = candidateVersions
.OrderByDescending(p => p.Identity.Version)
.ToList();
var major = FirstMatch(orderedCandidates, current, VersionChange.Major);
var minor = FirstMatch(orderedCandidates, current, VersionChange.Minor);
var patch = FirstMatch(orderedCandidates, current, VersionChange.Patch);
return(new PackageLookupResult(allowedChange, major, minor, patch));
}
public async Task <IReadOnlyCollection <PackageUpdateSet> > FindPackageUpdateSets(
IFolder workingFolder,
NuGetSources sources,
VersionChange allowedChange)
{
var packages = FindPackages(workingFolder);
_logger.Log(PackagesFoundLogger.Log(packages));
// look for updates to these packages
var updates = await _packageUpdatesLookup.FindUpdatesForPackages(
packages, sources, allowedChange);
_logger.Log(UpdatesLogger.Log(updates));
return(updates);
}
public async Task WhenPatchVersionChangesAreAllowed(VersionChange dataRange,
int expectedMajor, int expectedMinor, int expectedPatch)
{
var expectedUpdate = new NuGetVersion(expectedMajor, expectedMinor, expectedPatch);
var resultPackages = PackageVersionTestData.VersionsFor(dataRange);
var allVersionsLookup = MockVersionLookup(resultPackages);
IApiPackageLookup lookup = new ApiPackageLookup(allVersionsLookup);
var updates = await lookup.FindVersionUpdate(CurrentVersion123("TestPackage"),
VersionChange.Patch);
AssertPackagesIdentityIs(updates, "TestPackage");
Assert.That(updates.Selected().Identity.Version, Is.EqualTo(expectedUpdate));
Assert.That(updates.Major.Identity.Version, Is.EqualTo(HighestVersion(resultPackages)));
}
private static PackageLookupResult GetPackageLookupResult(
PackageIdentity package,
VersionChange versionChange
)
{
var packageName = package.Id;
var major = package.Version.Major;
var minor = package.Version.Minor;
var patch = package.Version.Patch;
return(new PackageLookupResult(
versionChange,
MakePackageSearchMetadata(packageName, $"{major + 1}.0.0"),
MakePackageSearchMetadata(packageName, $"{major}.{minor+1}.0"),
MakePackageSearchMetadata(packageName, $"{major}.{minor}.{patch+1}")
));
}
public async Task <IReadOnlyCollection <PackageUpdateSet> > FindPackageUpdateSets(
IFolder workingFolder,
NuGetSources sources,
VersionChange allowedChange)
{
// scan for nuget packages
var packages = _repositoryScanner.FindAllNuGetPackages(workingFolder)
.ToList();
_logger.Log(PackagesFoundLogger.Log(packages));
// look for updates to these packages
var updates = await _packageUpdatesLookup.FindUpdatesForPackages(
packages, sources, allowedChange);
_logger.Log(UpdatesLogger.Log(updates));
return(updates);
}
private static bool Filter(NuGetVersion v1, NuGetVersion v2, VersionChange allowedChange)
{
switch (allowedChange)
{
case VersionChange.Major:
return(true);
case VersionChange.Minor:
return(v1.Major == v2.Major);
case VersionChange.Patch:
return((v1.Major == v2.Major) && (v1.Minor == v2.Minor));
case VersionChange.None:
return(v1 == v2);
default:
throw new NuKeeperException($"Unknown version change {allowedChange}");
}
}
public async Task WhenFromPrereleaseIsNeverAllowedAndCurrentVersionIsStable(
VersionChange dataRange,
int expectedMajor, int expectedMinor, int expectedPatch, string expectedReleaseLabel)
{
var expectedUpdate = new NuGetVersion(expectedMajor, expectedMinor, expectedPatch, expectedReleaseLabel);
var resultPackages = PackageVersionTestData.VersionsFor(dataRange);
var allVersionsLookup = MockVersionLookup(resultPackages);
IApiPackageLookup lookup = new ApiPackageLookup(allVersionsLookup);
var updates = await lookup.FindVersionUpdate(
CurrentVersion123("TestPackage"),
NuGetSources.GlobalFeed,
VersionChange.Major,
UsePrerelease.Never);
AssertPackagesIdentityIs(updates, "TestPackage");
Assert.That(updates.Selected().Identity.Version, Is.EqualTo(expectedUpdate));
Assert.That(updates.Major.Identity.Version, Is.EqualTo(HighestVersion(resultPackages)));
}
public async Task <IReadOnlyCollection <PackageUpdateSet> > FindPackageUpdateSets(
IFolder workingFolder,
NuGetSources sources,
VersionChange allowedChange,
UsePrerelease usePrerelease,
Regex includes = null,
Regex excludes = null)
{
var packages = FindPackages(workingFolder);
_logger.Normal($"Found {packages.Count} packages");
var filtered = FilteredByIncludeExclude(packages, includes, excludes);
_logger.Log(PackagesFoundLogger.Log(filtered));
// look for updates to these packages
var updates = await _packageUpdatesLookup.FindUpdatesForPackages(
filtered, sources, allowedChange, usePrerelease);
_logger.Log(UpdatesLogger.Log(updates));
return(updates);
}
public async Task <Dictionary <string, PackageLookupResult> > FindVersionUpdates(
IEnumerable <PackageIdentity> packages, VersionChange allowedChange)
{
var latestOfEach = packages
.GroupBy(pi => pi.Id)
.Select(HighestVersion);
var lookupTasks = latestOfEach
.Select(id => _packageLookup.FindVersionUpdate(id, allowedChange))
.ToList();
await Task.WhenAll(lookupTasks);
var result = new Dictionary <string, PackageLookupResult>();
foreach (var lookupTask in lookupTasks)
{
var serverVersions = lookupTask.Result;
ProcessLookupResult(serverVersions, result);
}
return(result);
}
//--- Constructors ----
public VersionDiff(VersionChange change, VersionSeverity severity)
{
Change = change;
Severity = severity;
}
//--- Constructors ----
public VersionDiff(VersionChange change, VersionSeverity severity)
{
Change = change;
Severity = severity;
}
public PackageUpdatesLookup(IBulkPackageLookup bulkPackageLookup, UserSettings settings)
{
_bulkPackageLookup = bulkPackageLookup;
_allowedChange = settings.AllowedChange;
}
