public void InstallPackageSetOperationToInstall3() { // Arrange var localRepository = new MockSharedPackageRepository(); var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository()); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }); sourceRepository.AddPackage(package); var package2 = PackageUtility.CreatePackage("bar", "2.0", new[] { "world" }); sourceRepository.AddPackage(package2); // Act packageManager.InstallPackage( projectManager, package2, new PackageOperation[] { new PackageOperation(package, PackageAction.Install), new PackageOperation(package2, PackageAction.Install), }, ignoreDependencies: false, allowPrereleaseVersions: false, logger: NullLogger.Instance); // Assert Assert.Equal("Install", sourceRepository.LastOperation); Assert.Equal("bar", sourceRepository.LastMainPackageId); Assert.Equal("2.0", sourceRepository.LastMainPackageVersion); }
public void UpdatePackagesSetOperationToUpdate1() { // Arrange var localRepository = new MockSharedPackageRepository(); var sourceRepository = new MockPackageRepository(); var projectRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), projectRepository); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock <IFileSystemProvider>().Object, projectSystem, localRepository, new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object); var package = PackageUtility.CreatePackage("phuong", "1.0", new[] { "hello" }); localRepository.AddPackage(package); projectRepository.AddPackage(package); var package2 = PackageUtility.CreatePackage("phuong", "2.0", new[] { "hello" }); sourceRepository.AddPackage(package2); // Act packageManager.UpdatePackages( projectManager, updateDependencies: true, allowPrereleaseVersions: true, logger: NullLogger.Instance); // Assert Assert.Equal("Update", sourceRepository.LastOperation); Assert.Equal("phuong", sourceRepository.LastMainPackageId); Assert.Equal("2.0", sourceRepository.LastMainPackageVersion); }
public void 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 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 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 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 InstallPackageSetOperationToInstall3() { // Arrange var localRepository = new MockSharedPackageRepository(); var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository()); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock <IFileSystemProvider>().Object, projectSystem, localRepository, new Mock <IDeleteOnRestartManager>().Object, new Mock <VsPackageInstallerEvents>().Object); var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }); sourceRepository.AddPackage(package); var package2 = PackageUtility.CreatePackage("bar", "2.0", new[] { "world" }); sourceRepository.AddPackage(package2); // Act packageManager.InstallPackage( projectManager, package2, new PackageOperation[] { new PackageOperation(package, PackageAction.Install), new PackageOperation(package2, PackageAction.Install), }, ignoreDependencies: false, allowPrereleaseVersions: false, logger: NullLogger.Instance); // Assert Assert.Equal("Install", sourceRepository.LastOperation); Assert.Equal("bar", sourceRepository.LastMainPackageId); Assert.Equal("2.0", sourceRepository.LastMainPackageVersion); }
public void 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 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 InstallMetadataPackageWithReadMeInstallsIntoProjectAndPackageManager() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository()); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var packageA = PackageUtility.CreatePackage("A", "1.0", dependencies: new[] { new PackageDependency("B") }); var mockPackageA = Mock.Get(packageA); mockPackageA.Setup(m => m.GetFiles()).Returns(PackageUtility.CreateFiles(new[] { "readme.txt" })); var packageB = PackageUtility.CreatePackage("B", "1.0", content: new[] { "hello.txt" }); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageB); // Act packageManager.InstallPackage(projectManager, "A", new SemanticVersion("1.0"), ignoreDependencies: false, allowPrereleaseVersions: false, logger: NullLogger.Instance); // Assert Assert.True(packageManager.LocalRepository.Exists(packageA)); Assert.True(projectManager.LocalRepository.Exists(packageA)); Assert.True(packageManager.LocalRepository.Exists(packageB)); Assert.True(projectManager.LocalRepository.Exists(packageB)); }
public void UpdatePackageDoesNotRemovesPackageIfPackageIsReferenced() { // Arrange var localRepository = new Mock <MockPackageRepository>() { CallBase = true }.As <ISharedPackageRepository>(); localRepository.Setup(m => m.IsReferenced("A", new Version("1.0"))).Returns(true); 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.IsTrue(packageManager.LocalRepository.Exists(A10)); }
public void ReinstallPackagesRestoresPackageWithTheSameVersion() { // 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, projectSystem, new MockPackageRepository()); var packageManager = new VsPackageManager( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var packageA = PackageUtility.CreatePackage("A", "1.2", new[] { "content.txt" }); sourceRepository.Add(packageA); localRepository.AddPackage(packageA); projectManager.LocalRepository.AddPackage(packageA); // Act packageManager.ReinstallPackage(projectManager, "A", updateDependencies: true, allowPrereleaseVersions: true, logger: null); // Assert Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2"))); Assert.True(projectManager.LocalRepository.Exists("A", new SemanticVersion("1.2"))); }
public void GetPackageDoNotShowUnlistedPackagesForUpdates() { // Arrange var sourceRepository = new MockPackageRepository() { PackageUtility.CreatePackage("A", "1.1"), PackageUtility.CreatePackage("B", "1.1.0-b"), PackageUtility.CreatePackage("C", "2.0.0", listed: false), PackageUtility.CreatePackage("C", "2.0.3.4-alpha", 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.SetupSet(p => p.PackageSaveMode = PackageSaveModes.Nupkg); 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.False(packages.Any()); }
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 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 InstallPackageUsesProjectTargetFramework() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework, Version=4.5")); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, new MockPackageRepository()); var packageManager = new VsPackageManager( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object); var dependencySets = new PackageDependencySet[] { new PackageDependencySet( new FrameworkName(".NETFramework, Version=4.5"), new [] { new PackageDependency("B") }), new PackageDependencySet( new FrameworkName(".NETFramework, Version=4.0"), new [] { new PackageDependency("C") }) }; var package = PackageUtility.CreatePackageWithDependencySets( "foo", "1.0", new[] { "hello" }, dependencySets: dependencySets); var packageB = PackageUtility.CreatePackage("B", "2.0", new[] { "good morning" }); var packageC = PackageUtility.CreatePackage("C", "2.0", new[] { "good morning" }); sourceRepository.AddPackage(package); sourceRepository.AddPackage(packageB); sourceRepository.AddPackage(packageC); // Act packageManager.InstallPackage(projectManager, "foo", new SemanticVersion("1.0"), ignoreDependencies: false, allowPrereleaseVersions: false, logger: NullLogger.Instance); // Assert Assert.True(packageManager.LocalRepository.Exists(package)); Assert.True(packageManager.LocalRepository.Exists(packageB)); Assert.False(packageManager.LocalRepository.Exists(packageC)); Assert.True(projectManager.LocalRepository.Exists(package)); Assert.True(projectManager.LocalRepository.Exists(packageB)); }
public void 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 ReinstallPackagesSkipsReinstallingIfPackageDoesNotExistAndLogWarning() { // 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, projectSystem, new MockPackageRepository()); var installerEvents = new Mock<VsPackageInstallerEvents>(MockBehavior.Strict); int eventCount = 0; RegisterInstallerEvents(installerEvents, _ => eventCount++); var packageManager = new VsPackageManager( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, installerEvents.Object); var packageA = PackageUtility.CreatePackage("A", "1.2", new[] { "content.txt" }); sourceRepository.Add(packageA); localRepository.AddPackage(packageA); projectManager.LocalRepository.AddPackage(packageA); // remove package from source repository to simulate missing package condition sourceRepository.Remove(packageA); var logger = new Mock<ILogger>(); logger.Setup(s => s.Log( MessageLevel.Warning, "Skipped reinstalling package '{0}' in project '{1}' because the package does not exist in the package source.", "A 1.2", "x:\\MockFileSystem") ).Verifiable(); // Act packageManager.ReinstallPackage(projectManager, "A", updateDependencies: true, allowPrereleaseVersions: true, logger: logger.Object); // Assert logger.Verify(); Assert.Equal(0, eventCount); Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2"))); Assert.True(projectManager.LocalRepository.Exists("A", new SemanticVersion("1.2"))); }
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(), fileSystem.Object, localRepo.Object, new Mock <IRecentPackageRepository>().Object); var factory = new Mock <IVsPackageManagerFactory>(); factory.Setup(c => c.CreatePackageManager()).Returns(packageManager); return(factory.Object); }
public void InstallPackageInstallsIntoProjectAndPackageManager() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository()); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }); sourceRepository.AddPackage(package); // Act packageManager.InstallPackage(projectManager, "foo", new SemanticVersion("1.0"), ignoreDependencies: false, allowPrereleaseVersions: false, logger: NullLogger.Instance); // Assert Assert.True(packageManager.LocalRepository.Exists(package)); Assert.True(projectManager.LocalRepository.Exists(package)); }
public void InstallPackageWithOperationsExecuteAllOperations() { // Arrange var localRepository = new Mock <MockPackageRepository>() { CallBase = true }.As <ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository()); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, projectSystem, localRepository, new Mock <IRecentPackageRepository>().Object); var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }, dependencies: new PackageDependency[] { new PackageDependency("bar") }); sourceRepository.AddPackage(package); var package2 = PackageUtility.CreatePackage("bar", "2.0", new[] { "world" }); sourceRepository.AddPackage(package2); var package3 = PackageUtility.CreatePackage("awesome", "1.0", new[] { "candy" }); localRepository.AddPackage(package3); var operations = new PackageOperation[] { new PackageOperation(package, PackageAction.Install), new PackageOperation(package2, PackageAction.Install), new PackageOperation(package3, PackageAction.Uninstall) }; // Act packageManager.InstallPackage(projectManager, package, operations, ignoreDependencies: false, logger: NullLogger.Instance); // Assert Assert.IsTrue(packageManager.LocalRepository.Exists(package)); Assert.IsTrue(packageManager.LocalRepository.Exists(package2)); Assert.IsTrue(!packageManager.LocalRepository.Exists(package3)); Assert.IsTrue(projectManager.LocalRepository.Exists(package)); Assert.IsTrue(projectManager.LocalRepository.Exists(package2)); }
public void 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 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 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); var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }); sourceRepository.AddPackage(package); // Act packageManager.InstallPackage((IProjectManager)null, "foo", new Version("1.0"), ignoreDependencies: false, logger: NullLogger.Instance); // Assert Assert.IsTrue(packageManager.LocalRepository.Exists(package)); }
public void UninstallPackageRemovesPackageIfPackageIsNotReferenced() { // Arrange var localRepository = new Mock <MockPackageRepository>() { CallBase = true }.As <ISharedPackageRepository>(); localRepository.Setup(m => m.IsReferenced("foo", It.IsAny <Version>())).Returns(false); var sourceRepository = new MockPackageRepository(); var fileSystem = new MockFileSystem(); var pathResolver = new DefaultPackagePathResolver(fileSystem); var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }); localRepository.Object.AddPackage(package); sourceRepository.AddPackage(package); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, fileSystem, localRepository.Object, new Mock <IRecentPackageRepository>().Object); // Act packageManager.UninstallPackage(null, "foo", version: null, forceRemove: false, removeDependencies: false, logger: NullLogger.Instance); // Assert Assert.IsFalse(packageManager.LocalRepository.Exists(package)); }
public 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, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().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 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, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().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 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, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var projectManager = new ProjectManager(localRepository.Object, pathResolver, projectSystem, projectRepository); projectManager.AddPackageReference("A", new SemanticVersion("1.0")); // Act packageManager.UpdatePackage(projectManager, "A", version: null, updateDependencies: true, allowPrereleaseVersions: false, logger: NullLogger.Instance); // Assert Assert.False(packageManager.LocalRepository.Exists(A10)); Assert.False(projectSystem.ReferenceExists("A1.dll")); Assert.False(packageManager.LocalRepository.Exists(C10)); Assert.False(projectSystem.ReferenceExists("C1.dll")); Assert.True(packageManager.LocalRepository.Exists(B10)); Assert.True(projectSystem.ReferenceExists("B1.dll")); Assert.True(packageManager.LocalRepository.Exists(A20)); Assert.True(projectSystem.ReferenceExists("A2.dll")); }
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, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var projectManager = new ProjectManager(localRepository.Object, pathResolver, new MockProjectSystem(), projectRepository); // Act packageManager.UpdatePackage(projectManager, "A", version: null, updateDependencies: true, allowPrereleaseVersions: false, logger: NullLogger.Instance); // Assert Assert.False(packageManager.LocalRepository.Exists(A10)); Assert.False(packageManager.LocalRepository.Exists(B10)); Assert.True(packageManager.LocalRepository.Exists(A20)); Assert.True(packageManager.LocalRepository.Exists(B20)); Assert.True(packageManager.LocalRepository.Exists(F10)); Assert.True(packageManager.LocalRepository.Exists(G10)); }
public void UpdatePackageCallsMarkPackageDirectory() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var deleteOnRestartManager = new Mock<IDeleteOnRestartManager>(MockBehavior.Strict); var packageA = PackageUtility.CreatePackage("A", "1.0"); var packageAv2 = PackageUtility.CreatePackage("A", "2.0"); localRepository.AddPackage(packageA); sourceRepository.AddPackage(packageA); sourceRepository.AddPackage(packageAv2); deleteOnRestartManager.Setup(d => d.MarkPackageDirectoryForDeletion(packageA)).Verifiable(); var packageManager = new VsPackageManager( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, deleteOnRestartManager.Object, new Mock<VsPackageInstallerEvents>().Object); // Act packageManager.UpdatePackage("A", updateDependencies: false, allowPrereleaseVersions: false); // Assert deleteOnRestartManager.Verify(); }
public void ReinstallPackagesWithDependenciesSkipIfDependencyPackageIsMissingFromSource() { // 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, projectSystem, new MockPackageRepository()); var packageManager = new VsPackageManager( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var packageA = PackageUtility.CreatePackage("A", "1.2-alpha", new[] { "content.txt" }, dependencies: new[] { new PackageDependency("B") }); var packageB = PackageUtility.CreatePackage("B", "2.0.0", new[] { "hello.txt" }); sourceRepository.Add(packageA); localRepository.AddPackage(packageA); projectManager.LocalRepository.AddPackage(packageA); //sourceRepository.Add(packageB); localRepository.AddPackage(packageB); projectManager.LocalRepository.AddPackage(packageB); var logger = new Mock<ILogger>(); logger.Setup(s => s.Log( MessageLevel.Warning, "Skipped reinstalling package '{0}' in project '{1}' because the package does not exist in the package source.", "B 2.0.0", "x:\\MockFileSystem") ).Verifiable(); // Act packageManager.ReinstallPackages(projectManager, updateDependencies: false, allowPrereleaseVersions: false, logger: logger.Object); // Assert logger.Verify(); Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.True(projectManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.True(packageManager.LocalRepository.Exists("B", new SemanticVersion("2.0.0"))); Assert.True(projectManager.LocalRepository.Exists("B", new SemanticVersion("2.0.0"))); }
public void UpdatePackageShowWarningIfThereIsOrphanedPackageUnderPackagesFolder() { // 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, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var orphanPackage = PackageUtility.CreatePackage("orphan", "1.0", new [] { "content" }); localRepository.AddPackage(orphanPackage); var logger = new Mock<ILogger>(); logger.Setup(l => l.Log(MessageLevel.Warning, "'orphan' was not installed in any project. Update failed.")).Verifiable(); // Act packageManager.UpdatePackages(updateDependencies: true, allowPrereleaseVersions: true, logger: logger.Object, eventListener: new Mock<IPackageOperationEventListener>().Object); // Assert logger.Verify(); }
public void UninstallPackageCallsMarkPackageDirectoryForDeletion() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); var sourceRepository = new MockPackageRepository(); var packageA = PackageUtility.CreatePackage("A"); var deleteOnRestartManager = new Mock<IDeleteOnRestartManager>(MockBehavior.Strict); deleteOnRestartManager.Setup(d => d.MarkPackageDirectoryForDeletion(packageA)).Verifiable(); localRepository.Object.AddPackage(packageA); sourceRepository.AddPackage(packageA); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), localRepository.Object, deleteOnRestartManager.Object, new Mock<VsPackageInstallerEvents>().Object); // Act packageManager.UninstallPackage(null, "A", version: null, forceRemove: false, removeDependencies: false, logger: NullLogger.Instance); // Assert deleteOnRestartManager.Verify(); }
public void UninstallPackageRemovesPackageIfPackageIsNotReferenced() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); localRepository.Setup(m => m.IsReferenced("foo", It.IsAny<SemanticVersion>())).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, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); // Act packageManager.UninstallPackage(null, "foo", version: null, forceRemove: false, removeDependencies: false, logger: NullLogger.Instance); // Assert Assert.False(packageManager.LocalRepository.Exists(package)); }
public void UninstallProjectLevelPackageWithNoProjectManagerThrows() { // 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, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); // Act ExceptionAssert.Throws<InvalidOperationException>(() => packageManager.UninstallPackage(null, "foo", version: null, forceRemove: false, removeDependencies: false, logger: NullLogger.Instance), "No project was specified."); }
public void InstallPackageUninstalledSolutionLevelPackagesAreNotAddedToSolutionPackageConfig() { // Arrange var localRepository = new MockSharedPackageRepository(); var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository()); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var packageFoo = PackageUtility.CreatePackage("foo", "1.0", content: new[] { "hello" }); sourceRepository.AddPackage(packageFoo); var packageBar1 = PackageUtility.CreatePackage("bar1", "2.0", tools: new[] { "install.ps1" }); sourceRepository.AddPackage(packageBar1); var packageBar2 = PackageUtility.CreatePackage("bar2", "2.0", tools: new[] { "install.ps1" }); sourceRepository.AddPackage(packageBar2); var operations = new PackageOperation[] { new PackageOperation(packageFoo, PackageAction.Install), new PackageOperation(packageBar1, PackageAction.Uninstall), new PackageOperation(packageBar2, PackageAction.Uninstall) }; // Act packageManager.InstallPackage( projectManager, packageFoo, operations, ignoreDependencies: false, allowPrereleaseVersions: false, logger: NullLogger.Instance); // Assert Assert.False(localRepository.IsReferenced("bar1", new SemanticVersion("2.0"))); Assert.False(localRepository.IsReferenced("bar2", new SemanticVersion("2.0"))); Assert.True(packageManager.LocalRepository.Exists(packageFoo)); Assert.True(projectManager.LocalRepository.Exists(packageFoo)); }
public void InstallPackageDoesNotCallsMarkPackageDirectoryForDeletion() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); var sourceRepository = new MockPackageRepository(); var packageA = PackageUtility.CreatePackage("A"); var deleteOnRestartManager = new Mock<IDeleteOnRestartManager>(MockBehavior.Strict); sourceRepository.AddPackage(packageA); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, new MockFileSystem(), localRepository.Object, deleteOnRestartManager.Object, new Mock<VsPackageInstallerEvents>().Object); // Act packageManager.InstallPackage(null, "A", new SemanticVersion("1.0"), ignoreDependencies: false, allowPrereleaseVersions: false, logger: NullLogger.Instance); // Assert deleteOnRestartManager.Verify(); }
public void InstallPackageWithOperationsInstallsMetaPackageSuccessfully() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository()); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var package = PackageUtility.CreatePackage("foo", "1.0", dependencies: new [] { new PackageDependency("bar") }); sourceRepository.AddPackage(package); var package2 = PackageUtility.CreatePackage("bar", "2.0", content: new[] { "world" }); sourceRepository.AddPackage(package2); var operations = new PackageOperation[] { new PackageOperation(package, PackageAction.Install), new PackageOperation(package2, PackageAction.Install), }; // Act packageManager.InstallPackage(projectManager, package, operations, ignoreDependencies: false, allowPrereleaseVersions: false, logger: NullLogger.Instance); // Assert Assert.True(packageManager.LocalRepository.Exists(package)); Assert.True(packageManager.LocalRepository.Exists(package2)); Assert.True(projectManager.LocalRepository.Exists(package)); Assert.True(projectManager.LocalRepository.Exists(package2)); }
public void InstallPackageThrowsIfMinClientVersionIsNotSatisfied() { // Arrange Version nugetVersion = typeof(IPackage).Assembly.GetName().Version; Version requiredVersion = new Version(nugetVersion.Major, nugetVersion.Minor, nugetVersion.Build, nugetVersion.Revision + 1); var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), new MockPackageRepository()); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var package = PackageUtility.CreatePackage("foo", "1.0", new[] { "hello" }, minClientVersion: requiredVersion.ToString()); sourceRepository.AddPackage(package); string expectedErrorMessage = String.Format("The '{0}' package requires NuGet client version '{1}' or above, but the current NuGet version is '{2}'.", "foo 1.0", requiredVersion.ToString(), nugetVersion.ToString()); // Act & Assert ExceptionAssert.Throws<NuGetVersionNotSatisfiedException>( () => packageManager.InstallPackage(projectManager, "foo", new SemanticVersion("1.0"), ignoreDependencies: false, allowPrereleaseVersions: false, logger: NullLogger.Instance), expectedErrorMessage); }
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, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().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 ReinstallPackagesDoesNotThrowWithNewDependencyWhenProjectFrameworkChangesIfAllowPrereleaseParameterIsFalseAndPackageVersionIsPrerelease() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework, Version=v4.0")); var pathResolver = new DefaultPackagePathResolver(projectSystem); var packageReferenceRepository = new PackageReferenceRepository(projectSystem, localRepository); var projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, packageReferenceRepository); var packageManager = new VsPackageManager( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var packageA = PackageUtility.CreatePackageWithDependencySets( "A", "1.2-alpha", new[] { "contentA.txt" }, dependencySets: new PackageDependencySet[] { new PackageDependencySet(new FrameworkName(".NETFramework, Version=v4.0"), new [] { new PackageDependency("B")}), new PackageDependencySet(new FrameworkName("Silverlight, Version=v5.0"), new [] { new PackageDependency("C")}) }); var packageB = PackageUtility.CreatePackage( "B", "1.0", new[] { "contentB.txt" }); var packageC = PackageUtility.CreatePackage( "C", "2.0-beta", new[] { "contentC.txt" }); sourceRepository.Add(packageA); sourceRepository.Add(packageB); sourceRepository.Add(packageC); packageManager.InstallPackage(projectManager, "A", new SemanticVersion("1.2-alpha"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null); Assert.True(packageManager.LocalRepository.Exists("A")); Assert.True(projectManager.LocalRepository.Exists("A")); Assert.True(packageManager.LocalRepository.Exists("B")); Assert.True(projectManager.LocalRepository.Exists("B")); Assert.False(packageManager.LocalRepository.Exists("C")); Assert.False(projectManager.LocalRepository.Exists("C")); Assert.True(projectSystem.FileExists("contentA.txt")); Assert.True(projectSystem.FileExists("contentB.txt")); Assert.False(projectSystem.FileExists("contentC.txt")); // now change project's target framework to silverilght projectSystem.ChangeTargetFramework(new FrameworkName("Silverlight, Version=v5.0")); // Act packageManager.ReinstallPackage(projectManager, "A", updateDependencies: true, allowPrereleaseVersions: false, logger: null); // Assert Assert.True(packageManager.LocalRepository.Exists("A")); Assert.True(projectManager.LocalRepository.Exists("A")); Assert.False(packageManager.LocalRepository.Exists("B")); Assert.False(projectManager.LocalRepository.Exists("B")); Assert.True(packageManager.LocalRepository.Exists("C")); Assert.True(projectManager.LocalRepository.Exists("C")); }
public void ReinstallPackagesSkipReinstallingForPackagesThatDoNotExistInSource() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework, Version=v3.0")); var pathResolver = new DefaultPackagePathResolver(projectSystem); var packageReferenceRepository = new PackageReferenceRepository(projectSystem, localRepository); var projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, packageReferenceRepository); var installerEvents = new Mock<VsPackageInstallerEvents>(MockBehavior.Strict); int eventCount = 0; RegisterInstallerEvents(installerEvents, _ => eventCount++); var packageManager = new VsPackageManager( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, installerEvents.Object); var packageA = PackageUtility.CreatePackage( "A", "1.2-alpha", new[] { "net30\\content.txt", "silverlight40\\content4.txt" }, new[] { "lib\\net30\\ref.dll", "lib\\silverlight40\\refsl.dll" }); var packageB = PackageUtility.CreatePackage( "B", "2.0", new[] { "net30\\contentB.txt", "silverlight40\\content4B.txt" }, new[] { "lib\\net30\\refB.dll", "lib\\silverlight40\\refslB.dll" }); localRepository.AddPackage(packageA); localRepository.AddPackage(packageB); projectManager.LocalRepository.AddPackage(packageA); projectManager.LocalRepository.AddPackage(packageB); // now change project's target framework to silverlight projectSystem.ChangeTargetFramework(new FrameworkName("Silverlight, Version=v4.0")); var logger = new Mock<ILogger>(); logger.Setup(s => s.Log( MessageLevel.Warning, "Skipped reinstalling package '{0}' in project '{1}' because the package does not exist in the package source.", "B 2.0", "x:\\MockFileSystem") ).Verifiable(); logger.Setup(s => s.Log( MessageLevel.Warning, "Skipped reinstalling package '{0}' in project '{1}' because the package does not exist in the package source.", "A 1.2-alpha", "x:\\MockFileSystem") ).Verifiable(); // Act packageManager.ReinstallPackages(projectManager, updateDependencies: false, allowPrereleaseVersions: true, logger: logger.Object); // Assert logger.Verify(); Assert.Equal(0, eventCount); Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.True(projectManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.True(packageManager.LocalRepository.Exists("B")); Assert.True(projectManager.LocalRepository.Exists("B")); }
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, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().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 UpdatePackageDoesNotRemovesPackageIfPackageIsReferenced() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); localRepository.Setup(m => m.IsReferenced("A", new SemanticVersion("1.0"))).Returns(true); 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, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var projectManager = new ProjectManager(localRepository.Object, pathResolver, new MockProjectSystem(), projectRepository); // Act packageManager.UpdatePackage(projectManager, "A", version: null, updateDependencies: true, allowPrereleaseVersions: false, logger: NullLogger.Instance); // Assert Assert.True(packageManager.LocalRepository.Exists(A10)); }
public void InstallMetaPackageDoesNotAddEntryToSolutionPackagesConfig2(bool skipAssemblyReferences) { // Arrange // Source repository has A -> B, where B is a project-level package and A is a meta-package. // We want to make sure A is added to the packages.config of the project, and NOT packages.config of the solution var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); var sourceRepository = new MockPackageRepository(); var packageB = PackageUtility.CreatePackage("B", "1.0", new string[] { "hello.txt" }); var packageA = PackageUtility.CreatePackage("A", "2.0", new string[] { "world" }, dependencies: new[] { new PackageDependency("B") }); sourceRepository.Add(packageA); sourceRepository.Add(packageB); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var packageManager = new VsPackageManager( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository.Object, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var projectRepository = new MockProjectPackageRepository(localRepository.Object); var projectManager = new ProjectManager(localRepository.Object, pathResolver, projectSystem, projectRepository); localRepository.Setup(r => r.IsReferenced(It.IsAny<string>(), It.IsAny<SemanticVersion>())). Returns((string id, SemanticVersion version) => projectRepository.Exists(id, version)); // Act packageManager.InstallPackage( projectManager, "A", new SemanticVersion("2.0"), ignoreDependencies: false, allowPrereleaseVersions: true, skipAssemblyReferences: skipAssemblyReferences, logger: null); // Assert Assert.True(projectRepository.Exists("A", new SemanticVersion("2.0"))); Assert.True(projectRepository.Exists("B", new SemanticVersion("1.0"))); // assert that packages.config for solution-level is not created. Assert.False(localRepository.Object.IsSolutionReferenced("A", new SemanticVersion("2.0"))); Assert.False(localRepository.Object.IsSolutionReferenced("B", new SemanticVersion("1.0"))); }
public void ReinstallPackagesRestoresAllPackagesInAProjectWithNewContentIfProjectFrameworkChanges() { // Arrange var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>().Object; var sourceRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(new FrameworkName(".NETFramework, Version=v3.0")); var pathResolver = new DefaultPackagePathResolver(projectSystem); var packageReferenceRepository = new PackageReferenceRepository(projectSystem, localRepository); var projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, packageReferenceRepository); var packageManager = new VsPackageManager( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var packageA = PackageUtility.CreatePackage( "A", "1.2-alpha", new[] { "net30\\content.txt", "silverlight40\\content4.txt" }, new[] { "lib\\net30\\ref.dll", "lib\\silverlight40\\refsl.dll" }); var packageB = PackageUtility.CreatePackage( "B", "2.0", new[] { "net30\\contentB.txt", "silverlight40\\content4B.txt" }, new[] { "lib\\net30\\refB.dll", "lib\\silverlight40\\refslB.dll" }); sourceRepository.Add(packageA); sourceRepository.Add(packageB); packageManager.InstallPackage(projectManager, "A", new SemanticVersion("1.2-alpha"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null); packageManager.InstallPackage(projectManager, "B", new SemanticVersion("2.0"), ignoreDependencies: false, allowPrereleaseVersions: true, logger: null); Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.True(projectManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.True(projectSystem.FileExists("content.txt")); Assert.False(projectSystem.FileExists("content4.txt")); Assert.True(projectSystem.ReferenceExists("ref.dll")); Assert.False(projectSystem.ReferenceExists("refsl.dll")); Assert.True(packageManager.LocalRepository.Exists("B")); Assert.True(projectManager.LocalRepository.Exists("B")); Assert.True(projectSystem.FileExists("contentB.txt")); Assert.False(projectSystem.FileExists("content4B.txt")); Assert.True(projectSystem.ReferenceExists("refB.dll")); Assert.False(projectSystem.ReferenceExists("refslB.dll")); // now change project's target framework to silverlight projectSystem.ChangeTargetFramework(new FrameworkName("Silverlight, Version=v4.0")); // Act packageManager.ReinstallPackages(projectManager, updateDependencies: true, allowPrereleaseVersions: false, logger: null); // Assert Assert.True(packageManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.True(projectManager.LocalRepository.Exists("A", new SemanticVersion("1.2-alpha"))); Assert.False(projectSystem.FileExists("content.txt")); Assert.True(projectSystem.FileExists("content4.txt")); Assert.False(projectSystem.ReferenceExists("ref.dll")); Assert.True(projectSystem.ReferenceExists("refsl.dll")); Assert.True(packageManager.LocalRepository.Exists("B")); Assert.True(projectManager.LocalRepository.Exists("B")); Assert.False(projectSystem.FileExists("contentB.txt")); Assert.True(projectSystem.FileExists("content4B.txt")); Assert.False(projectSystem.ReferenceExists("refB.dll")); Assert.True(projectSystem.ReferenceExists("refslB.dll")); }
public void UpdatePackagesWithOperationsAddPackageCorrectly() { // Arrange var localRepository = new MockSharedPackageRepository(); var projectRepository = new MockProjectPackageRepository(localRepository); var sourceRepository = new MockPackageRepository(); var fileSystem = new MockFileSystem(); var pathResolver = new DefaultPackagePathResolver(fileSystem); var A1 = PackageUtility.CreatePackage("A", "1.0", new[] { "hello1" }); var A2 = PackageUtility.CreatePackage("A", "2.0", new[] { "hello2" }); var A3 = PackageUtility.CreatePackage("A", "3.0", new[] { "hello3" }); var B1 = PackageUtility.CreatePackage("B", "1.0", new[] { "world1" }); var B2 = PackageUtility.CreatePackage("B", "2.0", new[] { "world2" }); sourceRepository.AddPackage(A2); sourceRepository.AddPackage(A3); sourceRepository.AddPackage(B1); sourceRepository.AddPackage(B2); localRepository.AddPackage(A1); localRepository.AddPackage(B1); projectRepository.Add(A1); projectRepository.Add(B1); var packageManager = new VsPackageManager(TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, fileSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), projectRepository); var operations = new PackageOperation[] { new PackageOperation(A3, PackageAction.Install), new PackageOperation(B2, PackageAction.Install) }; // Act packageManager.UpdatePackages(projectManager, new[] { A3, B2 }, operations, updateDependencies: true, allowPrereleaseVersions: true, logger: NullLogger.Instance); // Assert Assert.True(localRepository.Exists("A", new SemanticVersion("3.0"))); Assert.False(localRepository.Exists("A", new SemanticVersion("2.0"))); Assert.False(localRepository.Exists("A", new SemanticVersion("1.0"))); Assert.True(localRepository.Exists("B", new SemanticVersion("2.0"))); Assert.False(localRepository.Exists("B", new SemanticVersion("1.0"))); Assert.True(projectRepository.Exists("A", new SemanticVersion("3.0"))); Assert.True(projectRepository.Exists("B", new SemanticVersion("2.0"))); }
public void InstallSolutionLevelPackageAddEntryToSolutionPackagesConfig2(bool skipAssemblyReferences) { // Arrange // Source repository has A -> B, where B is a project-level package and A is a meta-package. // We want to make sure A is added to the packages.config of the project, and NOT packages.config of the solution var localRepository = new MockSharedPackageRepository(); var sourceRepository = new MockPackageRepository(); var packageA = PackageUtility.CreatePackage("A", "2.0", tools: new[] { "install.ps1" }); sourceRepository.Add(packageA); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var packageManager = new VsPackageManager( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); var projectRepository = new MockProjectPackageRepository(localRepository); var projectManager = new ProjectManager(localRepository, pathResolver, projectSystem, projectRepository); // Act packageManager.InstallPackage( projectManager, "A", new SemanticVersion("2.0"), ignoreDependencies: false, allowPrereleaseVersions: true, skipAssemblyReferences: skipAssemblyReferences, logger: null); // Assert Assert.True(!projectRepository.Exists("A", new SemanticVersion("2.0"))); // assert that packages.config for solution-level is created. Assert.True(localRepository.IsSolutionReferenced("A", new SemanticVersion("2.0"))); }
public void InstallSolutionLevelPackageAddEntryToSolutionPackagesConfig(bool allowPrerelease) { // Arrange // Source repository has A -> B, where B is a project-level package and A is a meta-package. // We want to make sure A is added to the packages.config of the project, and NOT packages.config of the solution var localRepository = new Mock<MockPackageRepository>() { CallBase = true }.As<ISharedPackageRepository>(); var sourceRepository = new MockPackageRepository(); var packageA = PackageUtility.CreatePackage("A", "2.0", tools: new[] { "install.ps1" }); sourceRepository.Add(packageA); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var packageManager = new VsPackageManager( TestUtils.GetSolutionManager(), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository.Object, new Mock<IRecentPackageRepository>().Object, new Mock<VsPackageInstallerEvents>().Object); var projectRepository = new MockProjectPackageRepository(localRepository.Object); var projectManager = new ProjectManager(localRepository.Object, pathResolver, projectSystem, projectRepository); localRepository.Setup(r => r.IsReferenced(It.IsAny<string>(), It.IsAny<SemanticVersion>())). Returns((string id, SemanticVersion version) => projectRepository.Exists(id, version)); // Act packageManager.InstallPackage( projectManager, "A", new SemanticVersion("2.0"), ignoreDependencies: false, allowPrereleaseVersions: allowPrerelease, logger: null); // Assert Assert.True(!projectRepository.Exists("A", new SemanticVersion("2.0"))); // assert that packages.config for solution-level is created. localRepository.Verify(r => r.AddPackageReferenceEntry("A", new SemanticVersion("2.0")), Times.Once()); }