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 CallingCheckForMissingPackagesRaisesThePackagesMissingStatusChangedEventWithFalseValue() { // Scenario: // Project's packages.config specifies: A[1.0], B[1.2-alpha] // The solution's packages folder contains only A[1.0], B[1.2-alpha] // Arrange string tempSolutionPath = "x:\\project1"; var project = new Mock<Project>(); // setup SolutionManager var solutionManager = new Mock<ISolutionManager>(); solutionManager.Setup(p => p.IsSolutionOpen).Returns(true); solutionManager.Setup(p => p.SolutionDirectory).Returns(tempSolutionPath); solutionManager.Setup(p => p.GetProjects()).Returns(new[] { project.Object }); // setup file system var fileSystem = new Mock<IFileSystem>(); fileSystem.Setup(p => p.DirectoryExists(".nuget")).Returns(true); fileSystem.Setup(p => p.FileExists(".nuget\\NuGet.exe")).Returns(true); fileSystem.Setup(p => p.FileExists(".nuget\\NuGet.targets")).Returns(true); var fileSystemProvider = new Mock<IFileSystemProvider>(); fileSystemProvider.Setup(p => p.GetFileSystem(tempSolutionPath)).Returns(fileSystem.Object); // setup VsPackageManager var projectFileSystem = new MockFileSystem(); projectFileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.0.0.0"" /> <package id=""B"" version=""1.2-alpha"" /> </packages>"); var packageReferenceRepository = new PackageReferenceRepository(projectFileSystem, projectName: null, sourceRepository: new Mock<ISharedPackageRepository>().Object); var projectManager = new Mock<IProjectManager>(); projectManager.Setup(p => p.LocalRepository).Returns(packageReferenceRepository); var localRepository = new MockSharedPackageRepository(); localRepository.AddPackage(PackageUtility.CreatePackage("A", "1.0")); localRepository.AddPackage(PackageUtility.CreatePackage("B", "1.2-alpha")); var packageManager = new Mock<IVsPackageManager>(); packageManager.Setup(p => p.GetProjectManager(project.Object)).Returns(projectManager.Object); packageManager.Setup(p => p.LocalRepository).Returns(localRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(p => p.CreatePackageManager()).Returns(packageManager.Object); var packageRestore = CreateInstance( fileSystemProvider: fileSystemProvider.Object, solutionManager: solutionManager.Object, packageManagerFactory: packageManagerFactory.Object); bool? packagesMissing = null; packageRestore.PackagesMissingStatusChanged += (o, e) => { packagesMissing = e.PackagesMissing; }; // Act packageRestore.CheckForMissingPackages(); // Assert Assert.Equal(false, packagesMissing); }
public void CallingCheckForMissingPackagesRaisesThePackagesMissingStatusChangedEventWithTrueValueIfPackagesFolderIsMissing() { // Scenario: // Project's packages.config specifies: A[1.0] // The solution's packages folder doesn't contain any packages // Arrange string tempSolutionPath = "x:\\project1"; var project = new Mock<Project>(); // setup SolutionManager var solutionManager = new Mock<ISolutionManager>(); solutionManager.Setup(p => p.IsSolutionOpen).Returns(true); solutionManager.Setup(p => p.SolutionDirectory).Returns(tempSolutionPath); solutionManager.Setup(p => p.GetProjects()).Returns(new[] { project.Object }); // setup file system var fileSystem = new Mock<IFileSystem>(MockBehavior.Strict); var fileSystemProvider = new Mock<IFileSystemProvider>(); fileSystemProvider.Setup(p => p.GetFileSystem(tempSolutionPath)).Returns(fileSystem.Object); // setup VsPackageManager var projectFileSystem = new MockFileSystem(); projectFileSystem.AddFile("packages.config", @"<?xml version=""1.0"" encoding=""utf-8""?> <packages> <package id=""A"" version=""1.0.0.0"" /> </packages>"); var packageReferenceRepository = new PackageReferenceRepository(projectFileSystem, projectName: null, sourceRepository: new Mock<ISharedPackageRepository>().Object); var projectManager = new Mock<IProjectManager>(); projectManager.Setup(p => p.LocalRepository).Returns(packageReferenceRepository); var localRepository = new MockSharedPackageRepository(); var packageManager = new Mock<IVsPackageManager>(); packageManager.Setup(p => p.GetProjectManager(project.Object)).Returns(projectManager.Object); packageManager.Setup(p => p.LocalRepository).Returns(localRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(); packageManagerFactory.Setup(p => p.CreatePackageManager()).Returns(packageManager.Object); var packageRestore = CreateInstance( fileSystemProvider: fileSystemProvider.Object, solutionManager: solutionManager.Object, packageManagerFactory: packageManagerFactory.Object); bool? packagesMissing = null; packageRestore.PackagesMissingStatusChanged += (o, e) => { packagesMissing = e.PackagesMissing; }; // Act packageRestore.CheckForMissingPackages(); // Assert Assert.Equal(true, packagesMissing); }
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 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 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 UpdatePackagesEndToEndWhereNewerVersionPackageDoesNotHaveDependencyLikeOlderVersion() { // 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" }, dependencies: new[] { PackageDependency.CreateDependency("B", "1.0") }); var A2 = PackageUtility.CreatePackage("A", "2.0", new[] { "hello2" }, dependencies: new[] { PackageDependency.CreateDependency("C", "1.0") }); var B1 = PackageUtility.CreatePackage("B", "1.0", new[] { "world1" }); var B2 = PackageUtility.CreatePackage("B", "2.0", new[] { "world2" }); var C1 = PackageUtility.CreatePackage("C", "1.0", new[] { "galaxy1" }); var C2 = PackageUtility.CreatePackage("C", "2.0", new[] { "galaxy2" }); sourceRepository.AddPackage(A1); sourceRepository.AddPackage(A2); sourceRepository.AddPackage(B1); sourceRepository.AddPackage(B2); sourceRepository.AddPackage(C1); sourceRepository.AddPackage(C2); localRepository.AddPackage(A1); localRepository.AddPackage(B1); localRepository.AddPackage(C1); projectRepository.Add(A1); projectRepository.Add(B1); projectRepository.Add(C1); 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 installWalker = new InstallWalker( localRepository, sourceRepository, null, logger: NullLogger.Instance, ignoreDependencies: false, allowPrereleaseVersions: true); IList<IPackage> updatePackagesByDependencyOrder; var updatePackages = new List<IPackage> { A2, B2, C2 }; var operationsForShowingLicense = installWalker.ResolveOperations(updatePackages, out updatePackagesByDependencyOrder); // Act packageManager.UpdatePackages(projectManager, updatePackagesByDependencyOrder, operationsForShowingLicense, updateDependencies: true, allowPrereleaseVersions: true, logger: NullLogger.Instance); // Assert // NOTE THAT BELOW, there is no uninstall operation for B1 but only for C1. Because A2 depends on C1 only where A1 depends on B1 only // And, the operations are resolved for A2 NOT A1 Assert.True(operationsForShowingLicense.Count == 4); Assert.True(operationsForShowingLicense[0].Package == A2 && operationsForShowingLicense[0].Action == PackageAction.Install); Assert.True(operationsForShowingLicense[1].Package == B2 && operationsForShowingLicense[1].Action == PackageAction.Install); Assert.True(operationsForShowingLicense[2].Package == C1 && operationsForShowingLicense[2].Action == PackageAction.Uninstall); Assert.True(operationsForShowingLicense[3].Package == C2 && operationsForShowingLicense[3].Action == PackageAction.Install); Assert.True(updatePackagesByDependencyOrder.Count == 3); Assert.True(updatePackagesByDependencyOrder[0] == C2); Assert.True(updatePackagesByDependencyOrder[1] == A2); Assert.True(updatePackagesByDependencyOrder[2] == B2); Assert.True(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(localRepository.Exists("C", new SemanticVersion("2.0"))); Assert.False(localRepository.Exists("C", new SemanticVersion("1.0"))); Assert.True(projectRepository.Exists("A", new SemanticVersion("2.0"))); Assert.True(projectRepository.Exists("B", new SemanticVersion("2.0"))); Assert.True(projectRepository.Exists("C", new SemanticVersion("2.0"))); }
public void InstallCommandUpdatesPackageIfAlreadyPresentAndNotUsingSideBySide() { // Arrange var fileSystem = new MockFileSystem(); var repository = new MockSharedPackageRepository(); var packageManager = new PackageManager(GetFactory().CreateRepository("Some source"), new DefaultPackagePathResolver(fileSystem), fileSystem, repository); var installCommand = new TestInstallCommand(GetFactory(), GetSourceProvider(), fileSystem, packageManager) { Console = new MockConsole(), ExcludeVersion = true, Version = "0.4", }; installCommand.Arguments.Add("Baz"); // Act - 1 installCommand.ExecuteCommand(); // Assert - 1 Assert.True(repository.Exists("Baz", new SemanticVersion("0.4"))); // Act - 2 installCommand.Version = null; installCommand.ExecuteCommand(); // Assert - 2 Assert.False(repository.Exists("Baz", new SemanticVersion("0.4"))); Assert.True(repository.Exists("Baz", new SemanticVersion("0.7"))); }
public void InstallingSatellitePackageOnlyCopiesCultureSpecificLibFolderContents() { // Arrange // Create a runtime package and a satellite package that has a dependency on the runtime package, and uses the // local suffix convention. var runtimePackage = PackageUtility.CreatePackage("foo", "1.0.0", assemblyReferences: new[] { @"lib\foo.dll" }, content: new[] { @"english.txt" }); var satellitePackage = PackageUtility.CreatePackage("foo.ja-jp", "1.0.0", language: "ja-jp", satelliteAssemblies: new[] { @"lib\ja-jp\foo.resources.dll", @"lib\ja-jp\foo.xml", @"lib\japanese.xml" }, content: new[] { @"english.txt", @"japanese.txt" }, dependencies: new[] { new PackageDependency("foo", VersionUtility.ParseVersionSpec("[1.0.0]")) }); var projectSystem = new MockProjectSystem(); var localRepository = new MockSharedPackageRepository(); var sourceRepository = new MockPackageRepository(); var packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository); sourceRepository.AddPackage(runtimePackage); sourceRepository.AddPackage(satellitePackage); // Act Install("foo", new NullProjectManager(packageManager)); Install("foo.ja-jp", new NullProjectManager(packageManager)); // Assert Assert.Equal(9, projectSystem.Paths.Count); Assert.True(projectSystem.FileExists(@"foo.1.0.0\content\english.txt")); Assert.True(projectSystem.FileExists(@"foo.1.0.0\lib\foo.dll")); Assert.True(projectSystem.FileExists(@"foo.1.0.0\lib\ja-jp\foo.resources.dll")); Assert.True(projectSystem.FileExists(@"foo.1.0.0\lib\ja-jp\foo.xml")); Assert.True(projectSystem.FileExists(@"foo.ja-jp.1.0.0\content\english.txt")); Assert.True(projectSystem.FileExists(@"foo.ja-jp.1.0.0\content\japanese.txt")); Assert.True(projectSystem.FileExists(@"foo.ja-jp.1.0.0\lib\japanese.xml")); Assert.True(projectSystem.FileExists(@"foo.ja-jp.1.0.0\lib\ja-jp\foo.resources.dll")); Assert.True(projectSystem.FileExists(@"foo.ja-jp.1.0.0\lib\ja-jp\foo.xml")); Assert.False(projectSystem.FileExists(@"foo.1.0.0\lib\japanese.xml")); Assert.False(projectSystem.FileExists(@"foo.1.0.0\content\japanese.txt")); }
public void InstallingSatellitePackageCopiesFilesIntoRuntimePackageFolderWhenRuntimeIsInstalledAsADependency() { // Arrange // Create a runtime package and a satellite package that has a dependency on the runtime package, and uses the // local suffix convention. var runtimePackage = PackageUtility.CreatePackage("foo", "1.0.0", assemblyReferences: new[] { @"lib\foo.dll" }); var satellitePackage = PackageUtility.CreatePackage("foo.ja-jp", "1.0.0", language: "ja-jp", satelliteAssemblies: new[] { @"lib\ja-jp\foo.resources.dll", @"lib\ja-jp\foo.xml" }, dependencies: new[] { new PackageDependency("foo", VersionUtility.ParseVersionSpec("[1.0.0]")) }); var projectSystem = new MockProjectSystem(); var localRepository = new MockSharedPackageRepository(); var sourceRepository = new MockPackageRepository(); var packageManager = new PackageManager(sourceRepository, new DefaultPackagePathResolver(projectSystem), projectSystem, localRepository); sourceRepository.AddPackage(runtimePackage); sourceRepository.AddPackage(satellitePackage); // Act Install("foo.ja-jp", new NullProjectManager(packageManager)); // Assert Assert.True(projectSystem.FileExists(@"foo.1.0.0\lib\foo.dll")); Assert.True(projectSystem.FileExists(@"foo.1.0.0\lib\ja-jp\foo.resources.dll")); Assert.True(projectSystem.FileExists(@"foo.1.0.0\lib\ja-jp\foo.xml")); Assert.True(projectSystem.FileExists(@"foo.ja-jp.1.0.0\lib\ja-jp\foo.resources.dll")); Assert.True(projectSystem.FileExists(@"foo.ja-jp.1.0.0\lib\ja-jp\foo.xml")); }
public void SafeUpdatePackageDoNotUpdateToUnlistedPackage(string versionA1, string versionA2) { // Arrange var packageA1 = PackageUtility.CreatePackage("A", versionA1); var packageA2 = PackageUtility.CreatePackage("A", versionA2, listed: false); var sharedRepository = new MockSharedPackageRepository(); sharedRepository.AddPackage(packageA1); var packageRepository = new MockPackageRepository { packageA1, packageA2 }; var packageManager = new MockVsPackageManager( TestUtils.GetSolutionManagerWithProjects(), packageRepository, sharedRepository); var packageManagerFactory = new Mock<IVsPackageManagerFactory>(MockBehavior.Strict); packageManagerFactory.Setup(m => m.CreatePackageManager()).Returns(packageManager); // Act var cmdlet = new UpdatePackageCommand(TestUtils.GetSolutionManager(), packageManagerFactory.Object, null, new Mock<IVsPackageSourceProvider>().Object, new Mock<IHttpClientEvents>().Object, null, new Mock<IVsCommonOperations>().Object, new Mock<IDeleteOnRestartManager>().Object); cmdlet.Id = "A"; cmdlet.Safe = true; cmdlet.Execute(); // Assert Assert.True(sharedRepository.Contains(packageA1)); Assert.False(sharedRepository.Contains(packageA2)); }
public void 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 ReinstallOnePackageInOneProjectSetOperationToUpdate() { // Arrange var localRepository = new MockSharedPackageRepository(); var sourceRepository = new MockPackageRepository(); var projectRepository = new MockPackageRepository(); var projectSystem = new MockProjectSystem(); var pathResolver = new DefaultPackagePathResolver(projectSystem); var projectManager = new ProjectManager(localRepository, pathResolver, new MockProjectSystem(), projectRepository); var project = TestUtils.GetProject("project runway", projectFiles: new[] { "dotnetjunky.cs" }); var packageManager = new MockVsPackageManager( TestUtils.GetSolutionManager(defaultProjectName: "project runway", projects: new[] { project }), sourceRepository, new Mock<IFileSystemProvider>().Object, projectSystem, localRepository, new Mock<IDeleteOnRestartManager>().Object, new Mock<VsPackageInstallerEvents>().Object); packageManager.RegisterProjectManager(project, projectManager); var package = PackageUtility.CreatePackage("phuong", "1.0", new[] { "hello" }); localRepository.AddPackage(package); projectRepository.AddPackage(package); sourceRepository.AddPackage(package); // Act packageManager.ReinstallPackage( projectManager, "phuong", updateDependencies: true, allowPrereleaseVersions: true, logger: NullLogger.Instance); // Assert Assert.Equal("Reinstall", sourceRepository.LastOperation); Assert.Equal("phuong", sourceRepository.LastMainPackageId); }