public void InstallPackageCmdletPassesParametersCorrectlyWhenIdAndVersionAreSpecified() { // Arrange var vsPackageManager = new MockVsPackageManager(); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); var cmdlet = new InstallPackageCommand( TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object); cmdlet.Id = "my-id"; cmdlet.Version = new SemanticVersion("2.8"); // Act cmdlet.Execute(); // Assert Assert.Equal("my-id", vsPackageManager.PackageId); Assert.Equal(new SemanticVersion("2.8"), vsPackageManager.Version); }
public void InstallPackageCmdletSpecifiesInstallOperationDuringExecution() { // Arrange var repo = new MockPackageRepository(); var vsPackageManager = new MockVsPackageManager(repo); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); var cmdlet = new InstallPackageCommand( TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, null, null, new Mock <IVsCommonOperations>().Object); cmdlet.Id = "my-id"; cmdlet.Version = new SemanticVersion("2.8"); // Act cmdlet.Execute(); // Assert Assert.Equal(RepositoryOperationNames.Install, repo.LastOperation); }
public void InstallPackageCmdletPassesIgnoreDependencySwitchCorrectly() { // Arrange var vsPackageManager = new MockVsPackageManager(); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); var cmdlet = new InstallPackageCommand( TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, null, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object); cmdlet.Id = "my-id"; cmdlet.Version = new SemanticVersion("2.8"); cmdlet.IgnoreDependencies = new SwitchParameter(true); // Act cmdlet.Execute(); // Assert Assert.Equal("my-id", vsPackageManager.PackageId); Assert.Equal(new SemanticVersion("2.8"), vsPackageManager.Version); Assert.True(vsPackageManager.IgnoreDependencies); }
public void UninstallPackageCmdletPassesForceSwitchCorrectly() { // Arrange var id = "my-id"; var version = new SemanticVersion("2.8"); var forceSwitch = true; var vsPackageManager = new MockVsPackageManager(); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); var uninstallCmdlet = new Mock <UninstallPackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock <IVsCommonOperations>().Object) { CallBase = true }; uninstallCmdlet.Object.Id = id; uninstallCmdlet.Object.Version = version; uninstallCmdlet.Object.Force = new SwitchParameter(forceSwitch); // Act uninstallCmdlet.Object.Execute(); // Assert Assert.Equal("my-id", vsPackageManager.PackageId); Assert.Equal(new SemanticVersion("2.8"), vsPackageManager.Version); Assert.True(vsPackageManager.ForceRemove); }
public void InstallPackageCmdletUsesPackageManangerWithSourceIfSpecified() { // Arrange var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); var vsPackageManager = new MockVsPackageManager(); var sourceVsPackageManager = new MockVsPackageManager(); var mockPackageRepository = new MockPackageRepository(); var sourceProvider = GetPackageSourceProvider(new PackageSource("somesource")); var repositoryFactory = new Mock <IPackageRepositoryFactory>(); repositoryFactory.Setup(c => c.CreateRepository(It.Is <string>(s => s == "somesource"))).Returns(mockPackageRepository); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny <IPackageRepository>(), true)).Returns(sourceVsPackageManager); var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, repositoryFactory.Object, sourceProvider, null, null, new Mock <IVsCommonOperations>().Object); cmdlet.Source = "somesource"; cmdlet.Id = "my-id"; cmdlet.Version = new SemanticVersion("2.8"); // Act cmdlet.Execute(); // Assert Assert.Same(sourceVsPackageManager, cmdlet.PackageManager); }
public void UpdatePackageCmdletDoNotInvokeProductUpdateCheckWhenSourceIsNotHttpAddress() { // Arrange string source = "ftp://bing.com"; var productUpdateService = new Mock <IProductUpdateService>(); var sourceRepository = new Mock <IPackageRepository>(); sourceRepository.Setup(p => p.Source).Returns(source); var vsPackageManager = new MockVsPackageManager(sourceRepository.Object); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(sourceRepository.Object, true)).Returns(vsPackageManager); var sourceProvider = GetPackageSourceProvider(new PackageSource(source, "bing")); var repositoryFactory = new Mock <IPackageRepositoryFactory>(); repositoryFactory.Setup(c => c.CreateRepository(source)).Returns(sourceRepository.Object); var cmdlet = new UpdatePackageCommand(TestUtils.GetSolutionManagerWithProjects("foo"), packageManagerFactory.Object, repositoryFactory.Object, sourceProvider, null, productUpdateService.Object, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object); cmdlet.Id = "my-id"; cmdlet.Version = new SemanticVersion("2.8"); cmdlet.IgnoreDependencies = new SwitchParameter(isPresent: true); cmdlet.Source = source; cmdlet.ProjectName = "foo"; // Act cmdlet.Execute(); // Assert productUpdateService.Verify(p => p.CheckForAvailableUpdateAsync(), Times.Never()); }
public void InstallPackageCmdletDoNotInvokeProductUpdateCheckWhenSourceIsNotHttpAddress() { // Arrange string source = "ftp://bing.com"; var productUpdateService = new Mock <IProductUpdateService>(); var sourceRepository = new Mock <IPackageRepository>(); sourceRepository.Setup(p => p.Source).Returns(source); var vsPackageManager = new MockVsPackageManager(sourceRepository.Object); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny <string>())).Returns(vsPackageManager); var cmdlet = new Mock <InstallPackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, productUpdateService.Object) { CallBase = true }; cmdlet.Object.Id = "my-id"; cmdlet.Object.Version = new Version("2.8"); cmdlet.Object.IgnoreDependencies = new SwitchParameter(true); cmdlet.Object.Source = source; // Act cmdlet.Object.Execute(); // Assert productUpdateService.Verify(p => p.CheckForAvailableUpdateAsync(), Times.Never()); }
public void UpdatePackageCmdletPassesParametersCorrectlyWhenIdAndVersionAreSpecified() { // Arrange var vsPackageManager = new MockVsPackageManager(); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); var mockPackageRepository = new MockPackageRepository(); var sourceProvider = GetPackageSourceProvider(new PackageSource("somesource")); var repositoryFactory = new Mock <IPackageRepositoryFactory>(); repositoryFactory.Setup(c => c.CreateRepository(It.Is <string>(s => s == "somesource"))).Returns(mockPackageRepository); var cmdlet = new UpdatePackageCommand(TestUtils.GetSolutionManagerWithProjects("foo"), packageManagerFactory.Object, repositoryFactory.Object, sourceProvider, null, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object); cmdlet.Id = "my-id"; cmdlet.Version = new SemanticVersion("2.8"); cmdlet.ProjectName = "foo"; // Act cmdlet.Execute(); // Assert Assert.Equal("my-id", vsPackageManager.PackageId); Assert.Equal(new SemanticVersion("2.8"), vsPackageManager.Version); }
public void InstallPackageCmdletInvokeProductUpdateCheckWhenSourceIsHttpAddressAndSourceNameIsSpecified() { // Arrange string source = "http://bing.com"; string sourceName = "bing"; var productUpdateService = new Mock <IProductUpdateService>(); var sourceRepository = new Mock <IPackageRepository>(); sourceRepository.Setup(p => p.Source).Returns(source); var vsPackageManager = new MockVsPackageManager(sourceRepository.Object); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); var packageRepositoryFactory = new Mock <IPackageRepositoryFactory>(); var sourceProvider = GetPackageSourceProvider(new PackageSource(source, sourceName)); packageRepositoryFactory.Setup(c => c.CreateRepository(source)).Returns(sourceRepository.Object); packageManagerFactory.Setup(m => m.CreatePackageManager(sourceRepository.Object, true)).Returns(vsPackageManager); var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, packageRepositoryFactory.Object, sourceProvider, null, productUpdateService.Object, new Mock <IVsCommonOperations>().Object); cmdlet.Id = "my-id"; cmdlet.Version = new SemanticVersion("2.8"); cmdlet.IgnoreDependencies = new SwitchParameter(true); cmdlet.Source = sourceName; // Act cmdlet.Execute(); // Assert productUpdateService.Verify(p => p.CheckForAvailableUpdateAsync(), Times.Once()); }
public void SafeUpdatePackageDoNotUpdateToUnlistedPackage(string versionA1, string versionA2) { // Arrange var packageA1 = PackageUtility.CreatePackage("A", versionA1); var packageA2 = PackageUtility.CreatePackage("A", versionA2, listed: false); var sharedRepository = new MockSharedPackageRepository(); sharedRepository.AddPackage(packageA1); var packageRepository = new MockPackageRepository { packageA1, packageA2 }; var packageManager = new MockVsPackageManager( TestUtils.GetSolutionManagerWithProjects(), packageRepository, sharedRepository); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new UpdatePackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, new Mock <IHttpClientEvents>().Object, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object); cmdlet.Id = "A"; cmdlet.Safe = true; cmdlet.Execute(); // Assert Assert.True(sharedRepository.Contains(packageA1)); Assert.False(sharedRepository.Contains(packageA2)); }
public void InstallPackageCmdletPassesParametersCorrectlyWhenIdAndVersionAreSpecified() { // Arrange var vsPackageManager = new MockVsPackageManager(); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); var cmdlet = new InstallPackageCommand( TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, null, null, new Mock <IVsCommonOperations>().Object); cmdlet.Id = "my-id"; cmdlet.Version = new SemanticVersion("2.8"); // Act cmdlet.Execute(); // Assert Assert.Equal("my-id", vsPackageManager.PackageId); Assert.Equal(new SemanticVersion("2.8"), vsPackageManager.Version); }
public void UpdatePackageWithProjectManagerSetOperationToUpdate() { // Arrange var localRepository = new MockSharedPackageRepository(); var sourceRepository = new MockPackageRepository(); var projectRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), projectRepository); var project = TestUtils.GetProject("project runway", projectFiles: new[] { "dotnetjunky.cs" }); var packageManager = new MockVsPackageManager( TestUtils.GetSolutionManager(defaultProjectName: "project runway", projects: new[] { project }), sourceRepository, new Mock <IFileSystemProvider>().Object, projectSystem, localRepository, new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object); packageManager.RegisterProjectManager(project, projectManager); var package = PackageUtility.CreatePackage("phuong", "1.0", new[] { "hello" }); localRepository.AddPackage(package); projectRepository.AddPackage(package); var package2 = PackageUtility.CreatePackage("phuong", "2.0", new[] { "hello" }); sourceRepository.AddPackage(package2); // Act packageManager.UpdatePackage( projectManager, "phuong", new SemanticVersion("2.0"), updateDependencies: true, allowPrereleaseVersions: true, logger: NullLogger.Instance); // Assert Assert.Equal("Update", sourceRepository.LastOperation); Assert.Equal("phuong", sourceRepository.LastMainPackageId); Assert.Equal("2.0", sourceRepository.LastMainPackageVersion); }
public void UpdatePackageCmdletPassesIgnoreDependencySwitchCorrectly() { // Arrange var vsPackageManager = new MockVsPackageManager(); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); var cmdlet = new Mock<UpdatePackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, null) { CallBase = true }; cmdlet.Object.Id = "my-id"; cmdlet.Object.Version = new Version("2.8"); // Act cmdlet.Object.Execute(); // Assert Assert.AreEqual("my-id", vsPackageManager.PackageId); Assert.AreEqual(new Version("2.8"), vsPackageManager.Version); Assert.IsTrue(vsPackageManager.UpdateDependencies); }
public void UninstallPackageCmdletPassesRemoveDependencyCorrectly() { // Arrange var vsPackageManager = new MockVsPackageManager(); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); var uninstallCmdlet = new Mock<UninstallPackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object) { CallBase = true }; uninstallCmdlet.Object.Id = "my-id"; uninstallCmdlet.Object.Version = new SemanticVersion("2.8"); uninstallCmdlet.Object.RemoveDependencies = new SwitchParameter(true); // Act uninstallCmdlet.Object.Execute(); // Assert Assert.Equal("my-id", vsPackageManager.PackageId); Assert.Equal(new SemanticVersion("2.8"), vsPackageManager.Version); Assert.True(vsPackageManager.RemoveDependencies); }
public void UninstallPackageCmdletPassesParametersCorrectlyWhenIdAndVersionAreSpecified() { // Arrange var id = "my-id"; var version = new SemanticVersion("2.8"); var vsPackageManager = new MockVsPackageManager(); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); var uninstallCmdlet = new Mock<UninstallPackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsCommonOperations>().Object) { CallBase = true }; uninstallCmdlet.Object.Id = id; uninstallCmdlet.Object.Version = version; // Act uninstallCmdlet.Object.Execute(); // Assert Assert.Equal("my-id", vsPackageManager.PackageId); Assert.Equal(new SemanticVersion("2.8"), vsPackageManager.Version); }
public void UpdatePackageCmdletSpecifiesUpdateOperationDuringExecution() { // Arrange var mockPackageRepository = new MockPackageRepository(); var vsPackageManager = new MockVsPackageManager(mockPackageRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); var sourceProvider = GetPackageSourceProvider(new PackageSource("somesource")); var repositoryFactory = new Mock<IPackageRepositoryFactory>(); repositoryFactory.Setup(c => c.CreateRepository(It.Is<string>(s => s == "somesource"))).Returns(mockPackageRepository); var cmdlet = new UpdatePackageCommand(TestUtils.GetSolutionManagerWithProjects("foo"), packageManagerFactory.Object, repositoryFactory.Object, sourceProvider, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object); cmdlet.Id = "my-id"; cmdlet.Version = new SemanticVersion("2.8"); cmdlet.ProjectName = "foo"; // Act cmdlet.Execute(); // Assert Assert.Equal(RepositoryOperationNames.Update, mockPackageRepository.LastOperation); }
public void InstallPackageCmdletPassesParametersCorrectlyWhenIdAndVersionAreSpecified() { // Arrange var vsPackageManager = new MockVsPackageManager(); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); var cmdlet = new Mock <InstallPackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, null) { CallBase = true }; cmdlet.Object.Id = "my-id"; cmdlet.Object.Version = new Version("2.8"); // Act cmdlet.Object.Execute(); // Assert Assert.AreEqual("my-id", vsPackageManager.PackageId); Assert.AreEqual(new Version("2.8"), vsPackageManager.Version); }
public void UpdatePackageCmdletPassesParametersCorrectlyWhenIdAndVersionAreSpecified() { // Arrange var vsPackageManager = new MockVsPackageManager(); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); var mockPackageRepository = new MockPackageRepository(); var sourceProvider = GetPackageSourceProvider(new PackageSource("somesource")); var repositoryFactory = new Mock<IPackageRepositoryFactory>(); repositoryFactory.Setup(c => c.CreateRepository(It.Is<string>(s => s == "somesource"))).Returns(mockPackageRepository); var cmdlet = new UpdatePackageCommand(TestUtils.GetSolutionManagerWithProjects("foo"), packageManagerFactory.Object, repositoryFactory.Object, sourceProvider, null, null, new Mock<IVsCommonOperations>().Object); cmdlet.Id = "my-id"; cmdlet.Version = new SemanticVersion("2.8"); cmdlet.ProjectName = "foo"; // Act cmdlet.Execute(); // Assert Assert.Equal("my-id", vsPackageManager.PackageId); Assert.Equal(new SemanticVersion("2.8"), vsPackageManager.Version); }
public void UpdatePackageCmdletPassesIgnoreDependencySwitchCorrectly() { // Arrange var vsPackageManager = new MockVsPackageManager(); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); var cmdlet = new Mock <UpdatePackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, null) { CallBase = true }; cmdlet.Object.Id = "my-id"; cmdlet.Object.Version = new Version("2.8"); // Act cmdlet.Object.Execute(); // Assert Assert.AreEqual("my-id", vsPackageManager.PackageId); Assert.AreEqual(new Version("2.8"), vsPackageManager.Version); Assert.IsTrue(vsPackageManager.UpdateDependencies); }
public void InstallPackageCmdletUsesPackageManangerWithSourceIfSpecified() { // Arrange var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); var vsPackageManager = new MockVsPackageManager(); var sourceVsPackageManager = new MockVsPackageManager(); var mockPackageRepository = new MockPackageRepository(); var sourceProvider = GetPackageSourceProvider(new PackageSource("somesource")); var repositoryFactory = new Mock<IPackageRepositoryFactory>(); repositoryFactory.Setup(c => c.CreateRepository(It.Is<string>(s => s == "somesource"))).Returns(mockPackageRepository); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), true)).Returns(sourceVsPackageManager); var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, repositoryFactory.Object, sourceProvider, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object); cmdlet.Source = "somesource"; cmdlet.Id = "my-id"; cmdlet.Version = new SemanticVersion("2.8"); // Act cmdlet.Execute(); // Assert Assert.Same(sourceVsPackageManager, cmdlet.PackageManager); }
public void UpdatePackageCmdletInvokeProductUpdateCheckWhenSourceIsHttpAddress() { // Arrange string source = "http://bing.com"; var productUpdateService = new Mock<IProductUpdateService>(); var sourceRepository = new Mock<IPackageRepository>(); sourceRepository.Setup(p => p.Source).Returns(source); var vsPackageManager = new MockVsPackageManager(sourceRepository.Object); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<string>())).Returns(vsPackageManager); var cmdlet = new Mock<UpdatePackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, productUpdateService.Object) { CallBase = true }; cmdlet.Object.Id = "my-id"; cmdlet.Object.Version = new Version("2.8"); cmdlet.Object.IgnoreDependencies = new SwitchParameter(isPresent: true); cmdlet.Object.Source = source; // Act cmdlet.Object.Execute(); // Assert productUpdateService.Verify(p => p.CheckForAvailableUpdateAsync(), Times.Once()); }
public void InstallPackageCmdletUsesPackageManangerWithSourceIfSpecified() { // Arrange var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); var vsPackageManager = new MockVsPackageManager(); var sourceVsPackageManager = new MockVsPackageManager(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); packageManagerFactory.Setup(m => m.CreatePackageManager("somesource")).Returns(sourceVsPackageManager); var cmdlet = new Mock <InstallPackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, null) { CallBase = true }; cmdlet.Object.Source = "somesource"; cmdlet.Object.Id = "my-id"; cmdlet.Object.Version = new Version("2.8"); // Act cmdlet.Object.Execute(); // Assert Assert.AreSame(sourceVsPackageManager, cmdlet.Object.PackageManager); }
public void UpdatePackageCmdletSpecifiesUpdateOperationDuringExecution() { // Arrange var mockPackageRepository = new MockPackageRepository(); var vsPackageManager = new MockVsPackageManager(mockPackageRepository); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); var sourceProvider = GetPackageSourceProvider(new PackageSource("somesource")); var repositoryFactory = new Mock <IPackageRepositoryFactory>(); repositoryFactory.Setup(c => c.CreateRepository(It.Is <string>(s => s == "somesource"))).Returns(mockPackageRepository); var cmdlet = new UpdatePackageCommand(TestUtils.GetSolutionManagerWithProjects("foo"), packageManagerFactory.Object, repositoryFactory.Object, sourceProvider, null, null, new Mock <IVsCommonOperations>().Object); cmdlet.Id = "my-id"; cmdlet.Version = new SemanticVersion("2.8"); cmdlet.ProjectName = "foo"; // Act cmdlet.Execute(); // Assert Assert.Equal(RepositoryOperationNames.Update, mockPackageRepository.LastOperation); }
public void UninstallPackageCmdletPassesRemoveDependencyCorrectly() { // Arrange var vsPackageManager = new MockVsPackageManager(); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); var uninstallCmdlet = new Mock <UninstallPackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null) { CallBase = true }; uninstallCmdlet.Object.Id = "my-id"; uninstallCmdlet.Object.Version = new Version("2.8"); uninstallCmdlet.Object.RemoveDependencies = new SwitchParameter(true); // Act uninstallCmdlet.Object.Execute(); // Assert Assert.AreEqual("my-id", vsPackageManager.PackageId); Assert.AreEqual(new Version("2.8"), vsPackageManager.Version); Assert.IsTrue(vsPackageManager.RemoveDependencies); }
public void UninstallPackageCmdletPassesParametersCorrectlyWhenIdAndVersionAreSpecified() { // Arrange var id = "my-id"; var version = new SemanticVersion("2.8"); var vsPackageManager = new MockVsPackageManager(); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); var uninstallCmdlet = new Mock <UninstallPackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object) { CallBase = true }; uninstallCmdlet.Object.Id = id; uninstallCmdlet.Object.Version = version; // Act uninstallCmdlet.Object.Execute(); // Assert Assert.Equal("my-id", vsPackageManager.PackageId); Assert.Equal(new SemanticVersion("2.8"), vsPackageManager.Version); }
public void InstallPackageCmdletPassesIgnoreDependencySwitchCorrectly() { // Arrange var vsPackageManager = new MockVsPackageManager(); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); var cmdlet = new InstallPackageCommand( TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, null, null, new Mock<IVsCommonOperations>().Object); cmdlet.Id = "my-id"; cmdlet.Version = new SemanticVersion("2.8"); cmdlet.IgnoreDependencies = new SwitchParameter(true); // Act cmdlet.Execute(); // Assert Assert.Equal("my-id", vsPackageManager.PackageId); Assert.Equal(new SemanticVersion("2.8"), vsPackageManager.Version); Assert.True(vsPackageManager.IgnoreDependencies); }
public void InstallPackageCmdletSpecifiesInstallOperationDuringExecution() { // Arrange var repo = new MockPackageRepository(); var vsPackageManager = new MockVsPackageManager(repo); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); var cmdlet = new InstallPackageCommand( TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object); cmdlet.Id = "my-id"; cmdlet.Version = new SemanticVersion("2.8"); // Act cmdlet.Execute(); // Assert Assert.Equal(RepositoryOperationNames.Install, repo.LastOperation); }
public void InstallPackageCmdletDoNotInvokeProductUpdateCheckWhenSourceIsNotHttpAddressAndSourceNameIsSpecified() { // Arrange string source = "ftp://bing.com"; string sourceName = "BING"; var productUpdateService = new Mock<IProductUpdateService>(); var sourceRepository = new Mock<IPackageRepository>(); sourceRepository.Setup(p => p.Source).Returns(source); var vsPackageManager = new MockVsPackageManager(sourceRepository.Object); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager(sourceRepository.Object, true)).Returns(vsPackageManager); var packageRepositoryFactory = new Mock<IPackageRepositoryFactory>(); var sourceProvider = GetPackageSourceProvider(new PackageSource(source, sourceName)); packageRepositoryFactory.Setup(c => c.CreateRepository(source)).Returns(sourceRepository.Object); var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, packageRepositoryFactory.Object, sourceProvider, null, productUpdateService.Object, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object); cmdlet.Id = "my-id"; cmdlet.Version = new SemanticVersion("2.8"); cmdlet.IgnoreDependencies = new SwitchParameter(true); cmdlet.Source = sourceName; // Act cmdlet.Execute(); // Assert productUpdateService.Verify(p => p.CheckForAvailableUpdateAsync(), Times.Never()); }
public void InstallPackageCmdletFallsbackToCacheWhenNetworkIsUnavailable() { // Arrange var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); var repositoryFactory = new Mock<IPackageRepositoryFactory>(); var vsPackageManager = new MockVsPackageManager(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); var sourceVsPackageManager = new MockVsPackageManager(); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), true)).Returns(sourceVsPackageManager); var userSettings = new Mock<ISettings>(); userSettings.Setup(s => s.GetSettingValues("packageSources", true)).Returns(new[] { new SettingValue("one", @"\\LetsHopeThisDirectory\IsNotAvaialble", false), }); userSettings.Setup(s => s.GetValues("activePackageSource")) .Returns(new[] { new KeyValuePair<string, string>("one", @"\\LetsHopeThisDirectory\IsNotAvaialble") }); var provider = new VsPackageSourceProvider(userSettings.Object, CreateDefaultSourceProvider(userSettings.Object), new Mock<IVsShellInfo>().Object); var activeSource = provider.ActivePackageSource; //Act var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, repositoryFactory.Object, provider, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, false); cmdlet.Id = "my-id"; cmdlet.Execute(); // Assert Assert.Equal(cmdlet.Source, NuGet.MachineCache.Default.Source); }
public void ReinstallOnePackageInOneProjectSetOperationToUpdate() { // Arrange var localRepository = new MockSharedPackageRepository(); var sourceRepository = new MockPackageRepository(); var projectRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), projectRepository); var project = TestUtils.GetProject("project runway", projectFiles: new[] { "dotnetjunky.cs" }); var packageManager = new MockVsPackageManager( TestUtils.GetSolutionManager(defaultProjectName: "project runway", projects: new[] { project }), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); packageManager.RegisterProjectManager(project, projectManager); var package = PackageUtility.CreatePackage("phuong", "1.0", new[] { "hello" }); localRepository.AddPackage(package); projectRepository.AddPackage(package); sourceRepository.AddPackage(package); // Act packageManager.ReinstallPackage( projectManager, "phuong", updateDependencies: true, allowPrereleaseVersions: true, logger: NullLogger.Instance); // Assert Assert.Equal("Reinstall", sourceRepository.LastOperation); Assert.Equal("phuong", sourceRepository.LastMainPackageId); }
public void FallbackToCacheDoesntHappenWhenAggregateIsUsedAndLocalSourceIsAvailable() { // Arrange string localdrive = System.Environment.GetEnvironmentVariable("TEMP"); var userSettings = new Mock<ISettings>(); userSettings.Setup(s => s.GetSettingValues("packageSources", true)).Returns(new[] { new SettingValue("one", @"\\LetsHopeThisDirectory\IsNotAvaialble", false), new SettingValue("two", localdrive, false), new SettingValue("three", @"http://SomeHttpSource/NotAvailable", false), }); userSettings.Setup(s => s.GetValues("activePackageSource")) .Returns(new[] { new KeyValuePair<string, string>("All", @"(All)"), }); var provider = new VsPackageSourceProvider(userSettings.Object, CreateDefaultSourceProvider(userSettings.Object), new Mock<IVsShellInfo>().Object); var activeSource = provider.ActivePackageSource; var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); var repositoryFactory = new Mock<IPackageRepositoryFactory>(); var vsPackageManager = new MockVsPackageManager(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); var sourceVsPackageManager = new MockVsPackageManager(); packageManagerFactory.Setup(m => m.CreatePackageManager(It.IsAny<IPackageRepository>(), true)).Returns(sourceVsPackageManager); //Act var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, repositoryFactory.Object, provider, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, false); cmdlet.Id = "my-id"; cmdlet.Execute(); // Assert Assert.NotEqual(cmdlet.Source, NuGet.MachineCache.Default.Source); }
public void SafeUpdatePackageDoNotUpdateToUnlistedPackageWithPrerelease(string versionA1, string versionA2) { // Arrange var packageA1 = PackageUtility.CreatePackage("A", versionA1); var packageA2 = PackageUtility.CreatePackage("A", versionA2, listed: false); var sharedRepository = new MockSharedPackageRepository(); sharedRepository.AddPackage(packageA1); var packageRepository = new MockPackageRepository { packageA1, packageA2 }; var packageManager = new MockVsPackageManager( TestUtils.GetSolutionManagerWithProjects(), packageRepository, sharedRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new UpdatePackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object); cmdlet.Id = "A"; cmdlet.IncludePrerelease = true; cmdlet.Safe = true; cmdlet.Execute(); // Assert Assert.False(sharedRepository.Contains(packageA2)); }
public void UpdatePackageUpdateToUnlistedPackageIfVersionIsSet(string versionA1, string versionA2) { // Arrange var packageA1 = PackageUtility.CreatePackage("A", versionA1); var packageA2 = PackageUtility.CreatePackage("A", versionA2, listed: false); var localRepository = new Mock<MockPackageRepository>() { CallBase = true }; var sharedRepository = localRepository.As<ISharedPackageRepository>(); localRepository.Object.AddPackage(packageA1); var packageRepository = new MockPackageRepository { packageA1, packageA2 }; var packageManager = new MockVsPackageManager( TestUtils.GetSolutionManagerWithProjects(), packageRepository, sharedRepository.Object); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new UpdatePackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object); cmdlet.Id = "A"; cmdlet.Version = new SemanticVersion(versionA2); cmdlet.Execute(); // Assert Assert.False(localRepository.Object.Contains(packageA1)); Assert.True(localRepository.Object.Contains(packageA2)); }
public void ReinstallPackagesSkipRestallingForOneProjectButProceedWithTheOther() { // Arrange var localRepositoryMock = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); var localRepository = localRepositoryMock.Object; var sourceRepository = new MockPackageRepository(); var projectSystem1 = new MockProjectSystem(new FrameworkName(".NETFramework, Version=v3.0")); var pathResolver1 = new DefaultPackagePathResolver(projectSystem1); var packageReferenceRepository1 = new PackageReferenceRepository(projectSystem1, localRepository); var projectManager1 = new ProjectManager(localRepository, pathResolver1, projectSystem1, packageReferenceRepository1); var projectSystem2 = new MockProjectSystem(new FrameworkName(".NETCore, Version=v4.5")); var pathResolver2 = new DefaultPackagePathResolver(projectSystem2); var packageReferenceRepository2 = new PackageReferenceRepository(projectSystem2, localRepository); var projectManager2 = new ProjectManager(localRepository, pathResolver2, projectSystem2, packageReferenceRepository2); var project1 = TestUtils.GetProject("Project1"); var project2 = TestUtils.GetProject("Project2"); var packageManager = new MockVsPackageManager( TestUtils.GetSolutionManager(projects: new[] { project1, project2 }), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem2, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); packageManager.RegisterProjectManager(project1, projectManager1); packageManager.RegisterProjectManager(project2, projectManager2); var packageA = PackageUtility.CreatePackage( "A", "1.2-alpha", new[] { "net30\\content.txt", "silverlight40\\content4.txt" }, new[] { "lib\\net30\\ref.dll", "lib\\silverlight40\\refsl.dll" }); var packageB = PackageUtility.CreatePackage( "B", "2.0", new[] { "winrt45\\hello.txt", "sl4-wp71\\world.txt" }, new[] { "lib\\winrt45\\comma.dll", "lib\\sl4-wp71\\dude.dll" }); sourceRepository.Add(packageA); localRepository.AddPackage(packageA); localRepository.AddPackage(packageB); // install package A -> project 1 // and package B -> project 2 packageManager.InstallPackage(projectManager1, "A", new SemanticVersion("1.2-alpha"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null); packageManager.InstallPackage(projectManager2, "B", new SemanticVersion("2.0"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null); // now change project's target framework to silverlight projectSystem1.ChangeTargetFramework(new FrameworkName("Silverlight, Version=v4.0")); projectSystem2.ChangeTargetFramework(new FrameworkName("Silverlight, Version=v4.0, Profile=WindowsPhone71")); localRepositoryMock.Setup(p => p.IsReferenced("A", new SemanticVersion("1.2-alpha"))).Returns((string id, SemanticVersion version) => projectManager1.LocalRepository.Exists(id, version)); localRepositoryMock.Setup(p => p.IsReferenced("B", new SemanticVersion("2.0"))).Returns((string id, SemanticVersion version) => projectManager2.LocalRepository.Exists(id, version)); var logger = new Mock<ILogger>(); logger.Setup(s => s.Log( MessageLevel.Warning, "Skipped reinstalling package '{0}' in project '{1}' because the package does not exist in the package source.", "B 2.0", "Project2") ).Verifiable(); // Act packageManager.ReinstallPackages(updateDependencies: true, allowPrereleaseVersions: false, logger: logger.Object, eventListener: NullPackageOperationEventListener.Instance); // Assert logger.Verify(); Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.True(projectManager1.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.False(projectSystem1.FileExists("content.txt")); Assert.True(projectSystem1.FileExists("content4.txt")); Assert.False(projectSystem1.ReferenceExists("ref.dll")); Assert.True(projectSystem1.ReferenceExists("refsl.dll")); Assert.True(packageManager.LocalRepository.Exists("B", new SemanticVersion("2.0"))); Assert.True(projectManager2.LocalRepository.Exists("B", new SemanticVersion("2.0"))); Assert.True(projectSystem2.FileExists("hello.txt")); Assert.False(projectSystem2.FileExists("world.txt")); Assert.True(projectSystem2.ReferenceExists("comma.dll")); Assert.False(projectSystem2.ReferenceExists("dude.dll")); }
public void UpdatePackageCmdletPassesParametersCorrectlyWhenIdAndVersionAreSpecified() { // Arrange var vsPackageManager = new MockVsPackageManager(); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); var cmdlet = new Mock<UpdatePackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, null) { CallBase = true }; cmdlet.Object.Id = "my-id"; cmdlet.Object.Version = new Version("2.8"); // Act cmdlet.Object.Execute(); // Assert Assert.AreEqual("my-id", vsPackageManager.PackageId); Assert.AreEqual(new Version("2.8"), vsPackageManager.Version); }
public void UpdatePackageCmdletUsesPackageManangerWithSourceIfSpecified() { // Arrange var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); var vsPackageManager = new MockVsPackageManager(); var sourceVsPackageManager = new MockVsPackageManager(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(vsPackageManager); packageManagerFactory.Setup(m => m.CreatePackageManager("somesource")).Returns(sourceVsPackageManager); var cmdlet = new Mock<UpdatePackageCommand>(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, null) { CallBase = true }; cmdlet.Object.Source = "somesource"; cmdlet.Object.Id = "my-id"; cmdlet.Object.Version = new Version("2.8"); // Act cmdlet.Object.Execute(); // Assert Assert.AreSame(sourceVsPackageManager, cmdlet.Object.PackageManager); }
public void ReinstallPackagesRestoresPackageInAllProjectsWithNewContentIfSourcePackageChanges() { // Arrange var localRepositoryMock = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); var localRepository = localRepositoryMock.Object; var sourceRepository = new MockPackageRepository(); var projectSystem1 = new MockProjectSystem(); var pathResolver1 = new DefaultPackagePathResolver(projectSystem1); var packageReferenceRepository1 = new PackageReferenceRepository(projectSystem1, localRepository); var projectManager1 = new ProjectManager(localRepository, pathResolver1, projectSystem1, packageReferenceRepository1); var projectSystem2 = new MockProjectSystem(); var pathResolver2 = new DefaultPackagePathResolver(projectSystem2); var packageReferenceRepository2 = new PackageReferenceRepository(projectSystem2, localRepository); var projectManager2 = new ProjectManager(localRepository, pathResolver2, projectSystem2, packageReferenceRepository2); var project1 = TestUtils.GetProject("Project1"); var project2 = TestUtils.GetProject("Project2"); var packageManager = new MockVsPackageManager( TestUtils.GetSolutionManager(projects: new[] { project1, project2 }), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem2, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); packageManager.RegisterProjectManager(project1, projectManager1); packageManager.RegisterProjectManager(project2, projectManager2); var packageA = PackageUtility.CreatePackage( "A", "1.2-alpha", new[] { "content.txt" }, new[] { "lib\\ref.dll" }); var packageA2 = PackageUtility.CreatePackage( "A", "1.2-alpha", new[] { "foo.txt" }, new[] { "lib\\bar.dll" }); var packageB = PackageUtility.CreatePackage( "B", "2.0", new[] { "hello.txt" }, new[] { "lib\\comma.dll" }); var packageB2 = PackageUtility.CreatePackage( "B", "2.0", new[] { "world.txt" }, new[] { "lib\\dude.dll" }); sourceRepository.Add(packageA); sourceRepository.Add(packageB); // install package A -> project 1 // and package B -> project 2 packageManager.InstallPackage(projectManager1, "A", new SemanticVersion("1.2-alpha"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null); packageManager.InstallPackage(projectManager2, "B", new SemanticVersion("2.0"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null); Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.True(projectManager1.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.True(projectSystem1.FileExists("content.txt")); Assert.True(projectSystem1.ReferenceExists("ref.dll")); Assert.True(packageManager.LocalRepository.Exists("B", new SemanticVersion("2.0"))); Assert.True(projectManager2.LocalRepository.Exists("B", new SemanticVersion("2.0"))); Assert.True(projectSystem2.FileExists("hello.txt")); Assert.True(projectSystem2.ReferenceExists("comma.dll")); // now change the package A and B to different packages sourceRepository.RemovePackage(packageA); sourceRepository.RemovePackage(packageB); sourceRepository.AddPackage(packageA2); sourceRepository.AddPackage(packageB2); localRepositoryMock.Setup(p => p.IsReferenced("A", new SemanticVersion("1.2-alpha"))).Returns((string id, SemanticVersion version) => projectManager1.LocalRepository.Exists(id, version)); localRepositoryMock.Setup(p => p.IsReferenced("B", new SemanticVersion("2.0"))).Returns((string id, SemanticVersion version) => projectManager2.LocalRepository.Exists(id, version)); // Act packageManager.ReinstallPackages(updateDependencies: true, allowPrereleaseVersions: false, logger: NullLogger.Instance, eventListener: NullPackageOperationEventListener.Instance); // Assert Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.True(projectManager1.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.False(projectSystem1.FileExists("content.txt")); Assert.True(projectSystem1.FileExists("foo.txt")); Assert.False(projectSystem1.ReferenceExists("ref.dll")); Assert.True(projectSystem1.ReferenceExists("bar.dll")); Assert.True(packageManager.LocalRepository.Exists("B", new SemanticVersion("2.0"))); Assert.True(projectManager2.LocalRepository.Exists("B", new SemanticVersion("2.0"))); Assert.False(projectSystem2.FileExists("hello.txt")); Assert.True(projectSystem2.FileExists("world.txt")); Assert.False(projectSystem2.ReferenceExists("comma.dll")); Assert.True(projectSystem2.ReferenceExists("dude.dll")); }
public void UpdatePackageCmdletInvokeProductUpdateCheckWhenSourceIsHttpAddress() { // Arrange string source = "http://bing.com"; var productUpdateService = new Mock<IProductUpdateService>(); var sourceRepository = new Mock<IPackageRepository>(); sourceRepository.Setup(p => p.Source).Returns(source); var vsPackageManager = new MockVsPackageManager(sourceRepository.Object); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(c => c.CreatePackageManager(sourceRepository.Object, true)).Returns(vsPackageManager); var mockPackageRepository = new MockPackageRepository(); var sourceProvider = GetPackageSourceProvider(new PackageSource(source)); var repositoryFactory = new Mock<IPackageRepositoryFactory>(); repositoryFactory.Setup(c => c.CreateRepository(source)).Returns(sourceRepository.Object); var cmdlet = new UpdatePackageCommand(TestUtils.GetSolutionManagerWithProjects("foo"), packageManagerFactory.Object, repositoryFactory.Object, sourceProvider, null, productUpdateService.Object, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object); cmdlet.Id = "my-id"; cmdlet.Version = new SemanticVersion("2.8"); cmdlet.IgnoreDependencies = new SwitchParameter(isPresent: true); cmdlet.Source = source; cmdlet.ProjectName = "foo"; // Act cmdlet.Execute(); // Assert productUpdateService.Verify(p => p.CheckForAvailableUpdateAsync(), Times.Once()); }