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 InstallPackageCmdletInstallPrereleasePackageIfFlagIsPresent() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0.0-a"); var packageRepository = new MockPackageRepository { packageA }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // packageA is not installed yet. Assert.False(packageManager.LocalRepository.IsSolutionReferenced(packageA.Id, packageA.Version)); // Act var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, new Mock <IHttpClientEvents>().Object, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; cmdlet.IncludePrerelease = true; cmdlet.Execute(); // Assert: packageA is installed. var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(1, installedPackages.Count); Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion); }
public void InstallPackageInstallUnlistedPrereleasePackageAsADependency(string versionA, string versionB) { // Arrange var packageA = PackageUtility.CreatePackage("A", versionA, dependencies: new[] { new PackageDependency("B") }); var packageB = PackageUtility.CreatePackage("B", versionB, listed: false); var sharedRepository = new Mock <ISharedPackageRepository>(MockBehavior.Strict); sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty <IPackage>().AsQueryable()); sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable(); sharedRepository.Setup(s => s.AddPackage(packageB)).Verifiable(); sharedRepository.Setup(s => s.IsReferenced("A", new SemanticVersion(versionA))).Returns(true); sharedRepository.Setup(s => s.IsReferenced("B", new SemanticVersion(versionB))).Returns(true); var packageRepository = new MockPackageRepository { packageA, packageB }; var recentPackageRepository = new Mock <IRecentPackageRepository>(); var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock <IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, recentPackageRepository.Object, new VsPackageInstallerEvents()); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, new Mock <IHttpClientEvents>().Object, null, new Mock <IVsCommonOperations>().Object); cmdlet.Id = "A"; cmdlet.IncludePrerelease = true; cmdlet.Execute(); // Assert sharedRepository.Verify(); }
public void InstallPackageShouldPickUnListedPrereleasePackagesIfItSatisfiesContrainsAndOthersAreNot() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B", new VersionSpec { MinVersion = new SemanticVersion("1.0"), IsMinInclusive = true }) }); var packageB1 = PackageUtility.CreatePackage("B", "0.0.9", listed: true); var packageB2 = PackageUtility.CreatePackage("B", "1.0.1-a", listed: false); var sharedRepository = new Mock <ISharedPackageRepository>(); sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty <IPackage>().AsQueryable()); sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable(); sharedRepository.Setup(s => s.AddPackage(packageB2)).Verifiable(); var packageRepository = new MockPackageRepository { packageA, packageB1, packageB2 }; var recentPackageRepository = new Mock <IRecentPackageRepository>(); var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock <IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, recentPackageRepository.Object, new VsPackageInstallerEvents()); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, new Mock <IHttpClientEvents>().Object, null, new Mock <IVsCommonOperations>().Object); cmdlet.Id = "A"; cmdlet.IncludePrerelease = true; cmdlet.Execute(); // Assert sharedRepository.Verify(); sharedRepository.Verify(s => s.AddPackage(packageB1), Times.Never()); }
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 InstallPackageCmdletInstallPrereleasePackageIfFlagIsPresent() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0.0-a"); var sharedRepository = new Mock <ISharedPackageRepository>(MockBehavior.Strict); sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty <IPackage>().AsQueryable()); sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable(); sharedRepository.Setup(s => s.IsReferenced("A", new SemanticVersion("1.0.0-a"))).Returns(true); var packageRepository = new MockPackageRepository { packageA }; var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock <IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock <IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents()); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand( 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.Execute(); // Assert sharedRepository.Verify(); }
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 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); 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 InstallPackageCmdletCreatesPackageManagerWithFallbackFlagSet() { // Arrange var productUpdateService = new Mock <IProductUpdateService>(); var fallbackRepo = new Mock <IVsPackageManager>(); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(c => c.CreatePackageManager()).Returns(fallbackRepo.Object).Verifiable(); packageManagerFactory.Setup(c => c.CreatePackageManager(It.IsAny <IPackageRepository>(), false)).Throws(new Exception()); var repoA = new MockPackageRepository(); var repositoryFactory = new Mock <IPackageRepositoryFactory>(); repositoryFactory.Setup(c => c.CreateRepository("A")).Returns(repoA); var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManagerWithProjects("foo"), packageManagerFactory.Object, repositoryFactory.Object, GetPackageSourceProvider(new PackageSource("A")), null, productUpdateService.Object, new Mock <IVsCommonOperations>().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 InstallPackageShouldPickListedPackagesOverUnlistedOnesAsDependency() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B", new VersionSpec { MinVersion = new SemanticVersion("0.5") }) }); var packageB1 = PackageUtility.CreatePackage("B", "1.0.0", listed: true); var packageB2 = PackageUtility.CreatePackage("B", "1.0.2", listed: false); var sharedRepository = new Mock <ISharedPackageRepository>(); sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty <IPackage>().AsQueryable()); sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable(); sharedRepository.Setup(s => s.AddPackage(packageB1)).Verifiable(); var packageRepository = new MockPackageRepository { packageA, packageB1, packageB2 }; var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock <IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock <IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents()); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(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.Execute(); // Assert sharedRepository.Verify(); sharedRepository.Verify(s => s.AddPackage(packageB2), Times.Never()); }
public void InstallPackageInstallUnlistedPrereleasePackageIfVersionIsSet() { // Arrange var packageA1 = PackageUtility.CreatePackage("A", "1.0.0"); var packageA2 = PackageUtility.CreatePackage("A", "1.0.0-ReleaseCandidate", listed: false); var packageRepository = new MockPackageRepository { packageA1, packageA2 }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, new Mock <IHttpClientEvents>().Object, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; cmdlet.Version = new SemanticVersion("1.0.0-ReleaseCandidate"); cmdlet.IncludePrerelease = true; cmdlet.Execute(); // Assert: the unlisted prerelease packageA2 is installed. var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(1, installedPackages.Count); Assert.Equal(packageA2, installedPackages[0], PackageEqualityComparer.IdAndVersion); }
public SitecoreShipHttpHandler() { // TODO move this construction logic out of here ... var aboutCommand = new AboutCommand(); var installPackageCommand = new InstallPackageCommand(); var installUploadPackageCommand = new InstallUploadPackageCommand(); var latestVersionCommand = new LatestVersionCommand(); var invokePublishingCommand = new InvokePublishingCommand(); var publishingLastCompletedCommand = new PublishingLastCompletedCommand(); var unhandledCommand = new UnhandledCommand(); aboutCommand.SetSuccessor(installPackageCommand); installPackageCommand.SetSuccessor(installUploadPackageCommand); installUploadPackageCommand.SetSuccessor(latestVersionCommand); latestVersionCommand.SetSuccessor(invokePublishingCommand); invokePublishingCommand.SetSuccessor(publishingLastCompletedCommand); publishingLastCompletedCommand.SetSuccessor(unhandledCommand); _commandChain = aboutCommand; }
public void InstallPackageInstallUnlistedPrereleasePackageAsADependency(string versionA, string versionB) { // Arrange var packageA = PackageUtility.CreatePackage("A", versionA, dependencies: new[] { new PackageDependency("B") }); var packageB = PackageUtility.CreatePackage("B", versionB, listed: false); var packageRepository = new MockPackageRepository { packageA, packageB }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, new Mock <IHttpClientEvents>().Object, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; cmdlet.IncludePrerelease = true; cmdlet.Execute(); // Assert var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(2, installedPackages.Count); Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion); Assert.Equal(packageB, installedPackages[1], PackageEqualityComparer.IdAndVersion); }
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 InstallPackageShouldPickListedPackagesOverUnlistedOnesAsDependency() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B", new VersionSpec { MinVersion = new SemanticVersion("0.5") }) }); var packageB1 = PackageUtility.CreatePackage("B", "1.0.0", listed: true); var packageB2 = PackageUtility.CreatePackage("B", "1.0.2", listed: false); var packageRepository = new MockPackageRepository { packageA, packageB1, packageB2 }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, new Mock <IHttpClientEvents>().Object, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; cmdlet.Execute(); // Assert: packageA and packageB1 are installed. packageB1 is picked because // packageB2 is unlisted. var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(2, installedPackages.Count); Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion); Assert.Equal(packageB1, installedPackages[1], PackageEqualityComparer.IdAndVersion); }
public void InstallPackageShouldPickUnListedPrereleasePackagesIfItSatisfiesContrainsAndOthersAreNot() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B", new VersionSpec { MinVersion = new SemanticVersion("1.0"), IsMinInclusive = true }) }); var packageB1 = PackageUtility.CreatePackage("B", "0.0.9", listed: true); var packageB2 = PackageUtility.CreatePackage("B", "1.0.1-a", listed: false); var packageRepository = new MockPackageRepository { packageA, packageB1, packageB2 }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, new Mock <IHttpClientEvents>().Object, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; cmdlet.IncludePrerelease = true; cmdlet.Execute(); // Assert: packageA and packageB2 are installed. // packageB1 is not picked because it cannot be used as a dependency of packageA var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(2, installedPackages.Count); Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion); Assert.Equal(packageB2, installedPackages[1], PackageEqualityComparer.IdAndVersion); }
public void InstallPackageInstallUnlistedPrereleasePackageIfVersionIsSet() { // Arrange var packageA1 = PackageUtility.CreatePackage("A", "1.0.0"); var packageA2 = PackageUtility.CreatePackage("A", "1.0.0-ReleaseCandidate", listed: false); var sharedRepository = new Mock <ISharedPackageRepository>(MockBehavior.Strict); sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty <IPackage>().AsQueryable()); sharedRepository.Setup(s => s.AddPackage(packageA2)); sharedRepository.Setup(s => s.IsReferenced("A", new SemanticVersion("1.0.0-ReleaseCandidate"))).Returns(true); var packageRepository = new MockPackageRepository { packageA1, packageA2 }; var recentPackageRepository = new Mock <IRecentPackageRepository>(); var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock <IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, recentPackageRepository.Object, new VsPackageInstallerEvents()); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, new Mock <IHttpClientEvents>().Object, null, new Mock <IVsCommonOperations>().Object); cmdlet.Id = "A"; cmdlet.Version = new SemanticVersion("1.0.0-ReleaseCandidate"); cmdlet.IncludePrerelease = true; cmdlet.Execute(); // Assert sharedRepository.Verify(s => s.AddPackage(packageA1), Times.Never()); sharedRepository.Verify(s => s.AddPackage(packageA2), Times.Once()); }
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 InstallPackageCmdletThrowsWhenSolutionIsClosed() { // Arrange var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns((IVsPackageManager)null); var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(isSolutionOpen: false), packageManagerFactory.Object, null, null, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object); // Act and Assert ExceptionAssert.Throws<InvalidOperationException>(() => cmdlet.GetResults(), "The current environment doesn't have a solution open."); }
public void InstallPackageCmdletThrowsWhenSolutionIsClosed() { // Arrange var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns((IVsPackageManager)null); var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(isSolutionOpen: false), packageManagerFactory.Object, null, null, null, null, new Mock <IVsCommonOperations>().Object); // Act and Assert ExceptionAssert.Throws <InvalidOperationException>(() => cmdlet.GetResults(), "The current environment doesn't have a solution open."); }
public void InstallPackageIgnoresFailingRepositoriesWhenInstallingPackageWithOrWithoutDependencies() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B") }); var packageB = PackageUtility.CreatePackage("B", "1.0.0", listed: true); var packageC = PackageUtility.CreatePackage("C", "2.0.0"); var mockRepository = new Mock <IPackageRepository>(); mockRepository.Setup(c => c.GetPackages()).Returns(GetPackagesWithException().AsQueryable()).Verifiable(); var packageRepository = new AggregateRepository(new[] { new MockPackageRepository { packageA }, mockRepository.Object, new MockPackageRepository { packageB }, new MockPackageRepository { packageC }, }); var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, new Mock <IHttpClientEvents>().Object, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; cmdlet.Execute(); cmdlet.Id = "C"; cmdlet.Execute(); // Assert var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(3, installedPackages.Count); Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion); Assert.Equal(packageB, installedPackages[1], PackageEqualityComparer.IdAndVersion); Assert.Equal(packageC, installedPackages[2], PackageEqualityComparer.IdAndVersion); mockRepository.Verify(); }
public void InstallPackageCmdletOpenReadmeFileFromPackageIfItIsPresent() { // Arrange var packageA = new Mock <IPackage>(); packageA.Setup(p => p.Id).Returns("A"); packageA.Setup(p => p.Version).Returns(new SemanticVersion("1.0")); packageA.Setup(p => p.Listed).Returns(true); var readme = new Mock <IPackageFile>(); readme.Setup(f => f.Path).Returns("readMe.txt"); readme.Setup(f => f.GetStream()).Returns(new MemoryStream()); packageA.Setup(p => p.GetFiles()).Returns(new IPackageFile[] { readme.Object }); var sharedRepository = new Mock <ISharedPackageRepository>(MockBehavior.Strict); sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty <IPackage>().AsQueryable()); sharedRepository.Setup(s => s.AddPackage(packageA.Object)).Verifiable(); sharedRepository.Setup(s => s.IsReferenced("A", new SemanticVersion("1.0"))).Returns(true); var packageRepository = new MockPackageRepository { packageA.Object }; var recentPackageRepository = new Mock <IRecentPackageRepository>(); var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock <IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, recentPackageRepository.Object, new VsPackageInstallerEvents()); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); var fileOperations = new Mock <IVsCommonOperations>(); // Act var cmdlet = new InstallPackageCommand( TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, new Mock <IHttpClientEvents>().Object, null, fileOperations.Object); cmdlet.Id = "A"; cmdlet.Execute(); // Assert fileOperations.Verify(io => io.OpenFile(It.Is <string>(s => s.EndsWith("A.1.0\\readme.txt", StringComparison.OrdinalIgnoreCase))), Times.Once()); }
public void InstallPackageCmdletOpenReadmeFileFromPackageIfItIsPresent() { // Arrange var packageA = new Mock <IPackage>(); packageA.Setup(p => p.Id).Returns("A"); packageA.Setup(p => p.Version).Returns(new SemanticVersion("1.0")); packageA.Setup(p => p.Listed).Returns(true); var readme = new Mock <IPackageFile>(); readme.Setup(f => f.Path).Returns("readMe.txt"); readme.Setup(f => f.GetStream()).Returns(new MemoryStream()); packageA.Setup(p => p.GetFiles()).Returns(new IPackageFile[] { readme.Object }); packageA.Setup(p => p.GetStream()).Returns(new MemoryStream()); var packageRepository = new MockPackageRepository { packageA.Object }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); var fileOperations = new Mock <IVsCommonOperations>(); // Act var cmdlet = new InstallPackageCommand( packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, new Mock <IHttpClientEvents>().Object, null, fileOperations.Object, new Mock <IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; cmdlet.Execute(); // Assert fileOperations.Verify(io => io.OpenFile(It.Is <string>(s => s.EndsWith("A.1.0\\readme.txt", StringComparison.OrdinalIgnoreCase))), Times.Once()); }
public void InstallPackageCmdletThrowsWhenSolutionIsClosed() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0.0"); var packageRepository = new MockPackageRepository { packageA }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); ((MockSolutionManager2)packageManager.SolutionManager).IsSolutionOpen = false; var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, null, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true); // Act and Assert ExceptionAssert.Throws<InvalidOperationException>(() => cmdlet.GetResults(), "The current environment doesn't have a solution open."); }
public void InstallPackageCmdletDoesNotInstallPrereleasePackageIfFlagIsNotPresent() { // Arrange var sharedRepository = new Mock <ISharedPackageRepository>(MockBehavior.Strict); var packageRepository = new MockPackageRepository { PackageUtility.CreatePackage("A", "1.0.0-a") }; var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock <IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock <IDeleteOnRestartManager>().Object, null); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, null, null, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object); cmdlet.Id = "A"; // Assert ExceptionAssert.Throws <InvalidOperationException>(() => cmdlet.Execute(), "Unable to find package 'A'."); }
public void InstallPackageCmdletThrowsWhenSolutionIsClosed() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0.0"); var packageRepository = new MockPackageRepository { packageA }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); ((MockSolutionManager2)packageManager.SolutionManager).IsSolutionOpen = false; var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, null, null, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object, true); // Act and Assert ExceptionAssert.Throws <InvalidOperationException>(() => cmdlet.GetResults(), "The current environment doesn't have a solution open."); }
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 recentRepo = new Mock <IRecentPackageRepository>(); 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>())).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, null, 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); cmdlet.Id = "P1"; cmdlet.Source = "A"; // Act cmdlet.Execute(); // Assert // If we've come this far, P1 is successfully installed. Assert.True(true); }
private async void InstallPackageAsync() { try { ILibrary selectedPackage = SelectedPackage; _isInstalling = true; InstallPackageCommand.CanExecute(null); Manifest manifest = await Manifest.FromFileAsync(_configFileName, _deps, CancellationToken.None).ConfigureAwait(false); string targetPath = _targetPath; if (!string.IsNullOrEmpty(_configFileName)) { Uri configContainerUri = new Uri(_configFileName, UriKind.Absolute); Uri targetUri = new Uri(targetPath, UriKind.Absolute); targetPath = configContainerUri.MakeRelativeUri(targetUri).ToString(); } manifest.AddLibrary(new LibraryInstallationState { LibraryId = PackageId, ProviderId = selectedPackage.ProviderId, DestinationPath = targetPath, Files = SelectedFiles.ToList() }); await manifest.SaveAsync(_configFileName, CancellationToken.None).ConfigureAwait(false); EnvDTE.Project project = VsHelpers.DTE.SelectedItems.Item(1)?.ProjectItem?.ContainingProject; project?.AddFileToProject(_configFileName); await LibraryHelpers.RestoreAsync(_configFileName).ConfigureAwait(false); _dispatcher.Invoke(() => { _closeDialog(true); }); } catch { } }
private static void ParseArguments(string[] args) { if (args == null || args.Length == 0) { DisplayHelpMessage(); } if (args.Length == 2) { if (args[0] == "Install") { var command = new InstallPackageCommand(_logger, _fileSystem, _apiClient); command.ExecuteAsync(args[1]); } } if (args.Length > 2) { _logger.LogError("Too many arguments provided."); DisplayHelpMessage(); } }
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 InstallPackageCmdletPassesParametersCorrectlyWhenIdAndVersionAreSpecified() { // Arrange var packageA28 = PackageUtility.CreatePackage("A", "2.8"); var packageA31 = PackageUtility.CreatePackage("A", "3.1"); var packageRepository = new MockPackageRepository { packageA28, packageA31 }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand( packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, null, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; cmdlet.Version = new SemanticVersion("2.8"); cmdlet.Execute(); // Assert: version 2.8 is installed. var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(1, installedPackages.Count); Assert.Equal(packageA28, installedPackages[0], PackageEqualityComparer.IdAndVersion); }
public void InstallPackageCmdletPassesIgnoreDependencySwitchCorrectly() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0.0", dependencies: new[] { new PackageDependency("B") }); var packageB = PackageUtility.CreatePackage("B", "1.0.0"); var packageRepository = new MockPackageRepository { packageA, packageB }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock <IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand( packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock <IVsPackageSourceProvider>().Object, null, null, new Mock <IVsCommonOperations>().Object, new Mock <IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; cmdlet.IgnoreDependencies = new SwitchParameter(true); cmdlet.Execute(); // Assert: only packageA is installed. packageB is not. var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(1, installedPackages.Count); Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion); }
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 InstallPackageCmdletOpenReadmeFileFromPackageIfItIsPresent() { // Arrange var packageA = new Mock<IPackage>(); packageA.Setup(p => p.Id).Returns("A"); packageA.Setup(p => p.Version).Returns(new SemanticVersion("1.0")); packageA.Setup(p => p.Listed).Returns(true); var readme = new Mock<IPackageFile>(); readme.Setup(f => f.Path).Returns("readMe.txt"); readme.Setup(f => f.GetStream()).Returns(new MemoryStream()); packageA.Setup(p => p.GetFiles()).Returns(new IPackageFile[] { readme.Object }); packageA.Setup(p => p.GetStream()).Returns(new MemoryStream()); var packageRepository = new MockPackageRepository { packageA.Object }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); var fileOperations = new Mock<IVsCommonOperations>(); // Act var cmdlet = new InstallPackageCommand( packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, fileOperations.Object, new Mock<IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; cmdlet.Execute(); // Assert fileOperations.Verify(io => io.OpenFile(It.Is<string>(s => s.EndsWith("A.1.0\\readme.txt", StringComparison.OrdinalIgnoreCase))), Times.Once()); }
public void InstallPackageCmdletPassesParametersCorrectlyWhenIdAndVersionAreSpecified() { // Arrange var packageA28 = PackageUtility.CreatePackage("A", "2.8"); var packageA31 = PackageUtility.CreatePackage("A", "3.1"); var packageRepository = new MockPackageRepository { packageA28, packageA31 }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand( packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; cmdlet.Version = new SemanticVersion("2.8"); cmdlet.Execute(); // Assert: version 2.8 is installed. var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(1, installedPackages.Count); Assert.Equal(packageA28, installedPackages[0], PackageEqualityComparer.IdAndVersion); }
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 InstallPackageInstallUnlistedPrereleasePackageIfVersionIsSet() { // Arrange var packageA1 = PackageUtility.CreatePackage("A", "1.0.0"); var packageA2 = PackageUtility.CreatePackage("A", "1.0.0-ReleaseCandidate", listed: false); var sharedRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict); sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable()); sharedRepository.Setup(s => s.AddPackage(packageA2)); sharedRepository.Setup(s => s.IsReferenced("A", new SemanticVersion("1.0.0-ReleaseCandidate"))).Returns(true); var packageRepository = new MockPackageRepository { packageA1, packageA2 }; var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents()); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(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("1.0.0-ReleaseCandidate"); cmdlet.IncludePrerelease = true; cmdlet.Execute(); // Assert sharedRepository.Verify(s => s.AddPackage(packageA1), Times.Never()); sharedRepository.Verify(s => s.AddPackage(packageA2), Times.Once()); }
public void InstallPackageCmdletDoesNotInstallPrereleasePackageIfFlagIsNotPresent() { // Arrange var sharedRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict); var packageRepository = new MockPackageRepository { PackageUtility.CreatePackage("A", "1.0.0-a") }; var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, null); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, null, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object); cmdlet.Id = "A"; // Assert ExceptionAssert.Throws<InvalidOperationException>(() => cmdlet.Execute(), "Unable to find package 'A'."); }
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 InstallPackageInstallUnlistedPrereleasePackageIfVersionIsSet() { // Arrange var packageA1 = PackageUtility.CreatePackage("A", "1.0.0"); var packageA2 = PackageUtility.CreatePackage("A", "1.0.0-ReleaseCandidate", listed: false); var packageRepository = new MockPackageRepository { packageA1, packageA2 }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; cmdlet.Version = new SemanticVersion("1.0.0-ReleaseCandidate"); cmdlet.IncludePrerelease = true; cmdlet.Execute(); // Assert: the unlisted prerelease packageA2 is installed. var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(1, installedPackages.Count); Assert.Equal(packageA2, installedPackages[0], PackageEqualityComparer.IdAndVersion); }
public void InstallPackageInstallUnlistedPrereleasePackageAsADependency(string versionA, string versionB) { // Arrange var packageA = PackageUtility.CreatePackage("A", versionA, dependencies: new[] { new PackageDependency("B") }); var packageB = PackageUtility.CreatePackage("B", versionB, listed: false); var packageRepository = new MockPackageRepository { packageA, packageB }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; cmdlet.IncludePrerelease = true; cmdlet.Execute(); // Assert var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(2, installedPackages.Count); Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion); Assert.Equal(packageB, installedPackages[1], PackageEqualityComparer.IdAndVersion); }
public async Task <ActionResult <string> > Install(InstallPackageCommand command) { return(await Mediator.Send(command)); }
public void InstallPackageIgnoresFailingRepositoriesWhenInstallingPackageWithOrWithoutDependencies() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B") }); var packageB = PackageUtility.CreatePackage("B", "1.0.0", listed: true); var packageC = PackageUtility.CreatePackage("C", "2.0.0"); var mockRepository = new Mock<IPackageRepository>(); mockRepository.Setup(c => c.GetPackages()).Returns(GetPackagesWithException().AsQueryable()).Verifiable(); var packageRepository = new AggregateRepository(new[] { new MockPackageRepository { packageA }, mockRepository.Object, new MockPackageRepository { packageB }, new MockPackageRepository { packageC }, }); var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; cmdlet.Execute(); cmdlet.Id = "C"; cmdlet.Execute(); // Assert var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(3, installedPackages.Count); Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion); Assert.Equal(packageB, installedPackages[1], PackageEqualityComparer.IdAndVersion); Assert.Equal(packageC, installedPackages[2], PackageEqualityComparer.IdAndVersion); mockRepository.Verify(); }
public void InstallPackageShouldPickListedPackagesOverUnlistedOnesAsDependency2() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B", new VersionSpec { MinVersion = new SemanticVersion("0.5") }) }); var packageB1 = PackageUtility.CreatePackage("B", "1.0.0", listed: true); var packageB2 = PackageUtility.CreatePackage("B", "1.0.2-alpha", listed: true); var packageB3 = PackageUtility.CreatePackage("B", "1.0.2", listed: false); var packageRepository = new MockPackageRepository { packageA, packageB1, packageB2, packageB3 }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; cmdlet.IncludePrerelease = true; cmdlet.DependencyVersion = DependencyVersion.HighestPatch; cmdlet.Execute(); // Assert: packageA and packageB2 are installed. // packageB1 is not picked because packageB2's version is later. // packageB3 is not picked because it's unlisted. var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(2, installedPackages.Count); Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion); Assert.Equal(packageB2, installedPackages[1], PackageEqualityComparer.IdAndVersion); }
public void InstallPackageShouldPickListedPackagesOverUnlistedOnesAsDependency() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B", new VersionSpec { MinVersion = new SemanticVersion("0.5")})}); var packageB1 = PackageUtility.CreatePackage("B", "1.0.0", listed: true); var packageB2 = PackageUtility.CreatePackage("B", "1.0.2", listed: false); var sharedRepository = new Mock<ISharedPackageRepository>(); sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable()); sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable(); sharedRepository.Setup(s => s.AddPackage(packageB1)).Verifiable(); var packageRepository = new MockPackageRepository { packageA, packageB1, packageB2 }; var recentPackageRepository = new Mock<IRecentPackageRepository>(); var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, recentPackageRepository.Object, new VsPackageInstallerEvents()); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object); cmdlet.Id = "A"; cmdlet.Execute(); // Assert sharedRepository.Verify(); sharedRepository.Verify(s => s.AddPackage(packageB2), Times.Never()); }
public void InstallPackageCmdletInstallPrereleasePackageIfFlagIsPresent() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0.0-a"); var packageRepository = new MockPackageRepository { packageA }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // packageA is not installed yet. Assert.False(packageManager.LocalRepository.IsSolutionReferenced(packageA.Id, packageA.Version)); // Act var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; cmdlet.IncludePrerelease = true; cmdlet.Execute(); // Assert: packageA is installed. var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(1, installedPackages.Count); Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion); }
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 InstallPackageCmdletPassesIgnoreDependencySwitchCorrectly() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0.0", dependencies: new[] { new PackageDependency("B") }); var packageB = PackageUtility.CreatePackage("B", "1.0.0"); var packageRepository = new MockPackageRepository { packageA, packageB }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand( packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; cmdlet.IgnoreDependencies = new SwitchParameter(true); cmdlet.Execute(); // Assert: only packageA is installed. packageB is not. var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(1, installedPackages.Count); Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion); }
public void InstallPackageCmdletCreatesPackageManagerWithFallbackFlagSet() { // Arrange var productUpdateService = new Mock<IProductUpdateService>(); var fallbackRepo = new Mock<IVsPackageManager>(); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(c => c.CreatePackageManager()).Returns(fallbackRepo.Object).Verifiable(); packageManagerFactory.Setup(c => c.CreatePackageManager(It.IsAny<IPackageRepository>(), false)).Throws(new Exception()); var repoA = new MockPackageRepository(); var repositoryFactory = new Mock<IPackageRepositoryFactory>(); repositoryFactory.Setup(c => c.CreateRepository("A")).Returns(repoA); var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManagerWithProjects("foo"), packageManagerFactory.Object, repositoryFactory.Object, GetPackageSourceProvider(new PackageSource("A")), 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 InstallPackageCmdletInstallPrereleasePackageIfFlagIsPresent() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0.0-a"); var sharedRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict); sharedRepository.SetupSet(s => s.PackageSaveMode = PackageSaveModes.Nupkg); sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable()); sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable(); sharedRepository.Setup(s => s.IsReferenced("A", new SemanticVersion("1.0.0-a"))).Returns(true); var packageRepository = new MockPackageRepository { packageA }; var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents()); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand( TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; cmdlet.IncludePrerelease = true; cmdlet.Execute(); // Assert sharedRepository.Verify(); }
public void InstallPackageWithoutSettingVersionDoNotInstallUnlistedPackage() { // Arrange var packageA1 = PackageUtility.CreatePackage("A", "1.0.0"); var packageA2 = PackageUtility.CreatePackage("A", "2.0.0", listed: false); var sharedRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict); sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable()); sharedRepository.Setup(s => s.AddPackage(packageA1)); var packageRepository = new MockPackageRepository { packageA1, packageA2 }; var recentPackageRepository = new Mock<IRecentPackageRepository>(); var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new MockFileSystem(), sharedRepository.Object, recentPackageRepository.Object, new VsPackageInstallerEvents()); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object); cmdlet.Id = "A"; cmdlet.Execute(); // Assert sharedRepository.Verify(s => s.AddPackage(packageA1), Times.Once()); sharedRepository.Verify(s => s.AddPackage(packageA2), Times.Never()); }
public void InstallPackageCmdletOnlyOpenReadmeFileFromTheRootPackage() { // Arrange // A --> B var packageA = new Mock<IPackage>(); packageA.Setup(p => p.Id).Returns("A"); packageA.Setup(p => p.Version).Returns(new SemanticVersion("1.0")); var depSet = new PackageDependencySet(null, new[] { new PackageDependency("B") }); packageA.Setup(p => p.DependencySets).Returns(new[] { depSet }); packageA.Setup(p => p.Listed).Returns(true); var readme = new Mock<IPackageFile>(); readme.Setup(f => f.Path).Returns("readMe.txt"); readme.Setup(f => f.GetStream()).Returns(new MemoryStream()); packageA.Setup(p => p.GetFiles()).Returns(new IPackageFile[] { readme.Object }); var packageB = new Mock<IPackage>(); packageB.Setup(p => p.Id).Returns("B"); packageB.Setup(p => p.Version).Returns(new SemanticVersion("1.0")); var readmeB = new Mock<IPackageFile>(); readmeB.Setup(f => f.Path).Returns("readMe.txt"); readmeB.Setup(f => f.GetStream()).Returns(new MemoryStream()); packageB.Setup(p => p.GetFiles()).Returns(new IPackageFile[] { readmeB.Object }); var sharedRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict); sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable()); sharedRepository.Setup(s => s.AddPackage(packageA.Object)); sharedRepository.Setup(s => s.AddPackage(packageB.Object)); sharedRepository.Setup(s => s.IsReferenced("A", new SemanticVersion("1.0"))).Returns(true); sharedRepository.Setup(s => s.IsReferenced("B", new SemanticVersion("1.0"))).Returns(true); var packageRepository = new MockPackageRepository { packageA.Object, packageB.Object }; var packageManager = new VsPackageManager( TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents()); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); var fileOperations = new Mock<IVsCommonOperations>(); // Act var cmdlet = new InstallPackageCommand( TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, fileOperations.Object, new Mock<IDeleteOnRestartManager>().Object); cmdlet.Id = "A"; cmdlet.Execute(); // Assert fileOperations.Verify(io => io.OpenFile(It.Is<string>(s => s.EndsWith("A.1.0\\readme.txt", StringComparison.OrdinalIgnoreCase))), Times.Once()); fileOperations.Verify(io => io.OpenFile(It.Is<string>(s => s.EndsWith("B.1.0\\readme.txt", StringComparison.OrdinalIgnoreCase))), Times.Never()); }
public void InstallPackageInstallUnlistedPrereleasePackageAsADependency(string versionA, string versionB) { // Arrange var packageA = PackageUtility.CreatePackage("A", versionA, dependencies: new[] { new PackageDependency("B") }); var packageB = PackageUtility.CreatePackage("B", versionB, listed: false); var sharedRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict); sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable()); sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable(); sharedRepository.Setup(s => s.AddPackage(packageB)).Verifiable(); sharedRepository.Setup(s => s.IsReferenced("A", new SemanticVersion(versionA))).Returns(true); sharedRepository.Setup(s => s.IsReferenced("B", new SemanticVersion(versionB))).Returns(true); var packageRepository = new MockPackageRepository { packageA, packageB }; var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents()); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(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.Execute(); // Assert sharedRepository.Verify(); }
private async Task InstallPackageAsync() { try { bool isLibraryInstallationStateValid = await IsLibraryInstallationStateValidAsync().ConfigureAwait(false); if (isLibraryInstallationStateValid) { ILibrary selectedPackage = SelectedPackage; InstallPackageCommand.CanExecute(null); Manifest manifest = await Manifest.FromFileAsync(_configFileName, _deps, CancellationToken.None).ConfigureAwait(false); string targetPath = _targetPath; if (!string.IsNullOrEmpty(_configFileName)) { Uri configContainerUri = new Uri(_configFileName, UriKind.Absolute); Uri targetUri = new Uri(targetPath, UriKind.Absolute); targetPath = configContainerUri.MakeRelativeUri(targetUri).ToString(); } if (String.IsNullOrEmpty(manifest.Version)) { manifest.Version = Manifest.SupportedVersions.Max().ToString(); } (string name, string version) = LibraryIdToNameAndVersionConverter.Instance.GetLibraryNameAndVersion(PackageId, SelectedProvider.Id); LibraryInstallationState libraryInstallationState = new LibraryInstallationState { Name = name, Version = version, ProviderId = selectedPackage.ProviderId, DestinationPath = InstallationFolder.DestinationFolder, }; _isInstalling = true; // When "Include all files" option is checked, we don't want to write out the files to libman.json. // We will only list the files when user chose to install specific files. if (LibraryFilesToInstall == FileSelectionType.ChooseSpecificFilesToInstall) { libraryInstallationState.Files = SelectedFiles.ToList(); } manifest.AddLibrary(libraryInstallationState); await Shell.ThreadHelper.JoinableTaskFactory.SwitchToMainThreadAsync(); if (!File.Exists(_configFileName)) { await manifest.SaveAsync(_configFileName, CancellationToken.None); if (_project != null) { await _project.AddFileToProjectAsync(_configFileName); } } RunningDocumentTable rdt = new RunningDocumentTable(Shell.ServiceProvider.GlobalProvider); string configFilePath = Path.GetFullPath(_configFileName); IVsTextBuffer textBuffer = rdt.FindDocument(configFilePath) as IVsTextBuffer; _dispatcher.Invoke(() => { _closeDialog(true); }); // The file isn't open. So we'll write to disk directly if (textBuffer == null) { manifest.AddLibrary(libraryInstallationState); await manifest.SaveAsync(_configFileName, CancellationToken.None).ConfigureAwait(false); Telemetry.TrackUserTask("Invoke-RestoreFromAddClientLibrariesDialog"); await _libraryCommandService.RestoreAsync(_configFileName, CancellationToken.None).ConfigureAwait(false); } else { // libman.json file is open, so we will write to the textBuffer. InsertIntoTextBuffer(textBuffer, libraryInstallationState, manifest); // Save manifest file so we can restore library files. rdt.SaveFileIfDirty(configFilePath); } } } catch (Exception ex) { Telemetry.TrackException(nameof(InstallPackageAsync), ex); } }
public void InstallPackageShouldPickUnListedPrereleasePackagesIfItSatisfiesContrainsAndOthersAreNot() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B", new VersionSpec { MinVersion = new SemanticVersion("1.0"), IsMinInclusive = true }) }); var packageB1 = PackageUtility.CreatePackage("B", "0.0.9", listed: true); var packageB2 = PackageUtility.CreatePackage("B", "1.0.1-a", listed: false); var sharedRepository = new Mock<ISharedPackageRepository>(); sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable()); sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable(); sharedRepository.Setup(s => s.AddPackage(packageB2)).Verifiable(); var packageRepository = new MockPackageRepository { packageA, packageB1, packageB2 }; var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents()); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(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.Execute(); // Assert sharedRepository.Verify(); sharedRepository.Verify(s => s.AddPackage(packageB1), Times.Never()); }
public void InstallPackageShouldPickUnListedPrereleasePackagesIfItSatisfiesContrainsAndOthersAreNot() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B", new VersionSpec { MinVersion = new SemanticVersion("1.0"), IsMinInclusive = true }) }); var packageB1 = PackageUtility.CreatePackage("B", "0.0.9", listed: true); var packageB2 = PackageUtility.CreatePackage("B", "1.0.1-a", listed: false); var packageRepository = new MockPackageRepository { packageA, packageB1, packageB2 }; var packageManager = new MockVsPackageManager2( @"c:\solution", packageRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(packageManager.SolutionManager, packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; cmdlet.IncludePrerelease = true; cmdlet.Execute(); // Assert: packageA and packageB2 are installed. // packageB1 is not picked because it cannot be used as a dependency of packageA var installedPackages = packageManager.LocalRepository.GetPackages().ToList(); Assert.Equal(2, installedPackages.Count); Assert.Equal(packageA, installedPackages[0], PackageEqualityComparer.IdAndVersion); Assert.Equal(packageB2, installedPackages[1], PackageEqualityComparer.IdAndVersion); }
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 InstallPackageCmdletDoesNotInstallPrereleasePackageIfFlagIsNotPresent() { // Arrange var packageA1 = PackageUtility.CreatePackage("A", "1.0.0-a"); var sharedRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict); sharedRepository.SetupSet(s => s.PackageSaveMode = PackageSaveModes.Nupkg); var packageRepository = new MockPackageRepository { packageA1 }; var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, null); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, null, null, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; // Assert ExceptionAssert.Throws<NotImplementedException>(() => cmdlet.Execute(), "WriteWarning"); sharedRepository.Verify(s => s.AddPackage(packageA1), Times.Never()); }
public void InstallPackageIgnoresFailingRepositoriesWhenInstallingPackageWithOrWithoutDependencies() { // Arrange var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B") }); var packageB = PackageUtility.CreatePackage("B", "1.0.0", listed: true); var packageC = PackageUtility.CreatePackage("C", "2.0.0"); var sharedRepository = new Mock<ISharedPackageRepository>(); sharedRepository.Setup(s => s.GetPackages()).Returns(Enumerable.Empty<IPackage>().AsQueryable()); sharedRepository.Setup(s => s.AddPackage(packageA)).Verifiable(); sharedRepository.Setup(s => s.AddPackage(packageB)).Verifiable(); sharedRepository.Setup(s => s.AddPackage(packageC)).Verifiable(); var mockRepository = new Mock<IPackageRepository>(); mockRepository.Setup(c => c.GetPackages()).Returns(GetPackagesWithException().AsQueryable()).Verifiable(); var packageRepository = new AggregateRepository(new[] { new MockPackageRepository { packageA }, mockRepository.Object, new MockPackageRepository { packageB }, new MockPackageRepository { packageC }, }); var packageManager = new VsPackageManager(TestUtils.GetSolutionManagerWithProjects("foo"), packageRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), sharedRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents()); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new InstallPackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object, true); cmdlet.Id = "A"; cmdlet.Execute(); cmdlet.Id = "C"; cmdlet.Execute(); // Assert sharedRepository.Verify(); mockRepository.Verify(); }
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); }