public void UninstallPackageExecutesUninstallScript() { // Arrange var activeRepository = new MockPackageRepository(); var localRepository = new Mock<MockPackageRepository>() { CallBase = true }; localRepository.As<ISharedPackageRepository>(); var projectRepository = new MockProjectPackageRepository(localRepository.Object); var project = TestUtils.GetProject("Foo"); var projectSystem = new MockProjectSystem(); var projectManager = new ProjectManager(activeRepository, new DefaultPackagePathResolver(new MockFileSystem()), projectSystem, projectRepository); var package = PackageUtility.CreatePackage("A"); var scriptExecutor = new Mock<IScriptExecutor>(MockBehavior.Strict); scriptExecutor.Setup(s => s.Execute(@"C:\MockFileSystem\A.1.0", "uninstall.ps1", package, project, NullLogger.Instance)).Returns(true).Verifiable(); var packageManager = new Mock<VsPackageManager>(TestUtils.GetSolutionManager(), activeRepository, new MockFileSystem(), localRepository.Object, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object) { CallBase = true }; var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(activeRepository, false, false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager).Verifiable(); var packageUninstaller = new VsPackageUninstaller(packageManagerFactory.Object, activeRepository, scriptExecutor.Object); // Act localRepository.Object.AddPackage(package); packageUninstaller.UninstallPackage(project, "A", removeDependencies: true); // Assert scriptExecutor.Verify(); Assert.False(localRepository.Object.Contains(package)); }
public void UninstallPackageRemovesDependenciesIfFlagIsTrue() { // Arrange var activeRepository = new MockPackageRepository(); var localRepository = new Mock<MockPackageRepository>() { CallBase = true }; localRepository.As<ISharedPackageRepository>(); var projectRepository = new MockProjectPackageRepository(localRepository.Object); var project = TestUtils.GetProject("Foo"); var projectSystem = new MockProjectSystem(); var projectManager = new ProjectManager(activeRepository, new DefaultPackagePathResolver(new MockFileSystem()), projectSystem, projectRepository); var packageA = PackageUtility.CreatePackage("A", dependencies: new[] { new PackageDependency("B") }); var packageB = PackageUtility.CreatePackage("B"); var scriptExecutor = new Mock<IScriptExecutor>(MockBehavior.Strict); scriptExecutor.Setup(s => s.Execute(@"C:\MockFileSystem\A.1.0", "uninstall.ps1", packageA, project, It.IsAny<FrameworkName>(), NullLogger.Instance)).Returns(true).Verifiable(); scriptExecutor.Setup(s => s.Execute(@"C:\MockFileSystem\B.1.0", "uninstall.ps1", packageB, project, It.IsAny<FrameworkName>(), NullLogger.Instance)).Returns(true).Verifiable(); var packageManager = new Mock<VsPackageManager>(TestUtils.GetSolutionManager(), activeRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), localRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object) { CallBase = true }; var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(activeRepository, false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager).Verifiable(); var packageUninstaller = new VsPackageUninstaller(packageManagerFactory.Object, activeRepository, scriptExecutor.Object); // Act localRepository.Object.AddPackage(packageA); localRepository.Object.AddPackage(packageB); packageUninstaller.UninstallPackage(project, "A", removeDependencies: true); // Assert scriptExecutor.Verify(); Assert.False(localRepository.Object.Contains(packageA)); Assert.False(localRepository.Object.Contains(packageB)); }
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 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 projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, projectRepository); var scriptExecutor = new Mock<IScriptExecutor>(); var packageManager = new Mock<VsPackageManager>(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object) { CallBase = true }; var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), false, false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager); 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<IVsCommonOperations>().Object, new Mock<ISolutionManager>().Object); // 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>(), It.IsAny<Project>(), It.IsAny<ILogger>()), Times.Once()); scriptExecutor.Verify(e => e.Execute(It.IsAny<string>(), PowerShellScripts.Install, It.IsAny<IPackage>(), It.IsAny<Project>(), It.IsAny<ILogger>()), Times.Once()); }
public void InstallPackageDoesNotUseFallbackRepository() { // 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 projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, projectRepository); var scriptExecutor = new Mock<IScriptExecutor>(); var packageManager = new Mock<VsPackageManager>(TestUtils.GetSolutionManager(), sourceRepository, fileSystem, localRepository, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object) { CallBase = true }; var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), false, false)).Returns(packageManager.Object); packageManagerFactory.Setup(m => m.CreatePackageManager()).Throws(new Exception("A")); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), true, It.IsAny<bool>())).Throws(new Exception("B")); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager); 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); // Act installer.InstallPackage(sourceRepository, project, "foo", new SemanticVersion("1.0"), ignoreDependencies: false); // Assert packageManagerFactory.Verify(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), false, false), Times.Once()); packageManagerFactory.Verify(m => m.CreatePackageManager(), Times.Never()); packageManagerFactory.Verify(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), true, It.IsAny<bool>()), Times.Never()); }
public void InstallPackagesFromVSExtensionRepositoryThrowsWhenPackageIsMissing() { // Arrange var extensionId = "myExtensionId"; var extensionManagerMock = new Mock <IVsExtensionManager>(); var extensionMock = new Mock <IInstalledExtension>(); extensionMock.Setup(e => e.InstallPath).Returns(@"C:\Extension\Dir"); var extension = extensionMock.Object; extensionManagerMock.Setup(em => em.TryGetInstalledExtension(extensionId, out extension)).Returns(true); var services = new Mock <IVsPackageInstallerServices>(); services.Setup(x => x.IsPackageInstalled(It.IsAny <Project>(), It.IsAny <string>())).Returns(false); 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 projectManager = new ProjectManager(null, pathResolver, projectSystem, projectRepository); var packageManager = new Mock <VsPackageManager>( TestUtils.GetSolutionManager(), sourceRepository, new Mock <IFileSystemProvider>().Object, fileSystem, localRepository, new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object, /* multiFrameworkTargeting */ null) { CallBase = true }; var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); var packageRepositoryFactory = new Mock <IPackageRepositoryFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny <IPackageRepository>(), false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager); packageRepositoryFactory.Setup(r => r.CreateRepository(@"x:\test")).Returns(new MockPackageRepository()).Verifiable(); var installer = new VsPackageInstaller(packageManagerFactory.Object, null, null, null, new Mock <IVsCommonOperations>().Object, new Mock <ISolutionManager>().Object, null, services.Object, extensionManagerMock.Object); var packages = new Dictionary <string, string>(); packages.Add("A", "1.0.0"); // Act & Assert var exception = Assert.Throws <InvalidOperationException>(() => installer.InstallPackagesFromVSExtensionRepository(extensionId, isPreUnzipped: false, skipAssemblyReferences: false, project: project, packageVersions: packages)); Assert.True(exception.Message.Contains("A.1.0.0 : ")); }
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 projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, projectRepository); var scriptExecutor = new Mock <IScriptExecutor>(); var packageManager = new Mock <VsPackageManager>( TestUtils.GetSolutionManager(), sourceRepository, new Mock <IFileSystemProvider>().Object, fileSystem, localRepository, new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object, /* multiFrameworkTargeting */ null) { CallBase = true }; var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManager.As <IVsPackageManager>().SetupGet(m => m.BindingRedirectEnabled).Returns(true); packageManager.As <IVsPackageManager>().SetupSet(m => m.BindingRedirectEnabled = false); packageManager.As <IVsPackageManager>().SetupSet(m => m.BindingRedirectEnabled = true); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny <IPackageRepository>(), false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager); 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 packageManager.As <IVsPackageManager>().VerifySet(m => m.BindingRedirectEnabled = false, Times.Never()); packageManager.As <IVsPackageManager>().VerifySet(m => m.BindingRedirectEnabled = true, Times.Exactly(2)); }
public void InstallPackagesFromRegistryRepositoryThrowsWhenPackageIsMissing() { // Arrange var registryPath = @"SOFTWARE\NuGet\Repository"; var registryKey = "PreinstalledPackages"; var registryValue = @"C:\PreinstalledPackages"; var hkcu_repository = new Mock <IRegistryKey>(); var hkcu = new Mock <IRegistryKey>(); hkcu_repository.Setup(k => k.GetValue(registryKey)).Returns(registryValue); hkcu.Setup(r => r.OpenSubKey(registryPath)).Returns(hkcu_repository.Object); var services = new Mock <IVsPackageInstallerServices>(); services.Setup(x => x.IsPackageInstalled(It.IsAny <Project>(), It.IsAny <string>())).Returns(false); 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 projectManager = new ProjectManager(null, pathResolver, projectSystem, projectRepository); var packageManager = new Mock <VsPackageManager>( TestUtils.GetSolutionManager(), sourceRepository, new Mock <IFileSystemProvider>().Object, fileSystem, localRepository, new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object, /* multiFrameworkTargeting */ null) { CallBase = true }; var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); var packageRepositoryFactory = new Mock <IPackageRepositoryFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny <IPackageRepository>(), false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager); packageRepositoryFactory.Setup(r => r.CreateRepository(@"x:\test")).Returns(new MockPackageRepository()).Verifiable(); var installer = new VsPackageInstaller(packageManagerFactory.Object, null, null, null, new Mock <IVsCommonOperations>().Object, new Mock <ISolutionManager>().Object, null, services.Object, registryKeys: new[] { hkcu.Object }); var packages = new Dictionary <string, string>(); packages.Add("A", "1.0.0"); // Act & Assert var exception = Assert.Throws <InvalidOperationException>(() => installer.InstallPackagesFromRegistryRepository(registryKey, isPreUnzipped: false, skipAssemblyReferences: false, project: project, packageVersions: packages)); Assert.True(exception.Message.Contains("A.1.0.0 : ")); }
public void UninstallPackageRemovesDependenciesIfFlagIsTrue() { // Arrange var activeRepository = new MockPackageRepository(); var localRepository = new Mock <MockPackageRepository>() { CallBase = true }; localRepository.As <ISharedPackageRepository>(); var projectRepository = new MockProjectPackageRepository(localRepository.Object); var project = TestUtils.GetProject("Foo"); var projectSystem = new MockProjectSystem(); var projectManager = new ProjectManager(activeRepository, new DefaultPackagePathResolver(new MockFileSystem()), projectSystem, projectRepository); var packageA = PackageUtility.CreatePackage("A", dependencies: new[] { new PackageDependency("B") }); var packageB = PackageUtility.CreatePackage("B", content: new[] { "file1.txt" }); var scriptExecutor = new Mock <IScriptExecutor>(MockBehavior.Strict); scriptExecutor.Setup(s => s.Execute(@"C:\MockFileSystem\A.1.0", "uninstall.ps1", packageA, project, It.IsAny <FrameworkName>(), NullLogger.Instance)).Returns(true).Verifiable(); scriptExecutor.Setup(s => s.Execute(@"C:\MockFileSystem\B.1.0", "uninstall.ps1", packageB, project, It.IsAny <FrameworkName>(), NullLogger.Instance)).Returns(true).Verifiable(); var packageManager = new Mock <VsPackageManager>( TestUtils.GetSolutionManager(), activeRepository, new Mock <IFileSystemProvider>().Object, new MockFileSystem(), localRepository.Object, new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object, /* multiFrameworkTargeting */ null) { CallBase = true }; projectManager.LocalRepository.AddPackage(packageA); projectManager.LocalRepository.AddPackage(packageB); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(activeRepository, false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager).Verifiable(); var packageUninstaller = new VsPackageUninstaller(packageManagerFactory.Object, activeRepository, scriptExecutor.Object); // Act localRepository.Object.AddPackage(packageA); localRepository.Object.AddPackage(packageB); packageUninstaller.UninstallPackage(project, "A", removeDependencies: true); // Assert scriptExecutor.Verify(); Assert.False(localRepository.Object.Contains(packageA)); Assert.False(localRepository.Object.Contains(packageB)); }
public void InstallPackageConvertsVersionToSemanticVersion() { // 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 Mock <VsPackageManager>( TestUtils.GetSolutionManager(), sourceRepository, new Mock <IFileSystemProvider>().Object, fileSystem, localRepository, new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object, /* multiFrameworkTargeting */ null) { CallBase = true }; var projectManager = new ProjectManager(packageManager.Object, pathResolver, projectSystem, projectRepository); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); var packageRepositoryFactory = new Mock <IPackageRepositoryFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny <IPackageRepository>(), false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager); packageRepositoryFactory.Setup(r => r.CreateRepository(@"x:\test")).Returns(new MockPackageRepository()).Verifiable(); 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, packageRepositoryFactory.Object, new Mock <IOutputConsoleProvider>().Object, new Mock <IVsCommonOperations>().Object, new Mock <ISolutionManager>().Object, null, null); // Act installer.InstallPackage(@"x:\test", project, "foo", new Version("1.0"), ignoreDependencies: 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()); packageRepositoryFactory.Verify(); }
public void InstallPackageTurnOffBindingRedirect() { // 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 projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, projectRepository); var scriptExecutor = new Mock <IScriptExecutor>(); var packageManager = new Mock <VsPackageManager>(TestUtils.GetSolutionManager(), sourceRepository, new Mock <IFileSystemProvider>().Object, fileSystem, localRepository, new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object) { CallBase = true }; var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManager.As <IVsPackageManager>().SetupGet(m => m.BindingRedirectEnabled).Returns(true); int state = 1; packageManager.As <IVsPackageManager>().SetupSet(m => m.BindingRedirectEnabled = false).Callback(() => state += 1); packageManager.As <IVsPackageManager>().SetupSet(m => m.BindingRedirectEnabled = true).Callback(() => state *= 2); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny <IPackageRepository>(), false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager); 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 <IVsCommonOperations>().Object, new Mock <ISolutionManager>().Object); // Act installer.InstallPackage(sourceRepository, project, "foo", new SemanticVersion("1.0"), ignoreDependencies: false, skipAssemblyReferences: false); // Assert // state = 4 means that BindingRedirectEnabled is set to 'false', then to 'true', in that order. // no other value of 4 can result in the same value of 4. Assert.Equal(4, state); packageManager.As <IVsPackageManager>().VerifySet(m => m.BindingRedirectEnabled = false, Times.Once()); packageManager.As <IVsPackageManager>().VerifySet(m => m.BindingRedirectEnabled = true, Times.Once()); }
public void UninstallPackageDoesNotForceRemovesPackages() { // Arrange var activeRepository = new MockPackageRepository(); var localRepository = new Mock <MockPackageRepository>() { CallBase = true }; localRepository.As <ISharedPackageRepository>(); var projectRepository = new MockProjectPackageRepository(localRepository.Object); var project = TestUtils.GetProject("Foo"); var projectSystem = new MockProjectSystem(); var projectManager = new ProjectManager(activeRepository, new DefaultPackagePathResolver(new MockFileSystem()), projectSystem, projectRepository); var packageA = PackageUtility.CreatePackage("A", dependencies: new[] { new PackageDependency("B") }); var packageB = PackageUtility.CreatePackage("B"); var scriptExecutor = new Mock <IScriptExecutor>(MockBehavior.Strict); scriptExecutor.Setup(s => s.Execute(@"C:\MockFileSystem\A.1.0", "uninstall.ps1", packageA, project, It.IsAny <FrameworkName>(), NullLogger.Instance)).Returns(true).Verifiable(); var packageManager = new Mock <VsPackageManager>( TestUtils.GetSolutionManager(), activeRepository, new Mock <IFileSystemProvider>().Object, new MockFileSystem(), localRepository.Object, new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object, null) { CallBase = true }; var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(activeRepository, false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager).Verifiable(); var packageUninstaller = new VsPackageUninstaller(packageManagerFactory.Object, activeRepository, scriptExecutor.Object); // Act and Assert localRepository.Object.AddPackage(packageA); localRepository.Object.AddPackage(packageB); ExceptionAssert.Throws <InvalidOperationException>(() => packageUninstaller.UninstallPackage(project, "B", removeDependencies: true), "Unable to uninstall 'B 1.0' because 'A 1.0' depends on it."); }
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); }
public void InstallPackageConvertsVersionToSemanticVersion() { // 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 projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, projectRepository); var scriptExecutor = new Mock<IScriptExecutor>(); var packageManager = new Mock<VsPackageManager>( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object, /* multiFrameworkTargeting */ null) { CallBase = true }; var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); var packageRepositoryFactory = new Mock<IPackageRepositoryFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager); packageRepositoryFactory.Setup(r => r.CreateRepository(@"x:\test")).Returns(new MockPackageRepository()).Verifiable(); 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, packageRepositoryFactory.Object, new Mock<IOutputConsoleProvider>().Object, new Mock<IVsCommonOperations>().Object, new Mock<ISolutionManager>().Object, null, null); // Act installer.InstallPackage(@"x:\test", project, "foo", new Version("1.0"), ignoreDependencies: 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()); packageRepositoryFactory.Verify(); }
public void InstallPackageThrowsIfRepositoryIsNull() { // 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 projectManager = new ProjectManager(null, pathResolver, projectSystem, projectRepository); var scriptExecutor = new Mock <IScriptExecutor>(); var packageManager = new Mock <VsPackageManager>( TestUtils.GetSolutionManager(), sourceRepository, new Mock <IFileSystemProvider>().Object, fileSystem, localRepository, new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object, /* multiFrameworkTargeting */ null) { CallBase = true }; var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); var packageRepositoryFactory = new Mock <IPackageRepositoryFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager(It.Is <IPackageRepository>(p => p != null), false)) .Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager); var installer = new VsPackageInstaller(packageManagerFactory.Object, scriptExecutor.Object, packageRepositoryFactory.Object, new Mock <IOutputConsoleProvider>().Object, new Mock <IVsCommonOperations>().Object, new Mock <ISolutionManager>().Object, null, null); // Act && Assert Assert.Throws <ArgumentNullException>(() => installer.InstallPackage(/* repository */ null, project, "foo", "1.0", ignoreDependencies: false, skipAssemblyReferences: true) ); }
public void InstallPackageDoesNotUseFallbackRepository() { // 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 projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, projectRepository); var scriptExecutor = new Mock <IScriptExecutor>(); var packageManager = new Mock <VsPackageManager>(TestUtils.GetSolutionManager(), sourceRepository, new Mock <IFileSystemProvider>().Object, fileSystem, localRepository, new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object) { CallBase = true }; var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny <IPackageRepository>(), false)).Returns(packageManager.Object); packageManagerFactory.Setup(m => m.CreatePackageManager()).Throws(new Exception("A")); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny <IPackageRepository>(), true)).Throws(new Exception("B")); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager); 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 <IVsCommonOperations>().Object, new Mock <ISolutionManager>().Object); // Act installer.InstallPackage(sourceRepository, project, "foo", new SemanticVersion("1.0"), ignoreDependencies: false, skipAssemblyReferences: false); // Assert packageManagerFactory.Verify(m => m.CreatePackageManager(It.IsAny <IPackageRepository>(), false), Times.Once()); packageManagerFactory.Verify(m => m.CreatePackageManager(), Times.Never()); packageManagerFactory.Verify(m => m.CreatePackageManager(It.IsAny <IPackageRepository>(), true), Times.Never()); }
public void InstallPackageTurnOffBindingRedirect() { // 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 projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, projectRepository); var scriptExecutor = new Mock<IScriptExecutor>(); var packageManager = new Mock<VsPackageManager>(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object) { CallBase = true }; var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManager.As<IVsPackageManager>().SetupGet(m => m.BindingRedirectEnabled).Returns(true); int state = 1; packageManager.As<IVsPackageManager>().SetupSet(m => m.BindingRedirectEnabled = false).Callback(() => state += 1); packageManager.As<IVsPackageManager>().SetupSet(m => m.BindingRedirectEnabled = true).Callback(() => state *= 2); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), false, false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager); 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<IVsCommonOperations>().Object, new Mock<ISolutionManager>().Object); // Act installer.InstallPackage(sourceRepository, project, "foo", new SemanticVersion("1.0"), ignoreDependencies: false, skipAssemblyReferences: false); // Assert // state = 4 means that BindingRedirectEnabled is set to 'false', then to 'true', in that order. // no other value of 4 can result in the same value of 4. Assert.Equal(4, state); packageManager.As<IVsPackageManager>().VerifySet(m => m.BindingRedirectEnabled = false, Times.Once()); packageManager.As<IVsPackageManager>().VerifySet(m => m.BindingRedirectEnabled = true, Times.Once()); }
public void UninstallPackageExecutesUninstallScript() { // Arrange var activeRepository = new MockPackageRepository(); var localRepository = new Mock <MockPackageRepository>() { CallBase = true }; localRepository.As <ISharedPackageRepository>(); var projectRepository = new MockProjectPackageRepository(localRepository.Object); var project = TestUtils.GetProject("Foo"); var projectSystem = new MockProjectSystem(new FrameworkName(".NETCore, Version=4.5")); var projectManager = new ProjectManager(activeRepository, new DefaultPackagePathResolver(new MockFileSystem()), projectSystem, projectRepository); var package = PackageUtility.CreatePackage("A"); var scriptExecutor = new Mock <IScriptExecutor>(MockBehavior.Strict); scriptExecutor.Setup(s => s.Execute(@"C:\MockFileSystem\A.1.0", "uninstall.ps1", package, project, new FrameworkName(".NETCore, Version=4.5"), NullLogger.Instance)).Returns(true).Verifiable(); var packageManager = new Mock <VsPackageManager>(TestUtils.GetSolutionManager(), activeRepository, new Mock <IFileSystemProvider>().Object, new MockFileSystem(), localRepository.Object, new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object) { CallBase = true }; var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(activeRepository, false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager).Verifiable(); var packageUninstaller = new VsPackageUninstaller(packageManagerFactory.Object, activeRepository, scriptExecutor.Object); // Act localRepository.Object.AddPackage(package); packageUninstaller.UninstallPackage(project, "A", removeDependencies: true); // Assert scriptExecutor.Verify(); Assert.False(localRepository.Object.Contains(package)); }
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 projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, projectRepository); var scriptExecutor = new Mock <IScriptExecutor>(); var packageManager = new Mock <VsPackageManager>(TestUtils.GetSolutionManager(), sourceRepository, fileSystem, localRepository, new Mock <IRecentPackageRepository>().Object) { CallBase = true }; var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny <IPackageRepository>())).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager); 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); // Act installer.InstallPackage(sourceRepository, project, "foo", new Version("1.0"), ignoreDependencies: false); // Assert scriptExecutor.Verify(e => e.Execute(It.IsAny <string>(), PowerShellScripts.Init, It.IsAny <IPackage>(), It.IsAny <Project>(), It.IsAny <ILogger>()), Times.Once()); scriptExecutor.Verify(e => e.Execute(It.IsAny <string>(), PowerShellScripts.Install, It.IsAny <IPackage>(), It.IsAny <Project>(), It.IsAny <ILogger>()), Times.Once()); }
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, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var projectManager = new ProjectManager(localRepository.Object, pathResolver, new MockProjectSystem(), projectRepository); // Act packageManager.UpdatePackage(projectManager, "A", version: null, updateDependencies: true, allowPrereleaseVersions: false, logger: NullLogger.Instance); // Assert Assert.False(packageManager.LocalRepository.Exists(A10)); Assert.False(packageManager.LocalRepository.Exists(B10)); Assert.True(packageManager.LocalRepository.Exists(A20)); Assert.True(packageManager.LocalRepository.Exists(B20)); Assert.True(packageManager.LocalRepository.Exists(F10)); Assert.True(packageManager.LocalRepository.Exists(G10)); }
public void UpdatePackageDoesNotRemovesPackageIfPackageIsReferenced() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); localRepository.Setup(m => m.IsReferenced("A", new SemanticVersion("1.0"))).Returns(true); 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, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var projectManager = new ProjectManager(localRepository.Object, pathResolver, new MockProjectSystem(), projectRepository); // Act packageManager.UpdatePackage(projectManager, "A", version: null, updateDependencies: true, allowPrereleaseVersions: false, logger: NullLogger.Instance); // Assert Assert.True(packageManager.LocalRepository.Exists(A10)); }
public void UpdatePackagesWithOperationsAddPackageCorrectly() { // 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" }); var A2 = PackageUtility.CreatePackage("A", "2.0", new[] { "hello2" }); var A3 = PackageUtility.CreatePackage("A", "3.0", new[] { "hello3" }); var B1 = PackageUtility.CreatePackage("B", "1.0", new[] { "world1" }); var B2 = PackageUtility.CreatePackage("B", "2.0", new[] { "world2" }); sourceRepository.AddPackage(A2); sourceRepository.AddPackage(A3); sourceRepository.AddPackage(B1); sourceRepository.AddPackage(B2); localRepository.AddPackage(A1); localRepository.AddPackage(B1); projectRepository.Add(A1); projectRepository.Add(B1); 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 operations = new PackageOperation[] { new PackageOperation(A3, PackageAction.Install), new PackageOperation(B2, PackageAction.Install) }; // Act packageManager.UpdatePackages(projectManager, new[] { A3, B2 }, operations, updateDependencies: true, allowPrereleaseVersions: true, logger: NullLogger.Instance); // Assert Assert.True(localRepository.Exists("A", new SemanticVersion("3.0"))); Assert.False(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(projectRepository.Exists("A", new SemanticVersion("3.0"))); Assert.True(projectRepository.Exists("B", new SemanticVersion("2.0"))); }
public void InstallSolutionLevelPackageAddEntryToSolutionPackagesConfig2(bool skipAssemblyReferences) { // Arrange // Source repository has A -> B, where B is a project-level package and A is a meta-package. // We want to make sure A is added to the packages.config of the project, and NOT packages.config of the solution var localRepository = new MockSharedPackageRepository(); var sourceRepository = new MockPackageRepository(); var packageA = PackageUtility.CreatePackage("A", "2.0", tools: new[] { "install.ps1" }); sourceRepository.Add(packageA); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var packageManager = new VsPackageManager( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var projectRepository = new MockProjectPackageRepository(localRepository); var projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, projectRepository); // Act packageManager.InstallPackage( projectManager, "A", new SemanticVersion("2.0"), ignoreDependencies: false, allowPrereleaseVersions: true, skipAssemblyReferences: skipAssemblyReferences, logger: null); // Assert Assert.True(!projectRepository.Exists("A", new SemanticVersion("2.0"))); // assert that packages.config for solution-level is created. Assert.True(localRepository.IsSolutionReferenced("A", new SemanticVersion("2.0"))); }
public void UpdatePackageThrowsIfNewPackageHasMinClientVersionNotSatisfied() { // Arrange Version nugetVersion = typeof(IPackage).Assembly.GetName().Version; Version requiredVersion = new Version(nugetVersion.Major, nugetVersion.Minor, nugetVersion.Build, nugetVersion.Revision + 1); var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); localRepository.Setup(m => m.IsReferenced("A", new SemanticVersion("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" }, minClientVersion: requiredVersion.ToString()); sourceRepository.AddPackage(A10); sourceRepository.AddPackage(A20); localRepository.Object.AddPackage(A10); localRepository.Object.AddPackage(A20); projectRepository.Add(A10); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var projectManager = new ProjectManager(localRepository.Object, pathResolver, new MockProjectSystem(), projectRepository); string expectedErrorMessage = String.Format("The '{0}' package requires NuGet client version '{1}' or above, but the current NuGet version is '{2}'.", "A 2.0", requiredVersion.ToString(), nugetVersion.ToString()); // Act && Assert ExceptionAssert.Throws<NuGetVersionNotSatisfiedException>( () => packageManager.UpdatePackage(projectManager, "A", version: null, updateDependencies: true, allowPrereleaseVersions: false, logger: NullLogger.Instance), expectedErrorMessage); }
public void InstallPackagesFromVSExtensionRepositoryInstallsPackages() { // Arrange var extensionId = "myExtensionId"; var extensionManagerMock = new Mock <IVsExtensionManager>(); var extensionMock = new Mock <IInstalledExtension>(); extensionMock.Setup(e => e.InstallPath).Returns(@"C:\Extension\Dir"); var extension = extensionMock.Object; extensionManagerMock.Setup(em => em.TryGetInstalledExtension(extensionId, out extension)).Returns(true); var consoleOutput = new List <string>(); var console = new Mock <NuGetConsole.IConsole>(); console.Setup(c => c.WriteLine(It.IsAny <string>())).Callback <string>(consoleOutput.Add); var consoleProvider = new Mock <IOutputConsoleProvider>(); consoleProvider.Setup(c => c.CreateOutputConsole(It.IsAny <bool>())).Returns(console.Object); var packageId = "A"; var packageVersion = "1.0.0"; var services = new Mock <IVsPackageInstallerServices>(); services.Setup(x => x.IsPackageInstalled(It.IsAny <Project>(), packageId)).Returns(false); 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 packageManager = new Mock <VsPackageManager>( TestUtils.GetSolutionManager(), sourceRepository, new Mock <IFileSystemProvider>().Object, fileSystem, localRepository, new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object, /* multiFrameworkTargeting */ null) { CallBase = true }; var projectManager = new ProjectManager(packageManager.Object, pathResolver, projectSystem, projectRepository); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); var packageRepositoryFactory = new Mock <IPackageRepositoryFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny <IPackageRepository>(), false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager); packageRepositoryFactory.Setup(r => r.CreateRepository(@"x:\test")).Returns(new MockPackageRepository()).Verifiable(); var package = NuGet.Test.PackageUtility.CreatePackage(packageId, packageVersion, new[] { "System" }); sourceRepository.AddPackage(package); var installer = new VsPackageInstaller(packageManagerFactory.Object, null, null, consoleProvider.Object, new Mock <IVsCommonOperations>().Object, new Mock <ISolutionManager>().Object, null, services.Object, extensionManagerMock.Object); var packages = new Dictionary <string, string>(); packages.Add(packageId, packageVersion); // Act Assert.False(localRepository.Exists(packageId, new SemanticVersion(packageVersion))); installer.InstallPackagesFromVSExtensionRepository(extensionId, isPreUnzipped: false, skipAssemblyReferences: false, project: project, packageVersions: packages); // Assert Assert.True(localRepository.Exists(packageId, new SemanticVersion(packageVersion))); }
public void InstallPackageThrowsIfRepositoryIsNull() { // 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 projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, projectRepository); var scriptExecutor = new Mock<IScriptExecutor>(); var packageManager = new Mock<VsPackageManager>( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object, /* multiFrameworkTargeting */ null) { CallBase = true }; var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); var packageRepositoryFactory = new Mock<IPackageRepositoryFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager(It.Is<IPackageRepository>(p => p != null), false)) .Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager); var installer = new VsPackageInstaller(packageManagerFactory.Object, scriptExecutor.Object, packageRepositoryFactory.Object, new Mock<IOutputConsoleProvider>().Object, new Mock<IVsCommonOperations>().Object, new Mock<ISolutionManager>().Object, null, null); // Act && Assert Assert.Throws<ArgumentNullException>( () => installer.InstallPackage(/* repository */ null, project, "foo", "1.0", ignoreDependencies: false, skipAssemblyReferences: true) ); }
public void InstallPackagesFromVSExtensionRepositoryInstallsPackages() { // Arrange var extensionId = "myExtensionId"; var extensionManagerMock = new Mock<IVsExtensionManager>(); var extensionMock = new Mock<IInstalledExtension>(); extensionMock.Setup(e => e.InstallPath).Returns(@"C:\Extension\Dir"); var extension = extensionMock.Object; extensionManagerMock.Setup(em => em.TryGetInstalledExtension(extensionId, out extension)).Returns(true); var consoleOutput = new List<string>(); var console = new Mock<NuGetConsole.IConsole>(); console.Setup(c => c.WriteLine(It.IsAny<string>())).Callback<string>(consoleOutput.Add); var consoleProvider = new Mock<IOutputConsoleProvider>(); consoleProvider.Setup(c => c.CreateOutputConsole(It.IsAny<bool>())).Returns(console.Object); var packageId = "A"; var packageVersion = "1.0.0"; var services = new Mock<IVsPackageInstallerServices>(); services.Setup(x => x.IsPackageInstalled(It.IsAny<Project>(), packageId)).Returns(false); 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 projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, projectRepository); var packageManager = new Mock<VsPackageManager>( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object, /* multiFrameworkTargeting */ null) { CallBase = true }; var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); var packageRepositoryFactory = new Mock<IPackageRepositoryFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager); packageRepositoryFactory.Setup(r => r.CreateRepository(@"x:\test")).Returns(new MockPackageRepository()).Verifiable(); var package = NuGet.Test.PackageUtility.CreatePackage(packageId, packageVersion, new[] { "System" }); sourceRepository.AddPackage(package); var installer = new VsPackageInstaller(packageManagerFactory.Object, null, null, consoleProvider.Object, new Mock<IVsCommonOperations>().Object, new Mock<ISolutionManager>().Object, null, services.Object, extensionManagerMock.Object); var packages = new Dictionary<string, string>(); packages.Add(packageId, packageVersion); // Act Assert.False(localRepository.Exists(packageId, new SemanticVersion(packageVersion))); installer.InstallPackagesFromVSExtensionRepository(extensionId, isPreUnzipped: false, skipAssemblyReferences: false, project: project, packageVersions: packages); // Assert Assert.True(localRepository.Exists(packageId, new SemanticVersion(packageVersion))); }
public void UninstallPackageDoesNotForceRemovesPackages() { // Arrange var activeRepository = new MockPackageRepository(); var localRepository = new Mock<MockPackageRepository>() { CallBase = true }; localRepository.As<ISharedPackageRepository>(); var projectRepository = new MockProjectPackageRepository(localRepository.Object); var project = TestUtils.GetProject("Foo"); var projectSystem = new MockProjectSystem(); var projectManager = new ProjectManager(activeRepository, new DefaultPackagePathResolver(new MockFileSystem()), projectSystem, projectRepository); var packageA = PackageUtility.CreatePackage("A", dependencies: new[] { new PackageDependency("B") }); var packageB = PackageUtility.CreatePackage("B"); var scriptExecutor = new Mock<IScriptExecutor>(MockBehavior.Strict); scriptExecutor.Setup(s => s.Execute(@"C:\MockFileSystem\A.1.0", "uninstall.ps1", packageA, project, It.IsAny<FrameworkName>(), NullLogger.Instance)).Returns(true).Verifiable(); var packageManager = new Mock<VsPackageManager>(TestUtils.GetSolutionManager(), activeRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), localRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object) { CallBase = true }; var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(activeRepository, false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager).Verifiable(); var packageUninstaller = new VsPackageUninstaller(packageManagerFactory.Object, activeRepository, scriptExecutor.Object); // Act and Assert localRepository.Object.AddPackage(packageA); localRepository.Object.AddPackage(packageB); ExceptionAssert.Throws<InvalidOperationException>(() => packageUninstaller.UninstallPackage(project, "B", removeDependencies: true), "Unable to uninstall 'B 1.0' because 'A 1.0' depends on it."); }
public void InstallPackagesFromRegistryRepositoryInstallsDependenciesIfIgnoreDependenciesIsFalse() { // Arrange var registryPath = @"SOFTWARE\NuGet\Repository"; var registryKey = "PreinstalledPackages"; var registryValue = @"C:\PreinstalledPackages"; var hkcu_repository = new Mock<IRegistryKey>(); var hkcu = new Mock<IRegistryKey>(); hkcu_repository.Setup(k => k.GetValue(registryKey)).Returns(registryValue); hkcu.Setup(r => r.OpenSubKey(registryPath)).Returns(hkcu_repository.Object); var consoleOutput = new List<string>(); var console = new Mock<NuGetConsole.IConsole>(); console.Setup(c => c.WriteLine(It.IsAny<string>())).Callback<string>(consoleOutput.Add); var consoleProvider = new Mock<IOutputConsoleProvider>(); consoleProvider.Setup(c => c.CreateOutputConsole(It.IsAny<bool>())).Returns(console.Object); var packageId = "A"; var packageVersion = "1.0.0"; var dependencyPackageId = "B"; var dependencyPackageVersion = "2.0.0"; var services = new Mock<IVsPackageInstallerServices>(); services.Setup(x => x.IsPackageInstalled(It.IsAny<Project>(), packageId)).Returns(false); 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 projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, projectRepository); var packageManager = new Mock<VsPackageManager>( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object, /* multiFrameworkTargeting */ null) { CallBase = true }; var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); var packageRepositoryFactory = new Mock<IPackageRepositoryFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager); packageRepositoryFactory.Setup(r => r.CreateRepository(@"x:\test")).Returns(new MockPackageRepository()).Verifiable(); var package = NuGet.Test.PackageUtility.CreatePackage( packageId, packageVersion, new[] { "System" }, null, null, new[] { new PackageDependency(dependencyPackageId, new VersionSpec(new SemanticVersion(dependencyPackageVersion))) }); var dependencyPackage = NuGet.Test.PackageUtility.CreatePackage( dependencyPackageId, dependencyPackageVersion, new[] { "System.IO" }); sourceRepository.AddPackage(package); sourceRepository.AddPackage(dependencyPackage); var installer = new VsPackageInstaller(packageManagerFactory.Object, null, null, consoleProvider.Object, new Mock<IVsCommonOperations>().Object, new Mock<ISolutionManager>().Object, null, services.Object, registryKeys: new[] { hkcu.Object }); var packages = new Dictionary<string, string>(); packages.Add(packageId, packageVersion); // Act Assert.False(localRepository.Exists(packageId, new SemanticVersion(packageVersion))); installer.InstallPackagesFromRegistryRepository(registryKey, isPreUnzipped: false, skipAssemblyReferences: false, ignoreDependencies: false, project: project, packageVersions: packages); // Assert Assert.True(localRepository.Exists(packageId, new SemanticVersion(packageVersion))); Assert.True(localRepository.Exists(dependencyPackageId, new SemanticVersion(dependencyPackageVersion))); }
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"))); }
public void InstallPackagesFromRegistryRepositoryThrowsWhenPackageIsMissing() { // Arrange var registryPath = @"SOFTWARE\NuGet\Repository"; var registryKey = "PreinstalledPackages"; var registryValue = @"C:\PreinstalledPackages"; var hkcu_repository = new Mock<IRegistryKey>(); var hkcu = new Mock<IRegistryKey>(); hkcu_repository.Setup(k => k.GetValue(registryKey)).Returns(registryValue); hkcu.Setup(r => r.OpenSubKey(registryPath)).Returns(hkcu_repository.Object); var services = new Mock<IVsPackageInstallerServices>(); services.Setup(x => x.IsPackageInstalled(It.IsAny<Project>(), It.IsAny<string>())).Returns(false); 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 projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, projectRepository); var packageManager = new Mock<VsPackageManager>( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object, /* multiFrameworkTargeting */ null) { CallBase = true }; var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); var packageRepositoryFactory = new Mock<IPackageRepositoryFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager); packageRepositoryFactory.Setup(r => r.CreateRepository(@"x:\test")).Returns(new MockPackageRepository()).Verifiable(); var installer = new VsPackageInstaller(packageManagerFactory.Object, null, null, null, new Mock<IVsCommonOperations>().Object, new Mock<ISolutionManager>().Object, null, services.Object, registryKeys: new[] { hkcu.Object }); var packages = new Dictionary<string, string>(); packages.Add("A", "1.0.0"); // Act & Assert var exception = Assert.Throws<InvalidOperationException>(() => installer.InstallPackagesFromRegistryRepository(registryKey, isPreUnzipped: false, skipAssemblyReferences: false, project: project, packageVersions: packages)); Assert.True(exception.Message.Contains("A.1.0.0 : ")); }
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 projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, projectRepository); var scriptExecutor = new Mock<IScriptExecutor>(); var packageManager = new Mock<VsPackageManager>( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object, /* multiFrameworkTargeting */ null) { CallBase = true }; var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManager.As<IVsPackageManager>().SetupGet(m => m.BindingRedirectEnabled).Returns(true); packageManager.As<IVsPackageManager>().SetupSet(m => m.BindingRedirectEnabled = false); packageManager.As<IVsPackageManager>().SetupSet(m => m.BindingRedirectEnabled = true); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager); 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 packageManager.As<IVsPackageManager>().VerifySet(m => m.BindingRedirectEnabled = false, Times.Never()); packageManager.As<IVsPackageManager>().VerifySet(m => m.BindingRedirectEnabled = true, Times.Exactly(2)); }
public void InstallSolutionLevelPackageAddEntryToSolutionPackagesConfig(bool allowPrerelease) { // Arrange // Source repository has A -> B, where B is a project-level package and A is a meta-package. // We want to make sure A is added to the packages.config of the project, and NOT packages.config of the solution var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); var sourceRepository = new MockPackageRepository(); var packageA = PackageUtility.CreatePackage("A", "2.0", tools: new[] { "install.ps1" }); sourceRepository.Add(packageA); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var packageManager = new VsPackageManager( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository.Object, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object); var projectRepository = new MockProjectPackageRepository(localRepository.Object); var projectManager = new ProjectManager(localRepository.Object, pathResolver, projectSystem, projectRepository); localRepository.Setup(r => r.IsReferenced(It.IsAny<string>(), It.IsAny<SemanticVersion>())). Returns((string id, SemanticVersion version) => projectRepository.Exists(id, version)); // Act packageManager.InstallPackage( projectManager, "A", new SemanticVersion("2.0"), ignoreDependencies: false, allowPrereleaseVersions: allowPrerelease, logger: null); // Assert Assert.True(!projectRepository.Exists("A", new SemanticVersion("2.0"))); // assert that packages.config for solution-level is created. localRepository.Verify(r => r.AddPackageReferenceEntry("A", new SemanticVersion("2.0")), Times.Once()); }
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, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var projectManager = new ProjectManager(localRepository.Object, pathResolver, projectSystem, projectRepository); projectManager.AddPackageReference("A", new SemanticVersion("1.0")); // Act packageManager.UpdatePackage(projectManager, "A", version: null, updateDependencies: true, allowPrereleaseVersions: false, logger: NullLogger.Instance); // Assert Assert.False(packageManager.LocalRepository.Exists(A10)); Assert.False(projectSystem.ReferenceExists("A1.dll")); Assert.False(packageManager.LocalRepository.Exists(C10)); Assert.False(projectSystem.ReferenceExists("C1.dll")); Assert.True(packageManager.LocalRepository.Exists(B10)); Assert.True(projectSystem.ReferenceExists("B1.dll")); Assert.True(packageManager.LocalRepository.Exists(A20)); Assert.True(projectSystem.ReferenceExists("A2.dll")); }
public void UpdatePackageNewVersionOfPackageHasLessDependencies() { // 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 // A2 var A10 = PackageUtility.CreatePackage("A", "1.0", assemblyReferences: new[] { "A1.dll" }, dependencies: new[] { new PackageDependency("B", VersionUtility.ParseVersionSpec("1.0")) }); var A20 = PackageUtility.CreatePackage("A", "2.0", assemblyReferences: new[] { "A2.dll" }); var B10 = PackageUtility.CreatePackage("B", "1.0", assemblyReferences: new[] { "B1.dll" }); sourceRepository.AddPackage(A10); sourceRepository.AddPackage(A20); sourceRepository.AddPackage(B10); localRepository.Object.AddPackage(A10); localRepository.Object.AddPackage(A20); localRepository.Object.AddPackage(B10); 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(B10)); Assert.IsFalse(projectSystem.ReferenceExists("B1.dll")); Assert.IsTrue(packageManager.LocalRepository.Exists(A20)); Assert.IsTrue(projectSystem.ReferenceExists("A2.dll")); }
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 InstallMetaPackageDoesNotAddEntryToSolutionPackagesConfig2(bool skipAssemblyReferences) { // Arrange // Source repository has A -> B, where B is a project-level package and A is a meta-package. // We want to make sure A is added to the packages.config of the project, and NOT packages.config of the solution var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); var sourceRepository = new MockPackageRepository(); var packageB = PackageUtility.CreatePackage("B", "1.0", new string[] { "hello.txt" }); var packageA = PackageUtility.CreatePackage("A", "2.0", new string[] { "world" }, dependencies: new[] { new PackageDependency("B") }); sourceRepository.Add(packageA); sourceRepository.Add(packageB); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var packageManager = new VsPackageManager( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var projectRepository = new MockProjectPackageRepository(localRepository.Object); var projectManager = new ProjectManager(localRepository.Object, pathResolver, projectSystem, projectRepository); localRepository.Setup(r => r.IsReferenced(It.IsAny<string>(), It.IsAny<SemanticVersion>())). Returns((string id, SemanticVersion version) => projectRepository.Exists(id, version)); // Act packageManager.InstallPackage( projectManager, "A", new SemanticVersion("2.0"), ignoreDependencies: false, allowPrereleaseVersions: true, skipAssemblyReferences: skipAssemblyReferences, logger: null); // Assert Assert.True(projectRepository.Exists("A", new SemanticVersion("2.0"))); Assert.True(projectRepository.Exists("B", new SemanticVersion("1.0"))); // assert that packages.config for solution-level is not created. Assert.False(localRepository.Object.IsSolutionReferenced("A", new SemanticVersion("2.0"))); Assert.False(localRepository.Object.IsSolutionReferenced("B", new SemanticVersion("1.0"))); }
public void InstallPackagesFromVSExtensionRepositoryThrowsWhenPackageIsMissing() { // Arrange var extensionId = "myExtensionId"; var extensionManagerMock = new Mock<IVsExtensionManager>(); var extensionMock = new Mock<IInstalledExtension>(); extensionMock.Setup(e => e.InstallPath).Returns(@"C:\Extension\Dir"); var extension = extensionMock.Object; extensionManagerMock.Setup(em => em.TryGetInstalledExtension(extensionId, out extension)).Returns(true); var services = new Mock<IVsPackageInstallerServices>(); services.Setup(x => x.IsPackageInstalled(It.IsAny<Project>(), It.IsAny<string>())).Returns(false); 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 projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, projectRepository); var packageManager = new Mock<VsPackageManager>( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object, /* multiFrameworkTargeting */ null) { CallBase = true }; var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); var packageRepositoryFactory = new Mock<IPackageRepositoryFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager); packageRepositoryFactory.Setup(r => r.CreateRepository(@"x:\test")).Returns(new MockPackageRepository()).Verifiable(); var installer = new VsPackageInstaller(packageManagerFactory.Object, null, null, null, new Mock<IVsCommonOperations>().Object, new Mock<ISolutionManager>().Object, null, services.Object, extensionManagerMock.Object); var packages = new Dictionary<string, string>(); packages.Add("A", "1.0.0"); // Act & Assert var exception = Assert.Throws<InvalidOperationException>(() => installer.InstallPackagesFromVSExtensionRepository(extensionId, isPreUnzipped: false, skipAssemblyReferences: false, project: project, packageVersions: packages)); Assert.True(exception.Message.Contains("A.1.0.0 : ")); }
public void InstallPackagesFromRegistryRepositoryInstallsDependenciesIfIgnoreDependenciesIsFalse() { // Arrange var registryPath = @"SOFTWARE\NuGet\Repository"; var registryKey = "PreinstalledPackages"; var registryValue = @"C:\PreinstalledPackages"; var hkcu_repository = new Mock <IRegistryKey>(); var hkcu = new Mock <IRegistryKey>(); hkcu_repository.Setup(k => k.GetValue(registryKey)).Returns(registryValue); hkcu.Setup(r => r.OpenSubKey(registryPath)).Returns(hkcu_repository.Object); var consoleOutput = new List <string>(); var console = new Mock <NuGetConsole.IConsole>(); console.Setup(c => c.WriteLine(It.IsAny <string>())).Callback <string>(consoleOutput.Add); var consoleProvider = new Mock <IOutputConsoleProvider>(); consoleProvider.Setup(c => c.CreateOutputConsole(It.IsAny <bool>())).Returns(console.Object); var packageId = "A"; var packageVersion = "1.0.0"; var dependencyPackageId = "B"; var dependencyPackageVersion = "2.0.0"; var services = new Mock <IVsPackageInstallerServices>(); services.Setup(x => x.IsPackageInstalled(It.IsAny <Project>(), packageId)).Returns(false); 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 packageManager = new Mock <VsPackageManager>( TestUtils.GetSolutionManager(), sourceRepository, new Mock <IFileSystemProvider>().Object, fileSystem, localRepository, new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object, /* multiFrameworkTargeting */ null) { CallBase = true }; var projectManager = new ProjectManager(packageManager.Object, pathResolver, projectSystem, projectRepository); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); var packageRepositoryFactory = new Mock <IPackageRepositoryFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny <IPackageRepository>(), false)).Returns(packageManager.Object); packageManager.Setup(m => m.GetProjectManager(project)).Returns(projectManager); packageRepositoryFactory.Setup(r => r.CreateRepository(@"x:\test")).Returns(new MockPackageRepository()).Verifiable(); var package = NuGet.Test.PackageUtility.CreatePackage( packageId, packageVersion, new[] { "System" }, null, null, new[] { new PackageDependency(dependencyPackageId, new VersionSpec(new SemanticVersion(dependencyPackageVersion))) }); var dependencyPackage = NuGet.Test.PackageUtility.CreatePackage( dependencyPackageId, dependencyPackageVersion, new[] { "System.IO" }); sourceRepository.AddPackage(package); sourceRepository.AddPackage(dependencyPackage); var installer = new VsPackageInstaller(packageManagerFactory.Object, null, null, consoleProvider.Object, new Mock <IVsCommonOperations>().Object, new Mock <ISolutionManager>().Object, null, services.Object, registryKeys: new[] { hkcu.Object }); var packages = new Dictionary <string, string>(); packages.Add(packageId, packageVersion); // Act Assert.False(localRepository.Exists(packageId, new SemanticVersion(packageVersion))); installer.InstallPackagesFromRegistryRepository(registryKey, isPreUnzipped: false, skipAssemblyReferences: false, ignoreDependencies: false, project: project, packageVersions: packages); // Assert Assert.True(localRepository.Exists(packageId, new SemanticVersion(packageVersion))); Assert.True(localRepository.Exists(dependencyPackageId, new SemanticVersion(dependencyPackageVersion))); }