|
public static GetSolutionManager ( bool isSolutionOpen = true, string defaultProjectName = null, IEnumerable |
||
| isSolutionOpen | bool | |
| defaultProjectName | string | |
| projects | IEnumerable |
|
| Résultat | ISolutionManager | |
public void InstallPackageSetOperationToInstall3()
{
// Arrange
var localRepository = new MockSharedPackageRepository();
var sourceRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository());
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock <IFileSystemProvider>().Object, projectSystem, localRepository, new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object);
var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" });
sourceRepository.AddPackage(package);
var package2 = PackageUtility.CreatePackage("bar", "2.0", new[] { "world" });
sourceRepository.AddPackage(package2);
// Act
packageManager.InstallPackage(
projectManager,
package2,
new PackageOperation[] {
new PackageOperation(package, PackageAction.Install),
new PackageOperation(package2, PackageAction.Install),
},
ignoreDependencies: false,
allowPrereleaseVersions: false,
logger: NullLogger.Instance);
// Assert
Assert.Equal("Install", sourceRepository.LastOperation);
Assert.Equal("bar", sourceRepository.LastMainPackageId);
Assert.Equal("2.0", sourceRepository.LastMainPackageVersion);
}
public void UpdatePackagesSetOperationToUpdate1()
{
// Arrange
var localRepository = new MockSharedPackageRepository();
var sourceRepository = new MockPackageRepository();
var projectRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), projectRepository);
var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock <IFileSystemProvider>().Object, projectSystem, localRepository, new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object);
var package = PackageUtility.CreatePackage("phuong", "1.0", new[] { "hello" });
localRepository.AddPackage(package);
projectRepository.AddPackage(package);
var package2 = PackageUtility.CreatePackage("phuong", "2.0", new[] { "hello" });
sourceRepository.AddPackage(package2);
// Act
packageManager.UpdatePackages(
projectManager,
updateDependencies: true,
allowPrereleaseVersions: true,
logger: NullLogger.Instance);
// Assert
Assert.Equal("Update", sourceRepository.LastOperation);
Assert.Equal("phuong", sourceRepository.LastMainPackageId);
Assert.Equal("2.0", sourceRepository.LastMainPackageVersion);
}
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 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 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 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 UpdatePackageWithVersionSpecSetOperationToUpdate()
{
// Arrange
var localRepository = new MockSharedPackageRepository();
var sourceRepository = new MockPackageRepository();
var projectRepository = new MockPackageRepository();
var projectSystem = new MockProjectSystem();
var pathResolver = new DefaultPackagePathResolver(projectSystem);
var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), projectRepository);
var project = TestUtils.GetProject("project runway", projectFiles: new[] { "dotnetjunky.cs" });
var packageManager = new MockVsPackageManager(
TestUtils.GetSolutionManager(defaultProjectName: "project runway", projects: new[] { project }),
sourceRepository,
new Mock <IFileSystemProvider>().Object,
projectSystem,
localRepository,
new Mock <IDeleteOnRestartManager>().Object,
new Mock <VsPackageInstallerEvents>().Object);
packageManager.RegisterProjectManager(project, projectManager);
var package = PackageUtility.CreatePackage("phuong", "1.0", new[] { "hello" });
localRepository.AddPackage(package);
projectRepository.AddPackage(package);
var package2 = PackageUtility.CreatePackage("phuong", "2.0", new[] { "hello" });
sourceRepository.AddPackage(package2);
// Act
packageManager.UpdatePackage(
"phuong",
new VersionSpec(new SemanticVersion("1.0")),
updateDependencies: true,
allowPrereleaseVersions: true,
logger: NullLogger.Instance,
eventListener: new Mock <IPackageOperationEventListener>().Object);
// Assert
Assert.Equal("Update", sourceRepository.LastOperation);
Assert.Equal("phuong", sourceRepository.LastMainPackageId);
Assert.Null(sourceRepository.LastMainPackageVersion);
}
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 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 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 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 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)));
}
