Pycopia QA package

This package provides a framework for quality assurance roles. It incorporates years of experience in software testing and hardware testing to provide a means to write flexible, quick, and robust test cases.

Core Tests and Suites

class pycopia.QA.core.PreReq(implementation, args=None, kwargs=None)[source]

A holder for test prerequisite.

Used to hold the definition of a prerequisite test. A prerequisite is a Test implementation class plus any arguments it may be called with. No arguments means ANY arguments.

pycopia.QA.core.PruneEnd(n, l)[source]
class pycopia.QA.core.SuiteEntry(inst, args=None, kwargs=None, autoadded=False)[source]

Entry object that wraps other Suite objects.

Used when sub-suites are run as test cases.

result

The test rusult enumeration PASSED if all tests in suite passed.

results

The actual list of test results.

class pycopia.QA.core.Test(config)[source]

Base class for all test cases.

Subclass this to define a new test. The test should be as atomic as possible. A Test may be combined with other tests and may have dependencies (defined by the database).

May send any of the following messages to the report object:
TESTARGUMENTS : string representation of supplied arguments. STARTTIME : timestamp indicating when test was started. ENDTIME : timestamp indicating when test ended. BUILD : string indicating a build that was tested against add_heading : Section heading. passed : When test passed. failed : When test failed. incomplete : When test was not able to complete. diagnostic : Add useful diagnostic information when a test fails. abort : Abort suite, provides the reason. info : Informational and progress messages.
OPTIONS = AttrDictDefault({}, ())
PREREQUISITES = []
abort(msg='no message')[source]

Abort the test suite.

Some drastic error occurred, or some condition is not met, and the suite cannot continue. Raises the TestSuiteAbort exception.

assertApproximatelyEqual(arg1, arg2, fudge=None, msg=None)[source]

Asserts that the numeric arguments are approximately equal.

Raises TestFailError if the second argument is outside a tolerance range (defined by the “fudge factor”). The default is 5% of the first argument.

assertEqual(arg1, arg2, msg=None)[source]

Asserts that the arguments are equal,

Raises TestFailError if arguments are not equal. An optional message may be included that overrides the default message.

assertFailed(arg, msg=None)[source]

Assert a sub-test run by the run_subtest() method failed.

Useful for “negative” tests.

assertFalse(arg, msg=None)[source]

Asserts that the argument evaluates to False by Python.

Raises TestFailError if argument is not False according to Python truth testing rules.

assertGreaterThan(arg1, arg2, msg=None)[source]

Asserts that the first argument is greater than the second argument.

assertGreaterThanOrEqual(arg1, arg2, msg=None)[source]

Asserts that the first argument is greater or equal to the second argument.

assertLessThan(arg1, arg2, msg=None)[source]

Asserts that the first argument is less than the second argument.

assertLessThanOrEqual(arg1, arg2, msg=None)[source]

Asserts that the first argument is less than or equal to the second argument.

assertNotEqual(arg1, arg2, msg=None)[source]

Asserts that the arguments are not equal,

Raises TestFailError if arguments are equal. An optional message may be included that overrides the default message.

assertNotFalse(arg, msg=None)

Asserts that the argument evaluates to True by Python.

Raises TestFailError if argument is not True according to Python truth testing rules.

assertNotTrue(arg, msg=None)

Asserts that the argument evaluates to False by Python.

Raises TestFailError if argument is not False according to Python truth testing rules.

assertPassed(arg, msg=None)[source]

Assert a sub-test run by the run_subtest() method passed.

Used when invoking test objects as a unit.

assertRaises(exception, method, args=None, kwargs=None, msg=None)[source]

Assert that a method and the given args will raise the given exception.

Args:
exception: The exception class the method should raise. method: the method to call with the given arguments. args: a tuple of positional arguments. kwargs: a dictionary of keyword arguments msg: optional message string to be used if assertion fails.
assertTrue(arg, msg=None)[source]

Asserts that the argument evaluates to True by Python.

Raises TestFailError if argument is not True according to Python truth testing rules.

debug()[source]

Enter The Debugger (starring Bruce Li).

Forceably enter the dubugger. Win the prize, escape with your life. Useful when developing tests.

diagnostic(msg)[source]

Emit diagnostic message to report.

Call this one or more times if a failed condition is detected, and you want to record in the report some pertinent diagnostic information. The diagnostic information is typically some ephemeral state of the UUT you want to record.

execute(*args, **kw)[source]

The primary test method.

Overrided this method in a subclass to implement a specific test. All primary test logic and control should go here.

expectedfail(msg='no message')[source]

Call this and return if the execute() failed but that was expected.

This is used primarily for exploratory testing where you may have a sequence of parameterized tests where some are expected to fail past a certain threshold. In other words, the test fails because the parameters are out of spec.

In the execute method, the pattern is: return self.expectedfail(‘message’).

failIfEqual(arg1, arg2, msg=None)

Asserts that the arguments are not equal,

Raises TestFailError if arguments are equal. An optional message may be included that overrides the default message.

failIfNotEqual(arg1, arg2, msg=None)

Asserts that the arguments are equal,

Raises TestFailError if arguments are not equal. An optional message may be included that overrides the default message.

failUnless(arg, msg=None)

Asserts that the argument evaluates to True by Python.

Raises TestFailError if argument is not True according to Python truth testing rules.

failUnlessRaises(exception, method, args=None, kwargs=None, msg=None)

Assert that a method and the given args will raise the given exception.

Args:
exception: The exception class the method should raise. method: the method to call with the given arguments. args: a tuple of positional arguments. kwargs: a dictionary of keyword arguments msg: optional message string to be used if assertion fails.
failed(msg='no message')[source]

Call this and return if the execute() failed.

Call this if your test logic determines a failure. Only call this if your test implementation in the execute is positively sure that it does not meet the criteria. Other kinds of errors should return incomplete().

In the execute method, the pattern is: return self.failed(‘message’).

finalize(result)[source]

Hook method when finalizing a test.

Override if necessary. Used to clean up any state in UUT.

get_file(basename=None, ext='log', mode='a+')[source]

Return a file object that you can write to in the results location.

get_filename(basename=None, ext='log')[source]

Create a log file name.

Return a standardized log file name with a timestamp that should be unique enough to not clash with other tests, and also able to correlate it later to the test report via the time stamp. The path points to the resultsdir location.

get_start_timestamp()[source]
incomplete(msg='no message')[source]

Test could not complete.

Call this and return if your test implementation determines that the test cannot be completed for whatever reason. In a execute, the pattern is: return self.incomplete(‘message’).

info(msg, level=0)[source]

Informational messages for the report.

Record non-critical information in the report object. The message is not recorded if the given level is greater than the current verbosity level.

initialize()[source]

Hook method to initialize a test.

Override if necessary. Establishes the pre-conditions of the test.

manual()[source]

Perform a purely manual test according to the instructions in the document string.

classmethod open_data_file(fname)[source]

Open a data file located in the same directory as the test case implmentation.

Return the file object (actually a UserFile object). Make sure you close it.

passed(msg='no message')[source]

Call this and return if the execute() passed.

If your execute determined that the test passed, call this. In a execute, the pattern is: return self.passed(‘message’).

prerequisites

Get the list of prerequisites.

Returns current list of prerequisite tests, which could be empty.

report_build(buildstring)[source]

Report any build information. Usually a version or build number.

The buildstring parameter must match the following pattern:

<projectname>[ .:]<major>.<minor>.<subminor>.<build>
run_command(cmdline, env=None, timeout=None, logfile=None)[source]

Run an external command.

This method will block until the command returns. An optional timeout may be supplied to prevent hanging forever.

Arguments:

A string that is the command line to be run.
A (optional) dictionary containing the environment variables.
An (optional) timeout value that will forcibly return if the call
    takes longer than the timeout value.

Returns:

A tuple of ExitStatus object and stdout/stderr (string) of the program.
run_subtest(_testclass, *args, **kwargs)[source]

Invoke another Test class in the same environment as this one.

Runs another Test subclass with the given arguments passed to the execute().

The report object is overridden with A NullReport by default. Therefore you won’t see output from subtests. If you want to see subtest output in the report give the verbose option to the test runner.

save_data(data, note=None)[source]

Send an add_data message to the report.

The object is serialized to JSON, so only use basic types.

Arguments:
data: any python object. note: A text note describing the data for future users (optional).
save_text(text, filename=None)[source]

Save some text into a file in the results location.

This may be called multiple times and the file will be appended to.

Arguments:

text:  A blob of text as a string.
filename:  the base name of the file to write. Default is test name plus timestamp.
schedule(delay, cb)[source]

Callback scheduler.

Schedule a function to run ‘delay’ seconds in the future.

set_debug(onoff=1)[source]

Turn on or off the DEBUG flag.

Set the debug flag from a test method. Useful for setting debug flag only around questionable code blocks during test development.

Args:
onoff: flag (boolean) to set the debug state on or off.
classmethod set_test_options()[source]
set_verbose(level=1)[source]

Turn on or off the VERBOSE flag.

Make reports more, or less, verbose at run time.

sleep(Nsecs)[source]

Sleep for N seconds.

Sleep method simply sleeps for specified number of seconds.

timed(function, args=(), kwargs={}, timeout=30)[source]

Run a function with a failsafe timer.

Call the provided function with a failsafe timeout value. The function will be interrupted if it takes longer than timeout seconds.

timedio(function, args=(), kwargs={}, timeout=30)[source]

Run a function that may block on I/O with a failsafe timer.

Call the provided function with a failsafe timeout value. The function will be interrupted if it takes longer than timeout seconds. The method should be one that blocks on I/O.

verbose
class pycopia.QA.core.TestEntry(inst, args=None, kwargs=None, autoadded=False)[source]

Helper class used to run a Test with arguments and store the result.

Holds an instance of a Test class and the parameters it will be called with. This actually calls the test, and stores the result value for later summary. It also supports pre-requisite checking.

abort()[source]

Abort the test suite.

Causes this this test, and the suite, to be aborted.

get_signature()[source]

Return a unique identifier for this test entry.

match_prerequisite(prereq)[source]

Does this test match the specified prerequisite?

Returns True if this test matches the supplied PreReq object.

match_test(name, args, kwargs)[source]

Test signature matcher.

Determine if a test name and set of arguments matches this test.

prerequisites
result

The test rusult enumeration.

run(config=None)[source]

Invoke the test with its arguments. The config argument is passed when run directly from a TestRunner, but not from a TestSuite. It is ignored here.

signature

unique signature string of test.

test_name
class pycopia.QA.core.TestEntrySeries(testinstance, N, chooser, filter, args, kwargs)[source]

Provides an efficient means to add many test case instances without having to actually instantiate a TestEntry at suite build time.

match_prerequisite(prereq)[source]

Does this test match the specified prerequisite?

Returns True if this test name matches the supplied PreReq object. Only the name is checked for series tests, since the arguments may vary.

run(config=None)[source]
test_name
exception pycopia.QA.core.TestError[source]

TestError() Base class of testing errors.

This is based on AssertionError so the same assertion catcher can be used to indicate test failure.

exception pycopia.QA.core.TestFailError[source]

Test case failed to meet the pass criteria.

exception pycopia.QA.core.TestIncompleteError[source]

Test case disposition could not be determined.

pycopia.QA.core.TestOptions[source]

A descriptor that forces OPTIONS to be class attributes that are not overridable by instances.

exception pycopia.QA.core.TestPrerequisiteError[source]

Error in prerequisite calculation.

class pycopia.QA.core.TestResult(value)[source]
is_failed()[source]
is_incomplete()[source]
is_passed()[source]
not_passed()[source]
class pycopia.QA.core.TestSuite(cf, nested=0, name=None)[source]

A Test holder and runner.

A TestSuite contains a set of test cases (subclasses of Test class) that are run sequentially, in the order added. It monitors abort status of each test, and aborts the suite if required.

To run it, create a TestSuite object (or a subclass with some methods overridden), add tests with the add_test() method, and then call the instance. The ‘initialize()’ method will be run with the arguments given when called.

add(klass, *args, **kwargs)[source]

Add a Suite or a Test to this TestSuite.

Most general method to add test case classes or other test suites.

add_arguments(name, args, kwargs)[source]

Add calling arguments to an existing test entry that has no arguments.

add_suite(suite, test_name=None)[source]

Add an entire suite of tests to this suite.

Appends an embedded test suite in this suite. This is called a sub-suite and is treated as a single test by this containing suite.

add_test(_testclass, *args, **kwargs)[source]

Add a Test subclass and its arguments to the suite.

Appends a test object in this suite. The test’s execute() will be called (at the appropriate time) with the arguments supplied here. If the test case has a prerequisite defined it is checked for existence in the suite, and an exception is raised if it is not found.

add_test_from_result(dbtestresult)[source]

Add a Test from information taken from stored test result.

This basically means duplicate the test call that originated that test result.

add_test_series(_testclass, N=100, chooser=None, filter=None, args=None, kwargs=None)[source]

Add a Test case as a series.

The arguments must be lists of possible values for each parameter. The args and kwargs arguments are lists that are combined in all possible combinations, except pruned to N values. The pruning policy can be adjusted by the chooser callback, and the N value itself.

Args:

testclass (class): the Test class object (subclass of core.Test).

N (integer): Maximum iterations to take from resulting set. Default
is 100 just to be safe.
chooser (callable): callable that takes one number and a list
argument, returns a list of the specified (N) length. Default is to chop off the top end of the list.
filter (callable): callable that takes a set of arguments with the
same semantics as the Test.execute() method and returns True or False to indicate if that combination should be included in the test. You might want to set a large N if you use this.
args (tuple): tuple of positional arguments, each argument is a list.
example: args=([1,2,3], [4,5]) maps to positional argumnts of execute() method of Test class.
kwargs (dict): Dictionary of keyword arguments, with list of values
as value.
example: kwargs={“arg1”:[“a”, “b”, “c”]} maps to keyword arguments of execute() method of Test class.
add_tests(_testclasslist, *args, **kwargs)[source]

Add a list of tests at once.

Similar to add_test method, but adds all test case classes found in the given list. Arguments are common to all tests. If object is a tuple it should be a (testclass, tuple, dictionary) of positional and keyword arguments.

check_prerequisites(currententry, upto)[source]

Verify that the prerequisite test passed.

Verify any prerequisites are met at run time.

finalize()[source]

Run the finalize phase for suite level.

Aborts the suite on error or interrupt. If this is a sub-suite then TestSuiteAbort is raised so that the top-level suite can handle it.

Override this if you need to do some additional clean-up after the suite is run.

get_start_timestamp()[source]
get_test_entries(name, *args, **kwargs)[source]

Get a list of test entries that matches the signature.

Return a list of Test entries that match the name and calling arguments.

info(msg)[source]

Informational messages for the report.

Record non-critical information in the report object.

initialize(*args, **kwargs)[source]

initialize phase handler for suite-level initialization.

Override this if you need to do some initialization just before the suite is run. This is called with the arguments given to the TestSuite object when it was called.

prerequisites

Get the list of prerequisites.

This is here for polymorhism with Test objects. Always return empty list.

report_build(buildstring)[source]

Report any build information. Usually a version or build number.

The buildstring parameter must match the following pattern:

<projectname>[ .:]<major>.<minor>.<subminor>.<build>
results
run(config=None)[source]

Define the runnable interface. May be called by the test runner.

exception pycopia.QA.core.TestSuiteAbort[source]

Entire test suite must be aborted.

class pycopia.QA.core.UseCase[source]

UseCase type.

Used to define use cases, which typically involve constructing TestSuite and running it. These are generally more complex operations, involving multiple steps. Each step can be made into a TestCase object, and assembled into a TestSuite using data from the configuration. Then run here.

static get_suite(config)[source]
classmethod run(config)[source]
pycopia.QA.core.insert_options(klass, **kwargs)[source]
pycopia.QA.core.parse_args(arguments)[source]

Take a string of arguments and keyword arguments and convert back to objects.

pycopia.QA.core.repr_args(args, kwargs)[source]

Stringify a set of arguments.

Arguments:
args: tuple of arguments as a function would see it. kwargs: dictionary of keyword arguments as a function would see it.
Returns:
String as you would write it in a script.
pycopia.QA.core.repr_test(name, args, kwargs)[source]

Produce repr form of test case signature.

Returns a Test instantiation plus arguments as text (repr).

pycopia.QA.core.timestamp(t)[source]

standard timesstamp string creator.

QA Universal constants and enumerations.

Possible test outcomes:

  • PASSED: execute() test passed (criteria was met), and the suite may continue.
  • FAILED: execute() failed (criteria was not met), but the suite can continue. You may also raise a TestFailError exception.
  • INCOMPLETE: execute() could not complete, and the pass/fail criteria could not be determined. but the suite may continue. You may also raise a TestIncompleteError exception.
  • ABORT: execute() could not complete, and the suite cannot continue. Raising TestSuiteAbort exception has the same effect.
  • NA: A result that is not applicable (e.g. it is a holder of tests).
  • EXPECTED_FAIL: Means the test is failing due to a bug, and is already known to fail.

Special runtime configuration

This is the dynamic configration object that magically creates things that tests need, such as equipment information, controllers, and reports.

Pycopia Configuration and Information storage

Provides runtime wrappers for persistent (database) objects with extra methods for constructing active controllers.

class pycopia.QA.config.EnvironmentRuntime(session, environmentrow, logfile)[source]
DUT
clear()[source]
del_state()[source]
environment
get(name, default=None)[source]
get_all_with_role(rolename)[source]
get_role(rolename)[source]
get_state()[source]
get_supported_roles()[source]
owner
set_state(newstate)[source]
state
supported_roles
class pycopia.QA.config.EquipmentModelRuntime(equipmentmodel)[source]
get(name, default=None)[source]
name[source]
class pycopia.QA.config.EquipmentRuntime(equipmentrow, rolename, logfile, session)[source]
URL
clear()[source]
controller
get(name, default=None)[source]
get_controller()[source]
get_initial_controller()[source]
get_primary_interface()[source]
get_software()[source]
get_state()[source]
get_url(scheme=None, port=None, path=None, with_account=False)[source]
initial_controller
model
primary_interface
set_state(newstate)[source]
software
state
class pycopia.QA.config.RootContainer(session, container, cache)[source]

RootContainer is the primary configuration holder.

The root container is special. It contains special object constructor methods, and a local writeable cache. It also supports path access using the dot as path separator.

UI

User interface object used for interactive tests.

close()[source]
commit()[source]
copy()[source]
del_logfile()[source]
del_report()[source]
del_userconfig()[source]
del_userinterface()[source]

Remove the UI object from the cache.

environment

Get the Environment object defined by the test configuration. Will set the owner to the currently running user. If already owned then a ConfigError will be raised.

evalset(k, v)[source]

Evaluates the (string) value to convert it to an object in the storage first. Useful for specifying objects from string-sources, such as the command line.

evalupdate(other)[source]
get(key, default=None)[source]
get_account(identifier)[source]

Get account credentials by identifier.

get_equipment(name)[source]

Get any equipment runtime from the configuration by name.

get_logfile()[source]
get_logfilename()[source]
get_report()[source]
get_userconfig()[source]
get_userinterface()[source]
has_key(key)[source]
logfile

ManagedLog object

logfilename

The logfile object’s path name.

mergefile(filename)[source]
report

report object

reportpath
rollback()[source]
set_logfile(lf=None)[source]
set_report(reportname)[source]
setdefault(key, val)[source]
update(other)[source]
userconfig

User specific configuration area.

class pycopia.QA.config.SoftwareRuntime(software)[source]
pycopia.QA.config.get_config([extrafiles][, initdict=][, **kwargs])[source]

Returns a RootContainer instance containing configuration parameters. An extra dictionary may be merged in with the ‘initdict’ parameter. And finally, extra options may be added with keyword parameters when calling this.

Running tests and suites

Top level test runner.

This module provides the primary test runner for the automation framework.

exception pycopia.QA.testrunner.Error[source]

Testrunner errors.

class pycopia.QA.testrunner.TestRunner(config)[source]

Runs test objects.

Handled running objects, generating the report, and other overhead of running tests and cleaning up afterwards.

finalize()[source]

Perform any finalization needed by the test runner. Sends runner end messages to report. Finalizes report.

initialize()[source]

Perform any initialization needed by the test runner.

Initializes report. Sends runner and header messages to the report.

report_global()[source]

Report common information. Send some information to the user interface about the available parameters that a user may provide to run a test.

run_class(cls)[source]

Run a container class inside a module.

The class is run as if it were a module, using the classes containing module. The class is just a container, and the run method should be a static method or class method.

Arguments:
class with run method:
A class object with a run() method that takes a configuration object as it’s single parameter.
Returns:
The return value of the class’s run() method, or FAILED if the module raised an exception.
run_module(mod)[source]

Run a test module.

Prepares the configuration with module configuration, sends report messages appropriate for modules, and reports pass or fail.

Arguments:
mod:
A module object with a run() function that takes a configuration object as it’s single parameter.
Returns:
The return value of the module’s Run() function, or FAILED if the module raised an exception.
run_object(obj)[source]

Run a test object (object with run() function or method).

Arguments:
obj:
A Python test object. This object must have a run() function or method that takes a configuration object as it’s single parameter. It should also have a test_name attribute.
Messages:
May send any of the following messages to the report object:
RUNNERARGUMENTS:
command-line arguments given to test runner.
logfile:
name of the log file from the configuration.
COMMENT:
User supplied comment given when test object was invoked.
RUNNERSTART:
Timestamp when test runner started.
RUNNEREND:
Timestamp when test runner ends.
add_url:
Location where any generated data files, logs, and reports can be found.
run_objects(objects)[source]

Invoke the run method on a list of mixed runnable objects.

Arguments:
objects:
A list of runnable objects. A runnable object is basically something that has a callable named “run” that takes a configuration object as a parameter.

May raise TestRunnerError if an object is not runnable by this test runner.

run_suite(suite)[source]

Run a TestSuite object.

Given a pre-populated TestSuite object, run it after initializing configuration and report objects.

Arguments:
suite:
An instance of a core.TestSuite class or subclass. This should already have Test objects added to it.
Returns:
The return value of the suite. Should be PASSED or FAILED.
run_test(testclass, *args, **kwargs)[source]

Run a test single test class with arguments.

Runs a single test class with the provided arguments. Test class is placed in a temporary TestSuite.

Arguments:
testclass:
A class that is a subclass of core.Test. Any extra arguments given are passed to the execute() method when it is invoked.
Returns:
The return value of the Test instance. Should be PASSED, FAILED, INCOMPLETE, or ABORT.
run_tests(testclasses)[source]

Run a list of test classes.

Runs a list of test classes. Test classes are placed in a temporary TestSuite.

Arguments:
testclasses:
A list of classes that are subclasses of core.Test.
Returns:
The return value of the temporary TestSuite instance.
set_options(opts)[source]
exception pycopia.QA.testrunner.TestRunnerError[source]

Raised for a runtime error of the test runner.

pycopia.QA.testrunner.get_module_version(mod)[source]

Module that defines test loaders.

The objects here are responsible for taking a desired test, or set of tests, looking in the database for implementations and dependencies, and constructing a runnable test objects.

exception pycopia.QA.testloader.Error[source]

Base class for test loader errors.

exception pycopia.QA.testloader.InvalidObjectError[source]

Raised when an attempt is made to instantiate a test object from the database, but the object in the database is marked invalid.

exception pycopia.QA.testloader.InvalidTestError[source]

Raised when a test is requested that cannot be run for some reason.

exception pycopia.QA.testloader.NoImplementationError[source]

Raised when a test object has no automated implementation defined.

pycopia.QA.testloader.get_TestSuite_from_module(mod, config)[source]

Get an existing suite from a module.

pycopia.QA.testloader.get_suite(dbsuite, config)[source]

Get a Suite object.

Return the implementation class of a TestSuite, or a generic Suite instance if not defined.

pycopia.QA.testloader.get_test_class(dbcase)[source]

Return the implementation class of a TestCase, or None if not found.

class pycopia.QA.shellinterface.FormatWrapper(ui, module, objname, format)[source]

Wrap module path object with a format.

The format string should have an ‘%O’ component that will be expanded to the stringified object, and an ‘%U’ component for the module name.

class pycopia.QA.shellinterface.TestReporterInterface(testreporter)[source]

A Basic CLI interface to a TestReporter object.

Instantiate with an instance of a TestReporter.

Call the instance of this with an argv list to report on the given runnable items.

class pycopia.QA.shellinterface.TestRunnerInterface(testrunner)[source]

A Basic CLI interface to a TestRunner object.

Instantiate with an instance of a TestRunner.

Call the instance of this with an argv list to instantiate and run the given tests.

An interface for running test cases as unattended jobs.

Supporting Modules

Abstract interfaces for object controllers.

class pycopia.QA.controller.Controller(equipment, logfile=None)[source]
close()[source]
finalize()[source]
initialize()[source]
set_logfile(lf)[source]
writelog(text)[source]
exception pycopia.QA.controller.ControllerError[source]
pycopia.QA.controller.get_controller(equipment, accessmethod, logfile=None)[source]

Return controller instance that is based on the equipment role.

pycopia.QA.controller.initialize(cf)[source]
pycopia.QA.controller.register_controller(accessmethod, classpath)[source]