aiida.manage.tests package

Testing infrastructure for easy testing of AiiDA plugins.

class aiida.manage.tests.ProfileManager(profile_name)[source]

Bases: object

Wraps existing AiiDA profile.

__dict__ = mappingproxy({'__module__': 'aiida.manage.tests', '__doc__': '\n Wraps existing AiiDA profile.\n ', '__init__': <function ProfileManager.__init__>, '_select_db_test_case': <function ProfileManager._select_db_test_case>, 'reset_db': <function ProfileManager.reset_db>, 'init_db': <function ProfileManager.init_db>, '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>})
__init__(profile_name)[source]

Use an existing profile.

Parameters

profile_name – Name of the profile to be loaded

__module__ = 'aiida.manage.tests'
__weakref__

list of weak references to the object (if defined)

_select_db_test_case(backend)[source]

Selects tests case for the correct database backend.

destroy_all()[source]
has_profile_open()[source]
init_db()[source]

Initialise the database state for running of tests.

Adds default user if necessary.

reset_db()[source]
class aiida.manage.tests.TemporaryProfileManager(backend='django', pgtest=None)[source]

Bases: aiida.manage.tests.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.reset_db()
# database ready for independent tests 2

# run tests 2

tests.destroy_all()
# everything cleaned up
__init__(backend='django', pgtest=None)[source]

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'
_return_dir(dir_path)[source]

Return a path to a directory from the fs environment

_test_case = None
property backend
property config_dir
property config_dir_ok
create_aiida_db()[source]

Create the necessary database on the temporary postgres instance.

create_db_cluster()[source]

Create the database cluster using PGTest.

create_profile()[source]

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()[source]

Remove all traces of the tests run

has_profile_open()[source]
property profile_dictionary

Profile parameters.

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

property repo
repo_ok()[source]
property root_dir
property root_dir_ok
class aiida.manage.tests.TestManager[source]

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', '__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__>, '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>, 'destroy_all': <function TestManager.destroy_all>, '__dict__': <attribute '__dict__' of 'TestManager' objects>, '__weakref__': <attribute '__weakref__' of 'TestManager' objects>})
__init__()[source]

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'aiida.manage.tests'
__weakref__

list of weak references to the object (if defined)

destroy_all()[source]
has_profile_open()[source]
reset_db()[source]
use_profile(profile_name)[source]

Set up Test manager to use existing profile.

Parameters

profile_name – Name of existing test profile to use.

use_temporary_profile(backend=None, pgtest=None)[source]

Set up Test manager to use temporary AiiDA profile.

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.TestManagerError(msg)[source]

Bases: Exception

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

__init__(msg)[source]

Initialize self. See help(type(self)) for accurate signature.

__module__ = 'aiida.manage.tests'
__str__()[source]

Return str(self).

__weakref__

list of weak references to the object (if defined)

Submodules

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

  • aiida_profile

  • clear_database

  • aiida_localhost

  • aiida_local_code_factory

aiida.manage.tests.pytest_fixtures.aiida_caplog(caplog)[source]

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

aiida.manage.tests.pytest_fixtures.aiida_local_code_factory(aiida_localhost)[source]

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)[source]

Get an AiiDA computer for localhost.

Usage:

def test_1(aiida_localhost):
    label = aiida_localhost.get_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()[source]

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.clear_database(clear_database_after_test)[source]

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)[source]

Clear the database after the test.

aiida.manage.tests.pytest_fixtures.clear_database_before_test(aiida_profile)[source]

Clear the database before the test.

aiida.manage.tests.pytest_fixtures.temp_dir()[source]

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()[source]

Create a temporary loop for independent test case

Test classes and test runners for testing AiiDA plugins with unittest.

class aiida.manage.tests.unittest_classes.PluginTestCase(methodName='runTest')[source]

Bases: unittest.case.TestCase

Set up a complete temporary AiiDA environment for plugin tests.

Note: This test class needs to be run through the TestRunner and will not work simply with python -m unittest discover.

Usage example:

MyTestCase(aiida.manage.tests.unittest_classes.PluginTestCase):

    def setUp(self):
        # load my tests data

    # optionally extend setUpClass / tearDownClass / tearDown if needed

    def test_my_plugin(self):
        # execute tests
__module__ = 'aiida.manage.tests.unittest_classes'
backend = None
classmethod setUpClass()[source]

Hook method for setting up class fixture before running tests in the class.

tearDown()[source]

Hook method for deconstructing the test fixture after testing it.

class aiida.manage.tests.unittest_classes.TestRunner(stream=None, descriptions=True, verbosity=1, failfast=False, buffer=False, resultclass=None, warnings=None, *, tb_locals=False)[source]

Bases: unittest.runner.TextTestRunner

Testrunner for unit tests using the fixture manager.

Usage example:

import unittest
from aiida.manage.tests.unittest_classes import TestRunner

tests = unittest.defaultTestLoader.discover('.')
TestRunner().run(tests)
__module__ = 'aiida.manage.tests.unittest_classes'
run(suite, backend=None, profile_name=None)[source]

Run tests using fixture manager for specified backend.

Parameters
  • suite – A suite of tests, as returned e.g. by unittest.TestLoader.discover()

  • backend – name of database backend to be used.

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