Reputation: 9726

How do I correctly setup and teardown for my pytest class with tests?

I am using selenium for end to end testing and I can't get how to use setup_class and teardown_class methods.

I need to set up browser in setup_class method, then perform a bunch of tests defined as class methods and finally quit browser in teardown_class method.

But logically it seems like a bad solution, because in fact my tests will not work with class, but with object. I pass self param inside every test method, so I can access objects' vars:

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

And it even seems not to be correct to create browser instance for class.. It should be created for every object separately, right?

So, I need to use __init__ and __del__ methods instead of setup_class and teardown_class?

Upvotes: 257

Answers (10)

Vladimir Serdyuk

Reputation: 41

@Simon's fixture-based approach seems like the right way, but unfortunately it is not guaranteed to save data in class: https://github.com/pytest-dev/pytest/issues/3778#issuecomment-479294091. The following worked for me with Python 3.8:

class TestClass:
    @pytest.fixture(autouse=True, scope="class")
    def fixture_class(self, my_global_fixture):
        cls = type(self)
        cls.some_class_data = "test_data"
        print("SetUpTestSuite")
        yield
        print("TearDownTestSuite")

    @pytest.fixture(autouse=True, scope="function")
    def fixture_method(self, my_global_fixture):
        print("SetUp")
        print(f"self.some_class_data={self.some_class_data}")
        yield
        print("TearDown")

Upvotes: 0

Simon Ioan

Reputation: 71

For support the fixture injection in the setup/teardown method parameters, use the `@pytest.fixture` decorator directly in your class !

For used fixture injection in the parameters, dont use the methods setup_class, setup_method, teardown_class, and teardown_method

To fully leverage the power of fixtures with pytest, avoid directly using the setup and teardown methods (setup_class, setup_method, teardown_class, and teardown_method) in test classes, as they do not support fixture injection in their parameters.

Use the @pytest.fixture decorator directly in your class set the scope to class (for setup_class or teardown_class) or to function (for setup_method or teardown_method) and don't forget to set autouse=True.

import pytest

class TestClass:
    @pytest.fixture(autouse=True, scope="class")
    @classmethod
    def fixture_class(cls, my_global_fixture) -> None:
        print("setup class")
        # Equivalent to setup_class
        # setup any state specific to the execution of the given class (which
        # usually contains tests).
        # <--- setup class code -->
        yield
        print("teardown class")
        # Equivalent to teardown_class
        # teardown any state that was previously setup with a call to
        # setup_class.
        # <--- teardown class code -->

    @pytest.fixture(autouse=True, scope="function")
    def fixture_method(self, request, my_global_fixture) -> None:
        print(f"setup method {request}")
        # Equivalent to setup_method
        # setup any state tied to the execution of the given method in a class.
        # setup_method is invoked for every test method of a class.
        # <--- setup method code -->
        yield
        print(f"teardown method {request}")
        # Equivalent to teardown_method
        # teardown any state that was previously setup with a setup_method call.
        # <--- teardown method code -->

Upvotes: 2

Federico Baù

Reputation: 7636

If you are like me, that want's to have quick recipes off all possible variation in once for later use or just a refresher, here you have it.

So, there are 2 main ways in Pytest to setup/teardown test (without including unittest intgration, that is, when you actually using unittest)

1) Fixture (the pytest way )

2) xunit-style (similar to unittest)

These recipes can be found in my Programming-CookBook here -> PyTest Recipes

Fixture

Collection of fixture setup/teardown

Recipes


import pytest

counter = 0

def add_counter():
    global counter
    counter += 1

# ---------------------------
# yield fixtures (recommended)
# ---------------------------


@pytest.fixture
def get_counter():
    print(f"{counter}) -- Fixture (yield)")
    add_counter()
    yield counter


def test_count_is_1(get_counter):
    assert get_counter == 1

def test_count_is_2(get_counter):
    assert get_counter == 2

# ---------------------------
# Adding finalizers directly
# ---------------------------

@pytest.fixture
def get_counter_direct(request):
    print(f"{counter}) -- Fixture (request)")
    add_counter()

    request.addfinalizer(add_counter)
    return counter

def test_count_is_3(get_counter_direct):
    assert get_counter_direct == 3

which results in

================================================================================================================ PASSES ================================================================================================================
___________________________________________________________________________________________________________ test_count_is_1 ____________________________________________________________________________________________________________
-------------------------------------------------------------------------------------------------------- Captured stdout setup ---------------------------------------------------------------------------------------------------------
0) -- Fixture (yield)
___________________________________________________________________________________________________________ test_count_is_2 ____________________________________________________________________________________________________________
-------------------------------------------------------------------------------------------------------- Captured stdout setup ---------------------------------------------------------------------------------------------------------
1) -- Fixture (yield)
___________________________________________________________________________________________________________ test_count_is_3 ____________________________________________________________________________________________________________
-------------------------------------------------------------------------------------------------------- Captured stdout setup ---------------------------------------------------------------------------------------------------------
2) -- Fixture (request)
========================================================================================================== 3 passed in 0.01s ==========================================================================================================

xunit-style

These are all collection of xunit-style like setup/teardown ways. Here I added a counter so that the order is visible

Recipe

import pytest

counter = 0

def add_counter():
    global counter
    counter += 1

# ---------------------------
# Module Level Setup/TearDown
# ---------------------------
def setup_module(module):
    """setup any state specific to the execution of the given module."""
    add_counter()
    print(f"{counter}) -- SetUp (module)")

def teardown_module(module):
    """teardown any state that was previously setup with a setup_module method."""
    add_counter()
    print(f"{counter}) -- tearDown (module)")

class TestSomeClass:

    # ---------------------------
    # Class level setup/teardown
    # ---------------------------
    @classmethod
    def setup_class(cls):
        """setup any state specific to the execution of the given class (which usually contains tests)."""
        add_counter()
        print(f"{counter}) -- SetUp (class)")

    @classmethod
    def teardown_class(cls):
        """teardown any state that was previously setup with a call to setup_class. """
        add_counter()
        print(f"{counter}) -- tearDown (class)")

    # ---------------------------
    # Class level setup/teardown
    # ---------------------------
    def setup_method(self, method):
        """setup any state tied to the execution of the given method in a class.  setup_method is invoked for every test method of a class."""
        add_counter()
        print(f"{counter}) -- SetUp (method)")

    def teardown_method(self, method):
        """teardown any state that was previously setup with a setup_method call. """
        add_counter()
        print(f"{counter}) -- tearDown (method)")

    def test_is_1_a_number(self):
        assert (1).__class__ is int


# ---------------------------
# module level  setup/teardown
# ---------------------------
def setup_function(function):
    """setup any state tied to the execution of the given function. Invoked for every test function in the module."""
    add_counter()
    print(f"{counter}) -- SetUp (function)")


def teardown_function(function):
    """teardown any state that was previously setup with a setup_function call."""
    add_counter()
    print(f"{counter}) -- tearDown (function)")

def test_something_at_module_level():
    assert (1).__class__ is int

which results in

================================================================================================================ PASSES ================================================================================================================
___________________________________________________________________________________________________ TestSomeClass.test_is_1_a_number ___________________________________________________________________________________________________
-------------------------------------------------------------------------------------------------------- Captured stdout setup ---------------------------------------------------------------------------------------------------------
1) -- SetUp (module)
2) -- SetUp (class)
3) -- SetUp (method)
------------------------------------------------------------------------------------------------------- Captured stdout teardown -------------------------------------------------------------------------------------------------------
4) -- tearDown (method)
5) -- tearDown (class)
____________________________________________________________________________________________________ test_something_at_module_level ____________________________________________________________________________________________________
-------------------------------------------------------------------------------------------------------- Captured stdout setup ---------------------------------------------------------------------------------------------------------
6) -- SetUp (function)
------------------------------------------------------------------------------------------------------- Captured stdout teardown -------------------------------------------------------------------------------------------------------
7) -- tearDown (function)
8) -- tearDown (module)
========================================================================================================== 2 passed in 0.01s ===========================================================================================================

Documentaiton

Upvotes: 15

Apteryx

Reputation: 6352

I'm not sure I got the specifics of using Selenium in your original questions, but in case you were simply asking about how to use a more classical setUp/tearDown style, Pytest supports most unittest features, so you could do something like:

import unittest


class TestHello(unittest.TestCase):

    def setUp(self):
        print('running setUp')

    def test_one(self):
        print('running test_one')

    def test_two(self):
        print('running test_two')

    def tearDown(self):
        print('running tearDown')

Which produces:

$ pytest -s -v
====================== test session starts =======================
platform linux -- Python 3.8.2, pytest-6.2.4, py-1.10.0, pluggy-0.13.1 -- /gnu/store/nckjv3ccwdi6096j478gvns43ssbls2p-python-wrapper-3.8.2/bin/python
cachedir: .pytest_cache
hypothesis profile 'default' -> database=DirectoryBasedExampleDatabase('/tmp/test/.hypothesis/examples')
rootdir: /tmp/test
plugins: hypothesis-5.4.1
collected 2 items                                                

test_hw.py::TestHello::test_one running setUp
running test_one
running tearDown
PASSED
test_hw.py::TestHello::test_two running setUp
running test_two
running tearDown
PASSED

Upvotes: 2

Everett Toews

Reputation: 10946

According to Fixture finalization / executing teardown code, the current best practice for setup and teardown is to use yield instead of 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))

Running it results in

$ 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 ===

Another way to write teardown code is by accepting a request-context object into your fixture function and calling its request.addfinalizer method with a function that performs the teardown one or multiple times:

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))

Upvotes: 249

Kiran Sk

Reputation: 923

import pytest
class Test:
    @pytest.fixture()
    def setUp(self):
        print("setup")
        yield "resource"
        print("teardown")

    def test_that_depends_on_resource(self, setUp):
        print("testing {}".format(setUp))

In order to run:

pytest nam_of_the_module.py -v

Upvotes: 9

Bruno Oliveira

Reputation: 15245

When you write "tests defined as class methods", do you really mean class methods (methods which receive its class as first parameter) or just regular methods (methods which receive an instance as first parameter)?

Since your example uses self for the test methods I'm assuming the latter, so you just need to use setup_method instead:

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

The test method instance is passed to setup_method and teardown_method, but can be ignored if your setup/teardown code doesn't need to know the testing context. More information can be found here.

I also recommend that you familiarize yourself with py.test's fixtures, as they are a more powerful concept.

Upvotes: 120

Kiran Vemuri

Reputation: 3022

This might help http://docs.pytest.org/en/latest/xunit_setup.html

In my test suite, I group my test cases into classes. For the setup and teardown I need for all the test cases in that class, I use the setup_class(cls) and teardown_class(cls) classmethods.

And for the setup and teardown I need for each of the test case, I use the setup_method(method) and teardown_method(methods)

Example:

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

Now when I run my tests, when the TestClass execution is starting, it logs the details for when it is beginning execution, when it is ending execution and same for the methods..

You can add up other setup and teardown steps you might have in the respective locations.

Hope it helps!

Upvotes: 92

Okken

Reputation: 2786

Your code should work just as you expect it to if you add @classmethod decorators.

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

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

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

Upvotes: 24

ecoe

Reputation: 5312

As @Bruno suggested, using pytest fixtures is another solution that is accessible for both test classes or even just simple test functions. Here's an example testing python2.7 functions:

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..."

So, running test_1... produces:

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

Notice that stuff_i_setup is referenced in the fixture, allowing that object to be setup and torn down for the test it's interacting with. You can imagine this could be useful for a persistent object, such as a hypothetical database or some connection, that must be cleared before each test runs to keep them isolated.

Upvotes: 33