Algunas soluciones de mejora para la afirmación en Python

¿Por qué las afirmaciones de Python no cumplen con las expectativas?63;

El uso de las afirmaciones en Python es muy simple, puedes seguir con cualquier condición de juicio después de assert, y si la afirmación falla, lanzará una excepción.

>>> assert 1 + 1 == 2
>>> assert isinstance('Hello', str)
>>> assert isinstance('Hello', int)
Traceback (última llamada reciente):
 Archivo "<entrada>", línea 1, en <módulo>
AssertionError

En realidad, assert parece bien, pero no es agradable de usar. Por ejemplo, alguien te dice que hay un error en el programa, pero no te dice dónde está el error. Muchas veces, tales assert son mejor no escribirlos, porque los escribo y quiero gritar. Lanzar una excepción es mucho más rápido.

Solución de mejora #1

Una solución ligeramente mejorada es poner también la información necesaria detrás de la declaración assert, por ejemplo, así.

>>> s = "nothin is impossible."
>>> key = "nothing"
>>> assert key in s, "Llave: '{}' no está en Destino: '{}'".format(key, s)
Traceback (última llamada reciente):
 Archivo "<entrada>", línea 1, en <módulo>
AssertionError: Llave: 'nothing' no está en Destino: 'nothin is impossible.'

Parece bien, pero en realidad es muy molesto de escribir. Supongamos que eres un especialista en pruebas y tienes miles de casos de prueba que necesitan hacer afirmaciones y verificaciones, creemos que frente a la forma anterior, en tu corazón, definitivamente hay miles de caballos galopando.

Solución de mejora #2

Independientemente de si eres un especialista en pruebas o desarrollo, seguro que has escuchado mucho sobre marcos de prueba. ¿Te das cuenta de lo que quiero decir? Sí, no usar el mecanismo de afirmaciones del marco de prueba, ¿no te sientes decepcionado?

py.test

py.test es un framework de prueba ligero, por lo que realmente no escribió su propio sistema de afirmaciones, pero ha mejorado el sistema de afirmaciones de Python nativo, si una afirmación falla, el framework en sí proporcionará tantas razones de falla de afirmación como sea posible. Esto significa que, para implementar pruebas con py.test, no necesitas modificar una sola línea de código.

import pytest
def test_case():
  expected = "Hello"
  actual = "hello"
  assert esperado == real
if __name__ == '__main__':
  pytest.main()
"""
================================== FALLBACKES ===================================
__________________________________ test_case __________________________________
  def test_case():
    expected = "Hello"
    actual = "hello"
>    assert expected == actual
E    assert 'Hello' == 'hello'
E     - Hello
E ? ^
E     + hello
E ? ^
assertion_in_python.py:7: AssertionError
========================== 1 falló en 0.05 segundos ===========================
""""

unittest

El marco de prueba de unit testing integrado en Python tiene sus propios métodos de afirmación self.assertXXX() y no se recomienda usar la sentencia assert XXX.

import unittest
class TestStringMethods(unittest.TestCase):
  def test_upper(self):
    self.assertEqual('foo'.upper(), 'FoO')
if __name__ == '__main__':
  unittest.main()
"""
Falla
Esperado :'FOO'
Actual  :'FoO'
Traceback (última llamada reciente):
 Archivo "assertion_in_python.py", línea 6, en test_upper
  self.assertEqual('foo'.upper(), 'FoO')
AssertionError: 'FOO' != 'FoO'
"""

ptest

Me encanta ptest, gracias a Karl el gran santo por escribir esta estructura de prueba. Las afirmaciones en ptest son muy legibles y puedes completar fácilmente todas las oraciones de afirmación con la sugerencia inteligente del IDE.

from ptest.decorator import *
from ptest.assertion import *
@TestClass()
class TestCases:
  @Test()
  def test1(self):
    actual = 'foo'
    expected = 'bar'
    assert_that(expected).is_equal_to(actual)
"""
Comienza a ejecutar siguiendo 1 tests:
------------------------------
...
[demo.assertion_in_python.TestCases.test1@Test] Falló con el siguiente mensaje:
...
AssertionError: Inesperadamente la cadena <bar> no es igual a la cadena <foo>.
"""

Solución de mejora #3

No solo nosotros y yo estamos insatisfechos con las afirmaciones en Python, por lo que todos competimos por inventar nuestros propios paquetes de afirmaciones. Aquí me gustaría recomendar encarecidamente el paquete assertpy, que es extremadamente potente y muy bien recibido.

pip install assertpy

Vea el ejemplo:

from assertpy import assert_that
def test_something():
  assert_that(1 + 2).es_igual_a(3)
  assert_that('foobar')\
    .is_length(6)\
    .starts_with('foo')\
    .ends_with('bar')
  assert_that(['a', 'b', 'c'])\
    .contains('a')\
    .does_not_contain('x')

Desde su documentación de inicio puedes ver que admite prácticamente todos los escenarios de prueba que puedas imaginar, incluyendo pero no limitado a la siguiente lista.

　　　　　 Cadenas

　　　　　 Números

　　　　　 Listas

　　　　　 Tuplas

　　　　　 Dicts

　　　　　 Conjuntos

　　　　　 Booleans

　　　　　 Fechas

　　　　　 Archivos

　　　　　 Objetos

Y su información de afirmación es concisa y clara, sin más ni menos.

Se esperaba que <foo> tuviera una longitud <4, pero fue <3>.
Se esperaba que <foo> fuera una cadena vacía, pero no fue así.
Se esperaba <False>, pero no fue así.
Se esperaba que <foo> contuviera solo dígitos, pero no fue así.
Se esperaba <123Se esperaba que contuviera solo caracteres alfabéticos, pero no fue así.
Se esperaba que <foo> contuviera solo caracteres en mayúsculas, pero no fue así.
Se esperaba que <FOO> contuviera solo caracteres en minúscula, pero no fue así.
Se esperaba que <foo> fuera igual a <bar>, pero no fue.
Se esperaba que <foo> no fuera igual a <foo>, pero fue.
Se esperaba que <foo> fuera caso-Igual que <BAR>, pero no fue.

Antes de descubrir assertpy, también quería escribir un paquete similar, intentando ser lo más genérico posible. Pero ahora, ¿por qué tengo que reinventar la rueda? ¡No es necesario!

Resumen

Las afirmaciones juegan un papel muy importante en los sistemas de software, y una buena escritura puede hacer que tu sistema sea más estable. En realidad, la sentencia de fallo predeterminada de Python también tiene otro propósito, si escribes una afirmación de tipo, el IDE considerará este objeto como ese tipo, en este momento, la sugerencia inteligente es como si tuviera un ayudante.

Depende completamente de la situación real si se debe cambiar la sentencia de fallo integrada por una función de afirmación de terceros con mejor legibilidad y más poderosa. Por ejemplo, si realmente necesitas verificar algo y te preocupa el resultado de la verificación, no puedes usar assert simple; si solo te preocupa que algún punto tenga un problema o que el IDE reconozca algún objeto, el assert integrado es simple y conveniente.

Por lo tanto, la experiencia del proyecto es bastante importante. Esto es todo el contenido de este artículo, espero que el contenido de este artículo pueda ayudar a sus estudios o trabajo. Si tienen alguna pregunta, dejen comentarios para intercambiar.

Declaración: El contenido de este artículo se obtiene de la red, pertenece a los propietarios originales, se contribuye y carga por los usuarios de Internet, este sitio no posee los derechos de propiedad, no se ha editado manualmente y no asume la responsabilidad legal relacionada. Si encuentra contenido sospechoso de copyright, le invitamos a enviar un correo electrónico a: notice#oldtoolbag.com (al enviar un correo electrónico, reemplaza # con @ para denunciar y proporciona pruebas relacionadas. Una vez verificada, este sitio eliminará inmediatamente el contenido sospechoso de infracción.)