Es Decir.Fail() considera una mala práctica?

Question

Yo uso la Aserción.Falla mucho a la hora de hacer TDD.Normalmente estoy trabajando en una prueba en un tiempo, pero cuando tengo ideas para cosas que quiero implementar más tarde he de escribir rápidamente un vacío de la prueba, donde el nombre del método de prueba indica lo que quiero implementar como una especie de todo-lista.Para asegurarse de que yo no me olvide de poner una Aserción.Fail() en el cuerpo.

Al probar xUnit.Net me encontré que no había implementado Valer.Error.Por supuesto, usted siempre puede Valer.IsTrue(falso), pero esto no comunicar mi intención también.Tengo la impresión de Afirmar.Fallar no fue implementado a propósito.Es este considera una mala práctica?Si es así ¿por qué?

---

@Martin Meredith Eso no es exactamente lo que yo hago.Yo no escribo una prueba primero y, a continuación, implementar el código para que funcione.Por lo general, yo creo que de varias pruebas a la vez.O pienso en una prueba a escribir cuando estoy trabajando en algo más.Que cuando escribo un vacío de la prueba infalible para recordar.Al momento de llegar a la escritura de la prueba me esmero de trabajo de pruebas en primer lugar.

@Jimmeh Eso parece una buena idea.Ignoró las pruebas no fallan, pero todavía se muestran en una lista separada.Tenemos que intentar que fuera.

@Matt Howells Gran Idea.NotImplementedException se comunica la intención mejor que hacer valer.Fail() en este caso

@Mitch Trigo Eso es lo que estaba buscando.Parece que fue dejado fuera para evitar que se abuse de ella en otra forma de abuso de él.

Answer 1

Para este escenario, en lugar de llamar a Afirmar.No, me hago la siguiente (en C# / NUnit)

[Test]
public void MyClassDoesSomething()
{
    throw new NotImplementedException();
}

Es más explícita que una Aserción.Error.

Parece haber acuerdo general en que es preferible utilizar más explícitas afirmaciones que Afirmar.Fail().La mayoría de los marcos tiene que incluirlo, porque aunque no ofrecen una alternativa mejor.Por ejemplo, NUnit (y otros) proporcionar un ExpectedExceptionAttribute para probar que el código de lanza de una clase particular de excepción.Sin embargo, con el fin de probar que una propiedad en la excepción que se establece en un valor determinado, uno no se puede utilizar.En lugar de tener que recurrir a Afirmar.Error:

[Test]
public void ThrowsExceptionCorrectly()
{
    const string BAD_INPUT = "bad input";
    try
    {
        new MyClass().DoSomething(BAD_INPUT);
        Assert.Fail("No exception was thrown");
    }
    catch (MyCustomException ex)
    {
         Assert.AreEqual(BAD_INPUT, ex.InputString); 
    }
}

El xUnit.Net método Assert.Lanza hace esto mucho más limpio sin necesidad de una Aserción.Falla del método.Mediante la no inclusión de una Aserción.Fail() método xUnit.Net anima a los desarrolladores a encontrar y utilizar más explícita de las alternativas, y para apoyar la creación de nuevas afirmaciones cuando sea necesario.

Answer 2

Fue deliberadamente fuera.Este es Brad Wilson respuesta en cuanto a por qué no Afirmar.Fail():

No nos pasan por alto este hecho.Yo encontrar Valer.No es una muleta que implica que es probable que haya un afirmación de que falta.A veces es sólo la forma en que la prueba está estructurada, y a veces es porque podría Valer utilizar otra afirmación.

Answer 3

Yo siempre he usado la Aserción.Fail() para el manejo de casos en donde se ha detectado que una prueba de falla a través de la lógica más allá de la simple comparación de valor.Como un ejemplo:

try 
{
  // Some code that should throw ExceptionX
  Assert.Fail("ExceptionX should be thrown")
} 
catch ( ExceptionX ex ) 
{
  // test passed
}

Por tanto, la falta de Afirmar.Fail() en el marco parece un error para mí.Te sugiero que parchear la clase Assert para incluir un Fail() método y, a continuación, enviar el parche en el marco de los desarrolladores, junto con su razonamiento para la adición.

Como para su práctica de la creación de pruebas que intencionalmente a fracasar en su área de trabajo, para recordar a implementar antes de comprometerse, que parece una multa práctica para mí.

Answer 4

Yo uso MbUnit para mi Unidad de Pruebas.Tienen una opción para Omitir las pruebas, que se muestran como la Naranja (en lugar de Verde o Rojo) en la suite de prueba.Tal vez xUnit tiene algo similar, y significaría que usted incluso no tiene que poner ningún afirmar en el método, porque sería una muestra en una molestamente de color diferente, lo que es difícil perderse?

Editar:

En MbUnit es de la siguiente manera:

[Test]
[Ignore]
public void YourTest()
{ } 

Answer 5

Este es el modelo que yo uso cuando solicitarlo a través de un test para el código que quiero lanzar una excepción por el diseño:

[TestMethod]
public void TestForException()
{
    Exception _Exception = null;

    try
    {
        //Code that I expect to throw the exception.
        MyClass _MyClass = null;
        _MyClass.SomeMethod();
        //Code that I expect to throw the exception.
    }
    catch(Exception _ThrownException)
    {   
        _Exception = _ThrownException
    }
    finally
    {
        Assert.IsNotNull(_Exception);
        //Replace NullReferenceException with expected exception.
        Assert.IsInstanceOfType(_Exception, typeof(NullReferenceException));
    }
}

En mi humilde opinión esta es una mejor manera de realizar pruebas de las excepciones sobre el uso de la Aserción.Fail().La razón de esto es que no sólo me prueba para una excepción en todo, pero yo también la prueba para el tipo de excepción.Me doy cuenta de que esto es similar a la respuesta de Matt Howells pero en mi humilde opinión utilizando el bloque finally es más robusto.

Obviamente, todavía sería posible incluir otros Afirman los métodos de prueba de las excepciones de la cadena de entrada, etc.Agradecería sus comentarios y opiniones sobre mi patrón.

Answer 6

Personalmente no tengo ningún problema con el uso de un conjunto de pruebas como una lista de tareas como este tan largo como el tiempo de poner en torno a la escritura de la prueba antes de implementar el código para pasar.

Habiendo dicho eso, yo solía usar este enfoque mí mismo, aunque ahora me estoy dando cuenta de que al hacerlo me lleva por un camino de escribir demasiadas pruebas iniciales, que de un modo extraño, es como el problema inverso de no escribir pruebas a todos:terminas la toma de decisiones sobre el diseño de un poco demasiado pronto en mi humilde opinión.

Por cierto en MSTest la Prueba estándar de plantilla utiliza la Aserción.Concluyentes al final de sus muestras.

AFAIK la xUnit.NET marco está diseñado para ser extremadamente ligero y sí que lo hizo cortar deliberadamente Fracasar, a animar a los desarrolladores a utilizar una explícita condición de error.

Answer 7

Conjetura:la retención de la Aserción.No es la intención de dejar de pensar que una buena manera de escribir el código de la prueba es como un enorme montón de espaguetis que conduce a una Aserción.Fallar en los casos graves.[Editar para agregar:las respuestas confirman a este, pero con citas]

Ya no es lo que estás haciendo, es posible que xUnit.Net está siendo sobre-protectora.

O tal vez simplemente creo que sea tan raro y tan unorthogonal como innecesarias.

Yo prefiero a implementar una función llamada ThisCodeHasNotBeenWrittenYet (en realidad algo más cortos, por la facilidad de escribir).No se puede comunicar la intención más clara de que, y usted tiene un preciso término de búsqueda.

Si se produce un error, o no está implementado (para provocar un error del vinculador), o es una macro que no se compila, se puede cambiar para adaptarse a su preferencia actual.Por ejemplo cuando se desea ejecutar algo que es terminado, usted quiere un error.Cuando esté sentado a deshacerse de todos ellos, es posible que desee un error de compilación.

Answer 8

Con el buen código que suele hacer:

void goodCode() {
     // TODO void goodCode()
     throw new NotSupportedOperationException("void goodCode()");
}

Con el código de prueba que suele hacer:

@Test
void testSomething() {
     // TODO void test Something
     Assert.assert("Some descriptive text about what to test")
}

Si el uso de JUnit, y no quiero llegar a ser el error, pero el error, yo suelo hacer:

@Test
void testSomething() {
     // TODO void test Something
     throw new NotSupportedOperationException("Some descriptive text about what to test")
}

Answer 9

Ten cuidado Assert.Fail y su influencia corruptora para hacer a los desarrolladores a escribir tonto o roto pruebas.Por ejemplo:

[TestMethod]
public void TestWork()
{
    try {
        Work();
    }
    catch {
        Assert.Fail();
    }
}

Este es tonto, porque el try-catch es redundante.Una prueba falla si no se lanza una excepción.

También

[TestMethod]
public void TestDivide()
{
    try {
        Divide(5,0);
        Assert.Fail();
    } catch { }
}

Este está roto, la prueba pasará siempre sea cual sea el resultado de la división de la función.De nuevo, una prueba falla si y sólo si se produce una excepción.

Answer 10

¿Por qué usar la Aserción.Fallar para decir que una excepción debe ser lanzado?Que es innecesario.Por qué no usar simplemente el ExpectedException atributo?

Answer 11

Si estás escribiendo un ensayo que acaba de falla, y luego escribir el código para, a continuación, escribir la prueba.Esto no es Desarrollo dirigido por Pruebas.

Técnicamente, Afirman.fail() no debería ser necesario si usted está utilizando el test driven development correctamente.

¿Has pensado en utilizar una Lista de Tareas, o la aplicación de una metodología GTD para su trabajo?

Answer 12

MS que la Prueba ha La aserción.Fail() pero también tiene La aserción.No concluyentes().Creo que el uso más apropiado de la Aserción.Fail() es que si tienes algunos en la línea de la lógica, que sería difícil de poner en una afirmación, aunque ni siquiera puedo pensar en ninguna buena ejemplos.Para la mayor parte, si la prueba framework admite otra cosa que Afirmar.Fail (), a continuación, utilizar ese.

Answer 13

Creo que usted debe preguntarse qué (por adelantado) el ensayo debe hacer.

Primero, escriba un (conjunto de) prueba sin aplicación.Tal vez, también el día de lluvia escenarios.

Todas esas pruebas deben fallar, al ser pruebas correctas:Así que usted quiere lograr dos cosas:1) Verificar que su aplicación es correcta;2) Verificar que las pruebas unitarias son correctos.

Ahora, si se hace por adelantado TDD, se desea ejecutar todas las pruebas, también, el de la JNI de las partes.El resultado de su total ejecución de la prueba pasa si:1) Todos implementado cosas correctamente 2) Todos los de la JNI de cosas falla

Después de todo, sería una prueba de unidad ommision si su unidad de pruebas se realiza correctamente, mientras que no hay ninguna aplicación, no?

Quieres terminar con algo de un correo electrónico de su continua integración de la prueba que comprueba que todo implementado y no se implementa el código, y se envía si cualquier implementado el código de falla, o cualquier no se implementa el código se ejecuta correctamente.Ambos son resultados no deseados.

Sólo tienes que escribir un [ignorar] pruebas de no hacer el trabajo.Ninguno de los dos, una afirma que deja un la primera alegar la falta, no se ejecuta otras pruebas de líneas en la prueba.

Ahora, ¿cómo lograr esto, entonces?Creo que se requiere más avanzadas de organización de las pruebas.Y se requiere de algún otro mecanismo, a continuación, afirma que para lograr estas metas.

Creo que usted tiene que dividir sus pruebas y crear algunos de los exámenes que completamente de ejecución, sino que debe fallar, y viceversa.

Las Ideas son para dividir sus pruebas a través de varias asambleas, uso de agrupación de las pruebas (ordenado pruebas en mstest puede hacer el trabajo).

Aún así, un CI de construir que los correos que si no todas las pruebas en el departamento de la JNI fallar no es fácil y sencillo.