public void InstallPackageWithOperationsExecuteAllOperations() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository()); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, projectSystem, localRepository, new Mock<IRecentPackageRepository>().Object); var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }, dependencies: new PackageDependency[] { new PackageDependency("bar") }); sourceRepository.AddPackage(package); var package2 = PackageUtility.CreatePackage("bar", "2.0", new[] { "world" }); sourceRepository.AddPackage(package2); var package3 = PackageUtility.CreatePackage("awesome", "1.0", new[] { "candy" }); localRepository.AddPackage(package3); var operations = new PackageOperation[] { new PackageOperation(package, PackageAction.Install), new PackageOperation(package2, PackageAction.Install), new PackageOperation(package3, PackageAction.Uninstall) }; // Act packageManager.InstallPackage(projectManager, package, operations, ignoreDependencies: false, logger: NullLogger.Instance); // Assert Assert.IsTrue(packageManager.LocalRepository.Exists(package)); Assert.IsTrue(packageManager.LocalRepository.Exists(package2)); Assert.IsTrue(!packageManager.LocalRepository.Exists(package3)); Assert.IsTrue(projectManager.LocalRepository.Exists(package)); Assert.IsTrue(projectManager.LocalRepository.Exists(package2)); }
public void ReverseDependencyWalkerUsersVersionAndIdToDetermineVisited() { // Arrange // A 1.0 -> B 1.0 IPackage packageA1 = PackageUtility.CreatePackage("A", "1.0", dependencies: new List<PackageDependency> { PackageDependency.CreateDependency("B", "[1.0]") }); // A 2.0 -> B 2.0 IPackage packageA2 = PackageUtility.CreatePackage("A", "2.0", dependencies: new List<PackageDependency> { PackageDependency.CreateDependency("B", "[2.0]") }); IPackage packageB1 = PackageUtility.CreatePackage("B", "1.0"); IPackage packageB2 = PackageUtility.CreatePackage("B", "2.0"); var mockRepository = new MockPackageRepository(); mockRepository.AddPackage(packageA1); mockRepository.AddPackage(packageA2); mockRepository.AddPackage(packageB1); mockRepository.AddPackage(packageB2); // Act IDependentsResolver lookup = new DependentsWalker(mockRepository); // Assert Assert.Equal(0, lookup.GetDependents(packageA1).Count()); Assert.Equal(0, lookup.GetDependents(packageA2).Count()); Assert.Equal(1, lookup.GetDependents(packageB1).Count()); Assert.Equal(1, lookup.GetDependents(packageB2).Count()); }
private static MockPackageRepository CreateMockRepository() { var mockRepo = new MockPackageRepository(); mockRepo.AddPackage(PackageUtility.CreatePackage("Test1", isLatest: true, assemblyReferences: new List<string> { "Assembly11.dll", "Assembly12.dll" }, dependencies: new List<PackageDependency> { new PackageDependency("Test2") })); mockRepo.AddPackage(PackageUtility.CreatePackage("Test2", isLatest: true, assemblyReferences: new List<string> { "Assembly21.dll", "Assembly22.dll" }, dependencies: new List<PackageDependency> { new PackageDependency("Test1") })); return mockRepo; }
public void CanExecuteReturnsCorrectResult() { // Local repository contains Package A and Package B // We test the CanExecute() method on Package A and Package C // Arrange var repository = new MockPackageRepository(); var packageA = PackageUtility.CreatePackage("A", "1.0"); repository.AddPackage(packageA); var packageB = PackageUtility.CreatePackage("B", "2.0"); repository.AddPackage(packageB); var packageC = PackageUtility.CreatePackage("C", "2.0"); var projectManager = new Mock<IProjectManager>(); projectManager.Setup(p => p.IsInstalled(It.IsAny<IPackage>())).Returns<IPackage>(p => repository.Exists(p)); var provider = CreateInstalledProvider(null, projectManager.Object); var extensionA = new PackageItem(provider, packageA, null); var extensionC = new PackageItem(provider, packageC, null); // Act bool canExecuteA = provider.CanExecute(extensionA); bool canExecuteC = provider.CanExecute(extensionC); // Assert Assert.IsTrue(canExecuteA); Assert.IsFalse(canExecuteC); }
public static MockPackageRepository CreateMockRepository() { var mockRepo = new MockPackageRepository(); mockRepo.AddPackage(PackageUtility.CreatePackage(PackageInRepository, isLatest: true, assemblyReferences: new List<string> { AssemblyFilenameInPackageRepository, "Assembly12.dll" }, dependencies: new List<PackageDependency>())); mockRepo.AddPackage(PackageUtility.CreatePackage("Test2", isLatest: true, assemblyReferences: new List<string> { AnotherAssemblyInPackageRepository, "Assembly22.dll" }, dependencies: new List<PackageDependency> { new PackageDependency(PackageInRepository) })); return mockRepo; }
public void GetPackagesReturnsUpdatesWhenThereAreMultipleVersionsOfTheSamePackageId() { // Arrange var localRepository = new MockPackageRepository(); var sourceRepository = new MockServiceBasePackageRepository(); UpdatesTreeNode node = CreateUpdatesTreeNode(localRepository, sourceRepository, includePrerelease: false); localRepository.AddPackage(PackageUtility.CreatePackage("A", "9.0-rtm")); localRepository.AddPackage(PackageUtility.CreatePackage("B", "1.0")); localRepository.AddPackage(PackageUtility.CreatePackage("A", "9.0")); localRepository.AddPackage(PackageUtility.CreatePackage("A", "10.0")); sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "9.5")); sourceRepository.AddPackage(PackageUtility.CreatePackage("B", "4.0-beta")); sourceRepository.AddPackage(PackageUtility.CreatePackage("C", "1.2.3.4-alpha")); // Act var packages = node.GetPackages(searchTerm: null, allowPrereleaseVersions: true).ToList(); // Assert Assert.Equal(2, packages.Count); AssertPackage(packages[0], "A", "9.5"); AssertPackage(packages[1], "B", "4.0-beta"); }
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 InstallMetadataPackageWithReadMeInstallsIntoProjectAndPackageManager() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository()); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B") }); var mockPackageA = Mock.Get(packageA); mockPackageA.Setup(m => m.GetFiles()).Returns(PackageUtility.CreateFiles(new[] { "readme.txt" })); var packageB = PackageUtility.CreatePackage("B", "1.0", content: new[] { "hello.txt" }); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageB); // Act packageManager.InstallPackage(projectManager, "A", new SemanticVersion("1.0"), ignoreDependencies: false, allowPrereleaseVersions: false, logger: NullLogger.Instance); // Assert Assert.True(packageManager.LocalRepository.Exists(packageA)); Assert.True(projectManager.LocalRepository.Exists(packageA)); Assert.True(packageManager.LocalRepository.Exists(packageB)); Assert.True(projectManager.LocalRepository.Exists(packageB)); }
public void GetUpdatesReturnAllPackageVersionsWhenFlagIsSpecified() { // Arrange var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "1.0", new string[] { "hello" })); sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "2.0", new string[] { "hello" })); sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "3.0", new string[] { "hello" })); sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "3.0-alpha", new string[] { "hello" })); var packages = new IPackage[] { PackageUtility.CreatePackage("A", "1.5") }; // Act var foundPackages = PackageRepositoryExtensions.GetUpdates(sourceRepository, packages, includePrerelease: true, includeAllVersions: true).ToList(); // Assert Assert.Equal(3, foundPackages.Count); Assert.Equal("A", foundPackages[0].Id); Assert.Equal(new SemanticVersion("2.0"), foundPackages[0].Version); Assert.Equal("A", foundPackages[1].Id); Assert.Equal(new SemanticVersion("3.0"), foundPackages[1].Version); Assert.Equal("A", foundPackages[2].Id); Assert.Equal(new SemanticVersion("3.0-alpha"), foundPackages[2].Version); }
public void AfterPackageWalkMetaPackageIsClassifiedTheSameAsDependencies() { // Arrange var mockRepository = new MockPackageRepository(); var walker = new TestWalker(mockRepository); IPackage metaPackage = PackageUtility.CreatePackage("A", "1.0", dependencies: new List<PackageDependency> { new PackageDependency("B"), new PackageDependency("C") }); IPackage projectPackageA = PackageUtility.CreatePackage("B", "1.0", content: new[] { "contentB" }); IPackage projectPackageB = PackageUtility.CreatePackage("C", "1.0", content: new[] { "contentC" }); mockRepository.AddPackage(projectPackageA); mockRepository.AddPackage(projectPackageB); Assert.AreEqual(PackageTargets.None, walker.GetPackageInfo(metaPackage).Target); // Act walker.Walk(metaPackage); // Assert Assert.AreEqual(PackageTargets.Project, walker.GetPackageInfo(metaPackage).Target); }
public void ExecuteMethodCallsInstallPackageMethodOnPackageManager() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageB = PackageUtility.CreatePackage("B", "2.0"); var packageC = PackageUtility.CreatePackage("C", "3.0"); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageB); var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA); var projectManager = new Mock<IProjectManager>(); projectManager.Setup(p => p.LocalRepository).Returns(localRepository); var packageManager = new Mock<IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); var provider = CreateOnlineProvider(packageManager.Object, projectManager.Object); var extensionTree = provider.ExtensionsTree; var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0]; firstTreeNode.Repository.AddPackage(packageA); firstTreeNode.Repository.AddPackage(packageB); firstTreeNode.Repository.AddPackage(packageC); provider.SelectedNode = firstTreeNode; IVsPackageManager activePackageManager = provider.GetActivePackageManager(); Mock<IVsPackageManager> mockPackageManager = Mock.Get<IVsPackageManager>(activePackageManager); ManualResetEvent manualEvent = new ManualResetEvent(false); provider.ExecuteCompletedCallback = delegate { // Assert mockPackageManager.Verify(p => p.InstallPackage(projectManager.Object, packageB, It.IsAny<IEnumerable<PackageOperation>>(), false, provider), Times.Once()); manualEvent.Set(); }; var extensionB = new PackageItem(provider, packageB, null); // Act provider.Execute(extensionB); // do not allow the method to return manualEvent.WaitOne(); }
public void InstallPackageUsesProjectTargetFramework() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework, Version=4.5")); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, new MockPackageRepository()); var packageManager = new VsPackageManager( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object); var dependencySets = new PackageDependencySet[] { new PackageDependencySet( new FrameworkName(".NETFramework, Version=4.5"), new [] { new PackageDependency("B") }), new PackageDependencySet( new FrameworkName(".NETFramework, Version=4.0"), new [] { new PackageDependency("C") }) }; var package = PackageUtility.CreatePackageWithDependencySets( "foo", "1.0", new[] { "hello" }, dependencySets: dependencySets); var packageB = PackageUtility.CreatePackage("B", "2.0", new[] { "good morning" }); var packageC = PackageUtility.CreatePackage("C", "2.0", new[] { "good morning" }); sourceRepository.AddPackage(package); sourceRepository.AddPackage(packageB); sourceRepository.AddPackage(packageC); // Act packageManager.InstallPackage(projectManager, "foo", new SemanticVersion("1.0"), ignoreDependencies: false, allowPrereleaseVersions: false, logger: NullLogger.Instance); // Assert Assert.True(packageManager.LocalRepository.Exists(package)); Assert.True(packageManager.LocalRepository.Exists(packageB)); Assert.False(packageManager.LocalRepository.Exists(packageC)); Assert.True(projectManager.LocalRepository.Exists(package)); Assert.True(projectManager.LocalRepository.Exists(packageB)); }
public void AddPackageReferencePreferPackagesProjectNameConfigOverNormalConfig() { // Arrange var sourceRepository = new MockPackageRepository(); IPackage packageA = PackageUtility.CreatePackage( "A", "1.0", assemblyReferences: new[] { "lib\\a.dll" }); sourceRepository.AddPackage(packageA); IPackage packageB = PackageUtility.CreatePackage( "B", "1.0", assemblyReferences: new[] { "lib\\b.dll" }); sourceRepository.AddPackage(packageB); IPackage packageC = PackageUtility.CreatePackage( "C", "1.0", assemblyReferences: new[] { "lib\\c.dll" }); sourceRepository.AddPackage(packageC); var projectSystem = new MockProjectSystem( new FrameworkName(".NETFramework, Version=4.5")); projectSystem.ProjectName = "CoolProject"; projectSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""B"" version=""1.0"" /> </packages>"); projectSystem.AddFile("packages.CoolProject.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""C"" version=""1.0"" /> </packages>"); var localRepository = new MockPackageRepository(); var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository); localRepository.AddPackage(packageC); // Act projectManager.AddPackageReference("A"); // Assert Assert.True(projectManager.LocalRepository.Exists("A")); Assert.True(projectManager.LocalRepository.Exists("C")); Assert.True(projectManager.Project.FileExists("packages.CoolProject.config")); Assert.True(projectManager.Project.FileExists("packages.config")); }
public void GetPackagesReturnPrereleasePackages() { // Arrange MockPackageRepository repository = new MockPackageRepository(); int numberOfPackages = 3; IPackage[] packages = new IPackage[numberOfPackages]; for (int i = 0; i < numberOfPackages; i++) { packages[i] = PackageUtility.CreatePackage("A" + i, "1.0-alpha"); repository.AddPackage(packages[i]); } SimpleTreeNode node = CreateSimpleTreeNode(repository); // Act var producedPackages = node.GetPackages(allowPrereleaseVersions: true).ToList(); // Assert Assert.Equal(packages.Length, producedPackages.Count); for (int i = 0; i < numberOfPackages; i++) { Assert.Same(packages[i], producedPackages[i]); } }
public void AddPackageReferenceAppliesPackageReferencesCorrectly2() { // Arrange var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework, Version=4.5")); var projectManager = new ProjectManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, new MockPackageRepository()); IPackage packageA = PackageUtility.CreatePackage( "A", "1.0", assemblyReferences: new[] { "lib\\net35\\a.dll", "lib\\net35\\b.dll" }); sourceRepository.AddPackage(packageA); Mock<IPackage> mockPackageA = Mock.Get<IPackage>(packageA); mockPackageA.Setup(m => m.PackageAssemblyReferences).Returns( new PackageReferenceSet[] { new PackageReferenceSet(VersionUtility.ParseFrameworkName("net40"), new [] { "a.dll" }), new PackageReferenceSet(VersionUtility.ParseFrameworkName("net45"), new [] { "b.dll" }) } ); // Act projectManager.AddPackageReference("A"); // Assert Assert.True(projectManager.LocalRepository.Exists("A")); Assert.False(projectSystem.ReferenceExists("a.dll")); Assert.True(projectSystem.ReferenceExists("b.dll")); }
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 AddPackageWithXdtTransformFile() { // Arrange var mockProjectSystem = new MockProjectSystem(); var mockRepository = new MockPackageRepository(); mockProjectSystem.AddFile("web.config", @"<configuration> <system.web> <compilation debug=""true"" /> </system.web> </configuration> ".AsStream()); var projectManager = new ProjectManager(mockRepository, new DefaultPackagePathResolver(new MockProjectSystem()), mockProjectSystem, new MockPackageRepository()); var package = new Mock<IPackage>(); package.Setup(m => m.Id).Returns("A"); package.Setup(m => m.Version).Returns(new SemanticVersion("1.0")); package.Setup(m => m.Listed).Returns(true); var file = new Mock<IPackageFile>(); file.Setup(m => m.Path).Returns(@"content\web.config.install.xdt"); file.Setup(m => m.EffectivePath).Returns("web.config.install.xdt"); file.Setup(m => m.GetStream()).Returns(() => @"<configuration xmlns:xdt=""http://schemas.microsoft.com/XML-Document-Transform""> <system.web> <compilation xdt:Locator=""Condition('@debug=true')"" debug=""false"" xdt:Transform=""Replace"" /> </system.web> </configuration>".AsStream()); var file2 = new Mock<IPackageFile>(); file2.Setup(m => m.Path).Returns(@"content\web.config.uninstall.xdt"); file2.Setup(m => m.EffectivePath).Returns("web.config.uninstall.xdt"); file2.Setup(m => m.GetStream()).Returns(() => @"<configuration xmlns:xdt=""http://schemas.microsoft.com/XML-Document-Transform""> <system.web> <compilation xdt:Locator=""Match(debug)"" debug=""false"" xdt:Transform=""Remove"" /> </system.web> </configuration>".AsStream()); package.Setup(m => m.GetFiles()).Returns(new[] { file.Object, file2.Object }); mockRepository.AddPackage(package.Object); // Act projectManager.AddPackageReference("A"); // Assert Assert.False(mockProjectSystem.FileExists("web.config.install.xdt")); Assert.False(mockProjectSystem.FileExists("web.config.uninstall.xdt")); Assert.True(mockProjectSystem.FileExists("web.config")); Assert.Equal( @"<configuration> <system.web> <compilation debug=""false""/> </system.web> </configuration> ", mockProjectSystem.OpenFile("web.config").ReadToEnd()); }
public void ExternalPackagesThatDepdendOnProjectLevelPackagesThrows() { // Arrange var mockRepository = new MockPackageRepository(); var walker = new TestWalker(mockRepository); IPackage solutionPackage = PackageUtility.CreatePackage("A", "1.0", dependencies: new List<PackageDependency> { new PackageDependency("B") }, tools: new[] { "install.ps1" }); IPackage projectPackageA = PackageUtility.CreatePackage("B", "1.0", content: new[] { "contentB" }); mockRepository.AddPackage(projectPackageA); mockRepository.AddPackage(solutionPackage); // Act && Assert ExceptionAssert.Throws<InvalidOperationException>(() => walker.Walk(solutionPackage), "External packages cannot depend on packages that target projects."); }
public void CanDetectMissingVersionAndUpdateToValid() { var fileSystem = new MockFileSystem(@"d:\"); fileSystem.AddFile(@"d:\test\packages.config", "<packages>" + "<package id=\"Test\" version=\"1.0.0.0\" />" + "<package id=\"Other\" version=\"1.0.0.0\" />" + "</packages>"); var repository = new MockPackageRepository("http://test.com"); repository.AddPackage(PackageUtility.CreatePackage("Test", "2.0.0.0")); repository.AddPackage(PackageUtility.CreatePackage("Other", "1.0.0.0")); var command = new FixReferences(fileSystem, repository, new Console()) {Directory = @"d:\test"}; command.Execute(); var packageReferences = new PackageReferenceFile(fileSystem, @"d:\test\packages.config").GetPackageReferences().ToList(); Assert.AreEqual("2.0.0.0", packageReferences.First(p => p.Id == "Test").Version.Version.ToString()); Assert.AreEqual("1.0.0.0", packageReferences.First(p => p.Id == "Other").Version.Version.ToString()); }
public void GetPackagesReturnsCorrectPackages3() { // Arrange MockPackageRepository localRepository = new MockPackageRepository(); MockPackageRepository sourceRepository = new MockPackageRepository(); UpdatesTreeNode node = CreateSimpleTreeNode(localRepository, sourceRepository); localRepository.AddPackage(PackageUtility.CreatePackage("A", "1.0")); sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "1.5")); sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "0.9")); // Act var packages = node.GetPackages().ToList(); // Assert Assert.AreEqual(1, packages.Count); AssertPackage(packages[0], "A", "1.5"); }
public void GetPackagesIngoresLowerVersions() { // Arrange MockPackageRepository localRepository = new MockPackageRepository(); MockPackageRepository sourceRepository = new MockPackageRepository(); UpdatesTreeNode node = CreateUpdatesTreeNode(localRepository, sourceRepository, includePrerelease: false); localRepository.AddPackage(PackageUtility.CreatePackage("A", "1.0")); sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "1.5")); sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "0.9")); // Act var packages = node.GetPackages(searchTerm: null, allowPrereleaseVersions: true).ToList(); // Assert Assert.Equal(1, packages.Count); AssertPackage(packages[0], "A", "1.5"); }
public void GetPackagesReturnsUpdatesIgnoreConstraintIfConstraintIsNull() { // Arrange var localRepository = new Mock<IPackageRepository>(); localRepository.Setup(l => l.GetPackages()).Returns(new IPackage[] { PackageUtility.CreatePackage("A", "1.0") }.AsQueryable()); Mock<IPackageConstraintProvider> constraintProvider = localRepository.As<IPackageConstraintProvider>(); constraintProvider.Setup(c => c.GetConstraint("A")).Returns((IVersionSpec)null); MockPackageRepository sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "1.5")); sourceRepository.AddPackage(PackageUtility.CreatePackage("A", "2.5")); UpdatesTreeNode node = CreateUpdatesTreeNode(localRepository.Object, sourceRepository, includePrerelease: false); // Act var packages = node.GetPackages(searchTerm: null, allowPrereleaseVersions: true).ToList(); // Assert Assert.Equal(1, packages.Count); AssertPackage(packages[0], "A", "2.5"); }
public static void GetPackagesToBeReinstalledWhenProjectKindIsNull() { // Arrange Mock<Project> mockProject = new Mock<Project>(); MockPackageRepository localRepository = new MockPackageRepository(); localRepository.AddPackage(PackageUtility.CreatePackage("A")); // Act var packagesToBeReinstalled = ProjectRetargetingUtility.GetPackagesToBeReinstalled(mockProject.Object, localRepository); // Assert Assert.True(packagesToBeReinstalled.IsEmpty()); }
public void CanExecuteReturnsCorrectResult() { // Local repository contains Package A 1.0 and Package B // Source repository contains Package A 2.0 and Package C var packageA1 = PackageUtility.CreatePackage("A", "1.0"); var packageA2 = PackageUtility.CreatePackage("A", "2.0"); var packageB = PackageUtility.CreatePackage("B", "2.0"); var packageC = PackageUtility.CreatePackage("C", "3.0"); // Arrange var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA1); localRepository.AddPackage(packageB); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA2); sourceRepository.AddPackage(packageC); var projectManager = new Mock<IProjectManager>(); projectManager.Setup(p => p.LocalRepository).Returns(localRepository); var packageManager = new Mock<IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); var provider = CreateUpdatesProvider(packageManager.Object, projectManager.Object); var extensionA = new PackageItem(provider, packageA2, null); var extensionC = new PackageItem(provider, packageC, null); // Act bool canExecuteA = provider.CanExecute(extensionA); bool canExecuteC = provider.CanExecute(extensionC); // Assert Assert.IsTrue(canExecuteA); Assert.IsFalse(canExecuteC); }
public void CanExecuteReturnsCorrectResult() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageB = PackageUtility.CreatePackage("B", "2.0"); var packageC = PackageUtility.CreatePackage("C", "3.0"); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageB); var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA); var projectManager = new Mock<IProjectManager>(); projectManager.Setup(p => p.IsInstalled(It.IsAny<IPackage>())).Returns<IPackage>(p => localRepository.Exists(p)); var packageManager = new Mock<IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); var provider = CreateOnlineProvider(packageManager.Object, projectManager.Object); var extensionA = new PackageItem(provider, packageA, null); var extensionB = new PackageItem(provider, packageB, null); var extensionC = new PackageItem(provider, packageC, null); // Act bool canExecuteA = provider.CanExecute(extensionA); bool canExecuteB = provider.CanExecute(extensionB); bool canExecuteC = provider.CanExecute(extensionC); // Assert Assert.IsTrue(canExecuteC); Assert.IsTrue(canExecuteB); Assert.IsFalse(canExecuteA); }
public IPackageRepositoryFactory CreatePackageRepositoryFactory() { //Default Repository MockPackageRepository defaultPackageRepository = new MockPackageRepository(); var packageA = PackageUtility.CreatePackage("DefaultUrlUsed", "1.0"); defaultPackageRepository.AddPackage(packageA); var packageC = PackageUtility.CreatePackage("SearchPackage", "1.0"); defaultPackageRepository.AddPackage(packageC); var packageD = PackageUtility.CreatePackage("AnotherTerm", "1.0"); defaultPackageRepository.AddPackage(packageD); //Nondefault Repository (Custom URL) MockPackageRepository nondefaultPackageRepository = new MockPackageRepository(); var packageB = PackageUtility.CreatePackage("CustomUrlUsed", "1.0"); nondefaultPackageRepository.AddPackage(packageB); // Repo with multiple versions var multiVersionRepo = new MockPackageRepository(); multiVersionRepo.AddPackage(PackageUtility.CreatePackage("NHibernate", "1.0")); multiVersionRepo.AddPackage(PackageUtility.CreatePackage("NHibernate", "1.1")); multiVersionRepo.AddPackage(PackageUtility.CreatePackage("NHibernate", "1.2")); multiVersionRepo.AddPackage(PackageUtility.CreatePackage("jQuery", "1.44")); multiVersionRepo.AddPackage(PackageUtility.CreatePackage("jQuery", "1.50")); //Setup Factory var packageRepositoryFactory = new Mock<IPackageRepositoryFactory>(); packageRepositoryFactory.Setup(p => p.CreateRepository(It.IsAny<PackageSource>())).Returns<PackageSource>(s => { switch (s.Source) { case NonDefaultRepoUrl1: return nondefaultPackageRepository; case NonDefaultRepoUrl2: return multiVersionRepo; default: return defaultPackageRepository; } }); //Return the Factory return packageRepositoryFactory.Object; }
public void CreatePackageMananagerForPackageRestoreUsesPackageRestoreRepositoryWithAggregateSecondary() { // Arrange var mockRepositoryFactory = new Mock<IPackageRepositoryFactory>(); var mockSourceProvider = new Mock<IVsPackageSourceProvider>(); var mockFileSystemProvider = new Mock<IFileSystemProvider>(); var mockRepository1 = new MockPackageRepository("Source1"); var mockRepository2 = new MockPackageRepository("Source2"); var mockRepository3 = new MockPackageRepository("Source3"); var source1 = new PackageSource("Source1"); var source2 = new PackageSource("Source2"); var source3 = new PackageSource("Source3"); mockRepository1.AddPackage(PackageUtility.CreatePackage("A", "1.0")); mockRepository2.AddPackage(PackageUtility.CreatePackage("A", "1.2")); mockRepository3.AddPackage(PackageUtility.CreatePackage("A", "1.4")); mockSourceProvider.Setup(m => m.LoadPackageSources()).Returns(new[] { source1, source2, source3 }); mockFileSystemProvider.Setup(f => f.GetFileSystem(It.IsAny<string>())).Returns(new MockFileSystem()); mockRepositoryFactory.Setup(m => m.CreateRepository(It.IsAny<string>())).Returns<string>(s => { switch (s) { case "Source1": return mockRepository1; case "Source2": return mockRepository2; case "Source3": return mockRepository3; default: return null; } }); var packageManagerFactory = new Mock<VsPackageManagerFactory>(new Mock<ISolutionManager>().Object, mockRepositoryFactory.Object, mockSourceProvider.Object, mockFileSystemProvider.Object, new Mock<IRepositorySettings>().Object, new Mock<VsPackageInstallerEvents>().Object, mockRepository1, null); packageManagerFactory.Setup(f => f.GetConfigSettingsFileSystem(It.IsAny<string>())).Returns(new MockFileSystem()); // Act var packageManager = packageManagerFactory.Object.CreatePackageManagerWithAllPackageSources(mockRepository1); // Assert Assert.IsType(typeof(PriorityPackageRepository), packageManager.SourceRepository); var packageRestoreRepository = (PriorityPackageRepository)packageManager.SourceRepository; Assert.Equal(mockRepository1, packageRestoreRepository.PrimaryRepository); Assert.IsType(typeof(AggregateRepository), packageRestoreRepository.SecondaryRepository); var secondaryRepository = (AggregateRepository)packageRestoreRepository.SecondaryRepository; var secondaryRepositories = secondaryRepository.Repositories.ToList(); Assert.Equal(2, secondaryRepositories.Count); Assert.Equal(mockRepository2, secondaryRepositories[0]); Assert.Equal(mockRepository3, secondaryRepositories[1]); }
public void InstallingPackageWithUnknownDependencyAndIgnoreDepencenciesInstallsPackageWithoutDependencies() { // Arrange var localRepository = new MockPackageRepository(); var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository); IPackage packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new List<PackageDependency> { new PackageDependency("C") }); IPackage packageC = PackageUtility.CreatePackage("C", "1.0"); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageC); // Act packageManager.InstallPackage("A", version: null, ignoreDependencies: true, allowPrereleaseVersions: true); // Assert Assert.True(localRepository.Exists(packageA)); Assert.False(localRepository.Exists(packageC)); }
public void GetPackagesWithUpdatesTest() { // Arrange var siteRoot = "x:\\"; var localRepository = new MockPackageRepository(); var sourceRepository = new MockServiceBasePackageRepository(); var projectSystem = new WebProjectSystem(siteRoot); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(sourceRepository, pathResolver, projectSystem, localRepository); var net40 = new FrameworkName(".NETFramework", new Version("4.0.0.0")); var net45 = new FrameworkName(".NETFramework", new Version("4.5.0.0")); IPackage packageA1 = PackageFactory.Create("A", new Version("1.0"), null); IPackage packageA2 = PackageFactory.Create("A", new Version("2.0"), null, new FrameworkName[] { net45 }); IPackage packageB1 = PackageFactory.Create("B", new Version("1.0"), null); IPackage packageB2 = PackageFactory.Create("B", new Version("2.0"), null, new FrameworkName[] { net40 }); sourceRepository.AddPackage(packageA1); sourceRepository.AddPackage(packageA2); sourceRepository.AddPackage(packageB1); sourceRepository.AddPackage(packageB2); localRepository.AddPackage(packageA1); localRepository.AddPackage(packageB1); // NOTE THAT target framework used by WebProjectManager would be .NETFramework, Version=4.0.0.0 var webProjectManager = new WebProjectManager(projectManager, siteRoot); // Act var packages = webProjectManager.GetPackagesWithUpdates(null, false).ToList(); // Assert Assert.Equal(1, packages.Count); Assert.Equal(packageB2, packages[0]); }
public static void GetPackagesToBeReinstalledWhenProjectIsNotOfSupportedType() { // Arrange Mock<Project> mockProject = new Mock<Project>(); MockPackageRepository localRepository = new MockPackageRepository(); localRepository.AddPackage(PackageUtility.CreatePackage("A")); mockProject.Setup(p => p.Kind).Returns(Guid.NewGuid().ToString()); // Act var packagesToBeReinstalled = ProjectRetargetingUtility.GetPackagesToBeReinstalled(mockProject.Object, localRepository); // Assert Assert.True(packagesToBeReinstalled.IsEmpty()); }
public void InstallPackageCmdletCreatesFallbackRepository() { // Arrange var productUpdateService = new Mock <IProductUpdateService>(); IPackageRepository repoA = new MockPackageRepository(), repoB = new MockPackageRepository(); var package = NuGet.Test.PackageUtility.CreatePackage("P1", dependencies: new[] { new PackageDependency("P2") }); repoA.AddPackage(package); repoB.AddPackage(NuGet.Test.PackageUtility.CreatePackage("P2")); var sharedRepo = new Mock <ISharedPackageRepository>(); var repositoryFactory = new Mock <IPackageRepositoryFactory>(); repositoryFactory.Setup(c => c.CreateRepository("A")).Returns(repoA); repositoryFactory.Setup(c => c.CreateRepository("B")).Returns(repoB); var sourceProvider = GetPackageSourceProvider(new PackageSource("A"), new PackageSource("B")); var fileSystemProvider = new Mock <IFileSystemProvider>(); fileSystemProvider.Setup(c => c.GetFileSystem(It.IsAny <string>(), It.IsAny <bool>())).Returns(new MockFileSystem()); var repositorySettings = new Mock <IRepositorySettings>(); repositorySettings.Setup(c => c.RepositoryPath).Returns(String.Empty); var solutionManager = new Mock <ISolutionManager>(); var packageManagerFactory = new Mock <VsPackageManagerFactory>(solutionManager.Object, repositoryFactory.Object, sourceProvider, fileSystemProvider.Object, repositorySettings.Object, new Mock <VsPackageInstallerEvents>().Object); packageManagerFactory.Setup(f => f.GetConfigSettingsFileSystem(It.IsAny <string>())).Returns(new MockFileSystem()); var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManagerWithProjects("foo"), packageManagerFactory.Object, repositoryFactory.Object, sourceProvider, null, productUpdateService.Object, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object); cmdlet.Id = "P1"; cmdlet.Source = "A"; // Act cmdlet.Execute(); // Assert // If we've come this far, P1 is successfully installed. Assert.True(true); }
public void CreateFallbackRepositoryUsesResolvedSourceNameWhenEnsuringRepositoryIsNotAlreadyListedInAggregate() { // Arrange var mockRepositoryFactory = new Mock <IPackageRepositoryFactory>(); var mockSourceProvider = new Mock <IVsPackageSourceProvider>(); var mockRepository1 = new MockPackageRepository(); var mockRepository2 = new MockPackageRepository("http://redirected"); var aggregateRepo = new AggregateRepository(new[] { mockRepository1, mockRepository2 }); var source1 = new PackageSource("Source1"); var source2 = new PackageSource("Source2"); var aggregateSource = AggregatePackageSource.Instance; mockRepository1.AddPackage(PackageUtility.CreatePackage("A", "1.0")); mockRepository2.AddPackage(PackageUtility.CreatePackage("A", "1.2")); mockSourceProvider.Setup(m => m.LoadPackageSources()).Returns(new[] { source1, source2, aggregateSource }); mockRepositoryFactory.Setup(m => m.CreateRepository(It.IsAny <string>())).Returns <string>(s => { switch (s) { case "Source1": return(mockRepository1); case "Source2": return(mockRepository2); default: return(null); } }); var packageManagerFactory = new VsPackageManagerFactory(new Mock <ISolutionManager>().Object, mockRepositoryFactory.Object, mockSourceProvider.Object, new Mock <IFileSystemProvider>().Object, new Mock <IRepositorySettings>().Object, new Mock <VsPackageInstallerEvents>().Object); // Act FallbackRepository repository = (FallbackRepository)packageManagerFactory.CreateFallbackRepository(mockRepository2); // Assert var dependencyResolver = (AggregateRepository)repository.DependencyResolver; Assert.Equal(2, dependencyResolver.Repositories.Count()); }
public void UninstallProjectLevelPackageThrowsIfPackageIsReferenced() { // Arrange var localRepository = new Mock <MockPackageRepository>() { CallBase = true }.As <ISharedPackageRepository>(); localRepository.Setup(m => m.IsReferenced("foo", It.IsAny <Version>())).Returns(true); var sourceRepository = new MockPackageRepository(); var fileSystem = new MockFileSystem(); var pathResolver = new DefaultPackagePathResolver(fileSystem); var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }); localRepository.Object.AddPackage(package); sourceRepository.AddPackage(package); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, fileSystem, localRepository.Object, new Mock <IRecentPackageRepository>().Object); var projectManager = new ProjectManager(localRepository.Object, pathResolver, new MockProjectSystem(), new MockPackageRepository()); // Act ExceptionAssert.Throws <InvalidOperationException>(() => packageManager.UninstallPackage(projectManager, "foo", version: null, forceRemove: false, removeDependencies: false, logger: NullLogger.Instance), @"Unable to find package 'foo 1.0' in 'C:\MockFileSystem\'."); }
public void InstallPackageThrowsExceptionPackageIsNotInstalled() { // Arrange var localRepository = new MockPackageRepository(); var sourceRepository = new MockPackageRepository(); var projectSystem = new Mock <IProjectSystem>(); projectSystem.Setup(m => m.AddFile(@"A.1.0\content\file", It.IsAny <Stream>())).Throws <UnauthorizedAccessException>(); projectSystem.Setup(m => m.Root).Returns("FakeRoot"); PackageManager packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(projectSystem.Object), projectSystem.Object, localRepository); IPackage packageA = PackageUtility.CreatePackage("A", "1.0", new[] { "file" }); sourceRepository.AddPackage(packageA); // Act ExceptionAssert.Throws <UnauthorizedAccessException>(() => packageManager.InstallPackage("A")); // Assert Assert.False(packageManager.LocalRepository.Exists(packageA)); }
public void InstallPackageSetOperationToInstall2() { // 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); // Act packageManager.InstallPackage(projectManager, "foo", new SemanticVersion("1.0"), ignoreDependencies: false, allowPrereleaseVersions: false, skipAssemblyReferences: false, logger: NullLogger.Instance); // Assert Assert.Equal("Install", sourceRepository.LastOperation); Assert.Equal("foo", sourceRepository.LastMainPackageId); Assert.Equal("1.0", sourceRepository.LastMainPackageVersion); }
public void CanExecuteReturnsCorrectResult() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageB = PackageUtility.CreatePackage("B", "2.0"); var packageC = PackageUtility.CreatePackage("C", "3.0"); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageB); var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); var provider = CreateOnlineProvider(packageManager.Object, localRepository); var extensionA = new PackageItem(provider, packageA); var extensionB = new PackageItem(provider, packageB); var extensionC = new PackageItem(provider, packageC); // Act bool canExecuteA = provider.CanExecute(extensionA); bool canExecuteB = provider.CanExecute(extensionB); bool canExecuteC = provider.CanExecute(extensionC); // Assert Assert.True(canExecuteC); Assert.True(canExecuteB); Assert.False(canExecuteA); }
public void UpdatePackagesSetOperationToUpdate3() { // 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); var packageB = PackageUtility.CreatePackage("time", "1.0", new[] { "hello" }); projectRepository.AddPackage(package); // Act packageManager.UpdatePackage( projectManager, "phuong", version: null, 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 PackageRestoreRepositoryExistsReturnsFalse() { // Arrange var mockRepositoryFactory = new Mock <IPackageRepositoryFactory>(); var mockSourceProvider = new Mock <IVsPackageSourceProvider>(); var mockRepository1 = new MockPackageRepository(); var mockRepository2 = new MockPackageRepository(); var mockRepository3 = new MockPackageRepository(); var source1 = new PackageSource("Source1"); var source2 = new PackageSource("Source2"); var source3 = new PackageSource("Source3"); mockRepository1.AddPackage(PackageUtility.CreatePackage("A", "1.0")); mockRepository2.AddPackage(PackageUtility.CreatePackage("B", "2.0")); mockRepository3.AddPackage(PackageUtility.CreatePackage("C", "3.0")); mockSourceProvider.Setup(m => m.LoadPackageSources()).Returns(new[] { source1, source2, source3 }); mockRepositoryFactory.Setup(m => m.CreateRepository(It.IsAny <string>())).Returns <string>(s => { switch (s) { case "Source1": return(mockRepository1); case "Source2": return(mockRepository2); case "Source3": return(mockRepository3); default: return(null); } }); // Act var packageRestoreRepository = mockSourceProvider.Object.CreatePriorityPackageRepository(mockRepositoryFactory.Object, mockRepository1); Assert.False(packageRestoreRepository.Exists("D", new SemanticVersion("1.0"))); }
public static void GetPackagesToBeReinstalledReturnsPackageTargetingSingleFrameworkBasedOnTools() { // Create a packageA which has as content only in net40. Create a package reference corresponding to this package with the project target framework as 'net40' // Now, Try and check if the created packagereference on a project with targetframework of net35 will require reinstallation. IT SHOULD REQUIRE REINSTALLATION // Arrange IPackage packageA = PackageUtility.CreatePackage("A", "1.0.0", null, null, tools: new[] { @"net40\init.ps1" }); MockPackageRepository localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA); List<PackageReference> packageReferences = new List<PackageReference>(); packageReferences.Add(new PackageReference("A", new SemanticVersion("1.0.0"), null, new FrameworkName(".NETFramework, Version=4.0"), isDevelopmentDependency: false)); FrameworkName projectFramework = new FrameworkName(".NETFramework, Version=3.5"); // Act var packagesToBeReinstalled = ProjectRetargetingUtility.GetPackagesToBeReinstalled(projectFramework, packageReferences, localRepository); // Assert Assert.Equal(1, packagesToBeReinstalled.Count); Assert.Equal(packagesToBeReinstalled[0].Id, "A"); }
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 <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); 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>(), 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 CreateFallbackRepositoryReturnsCurrentIfCurrentIsAggregateRepository() { // Arrange var mockRepositoryFactory = new Mock <IPackageRepositoryFactory>(); var mockSourceProvider = new Mock <IVsPackageSourceProvider>(); var mockRepository1 = new MockPackageRepository(); var mockRepository2 = new MockPackageRepository(); var aggregateRepo = new AggregateRepository(new[] { mockRepository1, mockRepository2 }); var source1 = new PackageSource("Source1"); var source2 = new PackageSource("Source2"); var aggregateSource = AggregatePackageSource.Instance; mockRepository1.AddPackage(PackageUtility.CreatePackage("A", "1.0")); mockRepository2.AddPackage(PackageUtility.CreatePackage("A", "1.2")); mockSourceProvider.Setup(m => m.LoadPackageSources()).Returns(new[] { source1, source2, aggregateSource }); mockRepositoryFactory.Setup(m => m.CreateRepository(It.IsAny <string>())).Returns <string>(s => { switch (s) { case "Source1": return(mockRepository1); case "Source2": return(mockRepository2); default: return(null); } }); var packageManagerFactory = new VsPackageManagerFactory(new Mock <ISolutionManager>().Object, mockRepositoryFactory.Object, mockSourceProvider.Object, new Mock <IFileSystemProvider>().Object, new Mock <IRepositorySettings>().Object, new Mock <VsPackageInstallerEvents>().Object, mockRepository1, machineWideSettings: null); // Act var repository = packageManagerFactory.CreateFallbackRepository(aggregateRepo); // Assert Assert.Equal(aggregateRepo, repository); }
public void CreatePackageManagerForPackageRestoreUsesAggregateRepository() { // Arrange var mockRepositoryFactory = new Mock <IPackageRepositoryFactory>(); var mockSourceProvider = new Mock <IVsPackageSourceProvider>(); var mockFileSystemProvider = new Mock <IFileSystemProvider>(); var mockRepository1 = new MockPackageRepository("Source1"); var mockRepository2 = new MockPackageRepository("Source2"); var source1 = new PackageSource("Source1"); var source2 = new PackageSource("Source2"); mockRepository1.AddPackage(PackageUtility.CreatePackage("A", "1.0")); mockRepository2.AddPackage(PackageUtility.CreatePackage("A", "1.2")); var aggregateRepository = new AggregateRepository(new [] { mockRepository1, mockRepository2 }); //mockSourceProvider.Setup(m => m.LoadPackageSources()).Returns(new[] { source1, source2 }); mockFileSystemProvider.Setup(f => f.GetFileSystem(It.IsAny <string>())).Returns(new MockFileSystem()); var packageManagerFactory = new Mock <VsPackageManagerFactory>(new Mock <ISolutionManager>().Object, mockRepositoryFactory.Object, mockSourceProvider.Object, mockFileSystemProvider.Object, new Mock <IRepositorySettings>().Object, new Mock <VsPackageInstallerEvents>().Object, mockRepository1, null); packageManagerFactory.Setup(f => f.GetConfigSettingsFileSystem(It.IsAny <string>())).Returns(new MockFileSystem()); // Act var packageManager = packageManagerFactory.Object.CreatePackageManagerWithAllPackageSources(aggregateRepository); // Assert Assert.IsType(typeof(AggregateRepository), packageManager.SourceRepository); var sourceAggregateRepository = (AggregateRepository)packageManager.SourceRepository; var repositories = sourceAggregateRepository.Repositories.ToList(); Assert.Equal(2, repositories.Count); Assert.Equal(mockRepository1, repositories[0]); Assert.Equal(mockRepository2, repositories[1]); }
public void InstallPackageInstallsIntoProjectAndPackageManager() { // Arrange var localRepository = new Mock <MockPackageRepository>() { CallBase = true }.As <ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository()); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, projectSystem, localRepository, new Mock <IRecentPackageRepository>().Object); var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }); sourceRepository.AddPackage(package); // Act packageManager.InstallPackage(projectManager, "foo", new Version("1.0"), ignoreDependencies: false, logger: NullLogger.Instance); // Assert Assert.IsTrue(packageManager.LocalRepository.Exists(package)); Assert.IsTrue(projectManager.LocalRepository.Exists(package)); }
public void UninstallPackageRemovesPackageIfPackageIsNotReferenced() { // Arrange var localRepository = new Mock <MockPackageRepository>() { CallBase = true }.As <ISharedPackageRepository>(); localRepository.Setup(m => m.IsReferenced("foo", It.IsAny <Version>())).Returns(false); var sourceRepository = new MockPackageRepository(); var fileSystem = new MockFileSystem(); var pathResolver = new DefaultPackagePathResolver(fileSystem); var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }); localRepository.Object.AddPackage(package); sourceRepository.AddPackage(package); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, fileSystem, localRepository.Object, new Mock <IRecentPackageRepository>().Object); // Act packageManager.UninstallPackage(null, "foo", version: null, forceRemove: false, removeDependencies: false, logger: NullLogger.Instance); // Assert Assert.IsFalse(packageManager.LocalRepository.Exists(package)); }
public static void GetPackagesToBeReinstalledReturnsEmptyListForPackageTargetingMultipleFrameworks() { // Create a packageA which has as assembly reference in net 20 and net30. Create a package reference corresponding to this package with the project target framework as 'net40' // Now, Try and check if the created packagereference on a project with targetframework of net35 will require reinstallation. IT SHOULD REQUIRE REINSTALLATION // Arrange IPackage packageA = PackageUtility.CreatePackage("A", "1.0.0", null, assemblyReferences: new[] { @"lib\net20\bar.dll", @"lib\net30\foo.dll" }); MockPackageRepository localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA); List <PackageReference> packageReferences = new List <PackageReference>(); packageReferences.Add(new PackageReference("A", new SemanticVersion("1.0.0"), null, new FrameworkName(".NETFramework, Version=4.0"), isDevelopmentDependency: false)); FrameworkName projectFramework = new FrameworkName(".NETFramework, Version=3.5"); // Act var packagesToBeReinstalled = ProjectRetargetingUtility.GetPackagesToBeReinstalled(projectFramework, packageReferences, localRepository); // Assert Assert.True(packagesToBeReinstalled.IsEmpty()); }
public void SolutionInstalledProviderShowsAllVersions() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageA2 = PackageUtility.CreatePackage("A", "2.0"); var packageB = PackageUtility.CreatePackage("B", "2.0"); var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA); localRepository.AddPackage(packageA2); localRepository.AddPackage(packageB); var projectManager1 = new Mock <IProjectManager>(); projectManager1.Setup(p => p.LocalRepository).Returns(localRepository); var projectManager2 = new Mock <IProjectManager>(); projectManager2.Setup(p => p.LocalRepository).Returns(localRepository); var project1 = MockProjectUtility.CreateMockProject("Project1"); var project2 = MockProjectUtility.CreateMockProject("Project2"); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object); packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true); var provider = CreateSolutionInstalledProvider(packageManager.Object, localRepository); var extensionTree = provider.ExtensionsTree; var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0]; provider.SelectedNode = firstTreeNode; firstTreeNode.IsSelected = true; var mre = new ManualResetEventSlim(false); firstTreeNode.PackageLoadCompleted += delegate { var allExtensions = firstTreeNode.Extensions; // Assert Assert.Equal(3, allExtensions.Count); Assert.Equal("A", allExtensions[0].Id); Assert.Equal("1.0", ((PackageItem)allExtensions[0]).Version); Assert.Equal("A", allExtensions[1].Id); Assert.Equal("2.0", ((PackageItem)allExtensions[1]).Version); Assert.Equal("B", allExtensions[2].Id); Assert.Equal("2.0", ((PackageItem)allExtensions[2]).Version); mre.Set(); }; // Act var ignore = firstTreeNode.Extensions; mre.Wait(); }
public void ExecuteUninstallsSolutionLevelPackageWhenUpdating() { // Arrange var packageA_10 = PackageUtility.CreatePackage("A", "1.0", content: null, assemblyReferences: null, tools: new[] { "init.ps1" }, dependencies: null); var packageA_12 = PackageUtility.CreatePackage("A", "1.2", content: null, assemblyReferences: null, tools: new[] { "init.ps1" }, dependencies: null); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA_12); var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA_10); var projectManager1 = new Mock <IProjectManager>(); projectManager1.Setup(p => p.LocalRepository).Returns(localRepository); var project1 = MockProjectUtility.CreateMockProject("Project1"); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.LocalRepository).Returns(localRepository); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object); packageManager.Setup(p => p.IsProjectLevel(packageA_12)).Returns(false); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1); solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1 }); var mockWindowService = new Mock <IUserNotifierServices>(); mockWindowService.Setup(p => p.ShowProjectSelectorWindow( It.IsAny <string>(), It.IsAny <IPackage>(), It.IsAny <Predicate <Project> >(), It.IsAny <Predicate <Project> >())).Returns(new Project[0]); var provider = CreateSolutionUpdatesProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.Object); var extensionTree = provider.ExtensionsTree; var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0]; firstTreeNode.Repository.AddPackage(packageA_10); provider.SelectedNode = firstTreeNode; IVsPackageManager activePackageManager = provider.GetActivePackageManager(); Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager); var manualEvent = new ManualResetEventSlim(false); Exception exception = null; provider.ExecuteCompletedCallback = delegate { try { // Assert mockPackageManager.Verify(p => p.UpdatePackage( new Project[0], packageA_12, new[] { new PackageOperation(packageA_10, PackageAction.Uninstall), new PackageOperation(packageA_12, PackageAction.Install) }, true, false, provider, provider), Times.Once()); } catch (Exception e) { exception = e; } finally { manualEvent.Set(); } }; var extensionA_12 = new PackageItem(provider, packageA_12); // Act provider.Execute(extensionA_12); // do not allow the method to return manualEvent.Wait(); Assert.Null(exception); }
public void ExecuteMethodInstallPackagesWithInitScript() { // source repo has A, B, C // solution repo has A // project repo has C // install B // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageB = PackageUtility.CreatePackage("B", "2.0", content: new string[] { "hello world" }, tools: new string[] { "init.ps1" }); var packageC = PackageUtility.CreatePackage("C", "3.0"); var solutionRepository = new MockPackageRepository(); solutionRepository.AddPackage(packageA); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageB); sourceRepository.AddPackage(packageC); var localRepository = new MockPackageRepository(); localRepository.Add(packageC); var projectManager = CreateProjectManager(localRepository, solutionRepository); var project = new Mock <Project>(); project.Setup(p => p.Properties.Item("TargetFrameworkMoniker").Value).Returns(".NETFramework, Version=4.0"); var scriptExecutor = new Mock <IScriptExecutor>(); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.LocalRepository).Returns(solutionRepository); packageManager.Setup(p => p.InstallPackage(projectManager, packageB, It.IsAny <IEnumerable <PackageOperation> >(), false, false, It.IsAny <ILogger>())). Raises(p => p.PackageInstalled += null, packageManager, new PackageOperationEventArgs(packageB, null, "")); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(s => s.GetProject(It.IsAny <string>())).Returns(project.Object); var provider = CreateOnlineProvider(packageManager.Object, null, null, null, project.Object, scriptExecutor.Object, solutionManager.Object); var extensionTree = provider.ExtensionsTree; var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0]; firstTreeNode.Repository.AddPackage(packageA); firstTreeNode.Repository.AddPackage(packageB); firstTreeNode.Repository.AddPackage(packageC); provider.SelectedNode = firstTreeNode; ManualResetEvent manualEvent = new ManualResetEvent(false); provider.ExecuteCompletedCallback = delegate { try { // Assert // init.ps1 should be executed scriptExecutor.Verify(p => p.Execute(It.IsAny <string>(), PowerShellScripts.Init, packageB, null, null, It.IsAny <ILogger>()), Times.Once()); // InstallPackage() should get called packageManager.Verify(p => p.InstallPackage( projectManager, It.IsAny <IPackage>(), It.IsAny <IEnumerable <PackageOperation> >(), false, false, It.IsAny <ILogger>()), Times.Once()); } finally { manualEvent.Set(); } }; var extensionB = new PackageItem(provider, packageB); // Act provider.Execute(extensionB); // do not allow the method to return manualEvent.WaitOne(); }
public void SearchTreeNodeHonorsTheIncludePrereleaseAttribute(bool includePrerelease, string expectedVersion) { // Arrange var packageA1 = PackageUtility.CreatePackage("packageA", "1.0"); var packageA2 = PackageUtility.CreatePackage("packageA", "2.0-alpha"); var packageC = PackageUtility.CreatePackage("packageB", "3.0.0.0-rtm"); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA2); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageA1); var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA2); var projectManager = new Mock <IProjectManager>(); projectManager.Setup(p => p.LocalRepository).Returns(localRepository); var project = new Mock <Project>(); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager.Object); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(s => s.GetProject(It.IsAny <string>())).Returns(project.Object); var provider = CreateOnlineProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, project: project.Object); provider.IncludePrerelease = includePrerelease; var extensionTree = provider.ExtensionsTree; var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0]; firstTreeNode.Repository.AddPackage(packageA2); firstTreeNode.Repository.AddPackage(packageA1); firstTreeNode.Repository.AddPackage(packageC); provider.SelectedNode = firstTreeNode; IVsPackageManager activePackageManager = provider.GetActivePackageManager(); Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager); mockPackageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager.Object); var manualEvent = new ManualResetEventSlim(false); // Act 1 var treeNode = (PackagesTreeNodeBase)provider.Search("packageA"); Assert.NotNull(treeNode); Exception exception = null; treeNode.PackageLoadCompleted += (o, e) => { try { var packages = treeNode.Extensions.OfType <PackageItem>().ToList(); Assert.Equal(1, packages.Count); AssertPackage(packages[0].PackageIdentity, "packageA", expectedVersion); } catch (Exception ex) { exception = ex; } finally { manualEvent.Set(); } }; // trigger loading packages var extensions = treeNode.Extensions; // do not allow the method to return manualEvent.Wait(); if (exception != null) { throw exception; } }
public void CallingCheckForMissingPackagesRaisesThePackagesMissingStatusChangedEventWithFalseValue() { // Scenario: // Project's packages.config specifies: A[1.0], B[1.2-alpha] // The solution's packages folder contains only A[1.0], B[1.2-alpha] // Arrange string tempSolutionPath = "x:\\project1"; var project = new Mock <Project>(); // setup SolutionManager var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(p => p.IsSolutionOpen).Returns(true); solutionManager.Setup(p => p.SolutionDirectory).Returns(tempSolutionPath); solutionManager.Setup(p => p.GetProjects()).Returns(new[] { project.Object }); // setup file system var fileSystem = new Mock <IFileSystem>(); fileSystem.Setup(p => p.DirectoryExists(".nuget")).Returns(true); fileSystem.Setup(p => p.FileExists(".nuget\\NuGet.exe")).Returns(true); fileSystem.Setup(p => p.FileExists(".nuget\\NuGet.targets")).Returns(true); var fileSystemProvider = new Mock <IFileSystemProvider>(); fileSystemProvider.Setup(p => p.GetFileSystem(tempSolutionPath)).Returns(fileSystem.Object); // setup VsPackageManager var projectFileSystem = new MockFileSystem(); projectFileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.0.0.0"" /> <package id=""B"" version=""1.2-alpha"" /> </packages>"); var packageReferenceRepository = new PackageReferenceRepository(projectFileSystem, new Mock <ISharedPackageRepository>().Object); var projectManager = new Mock <IProjectManager>(); projectManager.Setup(p => p.LocalRepository).Returns(packageReferenceRepository); var localRepository = new MockPackageRepository(); localRepository.AddPackage(PackageUtility.CreatePackage("A", "1.0")); localRepository.AddPackage(PackageUtility.CreatePackage("B", "1.2-alpha")); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.GetProjectManager(project.Object)).Returns(projectManager.Object); packageManager.Setup(p => p.LocalRepository).Returns(localRepository); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(p => p.CreatePackageManager()).Returns(packageManager.Object); var packageRestore = CreateInstance( fileSystemProvider: fileSystemProvider.Object, solutionManager: solutionManager.Object, packageManagerFactory: packageManagerFactory.Object); bool?packagesMissing = null; packageRestore.PackagesMissingStatusChanged += (o, e) => { packagesMissing = e.PackagesMissing; }; // Act packageRestore.CheckForMissingPackages(); // Assert Assert.Equal(false, packagesMissing); }
public void ExecuteAllMethodCallUpdateAllPackageOnAllProjects(bool includePrerelease) { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageB = PackageUtility.CreatePackage("B", "2.0"); var packageC = PackageUtility.CreatePackage("C", "3.0"); var packageB2 = PackageUtility.CreatePackage("B", "4.0"); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageB); sourceRepository.AddPackage(packageB2); var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageB); var projectManager1 = new Mock <IProjectManager>(); projectManager1.Setup(p => p.LocalRepository).Returns(localRepository); var projectManager2 = new Mock <IProjectManager>(); projectManager2.Setup(p => p.LocalRepository).Returns(localRepository); var project1 = MockProjectUtility.CreateMockProject("Project1"); var project2 = MockProjectUtility.CreateMockProject("Project2"); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object); packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2); solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 }); var mockWindowService = new Mock <IUserNotifierServices>(); mockWindowService.Setup(p => p.ShowProjectSelectorWindow( It.IsAny <string>(), It.IsAny <IPackage>(), It.IsAny <Predicate <Project> >(), It.IsAny <Predicate <Project> >())).Returns(new Project[] { project1, project2 }); var provider = CreateSolutionUpdatesProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.Object); provider.IncludePrerelease = includePrerelease; var extensionTree = provider.ExtensionsTree; var extensionB2 = new PackageItem(provider, packageB2); var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0]; firstTreeNode.Repository.AddPackage(packageA); firstTreeNode.Repository.AddPackage(packageB); firstTreeNode.Repository.AddPackage(packageC); firstTreeNode.Extensions.Add(extensionB2); provider.SelectedNode = firstTreeNode; IVsPackageManager activePackageManager = provider.GetActivePackageManager(); Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager); var manualEvent = new ManualResetEventSlim(false); Exception exception = null; provider.ExecuteCompletedCallback = delegate { try { // Assert Assert.Equal(RepositoryOperationNames.Update, sourceRepository.LastOperation); mockPackageManager.Verify( p => p.UpdatePackages(true, includePrerelease, provider, provider), Times.Once()); } catch (Exception ex) { exception = ex; } finally { manualEvent.Set(); } }; // Act provider.Execute(item: null); // do not allow the method to return manualEvent.Wait(); Assert.Null(exception); }
public void UninstallingSatellitePackageRemovesFilesFromRuntimePackageFolder() { // Arrange // Create a runtime package and a satellite package that has a dependency on the runtime package, and uses the // local suffix convention. var runtimePackage = PackageUtility.CreatePackage("foo", "1.0.0", assemblyReferences: new[] { @"lib\foo.dll" }, content: new[] { @"english.txt" }); var satellitePackage = PackageUtility.CreatePackage( "foo.ja-jp", "1.0.0", language: "ja-jp", satelliteAssemblies: new[] { @"lib\ja-jp\foo.resources.dll", @"lib\ja-jp\foo.xml", @"lib\japanese.xml" }, content: new[] { @"english.txt", @"japanese.txt" }, dependencies: new[] { new PackageDependency("foo", VersionUtility.ParseVersionSpec("[1.0]")) }); var packagesFolder = new MockFileSystem(@"c:\packagesFolder"); var sharedRepository = new MockSharedPackageRepository2(); var sourceRepository = new MockPackageRepository(); var packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(packagesFolder), packagesFolder, sharedRepository); sourceRepository.AddPackage(runtimePackage); sourceRepository.AddPackage(satellitePackage); var projectSystem = new MockProjectSystem(); var projectLocalRepo = new PackageReferenceRepository( new MockFileSystem(@"c:\project"), "projectName", sharedRepository); var projectManager = new ProjectManager( packageManager, packageManager.PathResolver, projectSystem, projectLocalRepo); // Act Install("foo", projectManager); Install("foo.ja-jp", projectManager); Uninstall("foo.ja-jp", packageManager, projectManager); // Assert Assert.Equal(2, packagesFolder.Paths.Count); Assert.True(packagesFolder.FileExists(@"foo.1.0.0\content\english.txt")); Assert.True(packagesFolder.FileExists(@"foo.1.0.0\lib\foo.dll")); Assert.False(packagesFolder.FileExists(@"foo.1.0.0\lib\ja-jp\foo.resources.dll")); Assert.False(packagesFolder.FileExists(@"foo.1.0.0\lib\ja-jp\foo.xml")); Assert.False(packagesFolder.FileExists(@"foo.ja-jp.1.0.0\content\english.txt")); Assert.False(packagesFolder.FileExists(@"foo.ja-jp.1.0.0\content\japanese.txt")); Assert.False(packagesFolder.FileExists(@"foo.ja-jp.1.0.0\lib\japanese.xml")); Assert.False(packagesFolder.FileExists(@"foo.ja-jp.1.0.0\lib\ja-jp\foo.resources.dll")); Assert.False(packagesFolder.FileExists(@"foo.ja-jp.1.0.0\lib\ja-jp\foo.xml")); Assert.False(packagesFolder.FileExists(@"foo.1.0.0\lib\japanese.xml")); Assert.False(packagesFolder.FileExists(@"foo.1.0.0\content\japanese.txt")); }
public void CallingRestoreMissingPackagesMethodInstallMissingPackages() { // Scenario: // Project's packages.config specifies: A[1.0] // The solution's packages folder contains only A[1.0], B[1.2-alpha], C[2.0-RC1] // Call RestoreMissingPackages() will install B[1.2-alpha] and C[2.0-RC1] into the solution // Arrange string tempSolutionPath = "x:\\project1"; var project = new Mock <Project>(); // setup SolutionManager var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(p => p.IsSolutionOpen).Returns(true); solutionManager.Setup(p => p.SolutionDirectory).Returns(tempSolutionPath); solutionManager.Setup(p => p.GetProjects()).Returns(new[] { project.Object }); // setup file system var fileSystem = new Mock <IFileSystem>(); fileSystem.Setup(p => p.DirectoryExists(".nuget")).Returns(true); fileSystem.Setup(p => p.FileExists(".nuget\\NuGet.exe")).Returns(true); fileSystem.Setup(p => p.FileExists(".nuget\\NuGet.targets")).Returns(true); var fileSystemProvider = new Mock <IFileSystemProvider>(); fileSystemProvider.Setup(p => p.GetFileSystem(tempSolutionPath)).Returns(fileSystem.Object); // setup VsPackageManager string tempFile = @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.0.0.0"" /> <package id=""B"" version=""1.2-alpha"" /> <package id=""C"" version=""2.0-RC1"" /> </packages>"; var projectFileSystem = new MockFileSystem(); projectFileSystem.AddFile("packages.config", tempFile); var packageReferenceRepository = new PackageReferenceRepository(projectFileSystem, new Mock <ISharedPackageRepository>().Object); var projectManager = new Mock <IProjectManager>(); projectManager.Setup(p => p.LocalRepository).Returns(packageReferenceRepository); var localRepository = new MockPackageRepository(); localRepository.AddPackage(PackageUtility.CreatePackage("A", "1.0")); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.GetProjectManager(project.Object)).Returns(projectManager.Object); packageManager.Setup(p => p.LocalRepository).Returns(localRepository); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(p => p.CreatePackageManager()).Returns(packageManager.Object); var packageRestore = CreateInstance( fileSystemProvider: fileSystemProvider.Object, solutionManager: solutionManager.Object, packageManagerFactory: packageManagerFactory.Object); Exception exception = null; var manualEvent = new ManualResetEventSlim(); // Act packageRestore.RestoreMissingPackages().ContinueWith( task => { if (task.IsFaulted) { exception = task.Exception; manualEvent.Set(); return; } try { // Assert packageManager.Verify(p => p.InstallPackage("A", new SemanticVersion("1.0.0.0"), true, true), Times.Never()); packageManager.Verify(p => p.InstallPackage("B", new SemanticVersion("1.2-alpha"), true, true), Times.Once()); packageManager.Verify(p => p.InstallPackage("C", new SemanticVersion("2.0-RC1"), true, true), Times.Once()); } catch (Exception testException) { exception = testException; } finally { manualEvent.Set(); } }); manualEvent.Wait(); Assert.Null(exception); }
public void ExecuteMethodCallsInstallPackageMethodOnPackageManager(bool includePrerelease) { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageB = PackageUtility.CreatePackage("B", "2.0"); var packageC = PackageUtility.CreatePackage("C", "3.0"); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageB); var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA); var projectManager1 = new Mock <IProjectManager>(); projectManager1.Setup(p => p.LocalRepository).Returns(localRepository); var projectManager2 = new Mock <IProjectManager>(); projectManager2.Setup(p => p.LocalRepository).Returns(localRepository); var project1 = MockProjectUtility.CreateMockProject("Project1"); var project2 = MockProjectUtility.CreateMockProject("Project2"); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object); packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2); solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 }); var provider = CreateSolutionOnlineProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object); provider.IncludePrerelease = includePrerelease; var extensionTree = provider.ExtensionsTree; var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0]; firstTreeNode.Repository.AddPackage(packageA); firstTreeNode.Repository.AddPackage(packageB); firstTreeNode.Repository.AddPackage(packageC); provider.SelectedNode = firstTreeNode; IVsPackageManager activePackageManager = provider.GetActivePackageManager(); Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager); var manualEvent = new ManualResetEventSlim(false); provider.ExecuteCompletedCallback = delegate { // Assert Assert.Equal(RepositoryOperationNames.Install, sourceRepository.LastOperation); mockPackageManager.Verify(p => p.InstallPackage( new Project[] { project1, project2 }, packageB, It.IsAny <IEnumerable <PackageOperation> >(), false, includePrerelease, provider, provider), Times.Once()); manualEvent.Set(); }; var extensionB = new PackageItem(provider, packageB); // Act provider.Execute(extensionB); // do not allow the method to return manualEvent.Wait(); }
public void ExecuteMethodDoNotCallInstallPackageIfUserDoesNotSelectAnyProject() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageB = PackageUtility.CreatePackage("B", "2.0"); var packageC = PackageUtility.CreatePackage("C", "3.0"); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageB); var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA); var projectManager1 = new Mock <IProjectManager>(); projectManager1.Setup(p => p.LocalRepository).Returns(localRepository); var projectManager2 = new Mock <IProjectManager>(); projectManager2.Setup(p => p.LocalRepository).Returns(localRepository); var project1 = MockProjectUtility.CreateMockProject("Project1"); var project2 = MockProjectUtility.CreateMockProject("Project2"); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object); packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2); solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 }); var mockWindowService = new Mock <IUserNotifierServices>(); mockWindowService.Setup(p => p.ShowProjectSelectorWindow( It.IsAny <string>(), It.IsAny <IPackage>(), It.IsAny <Predicate <Project> >(), It.IsAny <Predicate <Project> >())).Returns(new Project[0]); var provider = CreateSolutionOnlineProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.Object); var extensionTree = provider.ExtensionsTree; var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0]; firstTreeNode.Repository.AddPackage(packageA); firstTreeNode.Repository.AddPackage(packageB); firstTreeNode.Repository.AddPackage(packageC); provider.SelectedNode = firstTreeNode; IVsPackageManager activePackageManager = provider.GetActivePackageManager(); Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager); var manualEvent = new ManualResetEventSlim(false); provider.ExecuteCompletedCallback = delegate { // Assert mockPackageManager.Verify(p => p.InstallPackage( It.IsAny <IEnumerable <Project> >(), packageB, It.IsAny <IEnumerable <PackageOperation> >(), false, false, provider, provider), Times.Never()); manualEvent.Set(); }; var extensionB = new PackageItem(provider, packageB); // Act provider.Execute(extensionB); // do not allow the method to return manualEvent.Wait(); }
public void InstallPackageInvokeInstallScript() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageB = PackageUtility.CreatePackage("B", "2.0", tools: new[] { "install.ps1" }); var packageC = PackageUtility.CreatePackage("C", "3.0"); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageB); var localRepository = new MockPackageRepository(); var fileSystem = new Mock <IVsProjectSystem>(); fileSystem.SetupGet(f => f.UniqueName).Returns("Project1"); var projectManager1 = new Mock <IProjectManager>(); projectManager1.Setup(p => p.LocalRepository).Returns(localRepository); projectManager1.Setup(p => p.AddPackageReference(packageB, false, false)) .Raises(p => p.PackageReferenceAdded += (o, a) => { }, new PackageOperationEventArgs(packageB, fileSystem.As <IFileSystem>().Object, "x:\\nuget")); var project1 = MockProjectUtility.CreateMockProject("Project1"); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object); packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true); packageManager.Setup(p => p.InstallPackage( new[] { project1 }, packageB, It.IsAny <IEnumerable <PackageOperation> >(), false, false, It.IsAny <ILogger>(), It.IsAny <IPackageOperationEventListener>())) .Callback( (IEnumerable <Project> projects, IPackage package, IEnumerable <PackageOperation> operations, bool ignoreDependencies, bool allowPrereleaseVersions, ILogger logger, IPackageOperationEventListener eventListener) => { eventListener.OnBeforeAddPackageReference(project1); projectManager1.Object.AddPackageReference(packageB, false, false); }); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1); solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1 }); var scriptExecutor = new Mock <IScriptExecutor>(); var provider = CreateSolutionOnlineProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, scriptExecutor: scriptExecutor.Object); var extensionTree = provider.ExtensionsTree; var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0]; firstTreeNode.Repository.AddPackage(packageA); firstTreeNode.Repository.AddPackage(packageB); firstTreeNode.Repository.AddPackage(packageC); provider.SelectedNode = firstTreeNode; IVsPackageManager activePackageManager = provider.GetActivePackageManager(); Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager); var manualEvent = new ManualResetEventSlim(false); Exception callbackException = null; provider.ExecuteCompletedCallback = delegate { try { // Assert scriptExecutor.Verify(p => p.Execute("x:\\nuget", "install.ps1", packageB, project1, It.IsAny <FrameworkName>(), It.IsAny <ILogger>()), Times.Once()); } catch (Exception exception) { callbackException = exception; } finally { manualEvent.Set(); } }; var extensionB = new PackageItem(provider, packageB); // Act provider.Execute(extensionB); // do not allow the method to return manualEvent.Wait(); if (callbackException != null) { throw callbackException; } }
public void ExecuteMethodCallsUpdatePackageMethodOnPackageManager(bool includePrerelease) { // Local repository contains Package A 1.0 and Package B // Source repository contains Package A 2.0 and Package C var packageA1 = PackageUtility.CreatePackage("A", "1.0"); var packageA2 = PackageUtility.CreatePackage("A", "2.0"); var packageB = PackageUtility.CreatePackage("B", "2.0"); var packageC = PackageUtility.CreatePackage("C", "3.0"); // Arrange var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA1); localRepository.AddPackage(packageB); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA2); sourceRepository.AddPackage(packageC); var project = new Mock <Project>(); var projectManager = new Mock <IProjectManager>(); projectManager.Setup(p => p.LocalRepository).Returns(localRepository); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager.Object); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(s => s.GetProject(It.IsAny <string>())).Returns(project.Object); var mockWindowServices = new Mock <IUserNotifierServices>(); var provider = CreateUpdatesProvider(packageManager.Object, localRepository, project: project.Object, userNotifierServices: mockWindowServices.Object, solutionManager: solutionManager.Object); provider.IncludePrerelease = includePrerelease; var extensionA = new PackageItem(provider, packageA2); var extensionC = new PackageItem(provider, packageC); provider.SelectedNode = (UpdatesTreeNode)provider.ExtensionsTree.Nodes[0]; var manualEvent = new ManualResetEvent(false); provider.ExecuteCompletedCallback = delegate { // Assert Assert.Equal(RepositoryOperationNames.Update, sourceRepository.LastOperation); mockWindowServices.Verify(p => p.ShowLicenseWindow(It.IsAny <IEnumerable <IPackage> >()), Times.Never()); packageManager.Verify(p => p.UpdatePackage(projectManager.Object, packageA2, It.IsAny <IEnumerable <PackageOperation> >(), true, includePrerelease, provider), Times.Once()); manualEvent.Set(); }; // Act provider.Execute(extensionA); // do not allow the method to return manualEvent.WaitOne(); }
public void ExecuteMethodInvokeInstallScriptAndUninstallScript() { // Local repository contains Package A 1.0 and Package B // Source repository contains Package A 2.0 and Package C var packageA1 = PackageUtility.CreatePackage("A", "1.0", tools: new string[] { "uninstall.ps1" }); var packageA2 = PackageUtility.CreatePackage("A", "2.0", content: new string[] { "hello world" }, tools: new string[] { "install.ps1" }); var packageB = PackageUtility.CreatePackage("B", "2.0"); var packageC = PackageUtility.CreatePackage("C", "3.0"); // Arrange var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA1); localRepository.AddPackage(packageB); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA2); sourceRepository.AddPackage(packageC); var project = new Mock <Project>(); var projectManager = CreateProjectManager(localRepository, sourceRepository); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project.Object))).Returns(projectManager); packageManager.Setup(p => p.UpdatePackage( projectManager, It.IsAny <IPackage>(), It.IsAny <IEnumerable <PackageOperation> >(), true, false, It.IsAny <ILogger>())).Callback( () => { projectManager.AddPackageReference("A", new SemanticVersion("2.0"), false, false); }); var scriptExecutor = new Mock <IScriptExecutor>(); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(s => s.GetProject(It.IsAny <string>())).Returns(project.Object); var provider = CreateUpdatesProvider(packageManager.Object, localRepository, null, null, project.Object, scriptExecutor.Object, null, solutionManager.Object); provider.SelectedNode = (UpdatesTreeNode)provider.ExtensionsTree.Nodes[0]; var extensionA = new PackageItem(provider, packageA2); ManualResetEvent manualEvent = new ManualResetEvent(false); provider.ExecuteCompletedCallback = delegate { // Assert try { scriptExecutor.Verify(p => p.Execute(It.IsAny <string>(), "uninstall.ps1", packageA1, project.Object, It.IsAny <FrameworkName>(), It.IsAny <ILogger>()), Times.Once()); scriptExecutor.Verify(p => p.Execute(It.IsAny <string>(), "install.ps1", packageA2, project.Object, It.IsAny <FrameworkName>(), It.IsAny <ILogger>()), Times.Once()); } finally { manualEvent.Set(); } }; // Act provider.Execute(extensionA); // do not allow the method to return manualEvent.WaitOne(); }
public void ExecuteMethodCallsInstallPackageMethodOnPackageManager() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageB = PackageUtility.CreatePackage("B", "2.0"); var packageC = PackageUtility.CreatePackage("C", "3.0"); var sourceRepository = new MockPackageRepository(); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageC); sourceRepository.AddPackage(packageB); var localRepository = new MockPackageRepository(); localRepository.AddPackage(packageA); var projectManager1 = new Mock <IProjectManager>(); projectManager1.Setup(p => p.LocalRepository).Returns(localRepository); var projectManager2 = new Mock <IProjectManager>(); projectManager2.Setup(p => p.LocalRepository).Returns(localRepository); var project1 = MockProjectUtility.CreateMockProject("Project1"); var project2 = MockProjectUtility.CreateMockProject("Project2"); var packageManager = new Mock <IVsPackageManager>(); packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object); packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object); packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true); var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1); solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2); solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 }); var provider = CreateSolutionInstalledProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object); var extensionTree = provider.ExtensionsTree; var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0]; provider.SelectedNode = firstTreeNode; var manualEvent = new ManualResetEventSlim(false); provider.ExecuteCompletedCallback = delegate { // Assert packageManager.Verify(p => p.InstallPackage( projectManager1.Object, packageB.Id, packageB.Version, false, true, provider), Times.Once()); packageManager.Verify(p => p.InstallPackage( projectManager2.Object, packageB.Id, packageB.Version, false, true, provider), Times.Once()); manualEvent.Set(); }; var extensionB = new PackageItem(provider, packageB); // Act provider.Execute(extensionB); // do not allow the method to return manualEvent.Wait(); }
public void CallingEnableCurrentSolutionDoNotDownloadPackageIfPresentInLocalCache() { // Arrange string tempSolutionPath = CreateTempFolder(); // setup SolutionManager var solutionManager = new Mock <ISolutionManager>(); solutionManager.Setup(p => p.IsSolutionOpen).Returns(true); solutionManager.Setup(p => p.SolutionDirectory).Returns(tempSolutionPath); // setup file system var fileSystem = new PhysicalFileSystem(tempSolutionPath); var fileSystemProvider = new Mock <IFileSystemProvider>(MockBehavior.Strict); fileSystemProvider.Setup(p => p.GetFileSystem(tempSolutionPath)).Returns(fileSystem); var nugetFolderFileSystem = new PhysicalFileSystem(tempSolutionPath + "\\.nuget"); fileSystemProvider.Setup(p => p.GetFileSystem(tempSolutionPath + "\\.nuget")).Returns(nugetFolderFileSystem); // setup DTE var dte = new Mock <DTE>(); var projectItems = new Mock <ProjectItems>(); var solutionFolder = new Mock <Project>(); solutionFolder.Setup(s => s.Name).Returns(".nuget"); solutionFolder.SetupGet(s => s.ProjectItems).Returns(projectItems.Object); var solution = new Mock <Solution>(); solution.As <Solution2>().Setup(p => p.AddSolutionFolder(".nuget")).Returns(solutionFolder.Object); var projects = new MockProjects(new Project[0]); solution.As <Solution2>().Setup(s => s.Projects).Returns(projects); dte.SetupGet(p => p.Solution).Returns(solution.Object); // setup package repository var packageRepository = new MockPackageRepository(); var packageA = new Mock <IPackage>(MockBehavior.Strict); packageA.Setup(p => p.Id).Returns("NuGet.Build"); packageA.Setup(p => p.Version).Returns(new SemanticVersion("1.0")); packageA.Setup(p => p.IsLatestVersion).Returns(true); packageA.Setup(p => p.Listed).Returns(true); var packageB = new Mock <IPackage>(MockBehavior.Strict); packageB.Setup(p => p.Id).Returns("NuGet.CommandLine"); packageB.Setup(p => p.Version).Returns(new SemanticVersion("2.0")); packageB.Setup(p => p.IsLatestVersion).Returns(true); packageB.Setup(p => p.Listed).Returns(true); packageRepository.AddPackage(packageA.Object); packageRepository.AddPackage(packageB.Object); var packageRepositoryFactory = new Mock <IPackageRepositoryFactory>(MockBehavior.Strict); packageRepositoryFactory.Setup(p => p.CreateRepository("x:\\nugetsource")).Returns(packageRepository); var packageSourceProvider = new Mock <IVsPackageSourceProvider>(); packageSourceProvider.Setup(p => p.LoadPackageSources()).Returns(new[] { new PackageSource("x:\\nugetsource"), new PackageSource("y:\\me", "unabled", isEnabled: false), }); var localCache = new MockPackageRepository(); localCache.Add(PackageUtility.CreatePackage( "NuGet.Build", version: "1.0", tools: new string[] { "NuGet.targets" }, dependencies: new PackageDependency[] { new PackageDependency("NuGet.CommandLine") }, listed: true)); localCache.Add(PackageUtility.CreatePackage( "NuGet.CommandLine", version: "2.0", tools: new string[] { "NuGet.exe" }, listed: true)); var packageRestore = CreateInstance( dte.Object, solutionManager.Object, fileSystemProvider.Object, packageRepositoryFactory.Object, localCache: localCache, packageSourceProvider: packageSourceProvider.Object); // Act packageRestore.EnableCurrentSolutionForRestore(fromActivation: false); // Assert packageA.Verify(p => p.GetFiles(), Times.Never()); packageB.Verify(p => p.GetFiles(), Times.Never()); }