对其中包含Environment.Exit（）调用的方法进行单元测试

Question

I have a public method say,

public void ErrorEncounter()
{
//Global Error Counter
gblErrorCount++;

//Process tremination
Environment.Exit();
}

This method terminates whenever it is called. However, it will update the Global Error Count which i'm suppose to test. Is there any way to perform Unit Testing on this method?

I'm Using NUnit Framework for Unit Testing.

Answer 1

This method is designed to be difficult to test!

Most obviously, because it terminates the application when called. But also because it changes a global (I assume static) variable. Both of these things prevent writing a good unit test that calls the method.

Three ways around this: 1. Eliminate the method 2. Don't test the method 3. Modify the method

Option 1. If this method only called exit, then you could simply drop it and call Exit directly. However, that would make some other method difficult to test, so this isn't really a great option.

Option 2. Sometimes a method is so simple that you can avoid testing it. Whether this is such a method depends on how gblErrorCount is used elsewhere. It would appear, however, that incrementing the count has no effect, since the process immediately exits.

Option 3. Modify the method and those methods that call it. One approach would be to use an event handling mechanism and terminate the app in the event handler. You could make this easier to test by injecting a different event handler when running tests.

IOW, this is basically a pretty untestable method. Hopefully, you are in control of the system under test and can change it.

Answer 2

This question contains answers that show how Environment.Exit() can be tested. Constructor Dependency Injection

One option is to convert it into a dependency by injecting it through an interface :

interface ITerminator
{
    void Exit();
}

class RealTerminator
{
    void Exit()=>Environment.Exit();
}

public class MyErrorChecker
{
    ITerminator _terminator;
    public class MyErrorChecker(ITerminator terminator)
    {
        _terminator=terminator;
    }

    public void ErrorEncounter()
    {
        //Global Error Counter
        gblErrorCount++;

        //Process tremination
        _terminator.Exit();
    }
}

The test project will implement a fake terminator class that sets a flag if Exit is called:

class FakeTerminator:ITerminator
{
    public bool Called{get;private set;}
    public void Exit()
    {
        Called=true;
    }
}

Mocking

Another option is to mock it by extracting the call to a virtual method that can be replaced in a mock class :

public void ErrorEncounter()
{
    //Global Error Counter
    gblErrorCount++;

    //Process tremination
    ForceExit();
}

internal virtual void ForceExit()
{
    Environment.Exit();
}

The test project could create a mock error checker class:

class MockErrorChecker:MyErrorChecker
{
    public bool Called{get;private set;}
    public override void ForceExit()
    {
        Called=true;
    }
}

Function injection

This option isn't included in the linked question. Pass an exit Action as a parameter to ErrorEncounter whose default will be to call Environment.Exit() :

    public void ErrorEncounter(Action exitFn=null)
    {
        var doExit=exitFn ?? (()=>Environment.Exit());
        //Global Error Counter
        gblErrorCount++;

        //Process tremination
        doExit();
    }

The test could pass its own function that sets a flag:

[Test]
public void Test_Exit_Is_Called
{
    bool called;
    void fakeExit() { called=true; }

    thatClass.ErrorEncounter(fakeExit);

    Assert.True(called);
}