¿Cómo verifico “no ocurrió ninguna excepción” en mi prueba de unidad MSTest?

Estoy escribiendo una prueba unitaria para este método que devuelve "void". Me gustaría tener un caso en el que la prueba pase cuando no se lanza ninguna excepción. ¿Cómo escribo eso en C #?

Assert.IsTrue(????)

(Supongo que así es como debería comprobarlo, pero ¿qué entra en "???")

Espero que mi pregunta sea lo suficientemente clara.

Su prueba unitaria fallará de todos modos si se lanza una excepción; no es necesario que ingrese una afirmación especial.

Este es uno de los pocos escenarios en los que verá pruebas unitarias sin ninguna afirmación: la prueba fallará implícitamente si se genera una excepción.

Sin embargo, si realmente deseaba escribir una afirmación para esto, tal vez para poder detectar la excepción e informar "no esperaba ninguna excepción pero obtuve esto ...", puede hacer esto:

[Test]
public void TestNoExceptionIsThrownByMethodUnderTest()
{
    var myObject = new MyObject();

    try
    {
        myObject.MethodUnderTest();
    }
    catch (Exception ex)
    {
        Assert.Fail("Expected no exception, but got: " + ex.Message);
    }
}

(lo anterior es un ejemplo para NUnit, pero lo mismo es válido para MSTest)

En NUnit, puedes usar:

Assert.DoesNotThrow(<expression>); 

para afirmar que su código no lanza una excepción. Aunque la prueba fallaría si se lanza una excepción, incluso si no hubiera Assert a su alrededor, el valor de este enfoque es que luego puede distinguir entre las expectativas no cumplidas y los errores en sus pruebas, y tiene la opción de agregar un mensaje personalizado que se mostrará en su salida de prueba. Una salida de prueba bien redactada puede ayudarlo a localizar errores en su código que han provocado que una prueba falle.

Creo que es válido agregar pruebas para asegurarse de que su código no arroje excepciones; por ejemplo, imagina que estás validando una entrada y necesitas convertir una cadena entrante en una larga. Puede haber ocasiones en las que la cadena sea nula, y esto es aceptable, por lo que debe asegurarse de que la conversión de la cadena no genere una excepción. Por lo tanto, habrá un código para manejar esta ocasión, y si no ha escrito una prueba, se perderá la cobertura de una parte importante de la lógica.

No pruebes que algo no sucede . Es como asegurarse de que el código no se rompa . Eso es algo implícito, todos nos esforzamos por lograr un código que no se rompa ni tenga errores. ¿Quieres escribir pruebas para eso? ¿Por qué solo un método? ¿No desea que se prueben todos sus métodos para que no produzcan alguna excepción ? Siguiendo ese camino, terminarás con una prueba adicional, ficticia y sin aseveraciones para cada método en su base de código. No aporta ningún valor.

Por supuesto, si su requerimiento es para verificar método hace excepciones de captura , lo hace la prueba de que (o marcha atrás un poco, prueba de que no tira lo que se supone que la captura).

Sin embargo, el enfoque / prácticas generales permanecen intactos: no escribe pruebas para algunos requisitos artificiales / vagos que están fuera del alcance del código probado (y probar que "funciona" o "no arroja" suele ser un ejemplo de tal, especialmente en un escenario en el que las responsabilidades del método son bien conocidas).

En pocas palabras: concéntrate en lo que tiene que hacer tu código y pruébalo.

Esta clase de ayuda me rascó la picazón con MSTest. Quizás también pueda rayar el tuyo.

[TestMethod]
public void ScheduleItsIneligibilityJob_HasValid_CronSchedule()
{
    // Arrange
    var factory = new StdSchedulerFactory();
    IScheduler scheduler = factory.GetScheduler();

    // Assert
    AssertEx.NoExceptionThrown<FormatException>(() =>
        // Act
        _service.ScheduleJob(scheduler)
    );
}

public sealed class AssertEx
{
    public static void NoExceptionThrown<T>(Action a) where T:Exception
    {
        try
        {
            a();
        }
        catch (T)
        {
            Assert.Fail("Expected no {0} to be thrown", typeof(T).Name);
        }
    }
}

Me gusta ver un Assert.Whatever al final de cada prueba, solo por coherencia ... sin uno, ¿puedo estar seguro de que no debe haber uno allí?

Para mí, esto es tan simple como poner Assert.IsTrue(true);

Yo sé que no me accidentalmente puse ese código en allí, y por lo tanto debería tener la suficiente confianza en una rápida descremada a través de que se trataba de la forma prevista.

    [TestMethod]
    public void ProjectRejectsGappedVersioningByDefault() {

        var files = new List<ScriptFile>();
        files.Add(ScriptProjectTestMocks.GetVersion1to2());
        files.Add(ScriptProjectTestMocks.GetVersion3to4());

        Assert.Throws<ScriptProject.InvalidProjectFormatException>(() => {
            var sut = new ScriptProject(files);
        });

    }

    [TestMethod]
    public void ProjectAcceptsGappedVersionsExplicitly() {

        var files = new List<ScriptFile>();
        files.Add(ScriptProjectTestMocks.GetVersion1to2());
        files.Add(ScriptProjectTestMocks.GetVersion3to4());

        var sut = new ScriptProject(files, true);

        Assert.IsTrue(true);   // Assert.Pass() would be nicer... build it in if you like

    }

Mi amigo Tim me habló de ExpectedException . Realmente me gusta esto porque es más conciso, menos código y muy explícito que está probando una excepción.

[TestMethod()]
[ExpectedException(typeof(System.Exception))]
public void DivideTest()
{
    int numerator = 4;
    int denominator = 0;
    int actual = numerator / denominator;
}

Puedes leer mucho más sobre esto aquí: Uso de atributo de excepción esperada .