Add tests for EnvDTE.CodeInterface.AddFunction()

src/AddIns/Misc/PackageManagement/Project/Src/EnvDTE/CodeInterface.cs

@@ -18,10 +18,7 @@
 
 using System;
 using System.Linq;
-using System.Text;
 using ICSharpCode.NRefactory.TypeSystem;
-using ICSharpCode.NRefactory.TypeSystem.Implementation;
-using ICSharpCode.SharpDevelop.Dom;
 
 namespace ICSharpCode.PackageManagement.EnvDTE
 {
@@ -54,13 +51,7 @@ namespace ICSharpCode.PackageManagement.EnvDTE
 		IType GetMethodReturnType(string typeName)
 		{
 			var fullTypeName = new FullTypeName(typeName);
-			
-			IType type = typeDefinition.Compilation.FindType(fullTypeName);
-			if (type != null) {
-				return type;
-			}
-			
-			return new UnknownType(fullTypeName);
+			return typeDefinition.Compilation.FindType(fullTypeName);
 		}
 		
 		void ReloadTypeDefinition()

src/AddIns/Misc/PackageManagement/Project/Src/PackageManagementViewModels.cs

@@ -27,7 +27,6 @@ namespace ICSharpCode.PackageManagement
 	{
 		ManagePackagesViewModel managePackagesViewModel;
 		RegisteredPackageSourcesViewModel registeredPackageSourcesViewModel;
-		RegisteredPackageSourcesViewModel registeredProjectTemplatePackageSourcesViewModel;
 		PackageManagementOptionsViewModel packageManagementOptionsViewModel;
 		PackageManagementConsoleViewModel packageManagementConsoleViewModel;
 		IPackageManagementSolution solution;

src/AddIns/Misc/PackageManagement/Test/Src/EnvDTE/CodeInterfaceTests.cs

@@ -21,6 +21,7 @@ using System.Linq;
 using ICSharpCode.NRefactory.TypeSystem;
 using ICSharpCode.PackageManagement.EnvDTE;
 using NUnit.Framework;
+using Rhino.Mocks;
 
 namespace PackageManagement.Tests.EnvDTE
 {
@@ -28,12 +29,41 @@ namespace PackageManagement.Tests.EnvDTE
 	public class CodeInterfaceTests : CodeModelTestBase
 	{
 		CodeInterface codeInterface;
+		ITypeDefinition interfaceTypeDefinition;
 		
-		void CreateInterface(string code)
+		ITypeDefinition addMethodAtStartTypeDef;
+		Accessibility addMethodAtStartAccess;
+		IType addMethodAtStartReturnType;
+		string addMethodAtStartName;
+		
+		void UpdateCode(string code, string fileName = @"c:\projects\MyProject\interface.cs")
+		{
+			CreateCompilationForUpdatedCodeFile(fileName, code);
+		}
+		
+		void CreateInterface(string code, string fileName = @"c:\projects\MyProject\interface.cs")
+		{
+			CreateCodeModel();
+			AddCodeFile(fileName, code);
+			interfaceTypeDefinition = assemblyModel.TopLevelTypeDefinitions.First().Resolve();
+			codeInterface = new CodeInterface(codeModelContext, interfaceTypeDefinition);
+		}
+		
+		void CaptureCodeGeneratorAddMethodAtStartParameters()
 		{
-			AddCodeFile("interface.cs", code);
-			ITypeDefinition typeDefinition = assemblyModel.TopLevelTypeDefinitions.First().Resolve();
-			codeInterface = new CodeInterface(codeModelContext, typeDefinition);
+			codeGenerator
+				.Stub(generator => generator.AddMethodAtStart(
+					Arg<ITypeDefinition>.Is.Anything,
+					Arg<Accessibility>.Is.Anything,
+					Arg<IType>.Is.Anything,
+					Arg<string>.Is.Anything))
+				.Callback<ITypeDefinition, Accessibility, IType, string>((typeDef, access, returnType, name) => {
+					addMethodAtStartTypeDef = typeDef;
+					addMethodAtStartAccess = access;
+					addMethodAtStartReturnType = returnType;
+					addMethodAtStartName = name;
+					return true;
+				});
 		}
 		
 		[Test]
@@ -45,5 +75,97 @@ namespace PackageManagement.Tests.EnvDTE
 			
 			Assert.AreEqual(global::EnvDTE.vsCMElement.vsCMElementInterface, kind);
 		}
+		
+		[Test]
+		public void AddFunction_PublicFunctionReturningSystemInt32_AddsPublicFunctionWithCodeConverter()
+		{
+			CreateInterface ("interface MyInterface {}");
+			var kind = global::EnvDTE.vsCMFunction.vsCMFunctionFunction;
+			var access = global::EnvDTE.vsCMAccess.vsCMAccessPublic;
+			CaptureCodeGeneratorAddMethodAtStartParameters();
+			string newCode = 
+				"interface MyInterface {\r\n" +
+				"    System.Int32 MyMethod();\r\n" +
+				"}";
+			UpdateCode(newCode);
+			
+			codeInterface.AddFunction("MyMethod", kind, "System.Int32", null, access);
+			
+			Assert.AreEqual(Accessibility.Public, addMethodAtStartAccess);
+			Assert.AreEqual("MyMethod", addMethodAtStartName);
+			Assert.AreEqual(interfaceTypeDefinition, addMethodAtStartTypeDef);
+			Assert.AreEqual("System.Int32", addMethodAtStartReturnType.FullName);
+			Assert.IsTrue(addMethodAtStartReturnType.IsKnownType (KnownTypeCode.Int32));
+		}
+		
+		[Test]
+		public void AddFunction_PrivateFunctionReturningUnknownType_AddsPrivateFunctionWithCodeConverter()
+		{
+			CreateInterface ("interface MyInterface {}");
+			var kind = global::EnvDTE.vsCMFunction.vsCMFunctionFunction;
+			var access = global::EnvDTE.vsCMAccess.vsCMAccessPrivate;
+			CaptureCodeGeneratorAddMethodAtStartParameters();
+			string newCode = 
+				"interface MyInterface {\r\n" +
+				"    Unknown.MyUnknownType MyMethod();\r\n" +
+				"}";
+			UpdateCode(newCode);
+			
+			codeInterface.AddFunction("MyMethod", kind, "Unknown.MyUnknownType", null, access);
+			
+			Assert.AreEqual(Accessibility.Private, addMethodAtStartAccess);
+			Assert.AreEqual("MyMethod", addMethodAtStartName);
+			Assert.AreEqual(interfaceTypeDefinition, addMethodAtStartTypeDef);
+			Assert.AreEqual("Unknown.MyUnknownType", addMethodAtStartReturnType.FullName);
+		}
+		
+		[Test]
+		public void AddFunction_PublicFunctionReturningSystemInt32_ReturnsCodeFunctionForNewMethod()
+		{
+			string fileName = @"c:\projects\MyProject\interface.cs";
+			CreateInterface("interface MyInterface {}", fileName);
+			var kind = global::EnvDTE.vsCMFunction.vsCMFunctionFunction;
+			var access = global::EnvDTE.vsCMAccess.vsCMAccessPublic;
+			string newCode = 
+				"interface MyInterface {\r\n" +
+				"    int MyMethod();\r\n" +
+				"}";
+			UpdateCode(newCode, fileName);
+			
+			var codefunction = codeInterface.AddFunction("MyMethod", kind, "System.Int32", null, access) as CodeFunction;
+			
+			Assert.AreEqual("MyMethod", codefunction.Name);
+		}
+		
+		[Test]
+		public void AddFunction_MethodNotFoundAfterReloadingTypeDefinition_ReturnsNull()
+		{
+			string fileName = @"c:\projects\MyProject\interface.cs";
+			CreateInterface("interface MyInterface {}", fileName);
+			var kind = global::EnvDTE.vsCMFunction.vsCMFunctionFunction;
+			var access = global::EnvDTE.vsCMAccess.vsCMAccessPublic;
+			string newCode = "interface MyInterface {}";
+			UpdateCode(newCode, fileName);
+			
+			var codefunction = codeInterface.AddFunction("MyMethod", kind, "System.Int32", null, access) as CodeFunction;
+			
+			Assert.IsNull(codefunction);
+		}
+		
+		[Test]
+		public void AddFunction_UnableToFindTypeDefinitionAfterUpdate_ReturnsNull()
+		{
+			string fileName = @"c:\projects\MyProject\interface.cs";
+			CreateInterface("interface MyInterface {}", fileName);
+			var kind = global::EnvDTE.vsCMFunction.vsCMFunctionFunction;
+			var access = global::EnvDTE.vsCMAccess.vsCMAccessPublic;
+			string newCode = "interface SomeOtherInterface {}";
+			UpdateCode(newCode, fileName);
+			
+			var codefunction = codeInterface.AddFunction("MyMethod", kind, "System.Int32", null, access) as CodeFunction;
+			
+			Assert.IsNull(codefunction);
+			Assert.AreEqual("MyInterface", codeInterface.Name);
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/EnvDTE/CodeModelTestBase.cs

@@ -23,6 +23,7 @@ using ICSharpCode.PackageManagement;
 using ICSharpCode.PackageManagement.EnvDTE;
 using ICSharpCode.SharpDevelop;
 using ICSharpCode.SharpDevelop.Dom;
+using ICSharpCode.SharpDevelop.Project;
 using ICSharpCode.SharpDevelop.Refactoring;
 using PackageManagement.Tests.Helpers;
 using Rhino.Mocks;
@@ -59,7 +60,8 @@ namespace PackageManagement.Tests.EnvDTE
 		
 		protected void CreateCodeModel()
 		{
-			msbuildProject = ProjectHelper.CreateTestProject();
+			ISolution solution = ProjectHelper.CreateSolutionWithoutInitializingServicesForUnitTests();
+			msbuildProject = ProjectHelper.CreateTestProject(solution, "MyProject");
 			
 			projectService = MockRepository.GenerateStub<IPackageManagementProjectService>();
 			fileService = MockRepository.GenerateStub<IPackageManagementFileService>();
@@ -84,5 +86,16 @@ namespace PackageManagement.Tests.EnvDTE
 			solutionSnapshot.AddCompilation(projectContent, compilation);
 			return compilation;
 		}
+		
+		protected void CreateCompilationForUpdatedCodeFile(string fileName, string code)
+		{
+			fileService
+				.Stub(fs => fs.GetCompilationUnit(fileName))
+				.WhenCalled(compilation => {
+					UpdateCodeFile(fileName, code);
+					compilation.ReturnValue = CreateCompilation();
+				})
+				.Return(null); // HACK: Not returning null here but Rhino Mocks fails to work otherwise.
+		}
 	}
 }

src/AddIns/Misc/PackageManagement/Test/Src/Helpers/ProjectHelper.cs

@@ -31,6 +31,11 @@ namespace PackageManagement.Tests.Helpers
 		public static ISolution CreateSolution()
 		{
 			SD.InitializeForUnitTests();
+			return CreateSolutionWithoutInitializingServicesForUnitTests();
+		}
+		
+		public static ISolution CreateSolutionWithoutInitializingServicesForUnitTests()
+		{
 			ISolution solution = MockRepository.GenerateStub<ISolution>();
 			solution.Stub(s => s.MSBuildProjectCollection).Return(new Microsoft.Build.Evaluation.ProjectCollection());
 			solution.Stub(s => s.Projects).Return(new NullSafeSimpleModelCollection<IProject>());