public void InstallPackageWithOperationsExecuteAllOperations()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object;
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository());
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, projectSystem, localRepository, new Mock<IRecentPackageRepository>().Object);
var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }, dependencies: new PackageDependency[] { new PackageDependency("bar") });
sourceRepository.AddPackage(package);
var package2 = PackageUtility.CreatePackage("bar", "2.0", new[] { "world" });
sourceRepository.AddPackage(package2);
var package3 = PackageUtility.CreatePackage("awesome", "1.0", new[] { "candy" });
localRepository.AddPackage(package3);
var operations = new PackageOperation[] {
new PackageOperation(package, PackageAction.Install),
new PackageOperation(package2, PackageAction.Install),
new PackageOperation(package3, PackageAction.Uninstall)
};
// Act
packageManager.InstallPackage(projectManager, package, operations, ignoreDependencies: false, logger: NullLogger.Instance);
// Assert
Assert.IsTrue(packageManager.LocalRepository.Exists(package));
Assert.IsTrue(packageManager.LocalRepository.Exists(package2));
Assert.IsTrue(!packageManager.LocalRepository.Exists(package3));
Assert.IsTrue(projectManager.LocalRepository.Exists(package));
Assert.IsTrue(projectManager.LocalRepository.Exists(package2));
}
public VsProjectManager(
VsPackageManager packageManager,
IPackagePathResolver pathResolver,
IProjectSystem project,
IPackageRepository localRepository)
: base(packageManager, pathResolver, project, localRepository)
{
_packageManager = packageManager;
}
public VsProjectManager(
VsPackageManager packageManager,
IPackagePathResolver pathResolver,
IProjectSystem project,
IPackageRepository localRepository)
: base(packageManager, pathResolver, project, localRepository)
{
_packageManager = packageManager;
}
public IVsPackageManager CreatePackageManager(IPackageRepository repository, bool useFallbackForDependencies)
{
RepositoryInfo info = GetRepositoryInfo();
var packageManager = new VsPackageManager(_solutionManager,
repository,
_fileSystemProvider,
info.FileSystem,
info.Repository,
// We ensure DeleteOnRestartManager is initialized with a PhysicalFileSystem so the
// .deleteme marker files that get created don't get checked into version control
new DeleteOnRestartManager(() => new PhysicalFileSystem(info.FileSystem.Root)),
_packageEvents,
_frameworkMultiTargeting);
packageManager.DependencyVersion = GetDependencyVersion();
return(packageManager);
}
public void InstallPackgeWithNullProjectManagerOnlyInstallsIntoPackageManager()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object;
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, projectSystem, localRepository, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object);
var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" });
sourceRepository.AddPackage(package);
// Act
packageManager.InstallPackage((IProjectManager)null, "foo", new SemanticVersion("1.0"), ignoreDependencies: false, allowPrereleaseVersions: false, logger: NullLogger.Instance);
// Assert
Assert.True(packageManager.LocalRepository.Exists(package));
}
public void UpdatePackageWithMultipleSharedDependencies()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>();
var projectRepository = new MockProjectPackageRepository(localRepository.Object);
var sourceRepository = new MockPackageRepository();
var fileSystem = new MockFileSystem();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(fileSystem);
// A1 -> B1, C1
// A2 -> B1
var A10 = PackageUtility.CreatePackage("A", "1.0", assemblyReferences: new[] { "A1.dll" }, dependencies: new[] {
new PackageDependency("B", VersionUtility.ParseVersionSpec("1.0")),
new PackageDependency("C", VersionUtility.ParseVersionSpec("1.0")),
});
var A20 = PackageUtility.CreatePackage("A", "2.0", assemblyReferences: new[] { "A2.dll" }, dependencies: new[] {
new PackageDependency("B", VersionUtility.ParseVersionSpec("1.0"))
});
var B10 = PackageUtility.CreatePackage("B", "1.0", assemblyReferences: new[] { "B1.dll" });
var C10 = PackageUtility.CreatePackage("C", "1.0", assemblyReferences: new[] { "C1.dll" });
sourceRepository.AddPackage(A10);
sourceRepository.AddPackage(A20);
sourceRepository.AddPackage(B10);
sourceRepository.AddPackage(C10);
localRepository.Object.AddPackage(A10);
localRepository.Object.AddPackage(A20);
localRepository.Object.AddPackage(B10);
localRepository.Object.AddPackage(C10);
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, fileSystem, localRepository.Object, new Mock<IRecentPackageRepository>().Object);
var projectManager = new ProjectManager(localRepository.Object, pathResolver, projectSystem, projectRepository);
projectManager.AddPackageReference("A", new Version("1.0"));
// Act
packageManager.UpdatePackage(projectManager, "A", version: null, updateDependencies: true, logger: NullLogger.Instance);
// Assert
Assert.IsFalse(packageManager.LocalRepository.Exists(A10));
Assert.IsFalse(projectSystem.ReferenceExists("A1.dll"));
Assert.IsFalse(packageManager.LocalRepository.Exists(C10));
Assert.IsFalse(projectSystem.ReferenceExists("C1.dll"));
Assert.IsTrue(packageManager.LocalRepository.Exists(B10));
Assert.IsTrue(projectSystem.ReferenceExists("B1.dll"));
Assert.IsTrue(packageManager.LocalRepository.Exists(A20));
Assert.IsTrue(projectSystem.ReferenceExists("A2.dll"));
}
public void UpdatePackageRemovesPackageIfPackageIsNotReferenced()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>();
localRepository.Setup(m => m.IsReferenced("A", new Version("1.0"))).Returns(false);
var projectRepository = new MockProjectPackageRepository(localRepository.Object);
var sourceRepository = new MockPackageRepository();
var fileSystem = new MockFileSystem();
var pathResolver = new DefaultPackagePathResolver(fileSystem);
var A10 = PackageUtility.CreatePackage("A", "1.0", new[] { "hello" });
var A20 = PackageUtility.CreatePackage("A", "2.0", new[] { "hello" });
sourceRepository.AddPackage(A10);
sourceRepository.AddPackage(A20);
localRepository.Object.AddPackage(A10);
localRepository.Object.AddPackage(A20);
projectRepository.Add(A10);
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, fileSystem, localRepository.Object, new Mock<IRecentPackageRepository>().Object);
var projectManager = new ProjectManager(localRepository.Object, pathResolver, new MockProjectSystem(), projectRepository);
// Act
packageManager.UpdatePackage(projectManager, "A", version: null, updateDependencies: true, logger: NullLogger.Instance);
// Assert
Assert.IsFalse(packageManager.LocalRepository.Exists(A10));
}
public void UninstallProjectLevelPackageWithNoProjectManagerThrows()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>();
localRepository.Setup(m => m.IsReferenced("foo", It.IsAny<Version>())).Returns(true);
var sourceRepository = new MockPackageRepository();
var fileSystem = new MockFileSystem();
var pathResolver = new DefaultPackagePathResolver(fileSystem);
var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" });
localRepository.Object.AddPackage(package);
sourceRepository.AddPackage(package);
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, fileSystem, localRepository.Object, new Mock<IRecentPackageRepository>().Object);
// Act
ExceptionAssert.Throws<InvalidOperationException>(() => packageManager.UninstallPackage(null, "foo", version: null, forceRemove: false, removeDependencies: false, logger: NullLogger.Instance), "No project was specified.");
}
public void UninstallPackageRemovesPackageIfPackageIsNotReferenced()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>();
localRepository.Setup(m => m.IsReferenced("foo", It.IsAny<Version>())).Returns(false);
var sourceRepository = new MockPackageRepository();
var fileSystem = new MockFileSystem();
var pathResolver = new DefaultPackagePathResolver(fileSystem);
var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" });
localRepository.Object.AddPackage(package);
sourceRepository.AddPackage(package);
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, fileSystem, localRepository.Object, new Mock<IRecentPackageRepository>().Object);
// Act
packageManager.UninstallPackage(null, "foo", version: null, forceRemove: false, removeDependencies: false, logger: NullLogger.Instance);
// Assert
Assert.IsFalse(packageManager.LocalRepository.Exists(package));
}
public void InstallPackageInstallUnlistedPrereleasePackageIfVersionIsSet()
{
// Arrange
var packageA1 = PackageUtility.CreatePackage("A", "1.0.0");
var packageA2 = PackageUtility.CreatePackage("A", "1.0.0-ReleaseCandidate", listed: false);
var sharedRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict);
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA2));
sharedRepository.Setup(s => s.IsReferenced("A", new SemanticVersion("1.0.0-ReleaseCandidate"))).Returns(true);
var packageRepository = new MockPackageRepository { packageA1, packageA2 };
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents());
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object);
cmdlet.Id = "A";
cmdlet.Version = new SemanticVersion("1.0.0-ReleaseCandidate");
cmdlet.IncludePrerelease = true;
cmdlet.Execute();
// Assert
sharedRepository.Verify(s => s.AddPackage(packageA1), Times.Never());
sharedRepository.Verify(s => s.AddPackage(packageA2), Times.Once());
}
public void InstallPackageInstallsIndirectPrereleaseDependency()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object;
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, projectSystem, localRepository, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object);
var package = PackageUtility.CreatePackage("foo", "1.0.0", dependencies: new[] { new PackageDependency("bar") });
sourceRepository.AddPackage(package);
var versionSpec = VersionUtility.ParseVersionSpec("[0.6, 1.0)");
var package2 = PackageUtility.CreatePackage("bar", "2.0.0", dependencies: new[] { new PackageDependency("qux", versionSpec) });
sourceRepository.AddPackage(package2);
var package3A = PackageUtility.CreatePackage("qux", "1.0-alpha");
var package3B = PackageUtility.CreatePackage("qux", "1.0-beta");
var package3 = PackageUtility.CreatePackage("qux", "1.0");
localRepository.AddPackage(package3);
localRepository.AddPackage(package3A);
localRepository.AddPackage(package3B);
// Act
packageManager.InstallPackage(package, ignoreDependencies: false, allowPrereleaseVersions: true);
// Assert
Assert.True(packageManager.LocalRepository.Exists(package));
Assert.True(packageManager.LocalRepository.Exists(package2));
Assert.True(packageManager.LocalRepository.Exists(package3B));
}
public void UpdatePackageUpdateToUnlistedPackageIfVersionIsSet(string versionA1, string versionA2)
{
// Arrange
var packageA1 = PackageUtility.CreatePackage("A", versionA1, dependencies: new[] { new PackageDependency("B") });
var packageA2 = PackageUtility.CreatePackage("A", versionA2, listed: false);
var sharedRepository = new Mock<ISharedPackageRepository>();
sharedRepository.Setup(s => s.GetPackages()).Returns(new[] { packageA1 }.AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA2)).Verifiable();
var packageRepository = new MockPackageRepository { packageA1, packageA2 };
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents());
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new UpdatePackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object);
cmdlet.Id = "A";
cmdlet.Version = new SemanticVersion(versionA2);
cmdlet.Execute();
// Assert
sharedRepository.Verify();
}
public void InstallPackageCmdletDoesNotInstallPrereleasePackageIfFlagIsNotPresent()
{
// Arrange
var packageA1 = PackageUtility.CreatePackage("A", "1.0.0-a");
var sharedRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict);
sharedRepository.SetupSet(s => s.PackageSaveMode = PackageSaveModes.Nupkg);
var packageRepository = new MockPackageRepository { packageA1 };
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, null);
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, null, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true);
cmdlet.Id = "A";
// Assert
ExceptionAssert.Throws<NotImplementedException>(() => cmdlet.Execute(), "WriteWarning");
sharedRepository.Verify(s => s.AddPackage(packageA1), Times.Never());
}
public void InstallPackageCmdletInstallPrereleasePackageIfFlagIsPresent()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0.0-a");
var sharedRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict);
sharedRepository.SetupSet(s => s.PackageSaveMode = PackageSaveModes.Nupkg);
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable();
sharedRepository.Setup(s => s.IsReferenced("A", new SemanticVersion("1.0.0-a"))).Returns(true);
var packageRepository = new MockPackageRepository { packageA };
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents());
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(
TestUtils.GetSolutionManager(),
packageManagerFactory.Object,
null,
new Mock<IVsPackageSourceProvider>().Object,
new Mock<IHttpClientEvents>().Object,
null,
new Mock<IVsCommonOperations>().Object,
new Mock<IDeleteOnRestartManager>().Object,
true);
cmdlet.Id = "A";
cmdlet.IncludePrerelease = true;
cmdlet.Execute();
// Assert
sharedRepository.Verify();
}
public void InstallPackageShouldPickListedPackagesOverUnlistedOnesAsDependency()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B", new VersionSpec { MinVersion = new SemanticVersion("0.5")})});
var packageB1 = PackageUtility.CreatePackage("B", "1.0.0", listed: true);
var packageB2 = PackageUtility.CreatePackage("B", "1.0.2", listed: false);
var sharedRepository = new Mock<ISharedPackageRepository>();
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable();
sharedRepository.Setup(s => s.AddPackage(packageB1)).Verifiable();
var packageRepository = new MockPackageRepository { packageA, packageB1, packageB2 };
var recentPackageRepository = new Mock<IRecentPackageRepository>();
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, recentPackageRepository.Object, new VsPackageInstallerEvents());
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object);
cmdlet.Id = "A";
cmdlet.Execute();
// Assert
sharedRepository.Verify();
sharedRepository.Verify(s => s.AddPackage(packageB2), Times.Never());
}
public void InstallPackageWithoutSettingVersionDoNotInstallUnlistedPackage()
{
// Arrange
var packageA1 = PackageUtility.CreatePackage("A", "1.0.0");
var packageA2 = PackageUtility.CreatePackage("A", "2.0.0", listed: false);
var sharedRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict);
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA1));
var packageRepository = new MockPackageRepository { packageA1, packageA2 };
var recentPackageRepository = new Mock<IRecentPackageRepository>();
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new MockFileSystem(), sharedRepository.Object, recentPackageRepository.Object, new VsPackageInstallerEvents());
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object);
cmdlet.Id = "A";
cmdlet.Execute();
// Assert
sharedRepository.Verify(s => s.AddPackage(packageA1), Times.Once());
sharedRepository.Verify(s => s.AddPackage(packageA2), Times.Never());
}
public void UninstallProjectLevelPackageThrowsIfPackageIsReferenced()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>();
localRepository.Setup(m => m.IsReferenced("foo", It.IsAny<SemanticVersion>())).Returns(true);
var sourceRepository = new MockPackageRepository();
var fileSystem = new MockFileSystem();
var pathResolver = new DefaultPackagePathResolver(fileSystem);
var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" });
localRepository.Object.AddPackage(package);
sourceRepository.AddPackage(package);
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, fileSystem, localRepository.Object, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object);
var projectManager = new ProjectManager(localRepository.Object, pathResolver, new MockProjectSystem(), new MockPackageRepository());
// Act
ExceptionAssert.Throws<InvalidOperationException>(() => packageManager.UninstallPackage(projectManager, "foo", version: null, forceRemove: false, removeDependencies: false, logger: NullLogger.Instance), @"Unable to find package 'foo' in 'C:\MockFileSystem\'.");
}
public void UpdatePackageWithSharedDependency()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>();
var projectRepository = new MockProjectPackageRepository(localRepository.Object);
var sourceRepository = new MockPackageRepository();
var fileSystem = new MockFileSystem();
var pathResolver = new DefaultPackagePathResolver(fileSystem);
// A1 -> B1
// A2 -> B2
// F1 -> G1
// G1 -> B1
var A10 = PackageUtility.CreatePackage("A", "1.0", new[] { "hello" }, dependencies: new[] { new PackageDependency("B", VersionUtility.ParseVersionSpec("1.0")) });
var A20 = PackageUtility.CreatePackage("A", "2.0", new[] { "hello" }, dependencies: new[] { new PackageDependency("B", VersionUtility.ParseVersionSpec("2.0")) });
var B10 = PackageUtility.CreatePackage("B", "1.0", new[] { "hello" });
var B20 = PackageUtility.CreatePackage("B", "2.0", new[] { "hello" });
var F10 = PackageUtility.CreatePackage("F", "1.0", new[] { "hello" }, dependencies: new[] { new PackageDependency("G", VersionUtility.ParseVersionSpec("1.0")) });
var G10 = PackageUtility.CreatePackage("G", "1.0", new[] { "hello" }, dependencies: new[] { new PackageDependency("B", VersionUtility.ParseVersionSpec("1.0")) });
sourceRepository.AddPackage(A10);
sourceRepository.AddPackage(A20);
sourceRepository.AddPackage(B10);
sourceRepository.AddPackage(B20);
sourceRepository.AddPackage(F10);
sourceRepository.AddPackage(G10);
localRepository.Object.AddPackage(A10);
localRepository.Object.AddPackage(A20);
localRepository.Object.AddPackage(B10);
localRepository.Object.AddPackage(B20);
localRepository.Object.AddPackage(F10);
localRepository.Object.AddPackage(G10);
projectRepository.Add(A10);
projectRepository.Add(B10);
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, fileSystem, localRepository.Object, new Mock<IRecentPackageRepository>().Object);
var projectManager = new ProjectManager(localRepository.Object, pathResolver, new MockProjectSystem(), projectRepository);
// Act
packageManager.UpdatePackage(projectManager, "A", version: null, updateDependencies: true, logger: NullLogger.Instance);
// Assert
Assert.IsFalse(packageManager.LocalRepository.Exists(A10));
Assert.IsFalse(packageManager.LocalRepository.Exists(B10));
Assert.IsTrue(packageManager.LocalRepository.Exists(A20));
Assert.IsTrue(packageManager.LocalRepository.Exists(B20));
Assert.IsTrue(packageManager.LocalRepository.Exists(F10));
Assert.IsTrue(packageManager.LocalRepository.Exists(G10));
}
public void InstallPackageShouldPickUnListedPrereleasePackagesIfItSatisfiesContrainsAndOthersAreNot()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B", new VersionSpec { MinVersion = new SemanticVersion("1.0"), IsMinInclusive = true }) });
var packageB1 = PackageUtility.CreatePackage("B", "0.0.9", listed: true);
var packageB2 = PackageUtility.CreatePackage("B", "1.0.1-a", listed: false);
var sharedRepository = new Mock<ISharedPackageRepository>();
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable();
sharedRepository.Setup(s => s.AddPackage(packageB2)).Verifiable();
var packageRepository = new MockPackageRepository { packageA, packageB1, packageB2 };
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents());
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object);
cmdlet.Id = "A";
cmdlet.IncludePrerelease = true;
cmdlet.Execute();
// Assert
sharedRepository.Verify();
sharedRepository.Verify(s => s.AddPackage(packageB1), Times.Never());
}
public void InstallPackageDoesNotInstallPackageWithIndirectDependencyThatIsPrerelease()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object;
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, projectSystem, localRepository, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object);
var package = PackageUtility.CreatePackage("foo", "1.0.0", dependencies: new[] { new PackageDependency("bar") });
sourceRepository.AddPackage(package);
var versionSpec = VersionUtility.ParseVersionSpec("[0.6, 1.0)");
var package2 = PackageUtility.CreatePackage("bar", "2.0.0", dependencies: new[] { new PackageDependency("qux", versionSpec) });
sourceRepository.AddPackage(package2);
var package3A = PackageUtility.CreatePackage("qux", "1.0-alpha");
var package3B = PackageUtility.CreatePackage("qux", "1.0-beta");
var package3 = PackageUtility.CreatePackage("qux", "1.0");
sourceRepository.AddPackage(package3);
sourceRepository.AddPackage(package3A);
sourceRepository.AddPackage(package3B);
// Act and Assert
ExceptionAssert.Throws<InvalidOperationException>(() => packageManager.InstallPackage(package, ignoreDependencies: false, allowPrereleaseVersions: false),
"Unable to resolve dependency 'qux (≥ 0.6 && < 1.0)'.");
}
public void GetPackageDoNotShowUnlistedPackagesForUpdates2()
{
// Arrange
var sourceRepository = new MockPackageRepository()
{
PackageUtility.CreatePackage("C", "1.0.0", listed: true),
PackageUtility.CreatePackage("C", "2.0.0", listed: false),
PackageUtility.CreatePackage("C", "2.0.1", listed: true),
PackageUtility.CreatePackage("C", "2.0.3.4-alpha", listed: false),
PackageUtility.CreatePackage("C", "2.0.3.5-alpha", listed: true),
PackageUtility.CreatePackage("C", "2.5.0", listed: false),
};
var repositoryFactory = new Mock<IPackageRepositoryFactory>(MockBehavior.Strict);
repositoryFactory.Setup(r => r.CreateRepository("NuGet Official Source")).Returns(sourceRepository);
var solutionManager = TestUtils.GetSolutionManager();
var localPackages = new IPackage[]
{
PackageUtility.CreatePackage("C", "1.0.0")
};
var localRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict);
localRepository.Setup(p => p.GetPackages()).Returns(localPackages.AsQueryable()).Verifiable();
var packageManager = new VsPackageManager(
solutionManager,
sourceRepository,
new Mock<IFileSystemProvider>().Object,
new Mock<IFileSystem>().Object,
localRepository.Object,
new Mock<IDeleteOnRestartManager>().Object,
new VsPackageInstallerEvents());
var mockPackageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
mockPackageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager).Verifiable();
var cmdlet = new GetPackageCommand(
repositoryFactory.Object,
GetSourceProvider("NuGet Official Source"),
solutionManager,
mockPackageManagerFactory.Object,
new Mock<IHttpClient>().Object,
new Mock<IProductUpdateService>().Object);
cmdlet.Updates = true;
cmdlet.IncludePrerelease = true;
cmdlet.AllVersions = true;
cmdlet.Source = "NuGet Official Source";
// Act
var packages = cmdlet.GetResults<dynamic>();
// Assert
localRepository.Verify();
Assert.Equal(2, packages.Count());
AssertPackageResultsEqual(packages.ElementAt(0), new { Id = "C", Version = new SemanticVersion("2.0.1") });
AssertPackageResultsEqual(packages.ElementAt(1), new { Id = "C", Version = new SemanticVersion("2.0.3.5-alpha") });
}
public void InstallPackageCmdletDoesNotInstallPrereleasePackageIfFlagIsNotPresent()
{
// Arrange
var sharedRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict);
var packageRepository = new MockPackageRepository { PackageUtility.CreatePackage("A", "1.0.0-a") };
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, null);
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, null, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object);
cmdlet.Id = "A";
// Assert
ExceptionAssert.Throws<InvalidOperationException>(() => cmdlet.Execute(), "Unable to find package 'A'.");
}
public void UpdatePackageWithNoProjectsInstallsAtSolutionLevel()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object;
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, projectSystem, localRepository, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object);
var package = PackageUtility.CreatePackage("foo", "1.0", dependencies: new PackageDependency[] { new PackageDependency("bar") });
sourceRepository.AddPackage(package);
var package2 = PackageUtility.CreatePackage("bar", "2.0");
sourceRepository.AddPackage(package2);
var package3 = PackageUtility.CreatePackage("awesome", "1.0");
localRepository.AddPackage(package3);
var operations = new PackageOperation[] {
new PackageOperation(package, PackageAction.Install),
new PackageOperation(package2, PackageAction.Install),
new PackageOperation(package3, PackageAction.Uninstall)
};
// Act
packageManager.UpdatePackage(Enumerable.Empty<Project>(),
package,
operations,
updateDependencies: true,
allowPrereleaseVersions: false,
logger: NullLogger.Instance,
packageOperationEventListener: null);
// Assert
Assert.True(packageManager.LocalRepository.Exists(package));
Assert.True(packageManager.LocalRepository.Exists(package2));
Assert.True(!packageManager.LocalRepository.Exists(package3));
}
public void InstallPackageInstallUnlistedPrereleasePackageAsADependency(string versionA, string versionB)
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", versionA, dependencies: new[] { new PackageDependency("B") });
var packageB = PackageUtility.CreatePackage("B", versionB, listed: false);
var sharedRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict);
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable();
sharedRepository.Setup(s => s.AddPackage(packageB)).Verifiable();
sharedRepository.Setup(s => s.IsReferenced("A", new SemanticVersion(versionA))).Returns(true);
sharedRepository.Setup(s => s.IsReferenced("B", new SemanticVersion(versionB))).Returns(true);
var packageRepository = new MockPackageRepository { packageA, packageB };
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents());
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object);
cmdlet.Id = "A";
cmdlet.IncludePrerelease = true;
cmdlet.Execute();
// Assert
sharedRepository.Verify();
}
public void UpdatePackageUpdatesToTheHighestPackageIfPrereleaseFlagIsSetToTrue()
{
// Arrange
var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object;
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, projectSystem, localRepository, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object);
var package3_10A = PackageUtility.CreatePackage("qux", "1.0-alpha");
var package3_11B = PackageUtility.CreatePackage("qux", "1.1-alpha");
var package3_10 = PackageUtility.CreatePackage("qux", "1.0");
var package3_09 = PackageUtility.CreatePackage("qux", "0.9");
localRepository.AddPackage(package3_10);
localRepository.AddPackage(package3_10A);
localRepository.AddPackage(package3_11B);
localRepository.AddPackage(package3_09);
// Act
packageManager.InstallPackage(package3_09, ignoreDependencies: false, allowPrereleaseVersions: true);
Assert.True(packageManager.LocalRepository.Exists(package3_09));
packageManager.UpdatePackage("qux", updateDependencies: true, allowPrereleaseVersions: true);
// Assert
Assert.True(packageManager.LocalRepository.Exists(package3_11B));
}
public void InstallPackageCmdletOnlyOpenReadmeFileFromTheRootPackage()
{
// Arrange
// A --> B
var packageA = new Mock<IPackage>();
packageA.Setup(p => p.Id).Returns("A");
packageA.Setup(p => p.Version).Returns(new SemanticVersion("1.0"));
var depSet = new PackageDependencySet(null, new[] { new PackageDependency("B") });
packageA.Setup(p => p.DependencySets).Returns(new[] { depSet });
packageA.Setup(p => p.Listed).Returns(true);
var readme = new Mock<IPackageFile>();
readme.Setup(f => f.Path).Returns("readMe.txt");
readme.Setup(f => f.GetStream()).Returns(new MemoryStream());
packageA.Setup(p => p.GetFiles()).Returns(new IPackageFile[] { readme.Object });
var packageB = new Mock<IPackage>();
packageB.Setup(p => p.Id).Returns("B");
packageB.Setup(p => p.Version).Returns(new SemanticVersion("1.0"));
var readmeB = new Mock<IPackageFile>();
readmeB.Setup(f => f.Path).Returns("readMe.txt");
readmeB.Setup(f => f.GetStream()).Returns(new MemoryStream());
packageB.Setup(p => p.GetFiles()).Returns(new IPackageFile[] { readmeB.Object });
var sharedRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict);
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA.Object));
sharedRepository.Setup(s => s.AddPackage(packageB.Object));
sharedRepository.Setup(s => s.IsReferenced("A", new SemanticVersion("1.0"))).Returns(true);
sharedRepository.Setup(s => s.IsReferenced("B", new SemanticVersion("1.0"))).Returns(true);
var packageRepository = new MockPackageRepository { packageA.Object, packageB.Object };
var packageManager = new VsPackageManager(
TestUtils.GetSolutionManagerWithProjects("foo"),
packageRepository,
new Mock<IFileSystemProvider>().Object,
new MockFileSystem(),
sharedRepository.Object,
new Mock<IDeleteOnRestartManager>().Object,
new VsPackageInstallerEvents());
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
var fileOperations = new Mock<IVsCommonOperations>();
// Act
var cmdlet = new InstallPackageCommand(
TestUtils.GetSolutionManager(),
packageManagerFactory.Object,
null,
new Mock<IVsPackageSourceProvider>().Object,
new Mock<IHttpClientEvents>().Object,
null,
fileOperations.Object,
new Mock<IDeleteOnRestartManager>().Object);
cmdlet.Id = "A";
cmdlet.Execute();
// Assert
fileOperations.Verify(io => io.OpenFile(It.Is<string>(s => s.EndsWith("A.1.0\\readme.txt", StringComparison.OrdinalIgnoreCase))), Times.Once());
fileOperations.Verify(io => io.OpenFile(It.Is<string>(s => s.EndsWith("B.1.0\\readme.txt", StringComparison.OrdinalIgnoreCase))), Times.Never());
}
public IVsPackageManager CreatePackageManager(IPackageRepository repository, bool useFallbackForDependencies)
{
RepositoryInfo info = GetRepositoryInfo();
var packageManager = new VsPackageManager(_solutionManager,
repository,
_fileSystemProvider,
info.FileSystem,
info.Repository,
// We ensure DeleteOnRestartManager is initialized with a PhysicalFileSystem so the
// .deleteme marker files that get created don't get checked into version control
new DeleteOnRestartManager(() => new PhysicalFileSystem(info.FileSystem.Root)),
_packageEvents,
_frameworkMultiTargeting);
packageManager.DependencyVersion = GetDependencyVersion();
return packageManager;
}
private static IVsPackageManagerFactory GetPackageManagerForMultipleVersions()
{
var fileSystem = new Mock<IFileSystem>();
var localRepo = new Mock<ISharedPackageRepository>();
var localPackages = new[]
{
PackageUtility.CreatePackage("jQuery", "1.2"),
PackageUtility.CreatePackage("TestPack", "0.1")
};
localRepo.Setup(c => c.GetPackages()).Returns(localPackages.AsQueryable());
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), GetActiveRepository(),
new Mock<IFileSystemProvider>().Object,
fileSystem.Object, localRepo.Object,
new Mock<IDeleteOnRestartManager>().Object,
new Mock<VsPackageInstallerEvents>().Object);
var factory = new Mock<IVsPackageManagerFactory>();
factory.Setup(c => c.CreatePackageManager()).Returns(packageManager);
return factory.Object;
}
public void InstallPackageIgnoresFailingRepositoriesWhenInstallingPackageWithOrWithoutDependencies()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B") });
var packageB = PackageUtility.CreatePackage("B", "1.0.0", listed: true);
var packageC = PackageUtility.CreatePackage("C", "2.0.0");
var sharedRepository = new Mock<ISharedPackageRepository>();
sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable());
sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable();
sharedRepository.Setup(s => s.AddPackage(packageB)).Verifiable();
sharedRepository.Setup(s => s.AddPackage(packageC)).Verifiable();
var mockRepository = new Mock<IPackageRepository>();
mockRepository.Setup(c => c.GetPackages()).Returns(GetPackagesWithException().AsQueryable()).Verifiable();
var packageRepository = new AggregateRepository(new[] {
new MockPackageRepository {
packageA
},
mockRepository.Object,
new MockPackageRepository {
packageB
},
new MockPackageRepository {
packageC
},
});
var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents());
var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict);
packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager);
// Act
var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true);
cmdlet.Id = "A";
cmdlet.Execute();
cmdlet.Id = "C";
cmdlet.Execute();
// Assert
sharedRepository.Verify();
mockRepository.Verify();
}
