private IEnumerable <PackageOperation> ResolveOperationsToUpdateSolutionLevelPackage(Operation operation)
{
var repo = _virtualPackageRepos[operation.ProjectManager.PackageManager];
var updateWalker = new UpdateWalker(
repo,
operation.ProjectManager.PackageManager.DependencyResolver,
new DependentsWalker(repo, targetFramework: null)
{
DependencyVersion = DependencyVersion
},
constraintProvider: NullConstraintProvider.Instance,
targetFramework: null,
logger: Logger ?? NullLogger.Instance,
updateDependencies: !IgnoreDependencies,
allowPrereleaseVersions: AllowPrereleaseVersions)
{
AcceptedTargets = PackageTargets.All,
DependencyVersion = DependencyVersion
};
var operations = updateWalker.ResolveOperations(operation.Package);
// we're updating solution level packages, so all target should be
// set to PackagesFolder.
foreach (var op in operations)
{
op.Target = PackageOperationTarget.PackagesFolder;
}
return(operations);
}
private IEnumerable <PackageOperation> ResolveOperationsToInstallProjectLevelPackage(Operation operation)
{
var projectRepo = _virtualProjectRepos[operation.ProjectManager];
var dependentsWalker = new DependentsWalker(
operation.ProjectManager.PackageManager.LocalRepository,
operation.ProjectManager.GetTargetFrameworkForPackage(operation.Package.Id))
{
DependencyVersion = DependencyVersion
};
var updateWalker = new UpdateWalker(
projectRepo,
operation.ProjectManager.PackageManager.DependencyResolver,
dependentsWalker,
operation.ProjectManager.ConstraintProvider,
operation.ProjectManager.Project.TargetFramework,
Logger ?? NullLogger.Instance,
!IgnoreDependencies,
AllowPrereleaseVersions)
{
AcceptedTargets = PackageTargets.All,
DependencyVersion = DependencyVersion
};
var operations = updateWalker.ResolveOperations(operation.Package);
return(operations);
}
private IEnumerable <PackageOperation> ResolveOperationsToInstallProjectLevelPackage(Operation operation)
{
DependentsWalker walker1 = new DependentsWalker(operation.ProjectManager.PackageManager.LocalRepository, operation.ProjectManager.GetTargetFrameworkForPackage(operation.Package.Id));
walker1.DependencyVersion = this.DependencyVersion;
DependentsWalker dependentsResolver = walker1;
UpdateWalker walker2 = new UpdateWalker(this._virtualProjectRepos[operation.ProjectManager], operation.ProjectManager.PackageManager.DependencyResolver, dependentsResolver, operation.ProjectManager.ConstraintProvider, operation.ProjectManager.Project.TargetFramework, this.Logger ?? NullLogger.Instance, !this.IgnoreDependencies, this.AllowPrereleaseVersions);
walker2.AcceptedTargets = PackageTargets.All;
walker2.DependencyVersion = this.DependencyVersion;
return(walker2.ResolveOperations(operation.Package));
}
protected void InstallPackage(
IPackage package,
FrameworkName targetFramework,
bool ignoreDependencies,
bool allowPrereleaseVersions)
{
var installerWalker = new UpdateWalker(
LocalRepository,
SourceRepository,
new DependentsWalker(LocalRepository, targetFramework),
NullConstraintProvider.Instance,
targetFramework,
Logger,
!ignoreDependencies,
allowPrereleaseVersions);
Execute(package, installerWalker);
}
private IEnumerable <PackageOperation> ResolveOperationsToUpdateSolutionLevelPackage(Operation operation)
{
VirtualRepository repository = this._virtualPackageRepos[operation.ProjectManager.PackageManager];
DependentsWalker dependentsResolver = new DependentsWalker(repository, null);
dependentsResolver.DependencyVersion = this.DependencyVersion;
UpdateWalker walker2 = new UpdateWalker(repository, operation.ProjectManager.PackageManager.DependencyResolver, dependentsResolver, NullConstraintProvider.Instance, null, this.Logger ?? NullLogger.Instance, !this.IgnoreDependencies, this.AllowPrereleaseVersions);
walker2.AcceptedTargets = PackageTargets.All;
walker2.DependencyVersion = this.DependencyVersion;
IEnumerable <PackageOperation> enumerable = walker2.ResolveOperations(operation.Package);
using (IEnumerator <PackageOperation> enumerator = enumerable.GetEnumerator())
{
while (enumerator.MoveNext())
{
enumerator.Current.Target = PackageOperationTarget.PackagesFolder;
}
}
return(enumerable);
}
public void ProjectInstallWalkerIgnoresSolutionLevelPackages()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
IPackage projectPackage = PackageUtility.CreatePackage("A", "1.0",
dependencies: new List<PackageDependency> {
PackageDependency.CreateDependency("B", "[1.5]")
}, content: new[] { "content" });
sourceRepository.AddPackage(projectPackage);
IPackage toolsPackage = PackageUtility.CreatePackage("B", "1.5", tools: new[] { "init.ps1" });
sourceRepository.AddPackage(toolsPackage);
IPackageOperationResolver resolver = new UpdateWalker(localRepository,
sourceRepository,
new DependentsWalker(localRepository),
NullConstraintProvider.Instance,
NullLogger.Instance,
updateDependencies: true,
allowPrereleaseVersions: false) { AcceptedTargets = PackageTargets.Project };
// Act
var packages = resolver.ResolveOperations(projectPackage)
.ToDictionary(p => p.Package.Id);
// Assert
Assert.Equal(1, packages.Count);
Assert.NotNull(packages["A"]);
}
public void ResolveDependenciesForInstallSameDependencyAtDifferentLevelsInGraphDuringUpdate()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
// A1 -> B1, C1
IPackage packageA = PackageUtility.CreatePackage("A", "1.0",
content: new[] { "A1" },
dependencies: new List<PackageDependency> {
PackageDependency.CreateDependency("B", "1.0"),
PackageDependency.CreateDependency("C", "1.0")
});
// B1
IPackage packageB = PackageUtility.CreatePackage("B", "1.0", new[] { "B1" });
// C1 -> B1, D1
IPackage packageC = PackageUtility.CreatePackage("C", "1.0",
content: new[] { "C1" },
dependencies: new List<PackageDependency> {
PackageDependency.CreateDependency("B", "1.0"),
PackageDependency.CreateDependency("D", "1.0")
});
// D1 -> B1
IPackage packageD = PackageUtility.CreatePackage("D", "1.0",
content: new[] { "A1" },
dependencies: new List<PackageDependency> {
PackageDependency.CreateDependency("B", "1.0")
});
// A2 -> B2, C2
IPackage packageA2 = PackageUtility.CreatePackage("A", "2.0",
content: new[] { "A2" },
dependencies: new List<PackageDependency> {
PackageDependency.CreateDependency("B", "2.0"),
PackageDependency.CreateDependency("C", "2.0")
});
// B2
IPackage packageB2 = PackageUtility.CreatePackage("B", "2.0", new[] { "B2" });
// C2 -> B2, D2
IPackage packageC2 = PackageUtility.CreatePackage("C", "2.0",
content: new[] { "C2" },
dependencies: new List<PackageDependency> {
PackageDependency.CreateDependency("B", "2.0"),
PackageDependency.CreateDependency("D", "2.0")
});
// D2 -> B2
IPackage packageD2 = PackageUtility.CreatePackage("D", "2.0",
content: new[] { "D2" },
dependencies: new List<PackageDependency> {
PackageDependency.CreateDependency("B", "2.0")
});
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageD);
sourceRepository.AddPackage(packageA2);
sourceRepository.AddPackage(packageB2);
sourceRepository.AddPackage(packageC2);
sourceRepository.AddPackage(packageD2);
localRepository.AddPackage(packageA);
localRepository.AddPackage(packageB);
localRepository.AddPackage(packageC);
localRepository.AddPackage(packageD);
IPackageOperationResolver resolver = new UpdateWalker(localRepository,
sourceRepository,
new DependentsWalker(localRepository),
NullConstraintProvider.Instance,
NullLogger.Instance,
updateDependencies: true,
allowPrereleaseVersions: false);
var operations = resolver.ResolveOperations(packageA2).ToList();
Assert.Equal(8, operations.Count);
AssertOperation("A", "1.0", PackageAction.Uninstall, operations[0]);
AssertOperation("C", "1.0", PackageAction.Uninstall, operations[1]);
AssertOperation("D", "1.0", PackageAction.Uninstall, operations[2]);
AssertOperation("B", "1.0", PackageAction.Uninstall, operations[3]);
AssertOperation("B", "2.0", PackageAction.Install, operations[4]);
AssertOperation("D", "2.0", PackageAction.Install, operations[5]);
AssertOperation("C", "2.0", PackageAction.Install, operations[6]);
AssertOperation("A", "2.0", PackageAction.Install, operations[7]);
}
public void ResolvingDependencyForUpdateWithConflictingDependents()
{
// Arrange
var localRepository = new MockPackageRepository();
var sourceRepository = new MockPackageRepository();
// A 1.0 -> B [1.0]
IPackage A10 = PackageUtility.CreatePackage("A", "1.0",
dependencies: new List<PackageDependency> {
PackageDependency.CreateDependency("B", "[1.0]")
}, content: new[] { "a1" });
// A 2.0 -> B (any version)
IPackage A20 = PackageUtility.CreatePackage("A", "2.0",
dependencies: new List<PackageDependency> {
new PackageDependency("B")
}, content: new[] { "a2" });
IPackage B10 = PackageUtility.CreatePackage("B", "1.0", content: new[] { "b1" });
IPackage B101 = PackageUtility.CreatePackage("B", "1.0.1", content: new[] { "b101" });
IPackage B20 = PackageUtility.CreatePackage("B", "2.0", content: new[] { "a2" });
localRepository.Add(A10);
localRepository.Add(B10);
sourceRepository.AddPackage(A10);
sourceRepository.AddPackage(A20);
sourceRepository.AddPackage(B10);
sourceRepository.AddPackage(B101);
sourceRepository.AddPackage(B20);
IPackageOperationResolver resolver = new UpdateWalker(localRepository,
sourceRepository,
new DependentsWalker(localRepository),
NullConstraintProvider.Instance,
NullLogger.Instance,
updateDependencies: true,
allowPrereleaseVersions: false) { AcceptedTargets = PackageTargets.Project };
// Act
var packages = resolver.ResolveOperations(B101).ToList();
// Assert
Assert.Equal(4, packages.Count);
AssertOperation("A", "1.0", PackageAction.Uninstall, packages[0]);
AssertOperation("B", "1.0", PackageAction.Uninstall, packages[1]);
AssertOperation("A", "2.0", PackageAction.Install, packages[2]);
AssertOperation("B", "1.0.1", PackageAction.Install, packages[3]);
}
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 UpdateWalker(localRepository,
sourceRepository,
new DependentsWalker(localRepository),
NullConstraintProvider.Instance,
NullLogger.Instance,
updateDependencies: true,
allowPrereleaseVersions: false);
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);
}
private IEnumerable<PackageOperation> ResolveOperationsToUpdateSolutionLevelPackage(Operation operation)
{
var repo = _virtualPackageRepos[operation.ProjectManager.PackageManager];
var updateWalker = new UpdateWalker(
repo,
operation.ProjectManager.PackageManager.DependencyResolver,
new DependentsWalker(repo, targetFramework: null)
{
DependencyVersion = DependencyVersion
},
constraintProvider: NullConstraintProvider.Instance,
targetFramework: null,
logger: Logger ?? NullLogger.Instance,
updateDependencies: !IgnoreDependencies,
allowPrereleaseVersions: AllowPrereleaseVersions)
{
AcceptedTargets = PackageTargets.All,
DependencyVersion = DependencyVersion
};
var operations = updateWalker.ResolveOperations(operation.Package);
// we're updating solution level packages, so all target should be
// set to PackagesFolder.
foreach (var op in operations)
{
op.Target = PackageOperationTarget.PackagesFolder;
}
return operations;
}
private IEnumerable<PackageOperation> ResolveOperationsToInstallProjectLevelPackage(Operation operation)
{
var projectRepo = _virtualProjectRepos[operation.ProjectManager];
var dependentsWalker = new DependentsWalker(
operation.ProjectManager.PackageManager.LocalRepository,
operation.ProjectManager.GetTargetFrameworkForPackage(operation.Package.Id))
{
DependencyVersion = DependencyVersion
};
var updateWalker = new UpdateWalker(
projectRepo,
operation.ProjectManager.PackageManager.DependencyResolver,
dependentsWalker,
operation.ProjectManager.ConstraintProvider,
operation.ProjectManager.Project.TargetFramework,
Logger ?? NullLogger.Instance,
!IgnoreDependencies,
AllowPrereleaseVersions)
{
AcceptedTargets = PackageTargets.All,
DependencyVersion = DependencyVersion
};
var operations = updateWalker.ResolveOperations(operation.Package);
return operations;
}
