How to share global variables between tests?

Question

I have a global variable in conftest.py and use it in tests. For example:

conftest.py

api_version = 'v25'
api_url = 'http://www.foobar.com/' + api_version

test_foo.py

from conftest import api_url
import requests

@pytest.fixture
def data():
    return requests.request("GET", api_url)

test_bar(data):
    assert data is not None

Now I want to be able to change api_version from cmd for testing other api version. So I modified conftest.py in the following way:

conftest.py

api_url = None

def pytest_addoption(parser):
    parser.addoption("--api_version", action="store", default="v25", help="By default: v25")

@pytest.fixture(autouse=True, scope='session')
def cmd_param(pytestconfig):
    api_version = pytestconfig.getoption("--mobile_api_ver").lower()
    global api_url
    if api_version in ['v24', 'v25', 'v26', 'v27']:
        api_url = 'http://www.foobar.com/' + api_version
    else:
        raise ValueError('Unknown api version: ' + api_version)

But this doesn't work as I expected because all imports execute before fixtures and test_foo import api_url = None before cmd_param fixture redefines this. Then i write get_api_url method and call it from test module:

conftest.py

api_url = None

def pytest_addoption(parser):
    parser.addoption("--api_version", action="store", default="v25", help="By default: v25")

@pytest.fixture(autouse=True, scope='session')
def cmd_param(pytestconfig):
    api_version = pytestconfig.getoption("--mobile_api_ver").lower()
    global api_url
    if api_version in ['v24', 'v25', 'v26', 'v27']:
        api_url = 'http://www.foobar.com/' + api_version
    else:
        raise ValueError('Unknown api version: ' + api_version)

def get_api_url():
    return api_url

But now I was forced to change test_foo.py too:

test_foo.py

from conftest import get_api_url
import requests

@pytest.fixture
def data():

    return requests.request("GET", get_api_url())

test_bar(data):
    assert data is not None

It works, but solution looks awkward. Is there a more elegant way to use custom cmd options without changing test files?

The answer bellow from Joe Gasewicz it is a good idea, but the class should not be placed in the contest.py. In my test the class in the contest.py caused the test to consume more 20 seconds after the conclusion of the tests. — DevBush, Sep 08 '20 at 19:54

yashtodi94 · Answer 1 · 2019-02-06T08:06:01.133

50

According to docs, pytest_namespace has been removed in version 4.0:

One can use pytest_configure to share global variables.

Example:

import pytest

def pytest_configure():
    pytest.my_symbol = MySymbol()

edited Feb 06 '19 at 08:06

answered Jan 18 '19 at 06:16

yashtodi94

710
1
6
11

5

If anyone is searching, this solution works. At least for me :D – Shahriar Rahman Zahin Jan 06 '22 at 10:25
5

How is my_symbol accessed from the rest of the code? – user613 Jan 17 '22 at 08:52
3

@user613, check the accepted answer. You can directly use as: pytest. – Gru Jan 25 '22 at 06:33
why not just use fixtures for it? fixtures looks way simpler to define and call – Simon Ernesto Cardenas Zarate Nov 07 '22 at 16:27
2

When you call a fixture the code is ran. This implies that, in many cases, you will run a code several times. For example, when you are using session based libraries (like spark) fixtures will create a spark session each time you call it. The unit test will take tons of time to finish... is not what you want. – Gamugo Dec 06 '22 at 05:28
1

for me, it works by placing the code of this answer in a file named "conftest.py" – Blackvenom Jan 23 '23 at 16:02

supamaze · Accepted Answer · 2019-01-03T07:56:08.103

19

Note: pytest_namespace is deprecated now

pytest provides a way to use some global variables within the session. These variables can be used by fixtures as well.

These variables are controlled via pytest hooks.

import pytest

def pytest_namespace():
    return {'my_global_variable': 0}

@pytest.fixture
def data():
    pytest.my_global_variable = 100

def test(data):
    print pytest.my_global_variable

edited Jan 03 '19 at 07:56

answered Jun 22 '17 at 14:35

supamaze

8,169
2
11
11

I dived into my case and investigated, that this cause because api_url is string, that means it's immutable. When pytest starts it first executes all imports, so creates variable test_foo.api_url which references to the same object than references conftest.api_url. After all imports pytest executes conftest.cmd_param() which redefines conftest.api_url. It means that conftest.api_url starts to look to the new string-object while test_foo.api_url looks to the old object (which is None). So solution is to use mutable object for containing api_url in conftest. Your answer is closest to this. – Andrey Glazkov Jul 14 '17 at 14:58
12

Documentation says about `pytest_namespace()`: "(**Deprecated**) this hook causes direct monkeypatching on pytest, its use is strongly discouraged" – Patrick Mevzek Apr 19 '18 at 17:11
2

looks like deprecation happened recently – supamaze Apr 20 '18 at 12:10

Dmitry Tokarev · Answer 3 · 2018-12-29T00:56:55.797

I wouldn't mess with global variables. Just define your fixture to return a value and use that fixture in your tests: Similar to what @milo posted but a lot simpler.

Also you had defined --api_version CLI option but accessing --mobile_api_ver option in your fixture. Additionally your test is just checking that a response object is not None which will never be None, so assert statement will always pass even if response is 404 status, see inline comments.

Here is some code that will work:

contents of conftest.py

import pytest


def pytest_addoption(parser):
    parser.addoption("--api_version", action="store", default="v25", help="By default: v25")


@pytest.fixture(scope='session')
def api_url(pytestconfig):
    api_version = pytestconfig.getoption("--api_version").lower()
    if api_version in ['v24', 'v25', 'v26', 'v27']:
        return 'http://www.foobar.com/' + api_version
    else:
        raise ValueError('Unknown api version: ' + api_version)

contents of test_foo.py

import pytest
import requests


@pytest.fixture
def data(api_url):  # probably a good idea to rename your fixture to a api_response or change what fixture returns.
    return requests.get(api_url)


def test_bar(data):
    print(data.text)
    # below you are not testing data, but merely checking that response object is not None
    assert data is not None  # this will always pass

    # you probably want to test status code and response content
    assert data.status_code == 200
    assert data.json()

Run the tests: pytest -vvv --api_version v24 test_foo.py

Thanks for answer alot. Unfortunately your solution forces me to refactor all test fixtures(by adding api_url in fixtures argument). Nevertheless your solution is prettier than mine(using session-scope fixture directly). — Andrey Glazkov, Jul 14 '17 at 14:34

score 5 · Answer 4 · edited Jun 21 '21 at 19:21

5

You can currently use the pytest object directly as stated in the Docs but only as a stopgap measure:

import pytest


def pytest_configure():
    pytest.my_symbol = MySymbol()

But beware if using the pytest_namespace version as it's deprecated:

old version using the namespace:

class MySymbol:
    ...


def pytest_namespace():
    return {"my_symbol": MySymbol()}

edited Jun 21 '21 at 19:21

Maicon Mauricio

2,052
1
13
29

answered Feb 13 '20 at 13:26

Joe Gasewicz

1,252
15
20

Docs say: Removed in version 4.0. – Sigmatics Mar 02 '23 at 13:22
Current solution: https://stackoverflow.com/a/54248622/5726546 – Sigmatics Mar 02 '23 at 14:12

score 5 · Answer 5 · answered Jun 23 '21 at 18:29

The conftest.py file serves as a means of providing fixtures for an entire directory. Fixtures defined in a conftest.py can be used by any test in that package without needing to import them (pytest will automatically discover them).

https://docs.pytest.org/en/6.2.x/fixture.html#conftest-py-sharing-fixtures-across-multiple-files

tests/
__init__.py

conftest.py
    # content of tests/conftest.py
    import pytest

    @pytest.fixture
    def order():
        return []

    @pytest.fixture
    def top(order, innermost):
        order.append("top")

test_top.py
    # content of tests/test_top.py
    import pytest

    @pytest.fixture
    def innermost(order):
        order.append("innermost top")

    def test_order(order, top):
        assert order == ["innermost top", "top"]

subpackage/
    __init__.py

    conftest.py
        # content of tests/subpackage/conftest.py
        import pytest

        @pytest.fixture
        def mid(order):
            order.append("mid subpackage")

    test_subpackage.py
        # content of tests/subpackage/test_subpackage.py
        import pytest

        @pytest.fixture
        def innermost(order, mid):
            order.append("innermost subpackage")

        def test_order(order, top):
            assert order == ["mid subpackage", "innermost subpackage", "top"]

Alexandru Berbier · Answer 6 · 2019-08-28T18:08:57.943

What I do in conftest.py:


class StoreStuffHere:
    something_to_start_with = "value"
    somethingnew = None

#if you want an empty class:

class StoreStuffHere:
   pass

What I do in test_sample.py:

from conftest import StoreStuffHere

store_stuff_here = StoreStuffHere

#this will pass
def test_assert_value_stored():
    store_stuff_here.somethingnew = 45
    assert store_stuff_here.something_to_start_with == "value"

#this will pass
def test_assert_fresh_stored_value():
    assert store_stuff_here.somethingnew == 45

This will work for all the tests in the same module. If you're interested in using the same "storage" across test modules, use a dictionary instead or a named tupple instead of the class I used. In order to make sure you don't get missing values errors when certain tests fail, please initialize all known values with None.

score 3 · Answer 7 · edited Jun 22 '21 at 02:54

I just try to get it work without complete changing your code. I hope it could give you some idea.

in conftest.py

api_url_by_option = None

def pytest_addoption(parser):
    parser.addoption("--api_version", action="store", default="v25", help="By default: v25")

@pytest.fixture(autouse=True, scope='session')
def cmd_param(pytestconfig):
    api_version = pytestconfig.getoption("--mobile_api_ver").lower()
    global api_url_by_option
    if api_version in ['v24', 'v25', 'v26', 'v27']:
        api_url_by_option = 'http://www.foobar.com/' + api_version
    else:
        raise ValueError('Unknown api version: ' + api_version)

@pytest.fixture:
def api_url():
    return api_url_by_option

in test_foo.py you don't need to import api_url. Please notice that the api_url fixture from conftest.py is used in fixture data

import requests

@pytest.fixture
def data(api_url):
    return requests.request("GET", api_url)

test_bar(data):
    assert data is not None

score 3 · Answer 8 · answered Apr 28 '22 at 03:56

Just wanted to share the pattern that worked best for me that I feel is easy and explicit.

Within conftest.py I have:

import pytest
from types import SimpleNameSpace


# Temporary Storage

pytest.tmp = SimpleNameSpace()

@pytest.fixture(autouse=True, scope="class")
def set_tmp_cls():
    pytest.tmp.cls = SimpleNameSpace()

@pytest.fixture(autouse=True, scope="module")
def set_tmp_mod():
    pytest.tmp.mod = SimpleNameSpace()

and then when utilizing in a test:

import pytest
from pytest import tmp

def test_foo():
    tmp.cls.var = 1

scholorandaathlete · Answer 9 · 2022-08-04T03:21:53.870

0

I used this class. Real simple and scalable for later variables

class TestVars:
    """Class to save and use variables"""

    def __init__(self) -> None:
        self.variables = {}

    def save_var(self, variable: dict):
        self.variables.update(variable)

    def get_var(self, key):
        return self.variables[key]

edited Aug 04 '22 at 03:21

answered Aug 04 '22 at 03:20

scholorandaathlete

1
1

How to share global variables between tests?

9 Answers9