public void ResolveChooseBestMatchForDependencyBehavior()
{
// Arrange
var target = CreatePackage("A", "1.0", new Dictionary<string, string>() {
{ "B", "1.0.0" },
});
var sourceRepository = new List<ResolverPackage>();
sourceRepository.Add(target);
sourceRepository.Add(CreatePackage("B", "4.0.0", new Dictionary<string, string>() { { "C", "2.0.0" } }));
sourceRepository.Add(CreatePackage("B", "2.0.0", new Dictionary<string, string>() { { "C", "2.0.0" } }));
sourceRepository.Add(CreatePackage("C", "4.0.0"));
sourceRepository.Add(CreatePackage("C", "3.0.0"));
string message = string.Empty;
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
// Act
var packages = resolver.Resolve(context, CancellationToken.None).ToDictionary(p => p.Id);
// Assert
Assert.Equal(3, packages.Count());
Assert.Equal("1.0.0", packages["A"].Version.ToNormalizedString());
Assert.Equal("2.0.0", packages["B"].Version.ToNormalizedString());
Assert.Equal("3.0.0", packages["C"].Version.ToNormalizedString());
}
public void ResolveDependenciesForInstallPackageWithUnknownDependencyThrows()
{
// Arrange
var target = CreatePackage("A", "1.0", new Dictionary <string, string>()
{
{ "B", "1.0.0" },
});
var sourceRepository = new List <ResolverPackage>();
sourceRepository.Add(target);
string message = string.Empty;
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
// Act
try
{
var packages = resolver.Resolve(context, CancellationToken.None);
}
catch (NuGetResolverConstraintException ex)
{
message = ex.Message;
}
// Assert
Assert.Equal("Unable to resolve dependency 'B'.", message);
}
public virtual async Task <IEnumerable <SourcePackageDependencyInfo> > GetDependenciesAsync(PackageIdentity identity, SourceCacheContext cacheContext)
{
var packageSourceProvider = new PackageSourceProvider(m_NugetSettings);
var sourceRepositoryProvider = new SourceRepositoryProvider(packageSourceProvider, m_Providers);
var sourceRepositories = sourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependenciesAsync(identity, cacheContext, sourceRepositories, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { identity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
Logger);
return(m_PackageResolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x
=> PackageIdentityComparer.Default.Equals(x, p)))
.Where(d => !m_IgnoredDependendencies.Contains(d.Id)));
}
public void Resolver_IgnoreDependencies()
{
var target = CreatePackage("A", "1.0", new Dictionary <string, string>()
{
{ "B", null }, { "C", null }
});
var sourceRepository = new List <ResolverPackage>()
{
target,
CreatePackage("B", "1.0", new Dictionary <string, string>()
{
{ "D", null }
}),
CreatePackage("C", "1.0", new Dictionary <string, string>()
{
{ "D", null }
}),
CreatePackage("D", "1.0"),
};
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Ignore, target, sourceRepository);
var packages = resolver.Resolve(context, CancellationToken.None).ToDictionary(p => p.Id);
// Assert
Assert.Equal(1, packages.Count());
Assert.NotNull(packages["A"]);
}
public void Resolver_Basic_AllUnlisted()
{
var a100 = new ResolverPackage("a", new NuGetVersion(1, 0, 0),
new NuGet.Packaging.Core.PackageDependency[]
{
new NuGet.Packaging.Core.PackageDependency("b",
new VersionRange(new NuGetVersion(1, 0, 0), true, new NuGetVersion(5, 0, 0), true))
},
false,
false);
var b200 = new ResolverPackage("b", new NuGetVersion(2, 0, 0), null, false, false);
var b250 = new ResolverPackage("b", new NuGetVersion(2, 5, 0), null, false, false);
var b400 = new ResolverPackage("b", new NuGetVersion(4, 0, 0), null, false, false);
var b500 = new ResolverPackage("b", new NuGetVersion(5, 0, 0), null, false, false);
var b600 = new ResolverPackage("b", new NuGetVersion(6, 0, 0), null, false, false);
List <ResolverPackage> available = new List <ResolverPackage>();
available.Add(a100);
available.Add(b200);
available.Add(b250);
available.Add(b400);
available.Add(b500);
available.Add(b600);
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, a100, available);
var solution = resolver.Resolve(context, CancellationToken.None)
.OrderBy(pi => pi.Id)
.ToList();
Assert.Equal(new PackageIdentity("a", new NuGetVersion(1, 0, 0)), solution[0], PackageIdentityComparer.Default);
Assert.Equal(new PackageIdentity("b", new NuGetVersion(2, 0, 0)), solution[1], PackageIdentityComparer.Default);
}
public void ResolveDependencyForInstallPackageWithDependencyThatDoesntMeetExactVersionThrows()
{
// Arrange
var target = CreatePackage("A", "1.0", new Dictionary <string, string>()
{
{ "B", "[1.5]" },
});
var sourceRepository = new List <ResolverPackage>();
sourceRepository.Add(target);
sourceRepository.Add(CreatePackage("B", "1.4"));
string message = string.Empty;
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
// Act
try
{
var packages = resolver.Resolve(context, CancellationToken.None);
}
catch (NuGetResolverConstraintException ex)
{
message = ex.Message;
}
// Assert
Assert.Equal("Unable to resolve dependencies. 'B 1.4.0' is not compatible with 'A 1.0.0 constraint: B (= 1.5.0)'.", message);
}
public async Task <IEnumerable <SourcePackageDependencyInfo> > GetPackagesToInstall(
PackageIdentity packageId,
NuGetFramework packageFramework,
string[] omitDependencies)
{
var availablePackages = await GetPackageAndDependencies(packageId, packageFramework, omitDependencies);
var sourcePackageDependencyInfos =
availablePackages as SourcePackageDependencyInfo[] ?? availablePackages.ToArray();
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { packageId.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
sourcePackageDependencyInfos,
_repositories.Select(s => s.PackageSource),
_logger);
var resolver = new PackageResolver();
return(resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => sourcePackageDependencyInfos.Single(x => PackageIdentityComparer.Default.Equals(x, p))));
}
public void ResolveDependencyForInstallPackageWithDependencyThatDoesntMeetExactVersionThrows()
{
// Arrange
var target = CreatePackage("A", "1.0", new Dictionary<string, string>() {
{ "B", "[1.5]" },
});
var sourceRepository = new List<ResolverPackage>();
sourceRepository.Add(target);
sourceRepository.Add(CreatePackage("B", "1.4"));
string message = string.Empty;
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
// Act
try
{
var packages = resolver.Resolve(context, CancellationToken.None);
}
catch (NuGetResolverConstraintException ex)
{
message = ex.Message;
}
// Assert
Assert.Equal("Unable to resolve dependencies. 'B 1.4' is not compatible with 'A 1.0 constraint: B (= 1.5.0)'.", message);
}
public void ResolveActionsPreferInstalledPackages()
{
// Arrange
// Local:
// B 1.0
// C 1.0
// Remote
// A 1.0 -> B 1.0, C 1.0
// B 1.0
// B 1.1
// C 1.0
// C 2.0
var target = CreatePackage("A", "1.0", new Dictionary <string, string>()
{
{ "B", "1.0" }, { "C", "1.0" }
});
// Expect: Install A 1.0 (no change to B or C)
var sourceRepository = new List <ResolverPackage>()
{
target,
CreatePackage("B", "1.0"),
CreatePackage("B", "1.1"),
CreatePackage("C", "1.0"),
CreatePackage("C", "2.0"),
};
var install = new List <PackageReference>()
{
new PackageReference(new PackageIdentity("B", NuGetVersion.Parse("1.0")), null),
new PackageReference(new PackageIdentity("C", NuGetVersion.Parse("1.0")), null),
};
List <PackageIdentity> targets = new List <PackageIdentity>();
targets.Add(target);
targets.AddRange(install.Select(e => e.PackageIdentity));
// Act
var resolver = new PackageResolver();
var context = new PackageResolverContext(DependencyBehavior.HighestMinor,
new string[] { "A" },
install.Select(p => p.PackageIdentity.Id),
install,
targets,
sourceRepository,
Enumerable.Empty <PackageSource>(),
Common.NullLogger.Instance);
var solution = resolver.Resolve(context, CancellationToken.None).ToArray();
var packages = solution.ToDictionary(p => p.Id);
// Assert
Assert.Equal(3, packages.Count);
Assert.Equal("1.0.0", packages["A"].Version.ToNormalizedString());
Assert.Equal("1.0.0", packages["B"].Version.ToNormalizedString());
Assert.Equal("1.0.0", packages["C"].Version.ToNormalizedString());
}
public void ResolveActionsForSimpleUpdate()
{
// Arrange
// Installed: A, B
// A 1.0 -> B [1.0]
var project = new List <ResolverPackage>()
{
CreatePackage("A", "1.0", new Dictionary <string, string> {
{ "B", "1.0" }
}),
CreatePackage("B", "1.0"),
};
var target = CreatePackage("A", "2.0", new Dictionary <string, string> {
{ "B", "1.0" }
});
var sourceRepository = new List <ResolverPackage>()
{
target,
CreatePackage("B", "1.0"),
};
// Act
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.HighestPatch, target, sourceRepository);
var solution = resolver.Resolve(context, CancellationToken.None).ToArray();
var packages = solution.ToDictionary(p => p.Id);
// Assert
Assert.Equal(2, solution.Length);
Assert.Equal("2.0.0", packages["A"].Version.ToNormalizedString());
}
public void ResolveDependenciesWithCircularReference()
{
// Arrange
var target = CreatePackage("A", "1.0", new Dictionary <string, string>()
{
{ "B", "1.0.0" },
});
var sourceRepository = new List <ResolverPackage>();
sourceRepository.Add(target);
sourceRepository.Add(CreatePackage("B", "1.0", new Dictionary <string, string>()
{
{ "A", "1.0.0" },
}));
string message = string.Empty;
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
// Act
try
{
var packages = resolver.Resolve(context, CancellationToken.None);
}
catch (NuGetResolverConstraintException ex)
{
message = ex.Message;
}
// Assert
Assert.Equal("Circular dependency detected 'A 1.0.0 => B 1.0.0 => A 1.0.0'.", message);
}
public void ResolvesLowestMajorAndMinorHighestPatchVersionOfListedPackagesForDependencies()
{
// Arrange
var target = CreatePackage("A", "1.0", new Dictionary <string, string>()
{
{ "B", "1.0" }
});
// A 1.0 -> B 1.0
// B 1.0 -> C 1.1
// C 1.1 -> D 1.0
var sourceRepository = new List <ResolverPackage>()
{
target,
CreatePackage("B", "2.0", new Dictionary <string, string>()
{
{ "C", "1.1" }
}),
CreatePackage("B", "1.0", new Dictionary <string, string>()
{
{ "C", "1.1" }
}),
CreatePackage("B", "1.0.1"),
CreatePackage("D", "2.0"),
CreatePackage("C", "1.1.3", new Dictionary <string, string>()
{
{ "D", "1.0" }
}),
CreatePackage("C", "1.1.1", new Dictionary <string, string>()
{
{ "D", "1.0" }
}),
CreatePackage("C", "1.5.1", new Dictionary <string, string>()
{
{ "D", "1.0" }
}),
CreatePackage("B", "1.0.9", new Dictionary <string, string>()
{
{ "C", "1.1" }
}),
CreatePackage("B", "1.1", new Dictionary <string, string>()
{
{ "C", "1.1" }
})
};
// Act
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.HighestPatch, target, sourceRepository);
var packages = resolver.Resolve(context, CancellationToken.None).ToDictionary(p => p.Id);
// Assert
Assert.Equal(4, packages.Count);
Assert.Equal("2.0.0", packages["D"].Version.ToNormalizedString());
Assert.Equal("1.1.3", packages["C"].Version.ToNormalizedString());
Assert.Equal("1.0.9", packages["B"].Version.ToNormalizedString());
Assert.Equal("1.0.0", packages["A"].Version.ToNormalizedString());
}
public void Resolver_Basic()
{
ResolverPackage target = new ResolverPackage("a", new NuGetVersion(1, 0, 0),
new NuGet.Packaging.Core.PackageDependency[]
{
new NuGet.Packaging.Core.PackageDependency("b", new VersionRange(new NuGetVersion(1, 0, 0), true, new NuGetVersion(3, 0, 0), true))
},
true,
false);
var dep1 = new ResolverPackage("b", new NuGetVersion(2, 0, 0));
var dep2 = new ResolverPackage("b", new NuGetVersion(2, 5, 0));
var dep3 = new ResolverPackage("b", new NuGetVersion(4, 0, 0));
List <ResolverPackage> possible = new List <ResolverPackage>();
possible.Add(dep1);
possible.Add(dep2);
possible.Add(dep3);
possible.Add(target);
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, possible);
var solution = resolver.Resolve(context, CancellationToken.None).ToList();
Assert.Equal(2, solution.Count());
}
/// Flattens the list of dependency packages to a single list of packages to be installed.
public IEnumerable <SourcePackageDependencyInfo> ResolveDependencyGraph(PackageIdentity pkgId, IEnumerable <SourcePackageDependencyInfo> dependencies)
{
// We used PackageResolver to flatten the dependency graph. This is the process Nuget uses
// when adding a package to a project. It takes:
// - a list of targets, in this case the package we want to add
// - a list of packages already installed, (i.e. the package that used to be defined in the packages.config)
// * in our case, the packages already added to this service
// - a list of available packages (i.e. the list of packages in the nuget sources).
// * in our case, all the dependencies we already found via GetPackageDependencies
// The resolver will then filter out the list such that only one version of each package
// gets installed.
var resolverContext = new PackageResolverContext(
dependencyBehavior: DependencyBehavior.Lowest,
targetIds: new[] { pkgId.Id },
requiredPackageIds: Enumerable.Empty <string>(),
packagesConfig: Items.Select(p => new PackageReference(p, NETCOREAPP2_1, true)),
preferredVersions: Enumerable.Empty <PackageIdentity>(),
availablePackages: dependencies,
packageSources: Repositories.Select(s => s.PackageSource),
log: Logger);
var resolver = new PackageResolver();
return(resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => dependencies.Single(x => PackageIdentityComparer.Default.Equals(x, p))));
}
public void ResolveDependenciesForInstallDiamondDependencyGraphWithDifferentVersionsOfSamePackage()
{
// Arrange
var sourceRepository = new List <ResolverPackage>();
// A -> [B, C]
// B -> [D >= 1, E >= 2]
// C -> [D >= 2, E >= 1]
// A
// / \
// B C
// | \ | \
// D1 E2 D2 E1
var packageA = CreatePackage("A", "1.0", new Dictionary <string, string>()
{
{ "B", null }, { "C", null }
});
var packageB = CreatePackage("B", "1.0", new Dictionary <string, string>()
{
{ "D", "1.0" }, { "E", "2.0" }
});
var packageC = CreatePackage("C", "1.0", new Dictionary <string, string>()
{
{ "D", "2.0" }, { "E", "1.0" }
});
var packageD1 = CreatePackage("D", "1.0");
var packageD2 = CreatePackage("D", "2.0");
var packageE1 = CreatePackage("E", "1.0");
var packageE2 = CreatePackage("E", "2.0");
sourceRepository.Add(packageA);
sourceRepository.Add(packageB);
sourceRepository.Add(packageC);
sourceRepository.Add(packageD2);
sourceRepository.Add(packageD1);
sourceRepository.Add(packageE2);
sourceRepository.Add(packageE1);
// Act
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, packageA, sourceRepository);
var solution = resolver.Resolve(context, CancellationToken.None).ToArray();
var packages = solution.ToDictionary(p => p.Id);
// Assert
Assert.Equal(5, packages.Count());
Assert.Equal("1.0.0", packages["A"].Version.ToNormalizedString());
Assert.Equal("1.0.0", packages["B"].Version.ToNormalizedString());
Assert.Equal("1.0.0", packages["C"].Version.ToNormalizedString());
Assert.Equal("2.0.0", packages["D"].Version.ToNormalizedString());
Assert.Equal("2.0.0", packages["E"].Version.ToNormalizedString());
//Verify that D & E are first (order doesn't matter), then B & C (order doesn't matter), then A
Assert.True(solution.Take(2).Select(a => a.Id).All(id => id == "D" || id == "E"));
Assert.True(solution.Skip(2).Take(2).Select(a => a.Id).All(id => id == "B" || id == "C"));
Assert.Equal("A", solution[4].Id);
}
public async Task DownloadAndInstall(PackageIdentity identity)
{
//包源靠前的地址已经找到和安装了包的时候不要再继续下面的包源操作了
try
{
using (var cacheContext = new SourceCacheContext())
{
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(identity, cacheContext, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { identity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <NuGet.Packaging.PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
SourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(PackagesInstallFolder);
var packageExtractionContext = new PackageExtractionContext(Logger);
packageExtractionContext.PackageSaveMode = PackageSaveMode.Defaultv3;
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
// PackageReaderBase packageReader;
var installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath == null)
{
var downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
NuGet.Configuration.SettingsUtility.GetGlobalPackagesFolder(Settings),
Logger, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
}
InstallPackage(packageToInstall);
}
}
}
catch (Exception ex)
{
SharedObject.Instance.Output(SharedObject.enOutputType.Error, "下载和安装nupkg包过程中出错", ex);
}
}
public async Task <List <IPackageSearchMetadata> > DownloadAndInstall(Project project, PackageIdentity identity, bool LoadDlls)
{
var result = new List <IPackageSearchMetadata>();
using (var cacheContext = new SourceCacheContext())
{
var repositories = DefaultSourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(identity, cacheContext, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { identity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <NuGet.Packaging.PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
DefaultSourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
// resolverContext.IncludeUnlisted = true;
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(PackagesInstallFolder);
var clientPolicyContext = NuGet.Packaging.Signing.ClientPolicyContext.GetClientPolicy(Settings, NullLogger.Instance);
var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, clientPolicyContext, NullLogger.Instance);
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
var installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath == null)
{
var downloadResource = await packageToInstall.Source.GetResourceAsync <DownloadResource>(CancellationToken.None);
var downloadResult = await downloadResource.GetDownloadResourceResultAsync(
packageToInstall,
new PackageDownloadContext(cacheContext),
NuGet.Configuration.SettingsUtility.GetGlobalPackagesFolder(Settings),
NullLogger.Instance, CancellationToken.None);
await PackageExtractor.ExtractPackageAsync(PackagesInstallFolder,
downloadResult.PackageStream,
packagePathResolver,
packageExtractionContext,
CancellationToken.None);
}
// per project or joined ?
// string TargetFolder = System.IO.Path.Combine(project.Path, "extensions");
string TargetFolder = System.IO.Path.Combine(Interfaces.Extensions.ProjectsDirectory, "extensions");
InstallPackage(TargetFolder, packageToInstall, LoadDlls);
}
}
return(result);
}
public void Resolver_Complex()
{
var target = new PackageIdentity("EntityFramework", NuGetVersion.Parse("7.0.0-beta4"));
var packages = ResolverData.CreateEntityFrameworkPackageGraph();
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, packages);
var solution = resolver.Resolve(context, CancellationToken.None);
Assert.True(solution.Contains(target, PackageIdentityComparer.Default));
}
public void Resolver_NoSolution()
{
ResolverPackage target = new ResolverPackage("a", new NuGetVersion(1, 0, 0), new NuGet.Packaging.Core.PackageDependency[] { new NuGet.Packaging.Core.PackageDependency("b", null) });
List <ResolverPackage> possible = new List <ResolverPackage>();
possible.Add(target);
var resolver = new PackageResolver(DependencyBehavior.Lowest);
Assert.Throws <NuGetResolverConstraintException>(() => resolver.Resolve(new ResolverPackage[] { target }, possible, CancellationToken.None));
}
public void ResolveDependenciesForLargeSetWithFailure()
{
// Arrange
var target = CreatePackage("Package0", "1.0", new Dictionary <string, string>()
{
{ "Package1", "1.0.0" },
{ "Package2", "1.0.0" },
{ "Package3", "1.0.0" },
{ "Package4", "1.0.0" },
{ "Package5", "1.0.0" },
{ "Package6", "1.0.0" },
{ "Package7", "1.0.0" },
{ "Package8", "1.0.0" },
});
var sourceRepository = new List <ResolverPackage>();
sourceRepository.Add(target);
// make lots of packages
for (int i = 0; i < 10; i++)
{
for (int j = 1; j < 20; j++)
{
int next = j + 1;
sourceRepository.Add(CreatePackage($"Package{j}", $"2.0.{i}", new Dictionary <string, string>()
{
{ $"Package{next}", "1.0.0" }
}));
}
}
string message = string.Empty;
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
// Act
try
{
var packages = resolver.Resolve(context, CancellationToken.None);
}
catch (NuGetResolverConstraintException ex)
{
message = ex.Message;
}
// Assert
Assert.Equal("Unable to resolve dependency 'Package20'.", message);
}
public static async Task InstallWithDependencies(string packageId, string version, string frameworkVersion, ILogger logger)
{
var packageVersion = NuGetVersion.Parse(version);
var nuGetFramework = NuGetFramework.ParseFolder(frameworkVersion);
var settings = Settings.LoadDefaultSettings(root: null);
var feed = new Uri("https://api.nuget.org/v3/index.json");
var repositoryList = new List <SourceRepository>();
repositoryList.Add(Repository.Factory.GetCoreV3(feed.AbsoluteUri, FeedType.HttpV3));
var sourceRepositoryProvider = new SourceRepositoryProvider(settings, Repository.Provider.GetCoreV3());
using (var cacheContext = new SourceCacheContext())
{
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(
new PackageIdentity(packageId, packageVersion),
nuGetFramework, cacheContext, logger, repositoryList, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { packageId },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
logger);
var resolver = new PackageResolver();
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
var packagePathResolver = new PackagePathResolver(Path.GetFullPath("packages"));
var packageExtractionContext = new PackageExtractionContext(
PackageSaveMode.Defaultv3,
XmlDocFileSaveMode.None,
ClientPolicyContext.GetClientPolicy(settings, logger),
logger);
//new PackageSignatureVerifier(
// signatureVerification.GetSignatureVerificationProviders()),
//SignedPackageVerifierSettings.GetDefault());
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
InstallPackages(packagePathResolver, packageToInstall, cacheContext, packageExtractionContext,
frameworkReducer, nuGetFramework, settings, logger);
}
}
}
public void ResolveDependenciesForVeryDeepGraph()
{
// Arrange
var target = CreatePackage("Package0", "1.0", new Dictionary <string, string>()
{
{ "Package1", "1.0.0" },
{ "Package2", "1.0.0" },
{ "Package3", "1.0.0" },
{ "Package4", "1.0.0" },
{ "Package5", "1.0.0" },
{ "Package6", "1.0.0" },
{ "Package7", "1.0.0" },
{ "Package8", "1.0.0" },
});
var sourceRepository = new List <ResolverPackage>();
sourceRepository.Add(target);
var next = 1;
// make lots of packages
for (var j = 1; j < 1000; j++)
{
next = j + 1;
sourceRepository.Add(CreatePackage($"Package{j}", "1.0.0", new Dictionary <string, string>()
{
{ $"Package{next}", "1.0.0" }
}));
}
sourceRepository.Add(CreatePackage($"Package{next}", "1.0.0"));
var resolver = new PackageResolver();
var context = new PackageResolverContext(DependencyBehavior.Lowest,
new[] { target.Id }, Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
new[] { target },
sourceRepository,
Enumerable.Empty <PackageSource>(),
Common.NullLogger.Instance);
// Act
var packages = resolver.Resolve(context, CancellationToken.None);
// Assert
Assert.Equal(1001, packages.Count());
}
public async Task <List <PackageSearchItem> > GetLocal(Project project, PackageIdentity identity)
{
var result = new List <PackageSearchItem>();
using (var cacheContext = new SourceCacheContext())
{
var repositories = DefaultSourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(identity, cacheContext, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { identity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <NuGet.Packaging.PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
DefaultSourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
// resolverContext.IncludeUnlisted = true;
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(PackagesInstallFolder);
var clientPolicyContext = NuGet.Packaging.Signing.ClientPolicyContext.GetClientPolicy(Settings, NullLogger.Instance);
var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, clientPolicyContext, NullLogger.Instance);
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
var installedPath = packagePathResolver.GetInstalledPath(packageToInstall);
if (installedPath != null)
{
// per project or joined ?
// string TargetFolder = System.IO.Path.Combine(project.Path, "extensions");
string TargetFolder = System.IO.Path.Combine(Interfaces.Extensions.ProjectsDirectory, "extensions");
PackageReaderBase packageReader;
packageReader = new PackageFolderReader(installedPath);
result.Add(new PackageSearchItem(project, packageReader));
}
}
}
return(result);
}
public void ResolveDependenciesForLargeSet()
{
// Arrange
var target = CreatePackage("Package0", "1.0", new Dictionary <string, string>()
{
{ "Package1", "1.0.0" },
{ "Package2", "1.0.0" },
{ "Package3", "1.0.0" },
{ "Package4", "1.0.0" },
{ "Package5", "1.0.0" },
{ "Package6", "1.0.0" },
{ "Package7", "1.0.0" },
{ "Package8", "1.0.0" },
});
var sourceRepository = new List <ResolverPackage>();
sourceRepository.Add(target);
int next = -1;
// make lots of packages
for (int i = 0; i < 100; i++)
{
for (int j = 1; j < 100; j++)
{
next = j + 1;
sourceRepository.Add(CreatePackage($"Package{j}", $"2.0.{i}", new Dictionary <string, string>()
{
{ $"Package{next}", "1.0.0" }
}));
}
}
sourceRepository.Add(CreatePackage($"Package{next}", $"2.0.0"));
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
// Act
var packages = resolver.Resolve(context, CancellationToken.None);
// Assert
Assert.Equal(101, packages.Count());
}
public void ResolveDependenciesForInstallDiamondDependencyGraphMissingPackage()
{
// Arrange
// A -> [B, C]
// B -> [D]
// C -> [D]
// A
// / \
// B C
// \ /
// D
var target = CreatePackage("A", "1.0", new Dictionary <string, string>()
{
{ "B", null }, { "C", null }
});
var sourceRepository = new List <ResolverPackage>()
{
target,
CreatePackage("B", "1.0", new Dictionary <string, string>()
{
{ "D", null }
}),
CreatePackage("C", "1.0", new Dictionary <string, string>()
{
{ "D", null }
}),
};
string message = string.Empty;
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
try
{
var packages = resolver.Resolve(context, CancellationToken.None);
}
catch (NuGetResolverConstraintException ex)
{
message = ex.Message;
}
Assert.Equal("Unable to resolve dependency 'D'.", message);
}
public static async Task <List <NuGetPackage> > GetAllPackageDependencies(List <NuGetPackage> pkgs,
string framework)
{
var allPkgs = new List <NuGetPackage>();
var packagesToInstall = new List <SourcePackageDependencyInfo>();
var settings = Settings.LoadDefaultSettings(null);
var sourceRepositoryProvider =
new SourceRepositoryProvider(new PackageSourceProvider(settings), Repository.Provider.GetCoreV3());
using var cacheContext = new SourceCacheContext();
var repositories = sourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
foreach (var package in pkgs)
{
var packageId = package.Id;
await GetPackageDependencies(
new PackageIdentity(package.Id, NuGetVersion.Parse(package.Version)),
NuGetFramework.ParseFolder(framework), cacheContext, NullLogger.Instance, repositories,
availablePackages);
}
var resolverContext = new PackageResolverContext(
DependencyBehavior.Highest,
pkgs.Select(p => p.Id).ToArray(),
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
NullLogger.Instance);
var resolver = new PackageResolver();
packagesToInstall.AddRange(resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p))));
foreach (var package in pkgs)
{
package.Dependencies = packagesToInstall.First(p => p.Id == package.Id).Dependencies.Select(dep => dep.Id).ToArray();
}
return(pkgs);
}
public void Resolver_MissingPackage()
{
// No version constraints for any dependency
// A -> B 2.0 -> (C, D)
// A -> B 1.0 -> Missing Package
var packageA = CreatePackage("A", "2.0", new Dictionary <string, string>()
{
{ "B", null }
});
var packageB = CreatePackage("B", "2.0", new Dictionary <string, string>()
{
{ "C", null }, { "D", null }
});
var packageC = CreatePackage("C", "2.0");
var packageD = CreatePackage("D", "2.0");
// OldB is the lowest but it has a missing dependency
var packageOldB = CreatePackage("B", "1.0", new Dictionary <string, string>()
{
{ "E", null }
});
var sourceRepository = new List <ResolverPackage>()
{
packageA,
packageB,
packageC,
packageD,
packageOldB
};
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, packageA, sourceRepository);
var packages = resolver.Resolve(context, CancellationToken.None).ToDictionary(p => p.Id);
// Assert
Assert.Equal(4, packages.Count());
Assert.NotNull(packages["A"]);
Assert.NotNull(packages["B"]);
Assert.NotNull(packages["C"]);
Assert.NotNull(packages["D"]);
}
public void ResolveDependenciesForInstallDiamondDependencyGraph()
{
// Arrange
// A -> [B, C]
// B -> [D]
// C -> [D]
// A
// / \
// B C
// \ /
// D
var target = CreatePackage("A", "1.0", new Dictionary <string, string>()
{
{ "B", null }, { "C", null }
});
var sourceRepository = new List <ResolverPackage>()
{
target,
CreatePackage("B", "1.0", new Dictionary <string, string>()
{
{ "D", null }
}),
CreatePackage("C", "1.0", new Dictionary <string, string>()
{
{ "D", null }
}),
CreatePackage("D", "1.0"),
};
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
var packages = resolver.Resolve(context, CancellationToken.None).ToDictionary(p => p.Id);
// Assert
Assert.Equal(4, packages.Count());
Assert.NotNull(packages["A"]);
Assert.NotNull(packages["B"]);
Assert.NotNull(packages["C"]);
Assert.NotNull(packages["D"]);
}
private static IReadOnlyCollection <PackageIdentity> GetPackagesToInstall(
PackageIdentity packageIdentity,
ResolutionContext resolutionContext,
INuGetProjectContext nuGetProjectContext,
IReadOnlyCollection <SourcePackageDependencyInfo> availablePackages,
ISet <SourceRepository> sources,
CancellationToken token)
{
var packageResolverContext = new PackageResolverContext(
resolutionContext.DependencyBehavior,
new[] { packageIdentity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
sources.Select(s => s.PackageSource),
new LoggerAdapter(nuGetProjectContext));
var packageResolver = new PackageResolver();
return(packageResolver.Resolve(packageResolverContext, token)?.ToList());
}
public async Task <List <IPackageSearchMetadata> > DownloadAndInstall(PackageIdentity identity)
{
var result = new List <IPackageSearchMetadata>();
using (var cacheContext = new SourceCacheContext())
{
var repositories = SourceRepositoryProvider.GetRepositories();
var availablePackages = new HashSet <SourcePackageDependencyInfo>(PackageIdentityComparer.Default);
await GetPackageDependencies(identity, cacheContext, availablePackages);
var resolverContext = new PackageResolverContext(
DependencyBehavior.Lowest,
new[] { identity.Id },
Enumerable.Empty <string>(),
Enumerable.Empty <NuGet.Packaging.PackageReference>(),
Enumerable.Empty <PackageIdentity>(),
availablePackages,
SourceRepositoryProvider.GetRepositories().Select(s => s.PackageSource),
Logger);
var resolver = new PackageResolver();
// resolverContext.IncludeUnlisted = true;
var packagesToInstall = resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => availablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p)));
var packagePathResolver = new NuGet.Packaging.PackagePathResolver(Packagesfolder);
var clientPolicyContext = NuGet.Packaging.Signing.ClientPolicyContext.GetClientPolicy(Settings, Logger);
var packageExtractionContext = new PackageExtractionContext(PackageSaveMode.Defaultv3, XmlDocFileSaveMode.None, clientPolicyContext, Logger);
var frameworkReducer = new FrameworkReducer();
foreach (var packageToInstall in packagesToInstall)
{
await Download(packageToInstall);
await InstallPackage(packageToInstall);
}
}
return(result);
}
public void ResolveChooseBestMatchForDependencyBehavior()
{
// Arrange
var target = CreatePackage("A", "1.0", new Dictionary <string, string>()
{
{ "B", "1.0.0" },
});
var sourceRepository = new List <ResolverPackage>();
sourceRepository.Add(target);
sourceRepository.Add(CreatePackage("B", "4.0.0", new Dictionary <string, string>()
{
{ "C", "2.0.0" }
}));
sourceRepository.Add(CreatePackage("B", "2.0.0", new Dictionary <string, string>()
{
{ "C", "2.0.0" }
}));
sourceRepository.Add(CreatePackage("C", "4.0.0"));
sourceRepository.Add(CreatePackage("C", "3.0.0"));
string message = string.Empty;
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
// Act
var packages = resolver.Resolve(context, CancellationToken.None).ToDictionary(p => p.Id);
// Assert
Assert.Equal(3, packages.Count());
Assert.Equal("1.0.0", packages["A"].Version.ToNormalizedString());
Assert.Equal("2.0.0", packages["B"].Version.ToNormalizedString());
Assert.Equal("3.0.0", packages["C"].Version.ToNormalizedString());
}
public void ResolveDependenciesForInstallDiamondDependencyGraphMissingPackage()
{
// Arrange
// A -> [B, C]
// B -> [D]
// C -> [D]
// A
// / \
// B C
// \ /
// D
var target = CreatePackage("A", "1.0", new Dictionary<string, string>() { { "B", null }, { "C", null } });
var sourceRepository = new List<ResolverPackage>() {
target,
CreatePackage("B", "1.0", new Dictionary<string, string>() { { "D", null } }),
CreatePackage("C", "1.0", new Dictionary<string, string>() { { "D", null } }),
};
string message = string.Empty;
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
try
{
var packages = resolver.Resolve(context, CancellationToken.None);
}
catch (NuGetResolverConstraintException ex)
{
message = ex.Message;
}
Assert.Equal("Unable to resolve dependency 'D'.", message);
}
public void Resolver_MissingPackage()
{
// No version constraints for any dependency
// A -> B 2.0 -> (C, D)
// A -> B 1.0 -> Missing Package
var packageA = CreatePackage("A", "2.0", new Dictionary<string, string>() { { "B", null } });
var packageB = CreatePackage("B", "2.0", new Dictionary<string, string>() { { "C", null }, { "D", null } });
var packageC = CreatePackage("C", "2.0");
var packageD = CreatePackage("D", "2.0");
// OldB is the lowest but it has a missing dependency
var packageOldB = CreatePackage("B", "1.0", new Dictionary<string, string>() { { "E", null } });
var sourceRepository = new List<ResolverPackage>()
{
packageA,
packageB,
packageC,
packageD,
packageOldB
};
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, packageA, sourceRepository);
var packages = resolver.Resolve(context, CancellationToken.None).ToDictionary(p => p.Id);
// Assert
Assert.Equal(4, packages.Count());
Assert.NotNull(packages["A"]);
Assert.NotNull(packages["B"]);
Assert.NotNull(packages["C"]);
Assert.NotNull(packages["D"]);
}
public IEnumerable <SourcePackageDependencyInfo> ResolveDependencyGraph(PackageIdentity pkgId)
{
// We used PackageResolver to flatten the dependency graph. This is the process Nuget uses
// when adding a package to a project. It takes:
// - a list of targets, in this case the package we want to add
// - a list of packages already installed, (i.e. the package that used to be defined in the packages.config)
// * in our case, the packages already added to this service
// - a list of available packages (i.e. the list of packages in the nuget sources).
// * in our case, all the dependencies we already found via GetPackageDependencies
// The resolver will then filter out the list such that only one version of each package
// gets installed.
var resolverContext = new PackageResolverContext(
dependencyBehavior: DependencyBehavior.Lowest,
targetIds: new[] { pkgId.Id },
requiredPackageIds: Enumerable.Empty <string>(),
packagesConfig: Items.Select(p => new PackageReference(p, NETCOREAPP3_1, true)),
preferredVersions: Enumerable.Empty <PackageIdentity>(),
availablePackages: AvailablePackages,
packageSources: Repositories.Select(s => s.PackageSource),
log: Logger);
var resolver = new PackageResolver();
try
{
return(resolver.Resolve(resolverContext, CancellationToken.None)
.Select(p => AvailablePackages.Single(x => PackageIdentityComparer.Default.Equals(x, p))));
}
catch (NuGetResolverConstraintException exception)
{
Logger.LogWarning($"Exception caught when resolving package dependencies: {exception.Message}");
}
/*
* First we try using the NuGet PackageResolver to resolve all package dependencies.
* It's main purpose is to find which version of each package that needs to be loaded
* that satisfies all dependencies.
* But it may fail trying to find the perfect solution because some deeper package
* dependency might not be available, even though that dependency might never be
* needed in runtime.
* So we are opting to try to load our target package and all the available
* dependencies that could be found using the latest versions that are available in
* the local folders.
*/
var uniquePackageIds = AvailablePackages.Select(pkg => pkg.Id).Distinct();
var uniqueAvailablePackages = uniquePackageIds.SelectMany(
pkgId =>
LocalPackagesFinder.FindPackagesById(pkgId, Logger, CancellationToken.None)
.OrderByDescending(pkg => pkg.Identity.Version)
.Take(1)
.Select(
pkg => new SourcePackageDependencyInfo(
id: pkg.Identity.Id,
version: pkg.Identity.Version,
dependencies: AvailablePackages
.Where(d => d.Id == pkg.Identity.Id)
.OrderByDescending(d => d.Version.Version)
.FirstOrDefault()
?.Dependencies ?? new List <PackageDependency>(),
listed: true,
source: GlobalPackagesSource))
);
return(uniqueAvailablePackages);
}
public void Resolver_IgnoreDependencies()
{
var target = CreatePackage("A", "1.0", new Dictionary<string, string>() { { "B", null }, { "C", null } });
var sourceRepository = new List<ResolverPackage>()
{
target,
CreatePackage("B", "1.0", new Dictionary<string, string>() { { "D", null } }),
CreatePackage("C", "1.0", new Dictionary<string, string>() { { "D", null } }),
CreatePackage("D", "1.0"),
};
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Ignore, target, sourceRepository);
var packages = resolver.Resolve(context, CancellationToken.None).ToDictionary(p => p.Id);
// Assert
Assert.Equal(1, packages.Count());
Assert.NotNull(packages["A"]);
}
public void ResolveDependenciesForInstallDiamondDependencyGraph()
{
// Arrange
// A -> [B, C]
// B -> [D]
// C -> [D]
// A
// / \
// B C
// \ /
// D
var target = CreatePackage("A", "1.0", new Dictionary<string, string>() { { "B", null }, { "C", null } });
var sourceRepository = new List<ResolverPackage>()
{
target,
CreatePackage("B", "1.0", new Dictionary<string, string>() { { "D", null } }),
CreatePackage("C", "1.0", new Dictionary<string, string>() { { "D", null } }),
CreatePackage("D", "1.0"),
};
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
var packages = resolver.Resolve(context, CancellationToken.None).ToDictionary(p => p.Id);
// Assert
Assert.Equal(4, packages.Count());
Assert.NotNull(packages["A"]);
Assert.NotNull(packages["B"]);
Assert.NotNull(packages["C"]);
Assert.NotNull(packages["D"]);
}
public void ResolveDependenciesForInstallDiamondDependencyGraphWithDifferentVersionsOfSamePackage()
{
// Arrange
var sourceRepository = new List<ResolverPackage>();
// A -> [B, C]
// B -> [D >= 1, E >= 2]
// C -> [D >= 2, E >= 1]
// A
// / \
// B C
// | \ | \
// D1 E2 D2 E1
var packageA = CreatePackage("A", "1.0", new Dictionary<string, string>() { { "B", null }, { "C", null } });
var packageB = CreatePackage("B", "1.0", new Dictionary<string, string>() { { "D", "1.0" }, { "E", "2.0" } });
var packageC = CreatePackage("C", "1.0", new Dictionary<string, string>() { { "D", "2.0" }, { "E", "1.0" } });
var packageD1 = CreatePackage("D", "1.0");
var packageD2 = CreatePackage("D", "2.0");
var packageE1 = CreatePackage("E", "1.0");
var packageE2 = CreatePackage("E", "2.0");
sourceRepository.Add(packageA);
sourceRepository.Add(packageB);
sourceRepository.Add(packageC);
sourceRepository.Add(packageD2);
sourceRepository.Add(packageD1);
sourceRepository.Add(packageE2);
sourceRepository.Add(packageE1);
// Act
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, packageA, sourceRepository);
var solution = resolver.Resolve(context, CancellationToken.None).ToArray();
var packages = solution.ToDictionary(p => p.Id);
// Assert
Assert.Equal(5, packages.Count());
Assert.Equal("1.0.0", packages["A"].Version.ToNormalizedString());
Assert.Equal("1.0.0", packages["B"].Version.ToNormalizedString());
Assert.Equal("1.0.0", packages["C"].Version.ToNormalizedString());
Assert.Equal("2.0.0", packages["D"].Version.ToNormalizedString());
Assert.Equal("2.0.0", packages["E"].Version.ToNormalizedString());
//Verify that D & E are first (order doesn't matter), then B & C (order doesn't matter), then A
Assert.True(solution.Take(2).Select(a => a.Id).All(id => id == "D" || id == "E"));
Assert.True(solution.Skip(2).Take(2).Select(a => a.Id).All(id => id == "B" || id == "C"));
Assert.Equal("A", solution[4].Id);
}
public void ResolveDependenciesForLargeSetWithFailure()
{
// Arrange
var target = CreatePackage("Package0", "1.0", new Dictionary<string, string>() {
{ "Package1", "1.0.0" },
{ "Package2", "1.0.0" },
{ "Package3", "1.0.0" },
{ "Package4", "1.0.0" },
{ "Package5", "1.0.0" },
{ "Package6", "1.0.0" },
{ "Package7", "1.0.0" },
{ "Package8", "1.0.0" },
});
var sourceRepository = new List<ResolverPackage>();
sourceRepository.Add(target);
// make lots of packages
for (int i = 0; i < 20; i++)
{
for (int j = 1; j < 10; j++)
{
int next = j + 1;
sourceRepository.Add(CreatePackage($"Package{j}", $"2.0.{i}", new Dictionary<string, string>() { { $"Package{next}", "1.0.0" } }));
}
}
string message = string.Empty;
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
// Act
try
{
var packages = resolver.Resolve(context, CancellationToken.None);
}
catch (NuGetResolverConstraintException ex)
{
message = ex.Message;
}
// Assert
Assert.Equal("Unable to resolve dependency 'Package10'.", message);
}
public void ResolveActionsForSimpleUpdate()
{
// Arrange
// Installed: A, B
// A 1.0 -> B [1.0]
var project = new List<ResolverPackage>()
{
CreatePackage("A", "1.0", new Dictionary<string, string> { { "B", "1.0" } }),
CreatePackage("B", "1.0"),
};
var target = CreatePackage("A", "2.0", new Dictionary<string, string> { { "B", "1.0" } });
var sourceRepository = new List<ResolverPackage>()
{
target,
CreatePackage("B", "1.0"),
};
// Act
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.HighestPatch, target, sourceRepository);
var solution = resolver.Resolve(context, CancellationToken.None).ToArray();
var packages = solution.ToDictionary(p => p.Id);
// Assert
Assert.Equal(2, solution.Length);
Assert.Equal("2.0.0", packages["A"].Version.ToNormalizedString());
}
public void ResolvesLowestMajorAndMinorHighestPatchVersionOfListedPackagesForDependencies()
{
// Arrange
var target = CreatePackage("A", "1.0", new Dictionary<string, string>() { { "B", "1.0" } });
// A 1.0 -> B 1.0
// B 1.0 -> C 1.1
// C 1.1 -> D 1.0
var sourceRepository = new List<ResolverPackage>()
{
target,
CreatePackage("B", "2.0", new Dictionary<string, string>() { { "C", "1.1" } }),
CreatePackage("B", "1.0", new Dictionary<string, string>() { { "C", "1.1" } }),
CreatePackage("B", "1.0.1"),
CreatePackage("D", "2.0"),
CreatePackage("C", "1.1.3", new Dictionary<string, string>() { { "D", "1.0" } }),
CreatePackage("C", "1.1.1", new Dictionary<string, string>() { { "D", "1.0" } }),
CreatePackage("C", "1.5.1", new Dictionary<string, string>() { { "D", "1.0" } }),
CreatePackage("B", "1.0.9", new Dictionary<string, string>() { { "C", "1.1" } }),
CreatePackage("B", "1.1", new Dictionary<string, string>() { { "C", "1.1" } })
};
// Act
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.HighestPatch, target, sourceRepository);
var packages = resolver.Resolve(context, CancellationToken.None).ToDictionary(p => p.Id);
// Assert
Assert.Equal(4, packages.Count);
Assert.Equal("2.0.0", packages["D"].Version.ToNormalizedString());
Assert.Equal("1.1.3", packages["C"].Version.ToNormalizedString());
Assert.Equal("1.0.9", packages["B"].Version.ToNormalizedString());
Assert.Equal("1.0.0", packages["A"].Version.ToNormalizedString());
}
public void Resolver_Basic()
{
ResolverPackage target = new ResolverPackage("a", new NuGetVersion(1, 0, 0),
new NuGet.Packaging.Core.PackageDependency[]
{
new NuGet.Packaging.Core.PackageDependency("b", new VersionRange(new NuGetVersion(1, 0, 0), true, new NuGetVersion(3, 0, 0), true))
},
true,
false);
var dep1 = new ResolverPackage("b", new NuGetVersion(2, 0, 0));
var dep2 = new ResolverPackage("b", new NuGetVersion(2, 5, 0));
var dep3 = new ResolverPackage("b", new NuGetVersion(4, 0, 0));
List<ResolverPackage> possible = new List<ResolverPackage>();
possible.Add(dep1);
possible.Add(dep2);
possible.Add(dep3);
possible.Add(target);
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, possible);
var solution = resolver.Resolve(context, CancellationToken.None).ToList();
Assert.Equal(2, solution.Count());
}
public void Resolver_NoSolution()
{
ResolverPackage target = new ResolverPackage("a", new NuGetVersion(1, 0, 0), new NuGet.Packaging.Core.PackageDependency[] { new NuGet.Packaging.Core.PackageDependency("b", null) }, true, false);
List<ResolverPackage> possible = new List<ResolverPackage>();
possible.Add(target);
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, possible);
Assert.Throws<NuGetResolverConstraintException>(() => resolver.Resolve(context, CancellationToken.None));
}
public void ResolveDependenciesWithCircularReference()
{
// Arrange
var target = CreatePackage("A", "1.0", new Dictionary<string, string>() {
{ "B", "1.0.0" },
});
var sourceRepository = new List<ResolverPackage>();
sourceRepository.Add(target);
sourceRepository.Add(CreatePackage("B", "1.0", new Dictionary<string, string>() {
{ "A", "1.0.0" },
}));
string message = string.Empty;
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
// Act
try
{
var packages = resolver.Resolve(context, CancellationToken.None);
}
catch (NuGetResolverConstraintException ex)
{
message = ex.Message;
}
// Assert
Assert.Equal("Circular dependency detected 'A 1.0 => B 1.0 => A 1.0'.", message);
}
public void Resolver_Basic_AllUnlisted()
{
var a100 = new ResolverPackage("a", new NuGetVersion(1, 0, 0),
new NuGet.Packaging.Core.PackageDependency[]
{
new NuGet.Packaging.Core.PackageDependency("b",
new VersionRange(new NuGetVersion(1, 0, 0), true, new NuGetVersion(5, 0, 0), true))
},
false,
false);
var b200 = new ResolverPackage("b", new NuGetVersion(2, 0, 0), null, false, false);
var b250 = new ResolverPackage("b", new NuGetVersion(2, 5, 0), null, false, false);
var b400 = new ResolverPackage("b", new NuGetVersion(4, 0, 0), null, false, false);
var b500 = new ResolverPackage("b", new NuGetVersion(5, 0, 0), null, false, false);
var b600 = new ResolverPackage("b", new NuGetVersion(6, 0, 0), null, false, false);
List<ResolverPackage> available = new List<ResolverPackage>();
available.Add(a100);
available.Add(b200);
available.Add(b250);
available.Add(b400);
available.Add(b500);
available.Add(b600);
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, a100, available);
var solution = resolver.Resolve(context, CancellationToken.None)
.OrderBy(pi => pi.Id)
.ToList();
Assert.Equal(new PackageIdentity("a", new NuGetVersion(1, 0, 0)), solution[0], PackageIdentityComparer.Default);
Assert.Equal(new PackageIdentity("b", new NuGetVersion(2, 0, 0)), solution[1], PackageIdentityComparer.Default);
}
public void Resolver_Complex()
{
var target = new PackageIdentity("EntityFramework", NuGetVersion.Parse("7.0.0-beta4"));
var packages = ResolverData.CreateEntityFrameworkPackageGraph();
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, packages);
var solution = resolver.Resolve(context, CancellationToken.None);
Assert.True(solution.Contains(target, PackageIdentityComparer.Default));
}
public void ResolveDependenciesForLargeSet()
{
// Arrange
var target = CreatePackage("Package0", "1.0", new Dictionary<string, string>() {
{ "Package1", "1.0.0" },
{ "Package2", "1.0.0" },
{ "Package3", "1.0.0" },
{ "Package4", "1.0.0" },
{ "Package5", "1.0.0" },
{ "Package6", "1.0.0" },
{ "Package7", "1.0.0" },
{ "Package8", "1.0.0" },
});
var sourceRepository = new List<ResolverPackage>();
sourceRepository.Add(target);
int next = -1;
// make lots of packages
for (int i = 0; i < 20; i++)
{
for (int j = 1; j < 10; j++)
{
next = j + 1;
sourceRepository.Add(CreatePackage($"Package{j}", $"2.0.{i}", new Dictionary<string, string>() { { $"Package{next}", "1.0.0" } }));
}
}
sourceRepository.Add(CreatePackage($"Package{next}", $"2.0.0"));
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
// Act
var packages = resolver.Resolve(context, CancellationToken.None);
// Assert
Assert.Equal(11, packages.Count());
}
public void ResolveDependenciesForInstallPackageWithUnknownDependencyThrows()
{
// Arrange
var target = CreatePackage("A", "1.0", new Dictionary<string, string>() {
{ "B", "1.0.0" },
});
var sourceRepository = new List<ResolverPackage>();
sourceRepository.Add(target);
string message = string.Empty;
var resolver = new PackageResolver();
var context = CreatePackageResolverContext(DependencyBehavior.Lowest, target, sourceRepository);
// Act
try
{
var packages = resolver.Resolve(context, CancellationToken.None);
}
catch (NuGetResolverConstraintException ex)
{
message = ex.Message;
}
// Assert
Assert.Equal("Unable to resolve dependency 'B'.", message);
}
public void ResolveActionsPreferInstalledPackages()
{
// Arrange
// Local:
// B 1.0
// C 1.0
// Remote
// A 1.0 -> B 1.0, C 1.0
// B 1.0
// B 1.1
// C 1.0
// C 2.0
var target = CreatePackage("A", "1.0", new Dictionary<string, string>() { { "B", "1.0" }, { "C", "1.0" } });
// Expect: Install A 1.0 (no change to B or C)
var sourceRepository = new List<ResolverPackage>()
{
target,
CreatePackage("B", "1.0"),
CreatePackage("B", "1.1"),
CreatePackage("C", "1.0"),
CreatePackage("C", "2.0"),
};
var install = new List<PackageReference>()
{
new PackageReference(new PackageIdentity("B", NuGetVersion.Parse("1.0")), null),
new PackageReference(new PackageIdentity("C", NuGetVersion.Parse("1.0")), null),
};
List<PackageIdentity> targets = new List<PackageIdentity>();
targets.Add(target);
targets.AddRange(install.Select(e => e.PackageIdentity));
// Act
var resolver = new PackageResolver();
var context = new PackageResolverContext(DependencyBehavior.HighestMinor,
new string[] { "A" },
install.Select(p => p.PackageIdentity.Id),
install,
targets,
sourceRepository);
var solution = resolver.Resolve(context, CancellationToken.None).ToArray();
var packages = solution.ToDictionary(p => p.Id);
// Assert
Assert.Equal(3, packages.Count);
Assert.Equal("1.0.0", packages["A"].Version.ToNormalizedString());
Assert.Equal("1.0.0", packages["B"].Version.ToNormalizedString());
Assert.Equal("1.0.0", packages["C"].Version.ToNormalizedString());
}