public void InstallPackageWithOperationsExecuteAllOperations() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository()); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, projectSystem, localRepository, new Mock<IRecentPackageRepository>().Object); var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }, dependencies: new PackageDependency[] { new PackageDependency("bar") }); sourceRepository.AddPackage(package); var package2 = PackageUtility.CreatePackage("bar", "2.0", new[] { "world" }); sourceRepository.AddPackage(package2); var package3 = PackageUtility.CreatePackage("awesome", "1.0", new[] { "candy" }); localRepository.AddPackage(package3); var operations = new PackageOperation[] { new PackageOperation(package, PackageAction.Install), new PackageOperation(package2, PackageAction.Install), new PackageOperation(package3, PackageAction.Uninstall) }; // Act packageManager.InstallPackage(projectManager, package, operations, ignoreDependencies: false, logger: NullLogger.Instance); // Assert Assert.IsTrue(packageManager.LocalRepository.Exists(package)); Assert.IsTrue(packageManager.LocalRepository.Exists(package2)); Assert.IsTrue(!packageManager.LocalRepository.Exists(package3)); Assert.IsTrue(projectManager.LocalRepository.Exists(package)); Assert.IsTrue(projectManager.LocalRepository.Exists(package2)); }
public VsProjectManager( VsPackageManager packageManager, IPackagePathResolver pathResolver, IProjectSystem project, IPackageRepository localRepository) : base(packageManager, pathResolver, project, localRepository) { _packageManager = packageManager; }
public IVsPackageManager CreatePackageManager(IPackageRepository repository, bool useFallbackForDependencies) { RepositoryInfo info = GetRepositoryInfo(); var packageManager = new VsPackageManager(_solutionManager, repository, _fileSystemProvider, info.FileSystem, info.Repository, // We ensure DeleteOnRestartManager is initialized with a PhysicalFileSystem so the // .deleteme marker files that get created don't get checked into version control new DeleteOnRestartManager(() => new PhysicalFileSystem(info.FileSystem.Root)), _packageEvents, _frameworkMultiTargeting); packageManager.DependencyVersion = GetDependencyVersion(); return(packageManager); }
public void InstallPackgeWithNullProjectManagerOnlyInstallsIntoPackageManager() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, projectSystem, localRepository, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object); var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }); sourceRepository.AddPackage(package); // Act packageManager.InstallPackage((IProjectManager)null, "foo", new SemanticVersion("1.0"), ignoreDependencies: false, allowPrereleaseVersions: false, logger: NullLogger.Instance); // Assert Assert.True(packageManager.LocalRepository.Exists(package)); }
public void UpdatePackageWithMultipleSharedDependencies() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); var projectRepository = new MockProjectPackageRepository(localRepository.Object); var sourceRepository = new MockPackageRepository(); var fileSystem = new MockFileSystem(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(fileSystem); // A1 -> B1, C1 // A2 -> B1 var A10 = PackageUtility.CreatePackage("A", "1.0", assemblyReferences: new[] { "A1.dll" }, dependencies: new[] { new PackageDependency("B", VersionUtility.ParseVersionSpec("1.0")), new PackageDependency("C", VersionUtility.ParseVersionSpec("1.0")), }); var A20 = PackageUtility.CreatePackage("A", "2.0", assemblyReferences: new[] { "A2.dll" }, dependencies: new[] { new PackageDependency("B", VersionUtility.ParseVersionSpec("1.0")) }); var B10 = PackageUtility.CreatePackage("B", "1.0", assemblyReferences: new[] { "B1.dll" }); var C10 = PackageUtility.CreatePackage("C", "1.0", assemblyReferences: new[] { "C1.dll" }); sourceRepository.AddPackage(A10); sourceRepository.AddPackage(A20); sourceRepository.AddPackage(B10); sourceRepository.AddPackage(C10); localRepository.Object.AddPackage(A10); localRepository.Object.AddPackage(A20); localRepository.Object.AddPackage(B10); localRepository.Object.AddPackage(C10); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, fileSystem, localRepository.Object, new Mock<IRecentPackageRepository>().Object); var projectManager = new ProjectManager(localRepository.Object, pathResolver, projectSystem, projectRepository); projectManager.AddPackageReference("A", new Version("1.0")); // Act packageManager.UpdatePackage(projectManager, "A", version: null, updateDependencies: true, logger: NullLogger.Instance); // Assert Assert.IsFalse(packageManager.LocalRepository.Exists(A10)); Assert.IsFalse(projectSystem.ReferenceExists("A1.dll")); Assert.IsFalse(packageManager.LocalRepository.Exists(C10)); Assert.IsFalse(projectSystem.ReferenceExists("C1.dll")); Assert.IsTrue(packageManager.LocalRepository.Exists(B10)); Assert.IsTrue(projectSystem.ReferenceExists("B1.dll")); Assert.IsTrue(packageManager.LocalRepository.Exists(A20)); Assert.IsTrue(projectSystem.ReferenceExists("A2.dll")); }
public void UpdatePackageRemovesPackageIfPackageIsNotReferenced() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); localRepository.Setup(m => m.IsReferenced("A", new Version("1.0"))).Returns(false); var projectRepository = new MockProjectPackageRepository(localRepository.Object); var sourceRepository = new MockPackageRepository(); var fileSystem = new MockFileSystem(); var pathResolver = new DefaultPackagePathResolver(fileSystem); var A10 = PackageUtility.CreatePackage("A", "1.0", new[] { "hello" }); var A20 = PackageUtility.CreatePackage("A", "2.0", new[] { "hello" }); sourceRepository.AddPackage(A10); sourceRepository.AddPackage(A20); localRepository.Object.AddPackage(A10); localRepository.Object.AddPackage(A20); projectRepository.Add(A10); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, fileSystem, localRepository.Object, new Mock<IRecentPackageRepository>().Object); var projectManager = new ProjectManager(localRepository.Object, pathResolver, new MockProjectSystem(), projectRepository); // Act packageManager.UpdatePackage(projectManager, "A", version: null, updateDependencies: true, logger: NullLogger.Instance); // Assert Assert.IsFalse(packageManager.LocalRepository.Exists(A10)); }
public void UninstallProjectLevelPackageWithNoProjectManagerThrows() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); localRepository.Setup(m => m.IsReferenced("foo", It.IsAny<Version>())).Returns(true); var sourceRepository = new MockPackageRepository(); var fileSystem = new MockFileSystem(); var pathResolver = new DefaultPackagePathResolver(fileSystem); var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }); localRepository.Object.AddPackage(package); sourceRepository.AddPackage(package); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, fileSystem, localRepository.Object, new Mock<IRecentPackageRepository>().Object); // Act ExceptionAssert.Throws<InvalidOperationException>(() => packageManager.UninstallPackage(null, "foo", version: null, forceRemove: false, removeDependencies: false, logger: NullLogger.Instance), "No project was specified."); }
public void UninstallPackageRemovesPackageIfPackageIsNotReferenced() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); localRepository.Setup(m => m.IsReferenced("foo", It.IsAny<Version>())).Returns(false); var sourceRepository = new MockPackageRepository(); var fileSystem = new MockFileSystem(); var pathResolver = new DefaultPackagePathResolver(fileSystem); var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }); localRepository.Object.AddPackage(package); sourceRepository.AddPackage(package); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, fileSystem, localRepository.Object, new Mock<IRecentPackageRepository>().Object); // Act packageManager.UninstallPackage(null, "foo", version: null, forceRemove: false, removeDependencies: false, logger: NullLogger.Instance); // Assert Assert.IsFalse(packageManager.LocalRepository.Exists(package)); }
public 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 InstallPackageInstallsIndirectPrereleaseDependency() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, projectSystem, localRepository, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object); var package = PackageUtility.CreatePackage("foo", "1.0.0", dependencies: new[] { new PackageDependency("bar") }); sourceRepository.AddPackage(package); var versionSpec = VersionUtility.ParseVersionSpec("[0.6, 1.0)"); var package2 = PackageUtility.CreatePackage("bar", "2.0.0", dependencies: new[] { new PackageDependency("qux", versionSpec) }); sourceRepository.AddPackage(package2); var package3A = PackageUtility.CreatePackage("qux", "1.0-alpha"); var package3B = PackageUtility.CreatePackage("qux", "1.0-beta"); var package3 = PackageUtility.CreatePackage("qux", "1.0"); localRepository.AddPackage(package3); localRepository.AddPackage(package3A); localRepository.AddPackage(package3B); // Act packageManager.InstallPackage(package, ignoreDependencies: false, allowPrereleaseVersions: true); // Assert Assert.True(packageManager.LocalRepository.Exists(package)); Assert.True(packageManager.LocalRepository.Exists(package2)); Assert.True(packageManager.LocalRepository.Exists(package3B)); }
public void UpdatePackageUpdateToUnlistedPackageIfVersionIsSet(string versionA1, string versionA2) { // Arrange var packageA1 = PackageUtility.CreatePackage("A", versionA1, dependencies: new[] { new PackageDependency("B") }); var packageA2 = PackageUtility.CreatePackage("A", versionA2, listed: false); var sharedRepository = new Mock<ISharedPackageRepository>(); sharedRepository.Setup(s => s.GetPackages()).Returns(new[] { packageA1 }.AsQueryable()); sharedRepository.Setup(s => s.AddPackage(packageA2)).Verifiable(); 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 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 sharedRepository.Verify(); }
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 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 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 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 UninstallProjectLevelPackageThrowsIfPackageIsReferenced() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); localRepository.Setup(m => m.IsReferenced("foo", It.IsAny<SemanticVersion>())).Returns(true); var sourceRepository = new MockPackageRepository(); var fileSystem = new MockFileSystem(); var pathResolver = new DefaultPackagePathResolver(fileSystem); var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }); localRepository.Object.AddPackage(package); sourceRepository.AddPackage(package); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, fileSystem, localRepository.Object, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object); var projectManager = new ProjectManager(localRepository.Object, pathResolver, new MockProjectSystem(), new MockPackageRepository()); // Act ExceptionAssert.Throws<InvalidOperationException>(() => packageManager.UninstallPackage(projectManager, "foo", version: null, forceRemove: false, removeDependencies: false, logger: NullLogger.Instance), @"Unable to find package 'foo' in 'C:\MockFileSystem\'."); }
public void UpdatePackageWithSharedDependency() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); var projectRepository = new MockProjectPackageRepository(localRepository.Object); var sourceRepository = new MockPackageRepository(); var fileSystem = new MockFileSystem(); var pathResolver = new DefaultPackagePathResolver(fileSystem); // A1 -> B1 // A2 -> B2 // F1 -> G1 // G1 -> B1 var A10 = PackageUtility.CreatePackage("A", "1.0", new[] { "hello" }, dependencies: new[] { new PackageDependency("B", VersionUtility.ParseVersionSpec("1.0")) }); var A20 = PackageUtility.CreatePackage("A", "2.0", new[] { "hello" }, dependencies: new[] { new PackageDependency("B", VersionUtility.ParseVersionSpec("2.0")) }); var B10 = PackageUtility.CreatePackage("B", "1.0", new[] { "hello" }); var B20 = PackageUtility.CreatePackage("B", "2.0", new[] { "hello" }); var F10 = PackageUtility.CreatePackage("F", "1.0", new[] { "hello" }, dependencies: new[] { new PackageDependency("G", VersionUtility.ParseVersionSpec("1.0")) }); var G10 = PackageUtility.CreatePackage("G", "1.0", new[] { "hello" }, dependencies: new[] { new PackageDependency("B", VersionUtility.ParseVersionSpec("1.0")) }); sourceRepository.AddPackage(A10); sourceRepository.AddPackage(A20); sourceRepository.AddPackage(B10); sourceRepository.AddPackage(B20); sourceRepository.AddPackage(F10); sourceRepository.AddPackage(G10); localRepository.Object.AddPackage(A10); localRepository.Object.AddPackage(A20); localRepository.Object.AddPackage(B10); localRepository.Object.AddPackage(B20); localRepository.Object.AddPackage(F10); localRepository.Object.AddPackage(G10); projectRepository.Add(A10); projectRepository.Add(B10); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, fileSystem, localRepository.Object, new Mock<IRecentPackageRepository>().Object); var projectManager = new ProjectManager(localRepository.Object, pathResolver, new MockProjectSystem(), projectRepository); // Act packageManager.UpdatePackage(projectManager, "A", version: null, updateDependencies: true, logger: NullLogger.Instance); // Assert Assert.IsFalse(packageManager.LocalRepository.Exists(A10)); Assert.IsFalse(packageManager.LocalRepository.Exists(B10)); Assert.IsTrue(packageManager.LocalRepository.Exists(A20)); Assert.IsTrue(packageManager.LocalRepository.Exists(B20)); Assert.IsTrue(packageManager.LocalRepository.Exists(F10)); Assert.IsTrue(packageManager.LocalRepository.Exists(G10)); }
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 InstallPackageDoesNotInstallPackageWithIndirectDependencyThatIsPrerelease() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, projectSystem, localRepository, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object); var package = PackageUtility.CreatePackage("foo", "1.0.0", dependencies: new[] { new PackageDependency("bar") }); sourceRepository.AddPackage(package); var versionSpec = VersionUtility.ParseVersionSpec("[0.6, 1.0)"); var package2 = PackageUtility.CreatePackage("bar", "2.0.0", dependencies: new[] { new PackageDependency("qux", versionSpec) }); sourceRepository.AddPackage(package2); var package3A = PackageUtility.CreatePackage("qux", "1.0-alpha"); var package3B = PackageUtility.CreatePackage("qux", "1.0-beta"); var package3 = PackageUtility.CreatePackage("qux", "1.0"); sourceRepository.AddPackage(package3); sourceRepository.AddPackage(package3A); sourceRepository.AddPackage(package3B); // Act and Assert ExceptionAssert.Throws<InvalidOperationException>(() => packageManager.InstallPackage(package, ignoreDependencies: false, allowPrereleaseVersions: false), "Unable to resolve dependency 'qux (≥ 0.6 && < 1.0)'."); }
public void GetPackageDoNotShowUnlistedPackagesForUpdates2() { // Arrange var sourceRepository = new MockPackageRepository() { PackageUtility.CreatePackage("C", "1.0.0", listed: true), PackageUtility.CreatePackage("C", "2.0.0", listed: false), PackageUtility.CreatePackage("C", "2.0.1", listed: true), PackageUtility.CreatePackage("C", "2.0.3.4-alpha", listed: false), PackageUtility.CreatePackage("C", "2.0.3.5-alpha", listed: true), PackageUtility.CreatePackage("C", "2.5.0", listed: false), }; var repositoryFactory = new Mock<IPackageRepositoryFactory>(MockBehavior.Strict); repositoryFactory.Setup(r => r.CreateRepository("NuGet Official Source")).Returns(sourceRepository); var solutionManager = TestUtils.GetSolutionManager(); var localPackages = new IPackage[] { PackageUtility.CreatePackage("C", "1.0.0") }; var localRepository = new Mock<ISharedPackageRepository>(MockBehavior.Strict); localRepository.Setup(p => p.GetPackages()).Returns(localPackages.AsQueryable()).Verifiable(); var packageManager = new VsPackageManager( solutionManager, sourceRepository, new Mock<IFileSystemProvider>().Object, new Mock<IFileSystem>().Object, localRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new VsPackageInstallerEvents()); var mockPackageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); mockPackageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager).Verifiable(); var cmdlet = new GetPackageCommand( repositoryFactory.Object, GetSourceProvider("NuGet Official Source"), solutionManager, mockPackageManagerFactory.Object, new Mock<IHttpClient>().Object, new Mock<IProductUpdateService>().Object); cmdlet.Updates = true; cmdlet.IncludePrerelease = true; cmdlet.AllVersions = true; cmdlet.Source = "NuGet Official Source"; // Act var packages = cmdlet.GetResults<dynamic>(); // Assert localRepository.Verify(); Assert.Equal(2, packages.Count()); AssertPackageResultsEqual(packages.ElementAt(0), new { Id = "C", Version = new SemanticVersion("2.0.1") }); AssertPackageResultsEqual(packages.ElementAt(1), new { Id = "C", Version = new SemanticVersion("2.0.3.5-alpha") }); }
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 UpdatePackageWithNoProjectsInstallsAtSolutionLevel() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, projectSystem, localRepository, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object); var package = PackageUtility.CreatePackage("foo", "1.0", dependencies: new PackageDependency[] { new PackageDependency("bar") }); sourceRepository.AddPackage(package); var package2 = PackageUtility.CreatePackage("bar", "2.0"); sourceRepository.AddPackage(package2); var package3 = PackageUtility.CreatePackage("awesome", "1.0"); localRepository.AddPackage(package3); var operations = new PackageOperation[] { new PackageOperation(package, PackageAction.Install), new PackageOperation(package2, PackageAction.Install), new PackageOperation(package3, PackageAction.Uninstall) }; // Act packageManager.UpdatePackage(Enumerable.Empty<Project>(), package, operations, updateDependencies: true, allowPrereleaseVersions: false, logger: NullLogger.Instance, packageOperationEventListener: null); // Assert Assert.True(packageManager.LocalRepository.Exists(package)); Assert.True(packageManager.LocalRepository.Exists(package2)); Assert.True(!packageManager.LocalRepository.Exists(package3)); }
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(); }
public void UpdatePackageUpdatesToTheHighestPackageIfPrereleaseFlagIsSetToTrue() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, projectSystem, localRepository, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object); var package3_10A = PackageUtility.CreatePackage("qux", "1.0-alpha"); var package3_11B = PackageUtility.CreatePackage("qux", "1.1-alpha"); var package3_10 = PackageUtility.CreatePackage("qux", "1.0"); var package3_09 = PackageUtility.CreatePackage("qux", "0.9"); localRepository.AddPackage(package3_10); localRepository.AddPackage(package3_10A); localRepository.AddPackage(package3_11B); localRepository.AddPackage(package3_09); // Act packageManager.InstallPackage(package3_09, ignoreDependencies: false, allowPrereleaseVersions: true); Assert.True(packageManager.LocalRepository.Exists(package3_09)); packageManager.UpdatePackage("qux", updateDependencies: true, allowPrereleaseVersions: true); // Assert Assert.True(packageManager.LocalRepository.Exists(package3_11B)); }
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 IVsPackageManager CreatePackageManager(IPackageRepository repository, bool useFallbackForDependencies) { RepositoryInfo info = GetRepositoryInfo(); var packageManager = new VsPackageManager(_solutionManager, repository, _fileSystemProvider, info.FileSystem, info.Repository, // We ensure DeleteOnRestartManager is initialized with a PhysicalFileSystem so the // .deleteme marker files that get created don't get checked into version control new DeleteOnRestartManager(() => new PhysicalFileSystem(info.FileSystem.Root)), _packageEvents, _frameworkMultiTargeting); packageManager.DependencyVersion = GetDependencyVersion(); return packageManager; }
private static IVsPackageManagerFactory GetPackageManagerForMultipleVersions() { var fileSystem = new Mock<IFileSystem>(); var localRepo = new Mock<ISharedPackageRepository>(); var localPackages = new[] { PackageUtility.CreatePackage("jQuery", "1.2"), PackageUtility.CreatePackage("TestPack", "0.1") }; localRepo.Setup(c => c.GetPackages()).Returns(localPackages.AsQueryable()); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), GetActiveRepository(), new Mock<IFileSystemProvider>().Object, fileSystem.Object, localRepo.Object, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var factory = new Mock<IVsPackageManagerFactory>(); factory.Setup(c => c.CreatePackageManager()).Returns(packageManager); return factory.Object; }
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(); }