VS2008 tests unitaires - sorties de méthode assert

Question

Je suis en train d'écrire un C # test unitaire avec VS 2008 de cadre de tests unitaires intégré et la méthode que je teste Environment.Exit(0) appels. Quand j'appelle cette méthode dans mon test unitaire, mon test unitaire est Aborted. La méthode doit en effet appeler Exit, et je veux un moyen de tester qu'il fait, et aussi pour tester le code de sortie qu'il utilise. Comment pourrais-je faire cela? Je regardais Microsoft.VisualStudio.TestTools.UnitTesting Namespace mais ne voit rien qui semblait pertinent.

[TestMethod]
[DeploymentItem("myprog.exe")]
public void MyProgTest()
{
    // Want to ensure this Exit's with code 0:
    MyProg_Accessor.myMethod();
}

En attendant, voici l'essentiel du code que je veux tester:

static void myMethod()
{
    Environment.Exit(0);
}

Modifier voici la solution je dans ma méthode d'essai, grâce à RichardOD :

Process proc;

try
{
    proc = Process.Start(path, myArgs);
}
catch (System.ComponentModel.Win32Exception ex)
{
    proc = null;
    Assert.Fail(ex.Message);
}

Assert.IsNotNull(proc);
proc.WaitForExit(10000);
Assert.IsTrue(proc.HasExited);
Assert.AreEqual(code, proc.ExitCode);

Answer 1

Cela ressemble à une idée incroyablement mauvaise. Environment.Exit (0), fera évidemment comme prévu, donc pourquoi votre unité testings rompent.

Si vous voulez vraiment tester encore ce que vous pouvez en lançant un processus séparé et vérifier le retour code- un coup d'oeil à l'envelopper dans Process.Start .

Je suppose que l'autre option est l'affacturage et ce code à l'injection d'un , ou à l'aide un objet fictif pour vérifier le comportement correct.

Peut-être que vous pouvez faire quelque chose avec Typemock Isolator- Je crois que cela vous permet de méthodes statiques simulées .

Answer 2

Vous devez créer une enveloppe pour la classe environnement, puis utilisez l'emballage dans votre code. Pour vos tests unitaires, injecter une version maquette de l'emballage. L'exemple suivant utilise RhinoMocks pour vérifier que la méthode appelle l'enveloppe avec l'argument attendu.

public class EnvironmentWrapper
{
    public virtual void Exit( int code )
    {
        Environment.Exit( code );
    }
}


public class MyClass
{
    private EnvironmentWrapper Environment { get; set; }

    public MyClass() : this( null ) { }

    public MyClass( EnvironmentWrapper wrapper )
    {
        this.Environment = wrapper ?? new EnvironmentWrapper();
    }

    public void MyMethod( int code )
    {
        this.Environment.Exit( code )
    }
}


[TestMethod]
public void MyMethodTest()
{
     var mockWrapper = MockRepository.GenerateMock<EnvironmentWrapper>();

     int expectedCode = 5;

     mockWrapper.Expect( m => m.Exit( expectedCode ) );

     var myClass = new MyClass( mockWrapper );

     myclass.MyMethod( expectedCode );

     mockWrapper.VerifyAllExpectations()
}

Answer 3

Vous ne pourrez pas tester cette - Environment.Exit tue complètement l'application. Cela signifie que toute AppDomain qui utilise ce code sera déchargé complètement, que ce soit votre demande de production ou le cadre de tests unitaires.

Answer 4

Votre seule option serait ici de se moquer de la classe environnement avec une méthode de sortie fakie.

Answer 5

Vous pouvez ajouter un argument à votre méthode pour passer un environnement faux où la méthode exit () ne quittera pas.

Vous pouvez cette méthode extraite de la paramétrisé méthode appelée à partir de votre application, et l'unité de tester la fonction extraite. De cette façon, vous ne devez modifier votre application.

Answer 6

La seule chose qui me vient à l'esprit est quelque chose le long:

static void myMethod()
{
    DoEnvironmentExit(0);
}

static void DoEnvironentExit(int code)
{
    #if defined TEST_SOLUTION
      SomeMockingFunction(code);
    #else
      Environment.Exit(code);
    #endif
}