SharpDevelop/src/AddIns/Misc/PackageManagement/Test/Src/Helpers/ProjectContentHelper.cs

// 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.SharpDevelop.Dom;
using ICSharpCode.SharpDevelop.Project;
using Rhino.Mocks;

namespace PackageManagement.Tests.Helpers
{
	public class ProjectContentHelper
	{
		public IProjectContent FakeProjectContent;
		public List<string> NamespaceNames = new List<string>();
		
		public ProjectContentHelper()
		{
			FakeProjectContent = MockRepository.GenerateStub<IProjectContent>();
			FakeProjectContent.Stub(pc => pc.NamespaceNames).Return(NamespaceNames);
		}
		
		public void SetProjectForProjectContent(IProject project)
		{
			FakeProjectContent.Stub(pc => pc.Project).Return(project);
		}
		
		public IClass AddClassToProjectContentAndCompletionEntries(string namespaceName, string className)
		{
			IClass fakeClass = AddClassToProjectContent(className);
			var namespaceContents = new List<ICompletionEntry>();
			namespaceContents.Add(fakeClass);
			AddCompletionEntriesToNamespace(namespaceName, namespaceContents);
			
			return fakeClass;
		}
		
		public void AddCompletionEntriesToNamespace(string namespaceName, List<ICompletionEntry> namespaceContents)
		{
			FakeProjectContent.Stub(pc => pc.GetNamespaceContents(namespaceName)).Return(namespaceContents);
		}
		
		public void NoCompletionItemsInNamespace(string namespaceName)
		{
			AddCompletionEntriesToNamespace(namespaceName, new List<ICompletionEntry>());
		}
		
		public IClass AddClassToProjectContent(string className)
		{
			IClass fakeClass = AddClassToProjectContentCommon(FakeProjectContent, className);
			SetClassType(fakeClass, ClassType.Class);
			return fakeClass;
		}
		
		public void SetClassType(IClass fakeClass, ClassType classType)
		{
			fakeClass.Stub(c => c.ClassType).Return(classType);
		}
		
		public void AddClassToDifferentProjectContent(string className)
		{
			IProjectContent differentProjectContent = MockRepository.GenerateStub<IProjectContent>();
			AddClassToProjectContentCommon(differentProjectContent, className);
		}

		IClass AddClassToProjectContentCommon(IProjectContent projectContent, string className)
		{
			IClass fakeClass = MockRepository.GenerateMock<IClass, IEntity>();
			FakeProjectContent.Stub(pc => pc.GetClass(className, 0)).Return(fakeClass);
			fakeClass.Stub(c => c.FullyQualifiedName).Return(className);
			fakeClass.Stub(c => c.ProjectContent).Return(projectContent);
			return fakeClass;
		}
		
		public IClass AddInterfaceToProjectContent(string interfaceName)
		{
			return AddInterfaceToProjectContent(FakeProjectContent, interfaceName);
		}
		
		public IClass AddInterfaceToDifferentProjectContent(string interfaceName)
		{
			IProjectContent projectContent = MockRepository.GenerateStub<IProjectContent>();
			return AddInterfaceToProjectContent(projectContent, interfaceName);
		}
		
		public IClass AddInterfaceToProjectContent(IProjectContent projectContent, string interfaceName)
		{
			IClass fakeClass = AddClassToProjectContentCommon(projectContent, interfaceName);
			SetClassType(fakeClass, ClassType.Interface);
			return fakeClass;
		}
		
		public void AddNamespaceNameToProjectContent(string name)
		{
			NamespaceNames.Add(name);
		}
		
		public void NoCompletionEntriesForRootNamespace()
		{
			NoCompletionItemsInNamespace(String.Empty);
		}
		
		public void AddUnknownCompletionEntryTypeToNamespace(string namespaceName)
		{
			var unknownEntry = MockRepository.GenerateStub<ICompletionEntry>();
			var namespaceContents = new List<ICompletionEntry>();
			namespaceContents.Add(unknownEntry);
			AddCompletionEntriesToNamespace(namespaceName, namespaceContents);
		}
		
		public void AddNamespaceCompletionEntryInNamespace(string parentNamespaceName, string namespaceName)
		{
			AddNamespaceCompletionEntriesInNamespace(parentNamespaceName, new string[] { namespaceName });
		}
		
		public void AddNamespaceCompletionEntriesInNamespace(string parentNamespaceName, params string[] childNamespaceNames)
		{
			List<ICompletionEntry> entries = childNamespaceNames
				.Select(name => new NamespaceEntry(name) as ICompletionEntry)
				.ToList();
			AddCompletionEntriesToNamespace(parentNamespaceName, entries);
		}
		
		public void AddClassCompletionEntriesInDifferentProjectContent(string namespaceName, string className)
		{
			IProjectContent differentProjectContent = MockRepository.GenerateStub<IProjectContent>();
			AddClassToCompletionEntries(differentProjectContent, namespaceName, className);
		}
		
		public void AddClassToCompletionEntries(string namespaceName, string className)
		{
			AddClassToCompletionEntries(FakeProjectContent, namespaceName, className);
		}
		
		void AddClassToCompletionEntries(IProjectContent projectContent, string namespaceName, string className)
		{
			IClass fakeClass = MockRepository.GenerateStub<IClass>();
			fakeClass.Stub(c => c.ProjectContent).Return(projectContent);
			var entries = new List<ICompletionEntry>();
			entries.Add(fakeClass);
			AddCompletionEntriesToNamespace(namespaceName, entries);			
		}
		
		public void ProjectContentIsForCSharpProject()
		{
			TestableProject project = ProjectHelper.CreateTestProject();
			project.FileName = @"c:\projects\myproject.csproj";
			SetProjectForProjectContent(project);
		}
		
		public void ProjectContentIsForVisualBasicProject()
		{
			TestableProject project = ProjectHelper.CreateTestProject();
			project.FileName = @"c:\projects\myproject.vbproj";
			SetProjectForProjectContent(project);
		}
		
		public IClass AddPublicClassToProjectContent(string name)
		{
			IClass fakeClass = AddClassToProjectContent(name);
			MakeClassPublic(fakeClass);
			return fakeClass;
		}
		
		public IClass AddPrivateClassToProjectContent(string name)
		{
			IClass fakeClass = AddClassToProjectContent(name);
			MakeClassPrivate(fakeClass);
			return fakeClass;
		}
		
		public IClass AddPublicStructToProjectContent(string name)
		{
			IClass fakeStruct = AddStructToProjectContent(name);
			MakeClassPublic(fakeStruct);
			return fakeStruct;
		}
		
		public IClass AddStructToProjectContent(string name)
		{
			IClass fakeStruct = AddClassToProjectContentCommon(FakeProjectContent, name);
			SetClassType(fakeStruct, ClassType.Struct);
			return fakeStruct;
		}
		
		public IClass AddPrivateStructToProjectContent(string name)
		{
			IClass fakeStruct = AddStructToProjectContent(name);
			MakeClassPrivate(fakeStruct);
			return fakeStruct;
		}
		
		public IClass AddPublicDelegateToProjectContent(string name)
		{
			IClass fakeDelegate = AddDelegateToProjectContent(name);
			MakeClassPublic(fakeDelegate);
			return fakeDelegate;
		}
		
		public IClass AddDelegateToProjectContent(string name)
		{
			IClass fakeDelegate = AddClassToProjectContentCommon(FakeProjectContent, name);
			SetClassType(fakeDelegate, ClassType.Delegate);
			return fakeDelegate;
		}
		
		public void MakeClassPublic(IClass fakeClass)
		{
			fakeClass.Stub(c => c.IsPublic).Return(true);
		}
		
		public void MakeClassPrivate(IClass fakeClass)
		{
			fakeClass.Stub(c => c.IsPublic).Return(false);
			fakeClass.Stub(c => c.IsPrivate).Return(true);
		}
		
		public IClass AddPrivateDelegateToProjectContent(string name)
		{
			IClass fakeDelegate = AddDelegateToProjectContent(name);
			MakeClassPrivate(fakeDelegate);
			return fakeDelegate;
		}
	}
}