¿Cómo configuro y desarmo correctamente mi clase Pytest con pruebas?

Estoy usando selenio para las pruebas de extremo a extremo y no puedo entender cómo usar setup_classy teardown_classmétodos.

Necesito configurar el navegador en el setup_classmétodo, luego realizar un montón de pruebas definidas como métodos de clase y finalmente salir del navegador en el teardown_classmétodo.

Pero lógicamente parece una mala solución, porque de hecho mis pruebas no funcionarán con class, sino con object. Paso el selfparámetro dentro de cada método de prueba, para poder acceder a las variables de los objetos:

class TestClass:
  
    def setup_class(cls):
        pass
        
    def test_buttons(self, data):
        # self.$attribute can be used, but not cls.$attribute?  
        pass
        
    def test_buttons2(self, data):
        # self.$attribute can be used, but not cls.$attribute?
        pass
        
    def teardown_class(cls):
        pass
    

E incluso parece no ser correcto crear una instancia de navegador para una clase. Debería crearse para cada objeto por separado, ¿verdad?

Entonces, necesito usar los métodos __init__y en __del__lugar de setup_classy teardown_class?

De acuerdo con la finalización del dispositivo / ejecución del código de desmontaje , la mejor práctica actual para la configuración y el desmontaje es usar en yieldlugar de return:

import pytest

@pytest.fixture()
def resource():
    print("setup")
    yield "resource"
    print("teardown")

class TestResource:
    def test_that_depends_on_resource(self, resource):
        print("testing {}".format(resource))

Ejecutarlo da como resultado

$ py.test --capture=no pytest_yield.py
=== test session starts ===
platform darwin -- Python 2.7.10, pytest-3.0.2, py-1.4.31, pluggy-0.3.1
collected 1 items

pytest_yield.py setup
testing resource
.teardown


=== 1 passed in 0.01 seconds ===

Otra forma de escribir código de desmontaje es aceptando un requestobjeto -context en su función de dispositivo y llamando a su request.addfinalizermétodo con una función que realiza el desmontaje una o varias veces:

import pytest

@pytest.fixture()
def resource(request):
    print("setup")

    def teardown():
        print("teardown")
    request.addfinalizer(teardown)
    
    return "resource"

class TestResource:
    def test_that_depends_on_resource(self, resource):
        print("testing {}".format(resource))

Cuando escribe "pruebas definidas como métodos de clase" , ¿realmente se refiere a métodos de clase (métodos que reciben su clase como primer parámetro) o simplemente métodos regulares (métodos que reciben una instancia como primer parámetro)?

Dado que su ejemplo se usa selfpara los métodos de prueba, estoy asumiendo el último, por lo que solo necesita usar setup_methoden su lugar:

class Test:

    def setup_method(self, test_method):
        # configure self.attribute

    def teardown_method(self, test_method):
        # tear down self.attribute

    def test_buttons(self):
        # use self.attribute for test

La instancia del método de prueba se pasa a setup_methody teardown_method, pero se puede ignorar si su código de configuración / desmontaje no necesita conocer el contexto de prueba. Puede encontrar más información aquí .

También le recomiendo que se familiarice con los accesorios de py.test , ya que son un concepto más poderoso.

Esto podría ayudar a http://docs.pytest.org/en/latest/xunit_setup.html

En mi suite de pruebas, agrupo mis casos de prueba en clases. Para la configuración y el desmontaje que necesito para todos los casos de prueba en esa clase, utilizo los métodos setup_class(cls)y teardown_class(cls)clases.

Y para la configuración y el desmontaje que necesito para cada uno de los casos de prueba, utilizo setup_method(method)yteardown_method(methods)

Ejemplo:

lh = <got log handler from logger module>

class TestClass:
    @classmethod
    def setup_class(cls):
        lh.info("starting class: {} execution".format(cls.__name__))

    @classmethod
    def teardown_class(cls):
        lh.info("starting class: {} execution".format(cls.__name__))

    def setup_method(self, method):
        lh.info("starting execution of tc: {}".format(method.__name__))

    def teardown_method(self, method):
        lh.info("starting execution of tc: {}".format(method.__name__))

    def test_tc1(self):
        <tc_content>
        assert 

    def test_tc2(self):
        <tc_content>
        assert

Ahora, cuando ejecuto mis pruebas, cuando comienza la ejecución de TestClass, registra los detalles de cuándo comienza la ejecución, cuándo finaliza la ejecución y lo mismo para los métodos.

Puede agregar otros pasos de configuración y desmontaje que pueda tener en las ubicaciones respectivas.

¡Espero eso ayude!

Como sugirió @Bruno, el uso de accesorios de pytest es otra solución a la que se puede acceder tanto para clases de prueba como para funciones de prueba simples. Aquí hay un ejemplo de prueba de funciones de python2.7 :

import pytest

@pytest.fixture(scope='function')
def some_resource(request):
    stuff_i_setup = ["I setup"]

    def some_teardown():
        stuff_i_setup[0] += " ... but now I'm torn down..."
        print stuff_i_setup[0]
    request.addfinalizer(some_teardown)

    return stuff_i_setup[0]

def test_1_that_needs_resource(some_resource):
    print some_resource + "... and now I'm testing things..."

Entonces, correr test_1...produce:

I setup... and now I'm testing things...
I setup ... but now I'm torn down...

Observe que stuff_i_setupse hace referencia en el accesorio, lo que permite que ese objeto sea setupy torn downpara la prueba con la que está interactuando. Puede imaginar que esto podría ser útil para un objeto persistente, como una base de datos hipotética o alguna conexión, que debe borrarse antes de que se ejecute cada prueba para mantenerlos aislados.

Su código debería funcionar tal como lo espera si agrega @classmethoddecoradores.

@classmethod 
def setup_class(cls):
    "Runs once per class"

@classmethod 
def teardown_class(cls):
    "Runs at end of class"

Ver http://pythontesting.net/framework/pytest/pytest-xunit-style-fixtures/