From Fedora Project Wiki

Revision as of 15:31, 15 December 2009 by Jlaska (talk | contribs) (Some minor wiki changes)


This page is a draft only
It is still under construction and content may change. Do not rely on the information on this page.


The hooks/ directory in the autoqa source tree contains the hooks that AutoQA knows about. A hook has five main parts:

    • describes the event itself and the required (and optional) arguments that will be passed along to the tests.
    • python code that is used to parse the test arguments, as described in the README file. This is the formal definition of the test arguments.
  3. testlist
    • contains the list of test names that will be launched when this hook is triggered.
  4. control.template and
    • generic templates for creating new tests that use this hook. See below for more information on writing new tests.
  5. Watcher
    • This is the code that watches for the event and launches the autoqa harness with the arguments described in README and
    • Currently, all existing watchers are scripts that get run periodically by crond to check to see if the event has occurred since the last time it was run. If so, it launches autoqa.
    • In the future this will change to a daemon that waits for notifications about the event - see the Messaging SIG's Publish Subscribe Notification Proposal for further info about that.


This is the human-readable description for this hook. It describes the event, the required and optional arguments that will be passed to autoqa and the tests, and any special argument processing or test filtering that might happen.

Here's an example, the post-repo-update README:

This hook is for tests that run after a repo has changed. A repo is considered
"changed" if its package contents and metadata have been changed in some way.

The required argument for autoqa is a yum-compatible URL (probably http) that
points to the changed repo.

Some tests (e.g. repoclosure) need a list of "parent" repos to run properly.
You can specify these by doing '--parent URL1 --parent URL2 ...'

Any instances of '%a' in the URLs will be replaced by one of the listed
arches when the tests are actually run.

Every hook has at least one required argument - usually a URL that points to the new package/tree/repo/whatever. It can also define one or more optional arguments, which will be handled by autoqa commandline arguments. Those get defined in

This contains python code that will be loaded by autoqa when it is launched by the watcher. This code handles parsing the autoqa arguments, generating the data to be passed to the test, and filtering the list of tests, if needed. It must contain three functions: extend_parser, process_testdata, and process_testlist.


This function adds hook-specific options to the given OptionParser object, so autoqa can properly parse the arguments given by the watcher. Here's the extend_parser() from post-repo-update:

import optparse

def extend_parser(parser):
    '''Extend the given OptionParser object with settings for this hook.'''
    parser.set_usage('%%prog %s [options] REPOURL' % name)
    group = optparse.OptionGroup(parser, '%s options' % name)
    group.add_option('-n', '--name', default='',
        help='Short, human-readable name for the repo under test')
    group.add_option('-p', '--parent', action='append', default=[],
        help='URL of a "parent" repo that this repo depends on for closure')
    return parser

The new options are generally used to handle the optional arguments to the test. This is where we've defined the --parent argument that the README mentioned.

The required argument(s) are handled in process_testdata().


This function generates and returns a dict of testdata - the key=value data that will be passed along to the test.

It uses the results of parser.parse_args() - opts contains the options, and args contains the list of unhandled (usually required) args. It also gets the requested test arch. (In the future it may get some extra keyword arguments, so it is usually defined with an **extra parameter.)

Here's the one from post-repo-update:

def process_testdata(opts, args, arch, **extra):
    testdata = {'url': args[0].replace('%a', arch),
                'parents': ' '.join(opts.parent).replace('%a', arch)}
        testdata['reponame'] = '%s-%s' % (, arch)
        testdata['reponame'] = testdata['url']
    return testdata

As you can see, it sets three values - The required argument is a URL, so we set url to the first non-option argument. parents is set to a space-separated list of the given --parent items. And reponame is set to the --name argument if given - otherwise we just use the URL, which is a nice unique identifier.


Finally we have process_testlist(). This function takes the list of known tests for this hook (see testlist below) and filters out anything that might not be appropriate for the given arguments. It returns the modified list of tests.

In its simplest form, this function can just be defined as follows:

def process_testlist(opts, args, testlist):
    return testlist

Here's the version used by post-repo-update:

def process_testlist(opts, args, testlist):
    if not'rawhide'):
        if 'rats_sanity' in testlist:
    return testlist

The rats_sanity test is only appropriate to run on Rawhide repos, so if the repo isn't named rawhide-something, we remove it from the list.


Each hook should provide two template files - control.template, which is an example control file, and, which is an example test object. For more info about control files and test objects, see Writing AutoQA Tests which explains the components of AutoQA tests in great detail.

Writing the test file templates is pretty simple. You can mostly just copy the existing template files from another hook. You'll need to edit the parts that explain the hook-specific arguments - the things that get handled and passed along by autoqa, as described above.


Once again, an example from post-repo-update:

DOC = """
This is the long description of the purpose of this test.
NAME = 'short_testname'
TEST_TYPE = 'CLIENT' # SERVER can be used for tests that need multiple machines
TEST_CLASS = 'General'
TEST_CATEGORY = 'Functional'

# post-repo-update tests can expect the following variables from autoqa:
#url - url of repo that changed
#parents - space-separated list of urls for 'parent' repos of the given repo
#reponame - name for repo that changed
#autoqa_conf - contents of {{filename|/etc/autoqa.conf}} on the server

job.run_test('testclassname', baseurl=url,

The comment in the middle of the file explains the arguments passed from autoqa, and the final run_test line gives an example of how those arguments should be passed to the test object.

The variable names are the keys from the testdata dict returned by process_testdata, above. autoqa_conf is a special variable that holds the contents of the server's /etc/autoqa.conf. This is used for passing system-wide config stuff along to the tests.

You can name the keyword arguments to the run_test function pretty much anything except "url". That's reserved by the autotest system itself.

This is an example test class.

from autotest_lib.client.bin import test, utils
from autotest_lib.client.bin.test_config import config_loader

class post_repo_update_test_class_name(test.test):
    version = 1 # increment if setup() changes

    def initialize(self, config):
        self.config = config_loader(config, self.tmpdir)

    def setup(self):
        # this is where you can install required packages and such, e.g.:
        #utils.system('yum -y install yum-utils')

    def run_once(self, baseurl, parents, reponame):
        parentlist = ' '.split(parents)
        cmd = 'test_binary --url %s' % baseurl
        # You can get stuff from the [test] section of autoqa.conf like this
        email = self.config.get('test','result_email')
        if email:
            cmd += ' --email %s --subject %s' % (email, reponame)
        self.results = utils.system_output(cmd, retain_output=True)

Again, this is mostly just boilerplate example code, except the names of the arguments to initialize() and run_once(). The arguments to run_once() must have the same names as the keyword arguments listed in control.template. This is how we get the autoqa arguments passed along to the test code itself.

This applies to initialize() as well. Note that you don't need all the keyword arguments - in this example, initialize() only pays attention to config and run_once() handles baseurl, parents, and reponame.

run_once() has some silly example code that shows how some of its arguments might conceivably be used; probably most users will throw this away, so don't worry too much about it being useful or correct.


This file simply lists the names of tests that should be run for this hook. These names must correspond to directories in tests/ that contain control files.


This is the heart of the hook: the part that actually watches for the event and triggers autoqa when it happens.

The watcher is responsible for constructing the correct autoqa commandline (as defined in #README and, above) and executing autoqa. The rest of the design depends on the nature of the event.

The current watchers for post-repo-update and post-tree-compose are run at regular intervals by cron. They check a certain file in each known repo (repomd.xml or .treeinfo, respectively) to see if it's different from the cached copy. If it's changed, they save the new file and launch autoqa for the repo/tree that has updated.

Yours could work that way, or it could be a daemon that waits for a signal, or any other design that makes sense. A full discussion about how to write a watcher is outside the scope of this page, but you might get some inspiration by looking at the current watchers: