Simplifying Dynamics CRM Plugin Testing with FakeXrmEasy

 Introduction

Hello, fellow developers! If you're working with Microsoft Dynamics CRM and looking for a way to simplify your plugin testing, you're in the right place. Today, we're diving into FakeXrmEasy, a powerful testing framework designed specifically for Dynamics CRM. As someone who's been in the trenches, I'll share how FakeXrmEasy can make your life easier and help you write robust, reliable tests for your plugins.

What is FakeXrmEasy?

FakeXrmEasy is an open-source testing framework tailored for Dynamics CRM. It allows you to create mock environments and simulate CRM services, making it easier to test your plugins without needing a live CRM instance. With FakeXrmEasy, you can focus on writing tests that validate your business logic and ensure your plugins work as expected.

Why Use FakeXrmEasy?

1. Ease of Use: FakeXrmEasy is designed to be developer-friendly. It simplifies the setup process and provides intuitive methods for creating and managing mock data.
2. Isolation: By using FakeXrmEasy, you can isolate your tests from external dependencies, ensuring they are reliable and repeatable.
3. Efficiency: Testing with FakeXrmEasy is faster than using a live CRM instance. You can run tests quickly and get immediate feedback on your code.
4. Community Support: As an open-source project, FakeXrmEasy has a vibrant community of developers who contribute to its development and provide support.

Getting Started with FakeXrmEasy

Let's walk through the steps to set up and use FakeXrmEasy for testing your Dynamics CRM plugins.

1. Install FakeXrmEasy

   • You can install FakeXrmEasy via NuGet Package Manager in Visual Studio.

    Install-Package FakeXrmEasy
   

2. Create a Test Project

   • In Visual Studio, create a new Class Library project for your tests.
   • Add references to the necessary Dynamics CRM SDK assemblies and FakeXrmEasy.

3. Write Test Cases

   • Create test classes and methods to test your plugin logic. Use FakeXrmEasy to set up the mock CRM environment and simulate service calls.
   • Example of a simple test case using FakeXrmEasy:

    using FakeXrmEasy;
    using Microsoft.Xrm.Sdk;
    using NUnit.Framework;
    using YourPluginNamespace;
   
    [TestFixture]
    public class YourPluginTests
    {
        private XrmFakedContext _context;
        private IOrganizationService _service;
        private YourPlugin _plugin;
    [SetUp]
    public void Setup()
    {
        _context = new XrmFakedContext();
        _service = _context.GetOrganizationService();
        _plugin = new YourPlugin();
    }
   
    [Test]
    public void TestPluginLogic()
    {
        // Arrange
        var targetEntity = new Entity("account") { Id = Guid.NewGuid() };
        _context.Initialize(new List<Entity> { targetEntity });
   
        var pluginContext = _context.GetDefaultPluginContext();
        pluginContext.InputParameters["Target"] = targetEntity;
   
        // Act
        _plugin.Execute(pluginContext);
   
        // Assert
        var updatedEntity = _context.CreateQuery("account").FirstOrDefault();
        Assert.IsNotNull(updatedEntity);
        // Add more assertions as needed
    }
    }
   

4. Run Tests

   • Use the Test Explorer in Visual Studio to run your tests and see the results.
   • Ensure your tests cover various scenarios, including edge cases and error conditions.

Additional Examples

1. Testing Create Operation

   Scenario: You have a plugin that triggers on the creation of a contact and sets a default value for a custom field.

   Test Case:

   [Test]
   public void TestCreateContactPlugin()
   {
       // Arrange
       var contact = new Entity("contact") { Id = Guid.NewGuid() };
       _context.Initialize(new List<Entity> { contact });

       var pluginContext = _context.GetDefaultPluginContext();
       pluginContext.MessageName = "Create";
       pluginContext.InputParameters["Target"] = contact;

       // Act
       _plugin.Execute(pluginContext);

       // Assert
       var createdContact = _context.CreateQuery("contact").FirstOrDefault();
       Assert.IsNotNull(createdContact);
       Assert.AreEqual("Default Value", createdContact["customfield"]);
   }

2. Testing Update Operation

   Scenario: You have a plugin that triggers on the update of an account and logs the changes to a custom entity.

   Test Case:

   [Test]
   public void TestUpdateAccountPlugin()
   {
       // Arrange
       var account = new Entity("account") { Id = Guid.NewGuid() };
       _context.Initialize(new List<Entity> { account });

       var pluginContext = _context.GetDefaultPluginContext();
       pluginContext.MessageName = "Update";
       pluginContext.InputParameters["Target"] = account;

       // Act
       _plugin.Execute(pluginContext);

       // Assert
       var logEntry = _context.CreateQuery("custom_log").FirstOrDefault();
       Assert.IsNotNull(logEntry);
       Assert.AreEqual(account.Id, logEntry["accountid"]);
   }

3. Testing Delete Operation

   Scenario: You have a plugin that triggers on the deletion of a case and performs cleanup operations.

   Test Case:

   [Test]
   public void TestDeleteCasePlugin()
   {
       // Arrange
       var caseEntity = new Entity("incident") { Id = Guid.NewGuid() };
       _context.Initialize(new List<Entity> { caseEntity });

       var pluginContext = _context.GetDefaultPluginContext();
       pluginContext.MessageName = "Delete";
       pluginContext.InputParameters["Target"] = caseEntity.ToEntityReference();

       // Act
       _plugin.Execute(pluginContext);

       // Assert
       var cleanupEntity = _context.CreateQuery("cleanup_entity").FirstOrDefault();
       Assert.IsNotNull(cleanupEntity);
       Assert.AreEqual(caseEntity.Id, cleanupEntity["caseid"]);
   }

Best Practices for Using FakeXrmEasy

1. Comprehensive Test Coverage: Aim for high test coverage to ensure all critical paths and edge cases are tested.
2. Mock Realistic Data: Use realistic data in your tests to simulate real-world scenarios and validate your plugin logic.
3. Isolate Tests: Ensure each test is isolated and does not depend on external systems or data.
4. Continuous Integration: Integrate your tests into a CI pipeline to run them automatically on code commits and pull requests.

Handling exceptions in tests is crucial to ensure your plugins are robust and can gracefully handle unexpected situations. Here’s how you can effectively handle exceptions in your tests using FakeXrmEasy and a testing framework like NUnit:

Steps to Handle Exceptions in Tests

1. Set Up Your Test Environment

   • Ensure you have your test project set up with FakeXrmEasy and your chosen testing framework (e.g., NUnit).

2. Write Test Cases to Handle Exceptions

   • Create test methods that simulate scenarios where exceptions might occur. Use assertions to verify that the exceptions are handled correctly.

3. Use Assertions to Verify Exceptions

   • Use the Assert.Throws method (or equivalent in your testing framework) to check that the expected exception is thrown.

Example: Handling Exceptions in a Plugin

Let’s say you have a plugin that throws an exception when a required field is missing. Here’s how you can write a test to handle this scenario:

using FakeXrmEasy;
using Microsoft.Xrm.Sdk;
using NUnit.Framework;
using YourPluginNamespace;

[TestFixture]
public class YourPluginTests
{
    private XrmFakedContext _context;
    private IOrganizationService _service;
    private YourPlugin _plugin;

    [SetUp]
    public void Setup()
    {
        _context = new XrmFakedContext();
        _service = _context.GetOrganizationService();
        _plugin = new YourPlugin();
    }

    [Test]
    public void TestPluginThrowsExceptionForMissingField()
    {
        // Arrange
        var targetEntity = new Entity("account") { Id = Guid.NewGuid() };
        // Intentionally not setting a required field to trigger the exception
        _context.Initialize(new List<Entity> { targetEntity });

        var pluginContext = _context.GetDefaultPluginContext();
        pluginContext.InputParameters["Target"] = targetEntity;

        // Act & Assert
        var ex = Assert.Throws<InvalidPluginExecutionException>(() => _plugin.Execute(pluginContext));
        Assert.AreEqual("Required field is missing.", ex.Message);
    }
}

Example: Handling Exceptions Gracefully

If your plugin handles exceptions internally and logs them, you can write a test to ensure this behavior:

[Test]
public void TestPluginHandlesExceptionGracefully()
{
    // Arrange
    var targetEntity = new Entity("account") { Id = Guid.NewGuid() };
    _context.Initialize(new List<Entity> { targetEntity });

    var pluginContext = _context.GetDefaultPluginContext();
    pluginContext.InputParameters["Target"] = targetEntity;

    // Simulate an exception in the plugin logic
    _context.AddExecutionMock<YourPlugin>((ctx) =>
    {
        throw new InvalidPluginExecutionException("Simulated exception");
    });

    // Act
    Assert.DoesNotThrow(() => _plugin.Execute(pluginContext));

    // Assert
    // Verify that the exception was logged or handled as expected
    // For example, check a log entity or a status field
    var logEntry = _context.CreateQuery("log_entity").FirstOrDefault();
    Assert.IsNotNull(logEntry);
    Assert.AreEqual("Simulated exception", logEntry["message"]);
}

Tips for Handling Exceptions in Tests

1. Simulate Real-World Scenarios: Create test cases that mimic real-world scenarios where exceptions might occur.
2. Use Meaningful Assertions: Ensure your assertions check not only that an exception is thrown but also that it is handled correctly.
3. Test Different Exception Types: Test for various types of exceptions that your plugin might encounter.
4. Log and Verify: If your plugin logs exceptions, include assertions to verify that the logging is done correctly.