Work on infrastructure for AddInSetup unit testing.

src/AddIns/Misc/AddInManager2/AddInManager2.Tests/AddInManager2.Tests.csproj

@@ -71,13 +71,20 @@
     <Compile Include="AddInSetupTests.cs" />
     <Compile Include="Configuration\AssemblyInfo.cs" />
     <Compile Include="Fakes\FakeAddInSetup.cs" />
+    <Compile Include="Fakes\FakeAddInTree.cs" />
+    <Compile Include="Fakes\FakeCorePackageRepository.cs" />
     <Compile Include="Fakes\FakeNuGetCorePackageManager.cs" />
     <Compile Include="Fakes\FakeNuGetPackageManager.cs" />
+    <Compile Include="Fakes\FakePackage.cs" />
+    <Compile Include="Fakes\FakePackageOperationResolver.cs" />
     <Compile Include="Fakes\FakePackageRepositories.cs" />
     <Compile Include="Fakes\FakeAddInManagerSettings.cs" />
+    <Compile Include="Fakes\FakeSDAddInManagement.cs" />
     <Compile Include="PackageRepositoriesTests.cs" />
   </ItemGroup>
-  <ItemGroup />
+  <ItemGroup>
+    <Folder Include="TestResources" />
+  </ItemGroup>
   <ItemGroup>
     <ProjectReference Include="..\..\..\..\Libraries\NRefactory\ICSharpCode.NRefactory\ICSharpCode.NRefactory.csproj">
       <Project>{3B2A5653-EC97-4001-BB9B-D90F1AF2C371}</Project>
@@ -105,6 +112,7 @@
       <Link>SharpDevelop.exe</Link>
       <CopyToOutputDirectory>Always</CopyToOutputDirectory>
     </None>
+    <Resource Include="TestResources\AddInManager2Test.addin" />
   </ItemGroup>
   <Import Project="$(MSBuildBinPath)\Microsoft.CSharp.Targets" />
 </Project>

src/AddIns/Misc/AddInManager2/AddInManager2.Tests/AddInSetupTests.cs

@@ -2,9 +2,12 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using System.IO;
+using System.Reflection;
 using ICSharpCode.AddInManager2;
 using ICSharpCode.AddInManager2.Model;
 using ICSharpCode.AddInManager2.Tests.Fakes;
+using ICSharpCode.Core;
 using ICSharpCode.SharpDevelop;
 using NuGet;
 using NUnit.Framework;
@@ -15,8 +18,50 @@ namespace ICSharpCode.AddInManager2.Tests
 	[Category("AddInSetupTests")]
 	public class AddInSetupTests
 	{
+		AddInManagerEvents _events;
+		FakeNuGetPackageManager _nuGet;
+		FakeSDAddInManagement _sdAddInManagement;
+		AddInSetup _addInSetup;
+		
 		public AddInSetupTests()
 		{
 		}
+		
+		private void PrepareAddInSetup()
+		{
+			_events = new AddInManagerEvents();
+			_nuGet = new FakeNuGetPackageManager();
+			_sdAddInManagement = new FakeSDAddInManagement();
+			_addInSetup = new AddInSetup(_events, _nuGet, _sdAddInManagement);
+		}
+		
+		private AddIn CreateAddIn()
+		{
+			// Create AddIn object from an *.addin file available in this assembly's resources
+			FakeAddInTree _addInTree = new FakeAddInTree();
+			Stream resourceStream =
+				Assembly.GetExecutingAssembly().GetManifestResourceStream("ICSharpCode.AddInManager2.Tests.TestResources.AddInManager2Test.addin");
+			using (StreamReader streamReader = new StreamReader(resourceStream))
+			{
+				return AddIn.Load(_addInTree, streamReader);
+			}
+		}
+		
+		[Test, Description("")]
+		public void InstallValidAddIn()
+		{
+			AddIn addIn = CreateAddIn();
+			
+			// Create a fake package
+			FakePackage package = new FakePackage()
+			{
+				Id = addIn.Name,
+				Version = new SemanticVersion(addIn.Version)
+			};
+			
+			PrepareAddInSetup();
+			
+			
+		}
 	}
 }

src/AddIns/Misc/AddInManager2/AddInManager2.Tests/Fakes/FakeAddInTree.cs

@@ -0,0 +1,68 @@
+// 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.Concurrent;
+using System.Collections.Generic;
+using ICSharpCode.Core;
+
+namespace ICSharpCode.AddInManager2.Tests.Fakes
+{
+	public class FakeAddInTree : IAddInTree
+	{
+		private List<AddIn> _addIns;
+		private ConcurrentDictionary<string, IDoozer> _doozers;
+		private ConcurrentDictionary<string, IConditionEvaluator> _conditionEvaluators;
+		
+		public FakeAddInTree()
+		{
+			_addIns = new List<AddIn>();
+			_doozers = new ConcurrentDictionary<string, IDoozer>();
+			_conditionEvaluators = new ConcurrentDictionary<string, IConditionEvaluator>();
+		}
+		
+		public System.Collections.Generic.IReadOnlyList<AddIn> AddIns
+		{
+			get
+			{
+				return _addIns.AsReadOnly();
+			}
+		}
+		
+		public System.Collections.Concurrent.ConcurrentDictionary<string, IDoozer> Doozers
+		{
+			get
+			{
+				return _doozers;
+			}
+		}
+		
+		public System.Collections.Concurrent.ConcurrentDictionary<string, IConditionEvaluator> ConditionEvaluators
+		{
+			get
+			{
+				return _conditionEvaluators;
+			}
+		}
+		
+		public System.Collections.Generic.IReadOnlyList<T> BuildItems<T>(string path, object parameter, bool throwOnNotFound)
+		{
+			return new List<T>().AsReadOnly();
+		}
+		
+		public object BuildItem(string path, object parameter)
+		{
+			return null;
+		}
+		
+		public object BuildItem(string path, object parameter, System.Collections.Generic.IEnumerable<ICondition> additionalConditions)
+		{
+			return null;
+		}
+		
+		public AddInTreeNode GetTreeNode(string path, bool throwOnNotFound)
+		{
+			return null;
+		}
+	}
+}

src/AddIns/Misc/AddInManager2/AddInManager2.Tests/Fakes/FakeCorePackageRepository.cs

@@ -0,0 +1,67 @@
+// 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.Linq;
+using NuGet;
+
+namespace ICSharpCode.AddInManager2.Tests.Fakes
+{
+	public class FakeCorePackageRepository : IPackageRepository
+	{
+		public FakeCorePackageRepository()
+		{
+		}
+		
+		public string Source
+		{
+			get;
+			set;
+		}
+		
+		public bool SupportsPrereleasePackages
+		{
+			get;
+			set;
+		}
+		
+		public IQueryable<IPackage> ReturnedPackages
+		{
+			get;
+			set;
+		}
+		
+		public System.Linq.IQueryable<IPackage> GetPackages()
+		{
+			return ReturnedPackages;
+		}
+		
+		public void AddPackage(IPackage package)
+		{
+			if (AddPackageCallback != null)
+			{
+				AddPackageCallback(package);
+			}
+		}
+		
+		public Action<IPackage> AddPackageCallback
+		{
+			get;
+			set;
+		}
+		
+		public void RemovePackage(IPackage package)
+		{
+			if (RemovePackageCallback != null)
+			{
+				RemovePackageCallback(package);
+			}
+		}
+		
+		public Action<IPackage> RemovePackageCallback
+		{
+			get;
+			set;
+		}
+	}
+}

src/AddIns/Misc/AddInManager2/AddInManager2.Tests/Fakes/FakeNuGetCorePackageManager.cs

@@ -2,12 +2,10 @@
 // This code is distributed under the GNU LGPL (for details please see \doc\license.txt)
 
 using System;
+using NuGet;
 
 namespace ICSharpCode.AddInManager2.Tests.Fakes
 {
-	/// <summary>
-	/// Description of FakeNuGetCorePackageManager.
-	/// </summary>
 	public class FakeNuGetCorePackageManager : NuGet.IPackageManager
 	{
 		public FakeNuGetCorePackageManager()
@@ -24,85 +22,132 @@ namespace ICSharpCode.AddInManager2.Tests.Fakes
 		
 		public NuGet.IFileSystem FileSystem
 		{
-			get
-			{
-				throw new NotImplementedException();
-			}
-			set
-			{
-				throw new NotImplementedException();
-			}
+			get;
+			set;
 		}
 		
 		public NuGet.IPackageRepository LocalRepository
 		{
-			get
-			{
-				throw new NotImplementedException();
-			}
+			get;
+			set;
 		}
 		
 		public NuGet.ILogger Logger
 		{
-			get
-			{
-				throw new NotImplementedException();
-			}
-			set
-			{
-				throw new NotImplementedException();
-			}
+			get;
+			set;
 		}
 		
 		public NuGet.IPackageRepository SourceRepository
 		{
-			get
-			{
-				throw new NotImplementedException();
-			}
+			get;
+			set;
 		}
 		
 		public NuGet.IPackagePathResolver PathResolver
 		{
 			get
 			{
-				throw new NotImplementedException();
+				return null;
 			}
 		}
 		
+		public Action<IPackage, bool, bool> InstallPackageCallback
+		{
+			get;
+			set;
+		}
+		
+		public Action<string, SemanticVersion, bool, bool> InstallPackageWithVersionCallback
+		{
+			get;
+			set;
+		}
+		
 		public void InstallPackage(NuGet.IPackage package, bool ignoreDependencies, bool allowPrereleaseVersions)
 		{
-			throw new NotImplementedException();
+			if (InstallPackageCallback != null)
+			{
+				InstallPackageCallback(package, ignoreDependencies, allowPrereleaseVersions);
+			}
 		}
 		
 		public void InstallPackage(string packageId, NuGet.SemanticVersion version, bool ignoreDependencies, bool allowPrereleaseVersions)
 		{
-			throw new NotImplementedException();
+			if (InstallPackageWithVersionCallback != null)
+			{
+				InstallPackageWithVersionCallback(packageId, version, ignoreDependencies, allowPrereleaseVersions);
+			}
+		}
+		
+		public Action<IPackage, bool, bool> UpdatePackageCallback
+		{
+			get;
+			set;
 		}
 		
 		public void UpdatePackage(NuGet.IPackage newPackage, bool updateDependencies, bool allowPrereleaseVersions)
 		{
-			throw new NotImplementedException();
+			if (UpdatePackageCallback != null)
+			{
+				UpdatePackageCallback(newPackage, updateDependencies, allowPrereleaseVersions);
+			}
+		}
+		
+		public Action<string, SemanticVersion, bool, bool> UpdatePackageWithVersionCallback
+		{
+			get;
+			set;
 		}
 		
 		public void UpdatePackage(string packageId, NuGet.SemanticVersion version, bool updateDependencies, bool allowPrereleaseVersions)
 		{
-			throw new NotImplementedException();
+			if (UpdatePackageWithVersionCallback != null)
+			{
+				UpdatePackageWithVersionCallback(packageId, version, updateDependencies, allowPrereleaseVersions);
+			}
+		}
+		
+		public Action<string, IVersionSpec, bool, bool> UpdatePackageWithVersionSpecCallback
+		{
+			get;
+			set;
 		}
 		
 		public void UpdatePackage(string packageId, NuGet.IVersionSpec versionSpec, bool updateDependencies, bool allowPrereleaseVersions)
 		{
-			throw new NotImplementedException();
+			if (UpdatePackageWithVersionSpecCallback != null)
+			{
+				UpdatePackageWithVersionSpecCallback(packageId, versionSpec, updateDependencies, allowPrereleaseVersions);
+			}
+		}
+		
+		public Action<IPackage, bool, bool> UninstallPackageCallback
+		{
+			get;
+			set;
 		}
 		
 		public void UninstallPackage(NuGet.IPackage package, bool forceRemove, bool removeDependencies)
 		{
-			throw new NotImplementedException();
+			if (UninstallPackageCallback != null)
+			{
+				UninstallPackageCallback(package, forceRemove, removeDependencies);
+			}
+		}
+		
+		public Action<string, SemanticVersion, bool, bool> UninstallPackageWithVersionCallback
+		{
+			get;
+			set;
 		}
 		
 		public void UninstallPackage(string packageId, NuGet.SemanticVersion version, bool forceRemove, bool removeDependencies)
 		{
-			throw new NotImplementedException();
+			if (UninstallPackageWithVersionCallback != null)
+			{
+				UninstallPackageWithVersionCallback(packageId, version, forceRemove, removeDependencies);
+			}
 		}
 	}
 }

src/AddIns/Misc/AddInManager2/AddInManager2.Tests/Fakes/FakeNuGetPackageManager.cs

@@ -7,40 +7,63 @@ using System.Collections.Generic;
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using NuGet;
 
 namespace ICSharpCode.AddInManager2.Tests.Fakes
 {
     public class FakeNuGetPackageManager : INuGetPackageManager
     {
+    	private FakeNuGetCorePackageManager _corePackageManager;
+    	private FakePackageOperationResolver _packageOperationResolver;
+    	
+    	public FakeNuGetPackageManager()
+    	{
+    		_corePackageManager = new FakeNuGetCorePackageManager();
+    		_packageOperationResolver = new FakePackageOperationResolver();
+    	}
+    	
         public NuGet.IPackageManager Packages
         {
             get
             {
-                throw new NotImplementedException();
+                return _corePackageManager;
             }
         }
 
         public string PackageOutputDirectory
         {
-            get
-            {
-                throw new NotImplementedException();
-            }
+            get;
+            set;
+        }
+        
+        public bool FakePackageContainsAddIn
+        {
+        	get;
+        	set;
         }
 
         public bool PackageContainsAddIn(NuGet.IPackage package)
         {
-            throw new NotImplementedException();
+            return FakePackageContainsAddIn;
         }
 
         public NuGet.IPackageOperationResolver CreateInstallPackageOperationResolver(bool allowPrereleaseVersions)
         {
-            throw new NotImplementedException();
+            return _packageOperationResolver;
         }
 
         public void ExecuteOperation(NuGet.PackageOperation operation)
         {
-            throw new NotImplementedException();
+            if (ExecuteOperationCallback != null)
+            {
+            	ExecuteOperationCallback(operation);
+            }
         }
+        
+       	public Action<PackageOperation> ExecuteOperationCallback
+       	{
+       		get;
+       		set;
+       	}
     }
 }

src/AddIns/Misc/AddInManager2/AddInManager2.Tests/Fakes/FakePackage.cs

@@ -0,0 +1,174 @@
+// 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 NuGet;
+
+namespace ICSharpCode.AddInManager2.Tests.Fakes
+{
+	public class FakePackage : IPackage
+	{
+		public FakePackage()
+		{
+		}
+		
+		public bool IsAbsoluteLatestVersion
+		{
+			get;
+			set;
+		}
+		
+		public bool IsLatestVersion
+		{
+			get;
+			set;
+		}
+		
+		public bool Listed
+		{
+			get;
+			set;
+		}
+		
+		public Nullable<DateTimeOffset> Published
+		{
+			get;
+			set;
+		}
+		
+		public System.Collections.Generic.IEnumerable<IPackageAssemblyReference> AssemblyReferences
+		{
+			get;
+			set;
+		}
+		
+		public string Id
+		{
+			get;
+			set;
+		}
+		
+		public SemanticVersion Version
+		{
+			get;
+			set;
+		}
+		
+		public string Title
+		{
+			get;
+			set;
+		}
+		
+		public System.Collections.Generic.IEnumerable<string> Authors
+		{
+			get;
+			set;
+		}
+		
+		public System.Collections.Generic.IEnumerable<string> Owners
+		{
+			get;
+			set;
+		}
+		
+		public Uri IconUrl
+		{
+			get;
+			set;
+		}
+		
+		public Uri LicenseUrl
+		{
+			get;
+			set;
+		}
+		
+		public Uri ProjectUrl
+		{
+			get;
+			set;
+		}
+		
+		public bool RequireLicenseAcceptance
+		{
+			get;
+			set;
+		}
+		
+		public string Description
+		{
+			get;
+			set;
+		}
+		
+		public string Summary
+		{
+			get;
+			set;
+		}
+		
+		public string ReleaseNotes
+		{
+			get;
+			set;
+		}
+		
+		public string Language
+		{
+			get;
+			set;
+		}
+		
+		public string Tags
+		{
+			get;
+			set;
+		}
+		
+		public string Copyright
+		{
+			get;
+			set;
+		}
+		
+		public System.Collections.Generic.IEnumerable<FrameworkAssemblyReference> FrameworkAssemblies
+		{
+			get;
+			set;
+		}
+		
+		public System.Collections.Generic.IEnumerable<PackageDependencySet> DependencySets
+		{
+			get;
+			set;
+		}
+		
+		public Uri ReportAbuseUrl
+		{
+			get;
+			set;
+		}
+		
+		public int DownloadCount
+		{
+			get;
+			set;
+		}
+		
+		public System.Collections.Generic.IEnumerable<IPackageFile> GetFiles()
+		{
+			return null;
+		}
+		
+		public System.Collections.Generic.IEnumerable<System.Runtime.Versioning.FrameworkName> GetSupportedFrameworks()
+		{
+			return null;
+		}
+		
+		public System.IO.Stream GetStream()
+		{
+			return null;
+		}
+	}
+}

src/AddIns/Misc/AddInManager2/AddInManager2.Tests/Fakes/FakePackageOperationResolver.cs

@@ -0,0 +1,34 @@
+// 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 NuGet;
+
+namespace ICSharpCode.AddInManager2.Tests.Fakes
+{
+	public class FakePackageOperationResolver : IPackageOperationResolver
+	{
+		public FakePackageOperationResolver()
+		{
+		}
+		
+		public System.Collections.Generic.IEnumerable<PackageOperation> ResolveOperations(IPackage package)
+		{
+			if (ResolveOperationsCallback != null)
+			{
+				return ResolveOperationsCallback(package);
+			}
+			else
+			{
+				return null;
+			}
+		}
+		
+		public Func<IPackage, IEnumerable<PackageOperation>> ResolveOperationsCallback
+		{
+			get;
+			set;
+		}
+	}
+}

src/AddIns/Misc/AddInManager2/AddInManager2.Tests/Fakes/FakeSDAddInManagement.cs

@@ -0,0 +1,156 @@
+// 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.AddInManager2.Model;
+using ICSharpCode.Core;
+
+namespace ICSharpCode.AddInManager2.Tests.Fakes
+{
+	public class FakeSDAddInManagement : ISDAddInManagement
+	{
+		private List<AddIn> _registeredAddIns;
+		private List<string> _addInsMarkedForRemoval;
+		private List<AddIn> _addedExternalAddIns;
+		private List<AddIn> _removedExternalAddIns;
+		
+		public FakeSDAddInManagement()
+		{
+			_registeredAddIns = new List<AddIn>();
+			_addInsMarkedForRemoval = new List<string>();
+			_addedExternalAddIns = new List<AddIn>();
+			_removedExternalAddIns = new List<AddIn>();
+		}
+		
+		public List<AddIn> RegisteredAddIns
+		{
+			get
+			{
+				return _registeredAddIns;
+			}
+		}
+		
+		public List<string> AddInsMarkedForRemoval
+		{
+			get
+			{
+				return _addInsMarkedForRemoval;
+			}
+		}
+		
+		public List<AddIn> AddedExternalAddIns
+		{
+			get
+			{
+				return _addedExternalAddIns;
+			}
+		}
+		
+		public List<AddIn> RemovedExternalAddIns
+		{
+			get
+			{
+				return _removedExternalAddIns;
+			}
+		}
+		
+		public AddIn AddInToLoad
+		{
+			get;
+			set;
+		}
+		
+		public System.Collections.Generic.IReadOnlyList<ICSharpCode.Core.AddIn> AddIns
+		{
+			get
+			{
+				return _registeredAddIns.AsReadOnly();
+			}
+		}
+		
+		public string TempInstallDirectory
+		{
+			get;
+			set;
+		}
+		
+		public string UserInstallDirectory
+		{
+			get;
+			set;
+		}
+		
+		public void AddToTree(ICSharpCode.Core.AddIn addIn)
+		{
+			if (addIn != null)
+			{
+				_registeredAddIns.Add(addIn);
+			}
+		}
+		
+		public void AbortRemoveUserAddInOnNextStart(string identity)
+		{
+			if (identity != null)
+			{
+				_addInsMarkedForRemoval.Remove(identity);
+			}
+		}
+		
+		public void Enable(System.Collections.Generic.IList<ICSharpCode.Core.AddIn> addIns)
+		{
+			if (addIns != null)
+			{
+				foreach (var addIn in addIns)
+				{
+					addIn.Enabled = true;
+				}
+			}
+		}
+		
+		public void Disable(System.Collections.Generic.IList<ICSharpCode.Core.AddIn> addIns)
+		{
+			if (addIns != null)
+			{
+				foreach (var addIn in addIns)
+				{
+					addIn.Enabled = false;
+				}
+			}
+		}
+		
+		public void RemoveExternalAddIns(System.Collections.Generic.IList<ICSharpCode.Core.AddIn> addIns)
+		{
+			if (addIns != null)
+			{
+				_removedExternalAddIns.AddRange(addIns);
+			}
+		}
+		
+		public void RemoveUserAddInOnNextStart(string identity)
+		{
+			if (identity != null)
+			{
+				_addInsMarkedForRemoval.Add(identity);
+			}
+		}
+		
+		public ICSharpCode.Core.AddIn Load(System.IO.TextReader textReader)
+		{
+			return AddInToLoad;
+		}
+		
+		public ICSharpCode.Core.AddIn Load(string fileName)
+		{
+			return AddInToLoad;
+		}
+		
+		public void AddExternalAddIns(System.Collections.Generic.IList<ICSharpCode.Core.AddIn> addIns)
+		{
+			if (addIns != null)
+			{
+				_addedExternalAddIns.AddRange(addIns);
+			}
+		}
+	}
+}

src/AddIns/Misc/AddInManager2/AddInManager2.Tests/TestResources/AddInManager2Test.addin

@@ -0,0 +1,13 @@
+<AddIn name="AddInManager Test"
+       author ="Andreas Weizel"
+       description="Allows to test the AddIn that allows installing and updating SharpDevelop AddIns.">
+	
+	<Manifest>
+		<Identity name="ICSharpCode.AddInManager2Test" version="@ICSharpCode.AddInManager2Test.dll" />
+	</Manifest>
+	
+	<Runtime>
+		<Import assembly="ICSharpCode.AddInManager2Test.dll"/>
+		<Import assembly="ICSharpCode.AddInManager2.dll"/>
+	</Runtime>
+</AddIn>