public void ResolveDependenciesForInstallPackageResolvesDependencyUsingDependencyProvider()
{
// Arrange
IPackage packageA = PackageUtility.CreatePackage("A",
"1.0",
dependencies: new List<PackageDependency> {
new PackageDependency("B")
});
IPackage packageB = PackageUtility.CreatePackage("B");
var repository = new Mock<PackageRepositoryBase>();
repository.Setup(c => c.GetPackages()).Returns(new[] { packageA }.AsQueryable());
var dependencyProvider = repository.As<IDependencyResolver>();
dependencyProvider.Setup(c => c.ResolveDependency(It.Is<PackageDependency>(p => p.Id == "B"), It.IsAny<IPackageConstraintProvider>(), false, true, DependencyVersion.Lowest))
.Returns(packageB).Verifiable();
var localRepository = new MockPackageRepository();
IPackageOperationResolver resolver = new InstallWalker(localRepository,
repository.Object,
NullLogger.Instance,
ignoreDependencies: false,
allowPrereleaseVersions: false);
// Act
var operations = resolver.ResolveOperations(packageA).ToList();
// Assert
Assert.Equal(2, operations.Count);
Assert.Equal(PackageAction.Install, operations.First().Action);
Assert.Equal(packageB, operations.First().Package);
Assert.Equal(PackageAction.Install, operations.Last().Action);
Assert.Equal(packageA, operations.Last().Package);
dependencyProvider.Verify();
}
protected bool ShowLicenseAgreementForAllPackages(IVsPackageManager activePackageManager, out IList <PackageOperation> allOperations, out IList <IPackage> packagesByDependencyOrder)
{
allOperations = new List <PackageOperation>();
var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease);
if (_project.SupportsINuGetProjectSystem())
{
packagesByDependencyOrder = allPackages.ToList();
foreach (var package in allPackages)
{
allOperations.Add(new PackageOperation(package, PackageAction.Install));
}
}
else
{
var installWalker = new InstallWalker(
LocalRepository,
activePackageManager.SourceRepository,
_project.GetTargetFrameworkName(),
logger: this,
ignoreDependencies: false,
allowPrereleaseVersions: IncludePrerelease,
dependencyVersion: activePackageManager.DependencyVersion);
allOperations = installWalker.ResolveOperations(allPackages, out packagesByDependencyOrder);
}
return(ShowLicenseAgreement(activePackageManager, allOperations));
}
protected bool ShowLicenseAgreementForAllPackages(IVsPackageManager activePackageManager, out List <PackageOperation> allOperations)
{
allOperations = new List <PackageOperation>();
var installWalker = new InstallWalker(
LocalRepository,
activePackageManager.SourceRepository,
_project.GetTargetFrameworkName(),
logger: this,
ignoreDependencies: false,
allowPrereleaseVersions: IncludePrerelease);
var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease);
foreach (var package in allPackages)
{
if (allOperations.FindIndex(
operation => operation.Action == PackageAction.Install &&
operation.Package.Id == package.Id &&
operation.Package.Version == package.Version) == -1)
{
var operations = installWalker.ResolveOperations(package);
allOperations.AddRange(operations);
}
}
allOperations = (List <PackageOperation>)allOperations.Reduce();
return(ShowLicenseAgreement(activePackageManager, allOperations));
}
public void ResolveDependenciesForInstallCircularReferenceThrows()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
dependencies: new List <PackageDependency> {
new PackageDependency("B")
});
IPackage packageB = PackageUtility.CreatePackage("B", "1.0",
dependencies: new List <PackageDependency> {
new PackageDependency("A")
});
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageB);
IPackageOperationResolver resolver = new InstallWalker(localRepository,
sourceRepository,
NullLogger.Instance,
ignoreDependencies: false);
// Act & Assert
ExceptionAssert.Throws <InvalidOperationException>(() => resolver.ResolveOperations(packageA), "Circular dependency detected 'A 1.0 => B 1.0 => A 1.0'.");
}
public IEnumerable <IPackage> GetPackagesToBeInstalledForUpdateAll()
{
InstallWalker walker = new InstallWalker(
_webProjectManager.LocalRepository,
_webProjectManager.SourceRepository,
TargetFramework,
NullLogger.Instance,
ignoreDependencies: false,
allowPrereleaseVersions: IncludePrerelease);
var packagesToUpdate = GetPackagesWithUpdates();
var allOperations = new List <PackageOperation>();
foreach (IPackage package in packagesToUpdate)
{
if (!allOperations.Any(operation => operation.Action == PackageAction.Install &&
operation.Package.Id == package.Id &&
operation.Package.Version == package.Version))
{
var operations = walker.ResolveOperations(package);
allOperations.AddRange(operations);
}
}
return((from operation in allOperations
where operation.Action == PackageAction.Install
select operation.Package).Distinct());
}
public IEnumerable <IPackage> GetSourcePackageDependencies(IPackage package)
{
InstallWalker walker = new InstallWalker(localRepository: LocalRepository, sourceRepository: SourceRepository, logger: NullLogger.Instance, ignoreDependencies: false, allowPrereleaseVersions: false, targetFramework: null);
IEnumerable <PackageOperation> operations = walker.ResolveOperations(package);
return(operations.Where(operation => operation.Action == PackageAction.Install).Select(operation => operation.Package));
}
public void ResolveDependencyForInstallPackageWithDependencyThatDoesntMeetExactVersionThrows()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
dependencies: new List <PackageDependency> {
PackageDependency.CreateDependency("B", "[1.5]")
});
sourceRepository.AddPackage(packageA);
IPackage packageB = PackageUtility.CreatePackage("B", "1.4");
sourceRepository.AddPackage(packageB);
IPackageOperationResolver resolver = new InstallWalker(localRepository,
sourceRepository,
NullLogger.Instance,
ignoreDependencies: false);
// Act & Assert
ExceptionAssert.Throws <InvalidOperationException>(() => resolver.ResolveOperations(packageA), "Unable to resolve dependency 'B (= 1.5)'.");
}
protected bool ShowLicenseAgreement(
IPackage package,
IVsPackageManager packageManager,
IEnumerable <Project> projects,
out IList <PackageOperation> operations)
{
var allOperations = new List <PackageOperation>();
foreach (Project project in projects)
{
var walker = new InstallWalker(
packageManager.GetProjectManager(project).LocalRepository,
packageManager.SourceRepository,
project.GetTargetFrameworkName(),
this,
ignoreDependencies: false,
allowPrereleaseVersions: IncludePrerelease,
dependencyVersion: packageManager.DependencyVersion);
allOperations.AddRange(walker.ResolveOperations(package));
}
operations = allOperations.Reduce();
return(ShowLicenseAgreement(packageManager, operations));
}
protected void CheckInstallPSScripts(
IPackage package,
IPackageRepository localRepository,
IPackageRepository sourceRepository,
FrameworkName targetFramework,
bool includePrerelease,
out IList <PackageOperation> operations)
{
// Review: Is there any way the user could get into a position that we would need to allow pre release versions here?
var walker = new InstallWalker(
localRepository,
sourceRepository,
targetFramework,
this,
ignoreDependencies: false,
allowPrereleaseVersions: includePrerelease);
operations = walker.ResolveOperations(package).ToList();
var scriptPackages = from o in operations
where o.Package.HasPowerShellScript()
select o.Package;
if (scriptPackages.Any())
{
if (!RegistryHelper.CheckIfPowerShell2Installed())
{
throw new InvalidOperationException(Resources.Dialog_PackageHasPSScript);
}
}
}
void WalkPackage(IPackage package)
{
var localRepository = new FakePackageRepository();
var sourceRepository = new FakePackageRepository();
var walker = new InstallWalker(localRepository, sourceRepository, null, NullLogger.Instance, true, false, DependencyVersion.Lowest);
walker.Walk(package);
}
private static IEnumerable <IPackage> GetPackageDependencies(IPackage package, IPackageRepository localRepository, IPackageRepository sourceRepository)
{
InstallWalker walker = new InstallWalker(localRepository: localRepository, sourceRepository: sourceRepository, logger: NullLogger.Instance, ignoreDependencies: false);
IEnumerable <PackageOperation> operations = walker.ResolveOperations(package);
return(from operation in operations
where operation.Action == PackageAction.Install
select operation.Package);
}
/// <summary>
/// Gets the package dependencies.
/// </summary>
/// <param name="package">The package.</param>
/// <param name="localRepository">The local repository.</param>
/// <param name="sourceRepository">The source repository.</param>
/// <returns></returns>
private static IEnumerable <IPackage> GetPackageDependencies(IPackage package, IPackageRepository localRepository, IPackageRepository sourceRepository)
{
InstallWalker walker = new InstallWalker(localRepository: localRepository, sourceRepository: sourceRepository, targetFramework: null, logger: NullLogger.Instance, ignoreDependencies: false, allowPrereleaseVersions: false, dependencyVersion: DependencyVersion.Highest);
IEnumerable <PackageOperation> operations = walker.ResolveOperations(package);
return(from operation in operations
where operation.Action == PackageAction.Install
select operation.Package);
}
protected override bool ExecuteCore(PackageItem item)
{
var activePackageManager = GetActivePackageManager();
Debug.Assert(activePackageManager != null);
var walker = new InstallWalker(
ProjectManager.LocalRepository,
activePackageManager.SourceRepository,
this,
ignoreDependencies: false);
IList <PackageOperation> operations = walker.ResolveOperations(item.PackageIdentity).ToList();
IList <IPackage> scriptPackages = (from o in operations
where o.Package.HasPowerShellScript()
select o.Package).ToList();
if (scriptPackages.Count > 0)
{
if (!RegistryHelper.CheckIfPowerShell2Installed())
{
throw new InvalidOperationException(Resources.Dialog_PackageHasPSScript);
}
}
IEnumerable <IPackage> licensePackages = from o in operations
where o.Action == PackageAction.Install && o.Package.RequireLicenseAcceptance && !activePackageManager.LocalRepository.Exists(o.Package)
select o.Package;
// display license window if necessary
if (licensePackages.Any())
{
// hide the progress window if we are going to show license window
HideProgressWindow();
bool accepted = _licenseWindowOpener.ShowLicenseWindow(licensePackages);
if (!accepted)
{
return(false);
}
ShowProgressWindow();
}
try {
RegisterPackageOperationEvents(activePackageManager);
ExecuteCommand(item, activePackageManager, operations);
}
finally {
UnregisterPackageOperationEvents(activePackageManager);
}
return(true);
}
public void ResolveDependenciesForInstallDiamondDependencyGraph()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
// A -> [B, C]
// B -> [D]
// C -> [D]
// A
// / \
// B C
// \ /
// D
IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
dependencies: new List <PackageDependency> {
new PackageDependency("B"),
new PackageDependency("C")
});
IPackage packageB = PackageUtility.CreatePackage("B", "1.0",
dependencies: new List <PackageDependency> {
new PackageDependency("D")
});
IPackage packageC = PackageUtility.CreatePackage("C", "1.0",
dependencies: new List <PackageDependency> {
new PackageDependency("D")
});
IPackage packageD = PackageUtility.CreatePackage("D", "1.0");
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageD);
IPackageOperationResolver resolver = new InstallWalker(localRepository,
sourceRepository,
NullLogger.Instance,
ignoreDependencies: false);
// Act
var packages = resolver.ResolveOperations(packageA).ToList();
// Assert
var dict = packages.ToDictionary(p => p.Package.Id);
Assert.AreEqual(4, packages.Count);
Assert.IsNotNull(dict["A"]);
Assert.IsNotNull(dict["B"]);
Assert.IsNotNull(dict["C"]);
Assert.IsNotNull(dict["D"]);
}
private IEnumerable <PackageOperation> ResolveOperationsToInstallSolutionLevelPackage(Operation operation)
{
IEnumerable <PackageOperation> enumerable = new InstallWalker(this._virtualPackageRepos[operation.ProjectManager.PackageManager], operation.ProjectManager.PackageManager.DependencyResolver, null, this.Logger, this.IgnoreDependencies, this.AllowPrereleaseVersions, this.DependencyVersion).ResolveOperations(operation.Package);
using (IEnumerator <PackageOperation> enumerator = enumerable.GetEnumerator())
{
while (enumerator.MoveNext())
{
enumerator.Current.Target = PackageOperationTarget.PackagesFolder;
}
}
return(enumerable);
}
public void ResolveOperationsForInstallSameDependencyAtDifferentLevelsInGraph()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
// A1 -> B1, C1
IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
dependencies: new List <PackageDependency> {
PackageDependency.CreateDependency("B", "1.0"),
PackageDependency.CreateDependency("C", "1.0")
});
// B1
IPackage packageB = PackageUtility.CreatePackage("B", "1.0");
// C1 -> B1, D1
IPackage packageC = PackageUtility.CreatePackage("C", "1.0",
dependencies: new List <PackageDependency> {
PackageDependency.CreateDependency("B", "1.0"),
PackageDependency.CreateDependency("D", "1.0")
});
// D1 -> B1
IPackage packageD = PackageUtility.CreatePackage("D", "1.0",
dependencies: new List <PackageDependency> {
PackageDependency.CreateDependency("B", "1.0")
});
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageD);
IPackageOperationResolver resolver = new InstallWalker(localRepository,
sourceRepository,
NullLogger.Instance,
ignoreDependencies: false);
// Act & Assert
var packages = resolver.ResolveOperations(packageA).ToList();
Assert.AreEqual(4, packages.Count);
Assert.AreEqual("B", packages[0].Package.Id);
Assert.AreEqual("D", packages[1].Package.Id);
Assert.AreEqual("C", packages[2].Package.Id);
Assert.AreEqual("A", packages[3].Package.Id);
}
private static IEnumerable <IPackage> GetPackageDependencies(IPackage package, IPackageRepository localRepository, IPackageRepository sourceRepository)
{
var walker = new InstallWalker(
localRepository,
sourceRepository,
new FrameworkName(".NET Framework, Version=4.0"),
NullLogger.Instance,
ignoreDependencies: false,
allowPrereleaseVersions: true);
return(from operation in walker.ResolveOperations(package)
where operation.Action == PackageAction.Install
select operation.Package);
}
private static IEnumerable <IPackage> GetPackageDependencies(IPackage package, IPackageRepository localRepository, IPackageRepository sourceRepository)
{
IPackageRepository repository = localRepository;
IPackageRepository repository2 = sourceRepository;
ILogger instance = NullLogger.Instance;
bool ignoreDependencies = false;
var walker = new InstallWalker(repository, repository2, new FrameworkName(".NETFramework", new Version("4.0")), instance, ignoreDependencies, true);
return(walker.ResolveOperations(package).Where <PackageOperation>(delegate(PackageOperation operation)
{
return (operation.Action == PackageAction.Install);
}).Select <PackageOperation, IPackage>(delegate(PackageOperation operation)
{
return operation.Package;
}));
}
protected bool ShowLicenseAgreement(
IPackage package,
IVsPackageManager packageManager,
FrameworkName targetFramework,
out IList <PackageOperation> operations)
{
var walker = new InstallWalker(
LocalRepository,
packageManager.SourceRepository,
targetFramework,
this,
ignoreDependencies: false,
allowPrereleaseVersions: IncludePrerelease);
operations = walker.ResolveOperations(package).ToList();
return(ShowLicenseAgreement(packageManager, operations));
}
public void ResolveDependenciesForInstallPackageWithUnknownDependencyThrows()
{
// Arrange
IPackage package = PackageUtility.CreatePackage("A",
"1.0",
dependencies: new List <PackageDependency> {
new PackageDependency("B")
});
IPackageOperationResolver resolver = new InstallWalker(new MockPackageRepository(),
new MockPackageRepository(),
NullLogger.Instance,
ignoreDependencies: false);
// Act & Assert
ExceptionAssert.Throws <InvalidOperationException>(() => resolver.ResolveOperations(package), "Unable to resolve dependency 'B'.");
}
protected bool ShowLicenseAgreementForAllPackages(IVsPackageManager activePackageManager, out IList <PackageOperation> allOperations, out IList <IPackage> packagesByDependencyOrder)
{
allOperations = new List <PackageOperation>();
var installWalker = new InstallWalker(
LocalRepository,
activePackageManager.SourceRepository,
_project.GetTargetFrameworkName(),
logger: this,
ignoreDependencies: false,
allowPrereleaseVersions: IncludePrerelease);
var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease);
allOperations = installWalker.ResolveOperations(allPackages, out packagesByDependencyOrder);
return(ShowLicenseAgreement(activePackageManager, allOperations));
}
public IEnumerable <IPackage> FindDependenciesToBeInstalled(IPackage package)
{
// We don't currently sync the set of dependencies/packates to be installed
// with the target framework of the user's site. We'd need to supply a framework
// version here to add that feature.
InstallWalker walker = new InstallWalker(
_webProjectManager.LocalRepository,
_webProjectManager.SourceRepository,
TargetFramework,
NullLogger.Instance,
ignoreDependencies: false,
allowPrereleaseVersions: IncludePrerelease);
IEnumerable <PackageOperation> operations = walker.ResolveOperations(package);
return(from operation in operations
where operation.Package != package && operation.Action == PackageAction.Install
select operation.Package);
}
public void ResolveDependenciesForInstallPackageWithUnknownDependencyThrows()
{
// Arrange
IPackage package = PackageUtility.CreatePackage("A",
"1.0",
dependencies: new List<PackageDependency> {
new PackageDependency("B")
});
IPackageOperationResolver resolver = new InstallWalker(new MockPackageRepository(),
new MockPackageRepository(),
NullLogger.Instance,
ignoreDependencies: false,
allowPrereleaseVersions: false);
// Act & Assert
ExceptionAssert.Throws<InvalidOperationException>(() => resolver.ResolveOperations(package), "Unable to resolve dependency 'B'.");
}
public ReinstallPackageOperations GetReinstallPackageOperations(IEnumerable <IPackage> packages)
{
var installWalker = new InstallWalker(
LocalRepository,
SourceRepository,
ProjectManager.Project.TargetFramework,
ProjectManager.Logger,
ignoreDependencies: true,
allowPrereleaseVersions: false,
dependencyVersion: DependencyVersion.Lowest);
IList <IPackage> packagesInDependencyOrder;
IList <PackageOperation> operations = installWalker.ResolveOperations(
packages,
out packagesInDependencyOrder,
allowPrereleaseVersionsBasedOnPackage: true);
return(new ReinstallPackageOperations(operations, packagesInDependencyOrder));
}
public void InstallWalkerResolvesLowestMajorAndMinorVersionButHighestBuildAndRevisionForDependencies()
{
// Arrange
// A 1.0 -> B 1.0
// B 1.0 -> C 1.1
// C 1.1 -> D 1.0
var A10 = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { PackageDependency.CreateDependency("B", "1.0") });
var repository = new MockPackageRepository()
{
PackageUtility.CreatePackage("B", "2.0", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") }),
PackageUtility.CreatePackage("B", "1.0", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") }),
PackageUtility.CreatePackage("B", "1.0.1"),
A10,
PackageUtility.CreatePackage("D", "2.0"),
PackageUtility.CreatePackage("C", "1.1.3", dependencies: new[] { PackageDependency.CreateDependency("D", "1.0") }),
PackageUtility.CreatePackage("C", "1.1.1", dependencies: new[] { PackageDependency.CreateDependency("D", "1.0") }),
PackageUtility.CreatePackage("C", "1.5.1", dependencies: new[] { PackageDependency.CreateDependency("D", "1.0") }),
PackageUtility.CreatePackage("B", "1.0.9", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") }),
PackageUtility.CreatePackage("B", "1.1", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") })
};
IPackageOperationResolver resolver = new InstallWalker(new MockPackageRepository(),
repository,
NullLogger.Instance,
ignoreDependencies: false);
// Act
var packages = resolver.ResolveOperations(A10).ToList();
// Assert
Assert.AreEqual(4, packages.Count);
Assert.AreEqual("D", packages[0].Package.Id);
Assert.AreEqual(new Version("2.0"), packages[0].Package.Version);
Assert.AreEqual("C", packages[1].Package.Id);
Assert.AreEqual(new Version("1.1.3"), packages[1].Package.Version);
Assert.AreEqual("B", packages[2].Package.Id);
Assert.AreEqual(new Version("1.0.9"), packages[2].Package.Version);
Assert.AreEqual("A", packages[3].Package.Id);
Assert.AreEqual(new Version("1.0"), packages[3].Package.Version);
}
public void InstallPackage(IPackageDetails package, bool allowedPrerelease)
{
Argument.IsNotNull(() => package);
Argument.IsOfType(() => package, typeof(PackageDetails));
var repository = _packageOperationContextService.CurrentContext.Repository;
var sourceRepository = _repositoryCacheService.GetNuGetRepository(repository);
var walker = new InstallWalker(_localRepository, sourceRepository, null, _logger, false, allowedPrerelease, DependencyVersion);
try
{
var nuGetPackage = ((PackageDetails)package).Package;
var operations = walker.ResolveOperations(nuGetPackage);
_packageManager.InstallPackage(nuGetPackage, false, allowedPrerelease, false);
}
catch (Exception exception)
{
_logger.Log(MessageLevel.Error, exception.Message);
_packageOperationContextService.CurrentContext.CatchedExceptions.Add(exception);
}
}
protected bool ShowLicenseAgreementForAllPackages(IVsPackageManager activePackageManager)
{
var allOperations = new List <PackageOperation>();
var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease).ToList();
foreach (var package in allPackages)
{
var installWalker = new InstallWalker(
LocalRepository,
activePackageManager.SourceRepository,
_project.GetTargetFrameworkName(),
logger: this,
ignoreDependencies: false,
allowPrereleaseVersions: IncludePrerelease);
var operations = installWalker.ResolveOperations(package);
allOperations.AddRange(operations);
}
return(ShowLicenseAgreement(activePackageManager, allOperations.Reduce()));
}
private IEnumerable <PackageOperation> ResolveOperationsToInstallSolutionLevelPackage(Operation operation)
{
var repo = _virtualPackageRepos[operation.ProjectManager.PackageManager];
var installWalker = new InstallWalker(
repo,
operation.ProjectManager.PackageManager.DependencyResolver,
targetFramework: null,
logger: Logger,
ignoreDependencies: IgnoreDependencies,
allowPrereleaseVersions: AllowPrereleaseVersions,
dependencyVersion: DependencyVersion);
var operations = installWalker.ResolveOperations(operation.Package);
// we're installing solution level packages, so all target should be
// set to PackagesFolder.
foreach (var op in operations)
{
op.Target = PackageOperationTarget.PackagesFolder;
}
return(operations);
}
protected bool ShowLicenseAgreementForAllPackages(IVsPackageManager activePackageManager, out IList<PackageOperation> allOperations, out IList<IPackage> packagesByDependencyOrder)
{
allOperations = new List<PackageOperation>();
var installWalker = new InstallWalker(
LocalRepository,
activePackageManager.SourceRepository,
_project.GetTargetFrameworkName(),
logger: this,
ignoreDependencies: false,
allowPrereleaseVersions: IncludePrerelease,
dependencyVersion: activePackageManager.DependencyVersion);
var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease);
allOperations = installWalker.ResolveOperations(allPackages, out packagesByDependencyOrder);
return ShowLicenseAgreement(activePackageManager, allOperations);
}
protected bool ShowLicenseAgreementForAllPackages(IVsPackageManager activePackageManager, out IList<PackageOperation> allOperations, out IList<IPackage> packagesByDependencyOrder)
{
allOperations = new List<PackageOperation>();
var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease);
if (_project.SupportsINuGetProjectSystem())
{
packagesByDependencyOrder = allPackages.ToList();
foreach (var package in allPackages)
{
allOperations.Add(new PackageOperation(package, PackageAction.Install));
}
}
else
{
var installWalker = new InstallWalker(
LocalRepository,
activePackageManager.SourceRepository,
_project.GetTargetFrameworkName(),
logger: this,
ignoreDependencies: false,
allowPrereleaseVersions: IncludePrerelease,
dependencyVersion: activePackageManager.DependencyVersion);
allOperations = installWalker.ResolveOperations(allPackages, out packagesByDependencyOrder);
}
return ShowLicenseAgreement(activePackageManager, allOperations);
}
protected bool ShowLicenseAgreement(
IPackage package,
IVsPackageManager packageManager,
IEnumerable<Project> projects,
out IList<PackageOperation> operations)
{
var allOperations = new List<PackageOperation>();
foreach (Project project in projects)
{
var walker = new InstallWalker(
packageManager.GetProjectManager(project).LocalRepository,
packageManager.SourceRepository,
project.GetTargetFrameworkName(),
this,
ignoreDependencies: false,
allowPrereleaseVersions: IncludePrerelease,
dependencyVersion: packageManager.DependencyVersion);
allOperations.AddRange(walker.ResolveOperations(package));
}
operations = allOperations.Reduce();
return ShowLicenseAgreement(packageManager, operations);
}
public void ResolveOperationsForInstallSameDependencyAtDifferentLevelsInGraph()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
// A1 -> B1, C1
IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
dependencies: new List<PackageDependency> {
PackageDependency.CreateDependency("B", "1.0"),
PackageDependency.CreateDependency("C", "1.0")
});
// B1
IPackage packageB = PackageUtility.CreatePackage("B", "1.0");
// C1 -> B1, D1
IPackage packageC = PackageUtility.CreatePackage("C", "1.0",
dependencies: new List<PackageDependency> {
PackageDependency.CreateDependency("B", "1.0"),
PackageDependency.CreateDependency("D", "1.0")
});
// D1 -> B1
IPackage packageD = PackageUtility.CreatePackage("D", "1.0",
dependencies: new List<PackageDependency> {
PackageDependency.CreateDependency("B", "1.0")
});
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageD);
IPackageOperationResolver resolver = new InstallWalker(localRepository,
sourceRepository,
NullLogger.Instance,
ignoreDependencies: false,
allowPrereleaseVersions: false);
// Act & Assert
var packages = resolver.ResolveOperations(packageA).ToList();
Assert.Equal(4, packages.Count);
Assert.Equal("B", packages[0].Package.Id);
Assert.Equal("D", packages[1].Package.Id);
Assert.Equal("C", packages[2].Package.Id);
Assert.Equal("A", packages[3].Package.Id);
}
public void ResolvingDependencyForUpdateThatHasAnUnsatisfiedConstraint()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
var constraintProvider = new Mock<IPackageConstraintProvider>();
constraintProvider.Setup(m => m.GetConstraint("B")).Returns(VersionUtility.ParseVersionSpec("[1.4]"));
constraintProvider.Setup(m => m.Source).Returns("foo");
IPackage A10 = PackageUtility.CreatePackage("A", "1.0",
dependencies: new List<PackageDependency> {
PackageDependency.CreateDependency("B", "1.5")
});
IPackage A20 = PackageUtility.CreatePackage("A", "2.0",
dependencies: new List<PackageDependency> {
PackageDependency.CreateDependency("B", "2.0")
});
IPackage B15 = PackageUtility.CreatePackage("B", "1.5");
IPackage B20 = PackageUtility.CreatePackage("B", "2.0");
localRepository.Add(A10);
localRepository.Add(B15);
sourceRepository.AddPackage(A10);
sourceRepository.AddPackage(A20);
sourceRepository.AddPackage(B15);
sourceRepository.AddPackage(B20);
IPackageOperationResolver resolver = new InstallWalker(localRepository,
sourceRepository,
constraintProvider.Object,
null,
NullLogger.Instance,
ignoreDependencies: false,
allowPrereleaseVersions: false);
// Act & Assert
ExceptionAssert.Throws<InvalidOperationException>(() => resolver.ResolveOperations(A20), "Unable to resolve dependency 'B (\u2265 2.0)'.'B' has an additional constraint (= 1.4) defined in foo.");
}
public void ResolveDependencyForInstallCircularReferenceWithDifferentVersionOfPackageReferenceThrows()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
IPackage packageA10 = PackageUtility.CreatePackage("A", "1.0",
dependencies: new List<PackageDependency> {
new PackageDependency("B")
});
IPackage packageA15 = PackageUtility.CreatePackage("A", "1.5",
dependencies: new List<PackageDependency> {
new PackageDependency("B")
});
IPackage packageB10 = PackageUtility.CreatePackage("B", "1.0",
dependencies: new List<PackageDependency> {
PackageDependency.CreateDependency("A", "[1.5]")
});
sourceRepository.AddPackage(packageA10);
sourceRepository.AddPackage(packageA15);
sourceRepository.AddPackage(packageB10);
IPackageOperationResolver resolver = new InstallWalker(localRepository,
sourceRepository,
NullLogger.Instance,
ignoreDependencies: false,
allowPrereleaseVersions: false);
// Act & Assert
ExceptionAssert.Throws<InvalidOperationException>(() => resolver.ResolveOperations(packageA10), "Circular dependency detected 'A 1.0 => B 1.0 => A 1.5'.");
}
public void ResolveDependenciesForInstallDiamondDependencyGraph()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
// A -> [B, C]
// B -> [D]
// C -> [D]
// A
// / \
// B C
// \ /
// D
IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
dependencies: new List<PackageDependency> {
new PackageDependency("B"),
new PackageDependency("C")
});
IPackage packageB = PackageUtility.CreatePackage("B", "1.0",
dependencies: new List<PackageDependency> {
new PackageDependency("D")
});
IPackage packageC = PackageUtility.CreatePackage("C", "1.0",
dependencies: new List<PackageDependency> {
new PackageDependency("D")
});
IPackage packageD = PackageUtility.CreatePackage("D", "1.0");
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageD);
IPackageOperationResolver resolver = new InstallWalker(localRepository,
sourceRepository,
NullLogger.Instance,
ignoreDependencies: false,
allowPrereleaseVersions: false);
// Act
var packages = resolver.ResolveOperations(packageA).ToList();
// Assert
var dict = packages.ToDictionary(p => p.Package.Id);
Assert.Equal(4, packages.Count);
Assert.NotNull(dict["A"]);
Assert.NotNull(dict["B"]);
Assert.NotNull(dict["C"]);
Assert.NotNull(dict["D"]);
}
// Reinstall all packages in the specified project
public void ReinstallPackages(
IProjectManager projectManager,
bool updateDependencies,
bool allowPrereleaseVersions,
ILogger logger)
{
//1) Call UninstallPackagesForReinstall(IProjectManager, Empty Dictionary, out packagesUninstalledForReinstallation)
//2) Call InstallWalker.ResolveOperations(packagesInSourceRepository, out IList<IPackage> packagesByDependencyOrder)
//3) Call ExecuteOperationsWithPackage( call projectManager.AddPackageReference(IPackage, ..., ...)
HashSet<IPackage> packagesToBeReinstalled;
UninstallPackagesForReinstall(projectManager, updateDependencies, logger, new Dictionary<PackageName, IPackage>(), out packagesToBeReinstalled);
// NOTE THAT allowPrereleaseVersions should be true for pre-release packages alone, even if the user did not specify it
// since we are trying to reinstall packages here. However, ResolveOperations below will take care of this problem via allowPrereleaseVersionsBasedOnPackage parameter
var installWalker = new InstallWalker(projectManager.LocalRepository, SourceRepository, projectManager.Project.TargetFramework, logger ?? NullLogger.Instance,
ignoreDependencies: !updateDependencies, allowPrereleaseVersions: allowPrereleaseVersions,
dependencyVersion: DependencyVersion);
IList<IPackage> packagesUninstalledInDependencyOrder;
var operations = installWalker.ResolveOperations(packagesToBeReinstalled, out packagesUninstalledInDependencyOrder, allowPrereleaseVersionsBasedOnPackage: true);
ExecuteOperationsWithPackage(
projectManager,
null,
operations,
() =>
{
foreach (var package in packagesUninstalledInDependencyOrder)
{
AddPackageReference(projectManager, package, ignoreDependencies: !updateDependencies, allowPrereleaseVersions: allowPrereleaseVersions || !package.IsReleaseVersion());
}
},
logger);
}
protected void CheckInstallPSScripts(
IPackage package,
IPackageRepository localRepository,
IPackageRepository sourceRepository,
FrameworkName targetFramework,
bool includePrerelease,
out IList<PackageOperation> operations)
{
// Review: Is there any way the user could get into a position that we would need to allow pre release versions here?
var walker = new InstallWalker(
localRepository,
sourceRepository,
targetFramework,
this,
ignoreDependencies: false,
allowPrereleaseVersions: includePrerelease);
operations = walker.ResolveOperations(package).ToList();
var scriptPackages = from o in operations
where o.Package.HasPowerShellScript()
select o.Package;
if (scriptPackages.Any())
{
if (!RegistryHelper.CheckIfPowerShell2Installed())
{
throw new InvalidOperationException(Resources.Dialog_PackageHasPSScript);
}
}
}
protected override bool ExecuteCore(PackageItem item)
{
var activePackageManager = GetActivePackageManager();
Debug.Assert(activePackageManager != null);
var walker = new InstallWalker(
ProjectManager.LocalRepository,
activePackageManager.SourceRepository,
this,
ignoreDependencies: false);
IList<PackageOperation> operations = walker.ResolveOperations(item.PackageIdentity).ToList();
IList<IPackage> scriptPackages = (from o in operations
where o.Package.HasPowerShellScript()
select o.Package).ToList();
if (scriptPackages.Count > 0) {
if (!RegistryHelper.CheckIfPowerShell2Installed()) {
throw new InvalidOperationException(Resources.Dialog_PackageHasPSScript);
}
}
IEnumerable<IPackage> licensePackages = from o in operations
where o.Action == PackageAction.Install && o.Package.RequireLicenseAcceptance && !activePackageManager.LocalRepository.Exists(o.Package)
select o.Package;
// display license window if necessary
if (licensePackages.Any()) {
// hide the progress window if we are going to show license window
HideProgressWindow();
bool accepted = _licenseWindowOpener.ShowLicenseWindow(licensePackages);
if (!accepted) {
return false;
}
ShowProgressWindow();
}
try {
RegisterPackageOperationEvents(activePackageManager);
ExecuteCommand(item, activePackageManager, operations);
}
finally {
UnregisterPackageOperationEvents(activePackageManager);
}
return true;
}
public void UpdatePackagesEndToEndWhereNewerVersionPackageDoesNotHaveDependencyLikeOlderVersion()
{
// Arrange
var localRepository = new MockSharedPackageRepository();
var projectRepository = new MockProjectPackageRepository(localRepository);
var sourceRepository = new MockPackageRepository();
var fileSystem = new MockFileSystem();
var pathResolver = new DefaultPackagePathResolver(fileSystem);
var A1 = PackageUtility.CreatePackage("A", "1.0", new[] { "hello1" }, dependencies: new[] { PackageDependency.CreateDependency("B", "1.0") });
var A2 = PackageUtility.CreatePackage("A", "2.0", new[] { "hello2" }, dependencies: new[] { PackageDependency.CreateDependency("C", "1.0") });
var B1 = PackageUtility.CreatePackage("B", "1.0", new[] { "world1" });
var B2 = PackageUtility.CreatePackage("B", "2.0", new[] { "world2" });
var C1 = PackageUtility.CreatePackage("C", "1.0", new[] { "galaxy1" });
var C2 = PackageUtility.CreatePackage("C", "2.0", new[] { "galaxy2" });
sourceRepository.AddPackage(A1);
sourceRepository.AddPackage(A2);
sourceRepository.AddPackage(B1);
sourceRepository.AddPackage(B2);
sourceRepository.AddPackage(C1);
sourceRepository.AddPackage(C2);
localRepository.AddPackage(A1);
localRepository.AddPackage(B1);
localRepository.AddPackage(C1);
projectRepository.Add(A1);
projectRepository.Add(B1);
projectRepository.Add(C1);
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object);
var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), projectRepository);
var installWalker = new InstallWalker(
localRepository,
sourceRepository,
null,
logger: NullLogger.Instance,
ignoreDependencies: false,
allowPrereleaseVersions: true);
IList<IPackage> updatePackagesByDependencyOrder;
var updatePackages = new List<IPackage> { A2, B2, C2 };
var operationsForShowingLicense = installWalker.ResolveOperations(updatePackages, out updatePackagesByDependencyOrder);
// Act
packageManager.UpdatePackages(projectManager, updatePackagesByDependencyOrder, operationsForShowingLicense, updateDependencies: true, allowPrereleaseVersions: true, logger: NullLogger.Instance);
// Assert
// NOTE THAT BELOW, there is no uninstall operation for B1 but only for C1. Because A2 depends on C1 only where A1 depends on B1 only
// And, the operations are resolved for A2 NOT A1
Assert.True(operationsForShowingLicense.Count == 4);
Assert.True(operationsForShowingLicense[0].Package == A2 && operationsForShowingLicense[0].Action == PackageAction.Install);
Assert.True(operationsForShowingLicense[1].Package == B2 && operationsForShowingLicense[1].Action == PackageAction.Install);
Assert.True(operationsForShowingLicense[2].Package == C1 && operationsForShowingLicense[2].Action == PackageAction.Uninstall);
Assert.True(operationsForShowingLicense[3].Package == C2 && operationsForShowingLicense[3].Action == PackageAction.Install);
Assert.True(updatePackagesByDependencyOrder.Count == 3);
Assert.True(updatePackagesByDependencyOrder[0] == C2);
Assert.True(updatePackagesByDependencyOrder[1] == A2);
Assert.True(updatePackagesByDependencyOrder[2] == B2);
Assert.True(localRepository.Exists("A", new SemanticVersion("2.0")));
Assert.False(localRepository.Exists("A", new SemanticVersion("1.0")));
Assert.True(localRepository.Exists("B", new SemanticVersion("2.0")));
Assert.False(localRepository.Exists("B", new SemanticVersion("1.0")));
Assert.True(localRepository.Exists("C", new SemanticVersion("2.0")));
Assert.False(localRepository.Exists("C", new SemanticVersion("1.0")));
Assert.True(projectRepository.Exists("A", new SemanticVersion("2.0")));
Assert.True(projectRepository.Exists("B", new SemanticVersion("2.0")));
Assert.True(projectRepository.Exists("C", new SemanticVersion("2.0")));
}
private IEnumerable<PackageOperation> ResolveOperationsToInstallSolutionLevelPackage(Operation operation)
{
var repo = _virtualPackageRepos[operation.ProjectManager.PackageManager];
var installWalker = new InstallWalker(
repo,
operation.ProjectManager.PackageManager.DependencyResolver,
targetFramework: null,
logger: Logger,
ignoreDependencies: IgnoreDependencies,
allowPrereleaseVersions: AllowPrereleaseVersions,
dependencyVersion: DependencyVersion);
var operations = installWalker.ResolveOperations(operation.Package);
// we're installing solution level packages, so all target should be
// set to PackagesFolder.
foreach (var op in operations)
{
op.Target = PackageOperationTarget.PackagesFolder;
}
return operations;
}
protected bool ShowLicenseAgreement(
IPackage package,
IVsPackageManager packageManager,
FrameworkName targetFramework,
out IList<PackageOperation> operations)
{
var walker = new InstallWalker(
LocalRepository,
packageManager.SourceRepository,
targetFramework,
this,
ignoreDependencies: false,
allowPrereleaseVersions: IncludePrerelease,
dependencyVersion: packageManager.DependencyVersion);
operations = walker.ResolveOperations(package).ToList();
return ShowLicenseAgreement(packageManager, operations);
}
public void InstallWalkerResolvesLowestMajorAndMinorHighestPatchVersionOfListedPackagesForDependencies()
{
// Arrange
// A 1.0 -> B 1.0
// B 1.0 -> C 1.1
// C 1.1 -> D 1.0
var A10 = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { PackageDependency.CreateDependency("B", "1.0") });
var repository = new MockPackageRepository() {
PackageUtility.CreatePackage("B", "2.0", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") }),
PackageUtility.CreatePackage("B", "1.0", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") }, listed: false),
PackageUtility.CreatePackage("B", "1.0.1"),
A10,
PackageUtility.CreatePackage("D", "2.0"),
PackageUtility.CreatePackage("C", "1.1.3", dependencies: new[] { PackageDependency.CreateDependency("D", "1.0") }),
PackageUtility.CreatePackage("C", "1.1.1", dependencies: new[] { PackageDependency.CreateDependency("D", "1.0") }, listed: false),
PackageUtility.CreatePackage("C", "1.5.1", dependencies: new[] { PackageDependency.CreateDependency("D", "1.0") }),
PackageUtility.CreatePackage("B", "1.0.9", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") }),
PackageUtility.CreatePackage("B", "1.1", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") })
};
IPackageOperationResolver resolver = new InstallWalker(new MockPackageRepository(),
repository,
constraintProvider: null,
logger: NullLogger.Instance,
targetFramework: null,
ignoreDependencies: false,
allowPrereleaseVersions: false)
{
DependencyVersion = DependencyVersion.HighestPatch
};
// Act
var packages = resolver.ResolveOperations(A10).ToList();
// Assert
Assert.Equal(4, packages.Count);
Assert.Equal("D", packages[0].Package.Id);
Assert.Equal(new SemanticVersion("2.0"), packages[0].Package.Version);
Assert.Equal("C", packages[1].Package.Id);
Assert.Equal(new SemanticVersion("1.1.3"), packages[1].Package.Version);
Assert.Equal("B", packages[2].Package.Id);
Assert.Equal(new SemanticVersion("1.0.9"), packages[2].Package.Version);
Assert.Equal("A", packages[3].Package.Id);
Assert.Equal(new SemanticVersion("1.0"), packages[3].Package.Version);
}
public void ResolveOperationsForPackagesWherePackagesOrderIsDifferentFromItsDependencyOrder()
{
// Arrange
// A 1.0 -> B 1.0 to 1.5
// A 2.0 -> B 1.8
// B 1.0
// B 2.0
// C 1.0
// C 2.0
var A10 = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { PackageDependency.CreateDependency("B", "[1.0, 1.5]") });
var A20 = PackageUtility.CreatePackage("A", "2.0", dependencies: new[] { PackageDependency.CreateDependency("B", "1.8") });
var B10 = PackageUtility.CreatePackage("B", "1.0");
var B20 = PackageUtility.CreatePackage("B", "2.0");
var C10 = PackageUtility.CreatePackage("C", "1.0");
var C20 = PackageUtility.CreatePackage("C", "2.0");
var sourceRepository = new MockPackageRepository() {
A10,
A20,
B10,
B20,
C10,
C20,
};
var localRepository = new MockPackageRepository() {
A10,
B10,
C10
};
var resolver = new InstallWalker(localRepository,
sourceRepository,
constraintProvider: NullConstraintProvider.Instance,
logger: NullLogger.Instance,
targetFramework: null,
ignoreDependencies: false,
allowPrereleaseVersions: false);
var updatePackages = new List<IPackage> { A20, B20, C20 };
IList<IPackage> allUpdatePackagesByDependencyOrder;
// Act
var operations = resolver.ResolveOperations(updatePackages, out allUpdatePackagesByDependencyOrder);
// Assert
Assert.True(operations.Count == 3);
Assert.True(operations[0].Package == B20 && operations[0].Action == PackageAction.Install);
Assert.True(operations[1].Package == A20 && operations[1].Action == PackageAction.Install);
Assert.True(operations[2].Package == C20 && operations[2].Action == PackageAction.Install);
Assert.True(allUpdatePackagesByDependencyOrder[0] == B20);
Assert.True(allUpdatePackagesByDependencyOrder[1] == A20);
Assert.True(allUpdatePackagesByDependencyOrder[2] == C20);
}
// Reinstall all packages in all projects
public void ReinstallPackages(
bool updateDependencies,
bool allowPrereleaseVersions,
ILogger logger,
IPackageOperationEventListener eventListener)
{
//1) Reinstall solution packages first
//2) On Each Project, call UninstallAllPackages(IProjectManager, Dictionary<Tuple<string, SemanticVersion>, bool>, out packagesInSourceRepository). And, create a dictionary <projectManager, packages>
//3) Append all packagesInSourceRepository into allPackagesInSourceRepository
//4) Call InstallWalker.ResolveOperations(allPackagesInSourceRepository, out IList<IPackage> packagesByDependencyOrder)
//5) Call for each entry in Dictionary<projectManager, packages>
// InitializeLogger, RunSolutionAction( call projectManager.AddPackageReference(IPackage, ..., ...)
// Change it to array so that the enumeration is not modified during enumeration to reinstall solution packages
var packages = LocalRepository.GetPackages().ToArray();
foreach (var package in packages)
{
if (!IsProjectLevel(package))
{
ReinstallSolutionPackage(package, updateDependencies, allowPrereleaseVersions, logger);
}
}
// Now, take care of project-level packages
var packagesInProject = new Dictionary<IProjectManager, HashSet<IPackage>>();
var verifiedPackagesInSourceRepository = new Dictionary<PackageName, IPackage>();
HashSet<IPackage> allPackagesToBeReinstalled = new HashSet<IPackage>();
// first uninstall all the packages from each project
RunActionOnProjects(
_solutionManager.GetProjects(),
project =>
{
IProjectManager projectManager = GetProjectManager(project);
HashSet<IPackage> packagesToBeReinstalled;
UninstallPackagesForReinstall(projectManager, updateDependencies, logger, verifiedPackagesInSourceRepository, out packagesToBeReinstalled);
Debug.Assert(!packagesInProject.ContainsKey(projectManager));
packagesInProject[projectManager] = packagesToBeReinstalled;
allPackagesToBeReinstalled.AddRange(packagesToBeReinstalled);
},
logger,
eventListener ?? NullPackageOperationEventListener.Instance);
// NOTE THAT allowPrereleaseVersions should be true for pre-release packages alone, even if the user did not specify it
// since we are trying to reinstall packages here. However, ResolveOperations below will take care of this problem via allowPrereleaseVersionsBasedOnPackage parameter
var installWalker = new InstallWalker(LocalRepository, SourceRepository, null, logger ?? NullLogger.Instance,
ignoreDependencies: !updateDependencies, allowPrereleaseVersions: allowPrereleaseVersions,
dependencyVersion: DependencyVersion);
IList<IPackage> packagesUninstalledInDependencyOrder;
var operations = installWalker.ResolveOperations(allPackagesToBeReinstalled, out packagesUninstalledInDependencyOrder, allowPrereleaseVersionsBasedOnPackage: true);
ExecuteOperationsWithPackage(
_solutionManager.GetProjects(),
null,
operations,
projectManager =>
{
foreach (var package in packagesUninstalledInDependencyOrder)
{
HashSet<IPackage> packagesToBeReinstalled;
if (packagesInProject.TryGetValue(projectManager, out packagesToBeReinstalled) && packagesToBeReinstalled.Contains(package))
{
AddPackageReference(projectManager, package, ignoreDependencies: !updateDependencies, allowPrereleaseVersions: allowPrereleaseVersions || !package.IsReleaseVersion());
}
}
},
logger,
eventListener);
}
public void ResolveDependenciesForInstallDiamondDependencyGraphWithDifferntVersionOfSamePackage()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
// A -> [B, C]
// B -> [D >= 1, E >= 2]
// C -> [D >= 2, E >= 1]
// A
// / \
// B C
// | \ | \
// D1 E2 D2 E1
IPackage packageA = PackageUtility.CreateProjectLevelPackage("A", "1.0",
dependencies: new List<PackageDependency> {
new PackageDependency("B"),
new PackageDependency("C")
});
IPackage packageB = PackageUtility.CreateProjectLevelPackage("B", "1.0",
dependencies: new List<PackageDependency> {
PackageDependency.CreateDependency("D", "1.0"),
PackageDependency.CreateDependency("E", "2.0")
});
IPackage packageC = PackageUtility.CreateProjectLevelPackage("C", "1.0",
dependencies: new List<PackageDependency> {
PackageDependency.CreateDependency("D", "2.0"),
PackageDependency.CreateDependency("E", "1.0")
});
IPackage packageD10 = PackageUtility.CreateProjectLevelPackage("D", "1.0");
IPackage packageD20 = PackageUtility.CreateProjectLevelPackage("D", "2.0");
IPackage packageE10 = PackageUtility.CreateProjectLevelPackage("E", "1.0");
IPackage packageE20 = PackageUtility.CreateProjectLevelPackage("E", "2.0");
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageD20);
sourceRepository.AddPackage(packageD10);
sourceRepository.AddPackage(packageE20);
sourceRepository.AddPackage(packageE10);
IPackageOperationResolver resolver = new InstallWalker(localRepository,
sourceRepository,
NullLogger.Instance,
ignoreDependencies: false,
allowPrereleaseVersions: false);
// Act
var operations = resolver.ResolveOperations(packageA).ToList();
var projectOperations = resolver.ResolveOperations(packageA).ToList();
// Assert
Assert.Equal(5, operations.Count);
Assert.Equal("E", operations[0].Package.Id);
Assert.Equal(new SemanticVersion("2.0"), operations[0].Package.Version);
Assert.Equal("B", operations[1].Package.Id);
Assert.Equal("D", operations[2].Package.Id);
Assert.Equal(new SemanticVersion("2.0"), operations[2].Package.Version);
Assert.Equal("C", operations[3].Package.Id);
Assert.Equal("A", operations[4].Package.Id);
Assert.Equal(5, projectOperations.Count);
Assert.Equal("E", projectOperations[0].Package.Id);
Assert.Equal(new SemanticVersion("2.0"), projectOperations[0].Package.Version);
Assert.Equal("B", projectOperations[1].Package.Id);
Assert.Equal("D", projectOperations[2].Package.Id);
Assert.Equal(new SemanticVersion("2.0"), projectOperations[2].Package.Version);
Assert.Equal("C", projectOperations[3].Package.Id);
Assert.Equal("A", projectOperations[4].Package.Id);
}
protected bool ShowLicenseAgreementForAllPackages(IVsPackageManager activePackageManager, out List<PackageOperation> allOperations)
{
allOperations = new List<PackageOperation>();
var installWalker = new InstallWalker(
LocalRepository,
activePackageManager.SourceRepository,
_project.GetTargetFrameworkName(),
logger: this,
ignoreDependencies: false,
allowPrereleaseVersions: IncludePrerelease);
var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease);
foreach (var package in allPackages)
{
if (allOperations.FindIndex(
operation => operation.Action == PackageAction.Install &&
operation.Package.Id == package.Id &&
operation.Package.Version == package.Version) == -1)
{
var operations = installWalker.ResolveOperations(package);
allOperations.AddRange(operations);
}
}
allOperations = (List<PackageOperation>)allOperations.Reduce();
return ShowLicenseAgreement(activePackageManager, allOperations);
}
protected bool ShowLicenseAgreementForAllPackages(IVsPackageManager activePackageManager)
{
var allOperations = new List<PackageOperation>();
var allPackages = SelectedNode.GetPackages(String.Empty, IncludePrerelease).ToList();
foreach (var package in allPackages)
{
var installWalker = new InstallWalker(
LocalRepository,
activePackageManager.SourceRepository,
_project.GetTargetFrameworkName(),
logger: this,
ignoreDependencies: false,
allowPrereleaseVersions: IncludePrerelease);
var operations = installWalker.ResolveOperations(package);
allOperations.AddRange(operations);
}
return ShowLicenseAgreement(activePackageManager, allOperations.Reduce());
}
public void InstallWalkerResolvesLowestMajorAndMinorVersionButHighestBuildAndRevisionForDependencies()
{
// Arrange
// A 1.0 -> B 1.0
// B 1.0 -> C 1.1
// C 1.1 -> D 1.0
var A10 = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { PackageDependency.CreateDependency("B", "1.0") });
var repository = new MockPackageRepository() {
PackageUtility.CreatePackage("B", "2.0", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") }),
PackageUtility.CreatePackage("B", "1.0", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") }),
PackageUtility.CreatePackage("B", "1.0.1"),
A10,
PackageUtility.CreatePackage("D", "2.0"),
PackageUtility.CreatePackage("C", "1.1.3", dependencies: new[] { PackageDependency.CreateDependency("D", "1.0") }),
PackageUtility.CreatePackage("C", "1.1.1", dependencies: new[] { PackageDependency.CreateDependency("D", "1.0") }),
PackageUtility.CreatePackage("C", "1.5.1", dependencies: new[] { PackageDependency.CreateDependency("D", "1.0") }),
PackageUtility.CreatePackage("B", "1.0.9", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") }),
PackageUtility.CreatePackage("B", "1.1", dependencies: new[] { PackageDependency.CreateDependency("C", "1.1") })
};
IPackageOperationResolver resolver = new InstallWalker(new MockPackageRepository(),
repository,
NullLogger.Instance,
ignoreDependencies: false,
allowPrereleaseVersions: false);
// Act
var packages = resolver.ResolveOperations(A10).ToList();
// Assert
Assert.Equal(4, packages.Count);
Assert.Equal("D", packages[0].Package.Id);
Assert.Equal(new SemanticVersion("2.0"), packages[0].Package.Version);
Assert.Equal("C", packages[1].Package.Id);
Assert.Equal(new SemanticVersion("1.1.3"), packages[1].Package.Version);
Assert.Equal("B", packages[2].Package.Id);
Assert.Equal(new SemanticVersion("1.0.9"), packages[2].Package.Version);
Assert.Equal("A", packages[3].Package.Id);
Assert.Equal(new SemanticVersion("1.0"), packages[3].Package.Version);
}
public void ResolveDependencyForInstallPackageWithDependencyThatDoesntMeetExactVersionThrows()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
dependencies: new List<PackageDependency> {
PackageDependency.CreateDependency("B", "[1.5]")
});
sourceRepository.AddPackage(packageA);
IPackage packageB = PackageUtility.CreatePackage("B", "1.4");
sourceRepository.AddPackage(packageB);
IPackageOperationResolver resolver = new InstallWalker(localRepository,
sourceRepository,
NullLogger.Instance,
ignoreDependencies: false,
allowPrereleaseVersions: false);
// Act & Assert
ExceptionAssert.Throws<InvalidOperationException>(() => resolver.ResolveOperations(packageA), "Unable to resolve dependency 'B (= 1.5)'.");
}
public void ResolveDependenciesForInstallPackageResolvesDependencyWithConstraintsUsingDependencyResolver()
{
// Arrange
var packageDependency = new PackageDependency("B", new VersionSpec { MinVersion = new SemanticVersion("1.1") });
IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
dependencies: new List<PackageDependency> { packageDependency });
IPackage packageB10 = PackageUtility.CreatePackage("B", "1.0");
IPackage packageB12 = PackageUtility.CreatePackage("B", "1.2");
var repository = new Mock<PackageRepositoryBase>(MockBehavior.Strict);
repository.Setup(c => c.GetPackages()).Returns(new[] { packageA }.AsQueryable());
var dependencyProvider = repository.As<IDependencyResolver>();
dependencyProvider.Setup(c => c.ResolveDependency(packageDependency, It.IsAny<IPackageConstraintProvider>(), false, true))
.Returns(packageB12).Verifiable();
var localRepository = new MockPackageRepository();
IPackageOperationResolver resolver = new InstallWalker(localRepository,
repository.Object,
NullLogger.Instance,
ignoreDependencies: false,
allowPrereleaseVersions: false);
// Act
var operations = resolver.ResolveOperations(packageA).ToList();
// Assert
Assert.Equal(2, operations.Count);
Assert.Equal(PackageAction.Install, operations.First().Action);
Assert.Equal(packageB12, operations.First().Package);
Assert.Equal(PackageAction.Install, operations.Last().Action);
Assert.Equal(packageA, operations.Last().Package);
dependencyProvider.Verify();
}
public void ResolveDependenciesForInstallCircularReferenceThrows()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
dependencies: new List<PackageDependency> {
new PackageDependency("B")
});
IPackage packageB = PackageUtility.CreatePackage("B", "1.0",
dependencies: new List<PackageDependency> {
new PackageDependency("A")
});
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageB);
IPackageOperationResolver resolver = new InstallWalker(
localRepository,
new DependencyResolverFromRepo(sourceRepository),
NullLogger.Instance,
ignoreDependencies: false,
allowPrereleaseVersions: false,
dependencyVersion: DependencyVersion.Lowest);
// Act & Assert
ExceptionAssert.Throws<InvalidOperationException>(() => resolver.ResolveOperations(packageA), "Circular dependency detected 'A 1.0 => B 1.0 => A 1.0'.");
}
public void ResolveDependenciesForInstallDiamondDependencyGraphWithDifferntVersionOfSamePackage()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
// A -> [B, C]
// B -> [D >= 1, E >= 2]
// C -> [D >= 2, E >= 1]
// A
// / \
// B C
// | \ | \
// D1 E2 D2 E1
IPackage packageA = PackageUtility.CreateProjectLevelPackage("A", "1.0",
dependencies: new List <PackageDependency> {
new PackageDependency("B"),
new PackageDependency("C")
});
IPackage packageB = PackageUtility.CreateProjectLevelPackage("B", "1.0",
dependencies: new List <PackageDependency> {
PackageDependency.CreateDependency("D", "1.0"),
PackageDependency.CreateDependency("E", "2.0")
});
IPackage packageC = PackageUtility.CreateProjectLevelPackage("C", "1.0",
dependencies: new List <PackageDependency> {
PackageDependency.CreateDependency("D", "2.0"),
PackageDependency.CreateDependency("E", "1.0")
});
IPackage packageD10 = PackageUtility.CreateProjectLevelPackage("D", "1.0");
IPackage packageD20 = PackageUtility.CreateProjectLevelPackage("D", "2.0");
IPackage packageE10 = PackageUtility.CreateProjectLevelPackage("E", "1.0");
IPackage packageE20 = PackageUtility.CreateProjectLevelPackage("E", "2.0");
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageD20);
sourceRepository.AddPackage(packageD10);
sourceRepository.AddPackage(packageE20);
sourceRepository.AddPackage(packageE10);
IPackageOperationResolver projectResolver = new ProjectInstallWalker(localRepository,
sourceRepository,
new DependentsWalker(localRepository),
NullLogger.Instance,
ignoreDependencies: false);
IPackageOperationResolver resolver = new InstallWalker(localRepository,
sourceRepository,
NullLogger.Instance,
ignoreDependencies: false);
// Act
var operations = resolver.ResolveOperations(packageA).ToList();
var projectOperations = resolver.ResolveOperations(packageA).ToList();
// Assert
Assert.AreEqual(5, operations.Count);
Assert.AreEqual("E", operations[0].Package.Id);
Assert.AreEqual(new Version("2.0"), operations[0].Package.Version);
Assert.AreEqual("B", operations[1].Package.Id);
Assert.AreEqual("D", operations[2].Package.Id);
Assert.AreEqual(new Version("2.0"), operations[2].Package.Version);
Assert.AreEqual("C", operations[3].Package.Id);
Assert.AreEqual("A", operations[4].Package.Id);
Assert.AreEqual(5, projectOperations.Count);
Assert.AreEqual("E", projectOperations[0].Package.Id);
Assert.AreEqual(new Version("2.0"), projectOperations[0].Package.Version);
Assert.AreEqual("B", projectOperations[1].Package.Id);
Assert.AreEqual("D", projectOperations[2].Package.Id);
Assert.AreEqual(new Version("2.0"), projectOperations[2].Package.Version);
Assert.AreEqual("C", projectOperations[3].Package.Id);
Assert.AreEqual("A", projectOperations[4].Package.Id);
}
