public void InstallPackageRunsInitAndInstallScripts() { // Arrange var localRepository = new Mock <MockPackageRepository>() { CallBase = true }.As <ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectRepository = new MockProjectPackageRepository(localRepository); var fileSystem = new MockFileSystem(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(new MockProjectSystem()); var project = TestUtils.GetProject("Foo"); var scriptExecutor = new Mock <IScriptExecutor>(); var packageManager = new MockVsPackageManager2( @"c:\solution", sourceRepository); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny <IPackageRepository>(), false)).Returns(packageManager); var package = NuGet.Test.PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }, tools: new[] { "init.ps1", "install.ps1" }); sourceRepository.AddPackage(package); var installer = new VsPackageInstaller(packageManagerFactory.Object, scriptExecutor.Object, new Mock <IPackageRepositoryFactory>().Object, new Mock <IOutputConsoleProvider>().Object, new Mock <IVsCommonOperations>().Object, new Mock <ISolutionManager>().Object, null, null); // Act installer.InstallPackage(sourceRepository, project, "foo", new SemanticVersion("1.0"), ignoreDependencies: false, skipAssemblyReferences: false); // Assert scriptExecutor.Verify(e => e.Execute(It.IsAny <string>(), PowerShellScripts.Init, It.IsAny <IPackage>(), null, null, It.IsAny <ILogger>()), Times.Once()); scriptExecutor.Verify(e => e.Execute(It.IsAny <string>(), PowerShellScripts.Install, It.IsAny <IPackage>(), It.IsAny <Project>(), It.IsAny <FrameworkName>(), It.IsAny <ILogger>()), Times.Once()); }
public void UninstallPackageDoesNotRemoveDependenciesIfFlagIsFalse() { // Arrange var packageA = PackageUtility.CreatePackage( "A", "1.0", dependencies: new[] { new PackageDependency("B") }); var packageB = PackageUtility.CreatePackage("B", "1.0"); var packageRepository = new MockPackageRepository { packageA, packageB }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); InstallPackage("A", packageManager); var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(new[] { packageA, packageB }, installedPackages, PackageEqualityComparer.IdAndVersion); var project = packageManager.SolutionManager.GetProject("default"); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), false)).Returns(packageManager); var scriptExecutor = new Mock<IScriptExecutor>(MockBehavior.Strict); scriptExecutor.Setup(s => s.Execute(@"c:\solution\A.1.0", "uninstall.ps1", packageA, project, new FrameworkName(".NETFramework,Version=v4.0.0.0"), NullLogger.Instance)).Returns(true).Verifiable(); var packageUninstaller = new VsPackageUninstaller( packageManagerFactory.Object, packageManager.LocalRepository, scriptExecutor.Object); // Act packageUninstaller.UninstallPackage(project, "A", removeDependencies: false); // Assert: packageA is uninstalled, while packageB is not scriptExecutor.Verify(); installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(new[] { packageB }, installedPackages, PackageEqualityComparer.IdAndVersion); }
public void InstallPackageCmdletPassesParametersCorrectlyWhenIdAndVersionAreSpecified() { // Arrange var packageA28 = PackageUtility.CreatePackage("A", "2.8"); var packageA31 = PackageUtility.CreatePackage("A", "3.1"); var packageRepository = new MockPackageRepository { packageA28, packageA31 }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand( packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; cmdlet.Version = new SemanticVersion("2.8"); cmdlet.Execute(); // Assert: version 2.8 is installed. var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(1, installedPackages.Count); Assert.Equal(packageA28, installedPackages[0], PackageEqualityComparer.IdAndVersion); }
public void UninstallPackageDoesNotForceRemovesPackages() { // Arrange var packageA = PackageUtility.CreatePackage( "A", "1.0", dependencies: new[] { new PackageDependency("B") }); var packageB = PackageUtility.CreatePackage("B", "1.0"); var packageRepository = new MockPackageRepository { packageA, packageB }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); InstallPackage("A", packageManager); var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(new[] { packageA, packageB }, installedPackages, PackageEqualityComparer.IdAndVersion); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny <IPackageRepository>(), false)).Returns(packageManager); var scriptExecutor = new Mock <IScriptExecutor>(MockBehavior.Strict); var packageUninstaller = new VsPackageUninstaller( packageManagerFactory.Object, packageManager.LocalRepository, scriptExecutor.Object); // Act and Assert var project = packageManager.SolutionManager.GetProject("default"); ExceptionAssert.Throws <InvalidOperationException>(() => packageUninstaller.UninstallPackage(project, "B", removeDependencies: true), "Unable to uninstall 'B 1.0' because 'A 1.0' depends on it."); }
public void UninstallPackageCmdletWhenIdAndVersionAreSpecified() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageRepository = new MockPackageRepository { packageA }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); InstallPackage("A", packageManager); var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(new[] { packageA }, installedPackages, PackageEqualityComparer.IdAndVersion); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); var cmdlet = new UninstallPackageCommand( packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object); cmdlet.Id = "A"; cmdlet.Version = new SemanticVersion("1.1"); // Act and Assert ExceptionAssert.Throws<InvalidOperationException>(() => cmdlet.GetResults(), "Unable to find package 'A'."); }
public void InstallPackageCmdletThrowsWhenSolutionIsClosed() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0.0"); var packageRepository = new MockPackageRepository { packageA }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); ((MockSolutionManager2)packageManager.SolutionManager).IsSolutionOpen = false; var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, null, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true); // Act and Assert ExceptionAssert.Throws<InvalidOperationException>(() => cmdlet.GetResults(), "The current environment doesn't have a solution open."); }
public void InstallPackageTurnOffBindingRedirectIfSkipAssemblyReferences() { // Arrange var localRepository = new Mock <MockPackageRepository>() { CallBase = true }.As <ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectRepository = new MockProjectPackageRepository(localRepository); var fileSystem = new MockFileSystem(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(new MockProjectSystem()); var project = TestUtils.GetProject("Foo"); var scriptExecutor = new Mock <IScriptExecutor>(); var packageManager = new MockVsPackageManager2( @"c:\solution", sourceRepository); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny <IPackageRepository>(), false)).Returns(packageManager); var package = NuGet.Test.PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }, tools: new[] { "init.ps1", "install.ps1" }); sourceRepository.AddPackage(package); var installer = new VsPackageInstaller( packageManagerFactory.Object, scriptExecutor.Object, new Mock <IPackageRepositoryFactory>().Object, new Mock <IOutputConsoleProvider>().Object, new Mock <IVsCommonOperations>().Object, new Mock <ISolutionManager>().Object, null, null); // Act installer.InstallPackage(sourceRepository, project, "foo", new SemanticVersion("1.0"), ignoreDependencies: false, skipAssemblyReferences: true); // Assert: no binding redirection is called. Assert.Equal(0, packageManager.BindingRedirectedProjects.Count); Assert.True(packageManager.BindingRedirectEnabled); }
private void InstallPackage(string id, MockVsPackageManager2 packageManager) { var projectManager = packageManager.GetProjectManager(packageManager.SolutionManager.GetProject("default")); // Resolve the package to install IPackage package = PackageRepositoryHelper.ResolvePackage( packageManager.SourceRepository, packageManager.LocalRepository, id, version: null, allowPrereleaseVersions: false); // Resolve operations var resolver = new ActionResolver(); resolver.AddOperation(PackageAction.Install, package, projectManager); var actions = resolver.ResolveActions(); var actionExecutor = new ActionExecutor(); actionExecutor.Execute(actions); }
public void UninstallPackageRemovesDependenciesIfFlagIsTrue() { // Arrange var packageA = PackageUtility.CreatePackage( "A", "1.0", dependencies: new[] { new PackageDependency("B") }); var packageB = PackageUtility.CreatePackage("B", "1.0"); var packageRepository = new MockPackageRepository { packageA, packageB }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); InstallPackage("A", packageManager); var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(new[] { packageA, packageB }, installedPackages, PackageEqualityComparer.IdAndVersion); var project = packageManager.SolutionManager.GetProject("default"); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny <IPackageRepository>(), false)).Returns(packageManager); var scriptExecutor = new Mock <IScriptExecutor>(MockBehavior.Strict); scriptExecutor.Setup(s => s.Execute(@"c:\solution\A.1.0", "uninstall.ps1", packageA, project, new FrameworkName(".NETFramework,Version=v4.0.0.0"), NullLogger.Instance)).Returns(true).Verifiable(); scriptExecutor.Setup(s => s.Execute(@"c:\solution\B.1.0", "uninstall.ps1", packageB, project, It.IsAny <FrameworkName>(), NullLogger.Instance)).Returns(true).Verifiable(); var packageUninstaller = new VsPackageUninstaller( packageManagerFactory.Object, packageManager.LocalRepository, scriptExecutor.Object); // Act packageUninstaller.UninstallPackage(project, "A", removeDependencies: true); // Assert: both packageA and packageB are uninstalled scriptExecutor.Verify(); installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(0, installedPackages.Count); }
private void InstallPackage(string id, MockVsPackageManager2 packageManager) { var projectManager = packageManager.GetProjectManager(packageManager.SolutionManager.GetProject("default")); // Resolve the package to install IPackage package = PackageRepositoryHelper.ResolvePackage( packageManager.SourceRepository, packageManager.LocalRepository, id, version: null, allowPrereleaseVersions: false); // Resolve operations var resolver = new ActionResolver(); resolver.AddOperation(NuGet.PackageAction.Install, package, projectManager); var actions = resolver.ResolveActions(); var executor = new ActionExecutor(); executor.Execute(actions); }
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 packageRepository = new MockPackageRepository { packageA, packageB1, packageB2 }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, 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: packageA and packageB2 are installed. // packageB1 is not picked because it cannot be used as a dependency of packageA var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(2, installedPackages.Count); Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion); Assert.Equal(packageB2, installedPackages[1], PackageEqualityComparer.IdAndVersion); }
public void UninstallPackageCmdletPassesForceSwitchCorrectly() { // Arrange var packageA = PackageUtility.CreatePackage( "A", "1.0", dependencies: new[] { new PackageDependency("B") }); var packageB = PackageUtility.CreatePackage("B", "1.0"); var packageRepository = new MockPackageRepository { packageA, packageB }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); InstallPackage("A", packageManager); var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(new[] { packageA, packageB }, installedPackages, PackageEqualityComparer.IdAndVersion); // Act var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); var cmdlet = new UninstallPackageCommand( packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object); cmdlet.Id = "B"; // Assert: packageB cannot be uninstalled without -Force ExceptionAssert.Throws<InvalidOperationException>(() => cmdlet.Execute(), "Unable to uninstall 'B 1.0' because 'A 1.0' depends on it."); // Assert: packageB can be uninstalled with -Force cmdlet.Force = new SwitchParameter(true); cmdlet.Execute(); installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(1, installedPackages.Count); Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion); }
public void InstallPackageCmdletInstallPrereleasePackageIfFlagIsPresent() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0.0-a"); var packageRepository = new MockPackageRepository { packageA }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // packageA is not installed yet. Assert.False(packageManager.LocalRepository.IsSolutionReferenced(packageA.Id, packageA.Version)); // Act var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, 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: packageA is installed. var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(1, installedPackages.Count); Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion); }
public void UninstallPackageCmdletWithRemoveDependencySwitch() { // Arrange var packageA = PackageUtility.CreatePackage( "A", "1.0", dependencies: new[] { new PackageDependency("B") }); var packageB = PackageUtility.CreatePackage("B", "1.0"); var packageRepository = new MockPackageRepository { packageA, packageB }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); InstallPackage("A", packageManager); var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(new[] { packageA, packageB }, installedPackages, PackageEqualityComparer.IdAndVersion); // Act var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); var cmdlet = new UninstallPackageCommand( packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object); cmdlet.Id = "A"; cmdlet.RemoveDependencies = new SwitchParameter(true); cmdlet.Execute(); // Assert: both packageA & packageB are uninstalled installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(0, installedPackages.Count); }
public void InstallPackageInstallUnlistedPrereleasePackageIfVersionIsSet() { // Arrange var packageA1 = PackageUtility.CreatePackage("A", "1.0.0"); var packageA2 = PackageUtility.CreatePackage("A", "1.0.0-ReleaseCandidate", listed: false); var packageRepository = new MockPackageRepository { packageA1, packageA2 }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, 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.Version = new SemanticVersion("1.0.0-ReleaseCandidate"); cmdlet.IncludePrerelease = true; cmdlet.Execute(); // Assert: the unlisted prerelease packageA2 is installed. var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(1, installedPackages.Count); Assert.Equal(packageA2, installedPackages[0], PackageEqualityComparer.IdAndVersion); }
public void InstallPackageDoesNotTurnOffBindingRedirectIfNotSkipAssemblyReferences() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectRepository = new MockProjectPackageRepository(localRepository); var fileSystem = new MockFileSystem(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(new MockProjectSystem()); var project = TestUtils.GetProject("Foo"); var scriptExecutor = new Mock<IScriptExecutor>(); var packageManager = new MockVsPackageManager2( @"c:\solution", sourceRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), false)).Returns(packageManager); var package = NuGet.Test.PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }, tools: new[] { "init.ps1", "install.ps1" }); sourceRepository.AddPackage(package); var installer = new VsPackageInstaller( packageManagerFactory.Object, scriptExecutor.Object, new Mock<IPackageRepositoryFactory>().Object, new Mock<IOutputConsoleProvider>().Object, new Mock<IVsCommonOperations>().Object, new Mock<ISolutionManager>().Object, null, null); // Act installer.InstallPackage(sourceRepository, project, "foo", new SemanticVersion("1.0"), ignoreDependencies: false, skipAssemblyReferences: false); // Assert: binding redirection is called for project "Foo" Assert.Equal(1, packageManager.BindingRedirectedProjects.Count); Assert.Equal("Foo", packageManager.BindingRedirectedProjects[0]); }
public void InstallPackageRunsInitAndInstallScripts() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectRepository = new MockProjectPackageRepository(localRepository); var fileSystem = new MockFileSystem(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(new MockProjectSystem()); var project = TestUtils.GetProject("Foo"); var scriptExecutor = new Mock<IScriptExecutor>(); var packageManager = new MockVsPackageManager2( @"c:\solution", sourceRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), false)).Returns(packageManager); var package = NuGet.Test.PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }, tools: new[] { "init.ps1", "install.ps1" }); sourceRepository.AddPackage(package); var installer = new VsPackageInstaller(packageManagerFactory.Object, scriptExecutor.Object, new Mock<IPackageRepositoryFactory>().Object, new Mock<IOutputConsoleProvider>().Object, new Mock<IVsCommonOperations>().Object, new Mock<ISolutionManager>().Object, null, null); // Act installer.InstallPackage(sourceRepository, project, "foo", new SemanticVersion("1.0"), ignoreDependencies: false, skipAssemblyReferences: false); // Assert scriptExecutor.Verify(e => e.Execute(It.IsAny<string>(), PowerShellScripts.Init, It.IsAny<IPackage>(), null, null, It.IsAny<ILogger>()), Times.Once()); scriptExecutor.Verify(e => e.Execute(It.IsAny<string>(), PowerShellScripts.Install, It.IsAny<IPackage>(), It.IsAny<Project>(), It.IsAny<FrameworkName>(), It.IsAny<ILogger>()), Times.Once()); }
public void InstallPackageCmdletPassesIgnoreDependencySwitchCorrectly() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0.0", dependencies: new[] { new PackageDependency("B") }); var packageB = PackageUtility.CreatePackage("B", "1.0.0"); var packageRepository = new MockPackageRepository { packageA, packageB }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand( packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; cmdlet.IgnoreDependencies = new SwitchParameter(true); cmdlet.Execute(); // Assert: only packageA is installed. packageB is not. var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(1, installedPackages.Count); Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion); }
public void UninstallPackageDoesNotForceRemovesPackages() { // Arrange var packageA = PackageUtility.CreatePackage( "A", "1.0", dependencies: new[] { new PackageDependency("B") }); var packageB = PackageUtility.CreatePackage("B", "1.0"); var packageRepository = new MockPackageRepository { packageA, packageB }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); InstallPackage("A", packageManager); var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(new[] { packageA, packageB }, installedPackages, PackageEqualityComparer.IdAndVersion); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), false)).Returns(packageManager); var scriptExecutor = new Mock<IScriptExecutor>(MockBehavior.Strict); var packageUninstaller = new VsPackageUninstaller( packageManagerFactory.Object, packageManager.LocalRepository, scriptExecutor.Object); // Act and Assert var project = packageManager.SolutionManager.GetProject("default"); ExceptionAssert.Throws<InvalidOperationException>(() => packageUninstaller.UninstallPackage(project, "B", removeDependencies: true), "Unable to uninstall 'B 1.0' because 'A 1.0' depends on it."); }
public void InstallPackageShouldPickListedPackagesOverUnlistedOnesAsDependency2() { // 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-alpha", listed: true); var packageB3 = PackageUtility.CreatePackage("B", "1.0.2", listed: false); var packageRepository = new MockPackageRepository { packageA, packageB1, packageB2, packageB3 }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, 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.DependencyVersion = DependencyVersion.HighestPatch; cmdlet.Execute(); // Assert: packageA and packageB2 are installed. // packageB1 is not picked because packageB2's version is later. // packageB3 is not picked because it's unlisted. var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(2, installedPackages.Count); Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion); Assert.Equal(packageB2, installedPackages[1], PackageEqualityComparer.IdAndVersion); }
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 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 MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, 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 var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(3, installedPackages.Count); Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion); Assert.Equal(packageB, installedPackages[1], PackageEqualityComparer.IdAndVersion); Assert.Equal(packageC, installedPackages[2], PackageEqualityComparer.IdAndVersion); mockRepository.Verify(); }
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 packageRepository = new MockPackageRepository { packageA, packageB }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, 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 var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(2, installedPackages.Count); Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion); Assert.Equal(packageB, installedPackages[1], PackageEqualityComparer.IdAndVersion); }
public void UpdatePackageUpdateToUnlistedPackageIfVersionIsSet(string versionA1, string versionA2) { // Arrange var packageA1 = PackageUtility.CreatePackage("A", versionA1); var packageA2 = PackageUtility.CreatePackage("A", versionA2, listed: false); var packageRepository = new MockPackageRepository { packageA1, packageA2 }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); InstallPackage(packageA1.Id, packageA1.Version, packageManager); var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(new[] { packageA1 }, installedPackages, PackageEqualityComparer.IdAndVersion); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new UpdatePackageCommand(packageManager.SolutionManager, 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.GetResults(); // Assert: packageA1 is updated to packageA2. installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(new[] { packageA2 }, installedPackages, PackageEqualityComparer.IdAndVersion); }
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 }); packageA.Setup(p => p.GetStream()).Returns(new MemoryStream()); 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 }); packageB.Setup(p => p.GetStream()).Returns(new MemoryStream()); var packageRepository = new MockPackageRepository { packageA.Object, packageB.Object }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); var fileOperations = new Mock<IVsCommonOperations>(); // Act var cmdlet = new InstallPackageCommand( packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, fileOperations.Object, new Mock<IDeleteOnRestartManager>().Object, true); 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()); }