注入/模拟外部dll抽象类的静态方法

Question

I have this situation: An azure cloud service that uses an external DLL and makes API calls. This DLL has an abstract class that has a static method to return a subclass reference I need to use to make the API calls.

Now for testing purposes, we run the cloud service in an emulator and run our unit tests. But we don't want to make that API call to the external system. We need to intercept it somehow. I have spent the better part of yesterday trying to see if I could do some dependency injection (unity) to do this but needless to say, no luck.

The abstract class exposing a static method to get an instance of a subclass to actually make the API call is probably the most restrictive of scenarios.

Below is some decompiled & cleaned up code to show the relevant pieces.

public abstract class EntityManager : System.Object
{

    private static object lockObject;
    private static Dictionary<System.Type, EntityManager> entityManagers;
    private bool isSingleton;

    public enum EntityManagerInstanceType : int
    {
        SingletonInstance = 0,
        NewInstance = 1,
    }

    static EntityManager() { }

    protected EntityManager() { }

    public static T GetEntityManager<T>(EntityManagerInstanceType instanceType) where T : EntityManager
    {
        T item;
        System.Type type = typeof(T);
        T t = default(T);
        lock (EntityManager.lockObject)
        {
            if (instanceType != EntityManagerInstanceType.SingletonInstance || !EntityManager.entityManagers.ContainsKey(type))
            {
                t = (T)System.Activator.CreateInstance(type, true);
                try
                {                        
                    t.isSingleton = instanceType == EntityManagerInstanceType.SingletonInstance;                        
                }
                catch (Exception adapterException)
                {                        
                    throw;
                }
                if (instanceType == EntityManagerInstanceType.SingletonInstance)
                {
                    EntityManager.entityManagers[type] = t;
                }
                return t;
            }
            else
            {
                item = (T)EntityManager.entityManagers[type];
            }
        }
        return item;
    }

    protected object ProcessRequest(string methodName, object request) { return new object(); }
}

public class PersonaEntityManager : EntityManager
{
    protected PersonaEntityManager() { }

    public PersonaResponseData UpdatePersona(PersonaUpdateRequestData requestData)
    {
        return (PersonaResponseData)base.ProcessRequest("Mdm.UpdatePersona", requestData);
    }
}

public class PublisherWorkerRole : RoleEntryPoint
{
    public bool UpdatePersona(PersonaUpdateRequestData contact, string MessageId)
    {
        PersonaEntityManager mgr = EntityManager.GetEntityManager<PersonaEntityManager>(EntityManager.EntityManagerInstanceType.NewInstance);
        var resp = mgr.UpdatePersona(contact);
        return resp != null;
    }
}

What is the ideal approach in this scenario? Is this even testable short of setting up our own mock API and changing the application config for test to call our mock API instead?

Let me know if you need me to elaborate on this further.

Answer 1

One approach is to use something like ms shims or typemock to mock out the static call. This would reduce the impact to your production code, but if you're not already using them may require a financial investment. These libraries are able to intercept calls that other mocking frameworks can't so in addition to allowing you mock static calls, they would also allow you to create mock versions of the PersonaEntityManager which you would also need.

As you've mentioned in your comment below, the following approach doesn't work because you need to be able to Mock the PersonaEntityManager class so that you can intercept the call to UpdatePersona , which as it's not virtual standard mocking frameworks can't do. I've left the approach below for completeness, since it is the approach I would typically use to isolate a static dependency.

If you don't mind modifying your production code is to isolate the dependency behind a wrapper class. This wrapper class can then be injected into your code in the normal way.

So you would end up with some wrapper code something like this:

public interface IEntityManagerWrapper {
    T GetEntityManager<T>(EntityManager.EntityManagerInstanceType instanceType) where T : EntityManager;
}

public class EntityManagerWrapper : IEntityManagerWrapper {
    public T GetEntityManager<T>(EntityManager.EntityManagerInstanceType instanceType) where T : EntityManager {
        return EntityManager.GetEntityManager<T>(instanceType);
    }
}

The IEntityWrapper can be setup to be injected using Unity and then mocked using your mocking framework of choice to return mock instances of the other classes you depend on like PesonaEntityManager .

So, your production code would look like this:

public class MyProductionCode{
    private IEntityManagerWrapper _entityManager;

    public MyProductionCode(IEntityManagerWrapper entityManager) {
        _entityManager = entityManager;
    }

    public void DoStuff() {
        PersonaEntityManager pem = _entityManager.GetEntityManager<PersonaEntityManager>(EntityManager.EntityManagerInstanceType.NewInstance);

        var response = pem.UpdatePersona(new PersonaUpdateRequestData());
    }
}

And the test code would have looked like this (assuming you're using Moq):

[Test]
public void TestSomeStuff() {
    var em = new Mock<IEntityManagerWrapper>();
    var pe = new Mock<PersonaEntityManager>();
    pe.Setup(x => x.UpdatePersona(It.IsAny<PersonaUpdateRequestData>())).Returns(new PersonaResponseData());
    em.Setup(x=>x.GetEntityManager<PersonaEntityManager>(It.IsAny<EntityManager.EntityManagerInstanceType>())).Returns(pe.Object);

    var sut = new MyProductionCode(em.Object);

    sut.DoStuff();
}

The EntityWrapper class itself is pretty trivial, so I would tend to test it as an integration point, so use integration level testing to ensure it works both when it is written and if it is ever changed.

Answer 2

Hmm how about creating a proxy for that service. Expose necessary interface through proxy and inject provider (mocked or orginal) to it.