haas package

Subpackages

• haas.plugins package
  • Submodules
    • haas.plugins.base_hook_plugin module
    • haas.plugins.coverage module
    • haas.plugins.discoverer module
    • haas.plugins.i_hook_plugin module
    • haas.plugins.i_result_handler_plugin module
    • haas.plugins.i_runner_plugin module
    • haas.plugins.result_handler module
    • haas.plugins.runner module
• haas.tests package
  • Submodules
    • haas.tests.builder module

Submodules

haas.error_holder module

class haas.error_holder.ErrorHolder(description)

Bases: object

Placeholder for a TestCase inside a result. As far as a TestResult is concerned, this looks exactly like a unit test. Used to insert arbitrary errors into a test suite run.

countTestCases()

failureException = None

id()

run(result)

shortDescription()

haas.exceptions module

exception haas.exceptions.DotInModuleNameError

Bases: haas.exceptions.HaasException

exception haas.exceptions.HaasException

Bases: exceptions.Exception

exception haas.exceptions.PluginError

Bases: haas.exceptions.HaasException

haas.haas_application module

class haas.haas_application.HaasApplication(argv, **kwargs)

Bases: object

Main haas application entry-point.

run(plugin_manager=None)

Run the haas test runner.

This will load and configure the selected plugins, set up the environment and begin test discovery, loading and running.

Parameters:plugin_manager (haas.plugin_manager.PluginManager) – [Optional] Override the use of the default plugin manager.

haas.haas_application.create_argument_parser()

Creates the argument parser for haas.

haas.loader module

class haas.loader.Loader(test_suite_class=None, test_case_class=None, test_method_prefix=u'test', **kwargs)

Bases: object

Load individual test cases from modules and wrap them in the Suite container.

create_suite(tests=())

Create a test suite using the confugured test suite class.

Parameters:tests (sequence) – Sequence of TestCase instances.

find_test_method_names(testcase)

Return a list of test method names in the provided TestCase subclass.

Parameters:testcase (type) – Subclass of unittest.TestCase

get_test_cases_from_module(module)

Return a list of TestCase subclasses contained in the provided module object.

Parameters:module (module) – A module object containing TestCases

is_test_case(klass)

Check if a class is a TestCase.

load_case(testcase)

Load a TestSuite containing all TestCase instances for all tests in a TestCase subclass.

Parameters:testcase (type) – A subclass of unittest.TestCase

load_module(module)

Create and return a test suite containing all cases loaded from the provided module.

Parameters:module (module) – A module object containing TestCases

load_test(testcase, method_name)

Create and return an instance of unittest.TestCase for the specified unbound test method.

unbound_test : unbound method

An unbound method of a unittest.TestCase

haas.main module

haas.main.main()

Execute haas.

Parameters:argv (list) – The script’s full argument list including the script itself.

haas.module_import_error module

class haas.module_import_error.ModuleImportError

Bases: object

A base class for generated ModuleImportError placeholder test cases.

haas.plugin_context module

class haas.plugin_context.PluginContext(hooks=None, **kwargs)

Bases: object

Handles correct setup and teardown of multiple plugins.

setup()

teardown()

haas.plugin_manager module

class haas.plugin_manager.PluginManager

Bases: object

ENVIRONMENT_HOOK = u'haas.hooks.environment'

RESULT_HANDLERS = u'haas.result.handler'

TEST_DISCOVERY = u'haas.discovery'

TEST_RUNNER = u'haas.runner'

add_plugin_arguments(parser)

Add plugin arguments to argument parser.

Parameters:parser (argparse.ArgumentParser) – The main haas ArgumentParser.

get_driver(namespace, parsed_args, **kwargs)

Get mutually-exlusive plugin for plugin namespace.

get_enabled_hook_plugins(hook, args, **kwargs)

Get enabled plugins for specified hook name.

classmethod testing_plugin_manager(hook_managers, driver_managers)

Create a fabricated plugin manager for testing.

haas.result module

class haas.result.ResultCollecter(*args, **kwargs)

Bases: haas.result.ResultCollector

class haas.result.ResultCollector(buffer=False, failfast=False)

Bases: object

Collecter for test results. This handles creating TestResult instances and handing them off the registered result output handlers.

addError(*args, **kw)

Register that a test ended in an error.

Parameters:

• test (unittest.TestCase) – The test that has completed.
• exception (tuple) – exc_info tuple (type, value, traceback).

addExpectedFailure(test, exception)

Register that a test that failed and was expected to fail.

Parameters:

• test (unittest.TestCase) – The test that has completed.
• exception (tuple) – exc_info tuple (type, value, traceback).

addFailure(*args, **kw)

Register that a test ended with a failure.

Parameters:

• test (unittest.TestCase) – The test that has completed.
• exception (tuple) – exc_info tuple (type, value, traceback).

addSkip(test, reason)

Register that a test that was skipped.

Parameters:

• test (unittest.TestCase) – The test that has completed.
• reason (str) – The reason the test was skipped.

addSuccess(test)

Register that a test ended in success.

Parameters:test (unittest.TestCase) – The test that has completed.

addUnexpectedSuccess(*args, **kw)

Register a test that passed unexpectedly.

Parameters:test (unittest.TestCase) – The test that has completed.

add_result(result)

Add an already-constructed TestResult to this ResultCollector.

This may be used when collecting results created by other ResultCollectors (e.g. in subprocesses).

add_result_handler(handler)

Register a new result handler.

printErrors()

separator2 = u'----------------------------------------------------------------------'

startTest(test, start_time=None)

Indicate that an individual test is starting.

Parameters:

• test (unittest.TestCase) – The test that is starting.
• start_time (datetime) – An internal parameter to allow the parallel test runner to set the actual start time of a test run in a subprocess.

startTestRun()

Indicate that the test run is starting.

stop()

Set the shouldStop flag, used by the test cases to determine if they should terminate early.

stopTest(test)

Indicate that an individual test has completed.

Parameters:test (unittest.TestCase) – The test that has completed.

stopTestRun()

Indicate that the test run has completed.

wasSuccessful()

Return True if the run was successful.

class haas.result.TestCompletionStatus

Bases: enum.Enum

Enumeration to represent the status of a single test.

error = 3

The test encountered an unexpected error.

expected_failure = 5

A test failed as expected

failure = 2

The test failed, but did not encounter an unexpected error.

skipped = 6

A test was skipped

success = 1

The test completed successfully.

unexpected_success = 4

A test marked as expected to fail unexpected passed.

class haas.result.TestDuration(start_time, stop_time=None)

Bases: object

An orderable representation of the duration of an individual test.

as_integer_ratio()

duration

start_time

stop_time

total_seconds

class haas.result.TestResult(test_class, test_method_name, status, duration, exception=None, message=None)

Bases: object

Container object for all information related to the run of a single test. This contains the test itself, the actual status including the reason or error associated with status, along with timing information.

classmethod from_dict(data)

Create a TestResult from a dictionary created by to_dict()

classmethod from_test_case(test_case, status, duration, exception=None, message=None, stdout=None, stderr=None)

Construct a TestResult object from the test and a status.

Parameters:

• test_case (unittest.TestCase) – The test that this result will represent.
• status (haas.result.TestCompletionStatus) – The status of the test.
• exception (tuple) – exc_info tuple (type, value, traceback).
• message (str) – Optional message associated with the result (e.g. skip reason).
• stdout (str) – The test stdout if stdout was buffered.
• stderr (str) – The test stderr if stderr was buffered.

test

The test case instance this result represents.

to_dict()

Serialize the TestResult to a dictionary.

haas.result.failfast(method)

haas.suite module

class haas.suite.TestSuite(tests=())

Bases: object

A TestSuite is a container of test cases and allows executing many test cases while managing the state of the overall suite.

countTestCases()

Return the total number of tests contained in this suite.

run(result, _state=None)

Run all tests in the suite.

Parameters:result (unittest.result.TestResult) –

haas.suite.find_test_cases(suite)

Generate a list of all test cases contained in a test suite.

Parameters:suite (haas.suite.TestSuite) – The test suite from which to generate the test case list.

haas.testing module

haas.utils module

class haas.utils.abstractclassmethod(callable)

Bases: classmethod

A decorator indicating abstract classmethods.

Similar to abstractmethod.

Usage:

class C(metaclass=ABCMeta):

@abstractclassmethod def my_abstract_classmethod(cls, …):

…

class haas.utils.cd(destdir)

Bases: object

haas.utils.configure_logging(level)

haas.utils.get_module_by_name(name)

Import a module and return the imported module object.

haas.utils.uncamelcase(string, sep=u'_')