Question

I have a Dictionary that I am using to avoid writing big if statements. It maps an enum to an action. It looks like this:

 var decisionMapper = new Dictionary<int, Action>
                             {
                                 {
                                     (int) ReviewStepType.StandardLetter,
                                     () =>  
                           caseDecisionService.ProcessSendStandardLetter(aCase)
                                     },
                                 {
                                     (int) ReviewStepType.LetterWithComment,
                                     () => 
                          caseDecisionService.ProcessSendStandardLetter(aCase)
                                     },
                                 {
                                     (int) ReviewStepType.BespokeLetter,
                                     () =>              
                          caseDecisionService.ProcessSendBespokeLetter(aCase)

                                     },
                                 {
                                     (int) ReviewStepType.AssignToCaseManager,
                                     () => 
                          caseDecisionService.ProcessContinueAsCase(aCase)
                                     },
                             };

then I call it like this in my method:

     decisionMapper[(int) reviewDecisionRequest.ReviewStepType]();

My question is how can I unit test these mappings?
(I am using Nunit and c# 4.0)

How can I assert that when I call my decisionMapper – that 1 is equal to the call -caseDecisionService.ProcessSendStandardLetter(aCase).

Thanks very much.

Answer 1

Thanks everyone for helping with this. This was what I did in the end.

I mocked the Action Service call, then invoked the dictionary’s value, then called AssertWasCalled / AssertWasNotCalled. Like this:

        mapper[(int) ReviewStepType.StandardLetter].Invoke();
        caseDecisionService.AssertWasCalled(c => c.ProcessSendStandardLetter(aCase),
                                            options => options.IgnoreArguments());
        caseDecisionService.AssertWasNotCalled(c =>  
                                               c.ProcessSendBespokeLetter(aCase),
                                               options => options.IgnoreArguments());
        caseDecisionService.AssertWasNotCalled(c => 
                                               c.ProcessContinueAsCase(aCase),
                                               options => options.IgnoreArguments());