Introduction
Here's some info on writing tests for AutoQA. There's four parts to a test: the test code, the test object, the Autotest control file, and the AutoQA control file. Typically they all live in a single directory, located in the tests/ dir of the autoqa source tree.
Write test code first
I'll say it again: Write the test first. The tests don't require anything from autotest or autoqa. You should have a working test before you even start thinking about AutoQA.
You can package up pre-existing tests or you can write a new test in whatever language you're comfortable with. It doesn't even need to return a meaningful exit code if you don't want it to (even though it is definitely better). You'll handle parsing the output and returning a useful result in the test object.
If you are writing a brand new test, there are some python libraries that have been developed for use in existing AutoQA tests. More information about this will be available once these libraries are packaged correctly, but they are not necessary to write your own tests. You can choose to use whatever language and libraries you want.
The test directory
Create a new directory to hold your test. The directory name will be used as the test name, and the test object name should match that. Choose a name that doesn't use spaces, dashes, or dots. Underscores are acceptable.
Drop your test code into the directory - it can be a bunch of scripts, a tarball of sources that may need compiling, whatever.
Next, from the directory autoqa/doc/, copy template files control.template, control.autoqa.template and test_class.py.template into your test directory. Rename them to control, control.autoqa and [testname].py, respectively.
The control file
The control file defines some metadata for this test - who wrote it, what kind of a test it is, what test arguments it uses from AutoQA, and so on. Here's an example control file:
control file for conflicts test
AUTHOR = "Will Woods <wwoods@redhat.com>"
TIME="SHORT"
NAME = 'conflict'
DOC = """
This test runs potential_conflict from yum-utils to check for possible
file / package conflicts.
"""
TEST_TYPE = 'CLIENT'
TEST_CLASS = 'General'
TEST_CATEGORY = 'Functional'
job.run_test('conflicts', config=autoqa_conf, **autoqa_args)
Append some real control file to show 'how it looks'
Required data
The following control file items are required for valid AutoQA tests. The first three are important for us, the rest is not so important but still required.
- NAME: The name of the test. Should match the test directory name, the test object name, etc.
- AUTHOR: Your name and email address.
- DOC: A verbose description of the test - its purpose, the logs and data it will generate, and so on.
- TIME: either 'SHORT', 'MEDIUM', or 'LONG'. This defines the expected runtime of the test - either 15 minutes, less than 4 hours, or more than 4 hours.
- TEST_TYPE: either 'CLIENT' or 'SERVER'. Use 'CLIENT' unless your test requires multiple machines (e.g. a client and server for network-based testing).
- TEST_CLASS: This is used to group tests in the UI. 'General' is fine. We may use this field to refer to the test event in the future.
- TEST_CATEGORY: This defines the category your test is a part of - usually this describes the general type of test it is. Examples include Functional, Stress, Performance, and Regression.
Optional data
The following control file items are optional, and infrequently used, for AutoQA tests.
DEPENDENCIES = 'POWER, CONSOLE' SYNC_COUNT = 1
- DEPENDENCIES: Comma-separated list of hardware requirements for the test. Currently unsupported.
- SYNC_COUNT: The number of hosts to set up and synchronize for this test. Only relevant for SERVER-type tests that need to run on multiple machines.
Launching the test object
Most tests will have a line in the control file like this:
job.run_test('conflicts', config=autoqa_conf, **autoqa_args)
This will create a 'conflicts' test object (see below) and pass along the following variables.
autoqa_conf- Contains string with autoqa.conf file, usually located at
/etc/autoqa/autoqa.conf. Note, though, that some of the values in autoqa_conf are changed by the autoqa harness while scheduling the testrun.
autoqa_args- A dictionary, containing all the event-specific variables (e.g. kojitag for post-koji-build event). Documentation on these is to be found in
events/[eventname]/READMEfiles. Some more variables may be also present, as described in the template file.
Those variables will be inserted into the control file by the autoqa test harness when it's time to schedule the test.
The control.autoqa file
The control.autoqa file allows a test to define any scheduling requirements or modify input arguments. This file will decide whether to run this test at all, on what architectures/distributions it should run, and so on. It is evaluated on the AutoQA server before the test itself is scheduled and run on AutoQA client.
All variables available in control.autoqa are documented in doc/control.autoqa.template. You can override them to customize your test's scheduling. Basically you can influence:
- Which event the test runs for and under which conditions.
- The type of system the test needs. This includes system architecture, operating system version and whether the system supports virtualization (see autotest labels for additional information)
- Data passed from the event to the test object.
Here is example control.autoqa file:
# this test can be run just once and on any architecture,
# override the default set of architectures
archs = ['noarch']
# this test may be destructive, let's require a virtual machine for it
labels = ['virt']
# we want to run this test just for post-koji-build event;
# please not that 'execute' defaults to 'False' and to have
# the test scheduled, control.autoqa needs to complete with
# 'execute' set to 'True'
if event in ['post-koji-build']:
execute = True
Similar to the control file, the control.autoqa file is a Python script, so you can execute conditional expressions, loops or virtually any other Python statements there. However, it is heavily recommended to keep this file as simple as possible and put all the logic to the test object.
Test Object
The test object is a python file that defines an object that represents your test. It handles the setup for the test (installing packages, modifying services, etc), running the test code, and sending results to Autotest (and other places).
Convention holds that the test object file - and the object itself - should have the same name as the test. For example, the conflicts test contains a file named conflicts.py, which defines a conflicts class, as follows:
import autoqa.util
from autoqa.test import AutoQATest
from autoqa.decorators import ExceptionCatcher
from autotest_lib.client.bin import utils
class conflicts(AutoQATest):
...
The name of the class must match the name given in the run_test() line of the control file, and test classes must be subclasses of the AutoQATest class. But don't worry too much about how this works - the test_class.py.template contains the skeleton of an appropriate test object. Just change the name of the file (and class!) to something appropriate for your test.
AutoQATest base class
This class contains the functionality common to all the tests - i.e. it initializes the variables used for storing results in its __init__ function. The default initialize method then parses the config string passed in the control file into self.config, and prepares self.autotest_url - a url pointing to the autotest storage place, where all the logs will be once the test finishes.
It also contains a postprocess_iteration method, which uses the self.result, self.summary, self.highlights and self.outputs to send a pretty formatted email to autoqa-results mailing list.
When writing tests and determining how to record test results, please make sure to use the variables
self.result, self.summary, self.highlights or self.outputs when writing tests. These variables make the 'central dispatch' of test results possible, and will be used for future enhancements like ResultsDB.The AutoQATest base class defines an additional method - process_exception. This is used by the ExceptionCatcher decorator when an exception occurs in any of setup, initialize or run_once methods (for details, see Writing_AutoQA_Tests#ExceptionCatcher_decorator).
ExceptionCatcher decorator
When an unintended exception is raised during test setup (setup()), initialization (initialize()) or execution (run_once()) the test immediately ends without calling the postprocess_iteration method, which is supposed to send all the gathered data to mailing list. This behaviour is not desirable as test cleanup may not have been run, and the exception cannot be properly handled or reported.
To address this, an ExceptionCatcher decorator is available. When using the ExceptionCatcher decorator, if an unhandled exception an exception is raised, it calls the function process_exception() which sets the test result to CRASHED, updates self.outputs to include traceback information, updates self.summary to reflect the cause of the exception, and attempts to call postprocess_iteraction() to further cleanup the test. Finally, before the test completes, the decorator will attempt to re-raise the exception.
To take advantage of the decorator in your tests, add @ExceptionCatcher() before each autotest method as shown below:
@ExceptionCatcher()
def run_once(self, **kwargs):
...
Optionally, if a different recovery procedure other than process_exception() is desired, you may define the method and provide the method name as an argument to the decorator. For an example, see below:
def my_exception_handler(self, exc = None):
'''do something different'''
@ExceptionCatcher('self.my_exception_handler')
def run_once(self, **kwargs):
...
Because of some nasty Autotest magic, it is required to have the
**kwargs argument in the decorated function. This is because Autotest magic can not find out, what is the correct subset of arguments from **autoqa_args to pass, so it passes them all - which causes error, if you don't have them all listed.Test stages
setup()
This is an optional method of the test class. This is where you make sure that any required packages are installed, services are started, your test code is compiled, and so on. For example:
@ExceptionCatcher()
def setup(self):
utils.system('yum -y install httpd')
if utils.system('service httpd status') != 0:
utils.system('service httpd start')
initialize()
This does any pre-test initialization that needs to happen. AutoQA tests typically uses this method to parse the autoqa config data provided by the server or to create initial test result data structures. This is an optional method.
All basic initialization is done in the AutoQATest class, so check it out, before you re-define it.
AutoQATest.initializeIf you re-implement the
initialize function, make sure, that you call super(self.__class__, self).initialize(config) inside it, so all the required initialization is executedrun_once()
This is where the test code actually gets run. It's the only required method for your test object.
In short, this method should build the argument list, run the test binary and process the test result and output. For example, see below:
@ExceptionCatcher()
def run_once(self, baseurl, parents, reponame, **kwargs):
super(self.__class__, self).run_once()
cmd = "./sanity.py --scratchdir %s --logdir %s" % (self.tmpdir, self.resultsdir)
cmd += " %s" % baseurl
retval = utils.system(cmd)
if retval != 0:
self.result = 'FAILED'
This above example will run the command sanity.py, store its exit code into the retval variable and set the test status based on the exit code.
If you want to catch the output of the command, rather than just the exit code, you can use the built-in utils.system_output() method:
from autotest_lib.client.common_lib import error
...
try:
output = utils.system_output(cmd, retain_output = True)
except error.CmdError, e:
output = e.result_obj.stdout
...
Additionally, if you need both the exit code and command output, use the built-in utils.run() method:
...
result = utils.run(cmd, ignore_status = True, stdout_tee = utils.TEE_TO_LOGS)
output = result.stdout
retval = result.exit_status
...
For more information about additional test object attributes such as self.bindir, self.tmpdir, refer to test object attributes. For more information on gathering results from your tests, refer to Getting test results.
postprocess_iteration()
This method is implemented in the AutoQATest base class, and it sends the data gathered in the self.result/summary/highlights/outputs to the autoqa-results maling list.
You can of course reimplement this function, if you want to (for instance) gather some extra data, or prepare the data gathered in the test before storing them, but please be sure to call the AutoQATest.postprocess_iteration() afterwards. In general, you should not need to reimplement this function at all.
def postprocess_iteration(self):
for line in self.outputs:
if line.startswith('Max transfer speed: '):
(dummy, max_speed) = line.split('speed: ')
keyval['max_speed'] = max_speed
self.write_test_keyval(keyval)
super(self.__class__, self).postprocess_iteration()
(See Returning extra data for details about write_test_keyval.)
This method will be run after each iteration of run_once(), but note that it gets no arguments passed in. Any data you want from the test run needs to be saved into the test object - hence the use of self.outputs.
Useful test object attributes
test objects have the following attributes available[1]:
outputdir eg. results/<job>/<testname.tag> resultsdir eg. results/<job>/<testname.tag>/results profdir eg. results/<job>/<testname.tag>/profiling debugdir eg. results/<job>/<testname.tag>/debug bindir eg. tests/<test> src eg. tests/<test>/src tmpdir eg. tmp/<tempname>_<testname.tag>
Test Results
The AutoQATest class provides a set of variables (self.result/summary/highlights/outputs) to be used for storing test results. The point of these, is to be able to have one implementation of the results harness - in the AutoQATest class. At the time being, the results are being sent to the autoqa-results mailing list, but in the near future, we'll be using a database-based storage, which will give us a better way of reviewing the results. Proper usage of abovementioned variables is crucial to the seamless transition to this tool.
Overall Result
The overall test result is stored in the variable self.result. You should set it in run_once() according to the result of your test. You can choose from these values:
PASSED- the test has passed, there is no problem with itINFO- the test has passed, but there is some important information that a relevant person would very probably like to reviewFAILED- the test has failed, requirements are not metNEEDS_INSPECTION(default)- the test has failed, but a relevant person is needed to inspect, and possibly waive, the errorsABORTED- some third party error has occurred (networking error, external script used for testing has crashed, etc) and the test could not complete because of that; re-running this test with same input arguments should usually solve this problemCRASHED- the test has crashed because of a programming error somewhere in our code (test script or autoqa code); close inspection is necessary to be able to solve this issue;
If no value is set in self.result, a value of NEEDS_INSPECTION will be used during postprocess_iteration().
If an exception occurs, and is caught by the ExceptionCatcher decorator (i.e. you don't catch it yourself), self.result is set to CRASHED.
Using ABORTED result properly
If you want to end your test with ABORTED result, simple set self.result and then re-raise the original exception. self.summary will be filled-in automatically (extracted from the exception message), if empty.
try:
//download from Koji
except IOError, e: //or some other error
self.result = 'ABORTED'
raise
If you don't have any exception to re-raise but still want to end the test, again set self.result, but this time be sure to also provide an explanation in self.summary and then end the test by raising autotest_lib.client.common_lib.error.TestFail. Alternatively you can provide the error explanation as an argument to the TestFail class instead of filling in self.summary.
from autotest_lib.client.common_lib import error
foo = //do some stuff
if foo == None:
self.result = 'ABORTED'
raise error.TestFail('No result returned from service bar')
Posting feedback into Bodhi
After the result of a test is known, it can be sent into Bodhi, for example:
from autoqa.bodhi_utils import bodhi_post_testresult
...
@ExceptionCatcher()
def run_once(self, envrs, kojitag, arch, **kwargs):
super(self.__class__, self).run_once()
title = kwargs['name'] # title of the update in Bodhi
...
Test runs
...
# post the result
bodhi_post_testresult(title, self.__class__.__name__, self.result, self.autotest_url, arch)
Summary
The self.summary is used as a subject for the purposes of the autoqa-results mailing list. It is intended to contain a short summary of the testrun - e.g. for Conflicts test, it can be "69 packages with file conflicts in rawhide-i386". It should be a short string describing the outcome of the test.
postprocess_iteration() then adds the name of the test and self.result, so the whole summary (as used for the mailing list autoqa-results) would be "Conflicts: FAILED;69 packages with file conflicts in rawhide-i386".
Highlights
The self.highlights should contain a digest from the stdout/stderr generated by your test. Traditionally, this is used to draw attention to important warnings or errors. For example, you may have several hundred/thousand lines of test output (self.outputs), but you wouldn't want to inspect that everytime to determine the nature of a failure. Draw attention to specific issues by using self.highlights.
The self.highlights can contain a string, or a list of strings.
Detailed Output
Put any detailed output into the self.outputs variable. Usually it contains the stdout/stderr of your test script, but it may contain less or more, as you wish. This detailed output will probably represent the largest portion of the test result report.
The self.outputs can contain a string or a list of strings.
Extra Data
Further test-level info can be returned by using test.write_test_keyval(dict). The following example demonstrates extracting and saving the kernel version used when running a test:
extrainfo = dict()
for line in self.results.stdout:
if line.startswith("kernel version "):
extrainfo['kernelver'] = line.split()[3]
...
self.write_test_keyval(extrainfo)
In addition to test-level key/value pairs, per-iteration key/value information (e.g. performance metrics) can be recorded:
self.write_attr_keyval(attr_dict)- Store test attributes (string data). Test attributes are limited to 100 characters. [2]self.write_perf_keyval(perf_dict)- Store test performance metrics (numerical data). Performance values must be floating-point numbers.self.write_iteration_keyval(attr_dict, perf_dict)- Storing both, attributes and performance data
Log files and scratch data
Autotest automatically logs all the client/server output, the full output of any commands you run, operating system variables and others and stores them on the server. There is a hyperlink to the directory with all these log files in every test report.
If you want to store a custom file (like your own log), just save it to self.resultsdir directory. All those files will be saved at the end of the test. On the other hand, any files written to self.tmpdir will be discarded.
output.log
After the test completes, an output.log file is created in the directory referenced by self.resultsdir. The output.log file combines all test output variables (self.result/summary/highlights/outputs) and writes them in a consistent format - the same format that is used for email reports. You can use this file to review the final test report even if you don't have access to the email one.
How to run AutoQA tests
Install AutoQA from GIT
First of all, you'll need to checkout some version from GIT. You can either use master, or some tagged 'release'.
To checkout master branch:
git clone git://git.fedorahosted.org/autoqa.git autoqa cd autoqa
To checkout tagged release:
git clone git://git.fedorahosted.org/autoqa.git autoqa cd autoqa git tag -l # now you'll get a list of tags, at the time of writing this document, the latests tag was v0.3.5-1 git checkout -b v0.3.5-1 tags/v0.3.5-1
Add your test
The best way to add your test into the directory structure is to create a new branch, copy your test and make install autoqa.
git checkout -b my_new_awesome_test cp -r /path/to/directory/with/your/test ./tests make clean install
It's possible that
make install will fail due to missing some python modules (e.g. turbogears2). In that case install them using yum.Run your test
This is dependent on the event, your test is supposed to run under. Let's assume, that it is the post-koji-build.
/usr/share/autoqa/post-koji-build/watch-koji-builds.py --dry-run
This command will show you current koji builds e.g.
No previous run - checking builds in the past 3 hours autoqa post-koji-build --kojitag dist-f12-updates-candidate --arch x86_64 --arch i686 espeak-1.42.04-1.fc12 autoqa post-koji-build --kojitag dist-f11-updates-candidate --arch x86_64 kdemultimedia-4.3.4-1.fc11 autoqa post-koji-build --kojitag dist-f11-updates-candidate --arch x86_64 kdeplasma-addons-4.3.4-1.fc11 autoqa post-koji-build --kojitag dist-f12-updates-candidate --arch x86_64 --arch i686 cryptopp-5.6.1-0.1.svn479.fc12 autoqa post-koji-build --kojitag dist-f12-updates-candidate --arch x86_64 drupal-6.15-1.fc12 autoqa post-koji-build --kojitag dist-f12-updates-candidate --arch x86_64 --arch i686 seamonkey-2.0.1-1.fc12 ... output trimmed ...
So to run your test, just select one of the lines, and add parameters --test name_of_your_test --local, which will locally execute the test you just wrote.
If you wanted to run rpmlint, for example, the command would be
autoqa post-koji-build --kojitag dist-f12-updates-candidate --arch x86_64 --arch i686 espeak-1.42.04-1.fc12 --test rpmlint --local
It is important to add the
--local parameter. If you won't, the test will fail to run provided that you don't have Autotest server installed and configured.