¿Hay algún valor en escribir una prueba unitaria que sea un subconjunto de otra prueba?

Para dar un ejemplo ligeramente artificial, digamos que quiero probar que una función devuelve dos números y que el primero es más pequeño que el segundo:

def test_length():
    result = my_function()
    assert len(result) == 2

def test_order()
    a, b = my_function()
    assert a < b

Aquí, si test_lengthfalla, test_ordertambién fallará. ¿Es una buena práctica escribir test_lengthu omitirlo?

EDITAR: tenga en cuenta que en esta situación, ambas pruebas son en su mayoría independientes entre sí, cada una se puede ejecutar de forma aislada, o se pueden ejecutar en orden inverso, esto no importa. Entonces ninguna de estas preguntas anteriores

• ¿Cómo debo probar la funcionalidad de una función que usa otras funciones en ella?
• ¿Necesito una prueba unitaria si ya tengo una prueba de integración?
• ¿Cómo estructurar pruebas donde una prueba es la configuración de otra prueba?
• Cómo gestionar la dependencia exitosa entre pruebas unitarias

es un duplicado del anterior.

Puede haber valor, pero esto es un poco oloroso. O tus pruebas no están bien aisladas (ya que test_orderrealmente prueban dos cosas) o estás siendo demasiado dogmático en tus pruebas (haciendo que dos pruebas prueben lo mismo lógico).

En el ejemplo, fusionaría las dos pruebas juntas. Sí, significa que tienes múltiples afirmaciones. Demasiado. Todavía estás probando una sola cosa: el resultado de la función. A veces en el mundo real eso significa hacer dos controles.

Sus pruebas deben ser explícitas. No se infiere completamente que si text_length falla test_order falla.

No estoy seguro de cómo va en Python lo que has publicado, pero si len(result)es 3, el primero fallará pero el segundo puede pasar (y si no es en Python, seguro que en idiomas como JavaScript).

Como dijiste, quieres probar que la función devuelve dos números y que están en orden. Dos pruebas lo es.

El único valor de test_lengthaquí es que, si todo pasa, su sola presencia indica que se ha probado la "longitud".

Por lo tanto, es realmente innecesario tener ambas pruebas. Mantenga solo test_orderpero considere renombrarlo test_length_and_order.

Por cierto, encuentro el uso de nombres que comienzan con testun poco torpe. Soy un gran defensor de los nombres de las pruebas que realmente describen la condición que estás afirmando.

Dejaría estas pruebas separadas si así es como han evolucionado para ser. Sí test_orderes probable que falle siempre que lo test_lengthhaga, pero definitivamente sabes por qué.

También estoy de acuerdo en que si test_orderapareció primero y encontró una falla comprobable, es posible que el resultado no fueran dos valores, agregando esa verificación como asserty cambiando el nombre de la prueba para que test_length_and_ordertenga sentido.

Si tuviera que verificar también que los tipos de valores devueltos eran enteros, lo incluiría en esta prueba de resultados "general".

Pero tenga en cuenta que ahora tiene una batería de pruebas para el resultado de my_function(). Si hay múltiples contextos (o, más probablemente, múltiples parámetros) para probar esto, ahora puede ser una subrutina para probar todos los resultados my_function().

Sin embargo, cuando escribo pruebas unitarias, normalmente pruebo el borde y los casos incorrectos por separado de una buena entrada y una salida normal (en parte porque la mayoría de mis pruebas "unitarias" son a menudo pruebas de mini integración), y a menudo con múltiples afirmaciones, que solo están rotas en pruebas separadas si fallan en formas en las que encuentro que quiero más información sin depurar.

Así que probablemente comenzar con sus pruebas por separado y ampliar test_lengtha test_length_and_typesy dejar test_orderaparte, suponiendo que este último se ve que es "proceso normal".