aiida.manage.tests package

Testing infrastructure for easy testing of AiiDA plugins.

Submodules

Testing infrastructure for easy testing of AiiDA plugins.

class aiida.manage.tests.main.ProfileManager(profile_name)

Bases: object

Wraps existing AiiDA profile.

__dict__ = mappingproxy({'__module__': 'aiida.manage.tests.main', '__doc__': '\n    Wraps existing AiiDA profile.\n    ', '__init__': <function ProfileManager.__init__>, 'clear_profile': <staticmethod object>, 'has_profile_open': <function ProfileManager.has_profile_open>, 'destroy_all': <function ProfileManager.destroy_all>, '__dict__': <attribute '__dict__' of 'ProfileManager' objects>, '__weakref__': <attribute '__weakref__' of 'ProfileManager' objects>, '__annotations__': {}})

__init__(profile_name)

Use an existing profile.

Parameters

profile_name – Name of the profile to be loaded

__module__ = 'aiida.manage.tests.main'

__weakref__

list of weak references to the object (if defined)

static clear_profile()

Reset the global profile, clearing all its data and closing any open resources.

destroy_all()

has_profile_open()

class aiida.manage.tests.main.TemporaryProfileManager(backend='psql_dos', pgtest=None)

Bases: aiida.manage.tests.main.ProfileManager

Manage the life cycle of a completely separated and temporary AiiDA environment.

• No profile / database setup required

• Tests run via the TemporaryProfileManager never pollute the user’s working environment

Filesystem:

• temporary .aiida configuration folder

• temporary repository folder

Database:

• temporary database cluster (via the pgtest package)

• with aiida database user

• with aiida_db database

AiiDA:

• configured to use the temporary configuration

• sets up a temporary profile for tests

All of this happens automatically when using the corresponding tests classes & tests runners (unittest) or fixtures (pytest).

Example:

tests = TemporaryProfileManager(backend=backend)
tests.create_aiida_db()  # set up only the database
tests.create_profile()  # set up a profile (creates the db too if necessary)

# ready for tests

# run tests 1

tests.clear_profile()
# database ready for independent tests 2

# run tests 2

tests.destroy_all()
# everything cleaned up

__init__(backend='psql_dos', pgtest=None)

Construct a TemporaryProfileManager

Parameters

• backend – a database backend

• pgtest – a dictionary of arguments to be passed to PGTest() for starting the postgresql cluster, e.g. {‘pg_ctl’: ‘/somepath/pg_ctl’}. Should usually not be necessary.

__module__ = 'aiida.manage.tests.main'

_return_dir(dir_path)

Return a path to a directory from the fs environment

property backend

property config_dir

property config_dir_ok

create_aiida_db()

Create the necessary database on the temporary postgres instance.

create_db_cluster()

Create the database cluster using PGTest.

create_profile()

Set AiiDA to use the tests config dir and create a default profile there

Warning: the AiiDA dbenv must not be loaded when this is called!

destroy_all()

Remove all traces of the tests run

has_profile_open()

property profile_dictionary

Profile parameters.

Used to set up AiiDA profile from self.profile_info dictionary.

property repo

repo_ok()

property root_dir

property root_dir_ok

class aiida.manage.tests.main.TestManager

Bases: object

Test manager for plugin tests.

Uses either ProfileManager for wrapping an existing profile or TemporaryProfileManager for setting up a complete temporary AiiDA environment.

For usage with pytest, see pytest_fixtures.

__dict__ = mappingproxy({'__module__': 'aiida.manage.tests.main', '__doc__': '\n    Test manager for plugin tests.\n\n    Uses either ProfileManager for wrapping an existing profile or TemporaryProfileManager for setting up a complete\n    temporary AiiDA environment.\n\n    For usage with pytest, see :py:class:`~aiida.manage.tests.pytest_fixtures`.\n    ', '__init__': <function TestManager.__init__>, 'manager': <property object>, 'use_temporary_profile': <function TestManager.use_temporary_profile>, 'use_profile': <function TestManager.use_profile>, 'has_profile_open': <function TestManager.has_profile_open>, 'reset_db': <function TestManager.reset_db>, 'clear_profile': <function TestManager.clear_profile>, 'destroy_all': <function TestManager.destroy_all>, '__dict__': <attribute '__dict__' of 'TestManager' objects>, '__weakref__': <attribute '__weakref__' of 'TestManager' objects>, '__annotations__': {}})

__init__()

__module__ = 'aiida.manage.tests.main'

__weakref__

list of weak references to the object (if defined)

clear_profile()

Reset the global profile, clearing all its data and closing any open resources.

destroy_all()

has_profile_open()

property manager: aiida.manage.tests.main.ProfileManager

reset_db()

use_profile(profile_name)

Set up Test manager to use existing profile.

Uses aiida.manage.tests.main.ProfileManager internally.

Parameters

profile_name – Name of existing test profile to use.

use_temporary_profile(backend=None, pgtest=None)

Set up Test manager to use temporary AiiDA profile.

Uses aiida.manage.tests.main.TemporaryProfileManager internally.

Parameters

• backend – Backend to use.

• pgtest – a dictionary of arguments to be passed to PGTest() for starting the postgresql cluster, e.g. {‘pg_ctl’: ‘/somepath/pg_ctl’}. Should usually not be necessary.

exception aiida.manage.tests.main.TestManagerError(msg)

Bases: Exception

Raised by TestManager in situations that may lead to inconsistent behaviour.

__init__(msg)

__module__ = 'aiida.manage.tests.main'

__str__()

Return str(self).

__weakref__

list of weak references to the object (if defined)

aiida.manage.tests.main.get_test_backend_name() → str

Read name of storage backend from environment variable or the specified test profile.

Reads storage backend from ‘AIIDA_TEST_BACKEND’ environment variable, or the backend configured for the ‘AIIDA_TEST_PROFILE’.

Returns

name of storage backend

Raises

ValueError if unknown backend name detected.

Raises

ValueError if both ‘AIIDA_TEST_BACKEND’ and ‘AIIDA_TEST_PROFILE’ are set, and the two backends do not match.

aiida.manage.tests.main.get_test_profile_name()

Read name of test profile from environment variable.

Reads name of existing test profile ‘AIIDA_TEST_PROFILE’ environment variable. If specified, this profile is used for running the tests (instead of setting up a temporary profile).

Returns

content of environment variable or None

aiida.manage.tests.main.get_user_dict(profile_dict)

Collect parameters required for creating users.

aiida.manage.tests.main.test_manager(backend='psql_dos', profile_name=None, pgtest=None)

Context manager for TestManager objects.

Sets up temporary AiiDA environment for testing or reuses existing environment, if AIIDA_TEST_PROFILE environment variable is set.

Example pytest fixture:

def aiida_profile():
    with test_manager(backend) as test_mgr:
        yield fixture_mgr

Example unittest test runner:

with test_manager(backend) as test_mgr:
    # ready for tests
# everything cleaned up

Parameters

• backend – storage backend type name

• profile_name – name of test profile to be used or None (to use temporary profile)

• pgtest – a dictionary of arguments to be passed to PGTest() for starting the postgresql cluster, e.g. {‘pg_ctl’: ‘/somepath/pg_ctl’}. Should usually not be necessary.

Collection of pytest fixtures using the TestManager for easy testing of AiiDA plugins.

• aiida_profile

• aiida_profile_clean

• aiida_profile_clean_class

• aiida_localhost

• aiida_local_code_factory

aiida.manage.tests.pytest_fixtures.aiida_caplog(caplog)

A copy of pytest’s caplog fixture, which allows AIIDA_LOGGER to propagate.

aiida.manage.tests.pytest_fixtures.aiida_local_code_factory(aiida_localhost)

Get an AiiDA code on localhost.

Searches in the PATH for a given executable and creates an AiiDA code with provided entry point.

Usage:

def test_1(aiida_local_code_factory):
    code = aiida_local_code_factory('quantumespresso.pw', '/usr/bin/pw.x')
    # use code for testing ...

Returns

A function get_code(entry_point, executable) that returns the Code node.

Return type

object

aiida.manage.tests.pytest_fixtures.aiida_localhost(temp_dir)

Get an AiiDA computer for localhost.

Usage:

def test_1(aiida_localhost):
    label = aiida_localhost.label
    # proceed to set up code or use 'aiida_local_code_factory' instead

Returns

The computer node

Return type

aiida.orm.Computer

aiida.manage.tests.pytest_fixtures.aiida_profile()

Set up AiiDA test profile for the duration of the tests.

Note: scope=’session’ limits this fixture to run once per session. Thanks to autouse=True, you don’t actually

need to depend on it explicitly - it will activate as soon as you import it in your conftest.py.

aiida.manage.tests.pytest_fixtures.aiida_profile_clean(aiida_profile)

Provide an AiiDA test profile, with the storage reset at test function setup.

aiida.manage.tests.pytest_fixtures.aiida_profile_clean_class(aiida_profile)

Provide an AiiDA test profile, with the storage reset at test class setup.

aiida.manage.tests.pytest_fixtures.clear_database(clear_database_after_test)

Alias for ‘clear_database_after_test’.

Clears the database after each test. Use of the explicit ‘clear_database_after_test’ is preferred.

aiida.manage.tests.pytest_fixtures.clear_database_after_test(aiida_profile)

Clear the database after the test.

aiida.manage.tests.pytest_fixtures.clear_database_before_test(aiida_profile)

Clear the database before the test.

aiida.manage.tests.pytest_fixtures.clear_database_before_test_class(aiida_profile)

Clear the database before a test class.

aiida.manage.tests.pytest_fixtures.temp_dir()

Get a temporary directory.

E.g. to use as the working directory of an AiiDA computer.

Returns

The path to the directory

Return type

str

aiida.manage.tests.pytest_fixtures.temporary_event_loop()

Create a temporary loop for independent test case

previous

aiida.manage.external package

next

aiida.orm package