Author: Nishant Rana

Just sharing the helper class we use for writing Unit Test for Plugin using Microsoft Fakes

Sample Code for Plugin

</pre>
public class PluginClass: IPlugin
{
public void Execute(IServiceProvider serviceProvider)
{
IPluginExecutionContext context =
(IPluginExecutionContext)serviceProvider.GetService(typeof(IPluginExecutionContext));

// Everytime a lead record is created
// Create a corresponding contact record

if (context.InputParameters.Contains("Target") && context.InputParameters["Target"] is Entity)
{
Entity entity = (Entity)context.InputParameters["Target"];

IOrganizationServiceFactory serviceFactory =
(IOrganizationServiceFactory)
serviceProvider.GetService(typeof(IOrganizationServiceFactory));

IOrganizationService orgService = serviceFactory.CreateOrganizationService(context.UserId);

if (entity.LogicalName == "lead")
{
Entity contactEntity = new Entity("contact");
contactEntity.Attributes["lastname"] = entity.Attributes["subject"];
orgService.Create(contactEntity);
}
}
}
}

Sample Code for Unit Test Class

</pre>
[TestClass]
public class UnitTest1
{
[TestMethod]
public void UnitTestMethod()
{
var serviceProvider = new StubIServiceProvider();
var pluginContext = new StubIPluginExecutionContext();
var organizationService = new StubIOrganizationService();

// Mole the basic Plugin objects
Helper.FakePluginVariables(serviceProvider, pluginContext, organizationService, 40, "Create");

// set the mole of entity
var entityAttributes = new Dictionary<string, object>();

entityAttributes.Add("subject", "Test Subject");
Entity leadEntity = Helper.FakeEntity("lead", entityAttributes, pluginContext);

// set the entity in the parameter collection
var parameterAttributes = new Dictionary<string, object>();
parameterAttributes.Add("Target", leadEntity);
Helper.FakePluginInputParameters(pluginContext, parameterAttributes);

organizationService.CreateEntity = (p1) => { return Guid.NewGuid(); };

var postCreateLead = new Class1();
postCreateLead.Execute(serviceProvider);
}
}

Helper class

</pre>
/// <summary>
/// Helper class for Fakes
/// </summary>
public static class Helper
{
/// <summary>
/// Fakes the plugin variables.
/// </summary>
/// <param name="serviceProvider">The service provider.</param>
/// <param name="pluginContext">The plugin context.</param>
/// <param name="organizationService">The organization service.</param>
/// <param name="stageNumber">The stage number.</param>
/// <param name="messageName">Name of the message.</param>
public static void FakePluginVariables(
StubIServiceProvider serviceProvider,
StubIPluginExecutionContext pluginContext,
StubIOrganizationService organizationService,
int stageNumber,
string messageName)
{
var serviceFactory = new StubIOrganizationServiceFactory();
var tracingService = new StubITracingService();
if (serviceProvider != null)
{
serviceProvider.GetServiceType = type =>
{
if (type == typeof(IPluginExecutionContext))
{
return pluginContext;
}
else if (type == typeof(ITracingService))
{
return tracingService;
}
else if (type == typeof(IOrganizationServiceFactory))
{
return serviceFactory;
}

return null;
};
}

pluginContext.DepthGet = () => 1;
pluginContext.UserIdGet = () => new Guid();
pluginContext.MessageNameGet = () => messageName;
pluginContext.StageGet = () => stageNumber;
pluginContext.InitiatingUserIdGet = () => new Guid();
pluginContext.CorrelationIdGet = () => new Guid();
pluginContext.PrimaryEntityIdGet = Guid.NewGuid;
serviceFactory.CreateOrganizationServiceNullableOfGuid = t1 => organizationService;
tracingService.TraceStringObjectArray = Trace;
}

/// <summary>
/// Sets the Fakes for the Entity
/// </summary>
/// <param name="entityName">The LogicalName of the entity</param>
/// <param name="attributeValues">The attributes of the entity</param>
/// <param name="context">Object of type SIPluginExecutionContext</param>
/// <returns>Object of type Entity</returns>
public static Entity FakeEntity(string entityName, Dictionary<string, object> attributeValues, StubIPluginExecutionContext context)
{
var entity = new Entity(entityName);
entity.Attributes = new AttributeCollection();

if (attributeValues != null)
{
foreach (string key in attributeValues.Keys)
{
entity.Attributes.Add(key, attributeValues[key]);
}
}

if (context != null)
{
context.PrimaryEntityNameGet = () => entityName;
}

entity.Id = Guid.NewGuid();

return entity;
}

/// <summary>
/// Fakes the PluginContext.InputParameters
/// </summary>
/// <param name="context">the mole of the IPluginExecutionContext</param>
/// <param name="inputParameterCollection">Object of type System.Dictionary</param>
public static void FakePluginInputParameters(StubIPluginExecutionContext context, Dictionary<string, object> inputParameterCollection)
{
if (inputParameterCollection != null)
{
var parameterCollection = new ParameterCollection();
foreach (var key in inputParameterCollection.Keys)
{
parameterCollection.Add(key, inputParameterCollection[key]);
}

if (context != null)
{
context.InputParametersGet = () => parameterCollection;
}
}
}

/// <summary>
/// Detour method for the CRM Trace method
/// </summary>
/// <param name="content">the message to be traced</param>
/// <param name="value">Object of type object []</param>
public static void Trace(string content, params object[] value)
{
}
}

// Update 
   organizationService.UpdateEntity = (p) =>
            {
            };

// Execute
  organizationService.ExecuteOrganizationRequest = orgReq =>
                {                  
                    return new OrganizationResponse();
                };

// Retrieve
 organizationService.RetrieveStringGuidColumnSet = (p1, p2, p3) =>
            {
                Entity entity = null;
                if (p1 == entity1.EntityLogicalName)
                {
                    entity = new Entity(entity1.EntityLogicalName);
                    entity.Id = Guid.NewGuid();
                    entity.Attributes["new_category"] = new OptionSetValue(12345);
                    entity.FormattedValues["new_category"] = "home";                   
                }
                else if (p1 == entity2.EntityLogicalName)
                {
                    entity = new Entity(entity2.EntityLogicalName);
                    entity.Id = Guid.NewGuid();
                    entity.Attributes["new_moneyattr"] = new Money(100.0M);                    
                }
                return entity;
            };  
			
//RetrieveMultiple
  organizationService.RetrieveMultipleQueryBase = delegate(QueryBase query)
            {
                var collection = new EntityCollection();
                Entity entity;
                if (query is FetchExpression)
                {
                    entity = new Entity(entity.EntityLogicalName);
                    entity.Attributes = new AttributeCollection();
                    entity.Attributes.Add("attr", "value");                
                    collection.Entities.Add(entity);
                }
                return collection;
            };
			
// PreImage
  pluginContext.PreEntityImagesGet = () =>
            {
                EntityImageCollection entityImgColl = new EntityImageCollection();
                Entity preImageEntity = new Entity(enitity1.EntityLogicalName);         
                preImageEntity.Attributes.Add("new_id", new EntityReference(entity2.EntityLogicalName, Guid.NewGuid()));
                preImageEntity.Attributes.Add("new_bool", false);
                KeyValuePair<string, Entity> kvp = new KeyValuePair<string, Entity>("PreImageAI", preImageEntity);
                entityImgColl.Add(kvp);
                return entityImgColl;
            };
			

			

Hope it helps