通过事件C＃处理异常的单元测试方法

Question

I've decided to create Unit Tests for a WinForm application I have. I used a custom layered MVC approach (View, Controller, Model) which has made unit testing easier by creating a mock view and testing the controller methods. I've encountered an interesting problem with exceptions. In my application, exceptions are propagated via events. My controller subscribes to an "Exception Event" contained in the model which has exception information. In the event handler, the controller takes that information and calls the View's "Display Error" method. Here's some partial code to depict what I'm doing:

interface IView
{
    public void DisplayError(string message);
}

public class Controller
{
    IView _view;
    Model _model;
    public Controller(IView view, Model model)
    {
        _view = view;
        _model = model;
        model.ErrorRaised += ErrorRaisedEventHandler(handle_error);
    }

    private void handle_error(object sender, ErrorEventArgs e)
    {
        _view.DisplayError(e.Message);
    }
}

public Model
{
    event ErrorRaisedEventHandler ErrorRaised;

    public void DoSomething()
    {
        try
        {
            //Do something bad
        }
        catch (Exception e)
        {
            ErrorRaised(this, new ErrorEventArgs(e.Message))
        }
    }
}

Is there a best practice for unit testing this? I was searching for something along the lines of asserting the output message from the exceptions but didn't get very far. Thanks!

Answer 1

Your code doesn't even compile, public Model is missing class and model.ErrorRaised += ErrorRaisedEventHandler is missing new. Please do the needful next time, as it deters people...

Working Code

public interface IView
{
    void DisplayError(string message);
}

public class MyView : IView
{
    public string ErrorMessage;
    public void DisplayError(string message)
    {
        ErrorMessage = message;
        System.Diagnostics.Debug.Write(message);
    }
}

public delegate void ErrorRaisedEventHandler(object sender, ErrorEventArgs e);

public class Controller
{
    IView _view;
    Model _model;
    public Controller(IView view, Model model)
    {
        _view = view;
        _model = model;
        _model.ErrorRaised += new ErrorRaisedEventHandler((s,e) => _view.DisplayError(e.GetException().Message));
    }
}

public class Model
{
    public event ErrorRaisedEventHandler ErrorRaised;

    int monthsAlive = 0;
    public int MonthsAliveInPlanet(int yearBorn, int yearInTime, int monthsInPlanetsYear)
    {
        try
        {
            //Do something bad - divisioin by zero
            monthsAlive = (yearInTime - yearBorn) / monthsInPlanetsYear;               
        }
        catch (Exception e)
        {
            ErrorRaised(this, new ErrorEventArgs(e));
        }
        return monthsAlive;
    }
}

Best Practice

Generally you should put all the logic in the Controller not in the Model. However, to entertain your example of raising an exception event from the Model via the Controller to the View I've written a method: MonthsAliveInPlanet.

Sometimes little bits of logic do end up in the Model, simple stuff like an Age Calculation DateTime.Now.Year - yearBorn and to simulate a Division By Zero exception I've used a "monthsInPlanetsYear".

Is there a best practice for Unit Testing this?

Probably not, you would be better moving the logic to the controller and testing that. Nevertheless, if you did want to tick the "best practice" box and write a Unit Test for it I'd recommend using the "Create IntelliTests" feature included with VS2015:

This will churn out the following generic Unit Test code (as seen above, with the 2 failing tests and 1 passing test) that you can build on to test all edge cases .

[PexClass(typeof(Model))]
[PexAllowedExceptionFromTypeUnderTest(typeof(InvalidOperationException))]
[PexAllowedExceptionFromTypeUnderTest(typeof(ArgumentException), AcceptExceptionSubtypes = true)]
[TestClass]
public partial class ModelTest
{
    /// <summary>Test stub for MonthsAliveInPlanet(Int32, Int32, Int32)</summary>
    [PexMethod]
    public int MonthsAliveInPlanetTest([PexAssumeUnderTest]Model target, int yearBorn, int yearInTime, int monthsInPlanetsYear)
    {
        int result = target.MonthsAliveInPlanet(yearBorn, yearInTime, monthsInPlanetsYear);
        return result;
        // TODO: add assertions to method ModelTest.MonthsAliveInPlanetTest(Model, Int32, Int32, Int32)
    }
}

Edge Cases

So an edge case I'd add to test the Division By Zero error message is bubbled up to the view:

[TestMethod]
/// <summary>Test stub for MonthsAliveInPlanet(Int32, Int32, Int32)</summary>
public void MonthsAliveInPlanetTestShouldFailWithZeroMonthsInYear()
{
    //Arrange
    IView view = new MyView();
    Model target = new Model();
    Controller ctrl = new Controller(view, target);                        
    int yearBorn = 0;
    int yearInTime = 0;
    int monthsInPlanetsYear = 0;

    //Act
    int result = target.MonthsAliveInPlanet(yearBorn, yearInTime, monthsInPlanetsYear);

    //Assert
    Assert.AreEqual("Attempted to divide by zero.",((MyView)view).ErrorMessage);
}

Although I've entertained the idea of trivial logic in the Model and bubbling up an error message if an exception occurs, it is not good practice .

Validate Model Data Using DataAnnotations Attributes

Exceptions are exceptional and the Model should be dumb so any View can bind to it, with the Controller doing the work. Its best practice to put all the business logic in the Controller and use DataAnnotations Attributes to validate the Model, you don't want exceptions to ever occur in the Model, eg:

public class Demo {
    [StringLength(50),Required]
    public object Name { get; set; }
    [StringLength(15)]
    public object Color { get; set; }
    [Range(0, 9999)]
    public object Weight { get; set; }
}