When you finished your Dynamics CRM Plugin you need to write a Unit test to achieve 100% code coverage. Writing unit tests can be difficult, time-consuming, and slow when you can't isolate the classes you want to test from the rest of the system. Here are some steps you need to follow and cover your plugin code using Unit test methods.
Here in this blog, I have explained how to write unit test method for different functionality, data types and events like Retrieve, Retrieve Multiple, PreImage data, Post Image data, Entity, EntityReference, Option set, TargetEntity data, etc.
How to create a Unit test project: Create Unit test project in VS 2019
Step 1
Add Fakes references to your MS project
Unit testing using Fakes for MS Dynamics CRM Plugins
Unit testing using Fakes for MS Dynamics CRM Plugins
The Fakes Assemblies will automatically be created in your project.
Now you can start writing your Unit test method code.
Always remember Unit test for the plugin is passing hardcoded value only. The plugin does not connect with the CRM database while writing the Unit test methods.
Step 2
Use Fakes libraries in your Unittest.cs file
Unit testing using Fakes for MS Dynamics CRM Plugins
Now the below code is for every test method will be same. It contains the declaration, Initialization of the IPlugin interface.
  1. /// <summary>
  2. /// Organization Service Response
  3. /// </summary>
  4. private OrganizationResponse response = new CreateResponse();
  6. /// <summary>
  7. /// Gets or sets Service Provider
  8. /// </summary>
  9. private static StubIServiceProvider ServiceProvider { get; set; }
  11. /// <summary>
  12. /// Gets or sets Plugin Execution Context
  13. /// </summary>
  14. private static StubIPluginExecutionContext PluginExecutionContext { get; set; }
  16. /// <summary>
  17. /// Gets or sets Organization Service
  18. /// </summary>
  19. private static StubIOrganizationService OrganizationService { get; set; }
  21. /// <summary>
  22. /// Gets or sets Test Entity
  23. /// </summary>
  24. private Entity TestEntity { get; set; }
  26. /// <summary>
  27. /// Class Initialize
  28. /// </summary>
  29. /// <param name="textContext">text Context</param>
  30. [ClassInitialize]
  31. public static void ClassInit(TestContext textContext)
  32. {
  33. var context = new StubIPluginExecutionContext();
  34. var tracingService = new StubITracingService();
  35. var orgFactory = new StubIOrganizationServiceFactory();
  36. ServiceProvider = new StubIServiceProvider();
  37. OrganizationService = new StubIOrganizationService();
  38. PluginExecutionContext = context;
  40. ////override GetService behaviour and return our stubs
  41. ServiceProvider.GetServiceType = (type) =>
  42. {
  43. if (type == typeof(IPluginExecutionContext))
  44. {
  45. return context;
  46. }
  47. else if (type == typeof(IOrganizationServiceFactory))
  48. {
  49. return orgFactory;
  50. }
  51. else if (type == typeof(ITracingService))
  52. {
  53. return tracingService;
  54. }
  55. else if (type == typeof(IOrganizationService))
  56. {
  57. return OrganizationService;
  58. }
  60. return null;
  61. };
  63. ////return our stub organizationservice
  64. orgFactory.CreateOrganizationServiceNullableOfGuid = (userId) => OrganizationService;
  66. ////write trace logs to output. only works when debugging tests
  67. tracingService.TraceStringObjectArray = (message, args) => Debug.WriteLine(message, args);
  68. }
  70. /// <summary>
  71. /// Initialize Test File
  72. /// </summary>
  73. [TestInitialize]
  74. public void TestInit()
  75. {
  76. ////setup initial values for each test
  77. var inputParameters = new ParameterCollection();
  78. PluginExecutionContext.InputParametersGet = () => inputParameters;
  79. this.TestEntity = new Entity();
  80. inputParameters.Add(new KeyValuePair<string, object>("Target", this.TestEntity));
  81. }
  83. /// <summary>
  84. /// Test Cleanup
  85. /// </summary>
  86. [TestCleanup]
  87. public void TestCleanup()
  88. {
  89. this.TestEntity = null;
  90. }
Step 3
Write your Unit test methods
  1. [TestMethod]
  2. public void UnitTestMethod()
  3. {
  4. ////Arrange
  5. ParameterCollection parameter;
  7. ////setup input parameters.
  8. PluginExecutionContext.InputParametersGet = () =>
  9. {
  10. parameter = new ParameterCollection
  11. {
  12. ["Target"] = new Entity("account", Guid.Parse("e910c8ae-4c9d-e911-a98f-002248005d8"))
  13. {
  14. }
  15. };
  16. return parameter;
  17. };
  19. PluginExecutionContext.PostEntityImagesGet = () =>
  20. {
  21. // new entity
  22. Entity contactEntity = new Entity("contact", Guid.NewGuid());
  24. // Entity image object collection
  25. EntityImageCollection parameterImage = new EntityImageCollection();
  27. // Lookup field
  28. EntityReference entityReference = new EntityReference
  29. {
  30. Id = Guid.NewGuid(),
  31. LogicalName = "opportunity"
  32. };
  34. contactEntity["opportunityid"] = entityReference;
  36. // Option set field
  37. contactEntity["advertise"] = new OptionSetValue(3);
  39. // Date time field
  40. contactEntity["starttime"] = DateTime.Now;
  42. // Post Image data
  43. parameterImage["PostImage"] = contactEntity;
  45. return parameterImage;
  46. };
  48. PluginExecutionContext.PreEntityImagesGet = () =>
  49. {
  51. EntityImageCollection parameterImage = new EntityImageCollection();
  52. parameterImage["PreImage"] = new Entity();
  53. return parameterImage;
  54. };
  56. // Retrieve based entityId
  57. OrganizationService.RetrieveStringGuidColumnSet = (entityName, id, columns) =>
  58. {
  59. var entity = new Entity(entityName)
  60. {
  61. Id = id
  62. };
  63. entity.Attributes["date"] = DateTime.Now.AddHours(2);
  64. entity.Attributes["dateTime"] = DateTime.Now.AddHours(4);
  65. return entity;
  66. };
  68. // Retrieve multiple
  69. OrganizationService.RetrieveMultipleQueryBase = (req) =>
  70. {
  71. EntityCollection ec = null;
  72. if (req is FetchExpression)
  73. {
  74. var fe = req as FetchExpression;
  75. if (fe.Query.Contains("msdyn_timegroupdetail"))
  76. {
  77. ec = new EntityCollection();
  78. ec.Entities.Add(new Entity()
  79. {
  80. Attributes = new AttributeCollection()
  81. {
  82. { "msdyn_starttime", DateTime.Now.AddHours(2)},
  83. { "msdyn_endtime", DateTime.Now.AddHours(3)},
  84. }
  85. });
  86. }
  87. }
  88. if (req is QueryExpression)
  89. {
  90. ec = new EntityCollection();
  91. ec.Entities.Add(new Entity()
  92. {
  93. Attributes = new AttributeCollection()
  94. {
  95. { "timezonecode", 85},
  96. }
  97. });
  98. }
  99. return ec;
  100. };
  101. PluginExecutionContext.StageGet = () => 40;
  102. PluginExecutionContext.MessageNameGet = () => "Update";
  103. PluginExecutionContext.PrimaryEntityNameGet = () => "account";
  104. UnittestPlugin unitTestPlugin = new UnittestPlugin();
  105. unitTestPlugin.Execute(ServiceProvider);
  106. }
Using the above code you can easily cover your code coverage for your code.
Somewhere in the code, we needed a plugin exception for code coverages. Using the below code you can cover the IPluginExecutionException, FaultException, Exception for the exception handling process in the Unit test.
  1. [TestMethod, ExpectedException(typeof(InvalidPluginExecutionException))]
  2. public void PluginException()
  3. {
  4. ////Arrange
  5. ParameterCollection parameter;
  7. //// put wrong GUID in entity GUID it will show you IPluginExecutionException
  8. PluginExecutionContext.InputParametersGet = () =>
  9. {
  10. parameter = new ParameterCollection
  11. {
  12. ["Target"] = new Entity("account", new Guid("ed33f83c-9ed3-e911-a813-000d3a6d652"))
  13. {
  14. Attributes = {
  16. }
  17. }
  18. };
  19. return parameter;
  20. };
  21. }
For Fault Exception put null values or make cast error,
  1. [TestMethod, ExpectedException(typeof(InvalidCastException))]
  2. public void LoggedInUserDoesNotHaveSysAdminRole()
  3. {
  4. //// Now Here "accountcategory" code field is an Option set field but we are passing
  5. //// string value to the field So it will generate an error
  6. PluginExecutionContext.PreEntityImagesGet = () =>
  7. {
  8. EntityImageCollection preImage = new EntityImageCollection
  9. {
  10. ["PreImage"] = new Entity("account")
  11. {
  12. Attributes = {
  13. { "accountcategorycode", "value" }
  14. }
  15. }
  16. };
  17. return preImage;
  18. };
  19. }
I hope this article will solve your problem with writing a Unit test using Fakes.
Keep learning new things.....