Browse Source

Add Update All button to Manage Packages dialog.

pull/44/head
Matt Ward 12 years ago
parent
commit
beb62296ac
  1. 6
      src/AddIns/Misc/PackageManagement/Cmdlets/Project/Src/InvokeProcessPackageActionsCmdlet.cs
  2. 4
      src/AddIns/Misc/PackageManagement/Project/PackageManagement.csproj
  3. 5
      src/AddIns/Misc/PackageManagement/Project/Src/AvailablePackagesViewModel.cs
  4. 12
      src/AddIns/Misc/PackageManagement/Project/Src/ConsolePackageActionRunner.cs
  5. 31
      src/AddIns/Misc/PackageManagement/Project/Src/Design/FakePackageManagementProject.cs
  6. 16
      src/AddIns/Misc/PackageManagement/Project/Src/Design/FakePackageManager.cs
  7. 7
      src/AddIns/Misc/PackageManagement/Project/Src/Design/FakeRegisteredPackageRepositories.cs
  8. 15
      src/AddIns/Misc/PackageManagement/Project/Src/IPackageAction.cs
  9. 4
      src/AddIns/Misc/PackageManagement/Project/Src/IPackageActionRunner.cs
  10. 3
      src/AddIns/Misc/PackageManagement/Project/Src/IPackageManagementProject.cs
  11. 6
      src/AddIns/Misc/PackageManagement/Project/Src/IPackageOperationResolverFactory.cs
  12. 1
      src/AddIns/Misc/PackageManagement/Project/Src/IPackageViewModelFactory.cs
  13. 2
      src/AddIns/Misc/PackageManagement/Project/Src/ISharpDevelopPackageManager.cs
  14. 4
      src/AddIns/Misc/PackageManagement/Project/Src/IUpdatePackageActions.cs
  15. 13
      src/AddIns/Misc/PackageManagement/Project/Src/IUpdatePackageSettings.cs
  16. 10
      src/AddIns/Misc/PackageManagement/Project/Src/PackageActionRunner.cs
  17. 6
      src/AddIns/Misc/PackageManagement/Project/Src/PackageActionsToRun.cs
  18. 15
      src/AddIns/Misc/PackageManagement/Project/Src/PackageManagementProject.cs
  19. 11
      src/AddIns/Misc/PackageManagement/Project/Src/PackageOperationsResolverFactory.cs
  20. 2
      src/AddIns/Misc/PackageManagement/Project/Src/PackageViewModel.cs
  21. 9
      src/AddIns/Misc/PackageManagement/Project/Src/PackagesView.xaml
  22. 44
      src/AddIns/Misc/PackageManagement/Project/Src/PackagesViewModel.cs
  23. 4
      src/AddIns/Misc/PackageManagement/Project/Src/ProcessPackageAction.cs
  24. 2
      src/AddIns/Misc/PackageManagement/Project/Src/ProcessPackageOperationsAction.cs
  25. 52
      src/AddIns/Misc/PackageManagement/Project/Src/ReducedPackageOperations.cs
  26. 37
      src/AddIns/Misc/PackageManagement/Project/Src/SharpDevelopPackageManager.cs
  27. 2
      src/AddIns/Misc/PackageManagement/Project/Src/UpdatePackageAction.cs
  28. 2
      src/AddIns/Misc/PackageManagement/Project/Src/UpdatePackageActions.cs
  29. 85
      src/AddIns/Misc/PackageManagement/Project/Src/UpdatePackagesAction.cs
  30. 24
      src/AddIns/Misc/PackageManagement/Project/Src/UpdatedPackagesViewModel.cs
  31. 5
      src/AddIns/Misc/PackageManagement/Test/PackageManagement.Tests.csproj
  32. 18
      src/AddIns/Misc/PackageManagement/Test/Src/AvailablePackagesViewModelTests.cs
  33. 14
      src/AddIns/Misc/PackageManagement/Test/Src/ConsolePackageActionRunnerTests.cs
  34. 19
      src/AddIns/Misc/PackageManagement/Test/Src/Helpers/ExceptionThrowingPackageActionRunner.cs
  35. 16
      src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakePackageActionRunner.cs
  36. 20
      src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakePackageOperationResolverFactory.cs
  37. 10
      src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakePackageViewModelFactory.cs
  38. 2
      src/AddIns/Misc/PackageManagement/Test/Src/Helpers/PackageCollectionAssert.cs
  39. 29
      src/AddIns/Misc/PackageManagement/Test/Src/Helpers/PackageOperationHelper.cs
  40. 7
      src/AddIns/Misc/PackageManagement/Test/Src/Helpers/TestableProcessPackageAction.cs
  41. 4
      src/AddIns/Misc/PackageManagement/Test/Src/Helpers/TestableProjectManager.cs
  42. 37
      src/AddIns/Misc/PackageManagement/Test/Src/Helpers/TestableUpdatePackagesAction.cs
  43. 10
      src/AddIns/Misc/PackageManagement/Test/Src/InstallPackageActionTests.cs
  44. 2
      src/AddIns/Misc/PackageManagement/Test/Src/InstalledPackageViewModelTests.cs
  45. 14
      src/AddIns/Misc/PackageManagement/Test/Src/PackageActionRunnerTests.cs
  46. 22
      src/AddIns/Misc/PackageManagement/Test/Src/PackageActionsToRunTests.cs
  47. 41
      src/AddIns/Misc/PackageManagement/Test/Src/PackageManagementProjectTests.cs
  48. 2
      src/AddIns/Misc/PackageManagement/Test/Src/PackageReferenceInstallerTests.cs
  49. 14
      src/AddIns/Misc/PackageManagement/Test/Src/PackageViewModelTests.cs
  50. 23
      src/AddIns/Misc/PackageManagement/Test/Src/ProcessPackageActionTests.cs
  51. 170
      src/AddIns/Misc/PackageManagement/Test/Src/ReducedPackageOperationsTests.cs
  52. 245
      src/AddIns/Misc/PackageManagement/Test/Src/SharpDevelopPackageManagerTests.cs
  53. 165
      src/AddIns/Misc/PackageManagement/Test/Src/UpdatePackagesActionTests.cs
  54. 7
      src/AddIns/Misc/PackageManagement/Test/Src/UpdatedPackageViewModelTests.cs
  55. 253
      src/AddIns/Misc/PackageManagement/Test/Src/UpdatedPackagesViewModelTests.cs

6
src/AddIns/Misc/PackageManagement/Cmdlets/Project/Src/InvokeProcessPackageActionsCmdlet.cs

@ -36,18 +36,18 @@ namespace ICSharpCode.PackageManagement.Cmdlets
void ExecutePackageActions() void ExecutePackageActions()
{ {
ProcessPackageAction action = null; IPackageAction action = null;
while (GetNextAction(out action)) { while (GetNextAction(out action)) {
Execute(action); Execute(action);
} }
} }
bool GetNextAction(out ProcessPackageAction action) bool GetNextAction(out IPackageAction action)
{ {
return actionsToRun.GetNextAction(out action); return actionsToRun.GetNextAction(out action);
} }
void Execute(ProcessPackageAction action) void Execute(IPackageAction action)
{ {
action.PackageScriptRunner = this; action.PackageScriptRunner = this;
action.Execute(); action.Execute();

4
src/AddIns/Misc/PackageManagement/Project/PackageManagement.csproj

@ -156,8 +156,10 @@
<Compile Include="Src\IClassKindUpdater.cs" /> <Compile Include="Src\IClassKindUpdater.cs" />
<Compile Include="Src\IDocumentNamespaceCreator.cs" /> <Compile Include="Src\IDocumentNamespaceCreator.cs" />
<Compile Include="Src\IPackageExtensions.cs" /> <Compile Include="Src\IPackageExtensions.cs" />
<Compile Include="Src\IPackageAction.cs" />
<Compile Include="Src\IProjectBuilder.cs" /> <Compile Include="Src\IProjectBuilder.cs" />
<Compile Include="Src\IProjectContentExtensions.cs" /> <Compile Include="Src\IProjectContentExtensions.cs" />
<Compile Include="Src\IUpdatePackageSettings.cs" />
<Compile Include="Src\IVirtualMethodUpdater.cs" /> <Compile Include="Src\IVirtualMethodUpdater.cs" />
<Compile Include="Src\IProjectBrowserUpdater.cs" /> <Compile Include="Src\IProjectBrowserUpdater.cs" />
<Compile Include="Src\IRefactoringDocumentView.cs" /> <Compile Include="Src\IRefactoringDocumentView.cs" />
@ -230,8 +232,10 @@
<Compile Include="Src\PackageLicenseViewModel.cs" /> <Compile Include="Src\PackageLicenseViewModel.cs" />
<Compile Include="Src\PackageManagementServiceProvider.cs" /> <Compile Include="Src\PackageManagementServiceProvider.cs" />
<Compile Include="Src\ProjectBuilder.cs" /> <Compile Include="Src\ProjectBuilder.cs" />
<Compile Include="Src\ReducedPackageOperations.cs" />
<Compile Include="Src\ResolveFileConflictEventArgs.cs" /> <Compile Include="Src\ResolveFileConflictEventArgs.cs" />
<Compile Include="Src\ServiceWithWorkbenchOwner.cs" /> <Compile Include="Src\ServiceWithWorkbenchOwner.cs" />
<Compile Include="Src\UpdatePackagesAction.cs" />
<Compile Include="Src\VirtualMethodUpdater.cs" /> <Compile Include="Src\VirtualMethodUpdater.cs" />
<Compile Include="Src\NewProjectsCreated.cs" /> <Compile Include="Src\NewProjectsCreated.cs" />
<Compile Include="Src\OpenMSBuildProjects.cs" /> <Compile Include="Src\OpenMSBuildProjects.cs" />

5
src/AddIns/Misc/PackageManagement/Project/Src/AvailablePackagesViewModel.cs

@ -41,11 +41,6 @@ namespace ICSharpCode.PackageManagement
return repository.GetPackages().Where(package => package.IsLatestVersion); return repository.GetPackages().Where(package => package.IsLatestVersion);
} }
public IQueryable<IPackage> CallGetPackagesFromPackageSource()
{
return GetPackagesFromPackageSource();
}
/// <summary> /// <summary>
/// Order packages by most downloaded first. /// Order packages by most downloaded first.
/// </summary> /// </summary>

12
src/AddIns/Misc/PackageManagement/Project/Src/ConsolePackageActionRunner.cs

@ -30,14 +30,14 @@ namespace ICSharpCode.PackageManagement
this.workbench = workbench; this.workbench = workbench;
} }
public void Run(ProcessPackageAction action) public void Run(IPackageAction action)
{ {
var actions = new List<ProcessPackageAction>(); var actions = new List<IPackageAction>();
actions.Add(action); actions.Add(action);
Run(actions); Run(actions);
} }
public void Run(IEnumerable<ProcessPackageAction> actions) public void Run(IEnumerable<IPackageAction> actions)
{ {
CreateConsolePadIfConsoleHostIsNotRunning(); CreateConsolePadIfConsoleHostIsNotRunning();
AddNewActionsToRun(actions); AddNewActionsToRun(actions);
@ -51,14 +51,14 @@ namespace ICSharpCode.PackageManagement
} }
} }
void AddNewActionsToRun(IEnumerable<ProcessPackageAction> actions) void AddNewActionsToRun(IEnumerable<IPackageAction> actions)
{ {
foreach (ProcessPackageAction action in actions) { foreach (IPackageAction action in actions) {
AddNewActionToRun(action); AddNewActionToRun(action);
} }
} }
void AddNewActionToRun(ProcessPackageAction action) void AddNewActionToRun(IPackageAction action)
{ {
packageActionsToRun.AddAction(action); packageActionsToRun.AddAction(action);
} }

31
src/AddIns/Misc/PackageManagement/Project/Src/Design/FakePackageManagementProject.cs

@ -101,7 +101,7 @@ namespace ICSharpCode.PackageManagement.Design
var package = new FakePackage("MyPackage"); var package = new FakePackage("MyPackage");
var operation = new FakePackageOperation(package, PackageAction.Uninstall); var operation = new FakePackageOperation(package, PackageAction.Uninstall);
FakeInstallOperations.Add(operation); FakeInstallOperations.Add(operation);
return operation; return operation;
} }
public FakePackageRepository FakeSourceRepository = new FakePackageRepository(); public FakePackageRepository FakeSourceRepository = new FakePackageRepository();
@ -145,7 +145,7 @@ namespace ICSharpCode.PackageManagement.Design
{ {
return FakeUninstallPackageAction; return FakeUninstallPackageAction;
} }
public UpdatePackageAction CreateUpdatePackageAction() public UpdatePackageAction CreateUpdatePackageAction()
{ {
var action = new FakeUpdatePackageAction(this); var action = new FakeUpdatePackageAction(this);
@ -213,5 +213,32 @@ namespace ICSharpCode.PackageManagement.Design
{ {
FakeSourceRepository.AddFakePackage(packageId); FakeSourceRepository.AddFakePackage(packageId);
} }
public void UpdatePackages(UpdatePackagesAction action)
{
}
public List<UpdatePackagesAction> UpdatePackagesActionsCreated =
new List<UpdatePackagesAction>();
public UpdatePackagesAction CreateUpdatePackagesAction()
{
var action = new UpdatePackagesAction(this);
UpdatePackagesActionsCreated.Add(action);
return action;
}
public UpdatePackagesAction UpdatePackagesActionPassedToGetUpdatePackagesOperations;
public List<IPackage> PackagesOnUpdatePackagesActionPassedToGetUpdatePackagesOperations;
public List<PackageOperation> PackageOperationsToReturnFromGetUpdatePackagesOperations =
new List<PackageOperation>();
public IEnumerable<PackageOperation> GetUpdatePackagesOperations(UpdatePackagesAction action)
{
UpdatePackagesActionPassedToGetUpdatePackagesOperations = action;
PackagesOnUpdatePackagesActionPassedToGetUpdatePackagesOperations =
action.Packages.ToList();
return PackageOperationsToReturnFromGetUpdatePackagesOperations;
}
} }
} }

16
src/AddIns/Misc/PackageManagement/Project/Src/Design/FakePackageManager.cs

@ -22,6 +22,8 @@ namespace ICSharpCode.PackageManagement.Design
public IPackage PackagePassedToUninstallPackage; public IPackage PackagePassedToUninstallPackage;
public UpdatePackagesAction UpdatePackagesActionsPassedToUpdatePackages;
#pragma warning disable 67 #pragma warning disable 67
public event EventHandler<PackageOperationEventArgs> PackageInstalled; public event EventHandler<PackageOperationEventArgs> PackageInstalled;
public event EventHandler<PackageOperationEventArgs> PackageInstalling; public event EventHandler<PackageOperationEventArgs> PackageInstalling;
@ -158,5 +160,19 @@ namespace ICSharpCode.PackageManagement.Design
{ {
throw new NotImplementedException(); throw new NotImplementedException();
} }
public void UpdatePackages(UpdatePackagesAction updateAction)
{
UpdatePackagesActionsPassedToUpdatePackages = updateAction;
}
public List<PackageOperation> PackageOperationsToReturnFromGetUpdatePackageOperations = new List<PackageOperation>();
public UpdatePackagesAction UpdatePackagesActionsPassedToGetUpdatePackagesOperations;
public IEnumerable<PackageOperation> GetUpdatePackageOperations(UpdatePackagesAction updateAction)
{
UpdatePackagesActionsPassedToGetUpdatePackagesOperations = updateAction;
return PackageOperationsToReturnFromGetUpdatePackageOperations;
}
} }
} }

7
src/AddIns/Misc/PackageManagement/Project/Src/Design/FakeRegisteredPackageRepositories.cs

@ -72,7 +72,12 @@ namespace ICSharpCode.PackageManagement.Design
public FakePackage AddFakePackageWithVersionToActiveRepository(string version) public FakePackage AddFakePackageWithVersionToActiveRepository(string version)
{ {
var package = FakePackage.CreatePackageWithVersion("Test", version); return AddFakePackageWithVersionToActiveRepository("Test", version);
}
public FakePackage AddFakePackageWithVersionToActiveRepository(string id, string version)
{
var package = FakePackage.CreatePackageWithVersion(id, version);
FakeActiveRepository.FakePackages.Add(package); FakeActiveRepository.FakePackages.Add(package);
return package; return package;
} }

15
src/AddIns/Misc/PackageManagement/Project/Src/IPackageAction.cs

@ -0,0 +1,15 @@
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
using System;
using ICSharpCode.PackageManagement.Scripting;
namespace ICSharpCode.PackageManagement
{
public interface IPackageAction
{
void Execute();
bool HasPackageScriptsToRun();
IPackageScriptRunner PackageScriptRunner { get; set; }
}
}

4
src/AddIns/Misc/PackageManagement/Project/Src/IPackageActionRunner.cs

@ -8,7 +8,7 @@ namespace ICSharpCode.PackageManagement
{ {
public interface IPackageActionRunner public interface IPackageActionRunner
{ {
void Run(ProcessPackageAction action); void Run(IPackageAction action);
void Run(IEnumerable<ProcessPackageAction> actions); void Run(IEnumerable<IPackageAction> actions);
} }
} }

3
src/AddIns/Misc/PackageManagement/Project/Src/IPackageManagementProject.cs

@ -30,13 +30,16 @@ namespace ICSharpCode.PackageManagement
IEnumerable<IPackage> GetPackagesInReverseDependencyOrder(); IEnumerable<IPackage> GetPackagesInReverseDependencyOrder();
IEnumerable<PackageOperation> GetInstallPackageOperations(IPackage package, InstallPackageAction installAction); IEnumerable<PackageOperation> GetInstallPackageOperations(IPackage package, InstallPackageAction installAction);
IEnumerable<PackageOperation> GetUpdatePackagesOperations(UpdatePackagesAction action);
void InstallPackage(IPackage package, InstallPackageAction installAction); void InstallPackage(IPackage package, InstallPackageAction installAction);
void UpdatePackage(IPackage package, UpdatePackageAction updateAction); void UpdatePackage(IPackage package, UpdatePackageAction updateAction);
void UninstallPackage(IPackage package, UninstallPackageAction uninstallAction); void UninstallPackage(IPackage package, UninstallPackageAction uninstallAction);
void UpdatePackages(UpdatePackagesAction action);
InstallPackageAction CreateInstallPackageAction(); InstallPackageAction CreateInstallPackageAction();
UninstallPackageAction CreateUninstallPackageAction(); UninstallPackageAction CreateUninstallPackageAction();
UpdatePackageAction CreateUpdatePackageAction(); UpdatePackageAction CreateUpdatePackageAction();
UpdatePackagesAction CreateUpdatePackagesAction();
} }
} }

6
src/AddIns/Misc/PackageManagement/Project/Src/IPackageOperationResolverFactory.cs

@ -13,5 +13,11 @@ namespace ICSharpCode.PackageManagement
IPackageRepository sourceRepository, IPackageRepository sourceRepository,
ILogger logger, ILogger logger,
InstallPackageAction installAction); InstallPackageAction installAction);
IPackageOperationResolver CreateUpdatePackageOperationResolver(
IPackageRepository localRepository,
IPackageRepository sourceRepository,
ILogger logger,
IUpdatePackageSettings settings);
} }
} }

1
src/AddIns/Misc/PackageManagement/Project/Src/IPackageViewModelFactory.cs

@ -15,5 +15,6 @@ namespace ICSharpCode.PackageManagement
PackageManagementSelectedProjects SelectedProjects { get; } PackageManagementSelectedProjects SelectedProjects { get; }
IPackageManagementEvents PackageManagementEvents { get; } IPackageManagementEvents PackageManagementEvents { get; }
IPackageActionRunner PackageActionRunner { get; } IPackageActionRunner PackageActionRunner { get; }
ILogger Logger { get; }
} }
} }

2
src/AddIns/Misc/PackageManagement/Project/Src/ISharpDevelopPackageManager.cs

@ -14,7 +14,9 @@ namespace ICSharpCode.PackageManagement
void InstallPackage(IPackage package, InstallPackageAction installAction); void InstallPackage(IPackage package, InstallPackageAction installAction);
void UninstallPackage(IPackage package, UninstallPackageAction uninstallAction); void UninstallPackage(IPackage package, UninstallPackageAction uninstallAction);
void UpdatePackage(IPackage package, UpdatePackageAction updateAction); void UpdatePackage(IPackage package, UpdatePackageAction updateAction);
void UpdatePackages(UpdatePackagesAction updateAction);
IEnumerable<PackageOperation> GetInstallPackageOperations(IPackage package, InstallPackageAction installAction); IEnumerable<PackageOperation> GetInstallPackageOperations(IPackage package, InstallPackageAction installAction);
IEnumerable<PackageOperation> GetUpdatePackageOperations(UpdatePackagesAction updateAction);
} }
} }

4
src/AddIns/Misc/PackageManagement/Project/Src/IUpdatePackageActions.cs

@ -7,10 +7,8 @@ using ICSharpCode.PackageManagement.Scripting;
namespace ICSharpCode.PackageManagement namespace ICSharpCode.PackageManagement
{ {
public interface IUpdatePackageActions public interface IUpdatePackageActions : IUpdatePackageSettings
{ {
bool UpdateDependencies { get; set; }
bool AllowPrereleaseVersions { get; set; }
IPackageScriptRunner PackageScriptRunner { get; set; } IPackageScriptRunner PackageScriptRunner { get; set; }
IEnumerable<UpdatePackageAction> CreateActions(); IEnumerable<UpdatePackageAction> CreateActions();

13
src/AddIns/Misc/PackageManagement/Project/Src/IUpdatePackageSettings.cs

@ -0,0 +1,13 @@
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
using System;
namespace ICSharpCode.PackageManagement
{
public interface IUpdatePackageSettings
{
bool UpdateDependencies { get; set; }
bool AllowPrereleaseVersions { get; set; }
}
}

10
src/AddIns/Misc/PackageManagement/Project/Src/PackageActionRunner.cs

@ -31,7 +31,7 @@ namespace ICSharpCode.PackageManagement
this.powerShellDetection = powerShellDetection; this.powerShellDetection = powerShellDetection;
} }
public void Run(IEnumerable<ProcessPackageAction> actions) public void Run(IEnumerable<IPackageAction> actions)
{ {
if (ShouldRunActionsInConsole(actions)) { if (ShouldRunActionsInConsole(actions)) {
consolePackageActionRunner.Run(actions); consolePackageActionRunner.Run(actions);
@ -42,9 +42,9 @@ namespace ICSharpCode.PackageManagement
} }
} }
bool ShouldRunActionsInConsole(IEnumerable<ProcessPackageAction> actions) bool ShouldRunActionsInConsole(IEnumerable<IPackageAction> actions)
{ {
foreach (ProcessPackageAction action in actions) { foreach (IPackageAction action in actions) {
if (ShouldRunActionInConsole(action)) { if (ShouldRunActionInConsole(action)) {
return true; return true;
} }
@ -52,7 +52,7 @@ namespace ICSharpCode.PackageManagement
return false; return false;
} }
public void Run(ProcessPackageAction action) public void Run(IPackageAction action)
{ {
if (ShouldRunActionInConsole(action)) { if (ShouldRunActionInConsole(action)) {
consolePackageActionRunner.Run(action); consolePackageActionRunner.Run(action);
@ -61,7 +61,7 @@ namespace ICSharpCode.PackageManagement
} }
} }
bool ShouldRunActionInConsole(ProcessPackageAction action) bool ShouldRunActionInConsole(IPackageAction action)
{ {
if (action.HasPackageScriptsToRun()) { if (action.HasPackageScriptsToRun()) {
if (powerShellDetection.IsPowerShell2Installed()) { if (powerShellDetection.IsPowerShell2Installed()) {

6
src/AddIns/Misc/PackageManagement/Project/Src/PackageActionsToRun.cs

@ -8,14 +8,14 @@ namespace ICSharpCode.PackageManagement
{ {
public class PackageActionsToRun public class PackageActionsToRun
{ {
ConcurrentQueue<ProcessPackageAction> actions = new ConcurrentQueue<ProcessPackageAction>(); ConcurrentQueue<IPackageAction> actions = new ConcurrentQueue<IPackageAction>();
public bool GetNextAction(out ProcessPackageAction action) public bool GetNextAction(out IPackageAction action)
{ {
return actions.TryDequeue(out action); return actions.TryDequeue(out action);
} }
public void AddAction(ProcessPackageAction action) public void AddAction(IPackageAction action)
{ {
actions.Enqueue(action); actions.Enqueue(action);
} }

15
src/AddIns/Misc/PackageManagement/Project/Src/PackageManagementProject.cs

@ -131,5 +131,20 @@ namespace ICSharpCode.PackageManagement
.GetPackagesByDependencyOrder(projectManager.LocalRepository) .GetPackagesByDependencyOrder(projectManager.LocalRepository)
.Reverse(); .Reverse();
} }
public void UpdatePackages(UpdatePackagesAction updateAction)
{
packageManager.UpdatePackages(updateAction);
}
public UpdatePackagesAction CreateUpdatePackagesAction()
{
return new UpdatePackagesAction(this);
}
public IEnumerable<PackageOperation> GetUpdatePackagesOperations(UpdatePackagesAction action)
{
return packageManager.GetUpdatePackageOperations(action);
}
} }
} }

11
src/AddIns/Misc/PackageManagement/Project/Src/PackageOperationsResolverFactory.cs

@ -22,5 +22,16 @@ namespace ICSharpCode.PackageManagement
installAction.IgnoreDependencies, installAction.IgnoreDependencies,
installAction.AllowPrereleaseVersions); installAction.AllowPrereleaseVersions);
} }
public IPackageOperationResolver CreateUpdatePackageOperationResolver(IPackageRepository localRepository, IPackageRepository sourceRepository, ILogger logger, IUpdatePackageSettings settings)
{
return new InstallWalker(
localRepository,
sourceRepository,
null,
logger,
!settings.UpdateDependencies,
settings.AllowPrereleaseVersions);
}
} }
} }

2
src/AddIns/Misc/PackageManagement/Project/Src/PackageViewModel.cs

@ -402,7 +402,7 @@ namespace ICSharpCode.PackageManagement
void RunActionsIfAnyExist(IList<ProcessPackageAction> actions) void RunActionsIfAnyExist(IList<ProcessPackageAction> actions)
{ {
if (actions.Any()) { if (actions.Any()) {
actionRunner.Run(actions); actionRunner.Run(actions);
} }
} }

9
src/AddIns/Misc/PackageManagement/Project/Src/PackagesView.xaml

@ -1,4 +1,4 @@
<UserControl <UserControl
x:Class="ICSharpCode.PackageManagement.PackagesView" x:Class="ICSharpCode.PackageManagement.PackagesView"
xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
xmlns:core="http://icsharpcode.net/sharpdevelop/core" xmlns:core="http://icsharpcode.net/sharpdevelop/core"
@ -306,6 +306,7 @@
<Grid <Grid
Grid.Column="2"> Grid.Column="2">
<Grid.RowDefinitions> <Grid.RowDefinitions>
<RowDefinition Height="Auto"/>
<RowDefinition Height="Auto"/> <RowDefinition Height="Auto"/>
<RowDefinition /> <RowDefinition />
</Grid.RowDefinitions> </Grid.RowDefinitions>
@ -352,6 +353,12 @@
Width="16"/> Width="16"/>
</Hyperlink> </Hyperlink>
</TextBlock> </TextBlock>
<Button
Grid.Row="2"
Grid.Column="1"
Visibility="{Binding Path=IsUpdateAllPackagesEnabled, Converter={StaticResource BoolToVisibility}}"
Content="Update All"
Command="{Binding UpdateAllPackagesCommand}"/>
</Grid> </Grid>
<ContentControl <ContentControl
Grid.Row="1" Grid.Row="1"

44
src/AddIns/Misc/PackageManagement/Project/Src/PackagesViewModel.cs

@ -44,12 +44,14 @@ namespace ICSharpCode.PackageManagement
ShowPreviousPageCommand = new DelegateCommand(param => ShowPreviousPage()); ShowPreviousPageCommand = new DelegateCommand(param => ShowPreviousPage());
ShowPageCommand = new DelegateCommand(param => ExecuteShowPageCommand(param)); ShowPageCommand = new DelegateCommand(param => ExecuteShowPageCommand(param));
SearchCommand = new DelegateCommand(param => Search()); SearchCommand = new DelegateCommand(param => Search());
UpdateAllPackagesCommand = new DelegateCommand(param => UpdateAllPackages());
} }
public ICommand ShowNextPageCommand { get; private set; } public ICommand ShowNextPageCommand { get; private set; }
public ICommand ShowPreviousPageCommand { get; private set; } public ICommand ShowPreviousPageCommand { get; private set; }
public ICommand ShowPageCommand { get; private set; } public ICommand ShowPageCommand { get; private set; }
public ICommand SearchCommand { get; private set; } public ICommand SearchCommand { get; private set; }
public ICommand UpdateAllPackagesCommand { get; private set; }
public void Dispose() public void Dispose()
{ {
@ -281,7 +283,7 @@ namespace ICSharpCode.PackageManagement
public int PageSize { public int PageSize {
get { return pages.PageSize; } get { return pages.PageSize; }
set { pages.PageSize = value; } set { pages.PageSize = value; }
} }
public bool IsPaged { public bool IsPaged {
@ -361,5 +363,45 @@ namespace ICSharpCode.PackageManagement
} }
} }
} }
public bool ShowUpdateAllPackages { get; set; }
public bool IsUpdateAllPackagesEnabled {
get {
return ShowUpdateAllPackages && (TotalItems > 1);
}
}
void UpdateAllPackages()
{
try {
TryUpdatingAllPackages();
} catch (Exception ex) {
ReportError(ex);
LogError(ex);
}
}
void LogError(Exception ex)
{
packageViewModelFactory
.Logger
.Log(MessageLevel.Error, ex.ToString());
}
void ReportError(Exception ex)
{
packageViewModelFactory
.PackageManagementEvents
.OnPackageOperationError(ex);
}
protected virtual void TryUpdatingAllPackages()
{
}
protected IPackageActionRunner ActionRunner {
get { return packageViewModelFactory.PackageActionRunner; }
}
} }
} }

4
src/AddIns/Misc/PackageManagement/Project/Src/ProcessPackageAction.cs

@ -8,7 +8,7 @@ using NuGet;
namespace ICSharpCode.PackageManagement namespace ICSharpCode.PackageManagement
{ {
public abstract class ProcessPackageAction public abstract class ProcessPackageAction : IPackageAction
{ {
IPackageManagementEvents packageManagementEvents; IPackageManagementEvents packageManagementEvents;
@ -107,7 +107,7 @@ namespace ICSharpCode.PackageManagement
void FindPackage() void FindPackage()
{ {
Package =Project Package = Project
.SourceRepository .SourceRepository
.FindPackage(PackageId, PackageVersion, AllowPrereleaseVersions, allowUnlisted: true); .FindPackage(PackageId, PackageVersion, AllowPrereleaseVersions, allowUnlisted: true);
} }

2
src/AddIns/Misc/PackageManagement/Project/Src/ProcessPackageOperationsAction.cs

@ -30,7 +30,7 @@ namespace ICSharpCode.PackageManagement
base.BeforeExecute(); base.BeforeExecute();
GetPackageOperationsIfMissing(); GetPackageOperationsIfMissing();
} }
void GetPackageOperationsIfMissing() void GetPackageOperationsIfMissing()
{ {
if (Operations == null) { if (Operations == null) {

52
src/AddIns/Misc/PackageManagement/Project/Src/ReducedPackageOperations.cs

@ -0,0 +1,52 @@
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
using System;
using System.Collections.Generic;
using System.Linq;
using NuGet;
namespace ICSharpCode.PackageManagement
{
public class ReducedPackageOperations
{
IPackageOperationResolver resolver;
IList<PackageOperation> operations;
IEnumerable<IPackage> packages;
public ReducedPackageOperations(IPackageOperationResolver resolver, IEnumerable<IPackage> packages)
{
this.resolver = resolver;
this.packages = packages;
this.operations = new List<PackageOperation>();
}
public IEnumerable<PackageOperation> Operations {
get { return operations; }
}
public void Reduce()
{
foreach (IPackage package in packages) {
if (!InstallOperationExists(package)) {
operations.AddRange(resolver.ResolveOperations(package));
}
}
operations = operations.Reduce();
}
bool InstallOperationExists(IPackage package)
{
var installOperation = new PackageOperation(package, PackageAction.Install);
return operations.Any(operation => IsMatch(installOperation, operation));
}
bool IsMatch(PackageOperation x, PackageOperation y)
{
return (x.Package.Id == y.Package.Id) &&
(x.Package.Version == y.Package.Version) &&
(x.Action == y.Action);
}
}
}

37
src/AddIns/Misc/PackageManagement/Project/Src/SharpDevelopPackageManager.cs

@ -125,9 +125,42 @@ namespace ICSharpCode.PackageManagement
UpdatePackageReference(package, updateAction); UpdatePackageReference(package, updateAction);
} }
void UpdatePackageReference(IPackage package, UpdatePackageAction updateAction) void UpdatePackageReference(IPackage package, IUpdatePackageSettings settings)
{ {
ProjectManager.UpdatePackageReference(package.Id, package.Version, updateAction.UpdateDependencies, updateAction.AllowPrereleaseVersions); UpdatePackageReference(package, settings.UpdateDependencies, settings.AllowPrereleaseVersions);
}
void UpdatePackageReference(IPackage package, bool updateDependencies, bool allowPrereleaseVersions)
{
ProjectManager.UpdatePackageReference(package.Id, package.Version, updateDependencies, allowPrereleaseVersions);
}
public void UpdatePackages(UpdatePackagesAction updateAction)
{
foreach (PackageOperation operation in updateAction.Operations) {
Execute(operation);
}
foreach (IPackage package in updateAction.Packages) {
UpdatePackageReference(package, updateAction);
}
}
public IEnumerable<PackageOperation> GetUpdatePackageOperations(UpdatePackagesAction updateAction)
{
IPackageOperationResolver resolver = CreateUpdatePackageOperationResolver(updateAction);
var reducedOperations = new ReducedPackageOperations(resolver, updateAction.Packages);
reducedOperations.Reduce();
return reducedOperations.Operations;
}
IPackageOperationResolver CreateUpdatePackageOperationResolver(UpdatePackagesAction updateAction)
{
return packageOperationResolverFactory.CreateUpdatePackageOperationResolver(
LocalRepository,
SourceRepository,
Logger,
updateAction);
} }
} }
} }

2
src/AddIns/Misc/PackageManagement/Project/Src/UpdatePackageAction.cs

@ -7,7 +7,7 @@ using NuGet;
namespace ICSharpCode.PackageManagement namespace ICSharpCode.PackageManagement
{ {
public class UpdatePackageAction : ProcessPackageOperationsAction public class UpdatePackageAction : ProcessPackageOperationsAction, IUpdatePackageSettings
{ {
public UpdatePackageAction( public UpdatePackageAction(
IPackageManagementProject project, IPackageManagementProject project,

2
src/AddIns/Misc/PackageManagement/Project/Src/UpdatePackageActions.cs

@ -9,7 +9,7 @@ namespace ICSharpCode.PackageManagement
{ {
public abstract class UpdatePackageActions : IUpdatePackageActions public abstract class UpdatePackageActions : IUpdatePackageActions
{ {
public bool UpdateDependencies { get; set; } public bool UpdateDependencies { get; set; }
public bool AllowPrereleaseVersions { get; set; } public bool AllowPrereleaseVersions { get; set; }
public IPackageScriptRunner PackageScriptRunner { get; set; } public IPackageScriptRunner PackageScriptRunner { get; set; }

85
src/AddIns/Misc/PackageManagement/Project/Src/UpdatePackagesAction.cs

@ -0,0 +1,85 @@
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
using System;
using System.Collections.Generic;
using ICSharpCode.PackageManagement.Scripting;
using NuGet;
namespace ICSharpCode.PackageManagement
{
public class UpdatePackagesAction : IPackageAction, IUpdatePackageSettings
{
List<IPackage> packages = new List<IPackage>();
List<PackageOperation> operations = new List<PackageOperation>();
public UpdatePackagesAction(IPackageManagementProject project)
{
Project = project;
UpdateDependencies = true;
}
public IPackageScriptRunner PackageScriptRunner { get; set; }
public IPackageManagementProject Project { get; private set; }
public IEnumerable<IPackage> Packages {
get { return packages; }
}
public IEnumerable<PackageOperation> Operations {
get { return operations; }
}
public bool UpdateDependencies { get; set; }
public bool AllowPrereleaseVersions { get; set; }
public bool HasPackageScriptsToRun()
{
var files = new PackageFilesForOperations(Operations);
return files.HasAnyPackageScripts();
}
public void AddOperations(IEnumerable<PackageOperation> operations)
{
this.operations.AddRange(operations);
}
public void AddPackages(IEnumerable<IPackage> packages)
{
this.packages.AddRange(packages);
}
public void Execute()
{
if (PackageScriptRunner != null) {
ExecuteWithScriptRunner();
} else {
ExecuteCore();
}
}
protected virtual void ExecuteCore()
{
Project.UpdatePackages(this);
}
void ExecuteWithScriptRunner()
{
using (RunPackageScriptsAction runScriptsAction = CreateRunPackageScriptsAction()) {
ExecuteCore();
}
}
RunPackageScriptsAction CreateRunPackageScriptsAction()
{
return CreateRunPackageScriptsAction(PackageScriptRunner, Project);
}
protected virtual RunPackageScriptsAction CreateRunPackageScriptsAction(
IPackageScriptRunner scriptRunner,
IPackageManagementProject project)
{
return new RunPackageScriptsAction(scriptRunner, project);
}
}
}

24
src/AddIns/Misc/PackageManagement/Project/Src/UpdatedPackagesViewModel.cs

@ -14,6 +14,7 @@ namespace ICSharpCode.PackageManagement
PackageManagementSelectedProjects selectedProjects; PackageManagementSelectedProjects selectedProjects;
UpdatedPackages updatedPackages; UpdatedPackages updatedPackages;
string errorMessage = String.Empty; string errorMessage = String.Empty;
ILogger logger;
public UpdatedPackagesViewModel( public UpdatedPackagesViewModel(
IPackageManagementSolution solution, IPackageManagementSolution solution,
@ -26,7 +27,9 @@ namespace ICSharpCode.PackageManagement
taskFactory) taskFactory)
{ {
this.selectedProjects = new PackageManagementSelectedProjects(solution); this.selectedProjects = new PackageManagementSelectedProjects(solution);
this.logger = packageViewModelFactory.Logger;
ShowPackageSources = true; ShowPackageSources = true;
ShowUpdateAllPackages = true;
} }
protected override void UpdateRepositoryBeforeReadPackagesTaskStarts() protected override void UpdateRepositoryBeforeReadPackagesTaskStarts()
@ -62,5 +65,26 @@ namespace ICSharpCode.PackageManagement
{ {
return updatedPackages.GetUpdatedPackages().AsQueryable(); return updatedPackages.GetUpdatedPackages().AsQueryable();
} }
protected override void TryUpdatingAllPackages()
{
IEnumerable<IPackageFromRepository> packages = GetPackagesFromViewModels();
IPackageRepository repository = packages.First().Repository;
IPackageManagementProject project = selectedProjects.GetSingleProjectSelected(repository);
project.Logger = logger;
UpdatePackagesAction action = project.CreateUpdatePackagesAction();
action.AddPackages(packages);
IEnumerable<PackageOperation> operations = project.GetUpdatePackagesOperations(action);
action.AddOperations(operations);
ActionRunner.Run(action);
}
IEnumerable<IPackageFromRepository> GetPackagesFromViewModels()
{
return PackageViewModels.Select(viewModel => viewModel.GetPackage() as IPackageFromRepository);
}
} }
} }

5
src/AddIns/Misc/PackageManagement/Test/PackageManagement.Tests.csproj

@ -112,6 +112,7 @@
<Compile Include="Src\Helpers\ClassHelper.cs" /> <Compile Include="Src\Helpers\ClassHelper.cs" />
<Compile Include="Src\Helpers\CodeElementsExtensions.cs" /> <Compile Include="Src\Helpers\CodeElementsExtensions.cs" />
<Compile Include="Src\Helpers\CompilationUnitHelper.cs" /> <Compile Include="Src\Helpers\CompilationUnitHelper.cs" />
<Compile Include="Src\Helpers\ExceptionThrowingPackageActionRunner.cs" />
<Compile Include="Src\Helpers\FakeCodeGenerator.cs" /> <Compile Include="Src\Helpers\FakeCodeGenerator.cs" />
<Compile Include="Src\Helpers\FieldHelper.cs" /> <Compile Include="Src\Helpers\FieldHelper.cs" />
<Compile Include="Src\Helpers\FakeSelectProjectsService.cs" /> <Compile Include="Src\Helpers\FakeSelectProjectsService.cs" />
@ -120,6 +121,7 @@
<Compile Include="Src\Helpers\FakeUpdatePackageActionsFactory.cs" /> <Compile Include="Src\Helpers\FakeUpdatePackageActionsFactory.cs" />
<Compile Include="Src\Helpers\MethodHelper.cs" /> <Compile Include="Src\Helpers\MethodHelper.cs" />
<Compile Include="Src\Helpers\MethodOrPropertyHelper.cs" /> <Compile Include="Src\Helpers\MethodOrPropertyHelper.cs" />
<Compile Include="Src\Helpers\PackageOperationHelper.cs" />
<Compile Include="Src\Helpers\ParameterHelper.cs" /> <Compile Include="Src\Helpers\ParameterHelper.cs" />
<Compile Include="Src\Helpers\ProjectContentHelper.cs" /> <Compile Include="Src\Helpers\ProjectContentHelper.cs" />
<Compile Include="Src\Helpers\PropertiesHelper.cs" /> <Compile Include="Src\Helpers\PropertiesHelper.cs" />
@ -131,6 +133,7 @@
<Compile Include="Src\Helpers\TestablePackageFromRepository.cs" /> <Compile Include="Src\Helpers\TestablePackageFromRepository.cs" />
<Compile Include="Src\Helpers\TestableProjectBehaviour.cs" /> <Compile Include="Src\Helpers\TestableProjectBehaviour.cs" />
<Compile Include="Src\Helpers\TestableSelectedProjectsForUpdatedPackages.cs" /> <Compile Include="Src\Helpers\TestableSelectedProjectsForUpdatedPackages.cs" />
<Compile Include="Src\Helpers\TestableUpdatePackagesAction.cs" />
<Compile Include="Src\Helpers\TypeParameterHelper.cs" /> <Compile Include="Src\Helpers\TypeParameterHelper.cs" />
<Compile Include="Src\Helpers\UsingHelper.cs" /> <Compile Include="Src\Helpers\UsingHelper.cs" />
<Compile Include="Src\Helpers\UsingScopeHelper.cs" /> <Compile Include="Src\Helpers\UsingScopeHelper.cs" />
@ -195,6 +198,8 @@
<Compile Include="Src\OpenMSBuildProjectsTests.cs" /> <Compile Include="Src\OpenMSBuildProjectsTests.cs" />
<Compile Include="Src\PackageManagementServiceProviderTests.cs" /> <Compile Include="Src\PackageManagementServiceProviderTests.cs" />
<Compile Include="Src\PackageViewModelOperationLoggerTests.cs" /> <Compile Include="Src\PackageViewModelOperationLoggerTests.cs" />
<Compile Include="Src\ReducedPackageOperationsTests.cs" />
<Compile Include="Src\UpdatePackagesActionTests.cs" />
<Compile Include="Src\VirtualMethodUpdaterTests.cs" /> <Compile Include="Src\VirtualMethodUpdaterTests.cs" />
<Compile Include="Src\NewProjectsCreatedTests.cs" /> <Compile Include="Src\NewProjectsCreatedTests.cs" />
<Compile Include="Src\PackageActionRunnerTests.cs" /> <Compile Include="Src\PackageActionRunnerTests.cs" />

18
src/AddIns/Misc/PackageManagement/Test/Src/AvailablePackagesViewModelTests.cs

@ -455,5 +455,23 @@ namespace PackageManagement.Tests
Assert.IsFalse(containsDisabledPackageSource); Assert.IsFalse(containsDisabledPackageSource);
Assert.IsTrue(containsEnabledPackageSource); Assert.IsTrue(containsEnabledPackageSource);
} }
[Test]
public void IsInstallAllPackagesEnabled_RepositoryHasTwoPackages_ReturnsFalse()
{
CreateViewModel();
var package1 = new FakePackage("Test", "0.1.0.0");
var package2 = new FakePackage("Test", "0.2.0.0");
var packages = new FakePackage[] {
package1, package2
};
registeredPackageRepositories.FakeActiveRepository.FakePackages.AddRange(packages);
viewModel.ReadPackages();
CompleteReadPackagesTask();
bool enabled = viewModel.IsUpdateAllPackagesEnabled;
Assert.IsFalse(enabled);
}
} }
} }

14
src/AddIns/Misc/PackageManagement/Test/Src/ConsolePackageActionRunnerTests.cs

@ -78,17 +78,17 @@ namespace PackageManagement.Tests
fakeConsoleHost.IsRunning = false; fakeConsoleHost.IsRunning = false;
} }
ProcessPackageAction GetNextActionToRun() IPackageAction GetNextActionToRun()
{ {
ProcessPackageAction action = null; IPackageAction action = null;
actionsToRun.GetNextAction(out action); actionsToRun.GetNextAction(out action);
return action; return action;
} }
List<ProcessPackageAction> GetNextActionsToRun() List<IPackageAction> GetNextActionsToRun()
{ {
var actions = new List<ProcessPackageAction>(); var actions = new List<IPackageAction>();
ProcessPackageAction action = null; IPackageAction action = null;
while (actionsToRun.GetNextAction(out action)) { while (actionsToRun.GetNextAction(out action)) {
actions.Add(action); actions.Add(action);
} }
@ -102,7 +102,7 @@ namespace PackageManagement.Tests
ConsoleHostIsRunning(); ConsoleHostIsRunning();
FakeInstallPackageAction expectedAction = RunInstallActionWithOneOperation(); FakeInstallPackageAction expectedAction = RunInstallActionWithOneOperation();
ProcessPackageAction actionAdded = GetNextActionToRun(); IPackageAction actionAdded = GetNextActionToRun();
Assert.AreEqual(expectedAction, actionAdded); Assert.AreEqual(expectedAction, actionAdded);
} }
@ -188,7 +188,7 @@ namespace PackageManagement.Tests
ConsoleHostIsRunning(); ConsoleHostIsRunning();
List<FakeInstallPackageAction> expectedActions = RunTwoInstallActionsWithOneOperation(); List<FakeInstallPackageAction> expectedActions = RunTwoInstallActionsWithOneOperation();
List<ProcessPackageAction> actionsAdded = GetNextActionsToRun(); List<IPackageAction> actionsAdded = GetNextActionsToRun();
CollectionAssert.AreEqual(expectedActions, actionsAdded); CollectionAssert.AreEqual(expectedActions, actionsAdded);
} }

19
src/AddIns/Misc/PackageManagement/Test/Src/Helpers/ExceptionThrowingPackageActionRunner.cs

@ -0,0 +1,19 @@
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
using System;
using ICSharpCode.PackageManagement;
namespace PackageManagement.Tests.Helpers
{
public class ExceptionThrowingPackageActionRunner : FakePackageActionRunner
{
public Exception ExceptionToThrow = new Exception("test");
public override void Run(IPackageAction action)
{
base.Run(action);
throw ExceptionToThrow;
}
}
}

16
src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakePackageActionRunner.cs

@ -9,30 +9,30 @@ namespace PackageManagement.Tests.Helpers
{ {
public class FakePackageActionRunner : IPackageActionRunner public class FakePackageActionRunner : IPackageActionRunner
{ {
public ProcessPackageAction ActionPassedToRun; public IPackageAction ActionPassedToRun;
public bool IsRunCalled; public bool IsRunCalled;
public void Run(ProcessPackageAction action) public virtual void Run(IPackageAction action)
{ {
IsRunCalled = true; IsRunCalled = true;
ActionPassedToRun = action; ActionPassedToRun = action;
ActionsPassedToRun.Add(action); ActionsPassedToRun.Add(action);
} }
public List<ProcessPackageAction> ActionsPassedToRun = public List<IPackageAction> ActionsPassedToRun =
new List<ProcessPackageAction>(); new List<IPackageAction>();
public void Run(IEnumerable<ProcessPackageAction> actions) public void Run(IEnumerable<IPackageAction> actions)
{ {
IsRunCalled = true; IsRunCalled = true;
ActionsRunInOneCall = actions; ActionsRunInOneCall = actions;
} }
public IEnumerable<ProcessPackageAction> ActionsRunInOneCall; public IEnumerable<IPackageAction> ActionsRunInOneCall;
public List<ProcessPackageAction> GetActionsRunInOneCallAsList() public List<IPackageAction> GetActionsRunInOneCallAsList()
{ {
return new List<ProcessPackageAction>(ActionsRunInOneCall); return new List<IPackageAction>(ActionsRunInOneCall);
} }
} }
} }

20
src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakePackageOperationResolverFactory.cs

@ -30,5 +30,25 @@ namespace PackageManagement.Tests.Helpers
return FakeInstallPackageOperationResolver; return FakeInstallPackageOperationResolver;
} }
public IPackageRepository LocalRepositoryPassedToCreateUpdatePackageOperationsResolver;
public IPackageRepository SourceRepositoryPassedToCreateUpdatePackageOperationsResolver;
public IPackageOperationResolver UpdatePackageOperationsResolver = new FakePackageOperationResolver();
public ILogger LoggerPassedToCreateUpdatePackageOperationResolver;
public IUpdatePackageSettings SettingsPassedToCreatePackageOperationResolver;
public IPackageOperationResolver CreateUpdatePackageOperationResolver(
IPackageRepository localRepository,
IPackageRepository sourceRepository,
ILogger logger,
IUpdatePackageSettings settings)
{
LocalRepositoryPassedToCreateUpdatePackageOperationsResolver = localRepository;
SourceRepositoryPassedToCreateUpdatePackageOperationsResolver = sourceRepository;
LoggerPassedToCreateUpdatePackageOperationResolver = logger;
SettingsPassedToCreatePackageOperationResolver = settings;
return UpdatePackageOperationsResolver;
}
} }
} }

10
src/AddIns/Misc/PackageManagement/Test/Src/Helpers/FakePackageViewModelFactory.cs

@ -16,13 +16,9 @@ namespace PackageManagement.Tests.Helpers
public FakeLogger FakeLogger = new FakeLogger(); public FakeLogger FakeLogger = new FakeLogger();
public FakePackageActionRunner FakeActionRunner = new FakePackageActionRunner(); public FakePackageActionRunner FakeActionRunner = new FakePackageActionRunner();
public FakePackageViewModelFactory()
{
SelectedProjects = new PackageManagementSelectedProjects(FakeSolution);
}
public PackageViewModel CreatePackageViewModel(IPackageFromRepository package) public PackageViewModel CreatePackageViewModel(IPackageFromRepository package)
{ {
SelectedProjects = new PackageManagementSelectedProjects(FakeSolution);
return new PackageViewModel( return new PackageViewModel(
package, package,
SelectedProjects, SelectedProjects,
@ -44,5 +40,9 @@ namespace PackageManagement.Tests.Helpers
public IPackageActionRunner PackageActionRunner { public IPackageActionRunner PackageActionRunner {
get { return FakeActionRunner; } get { return FakeActionRunner; }
} }
public ILogger Logger {
get { return FakeLogger; }
}
} }
} }

2
src/AddIns/Misc/PackageManagement/Test/Src/Helpers/PackageCollectionAssert.cs

@ -33,7 +33,7 @@ namespace PackageManagement.Tests.Helpers
var expectedPackagesAsList = new List<IPackage>(expectedPackages); var expectedPackagesAsList = new List<IPackage>(expectedPackages);
var actualPackagesAsList = new List<IPackage>(actualPackages); var actualPackagesAsList = new List<IPackage>(actualPackages);
CollectionAssert.AreEqual(expectedPackagesAsList, actualPackagesAsList); CollectionAssert.AreEqual(expectedPackagesAsList, actualPackagesAsList);
} }
} }
} }

29
src/AddIns/Misc/PackageManagement/Test/Src/Helpers/PackageOperationHelper.cs

@ -0,0 +1,29 @@
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
using System;
using System.Collections.Generic;
using ICSharpCode.PackageManagement.Design;
using NuGet;
namespace PackageManagement.Tests.Helpers
{
public static class PackageOperationHelper
{
public static PackageOperation CreateInstallOperationWithFile(string fileName)
{
var package = new FakePackage();
package.AddFile(fileName);
return new PackageOperation(package, PackageAction.Install);
}
public static List<PackageOperation> CreateListWithOneInstallOperationWithFile(string fileName)
{
PackageOperation operation = CreateInstallOperationWithFile(fileName);
var operations = new List<PackageOperation>();
operations.Add(operation);
return operations;
}
}
}

7
src/AddIns/Misc/PackageManagement/Test/Src/Helpers/TestableProcessPackageAction.cs

@ -53,5 +53,12 @@ namespace PackageManagement.Tests.Helpers
public bool IsRunPackageScriptsActionDisposed { public bool IsRunPackageScriptsActionDisposed {
get { return RunPackageScriptsAction.IsDisposed; } get { return RunPackageScriptsAction.IsDisposed; }
} }
public bool IsExecuteCoreCalled { get; set; }
protected override void ExecuteCore()
{
IsExecuteCoreCalled = true;
}
} }
} }

4
src/AddIns/Misc/PackageManagement/Test/Src/Helpers/TestableProjectManager.cs

@ -2,6 +2,7 @@
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt) // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
using System; using System;
using System.Collections.Generic;
using ICSharpCode.PackageManagement; using ICSharpCode.PackageManagement;
using ICSharpCode.PackageManagement.Design; using ICSharpCode.PackageManagement.Design;
using NuGet; using NuGet;
@ -21,6 +22,7 @@ namespace PackageManagement.Tests.Helpers
public IPackage PackagePassedToUpdatePackageReference; public IPackage PackagePassedToUpdatePackageReference;
public bool UpdateDependenciesPassedToUpdatePackageReference; public bool UpdateDependenciesPassedToUpdatePackageReference;
public bool AllowPrereleaseVersionsPassedToUpdatePackageReference; public bool AllowPrereleaseVersionsPassedToUpdatePackageReference;
public List<IPackage> PackagesPassedToUpdatePackageReference = new List<IPackage>();
public FakePackageRepository FakeLocalRepository { public FakePackageRepository FakeLocalRepository {
get { return LocalRepository as FakePackageRepository; } get { return LocalRepository as FakePackageRepository; }
@ -67,6 +69,8 @@ namespace PackageManagement.Tests.Helpers
PackagePassedToUpdatePackageReference = package; PackagePassedToUpdatePackageReference = package;
UpdateDependenciesPassedToUpdatePackageReference = updateDependencies; UpdateDependenciesPassedToUpdatePackageReference = updateDependencies;
AllowPrereleaseVersionsPassedToUpdatePackageReference = allowPrereleaseVersions; AllowPrereleaseVersionsPassedToUpdatePackageReference = allowPrereleaseVersions;
PackagesPassedToUpdatePackageReference.Add(package);
} }
public FakePackage AddFakePackageToProjectLocalRepository(string packageId, string version) public FakePackage AddFakePackageToProjectLocalRepository(string packageId, string version)

37
src/AddIns/Misc/PackageManagement/Test/Src/Helpers/TestableUpdatePackagesAction.cs

@ -0,0 +1,37 @@
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
using System;
using ICSharpCode.PackageManagement;
using ICSharpCode.PackageManagement.Scripting;
namespace PackageManagement.Tests.Helpers
{
public class TestableUpdatePackagesAction : UpdatePackagesAction
{
public bool IsRunPackageScriptsActionCreated;
public IPackageScriptRunner ScriptRunnerPassedToCreateRunPackageScriptsAction;
public IPackageManagementProject ProjectPassedToCreateRunPackageScriptsAction;
public RunPackageScriptsAction RunPackageScriptsAction;
public TestableUpdatePackagesAction(IPackageManagementProject project)
: base(project)
{
}
protected override RunPackageScriptsAction CreateRunPackageScriptsAction(
IPackageScriptRunner scriptRunner,
IPackageManagementProject project)
{
IsRunPackageScriptsActionCreated = true;
ScriptRunnerPassedToCreateRunPackageScriptsAction = scriptRunner;
ProjectPassedToCreateRunPackageScriptsAction = project;
RunPackageScriptsAction = base.CreateRunPackageScriptsAction(scriptRunner, project);
return RunPackageScriptsAction;
}
public bool IsRunPackageScriptsActionDisposed {
get { return RunPackageScriptsAction.IsDisposed; }
}
}
}

10
src/AddIns/Misc/PackageManagement/Test/Src/InstallPackageActionTests.cs

@ -34,14 +34,8 @@ namespace PackageManagement.Tests
void AddInstallOperationWithFile(string fileName) void AddInstallOperationWithFile(string fileName)
{ {
var package = new FakePackage(); action.Operations =
package.AddFile(fileName); PackageOperationHelper.CreateListWithOneInstallOperationWithFile(fileName);
var operation = new PackageOperation(package, PackageAction.Install);
var operations = new List<PackageOperation>();
operations.Add(operation);
action.Operations = operations;
} }
[Test] [Test]

2
src/AddIns/Misc/PackageManagement/Test/Src/InstalledPackageViewModelTests.cs

@ -235,7 +235,7 @@ namespace PackageManagement.Tests
viewModel.FakePackageManagementEvents.ProjectsToSelect.Add("UnknownProject"); viewModel.FakePackageManagementEvents.ProjectsToSelect.Add("UnknownProject");
viewModel.ManagePackage(); viewModel.ManagePackage();
List<ProcessPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList(); List<IPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList();
var firstAction = actions[0] as UninstallPackageAction; var firstAction = actions[0] as UninstallPackageAction;
var secondAction = actions[1] as UninstallPackageAction; var secondAction = actions[1] as UninstallPackageAction;

14
src/AddIns/Misc/PackageManagement/Test/Src/PackageActionRunnerTests.cs

@ -42,14 +42,8 @@ namespace PackageManagement.Tests
{ {
CreateInstallActionWithNoPowerShellScripts(); CreateInstallActionWithNoPowerShellScripts();
var package = new FakePackage(); fakeAction.Operations =
package.AddFile(@"tools\init.ps1"); PackageOperationHelper.CreateListWithOneInstallOperationWithFile(@"tools\init.ps1");
var operation = new PackageOperation(package, PackageAction.Install);
var operations = new List<PackageOperation>();
operations.Add(operation);
fakeAction.Operations = operations;
fakeActions.Add(fakeAction); fakeActions.Add(fakeAction);
} }
@ -83,7 +77,7 @@ namespace PackageManagement.Tests
powerShellDetection.IsPowerShell2InstalledReturnValue = true; powerShellDetection.IsPowerShell2InstalledReturnValue = true;
Run(); Run();
ProcessPackageAction action = fakeConsoleActionRunner.ActionPassedToRun; IPackageAction action = fakeConsoleActionRunner.ActionPassedToRun;
Assert.AreEqual(fakeAction, action); Assert.AreEqual(fakeAction, action);
} }
@ -155,7 +149,7 @@ namespace PackageManagement.Tests
powerShellDetection.IsPowerShell2InstalledReturnValue = true; powerShellDetection.IsPowerShell2InstalledReturnValue = true;
RunMultipleActions(); RunMultipleActions();
IEnumerable<ProcessPackageAction> actions = fakeConsoleActionRunner.ActionsRunInOneCall; IEnumerable<IPackageAction> actions = fakeConsoleActionRunner.ActionsRunInOneCall;
CollectionAssert.AreEqual(fakeActions, actions); CollectionAssert.AreEqual(fakeActions, actions);
} }

22
src/AddIns/Misc/PackageManagement/Test/Src/PackageActionsToRunTests.cs

@ -33,7 +33,7 @@ namespace PackageManagement.Tests
public void GetNextAction_NewInstance_ReturnsFalse() public void GetNextAction_NewInstance_ReturnsFalse()
{ {
CreateActions(); CreateActions();
ProcessPackageAction action = null; IPackageAction action = null;
bool result = actions.GetNextAction(out action); bool result = actions.GetNextAction(out action);
Assert.IsFalse(result); Assert.IsFalse(result);
@ -45,7 +45,7 @@ namespace PackageManagement.Tests
CreateActions(); CreateActions();
ProcessPackageAction expectedAction = AddAction(); ProcessPackageAction expectedAction = AddAction();
ProcessPackageAction action = null; IPackageAction action = null;
actions.GetNextAction(out action); actions.GetNextAction(out action);
Assert.AreEqual(expectedAction, action); Assert.AreEqual(expectedAction, action);
@ -57,7 +57,7 @@ namespace PackageManagement.Tests
CreateActions(); CreateActions();
ProcessPackageAction expectedAction = AddAction(); ProcessPackageAction expectedAction = AddAction();
ProcessPackageAction action = null; IPackageAction action = null;
bool result = actions.GetNextAction(out action); bool result = actions.GetNextAction(out action);
Assert.IsTrue(result); Assert.IsTrue(result);
@ -67,8 +67,8 @@ namespace PackageManagement.Tests
public void GetNextAction_CalledTwiceWithOneActionAdded_ReturnsNullActionInOutParameterOnSecondCall() public void GetNextAction_CalledTwiceWithOneActionAdded_ReturnsNullActionInOutParameterOnSecondCall()
{ {
CreateActions(); CreateActions();
ProcessPackageAction expectedAction = AddAction(); IPackageAction expectedAction = AddAction();
ProcessPackageAction action = null; IPackageAction action = null;
actions.GetNextAction(out action); actions.GetNextAction(out action);
actions.GetNextAction(out action); actions.GetNextAction(out action);
@ -79,9 +79,9 @@ namespace PackageManagement.Tests
public void GetNextAction_CalledTwiceWithOneActionAdded_ReturnsFalseOnSecondCall() public void GetNextAction_CalledTwiceWithOneActionAdded_ReturnsFalseOnSecondCall()
{ {
CreateActions(); CreateActions();
ProcessPackageAction expectedAction = AddAction(); IPackageAction expectedAction = AddAction();
ProcessPackageAction action = null; IPackageAction action = null;
actions.GetNextAction(out action); actions.GetNextAction(out action);
bool result = actions.GetNextAction(out action); bool result = actions.GetNextAction(out action);
@ -93,8 +93,8 @@ namespace PackageManagement.Tests
{ {
CreateActions(); CreateActions();
AddAction(); AddAction();
ProcessPackageAction expectedAction = AddAction(); IPackageAction expectedAction = AddAction();
ProcessPackageAction action = null; IPackageAction action = null;
actions.GetNextAction(out action); actions.GetNextAction(out action);
actions.GetNextAction(out action); actions.GetNextAction(out action);
@ -106,8 +106,8 @@ namespace PackageManagement.Tests
{ {
CreateActions(); CreateActions();
AddAction(); AddAction();
ProcessPackageAction expectedAction = AddAction(); IPackageAction expectedAction = AddAction();
ProcessPackageAction action = null; IPackageAction action = null;
actions.GetNextAction(out action); actions.GetNextAction(out action);
bool result = actions.GetNextAction(out action); bool result = actions.GetNextAction(out action);

41
src/AddIns/Misc/PackageManagement/Test/Src/PackageManagementProjectTests.cs

@ -28,6 +28,7 @@ namespace PackageManagement.Tests
FakeInstallPackageAction fakeInstallAction; FakeInstallPackageAction fakeInstallAction;
FakeUninstallPackageAction fakeUninstallAction; FakeUninstallPackageAction fakeUninstallAction;
FakeUpdatePackageAction fakeUpdateAction; FakeUpdatePackageAction fakeUpdateAction;
UpdatePackagesAction updatePackagesAction;
void CreateProject() void CreateProject()
{ {
@ -63,6 +64,11 @@ namespace PackageManagement.Tests
return fakeUpdateAction; return fakeUpdateAction;
} }
void CreateUpdatePackagesAction()
{
updatePackagesAction = new UpdatePackagesAction(project);
}
[Test] [Test]
public void IsInstalled_PackageIsInstalled_ReturnsTrue() public void IsInstalled_PackageIsInstalled_ReturnsTrue()
{ {
@ -639,5 +645,40 @@ namespace PackageManagement.Tests
Assert.IsFalse(fakePackageManager.AllowPrereleaseVersionsPassedToInstallPackage); Assert.IsFalse(fakePackageManager.AllowPrereleaseVersionsPassedToInstallPackage);
} }
[Test]
public void UpdatePackages_ActionHasOperationsAndPackages_ActionPassedToPackageManager()
{
CreateProject();
CreateUpdatePackagesAction();
project.UpdatePackages(updatePackagesAction);
Assert.AreEqual(updatePackagesAction, fakePackageManager.UpdatePackagesActionsPassedToUpdatePackages);
}
[Test]
public void GetUpdatePackagesOperations_ActionPassed_ActionPassedToPackageManager()
{
CreateProject();
CreateUpdatePackagesAction();
project.GetUpdatePackagesOperations(updatePackagesAction);
Assert.AreEqual(updatePackagesAction, fakePackageManager.UpdatePackagesActionsPassedToGetUpdatePackagesOperations);
}
[Test]
public void GetUpdatePackagesOperations_ActionPassed_PackageOperationsReturned()
{
CreateProject();
CreateUpdatePackagesAction();
List<PackageOperation> expectedOperations = PackageOperationHelper.CreateListWithOneInstallOperationWithFile("readme.txt");
fakePackageManager.PackageOperationsToReturnFromGetUpdatePackageOperations = expectedOperations;
IEnumerable<PackageOperation> operations = project.GetUpdatePackagesOperations(updatePackagesAction);
CollectionAssert.AreEqual(expectedOperations, operations);
}
} }
} }

2
src/AddIns/Misc/PackageManagement/Test/Src/PackageReferenceInstallerTests.cs

@ -49,7 +49,7 @@ namespace PackageManagement.Tests
AddPackageReference("PackageId", "1.3.4.5"); AddPackageReference("PackageId", "1.3.4.5");
InstallPackages(); InstallPackages();
var actions = new List<ProcessPackageAction>(fakeActionRunner.ActionsRunInOneCall); var actions = new List<IPackageAction>(fakeActionRunner.ActionsRunInOneCall);
var action = actions[0] as InstallPackageAction; var action = actions[0] as InstallPackageAction;
var expectedVersion = new SemanticVersion("1.3.4.5"); var expectedVersion = new SemanticVersion("1.3.4.5");

14
src/AddIns/Misc/PackageManagement/Test/Src/PackageViewModelTests.cs

@ -177,7 +177,7 @@ namespace PackageManagement.Tests
viewModel.AddPackage(); viewModel.AddPackage();
ProcessPackageAction actionExecuted = fakeActionRunner.ActionPassedToRun; IPackageAction actionExecuted = fakeActionRunner.ActionPassedToRun;
Assert.AreEqual(fakeInstallPackageAction, actionExecuted); Assert.AreEqual(fakeInstallPackageAction, actionExecuted);
} }
@ -739,7 +739,7 @@ namespace PackageManagement.Tests
viewModel.AddOneFakeInstallPackageOperationForViewModelPackage(); viewModel.AddOneFakeInstallPackageOperationForViewModelPackage();
viewModel.RemovePackage(); viewModel.RemovePackage();
ProcessPackageAction actionExecuted = fakeActionRunner.ActionPassedToRun; IPackageAction actionExecuted = fakeActionRunner.ActionPassedToRun;
Assert.AreEqual(fakeUninstallPackageAction, actionExecuted); Assert.AreEqual(fakeUninstallPackageAction, actionExecuted);
} }
@ -902,7 +902,7 @@ namespace PackageManagement.Tests
viewModel.ManagePackagesForSelectedProjects(fakeSelectedProjects); viewModel.ManagePackagesForSelectedProjects(fakeSelectedProjects);
List<ProcessPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList(); List<IPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList();
InstallPackageAction action = actions[0] as InstallPackageAction; InstallPackageAction action = actions[0] as InstallPackageAction;
Assert.AreEqual(1, actions.Count); Assert.AreEqual(1, actions.Count);
@ -1111,7 +1111,7 @@ namespace PackageManagement.Tests
viewModel.ManagePackagesForSelectedProjects(fakeSelectedProjects); viewModel.ManagePackagesForSelectedProjects(fakeSelectedProjects);
InstallPackageAction expectedAction = FirstFakeSelectedProject.FakeInstallPackageAction; InstallPackageAction expectedAction = FirstFakeSelectedProject.FakeInstallPackageAction;
List<ProcessPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList(); List<IPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList();
InstallPackageAction action = actions[0] as InstallPackageAction; InstallPackageAction action = actions[0] as InstallPackageAction;
Assert.AreEqual(1, actions.Count); Assert.AreEqual(1, actions.Count);
@ -1224,12 +1224,12 @@ namespace PackageManagement.Tests
CreateViewModelWithTwoProjectsSelected("Project A", "Project B"); CreateViewModelWithTwoProjectsSelected("Project A", "Project B");
UserAcceptsProjectSelection(); UserAcceptsProjectSelection();
fakePackageManagementEvents.ProjectsToSelect.Add("Project A"); fakePackageManagementEvents.ProjectsToSelect.Add("Project A");
viewModel.ManagePackage(); viewModel.ManagePackage();
List<ProcessPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList(); List<IPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList();
ProcessPackageAction action = actions[0]; var action = actions[0] as ProcessPackageAction;
FakePackageManagementProject expectedProject = fakeSolution.FakeProjectsToReturnFromGetProject["Project A"]; FakePackageManagementProject expectedProject = fakeSolution.FakeProjectsToReturnFromGetProject["Project A"];
Assert.AreEqual(expectedProject, action.Project); Assert.AreEqual(expectedProject, action.Project);
} }

23
src/AddIns/Misc/PackageManagement/Test/Src/ProcessPackageActionTests.cs

@ -67,7 +67,7 @@ namespace PackageManagement.Tests
} }
[Test] [Test]
public void Execute_MethodCalled_RunPackageScriptsActionCreatedUsingPackageScriptRunner() public void Execute_PackageScriptRunnerSet_RunPackageScriptsActionCreatedUsingPackageScriptRunner()
{ {
CreateAction(); CreateAction();
var expectedRunner = new FakePackageScriptRunner(); var expectedRunner = new FakePackageScriptRunner();
@ -80,7 +80,7 @@ namespace PackageManagement.Tests
} }
[Test] [Test]
public void Execute_MethodCalled_RunPackageScriptsActionCreatedUsingProject() public void Execute_PackageScriptRunnerSet_RunPackageScriptsActionCreatedUsingProject()
{ {
CreateAction(); CreateAction();
var expectedProject = new FakePackageManagementProject(); var expectedProject = new FakePackageManagementProject();
@ -88,13 +88,13 @@ namespace PackageManagement.Tests
action.PackageScriptRunner = new FakePackageScriptRunner(); action.PackageScriptRunner = new FakePackageScriptRunner();
action.Execute(); action.Execute();
var actualProject = action.ProjectPassedToCreateRunPackageScriptsAction; IPackageManagementProject actualProject = action.ProjectPassedToCreateRunPackageScriptsAction;
Assert.AreEqual(expectedProject, actualProject); Assert.AreEqual(expectedProject, actualProject);
} }
[Test] [Test]
public void Execute_MethodCalled_RunPackageScriptsActionIsDisposed() public void Execute_PackageScriptRunnerSet_RunPackageScriptsActionIsDisposed()
{ {
CreateAction(); CreateAction();
action.PackageScriptRunner = new FakePackageScriptRunner(); action.PackageScriptRunner = new FakePackageScriptRunner();
@ -104,12 +104,25 @@ namespace PackageManagement.Tests
} }
[Test] [Test]
public void Execute_NullSession_RunPackageScriptsActionIsNotCreated() public void Execute_NullPackageScriptRunner_RunPackageScriptsActionIsNotCreated()
{ {
CreateAction(); CreateAction();
action.PackageScriptRunner = null;
action.Execute(); action.Execute();
Assert.IsFalse(action.IsRunPackageScriptsActionCreated); Assert.IsFalse(action.IsRunPackageScriptsActionCreated);
} }
[Test]
public void Execute_NullPackageScriptRunner_ActionIsExecuted()
{
CreateAction();
action.PackageScriptRunner = new FakePackageScriptRunner();
action.Execute();
Assert.IsTrue(action.IsExecuteCoreCalled);
}
} }
} }

170
src/AddIns/Misc/PackageManagement/Test/Src/ReducedPackageOperationsTests.cs

@ -0,0 +1,170 @@
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
using System;
using System.Collections.Generic;
using System.Linq;
using ICSharpCode.PackageManagement;
using NuGet;
using NUnit.Framework;
using Rhino.Mocks;
namespace PackageManagement.Tests
{
[TestFixture]
public class ReducedPackageOperationsTests
{
ReducedPackageOperations reducedPackageOperations;
IPackageOperationResolver fakePackageOperationResolver;
List<IPackage> packages;
void CreateReducedPackageOperations()
{
packages = new List<IPackage>();
fakePackageOperationResolver = MockRepository.GenerateStub<IPackageOperationResolver>();
reducedPackageOperations = new ReducedPackageOperations(fakePackageOperationResolver, packages);
}
IPackage AddPackage(string id, string version)
{
IPackage package = CreatePackage(id, version);
packages.Add(package);
return package;
}
IPackage CreatePackage(string id, string version)
{
IPackage package = MockRepository.GenerateStub<IPackage>();
package.Stub(p => p.Id).Return(id);
package.Stub(p => p.Version).Return(new SemanticVersion(version));
return package;
}
PackageOperation AddInstallOperationForPackage(IPackage package)
{
var operation = new PackageOperation(package, PackageAction.Install);
AddInstallOperationsForPackage(package, operation);
return operation;
}
void AddInstallOperationsForPackage(IPackage package, params PackageOperation[] operations)
{
fakePackageOperationResolver
.Stub(resolver => resolver.ResolveOperations(package))
.Return(operations);
}
PackageOperation CreatePackageOperation(string id, string version, PackageAction action)
{
IPackage package = CreatePackage(id, version);
return new PackageOperation(package, action);
}
void AssertReducedOperationsContains(PackageOperation operation)
{
Assert.Contains(operation, reducedPackageOperations.Operations.ToList());
}
[Test]
public void Reduce_OnePackage_ReturnsPackageOperationsFromResolverForPackage()
{
CreateReducedPackageOperations();
IPackage package = AddPackage("Test", "1.0");
PackageOperation operation = AddInstallOperationForPackage(package);
reducedPackageOperations.Reduce();
Assert.AreEqual(1, reducedPackageOperations.Operations.Count());
Assert.AreEqual(operation, reducedPackageOperations.Operations.First());
}
[Test]
public void Reduce_TwoPackages_ReturnsPackageOperationsForBothPackages()
{
CreateReducedPackageOperations();
IPackage package1 = AddPackage("Test", "1.0");
IPackage package2 = AddPackage("Test2", "1.0");
PackageOperation operation1 = AddInstallOperationForPackage(package1);
PackageOperation operation2 = AddInstallOperationForPackage(package2);
reducedPackageOperations.Reduce();
Assert.AreEqual(2, reducedPackageOperations.Operations.Count());
AssertReducedOperationsContains(operation1);
AssertReducedOperationsContains(operation2);
}
[Test]
public void Reduce_OncePackageOperationInstallsPackageWhilstOneUninstallsSamePackage_PackageOperationNotIncludedInReducedSet()
{
CreateReducedPackageOperations();
IPackage package = AddPackage("Test", "1.0");
PackageOperation installOperation = CreatePackageOperation("Foo", "1.0", PackageAction.Install);
PackageOperation uninstallOperation = CreatePackageOperation("Foo", "1.0", PackageAction.Uninstall);
AddInstallOperationsForPackage(package, installOperation, uninstallOperation);
reducedPackageOperations.Reduce();
Assert.AreEqual(0, reducedPackageOperations.Operations.Count());
}
[Test]
public void Reduce_OnePackageOperationMatchesPackageBeingInstalled_ReturnsOnlyOnePackageInstallOperationForThisPackage()
{
CreateReducedPackageOperations();
IPackage package1 = AddPackage("Test", "1.0");
IPackage package2 = AddPackage("Test2", "1.0");
PackageOperation operation1a = CreatePackageOperation("Test", "1.0", PackageAction.Install);
PackageOperation operation1b = CreatePackageOperation("Test2", "1.0", PackageAction.Install);
PackageOperation operation2 = CreatePackageOperation("Test2", "1.0", PackageAction.Install);
AddInstallOperationsForPackage(package1, operation1a, operation1b);
AddInstallOperationsForPackage(package2, operation2);
reducedPackageOperations.Reduce();
PackageOperation operation = reducedPackageOperations
.Operations
.SingleOrDefault(o => o.Package.Id == "Test2");
Assert.AreEqual(2, reducedPackageOperations.Operations.Count());
}
[Test]
public void Reduce_OnePackageOperationMatchesPackageBeingInstalledOnlyById_MatchingPackageOperationByIdIncludedInSet()
{
CreateReducedPackageOperations();
IPackage package1 = AddPackage("Test", "1.0");
IPackage package2 = AddPackage("Test2", "1.0");
PackageOperation operation1a = CreatePackageOperation("Test", "1.0", PackageAction.Install);
PackageOperation operation1b = CreatePackageOperation("Test2", "1.1", PackageAction.Install);
PackageOperation operation2 = CreatePackageOperation("Test2", "1.0", PackageAction.Install);
AddInstallOperationsForPackage(package1, operation1a, operation1b);
AddInstallOperationsForPackage(package2, operation2);
reducedPackageOperations.Reduce();
Assert.AreEqual(3, reducedPackageOperations.Operations.Count());
}
[Test]
public void Reduce_OnePackageOperationMatchesPackageBeingInstalledByIdAndVersionButOneIsInstallAndOneIsUninstall_BothOperationsNotIncludedInSet()
{
CreateReducedPackageOperations();
IPackage package1 = AddPackage("Test", "1.0");
IPackage package2 = AddPackage("Test2", "1.0");
PackageOperation operation1a = CreatePackageOperation("Test", "1.0", PackageAction.Install);
PackageOperation operation1b = CreatePackageOperation("Test2", "1.0", PackageAction.Uninstall);
PackageOperation operation2 = CreatePackageOperation("Test2", "1.0", PackageAction.Install);
AddInstallOperationsForPackage(package1, operation1a, operation1b);
AddInstallOperationsForPackage(package2, operation2);
reducedPackageOperations.Reduce();
PackageOperation operation = reducedPackageOperations
.Operations
.SingleOrDefault(o => o.Package.Id == "Test");
Assert.AreEqual(1, reducedPackageOperations.Operations.Count());
}
}
}

245
src/AddIns/Misc/PackageManagement/Test/Src/SharpDevelopPackageManagerTests.cs

@ -2,6 +2,7 @@
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt) // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
using System; using System;
using System.Linq;
using System.Collections.Generic; using System.Collections.Generic;
using ICSharpCode.Core; using ICSharpCode.Core;
using ICSharpCode.PackageManagement; using ICSharpCode.PackageManagement;
@ -10,6 +11,7 @@ using ICSharpCode.SharpDevelop.Project;
using NuGet; using NuGet;
using NUnit.Framework; using NUnit.Framework;
using PackageManagement.Tests.Helpers; using PackageManagement.Tests.Helpers;
using Rhino.Mocks;
namespace PackageManagement.Tests namespace PackageManagement.Tests
{ {
@ -26,6 +28,7 @@ namespace PackageManagement.Tests
TestableProjectManager testableProjectManager; TestableProjectManager testableProjectManager;
FakeFileSystem fakeFileSystem; FakeFileSystem fakeFileSystem;
FakePackageOperationResolverFactory fakePackageOperationResolverFactory; FakePackageOperationResolverFactory fakePackageOperationResolverFactory;
IPackageOperationResolver fakePackageOperationResolver;
void CreatePackageManager(IProject project, PackageReferenceRepositoryHelper packageRefRepositoryHelper) void CreatePackageManager(IProject project, PackageReferenceRepositoryHelper packageRefRepositoryHelper)
{ {
@ -76,9 +79,9 @@ namespace PackageManagement.Tests
packageManager.ProjectManager = testableProjectManager; packageManager.ProjectManager = testableProjectManager;
} }
FakePackage CreateFakePackage() FakePackage CreateFakePackage(string id = "Test", string version = "1.0.0.0")
{ {
return new FakePackage("Test", "1.0.0.0"); return new FakePackage(id, version);
} }
FakePackage InstallPackage() FakePackage InstallPackage()
@ -160,7 +163,7 @@ namespace PackageManagement.Tests
} }
FakePackage UninstallPackage() FakePackage UninstallPackage()
{ {
FakePackage package = CreateFakePackage(); FakePackage package = CreateFakePackage();
testableProjectManager.FakeLocalRepository.FakePackages.Add(package); testableProjectManager.FakeLocalRepository.FakePackages.Add(package);
@ -170,7 +173,7 @@ namespace PackageManagement.Tests
FakePackage UninstallPackageAndForceRemove() FakePackage UninstallPackageAndForceRemove()
{ {
FakePackage package = CreateFakePackage(); FakePackage package = CreateFakePackage();
testableProjectManager.FakeLocalRepository.FakePackages.Add(package); testableProjectManager.FakeLocalRepository.FakePackages.Add(package);
bool removeDependencies = false; bool removeDependencies = false;
@ -192,11 +195,9 @@ namespace PackageManagement.Tests
return package; return package;
} }
PackageOperation CreateOneInstallPackageOperation() PackageOperation CreateOneInstallPackageOperation(string id = "PackageToInstall", string version = "1.0")
{ {
FakePackage package = CreateFakePackage(); FakePackage package = CreateFakePackage(id, version);
package.Id = "PackageToInstall";
return new PackageOperation(package, PackageAction.Install); return new PackageOperation(package, PackageAction.Install);
} }
@ -267,9 +268,48 @@ namespace PackageManagement.Tests
updateAction.UpdateDependencies = updateDependencies; updateAction.UpdateDependencies = updateDependencies;
updateAction.AllowPrereleaseVersions = allowPrereleaseVersions; updateAction.AllowPrereleaseVersions = allowPrereleaseVersions;
packageManager.UpdatePackage(package, updateAction); packageManager.UpdatePackage(package, updateAction);
return package; return package;
} }
UpdatePackagesAction CreateUpdatePackagesAction()
{
return new UpdatePackagesAction(new FakePackageManagementProject());
}
UpdatePackagesAction CreateUpdatePackagesActionWithPackages(params IPackage[] packages)
{
UpdatePackagesAction action = CreateUpdatePackagesAction();
action.AddPackages(packages);
return action;
}
UpdatePackagesAction CreateUpdatePackagesActionWithOperations(params PackageOperation[] operations)
{
UpdatePackagesAction action = CreateUpdatePackagesAction();
action.AddOperations(operations);
return action;
}
PackageOperation AddInstallOperationForPackage(IPackage package)
{
var operation = new PackageOperation(package, PackageAction.Install);
AddInstallOperationsForPackage(package, operation);
return operation;
}
void AddInstallOperationsForPackage(IPackage package, params PackageOperation[] operations)
{
fakePackageOperationResolver
.Stub(resolver => resolver.ResolveOperations(package))
.Return(operations);
}
void CreateFakePackageResolverForUpdatePackageOperations()
{
fakePackageOperationResolver = MockRepository.GenerateStub<IPackageOperationResolver>();
fakePackageOperationResolverFactory.UpdatePackageOperationsResolver = fakePackageOperationResolver;
}
[Test] [Test]
public void ProjectManager_InstanceCreated_SourceRepositoryIsSharedRepositoryPassedToPackageManager() public void ProjectManager_InstanceCreated_SourceRepositoryIsSharedRepositoryPassedToPackageManager()
{ {
@ -566,7 +606,7 @@ namespace PackageManagement.Tests
public void GetInstallPackageOperations_PackageOperationResolverFactoryUsed_PackageOperationsReturnedFromPackageOperationsResolverCreated() public void GetInstallPackageOperations_PackageOperationResolverFactoryUsed_PackageOperationsReturnedFromPackageOperationsResolverCreated()
{ {
CreatePackageManager(); CreatePackageManager();
var package = new FakePackage(); var package = new FakePackage();
IEnumerable<PackageOperation> operations = GetInstallPackageOperations(package); IEnumerable<PackageOperation> operations = GetInstallPackageOperations(package);
IEnumerable<PackageOperation> expectedOperations = fakePackageOperationResolverFactory.FakeInstallPackageOperationResolver.PackageOperations; IEnumerable<PackageOperation> expectedOperations = fakePackageOperationResolverFactory.FakeInstallPackageOperationResolver.PackageOperations;
@ -649,8 +689,8 @@ namespace PackageManagement.Tests
bool result = fakePackageOperationResolverFactory.IgnoreDependenciesPassedToCreateInstallPackageOperationResolver; bool result = fakePackageOperationResolverFactory.IgnoreDependenciesPassedToCreateInstallPackageOperationResolver;
Assert.IsTrue(result); Assert.IsTrue(result);
} }
[Test] [Test]
public void GetInstallPackageOperations_AllowPrereleaseVersionsIsTrue_PackageOperationResolverAllowsPrereleaseVersions() public void GetInstallPackageOperations_AllowPrereleaseVersionsIsTrue_PackageOperationResolverAllowsPrereleaseVersions()
{ {
@ -661,7 +701,7 @@ namespace PackageManagement.Tests
bool result = fakePackageOperationResolverFactory.AllowPrereleaseVersionsPassedToCreateInstallPackageOperationResolver; bool result = fakePackageOperationResolverFactory.AllowPrereleaseVersionsPassedToCreateInstallPackageOperationResolver;
Assert.IsTrue(result); Assert.IsTrue(result);
} }
[Test] [Test]
public void GetInstallPackageOperations_AllowPrereleaseVersionsIsFalse_PackageOperationResolverDoesNotAllowPrereleaseVersions() public void GetInstallPackageOperations_AllowPrereleaseVersionsIsFalse_PackageOperationResolverDoesNotAllowPrereleaseVersions()
@ -673,7 +713,7 @@ namespace PackageManagement.Tests
bool result = fakePackageOperationResolverFactory.AllowPrereleaseVersionsPassedToCreateInstallPackageOperationResolver; bool result = fakePackageOperationResolverFactory.AllowPrereleaseVersionsPassedToCreateInstallPackageOperationResolver;
Assert.IsFalse(result); Assert.IsFalse(result);
} }
public void UpdatePackage_PackageInstanceAndNoPackageOperationsPassed_UpdatesReferenceInProject() public void UpdatePackage_PackageInstanceAndNoPackageOperationsPassed_UpdatesReferenceInProject()
{ {
@ -735,5 +775,180 @@ namespace PackageManagement.Tests
Assert.IsFalse(testableProjectManager.UpdateDependenciesPassedToUpdatePackageReference); Assert.IsFalse(testableProjectManager.UpdateDependenciesPassedToUpdatePackageReference);
} }
[Test]
public void UpdatePackages_OnePackage_PackageReferencedIsAddedToProject()
{
CreatePackageManager();
CreateTestableProjectManager();
FakePackage package = CreateFakePackage("Test", "1.1");
UpdatePackagesAction action = CreateUpdatePackagesActionWithPackages(package);
packageManager.UpdatePackages(action);
Assert.AreEqual(package, testableProjectManager.PackagePassedToUpdatePackageReference);
}
[Test]
public void UpdatePackages_TwoPackages_PackageReferencedIsAddedToProjectForBothPackages()
{
CreatePackageManager();
CreateTestableProjectManager();
FakePackage package1 = CreateFakePackage("First", "1.1");
FakePackage package2 = CreateFakePackage("Second", "2.0");
var expectedPackages = new FakePackage[] { package1, package2 };
UpdatePackagesAction action = CreateUpdatePackagesActionWithPackages(expectedPackages);
packageManager.UpdatePackages(action);
PackageCollectionAssert.AreEqual(expectedPackages, testableProjectManager.PackagesPassedToUpdatePackageReference);
}
[Test]
public void UpdatePackages_UpdateDependenciesIsTrue_UpdateDependenciesPassedToProjectManager()
{
CreatePackageManager();
CreateTestableProjectManager();
FakePackage package = CreateFakePackage("Test", "1.1");
UpdatePackagesAction action = CreateUpdatePackagesActionWithPackages(package);
action.UpdateDependencies = true;
packageManager.UpdatePackages(action);
Assert.IsTrue(testableProjectManager.UpdateDependenciesPassedToUpdatePackageReference);
}
[Test]
public void UpdatePackages_UpdateDependenciesIsFalse_UpdateDependenciesPassedToProjectManager()
{
CreatePackageManager();
CreateTestableProjectManager();
FakePackage package = CreateFakePackage("Test", "1.1");
UpdatePackagesAction action = CreateUpdatePackagesActionWithPackages(package);
action.UpdateDependencies = false;
packageManager.UpdatePackages(action);
Assert.IsFalse(testableProjectManager.UpdateDependenciesPassedToUpdatePackageReference);
}
[Test]
public void UpdatePackages_AllowPrereleaseVersionsIsTrue_AllowPrereleaseVersionsPassedToProjectManager()
{
CreatePackageManager();
CreateTestableProjectManager();
FakePackage package = CreateFakePackage("Test", "1.1");
UpdatePackagesAction action = CreateUpdatePackagesActionWithPackages(package);
action.AllowPrereleaseVersions = true;
packageManager.UpdatePackages(action);
Assert.IsTrue(testableProjectManager.AllowPrereleaseVersionsPassedToUpdatePackageReference);
}
[Test]
public void UpdatePackages_AllowPrereleaseVersionsIsFalse_AllowPrereleaseVersionsPassedToProjectManager()
{
CreatePackageManager();
CreateTestableProjectManager();
FakePackage package = CreateFakePackage("Test", "1.1");
UpdatePackagesAction action = CreateUpdatePackagesActionWithPackages(package);
action.AllowPrereleaseVersions = false;
packageManager.UpdatePackages(action);
Assert.IsFalse(testableProjectManager.AllowPrereleaseVersionsPassedToUpdatePackageReference);
}
[Test]
public void UpdatePackages_TwoPackageOperations_BothPackagesInOperationsAddedToSharedRepository()
{
CreatePackageManager();
CreateTestableProjectManager();
PackageOperation operation1 = CreateOneInstallPackageOperation("First", "1.0");
PackageOperation operation2 = CreateOneInstallPackageOperation("Second", "1.0");
UpdatePackagesAction action = CreateUpdatePackagesActionWithOperations(operation1, operation2);
var expectedPackages = new FakePackage[] {
operation1.Package as FakePackage,
operation2.Package as FakePackage
};
packageManager.UpdatePackages(action);
PackageCollectionAssert.AreEqual(expectedPackages, fakeSolutionSharedRepository.PackagesAdded);
}
[Test]
public void GetUpdatePackageOperations_PackageOperationResolverFactoryUsed_PackageManagerUsesLoggerWhenGettingPackageOperations()
{
CreatePackageManager();
FakePackage package = CreateFakePackage("Test", "1.1");
UpdatePackagesAction updateAction = CreateUpdatePackagesActionWithPackages(package);
packageManager.GetUpdatePackageOperations(updateAction);
ILogger expectedLogger = packageManager.Logger;
ILogger actualLogger = fakePackageOperationResolverFactory.LoggerPassedToCreateUpdatePackageOperationResolver;
Assert.AreEqual(expectedLogger, actualLogger);
}
[Test]
public void GetUpdatePackageOperations_PackageOperationResolverFactoryUsed_PackageManagerUsesLocalRepositoryWhenGettingPackageOperations()
{
CreatePackageManager();
FakePackage package = CreateFakePackage("Test", "1.1");
UpdatePackagesAction updateAction = CreateUpdatePackagesActionWithPackages(package);
packageManager.GetUpdatePackageOperations(updateAction);
IPackageRepository expectedRepository = packageManager.LocalRepository;
IPackageRepository actualRepository = fakePackageOperationResolverFactory.LocalRepositoryPassedToCreateUpdatePackageOperationsResolver;
Assert.AreEqual(expectedRepository, actualRepository);
}
[Test]
public void GetUpdatePackageOperations_PackageOperationResolverFactoryUsed_PackageManagerUsesSourceRepositoryWhenGettingPackageOperations()
{
CreatePackageManager();
FakePackage package = CreateFakePackage("Test", "1.1");
UpdatePackagesAction updateAction = CreateUpdatePackagesActionWithPackages(package);
packageManager.GetUpdatePackageOperations(updateAction);
IPackageRepository expectedRepository = packageManager.SourceRepository;
IPackageRepository actualRepository = fakePackageOperationResolverFactory.SourceRepositoryPassedToCreateUpdatePackageOperationsResolver;
Assert.AreEqual(expectedRepository, actualRepository);
}
[Test]
public void GetUpdatePackageOperations_PackageOperationResolverFactoryUsed_PackageManagerUsesUpdatePackageSettingsWhenGettingPackageOperations()
{
CreatePackageManager();
FakePackage package = CreateFakePackage("Test", "1.1");
UpdatePackagesAction updateAction = CreateUpdatePackagesActionWithPackages(package);
packageManager.GetUpdatePackageOperations(updateAction);
IUpdatePackageSettings settings = fakePackageOperationResolverFactory.SettingsPassedToCreatePackageOperationResolver;
Assert.AreEqual(updateAction, settings);
}
[Test]
public void GetUpdatePackageOperations_TwoPackages_ReturnsPackageOperationsForBothPackages()
{
CreatePackageManager();
CreateFakePackageResolverForUpdatePackageOperations();
IPackage package1 = CreateFakePackage("Test", "1.0");
IPackage package2 = CreateFakePackage("Test2", "1.0");
PackageOperation operation1 = AddInstallOperationForPackage(package1);
PackageOperation operation2 = AddInstallOperationForPackage(package2);
UpdatePackagesAction updateAction = CreateUpdatePackagesActionWithPackages(package1, package2);
List<PackageOperation> operations = packageManager.GetUpdatePackageOperations(updateAction).ToList();
Assert.AreEqual(2, operations.Count());
Assert.Contains(operation1, operations);
Assert.Contains(operation2, operations);
}
} }
} }

165
src/AddIns/Misc/PackageManagement/Test/Src/UpdatePackagesActionTests.cs

@ -0,0 +1,165 @@
// Copyright (c) AlphaSierraPapa for the SharpDevelop Team (for details please see \doc\copyright.txt)
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
using System;
using ICSharpCode.PackageManagement;
using ICSharpCode.PackageManagement.Scripting;
using NuGet;
using NUnit.Framework;
using PackageManagement.Tests.Helpers;
using Rhino.Mocks;
namespace PackageManagement.Tests
{
[TestFixture]
public class UpdatePackagesActionTests
{
TestableUpdatePackagesAction action;
IPackageManagementProject project;
void CreateAction()
{
CreateProject();
action = new TestableUpdatePackagesAction(project);
}
void CreateActionWithOperations(params PackageOperation[] operations)
{
CreateAction();
action.AddOperations(operations);
}
void CreateProject()
{
project = MockRepository.GenerateStub<IPackageManagementProject>();
}
IPackage CreatePackage()
{
return MockRepository.GenerateStub<IPackage>();
}
PackageOperation CreateInstallOperationWithFile(string fileName)
{
return PackageOperationHelper.CreateInstallOperationWithFile(fileName);
}
IPackageScriptRunner CreatePackageScriptRunner()
{
return MockRepository.GenerateStub<IPackageScriptRunner>();
}
[Test]
public void UpdateDependencies_DefaultValue_IsTrue()
{
CreateActionWithOperations();
bool result = action.UpdateDependencies;
Assert.IsTrue(result);
}
[Test]
public void HasPackageScriptsToRun_PackageHasInitPowerShellScript_ReturnsTrue()
{
PackageOperation operation = CreateInstallOperationWithFile(@"tools\install.ps1");
CreateActionWithOperations(operation);
bool result = action.HasPackageScriptsToRun();
Assert.IsTrue(result);
}
[Test]
public void HasPackageScriptsToRun_PackageHasOneTextFile_ReturnsFalse()
{
PackageOperation operation = CreateInstallOperationWithFile(@"tools\readme.txt");
CreateActionWithOperations(operation);
bool result = action.HasPackageScriptsToRun();
Assert.IsFalse(result);
}
[Test]
public void Execute_UpdatePackagesAction_PackagesUpdatedUsingProject()
{
CreateAction();
action.Execute();
project.AssertWasCalled(p => p.UpdatePackages(action));
}
[Test]
public void Execute_UpdatePackagesActionWithOnePackageOperation_PackagesUpdatedUsingProject()
{
PackageOperation operation = CreateInstallOperationWithFile(@"tools\readme.txt");
CreateActionWithOperations(operation);
action.Execute();
project.AssertWasCalled(p => p.UpdatePackages(action));
}
[Test]
public void Execute_PackageScriptRunnerSet_RunPackageScriptsActionCreatedUsingPackageScriptRunner()
{
CreateAction();
IPackageScriptRunner expectedRunner = CreatePackageScriptRunner();
action.PackageScriptRunner = expectedRunner;
action.Execute();
IPackageScriptRunner actualRunner = action.ScriptRunnerPassedToCreateRunPackageScriptsAction;
Assert.AreEqual(expectedRunner, actualRunner);
}
[Test]
public void Execute_PackageScriptRunnerSet_RunPackageScriptsActionCreatedUsingProject()
{
CreateAction();
action.PackageScriptRunner = CreatePackageScriptRunner();
action.Execute();
IPackageManagementProject actualProject = action.ProjectPassedToCreateRunPackageScriptsAction;
Assert.AreEqual(project, actualProject);
}
[Test]
public void Execute_PackageScriptRunnerSet_RunPackageScriptsActionIsDisposed()
{
CreateAction();
action.PackageScriptRunner = CreatePackageScriptRunner();
action.Execute();
Assert.IsTrue(action.IsRunPackageScriptsActionDisposed);
}
[Test]
public void Execute_NullPackageScriptRunner_RunPackageScriptsActionIsNotCreated()
{
CreateAction();
action.PackageScriptRunner = null;
action.Execute();
Assert.IsFalse(action.IsRunPackageScriptsActionCreated);
}
[Test]
public void Execute_NullPackageScriptRunner_PackagesAreUpdated()
{
CreateAction();
PackageOperation operation = CreateInstallOperationWithFile(@"tools\readme.txt");
CreateActionWithOperations(operation);
action.PackageScriptRunner = CreatePackageScriptRunner();
action.Execute();
project.AssertWasCalled(p => p.UpdatePackages(action));
}
}
}

7
src/AddIns/Misc/PackageManagement/Test/Src/UpdatedPackageViewModelTests.cs

@ -38,7 +38,6 @@ namespace PackageManagement.Tests
FakeUpdatePackageAction FirstUpdatePackageActionCreated { FakeUpdatePackageAction FirstUpdatePackageActionCreated {
get { return fakeProject.FirstFakeUpdatePackageActionCreated; } get { return fakeProject.FirstFakeUpdatePackageActionCreated; }
} }
void CreateFakeSolution() void CreateFakeSolution()
{ {
@ -106,7 +105,7 @@ namespace PackageManagement.Tests
CreateViewModel(); CreateViewModel();
viewModel.AddPackage(); viewModel.AddPackage();
ProcessPackageAction actionExecuted = fakeActionRunner.ActionPassedToRun; IPackageAction actionExecuted = fakeActionRunner.ActionPassedToRun;
Assert.AreEqual(FirstUpdatePackageActionCreated, actionExecuted); Assert.AreEqual(FirstUpdatePackageActionCreated, actionExecuted);
} }
@ -120,10 +119,10 @@ namespace PackageManagement.Tests
viewModel.ManagePackage(); viewModel.ManagePackage();
FakePackage expectedPackage = viewModel.FakePackage; FakePackage expectedPackage = viewModel.FakePackage;
List<ProcessPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList(); List<IPackageAction> actions = fakeActionRunner.GetActionsRunInOneCallAsList();
var updatePackageAction = actions[0] as UpdatePackageAction; var updatePackageAction = actions[0] as UpdatePackageAction;
IPackage actualPackage = updatePackageAction.Package; IPackage actualPackage = updatePackageAction.Package;
Assert.AreEqual(expectedPackage, actualPackage); Assert.AreEqual(expectedPackage, actualPackage);
} }
} }

253
src/AddIns/Misc/PackageManagement/Test/Src/UpdatedPackagesViewModelTests.cs

@ -2,6 +2,9 @@
// This code is distributed under the GNU LGPL (for details please see \doc\license.txt) // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
using System; using System;
using System.Collections.Generic;
using System.Linq;
using ICSharpCode.PackageManagement; using ICSharpCode.PackageManagement;
using ICSharpCode.PackageManagement.Design; using ICSharpCode.PackageManagement.Design;
using NuGet; using NuGet;
@ -18,6 +21,9 @@ namespace PackageManagement.Tests
FakeTaskFactory taskFactory; FakeTaskFactory taskFactory;
FakeRegisteredPackageRepositories registeredPackageRepositories; FakeRegisteredPackageRepositories registeredPackageRepositories;
ExceptionThrowingPackageManagementSolution exceptionThrowingSolution; ExceptionThrowingPackageManagementSolution exceptionThrowingSolution;
FakePackageViewModelFactory packageViewModelFactory;
FakePackageManagementEvents fakePackageManagementEvents;
UpdatedPackageViewModelFactory updatedPackageViewModelFactory;
void CreateViewModel() void CreateViewModel()
{ {
@ -42,11 +48,40 @@ namespace PackageManagement.Tests
CreateViewModel(solution, registeredPackageRepositories); CreateViewModel(solution, registeredPackageRepositories);
} }
void CreateViewModel(FakePackageActionRunner actionRunner)
{
CreateSolution();
CreateRegisteredPackageRepositories();
CreateViewModel(solution, registeredPackageRepositories, actionRunner);
}
void CreateViewModel(FakePackageManagementSolution solution, FakeRegisteredPackageRepositories registeredPackageRepositories) void CreateViewModel(FakePackageManagementSolution solution, FakeRegisteredPackageRepositories registeredPackageRepositories)
{
packageViewModelFactory = new FakePackageViewModelFactory { FakeSolution = solution };
CreateViewModel(solution, registeredPackageRepositories, packageViewModelFactory);
}
void CreateViewModel(
FakePackageManagementSolution solution,
FakeRegisteredPackageRepositories registeredPackageRepositories,
FakePackageActionRunner actionRunner)
{
packageViewModelFactory = new FakePackageViewModelFactory {
FakeSolution = solution,
FakeActionRunner = actionRunner
};
CreateViewModel(solution, registeredPackageRepositories, packageViewModelFactory);
}
void CreateViewModel(
FakePackageManagementSolution solution,
FakeRegisteredPackageRepositories registeredPackageRepositories,
FakePackageViewModelFactory packageViewModelFactory)
{ {
taskFactory = new FakeTaskFactory(); taskFactory = new FakeTaskFactory();
var packageViewModelFactory = new FakePackageViewModelFactory(); this.packageViewModelFactory = packageViewModelFactory;
var updatedPackageViewModelFactory = new UpdatedPackageViewModelFactory(packageViewModelFactory); fakePackageManagementEvents = packageViewModelFactory.FakePackageManagementEvents;
updatedPackageViewModelFactory = new UpdatedPackageViewModelFactory(packageViewModelFactory);
viewModel = new UpdatedPackagesViewModel( viewModel = new UpdatedPackagesViewModel(
solution, solution,
registeredPackageRepositories, registeredPackageRepositories,
@ -78,14 +113,24 @@ namespace PackageManagement.Tests
FakePackage AddPackageToLocalRepository(string version) FakePackage AddPackageToLocalRepository(string version)
{ {
FakePackage package = FakePackage.CreatePackageWithVersion(version); return AddPackageToLocalRepository("Test", version);
}
FakePackage AddPackageToLocalRepository(string id, string version)
{
FakePackage package = FakePackage.CreatePackageWithVersion(id, version);
solution.FakeProjectToReturnFromGetProject.FakePackages.Add(package); solution.FakeProjectToReturnFromGetProject.FakePackages.Add(package);
return package; return package;
} }
FakePackage AddPackageToActiveRepository(string version) FakePackage AddPackageToActiveRepository(string version)
{ {
return registeredPackageRepositories.AddFakePackageWithVersionToActiveRepository(version); return AddPackageToActiveRepository("Test", version);
}
FakePackage AddPackageToActiveRepository(string id, string version)
{
return registeredPackageRepositories.AddFakePackageWithVersionToActiveRepository(id, version);
} }
FakePackage AddPackageToSolution(string version) FakePackage AddPackageToSolution(string version)
@ -118,6 +163,28 @@ namespace PackageManagement.Tests
registeredPackageRepositories.AddPackageSources(sources); registeredPackageRepositories.AddPackageSources(sources);
} }
UpdatePackagesAction GetUpdatePackagesActionRun()
{
return packageViewModelFactory
.FakeActionRunner
.ActionPassedToRun as UpdatePackagesAction;
}
void RunUpdateAllPackagesCommand()
{
viewModel.UpdateAllPackagesCommand.Execute(null);
}
void ViewModelHasTwoPackagesThatCanBeUpdatedAfterReadingPackages()
{
AddPackageToLocalRepository("First", "1.0.0.0");
AddPackageToActiveRepository("First", "1.1.0.0");
AddPackageToLocalRepository("Second", "1.0.0.0");
AddPackageToActiveRepository("Second", "1.1.0.0");
viewModel.ReadPackages();
CompleteReadPackagesTask();
}
[Test] [Test]
public void ReadPackages_OneNewerPackageVersionAvailable_NewerPackageVersionDisplayed() public void ReadPackages_OneNewerPackageVersionAvailable_NewerPackageVersionDisplayed()
{ {
@ -259,5 +326,183 @@ namespace PackageManagement.Tests
Assert.IsTrue(viewModel.ShowPackageSources); Assert.IsTrue(viewModel.ShowPackageSources);
} }
[Test]
public void ShowUpdateAllPackages_DefaultValue_ReturnsTrue()
{
CreateViewModel();
bool result = viewModel.ShowUpdateAllPackages;
Assert.IsTrue(result);
}
[Test]
public void IsUpdateAllPackagesEnabled_NoPackages_ReturnsFalse()
{
CreateViewModel();
bool enabled = viewModel.IsUpdateAllPackagesEnabled;
Assert.IsFalse(enabled);
}
[Test]
public void IsUpdateAllPackagesEnabled_TwoNewerPackagesAvailable_ReturnsTrue()
{
CreateViewModel();
ViewModelHasTwoPackagesThatCanBeUpdatedAfterReadingPackages();
bool enabled = viewModel.IsUpdateAllPackagesEnabled;
Assert.IsTrue(enabled);
}
[Test]
public void IsUpdateAllPackagesEnabled_OneNewerPackageAvailable_ReturnsFalse()
{
CreateViewModel();
AddPackageToLocalRepository("First", "1.0.0.0");
AddPackageToActiveRepository("First", "1.1.0.0");
viewModel.ReadPackages();
CompleteReadPackagesTask();
bool enabled = viewModel.IsUpdateAllPackagesEnabled;
Assert.IsFalse(enabled);
}
[Test]
public void UpdateAllPackagesCommand_TwoPackagesToBeUpdated_BothPackagesUpdated()
{
CreateViewModel();
AddPackageToLocalRepository("First", "1.0.0.0");
FakePackage firstUpdatedPackage = AddPackageToActiveRepository("First", "1.1.0.0");
AddPackageToLocalRepository("Second", "1.0.0.0");
FakePackage secondUpdatedPackage = AddPackageToActiveRepository("Second", "1.1.0.0");
viewModel.ReadPackages();
CompleteReadPackagesTask();
RunUpdateAllPackagesCommand();
UpdatePackagesAction action = GetUpdatePackagesActionRun();
IPackage firstPackage = action.Packages.FirstOrDefault(p => p.Id == "First");
IPackage secondPackage = action.Packages.FirstOrDefault(p => p.Id == "Second");
Assert.AreEqual(firstUpdatedPackage, firstPackage);
Assert.AreEqual(secondUpdatedPackage, secondPackage);
Assert.AreEqual(2, action.Packages.Count());
}
[Test]
public void UpdateAllPackagesCommand_ExceptionThrownWhenUpdatingAllPackages_ExceptionReported()
{
var actionRunner = new ExceptionThrowingPackageActionRunner();
CreateViewModel(actionRunner);
ViewModelHasTwoPackagesThatCanBeUpdatedAfterReadingPackages();
var exception = new Exception("test");
actionRunner.ExceptionToThrow = exception;
RunUpdateAllPackagesCommand();
Assert.AreEqual(exception, packageViewModelFactory.FakePackageManagementEvents.ExceptionPassedToOnPackageOperationError);
}
[Test]
public void UpdateAllPackagesCommand_ExceptionThrownWhenUpdatingAllPackages_ExceptionLogged()
{
var actionRunner = new ExceptionThrowingPackageActionRunner();
CreateViewModel(actionRunner);
ViewModelHasTwoPackagesThatCanBeUpdatedAfterReadingPackages();
var exception = new Exception("Exception error message");
actionRunner.ExceptionToThrow = exception;
RunUpdateAllPackagesCommand();
string actualMessage = fakePackageManagementEvents.FormattedStringPassedToOnPackageOperationMessageLogged;
bool containsExceptionErrorMessage = actualMessage.Contains("Exception error message");
Assert.IsTrue(containsExceptionErrorMessage, actualMessage);
Assert.AreEqual(MessageLevel.Error, fakePackageManagementEvents.MessageLevelPassedToOnPackageOperationMessageLogged);
}
[Test]
public void UpdateAllPackagesCommand_PackagesUpdated_ProjectCreatedUsingSourcePackageRepository()
{
CreateViewModel();
ViewModelHasTwoPackagesThatCanBeUpdatedAfterReadingPackages();
var package = viewModel.PackageViewModels[0].GetPackage() as IPackageFromRepository;
solution.RepositoryPassedToGetProject = null;
RunUpdateAllPackagesCommand();
Assert.AreEqual(package.Repository, solution.RepositoryPassedToGetProject);
}
[Test]
public void UpdateAllPackagesCommand_PackagesUpdated_UpdatePackagesActionCreatedFromProject()
{
CreateViewModel();
ViewModelHasTwoPackagesThatCanBeUpdatedAfterReadingPackages();
RunUpdateAllPackagesCommand();
UpdatePackagesAction action = GetUpdatePackagesActionRun();
FakePackageManagementProject project = solution.FakeProjectToReturnFromGetProject;
UpdatePackagesAction expectedAction = project.UpdatePackagesActionsCreated.FirstOrDefault();
Assert.AreEqual(expectedAction, action);
}
[Test]
public void UpdateAllPackagesCommand_CheckLoggerUsed_PackageViewModelLoggerUsedWhenResolvingPackageOperations()
{
CreateViewModel();
ViewModelHasTwoPackagesThatCanBeUpdatedAfterReadingPackages();
RunUpdateAllPackagesCommand();
ILogger expectedLogger = updatedPackageViewModelFactory.Logger;
ILogger actualLogger = solution.FakeProjectToReturnFromGetProject.Logger;
Assert.AreEqual(expectedLogger, actualLogger);
}
[Test]
public void UpdateAllPackagesCommand_PackageOperations_CreatedFromProjectUsingPackagesAndUpdatePackagesAction()
{
CreateViewModel();
ViewModelHasTwoPackagesThatCanBeUpdatedAfterReadingPackages();
RunUpdateAllPackagesCommand();
UpdatePackagesAction action = GetUpdatePackagesActionRun();
FakePackageManagementProject project = solution.FakeProjectToReturnFromGetProject;
Assert.AreEqual(action, project.UpdatePackagesActionPassedToGetUpdatePackagesOperations);
}
[Test]
public void UpdateAllPackagesCommand_PackageOperations_ActionHasPackageOperationsReturnedFromProject()
{
CreateViewModel();
ViewModelHasTwoPackagesThatCanBeUpdatedAfterReadingPackages();
FakePackageManagementProject project = solution.FakeProjectToReturnFromGetProject;
List<PackageOperation> operations = PackageOperationHelper.CreateListWithOneInstallOperationWithFile("readme.txt");
project.PackageOperationsToReturnFromGetUpdatePackagesOperations = operations;
RunUpdateAllPackagesCommand();
UpdatePackagesAction action = GetUpdatePackagesActionRun();
CollectionAssert.AreEqual(operations, action.Operations);
}
[Test]
public void UpdateAllPackagesCommand_PackageOperations_PackagesUsedToDeterminePackageOperations()
{
CreateViewModel();
ViewModelHasTwoPackagesThatCanBeUpdatedAfterReadingPackages();
FakePackageManagementProject project = solution.FakeProjectToReturnFromGetProject;
List<FakePackage> expectedPackages = registeredPackageRepositories.FakeActiveRepository.FakePackages;
RunUpdateAllPackagesCommand();
CollectionAssert.AreEqual(expectedPackages, project.PackagesOnUpdatePackagesActionPassedToGetUpdatePackagesOperations);
}
} }
} }

Loading…
Cancel
Save