C# Unit tests verify on non-abstract method on class instantied by Activator

Question

First, let me introduce you my project.

We are developping an app in which user can work with programs. As programs I mean list of instructions for a confidential use.

There are different types of Programs all inheriting from the Program abstract base class.

As the user can create different types of program, we developped a ProgramManager that can instantiante any type of Program by its type. We don't need to instantiate the abstract class but all the concrete classes (and it works) but as concrete Program have same methods (AddNewChannel, Save, ...) we handle them like Programs.

Here's a sample of code:

public Program CreateProgram(Type type)
    {
        Program program = Activator.CreateInstance(type) as Program;
        program.Directory = ProgramsPath;

        int nbChannels = 2; //not 2 but a long line searching the correct number where it is.

        for (int i = 1; i <= nbChannels; i++)
        {
            program.AddNewChannel(i);
        }

        program.Save();
        return program;
    }

What I now have to do is test this function and I don't want to duplicate the unitTests I already made for the different Program classes.

As an example, here is one of my test functions (for the Save method) with it's init. I store the types I need to test in a xml file.

    [TestInitialize]
    public void TestInitialize()
    {
        if (!TestContext.TestName.StartsWith("GetKnownTypes"))
            type = UnitTestsInitialization.applicationHMIAssembly.GetType((string)TestContext.DataRow["Data"]);
    }


    [TestMethod]
    [DataSource("Microsoft.VisualStudio.TestTools.DataSource.XML",
               "|DataDirectory|\\" + DATA_FILE, "Row",
                DataAccessMethod.Sequential)]
    public void SavedProgramCreatesFile()
    {
        Program program = Activator.CreateInstance(type) as Program;
        program.Name = "SavedProgramCreatesFile";
        program.Directory = DIRECTORY;

        program.Save();

        string savedProgramFileName = program.GetFilePath();

        bool result = File.Exists(savedProgramFileName);

        Assert.IsTrue(result);
    }

All my concrete Program classes have been tested separatly.

Thereby, I would like to test if the following methods program.AddNewChannel and program.Save are called.

I gave a look at Moq but the first problem is that the method Save is not abstract.

Also, using Activator doesn't allow me to make a Mock<Program>.

I tried the following in a unit test in order to try to instantiate the mock and use it like a program:

    [TestMethod]
    [DataSource("Microsoft.VisualStudio.TestTools.DataSource.XML",
               "|DataDirectory|\\" + DATA_FILE, "Row",
                DataAccessMethod.Sequential)]
    public void CreateProgram_CallsProgramSaveMethod()
    {
        Mock<Program> mock = new Mock<Program>();
        mock.Setup(p => p.AddNewChannel(It.IsAny<int>()));

        Program program = pm.CreateProgram(mock.Object.GetType());
        mock.Verify(p => p.Save());
        mock.Verify(p => p.GetFilePath(It.IsAny<string>()));
        mock.Verify(p => p.AddNewChannel(It.IsAny<int>()), Times.Exactly(ProgramManager.NB_MACHINE_CHANNELS));
        Assert.IsNotNull(program);
        program.DeleteFile();
    }

Which was inspired by this question: How to mock An Abstract Base Class

And it works until it reaches the line program.AddNewChannel(i); in the for loop. The error is the following:

System.NotImplementedException: 'This is a DynamicProxy2 error: The interceptor attempted to 'Proceed' for method 'Void AddNewChannel(Int32)' which is abstract. When calling an abstract method there is no implementation to 'proceed' to and it is the responsibility of the interceptor to mimic the implementation (set return value, out arguments etc)'

It seems that the setup doesn't work but I might understand why. (I try to instantiate a subtype of Proxy which doesn't implement verify method)

I also tried to use a Proxy over my program class which would implement an interface which would contain the methods I needed but the problem here is the activator again.

Can anyone suggest me any way of testing those method calls ? (Even if I need to change my method CreateProgram)

I gave a look here: How to mock non virtual methods? but I am not sure this would be applicable to my problem.

I use MSTests for my unittests.

NOTICE

Everything else works fine. All my other tests pass without troubles and my code seems to work (Tested by hand).

Thanks in advance.

Answer 1

Create a wrapper interface and class around Activator, then pass the type to that:

public interface IActivatorWrapper
{
    object CreateInstance(Type type);
}

public class ActivatorWrapper : IActivatorWrapper
{
    public object CreateInstance(Type type)
    {
        return Activator.CreateInstance(type);
    }
}

Use this instead of Activator directly, then mock the IActivatorWrapper to return whatever mock object you want.

---

Another idea to help with your problem would be to add an IProgram interface to your abstract Program class, then use that to refer to your concrete Program instances. This might also help you, should you ever want to write a concrete Program with a different base class.