Need ideas for a TDD Approach

We have just released a re-written(for the 3rd time) module for our proprietary system. This module, which we call the Load Manager, is by far the most complicated of all the modules in our system to date. We are trying to get a comprehensive test suite because every time we make any kind of significant change to this module there is hell to pay for weeks in sorting out bugs and quirks. However, developing a test suite has proven to be quite difficult so we are looking for ideas.

The Load Manager's guts reside in a class called LoadManagerHandler, this is essentially all of the logic behind the module. This handler calls upon multiple controllers to do the CRUD methods in the database. These controllers are essentially the top layer of the DAL that sits on top and abstracts away our LLBLGen generated code.

So it is easy enough to mock these controllers, which we are doing using the Moq framework. However the problem comes in the complexity of the Load Manager and the issues that we receive aren't in dealing with the simple cases but the cases where there is a substantial amount of data contained within the handler.

To briefly explain the load manager contains a number of "unloaded" details, sometimes in the hundreds, that are then dropped into user created loads and resh开发者_JAVA百科ip pools. During the process of creating and populating these loads there is a multitude of deletes, changes, and additions that eventually cause issues to appear. However, because when you mock a method of an object the last mock wins, ie:

jobDetailControllerMock.Setup(mock => mock.GetById(1)).Returns(jobDetail1);
jobDetailControllerMock.Setup(mock => mock.GetById(2)).Returns(jobDetail2);
jobDetailControllerMock.Setup(mock => mock.GetById(3)).Returns(jobDetail3);

No matter what I send to jobDetailController.GetById(x) I will always get back jobDetail3. This makes testing almost impossible because we have to make sure that when changes are made all points are affected that should be affected.

So, I resolved to using the test database and just allowing the reads and writes to occur as normal. However, because you can't(read: should not) dictate the order of your tests, tests that are run earlier could cause tests that run later to fail.

TL/DR: I am essentially looking for testing strategies for data oriented code that is quite complex in nature.

As noted by Seb, you can indeed use a range matching:

controller.Setup(x => x.GetById(It.IsInRange<int>(1, 3, Range.Inclusive))))).Returns<int>(i => jobs[i]);

This code uses the argument passed to the method to calculate which value to return.

To get around the "last mock wins" with Moq, you could use the technique from this blog:

Moq Triqs - Successive Expectations

EDIT:

Actually you don't even need that. Based on your example, Moq will return different values based on the method argument.

public interface IController { string GetById(int id); }

class Program
{
    static void Main(string[] args)
    {
        var mockController = new Mock<IController>();

        mockController.Setup(x => x.GetById(1)).Returns("one");
        mockController.Setup(x => x.GetById(2)).Returns("two");
        mockController.Setup(x => x.GetById(3)).Returns("three");

        IController controller = mockController.Object;

        Console.WriteLine(controller.GetById(1));
        Console.WriteLine(controller.GetById(3));
        Console.WriteLine(controller.GetById(2));
        Console.WriteLine(controller.GetById(3));
        Console.WriteLine(controller.GetById(99) == null);
    }
}

Output is:

   one
   three
   two
   three
   True

It sounds like LoaderManagerHandler does... quite a bit of work. "Manager" in a class name always somewhat worries me... from a TDD standpoint, it might be worth thinking about breaking the class up appropriately if possible.

How long is this class?

I've never used Moq, but it seems that it should be able to match a mock invocation by argument(s) supplied.

A quick look at the Quick Start documentation has the following excerpt:

//Matching Arguments

// any value
mock.Setup(foo => foo.Execute(It.IsAny<string>())).Returns(true);


// matching Func<int>, lazy evaluated
mock.Setup(foo => foo.Add(It.Is<int>(i => i % 2 == 0))).Returns(true); 


// matching ranges
mock.Setup(foo => foo.Add(It.IsInRange<int>(0, 10, Range.Inclusive))).Returns(true); 

I think you should be able to use the second example above.

A simple testing technique is to make sure everytime a bug is logged against a system, make sure a unit test is written covering that case. You can build up a pretty solid set of tests just from that technique. And even better you won't run into the same thing twice.

No matter what I send to jobDetailController.GetById(x) I will always get back jobDetail3

You should spend more time debugging your tests because what is happening is not how Moq behaves. There is a bug in your code or tests causing something to misbehave.

If you want to make repeated calls with the same inputs but different outputs you could also use a different mocking framework. RhinoMocks supports the record/playback idiom. You're right this is not always what you want with regards to enforcing call order. I do prefer Moq myself for its simplicity.