public static GetProject ( string name, string kind = VsConstants.CsharpProjectTypeGuid, IEnumerable |
||
name | string | |
kind | string | |
projectFiles | IEnumerable |
|
propertyGetter | Property>.Func | |
return | Project |
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 InstallPackageIntoWindowsStoreProjectIgnoreAppConfigFile() { // Arrange var sourceRepository = new MockPackageRepository(); var mockFileSystemProvider = new Mock <IFileSystemProvider>(); mockFileSystemProvider.Setup(fs => fs.GetFileSystem(It.IsAny <string>())).Returns(new MockFileSystem()); var project = TestUtils.GetProject("WindowsStore"); var projectSystem = new TestableWindowsStoreProjectSystem(project, mockFileSystemProvider.Object); var pathResolver = new DefaultPackagePathResolver(projectSystem); var package = NuGet.Test.PackageUtility.CreatePackage( "foo", "1.0.0", content: new[] { "readme.txt", "app.config" }); sourceRepository.AddPackage(package); var projectManager = new ProjectManager( sourceRepository, pathResolver, projectSystem, new MockPackageRepository()); // Act projectManager.AddPackageReference(package, ignoreDependencies: false, allowPrereleaseVersions: false); // Assert Assert.True(projectSystem.FileExists("readme.txt")); Assert.False(projectSystem.FileExists("app.config")); }
internal void AddProject(string projectDirectory) { var project = TestUtils.GetProject(projectDirectory); _projects[project.Name] = project; DefaultProjectName = project.Name; }
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 GetPropertyValueUnknownPropertyReturnsNull() { // Arrange VsProjectSystem projectSystem = new VsProjectSystem(TestUtils.GetProject("Name")); // Assert var value = projectSystem.GetPropertyValue("notexist"); // Assert Assert.IsNull(value); }
public void GetOutputPathForWebSite() { // Arrange Project project = TestUtils.GetProject("WebProject", VsConstants.WebSiteProjectTypeGuid); // Act string path = project.GetOutputPath(); // Assert Assert.Equal(@"WebProject\Bin", path); }
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 GetPropertyValueUnknownPropertyReturnsNull() { // Arrange var mockFileSystemProvider = new Mock <IFileSystemProvider>(); mockFileSystemProvider.Setup(fs => fs.GetFileSystem(It.IsAny <string>())).Returns(new MockFileSystem()); VsProjectSystem projectSystem = new VsProjectSystem(TestUtils.GetProject("Name"), mockFileSystemProvider.Object); // Assert var value = projectSystem.GetPropertyValue("notexist"); // Assert Assert.Null(value); }
public void GetPropertyValueThrowsArgumentExceptionReturnsNull() { // Vs throws an argument exception when trying to index into an invalid property // Arrange Project project = TestUtils.GetProject("Name", propertyGetter: name => { throw new ArgumentException(); }); VsProjectSystem projectSystem = new VsProjectSystem(project); // Assert var value = projectSystem.GetPropertyValue("notexist"); // Assert Assert.IsNull(value); }
public void IsFileSupportedRejectsAllVariationsOfAppConfig(string filePath) { // Arrange var mockFileSystemProvider = new Mock <IFileSystemProvider>(); mockFileSystemProvider.Setup(fs => fs.GetFileSystem(It.IsAny <string>())).Returns(new MockFileSystem()); Project project = TestUtils.GetProject("TestProject"); var projectSystem = new WebProjectSystem(project, mockFileSystemProvider.Object); // Act bool supported = projectSystem.IsSupportedFile(filePath); // Assert Assert.False(supported); }
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 UpdatePackageWithProjectManagerSetOperationToUpdate() { // 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( projectManager, "phuong", new SemanticVersion("2.0"), 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 WindowsStoreProjectSystemAcceptAllOtherFiles(string path) { // Arrange var mockFileSystemProvider = new Mock <IFileSystemProvider>(); mockFileSystemProvider.Setup(fs => fs.GetFileSystem(It.IsAny <string>())).Returns(new MockFileSystem()); var project = TestUtils.GetProject("WindowsStore"); var projectSystem = new WindowsStoreProjectSystem(project, mockFileSystemProvider.Object); // Act bool isFileSupported = projectSystem.IsSupportedFile(path); // Assert Assert.True(isFileSupported); }
public void WindowsStoreProjectSystemDoesNotAllowBindingRedirect() { // Arrange var mockFileSystemProvider = new Mock <IFileSystemProvider>(); mockFileSystemProvider.Setup(fs => fs.GetFileSystem(It.IsAny <string>())).Returns(new MockFileSystem()); var project = TestUtils.GetProject("WindowsStore"); var projectSystem = new WindowsStoreProjectSystem(project, mockFileSystemProvider.Object); // Act bool isBindingRedirectSupported = projectSystem.IsBindingRedirectSupported; // Assert Assert.False(isBindingRedirectSupported); }
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 EnsureCheckedOutIfExistsOnReadOnlyFiles() { // Arrange var project = TestUtils.GetProject("Name"); var mockFileSystem = new Mock <IFileSystem>(); var fileName = "testFile"; mockFileSystem.Setup(f => f.GetFullPath(fileName)).Returns(fileName); mockFileSystem.Setup(f => f.FileExists(fileName)).Returns(true); mockFileSystem.Setup(f => f.MakeFileWritable(fileName)); // Act project.EnsureCheckedOutIfExists(mockFileSystem.Object, fileName); // Assert mockFileSystem.Verify(f => f.MakeFileWritable(fileName)); }
public void SilverlightProjectDoesNotSupportsBindingRedirect(string targetFramework) { // Arrange var silverlightProject = TestUtils.GetProject( "Silverlight", propertyGetter: name => GetTargetFrameworkProperty("TargetFrameworkMoniker", targetFramework)); var mockFileSystemProvider = new Mock <IFileSystemProvider>(); mockFileSystemProvider.Setup(fs => fs.GetFileSystem(It.IsAny <string>())).Returns(new MockFileSystem()); var projectSystem = new VsProjectSystem(silverlightProject, mockFileSystemProvider.Object); // Act bool bindingRedirectSupported = projectSystem.IsBindingRedirectSupported; // Assert Assert.False(bindingRedirectSupported); }
public void GetPropertyValueThrowsArgumentExceptionReturnsNull() { // Vs throws an argument exception when trying to index into an invalid property // Arrange var mockFileSystemProvider = new Mock <IFileSystemProvider>(); mockFileSystemProvider.Setup(fs => fs.GetFileSystem(It.IsAny <string>())).Returns(new MockFileSystem()); Project project = TestUtils.GetProject("Name", propertyGetter: name => { throw new ArgumentException(); }); VsProjectSystem projectSystem = new VsProjectSystem(project, mockFileSystemProvider.Object); // Assert var value = projectSystem.GetPropertyValue("notexist"); // Assert Assert.Null(value); }
public void InstallPackagesFromVSExtensionRepositoryRaisesWarningsIfDifferentVersionInstalled() { // 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(true); services.Setup(x => x.IsPackageInstalled(It.IsAny <Project>(), packageId, It.IsAny <SemanticVersion>())).Returns(false); var installer = new VsPackageInstaller(null, 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); var project = TestUtils.GetProject("Foo"); // Act installer.InstallPackagesFromVSExtensionRepository(extensionId, isPreUnzipped: false, skipAssemblyReferences: false, project: project, packageVersions: packages); // Assert Assert.Single(consoleOutput); Assert.True(consoleOutput.Single().Contains(string.Format(NuGet.VisualStudio.Resources.VsResources.PreinstalledPackages_VersionConflict, packageId, 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, 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 InstallPackagesFromRegistryRepositoryRaisesWarningsIfDifferentVersionInstalled() { // 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 services = new Mock <IVsPackageInstallerServices>(); services.Setup(x => x.IsPackageInstalled(It.IsAny <Project>(), packageId)).Returns(true); services.Setup(x => x.IsPackageInstalled(It.IsAny <Project>(), packageId, It.IsAny <SemanticVersion>())).Returns(false); var installer = new VsPackageInstaller(null, 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); var project = TestUtils.GetProject("Foo"); // Act installer.InstallPackagesFromRegistryRepository(registryKey, isPreUnzipped: false, skipAssemblyReferences: false, project: project, packageVersions: packages); // Assert Assert.Single(consoleOutput); Assert.True(consoleOutput.Single().Contains(string.Format(NuGet.VisualStudio.Resources.VsResources.PreinstalledPackages_VersionConflict, packageId, packageVersion))); }
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 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 InstallPackagesFromRegistryRepositoryThrowsRegistryKeyError() { // Arrange var registryPath = @"SOFTWARE\NuGet\Repository"; var registryKey = "PreinstalledPackages"; var hkcu_repository = new Mock <IRegistryKey>(); var hkcu = new Mock <IRegistryKey>(); hkcu.Setup(r => r.OpenSubKey(registryPath)).Returns((IRegistryKey)null); var project = TestUtils.GetProject("Foo"); var installer = new VsPackageInstaller(null, null, null, null, null, null, null, null, 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.Equal(string.Format(NuGet.VisualStudio.Resources.VsResources.PreinstalledPackages_RegistryKeyError, registryPath), exception.Message); }
public void InstallPackagesFromVSExtensionRepositoryThrowsExtensionError() { // Arrange var extensionId = "myExtensionId"; var project = TestUtils.GetProject("Foo"); var extensionManagerMock = new Mock <IVsExtensionManager>(); IInstalledExtension extension = null; extensionManagerMock.Setup(em => em.TryGetInstalledExtension(extensionId, out extension)).Returns(false); var installer = new VsPackageInstaller(null, null, null, null, null, null, null, null, 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.Equal(string.Format(NuGet.VisualStudio.Resources.VsResources.PreinstalledPackages_InvalidExtensionId, extensionId), exception.Message); }
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()); }