public void ExecuteMethodCallsInstallPackageMethodOnPackageManager(bool includePrerelease)
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
var projectManager2 = new Mock <IProjectManager>();
projectManager2.Setup(p => p.LocalRepository).Returns(localRepository);
var project1 = MockProjectUtility.CreateMockProject("Project1");
var project2 = MockProjectUtility.CreateMockProject("Project2");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object);
packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 });
var provider = CreateSolutionOnlineProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object);
provider.IncludePrerelease = includePrerelease;
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA);
firstTreeNode.Repository.AddPackage(packageB);
firstTreeNode.Repository.AddPackage(packageC);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager);
var manualEvent = new ManualResetEventSlim(false);
provider.ExecuteCompletedCallback = delegate
{
// Assert
Assert.Equal(RepositoryOperationNames.Install, sourceRepository.LastOperation);
mockPackageManager.Verify(p => p.InstallPackage(
new Project[] { project1, project2 },
packageB,
It.IsAny <IEnumerable <PackageOperation> >(),
false,
includePrerelease,
provider,
provider), Times.Once());
manualEvent.Set();
};
var extensionB = new PackageItem(provider, packageB);
// Act
provider.Execute(extensionB);
// do not allow the method to return
manualEvent.Wait();
}
public void ExecuteMethodDoNotCallInstallPackageIfUserDoesNotSelectAnyProject()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
var projectManager2 = new Mock <IProjectManager>();
projectManager2.Setup(p => p.LocalRepository).Returns(localRepository);
var project1 = MockProjectUtility.CreateMockProject("Project1");
var project2 = MockProjectUtility.CreateMockProject("Project2");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object);
packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 });
var mockWindowService = new Mock <IUserNotifierServices>();
mockWindowService.Setup(p => p.ShowProjectSelectorWindow(
It.IsAny <string>(),
It.IsAny <IPackage>(),
It.IsAny <Predicate <Project> >(),
It.IsAny <Predicate <Project> >())).Returns(new Project[0]);
var provider = CreateSolutionOnlineProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.Object);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA);
firstTreeNode.Repository.AddPackage(packageB);
firstTreeNode.Repository.AddPackage(packageC);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager);
var manualEvent = new ManualResetEventSlim(false);
provider.ExecuteCompletedCallback = delegate
{
// Assert
mockPackageManager.Verify(p => p.InstallPackage(
It.IsAny <IEnumerable <Project> >(),
packageB,
It.IsAny <IEnumerable <PackageOperation> >(),
false,
false,
provider,
provider), Times.Never());
manualEvent.Set();
};
var extensionB = new PackageItem(provider, packageB);
// Act
provider.Execute(extensionB);
// do not allow the method to return
manualEvent.Wait();
}
public void InstallPackageInvokeInstallScript()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0", tools: new[] { "install.ps1" });
var packageC = PackageUtility.CreatePackage("C", "3.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
var localRepository = new MockPackageRepository();
var fileSystem = new Mock <IVsProjectSystem>();
fileSystem.SetupGet(f => f.UniqueName).Returns("Project1");
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
projectManager1.Setup(p => p.AddPackageReference(packageB, false, false))
.Raises(p => p.PackageReferenceAdded += (o, a) => { }, new PackageOperationEventArgs(packageB, fileSystem.As <IFileSystem>().Object, "x:\\nuget"));
var project1 = MockProjectUtility.CreateMockProject("Project1");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true);
packageManager.Setup(p => p.InstallPackage(
new[] { project1 },
packageB,
It.IsAny <IEnumerable <PackageOperation> >(),
false,
false,
It.IsAny <ILogger>(),
It.IsAny <IPackageOperationEventListener>()))
.Callback(
(IEnumerable <Project> projects,
IPackage package,
IEnumerable <PackageOperation> operations,
bool ignoreDependencies,
bool allowPrereleaseVersions,
ILogger logger,
IPackageOperationEventListener eventListener) =>
{
eventListener.OnBeforeAddPackageReference(project1);
projectManager1.Object.AddPackageReference(packageB, false, false);
});
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1 });
var scriptExecutor = new Mock <IScriptExecutor>();
var provider = CreateSolutionOnlineProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, scriptExecutor: scriptExecutor.Object);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA);
firstTreeNode.Repository.AddPackage(packageB);
firstTreeNode.Repository.AddPackage(packageC);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager);
var manualEvent = new ManualResetEventSlim(false);
Exception callbackException = null;
provider.ExecuteCompletedCallback = delegate
{
try
{
// Assert
scriptExecutor.Verify(p => p.Execute("x:\\nuget", "install.ps1", packageB, project1, It.IsAny <FrameworkName>(), It.IsAny <ILogger>()), Times.Once());
}
catch (Exception exception)
{
callbackException = exception;
}
finally
{
manualEvent.Set();
}
};
var extensionB = new PackageItem(provider, packageB);
// Act
provider.Execute(extensionB);
// do not allow the method to return
manualEvent.Wait();
if (callbackException != null)
{
throw callbackException;
}
}
public void ExecuteMethodCallsInstallPackageMethodOnPackageManager()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
var projectManager2 = new Mock <IProjectManager>();
projectManager2.Setup(p => p.LocalRepository).Returns(localRepository);
var project1 = MockProjectUtility.CreateMockProject("Project1");
var project2 = MockProjectUtility.CreateMockProject("Project2");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object);
packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 });
var provider = CreateSolutionInstalledProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
provider.SelectedNode = firstTreeNode;
var manualEvent = new ManualResetEventSlim(false);
provider.ExecuteCompletedCallback = delegate
{
// Assert
packageManager.Verify(p => p.InstallPackage(
projectManager1.Object,
packageB.Id,
packageB.Version,
false,
true,
provider),
Times.Once());
packageManager.Verify(p => p.InstallPackage(
projectManager2.Object,
packageB.Id,
packageB.Version,
false,
true,
provider),
Times.Once());
manualEvent.Set();
};
var extensionB = new PackageItem(provider, packageB);
// Act
provider.Execute(extensionB);
// do not allow the method to return
manualEvent.Wait();
}
public void SolutionInstalledProviderShowsAllVersions()
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageA2 = PackageUtility.CreatePackage("A", "2.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA);
localRepository.AddPackage(packageA2);
localRepository.AddPackage(packageB);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
var projectManager2 = new Mock <IProjectManager>();
projectManager2.Setup(p => p.LocalRepository).Returns(localRepository);
var project1 = MockProjectUtility.CreateMockProject("Project1");
var project2 = MockProjectUtility.CreateMockProject("Project2");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object);
packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true);
var provider = CreateSolutionInstalledProvider(packageManager.Object, localRepository);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
provider.SelectedNode = firstTreeNode;
firstTreeNode.IsSelected = true;
var mre = new ManualResetEventSlim(false);
firstTreeNode.PackageLoadCompleted += delegate
{
var allExtensions = firstTreeNode.Extensions;
// Assert
Assert.Equal(3, allExtensions.Count);
Assert.Equal("A", allExtensions[0].Id);
Assert.Equal("1.0", ((PackageItem)allExtensions[0]).Version);
Assert.Equal("A", allExtensions[1].Id);
Assert.Equal("2.0", ((PackageItem)allExtensions[1]).Version);
Assert.Equal("B", allExtensions[2].Id);
Assert.Equal("2.0", ((PackageItem)allExtensions[2]).Version);
mre.Set();
};
// Act
var ignore = firstTreeNode.Extensions;
mre.Wait();
}
public void ExecuteUninstallsSolutionLevelPackageWhenUpdating()
{
// Arrange
var packageA_10 = PackageUtility.CreatePackage("A", "1.0", content: null, assemblyReferences: null, tools: new[] { "init.ps1" }, dependencies: null);
var packageA_12 = PackageUtility.CreatePackage("A", "1.2", content: null, assemblyReferences: null, tools: new[] { "init.ps1" }, dependencies: null);
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA_12);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageA_10);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
var project1 = MockProjectUtility.CreateMockProject("Project1");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.LocalRepository).Returns(localRepository);
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.IsProjectLevel(packageA_12)).Returns(false);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1 });
var mockWindowService = new Mock <IUserNotifierServices>();
mockWindowService.Setup(p => p.ShowProjectSelectorWindow(
It.IsAny <string>(),
It.IsAny <IPackage>(),
It.IsAny <Predicate <Project> >(),
It.IsAny <Predicate <Project> >())).Returns(new Project[0]);
var provider = CreateSolutionUpdatesProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.Object);
var extensionTree = provider.ExtensionsTree;
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA_10);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager);
var manualEvent = new ManualResetEventSlim(false);
Exception exception = null;
provider.ExecuteCompletedCallback = delegate
{
try
{
// Assert
mockPackageManager.Verify(p => p.UpdatePackage(
new Project[0],
packageA_12,
new[] { new PackageOperation(packageA_10, PackageAction.Uninstall), new PackageOperation(packageA_12, PackageAction.Install) },
true,
false,
provider,
provider), Times.Once());
}
catch (Exception e)
{
exception = e;
}
finally
{
manualEvent.Set();
}
};
var extensionA_12 = new PackageItem(provider, packageA_12);
// Act
provider.Execute(extensionA_12);
// do not allow the method to return
manualEvent.Wait();
Assert.Null(exception);
}
public void ExecuteAllMethodCallUpdateAllPackageOnAllProjects(bool includePrerelease)
{
// Arrange
var packageA = PackageUtility.CreatePackage("A", "1.0");
var packageB = PackageUtility.CreatePackage("B", "2.0");
var packageC = PackageUtility.CreatePackage("C", "3.0");
var packageB2 = PackageUtility.CreatePackage("B", "4.0");
var sourceRepository = new MockPackageRepository();
sourceRepository.AddPackage(packageA);
sourceRepository.AddPackage(packageC);
sourceRepository.AddPackage(packageB);
sourceRepository.AddPackage(packageB2);
var localRepository = new MockPackageRepository();
localRepository.AddPackage(packageB);
var projectManager1 = new Mock <IProjectManager>();
projectManager1.Setup(p => p.LocalRepository).Returns(localRepository);
var projectManager2 = new Mock <IProjectManager>();
projectManager2.Setup(p => p.LocalRepository).Returns(localRepository);
var project1 = MockProjectUtility.CreateMockProject("Project1");
var project2 = MockProjectUtility.CreateMockProject("Project2");
var packageManager = new Mock <IVsPackageManager>();
packageManager.Setup(p => p.SourceRepository).Returns(sourceRepository);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project1))).Returns(projectManager1.Object);
packageManager.Setup(p => p.GetProjectManager(It.Is <Project>(s => s == project2))).Returns(projectManager2.Object);
packageManager.Setup(p => p.IsProjectLevel(It.IsAny <IPackage>())).Returns(true);
var solutionManager = new Mock <ISolutionManager>();
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project1"))).Returns(project1);
solutionManager.Setup(p => p.GetProject(It.Is <string>(s => s == "Project2"))).Returns(project2);
solutionManager.Setup(p => p.GetProjects()).Returns(new Project[] { project1, project2 });
var mockWindowService = new Mock <IUserNotifierServices>();
mockWindowService.Setup(p => p.ShowProjectSelectorWindow(
It.IsAny <string>(),
It.IsAny <IPackage>(),
It.IsAny <Predicate <Project> >(),
It.IsAny <Predicate <Project> >())).Returns(new Project[] { project1, project2 });
var provider = CreateSolutionUpdatesProvider(packageManager.Object, localRepository, solutionManager: solutionManager.Object, userNotifierServices: mockWindowService.Object);
provider.IncludePrerelease = includePrerelease;
var extensionTree = provider.ExtensionsTree;
var extensionB2 = new PackageItem(provider, packageB2);
var firstTreeNode = (SimpleTreeNode)extensionTree.Nodes[0];
firstTreeNode.Repository.AddPackage(packageA);
firstTreeNode.Repository.AddPackage(packageB);
firstTreeNode.Repository.AddPackage(packageC);
firstTreeNode.Extensions.Add(extensionB2);
provider.SelectedNode = firstTreeNode;
IVsPackageManager activePackageManager = provider.GetActivePackageManager();
Mock <IVsPackageManager> mockPackageManager = Mock.Get <IVsPackageManager>(activePackageManager);
var manualEvent = new ManualResetEventSlim(false);
Exception exception = null;
provider.ExecuteCompletedCallback = delegate
{
try
{
// Assert
Assert.Equal(RepositoryOperationNames.Update, sourceRepository.LastOperation);
mockPackageManager.Verify(
p => p.UpdatePackages(true, includePrerelease, provider, provider),
Times.Once());
}
catch (Exception ex)
{
exception = ex;
}
finally
{
manualEvent.Set();
}
};
// Act
provider.Execute(item: null);
// do not allow the method to return
manualEvent.Wait();
Assert.Null(exception);
}
