Saltar al contenido

Tutorial de PyTest: Qué es, Instalar, Fijar, Afirmar

diciembre 8, 2019

¿Qué es PyTest?

Pytest es un marco de pruebas que nos permite escribir códigos de prueba usando python. Puedes escribir código para probar cualquier cosa como la base de datos , API, incluso la interfaz de usuario si quieres. Pero pytest se utiliza principalmente en la industria para escribir pruebas para APIs.

¿Por qué utilizar PyTest?

Algunas de las ventajas de pytest son

  • Muy fácil de empezar por su sintaxis simple y fácil.
  • Puede realizar pruebas en paralelo.
  • Puede ejecutar una prueba específica o un subconjunto de pruebas
  • Detección automática de pruebas
  • Saltar pruebas
  • Código abierto

En este tutorial, aprenderá:

  • ¿Qué es PyTest?
  • ¿Por qué utilizar PyTest?
  • Cómo instalar PyTest
  • Primer PyTest Básico
  • Afirmaciones en PyTest
  • Cómo pytest identifica los archivos y métodos de prueba
  • Ejecute múltiples pruebas desde un archivo específico y múltiples archivos.
  • Ejecutar un subconjunto de la prueba completa
  • Ejecución de pruebas en paralelo
  • Accesorios Pytest
  • Pruebas parametrizadas
  • Xfail / Saltar pruebas
  • Resultados XML
  • Un marco de trabajo pytest probando una API

Cómo instalar PyTest

Paso 1) Puede instalar pytest por

pip install pytest==2.9.1 

Una vez finalizada la instalación, puede confirmarla con

py.test -h

Esto mostrará la ayuda

Primer PyTest Básico

Cree una carpeta study_pytest. Vamos a crear nuestros archivos de prueba dentro de esta carpeta.

Por favor, navegue a esa carpeta en su línea de comandos.

Cree un archivo llamado test_sample1.py dentro de la carpeta

Añada el siguiente código y guarde

importación de pruebas
def archivo_de_prueba1_method1():
	x=5
	y=6
	afirmar x+1 == y, "prueba fallida"
	afirmar x == y, "prueba fallida"
def archivo_de_prueba1_method2():
	x=5
	y=6
	afirmar x+1 == y, "prueba fallida"

>

Ejecute la prueba utilizando el comando

Prueba de pimienta
>

Obtendrá la salida como

test_sample1.py F.
=======================================================================================================================================
Muestra_de_prueba1 ______________________________________________________________________.
    def archivo_de_prueba1_method1():
    	x=5
    	y=6
       	afirmar x+1 == y, "prueba fallida"
Afirmar x == y, "prueba fallida"
E AssertionError: prueba fallida
E afirmar 5 == 6
test_sample1.py:6: AfirmaciónError

>

Aquí en test_sample1.py F.

F dice falla

Dot(.) dice éxito.

En la sección de fallos, puede ver los métodos fallidos y la línea de fallo. Aquí x===y significa 5===6 lo cual es falso.

Afirmaciones en PyTest

Las afirmaciones son cheques que devuelven el estado Verdadero o Falso. En pytest, si una afirmación falla en un método de prueba, entonces la ejecución del método se detiene allí. El código restante en ese método de prueba no se ejecuta, y pytest continuará con el siguiente método de prueba.

Ejemplos:

assert “hello” == “Hai” es un fracaso de aserción.
assert 4==4 es una afirmación exitosa
asserert True es una afirmación exitosa
asserert False es un fracaso de aserción.
>

Considerar

afirmar x == y, "prueba fallida porque x=" + str(x) + " y=" + str(y)

>

Coloque este código en el archivo test_file1_method1() en lugar de la aserción

afirmar x == y, "prueba fallida"

>

Ejecutar la prueba dará el fallo como AssertionError: test failed x=5 y=6

Cómo pytest identifica los archivos y métodos de prueba

Por defecto, pytest sólo identifica los nombres de archivo que comienzan con test_ o terminan con _test como archivos de prueba. Sin embargo, podemos mencionar explícitamente otros nombres de archivo (que se explicarán más adelante). Pytest requiere que los nombres de los métodos de prueba empiecen por “test . Todos los demás nombres de métodos serán ignorados incluso si pedimos explícitamente que se ejecuten esos métodos.

Vea algunos ejemplos de nombres de archivos pytest válidos e inválidos

test_login.py – válido
login_test.py – válido
testlogin.py -inválido
logintest.py -inválido
>

Nota: Sí, podemos pedir explícitamente a pytest que elija testlogin.py y logintest.py

Vea algunos ejemplos de métodos de prueba de pytest válidos e inválidos

def archivo_de_prueba1_metodo1(): - válido
def testfile1_method1(): - valid
def file1_method1(): - inválido	

>

Nota: Incluso si mencionamos explícitamente file1_method1() pytest no ejecutará este método.

Ejecute múltiples pruebas desde un archivo específico y múltiples archivos.

Actualmente, dentro de la carpeta study_pytest, tenemos un archivo test_sample1.py. Supongamos que tenemos múltiples archivos, digamos test_sample2.py, test_sample3.py. Para ejecutar todas las pruebas desde todos los archivos de la carpeta y subcarpetas sólo tenemos que ejecutar el comando pytest.

py.test

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>””””””i

Esto ejecutará todos los nombres de archivo comenzando con test_ y los nombres de archivo terminando con _test en esa carpeta y subcarpetas bajo esa carpeta.

Para ejecutar pruebas sólo desde un archivo específico, podemos usar py.test <filename>

prueba.test_muestra1.py

>Prueba.test

Ejecutar un subconjunto de la prueba completa

A veces no queremos ejecutar todo el paquete de pruebas. Pytest nos permite realizar pruebas específicas. Podemos hacerlo de 2 maneras

  • Agrupación de nombres de prueba por coincidencia de substring
  • Agrupación de pruebas por marcadores

Ya tenemos test_sample1.py. Cree un archivo test_sample2.py y añada el siguiente código

def archivo_de_prueba2_metodo1():
	x=5
	y=6
	afirmar x+1 == y, "prueba fallida"
	afirmar x === y, "prueba fallida porque x=" + str(x) + " y=" + str(y)
def archivo_de_prueba2_method2():
	x=5
	y=6
	afirmar x+1 == y, "prueba fallida"

>

Así que actualmente tenemos

>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>>
  • test_sample1.py
    • archivo_de_prueba1_metodo1()
    • archivo_de_prueba1_metodo2()
  • test_sample2.py
    • archivo_de_prueba2_method1()
    • archivo_de_prueba2_method2()

>

Opción 1) Ejecutar pruebas por concordancia de substring

Aquí para ejecutar todas las pruebas con el método 1 en su nombre tenemos que ejecutar

>

Así que ejecutar py.test -k método1 -v le dará el siguiente resultado

test_sample2.py::archivo_de_prueba2_metodo1 FALLIDO
test_sample1.py::archivo_de_prueba1_metodo1 FALLIDO
===================================================================================================================================================
__________________________________________archivo_de_prueba2_método1 ______________________________________________________________.
    def archivo_de_prueba2_method1():
    	x=5
    	y=6
       	afirmar x+1 == y, "prueba fallida"
> afirme x === y, "prueba fallida porque x=" + str(x) + " y=" + str(y)
E AssertionError: prueba fallida porque x=5 y=6
E afirmar 5 == 6
test_sample2.py:5: AfirmaciónError
__________________________________________archivo_de_prueba1_método1 ______________________________________________________________.
    @pytest.mark.only
    def archivo_de_prueba1_method1():
    	x=5
    	y=6
       	afirmar x+1 == y, "prueba fallida"
> afirme x === y, "prueba fallida porque x=" + str(x) + " y=" + str(y)
E AssertionError: prueba fallida porque x=5 y=6
E afirmar 5 == 6
test_sample1.py:8: AfirmaciónError
===================================================================================================================================================================
============================================================================================================================================================================

>

Aquí puede ver hacia el final 2 pruebas deseleccionadas por $0027-kmethod1$0027 que son test_file1_method2 y test_file2_method2

Intente ejecutar con varias combinaciones como:-

pre>py.test -k método -v – ejecutará los cuatro métodos
py.test -k methods -v – no ejecutará ninguna prueba ya que no hay ningún nombre de prueba que coincida con la subcadena $0027methods$0027.
>

Opción 2) Ejecutar pruebas con marcadores

Pytest nos permite establecer varios atributos para los métodos de prueba usando marcadores de pytest, @pytest.mark. Para usar marcadores en el archivo de prueba, necesitamos importar pytest en los archivos de prueba.

Aquí aplicaremos diferentes nombres de marcadores para probar métodos y realizar pruebas específicas basadas en nombres de marcadores. Podemos definir los marcadores en cada nombre de prueba usando

@pytest.mark.<name>.			

>

Estamos definiendo los marcadores set1 y set2 en los métodos de prueba, y ejecutaremos la prueba usando los nombres de los marcadores. Actualice los archivos de prueba con el siguiente código

test_sample1.py

importación de pruebas
@pytest.mark.set1
def archivo_de_prueba1_method1():
	x=5
	y=6
	afirmar x+1 == y, "prueba fallida"
	afirmar x === y, "prueba fallida porque x=" + str(x) + " y=" + str(y)
@pytest.mark.set2
def archivo_de_prueba1_method2():
	x=5
	y=6
	afirmar x+1 == y, "prueba fallida"

>

test_sample2.py

importación de pruebas
@pytest.mark.set1
def archivo_de_prueba2_method1():
	x=5
	y=6
	afirmar x+1 == y, "prueba fallida"
	afirmar x === y, "prueba fallida porque x=" + str(x) + " y=" + str(y)
@pytest.mark.set1
def archivo_de_prueba2_method2():
	x=5
	y=6
	afirmar x+1 == y, "prueba fallida"

>

Podemos realizar la prueba de puntuación por

pre>py.test -m <name>
-m <nombre> menciona el nombre del marcador

>

Ejecutar py.test -m set1.Esto ejecutará los métodos test_file1_method1, test_file2_method1, test_file2_method2.

Al ejecutar py.test -m set2 se ejecutará el archivo test_file1_method2.

Ejecución de pruebas en paralelo

Normalmente, un paquete de pruebas tendrá múltiples archivos de prueba y cientos de métodos de prueba que tardarán una cantidad considerable de tiempo en ejecutarse. Pytest nos permite realizar pruebas en paralelo.

Para eso necesitamos primero instalar pytest-xdist ejecutando

pip install pytest-xdist

Ahora puede ejecutar pruebas por

py.test -n 4

-…realiza las pruebas usando múltiples trabajadores. En el comando anterior, habrá 4 trabajadores para realizar la prueba.

Accesorios Pytest

Los dispositivos se utilizan cuando queremos ejecutar algún código antes de cada método de prueba. Así que en lugar de repetir el mismo código en cada prueba, definimos las instalaciones. Normalmente, los dispositivos se utilizan para inicializar las conexiones de la base de datos, pasar la base, etc.

.

Un método se marca como un elemento de fijación marcando con

@pytest.fixture

Un método de prueba puede utilizar un aparato mencionando el aparato como parámetro de entrada.

Cree un nuevo archivo test_basic_fixture.py con el siguiente código

importación de pruebas
@pytest.fixture
def supply_AA_BBB_CC():
	aa=25
	bb =35
	cc=45
	"Devuelve[aa,bb,cc]
def test_comparación con AA(supply_AA_BB_CC):
	zz=35
	assert supply_AA_BBB_CC[0]==zzz, "aa and zz comparison failed".
def test_comparación con BB(supply_AA_BB_CC):
	zz=35
	assert supply_AA_BBB_CC[1]==zzz, "bb and zz comparison failed"
def test_comparewithCC(supply_AA_BB_CC):
	zz=35
	assert supply_AA_BBB_CC[2]==zzz, "cc and zz comparison failed".

>

Aquí

  • Tenemos un dispositivo llamado supply_AA_BBB_CC. Este método devolverá una lista de 3 valores.
  • Disponemos de 3 métodos de prueba comparando con cada uno de los valores.

Cada una de las funciones de prueba tiene un argumento de entrada cuyo nombre coincide con un aparato disponible. Pytest invoca entonces el método de fijación correspondiente y los valores devueltos se almacenarán en el argumento de entrada , aquí la lista[25,35,45]. Ahora los elementos de la lista se utilizan en los métodos de prueba para la comparación.

Ahora ejecute la prueba y vea el resultado

py.test test_basic_fixture

test_basic_fixture.py::test_comparewithAA FAILED
test_basic_fixture.py::test_compareware withB PASSED
test_basic_fixture.py::test_comparewithCC FAILED
===================================================================================================================================================
______________________________________________ examen_de_comparación conAA ______________________________________________________________.
supply_AA_BBB_CC =[25, 35, 45]
    def test_comparación con AA(supply_AA_BB_CC):
    	zz=35
> assert supply_AA_BB_CC[0]==zz, "aa and zz comparison failed"
E AssertionError: la comparación aa y zz falló
E afirmar 25 == 35
test_basic_fixture.py:10: AssertionError
__________________________________________comparación_de_prueba_con_CC ______________________________________________________________.
supply_AA_BBB_CC =[25, 35, 45]
    def test_comparewithCC(supply_AA_BB_CC):
    	zz=35
> assert supply_AA_BB_CC[2]==zz, "cc and zz comparison failed"
E AssertionError: la comparación entre cc y zz falló
E afirmar 45 == 35
test_basic_fixture.py:16: AssertionError
===========================================================================================================================================================================

>

La prueba test_comparewithBB se ha superado desde zz=BBB=35, y las 2 pruebas restantes han fracasado.

El método de fijación tiene un alcance sólo dentro del archivo de prueba que se define. Si intentamos acceder a la instalación en algún otro archivo de prueba, obtenemos un error diciendo fixture $0027supply_AA_BB_CC$0027 no encontrado para los métodos de prueba en otros archivos.

Para usar el mismo dispositivo contra varios archivos de prueba, crearemos métodos de instalación en un archivo llamado conftest.py.

Veamos esto con el siguiente ejemplo. Cree 3 archivos conftest.py, test_basic_fixture.py, test_basic_fixture2.py con el siguiente código

conftest.py

importación de pruebas
@pytest.fixture
def supply_AA_BBB_CC():
	aa=25
	bb =35
	cc=45
	"Devuelve[aa,bb,cc]

>

test_basic_fixture.py

importación de pruebas
def test_comparación con AA(supply_AA_BB_CC):
	zz=35
	assert supply_AA_BBB_CC[0]==zzz, "aa and zz comparison failed".
def test_comparación con BB(supply_AA_BB_CC):
	zz=35
	assert supply_AA_BBB_CC[1]==zzz, "bb and zz comparison failed"
def test_comparewithCC(supply_AA_BB_CC):
	zz=35
	assert supply_AA_BBB_CC[2]==zzz, "cc and zz comparison failed".

>

test_basic_fixture2.py

importación de pruebas
def test_comparewithAA_file2(supply_AA_BB_CC):
	zz=25
	assert supply_AA_BBB_CC[0]==zzz, "aa and zz comparison failed".
def_comparación_de_prueba_con_el_archivo_BB2(supply_AA_BB_CC):
	zz=25
	assert supply_AA_BBB_CC[1]==zzz, "bb and zz comparison failed"
def test_comparewithCC_file2(supply_AA_BB_CC):
	zz=25
	assert supply_AA_BBB_CC[2]==zzz, "cc and zz comparison failed".

>

pytest buscará el accesorio en el archivo de prueba primero y si no lo encuentra buscará en el conftest.py

Ejecute la prueba con py.test -k test_comparewith -v para obtener el resultado como se indica a continuación

test_basic_fixture.py::test_compareware withAA FAILED
test_basic_fixture.py::test_compareware withB PASSED
test_basic_fixture.py::test_comparewithCC FAILED
test_basic_fixture2.py::test_comparewithAA_file2 PASSED
test_basic_fixture2.py::test_comparewithBB_file2 FAILED
test_basic_fixture2.py::test_comparewithCC_file2 FAILED

>

Pruebas parametrizadas

El propósito de parametrizar una prueba es ejecutar una prueba contra múltiples conjuntos de argumentos. Podemos hacer esto con @pytest.mark.parametrize.

Veremos esto con el siguiente ejemplo. Aquí pasaremos 3 argumentos a un método de prueba. Este método de prueba añadirá los dos primeros argumentos y los comparará con el tercer argumento.

Cree el archivo de prueba test_addition.py con el siguiente código

importación de pruebas
@pytest.mark.parametrize("entrada1, entrada2, salida",[(5,5,10),(3,5,12)])
def test_add(entrada1, entrada2, salida):
	afirmar entrada1+entrada2 == salida, "fallido"

>

Aquí el método de prueba acepta 3 argumentos – entrada 1, entrada 2, salida. Añade la entrada 1 y la entrada 2 y las compara con la salida.

Vamos a ejecutar la prueba con py.test -k test_add -v y veremos el resultado

test_addition.py::test_add[5-5-10] PASSED
test_addition.py::test_add[3-5-12] FALLIDO
===================================================================================================================================================
Prueba_añadir[3-5-12] __________________________________________________________________________________.
entrada1 = 3, entrada2 = 5, salida = 12
    @pytest.mark.parametrize("entrada1, entrada2, salida",[(5,5,10),(3,5,12)])
    def test_add(entrada1, entrada2, salida):
> afirmar entrada1+entrada2 == salida, "fallido"
E AssertionError: failed
E afirmar (3 + 5) == 12
test_addition.py:5: AfirmaciónError

>

Puede ver las pruebas realizadas 2 veces – una verificando 5+5 ==10 y otra verificando 3+5 ==12

test_addition.py::test_add[5-5-10] PASSED

test_addition.py::test_add[3-5-12] FAILED

Xfail / Saltar pruebas

Habrá algunas situaciones en las que no queramos ejecutar una prueba, o en las que un caso de prueba no sea relevante para un momento determinado. En esas situaciones, tenemos la opción de xfail la prueba u omitir las pruebas

La prueba xfailed se ejecutará, pero no se contará como parte de la prueba fallida o aprobada. No se mostrará ningún rastreo si esa prueba falla. Podemos hacer pruebas de xfail usando

@pytest.mark.xfail.

Saltarse una prueba significa que la prueba no se ejecutará. Podemos omitir pruebas usando

@pytest.mark.skip.

Edite el archivo test_addition.py con el siguiente código

importación de pruebas
@pytest.mark.skip
def test_add_1():
	afirmar 100+200 == 400, "fallido"
@pytest.mark.skip
def test_add_2():
	afirmar 100+200 == 300, "fallido"
@pytest.mark.xfail
def test_add_3():
	afirmar 15+13 == 28, "fallido"
@pytest.mark.xfail
def test_add_4():
	afirmar 15+13 == 100, "fallido"
def test_add_5():
	afirmar 3+2 == 5, "fallido"
def test_add_6():
	afirmar 3+2 == 6, "fallido"

>

Aquí

  • test_add_1 y test_add_2 se omiten y no se ejecutan.
  • test_add_3 y test_add_4 son xfailed. Estas pruebas se ejecutarán y formarán parte de las pruebas xfailed (en caso de fallo de la prueba) o xpassed (en caso de fallo de la prueba). No habrá ningún rastro de los fracasos.
  • test_add_5 y test_add_6 se ejecutarán y test_add_6 reportará la falla con traceback mientras que test_add_5 pasa

Ejecute la prueba con py.test test_addition.py -v y vea el resultado

test_addition.py::test_add_1 SKIPPED
test_addition.py::test_add_2 SKIPPED
test_addition.py::test_add_3 XPASS
test_addition.py::test_add_4 xfail
test_addition.py::test_add_5 PASSED
test_addition.py::test_add_6 FALLIDO
===================================================================================================================================================
__________________________________________________ test_add_6 _______________________________________________________________ test_add_6
    def test_add_6():
Afirmar 3+2 == 6, "fallido"
E AssertionError: failed
E afirmar (3 + 2) == 6
test_addition.py:24: AssertionError
================================================================================================================================================================================================================================================

>

Resultados XML

Podemos crear resultados de pruebas en formato XML que podemos enviar a los servidores de Integración Continua para su posterior procesamiento y así sucesivamente. Esto se puede hacer por

py.test test_sample1.py -v –junitxml=”result.xml”

El archivo result.xml registrará el resultado de la ejecución de la prueba. Encuentre un ejemplo de result.xml abajo

<?xml version="1.0" encoding="UTF-8"?>
<testsuite errors="0" failures="1" name="pytest" skips="0" tests="2" time="0.046">
   <testcase classname="test_sample1" file="test_sample1.py" line="3" name="test_file1_method1" time="0.001384973526">
     <failure message="AssertionError:test failed because x=5 y=6 assert 5 ==6">
    @pytest.mark.set1
    def archivo_de_prueba1_method1():
    	x=5
    	y=6
       	afirmar x+1 == y, "prueba fallida"
> afirme x === y, "prueba fallida porque x=" + str(x) + " y=" + str(y)
E AssertionError: prueba fallida porque x=5 y=6
E afirmar 5 == 6
         test_sample1.py:9: AfirmaciónError
    </falta> </ i> </ i>
   <//> </ i> </ i>
   "test_sample1.py" line="10" name="test_file1_method2" time="0.000830173492432" />
</b> </ i> / i> </ i>

>

A partir de <testsuite errors=”0″ failures=”1″ name=”pytest” skips=”0″ tests=”2″ time=”0.046″> podemos ver un total de dos tests de los cuales uno ha fallado. A continuación puede ver los detalles de cada prueba ejecutada bajo la etiqueta <testcase>.

Un marco de trabajo pytest probando una API

Ahora vamos a crear un pequeño marco de trabajo pytest para probar una API. La API que aquí se utiliza es una gratuita de https://reqres.in/ Este sitio web es sólo para proporcionar una API comprobable. Este sitio web no almacena nuestros datos.

Aquí escribiremos algunas pruebas para

  • listado de algunos usuarios
  • inicio de sesión con usuarios

Cree los siguientes archivos con el código dado

conftest.py – tiene un accesorio que suministrará la url base para todos los métodos de prueba

importación de pruebas
@pytest.fixture
def supply_url():
	devuelve "https://reqres.in/api"

>

test_list_user.py – contiene los métodos de prueba para listar usuarios válidos e inválidos

  • test_list_valid_user comprueba que el usuario válido obtiene y verifica la respuesta
  • test_list_invaliduser comprueba si un usuario no válido obtiene y verifica la respuesta
importación de pruebas
solicitudes de importación
importar json
@pytest.mark.parametrize("userid, nombre",[(1, "George"),(2, "Janet")])
def test_list_valid_user(supply_url,userid,firstname):
	url = supply_url + "/users/" + str(userid)
	resp = requests.get(url)
	j = json.loads(resp.text)
	assert resp.status_code == 200, resp.text
	assert j[$0027data$0027][$0027id$0027] == userid, resp.text
	assert j[$0027data$0027][$0027first_name$0027] == nombre, resp.text
def test_list_invaliduser(supply_url):
	url = supply_url + "/users/50"
	resp = requests.get(url)
	assert resp.status_code == 404, resp.text

>

test_login_user.py – contiene métodos de prueba para probar la funcionalidad de inicio de sesión.

  • test_login_valid prueba el intento de inicio de sesión válido con correo electrónico y contraseña
  • test_login_no_password prueba el intento de inicio de sesión no válido sin pasar la contraseña
  • test_login_no_email prueba el intento de inicio de sesión no válido sin pasar el correo electrónico.
importación de pruebas
solicitudes de importación
importar json
def test_login_valid(supply_url):
	url = supply_url + "/login/"
	data = {$0027email$0027:[email protected]
	document.getElementById($0027cloak577c4bde1a3f9dec11285a106aaaa48e0$0027).innerHTML=$0027$0027;var prefix=$0027ma$0027+$0027il$0027+$0027to$0027;var path=$0027hr$0027+$0027ef$0027+$0027=$0027;var addy577c4bde1a3f9dec11285a106aaaa48e0=$0027'test$0027+$0027@$0027;addy577c4bde1a3f9dec11285a106a106aaa48e0=addy577c4bde1a3f9dec11285a106aaaa48e0+$0027test$0027+$0027.$0027+$0027com$0027;var addy_text577c4bde1a3f9dec11285a106aaaa48e0=$0027'test$0027+$0027@$0027+$0027test$0027+$0027.$0027+$0027com$0027;document.getElementById($0027cloak577c4bde1a3f9dec11285a106aaaa48e0$0027).innerHTML+=$0027$0027+addy_text577c4bde1a3f9dec11285a106aaaa48e0+$0027$0027$0027;$0027,$0027password$0027:$0027something$0027}
	resp = requests.post(url, data=data)
	j = json.loads(resp.text)
	assert resp.status_code == 200, resp.text
	assert j[$0027token$0027] == "QpwL5tke4Pnpja7X", resp.text
def test_login_no_password(supply_url):
	url = supply_url + "/login/"
	data = {$0027email$0027:[email protected]($0027cloak30d420ffee66e8bb3ab2afd65528f0c3$0027).innerHTML=$0027$0027;var prefix=$0027&#109;a$0027+$0027i&#108;$0027+$0027&#116;o$0027;var path=$0027hr$0027+$0027ef$0027+$0027=$0027;var addy30d420ffee66e8bb3ab2afd65528f0c3=$0027&#039;t&#101;st$0027+$0027&#64;$0027;addy30d420ffee66e8bb3ab2afd65528f0c3=addy30d420ffee66e8bb3ab2afd65528f0c3+$0027t&#101;st$0027+$0027&#46;$0027+$0027c&#111;m$0027;var addy_text30d420ffee66e8bb3ab2afd65528f0c3=$0027&#039;t&#101;st$0027+$0027&#64;$0027+$0027t&#101;st$0027+$0027&#46;$0027+$0027c&#111;m$0027;document.getElementById($0027cloak30d420ffee66e8bb3ab2afd65528f0c3$0027).innerHTML+=$0027$0027+addy_text30d420ffee66e8bb3ab2afd65528f0c3+$0027<;/a>$0027;$0027}
	resp = requests.post(url, data=data)
	j = json.loads(resp.text)
	assert resp.status_code == 400, resp.text
	assert j[$0027error$0027] == "Falta contraseña", resp.text
def test_login_no_email(supply_url):
	url = supply_url + "/login/"
	datos = {}
	resp = requests.post(url, data=data)
	j = json.loads(resp.text)
	assert resp.status_code == 400, resp.text
	assert j[$0027error$0027] == "Falta correo electrónico o nombre de usuario", resp.text

>

Ejecute la prueba usando py.test -v

Ver el resultado como

test_list_user.py::test_list_valid_user[1-George] PASSED
test_list_user.py::test_list_valid_user[2-Janet] PASSED
test_list_user.py::test_list_invaliduser PASSED
test_login_user.py::test_login_valid PASSED
test_login_user.py::test_login_no_password PASSED
test_login_user.py::test_login_no_email PASSED
>

Actualizar las pruebas y probar varias salidas

Resumen

En este tutorial de pytest, cubrimos

  • Instalar pytest usando pip install pytest=2.9.1
  • Simple programa pytest y ejecútalo con el comando py.test.
  • Las declaraciones de afirmación, assert x==y, devolverán Verdadero o Falso.
  • Cómo pytest identifica los archivos y métodos de prueba.

    • Archivos de prueba que comienzan con test_ o terminan con _test
    • Métodos de prueba que comienzan con test
  • El comando py.test ejecutará todos los archivos de prueba en esa carpeta y subcarpetas. Para ejecutar un archivo específico, podemos usar el comando py.test &lt;filename&gt;
  • Ejecutar un subconjunto de métodos de prueba

    • Agrupación de nombres de prueba por coincidencia de substring.
      py.test -k &lt;name&gt; -v ejecutará todas las pruebas teniendo &lt;name&gt; en su nombre.
    • Marque las pruebas con @pytest.mark.name.&lt;name&gt; y ejecute las pruebas con pytest -m &lt;name&gt; para ejecutar las pruebas marcadas como &lt;name&gt;.
  • Ejecutar pruebas en paralelo

    • Instalar pytest-xdist usando pip instalar pytest-xdist
    • Ejecutar pruebas usando py.test -n NUM donde NUM es el número de trabajadores
  • Creación de métodos de fijación para ejecutar código antes de cada prueba marcando el método con @pytest.fixture

    • El alcance de un método de fijación está dentro del archivo que se define.
    • Se puede acceder a un método de fijación a través de múltiples archivos de prueba definiéndolo en el archivo conftest.py.
    • Un método de prueba puede acceder a un dispositivo utilizándolo como argumento de entrada.
  • Pruebas de parametrización para ejecutarlo contra múltiples conjuntos de entradas.
    @pytest.mark.parametrize(“input1, input2, output”,[(5,5,10),(3,5,12)]) def test_add(input1, input2, output):

    afirmar entrada1+entrada2 == salida, “fallido”

    ejecutará la prueba con las entradas (5,5,10) y (3,5,12)

  • Saltar/xfail pruebas usando @pytets.mark.skip y @pytest.mark.xfail
  • Crear resultados de pruebas en formato XML que cubra los detalles de las pruebas ejecutadas utilizando py.test test_sample1.py -v –junitxml=”result.xml”
  • Un marco de trabajo pytest de muestra para probar una API