Contents
This package provides a number of testing frameworks. It includes a flexible test runner, and supports both doctest and unittest.
Enhanced version of python's standard doctest.py. Better test count (one per block instead of one per docstring). See doctest.txt.
(We need to merge this with the standard doctest module.)
An HTML parser that extracts form information.
This is intended to support functional tests that need to extract information from HTML forms returned by the publisher.
See formparser.txt.
Support for testing logging code
If you want to test that your code generates proper log output, you can create and install a handler that collects output.
Lets a doctest pretend to be a Python module.
See module.txt.
zope.testing uses buildout. To start, run python bootstrap.py. It will create a number of directories and the bin/buildout script. Next, run bin/buildout. It will create a test script for you. Now, run bin/test to run the zope.testing test suite.
LP #560259: Fix subunit output formatter to handle layer setup errors.
LP #399394: Added a --stop-on-error / --stop / -x option to the testrunner.
LP #498162: Added a --pdb alias for the existing --post-mortem / -D option to the testrunner.
LP #547023: Added a --version option to the testrunner.
Added tests for LP #144569 and #69988.
Sometimes in functional tests, information from a generated form must be extracted in order to re-submit it as part of a subsequent request. The zope.testing.formparser module can be used for this purpose.
The scanner is implemented using the FormParser class. The constructor arguments are the page data containing the form and (optionally) the URL from which the page was retrieved:
>>> import zope.testing.formparser>>> page_text = '''\ ... <html><body> ... <form name="form1" action="/cgi-bin/foobar.py" method="POST"> ... <input type="hidden" name="f1" value="today" /> ... <input type="submit" name="do-it-now" value="Go for it!" /> ... <input type="IMAGE" name="not-really" value="Don't." ... src="dont.png" /> ... <select name="pick-two" size="3" multiple> ... <option value="one" selected>First</option> ... <option value="two" label="Second">Another</option> ... <optgroup> ... <option value="three">Third</option> ... <option selected="selected">Fourth</option> ... </optgroup> ... </select> ... </form> ... ... Just for fun, a second form, after specifying a base: ... <base href="http://www.example.com/base/" /> ... <form action = 'sproing/sprung.html' enctype="multipart/form"> ... <textarea name="sometext" rows="5">Some text.</textarea> ... <input type="Image" name="action" value="Do something." ... src="else.png" /> ... <input type="text" value="" name="multi" size="2" /> ... <input type="text" value="" name="multi" size="3" /> ... </form> ... </body></html> ... '''>>> parser = zope.testing.formparser.FormParser(page_text) >>> forms = parser.parse()>>> len(forms) 2 >>> forms.form1 is forms[0] True >>> forms.form1 is forms[1] False
More often, the parse() convenience function is all that's needed:
>>> forms = zope.testing.formparser.parse( ... page_text, "http://cgi.example.com/somewhere/form.html")>>> len(forms) 2 >>> forms.form1 is forms[0] True >>> forms.form1 is forms[1] False
Once we have the form we're interested in, we can check form attributes and individual field values:
>>> form = forms.form1 >>> form.enctype 'application/x-www-form-urlencoded' >>> form.method 'post'>>> keys = form.keys() >>> keys.sort() >>> keys ['do-it-now', 'f1', 'not-really', 'pick-two']>>> not_really = form["not-really"] >>> not_really.type 'image' >>> not_really.value "Don't." >>> not_really.readonly False >>> not_really.disabled False
Note that relative URLs are converted to absolute URLs based on the <base> element (if present) or using the base passed in to the constructor.
>>> form.action 'http://cgi.example.com/cgi-bin/foobar.py' >>> not_really.src 'http://cgi.example.com/somewhere/dont.png'>>> forms[1].action 'http://www.example.com/base/sproing/sprung.html' >>> forms[1]["action"].src 'http://www.example.com/base/else.png'
Fields which are repeated are reported as lists of objects that represent each instance of the field:
>>> field = forms[1]["multi"] >>> type(field) <type 'list'> >>> [o.value for o in field] ['', ''] >>> [o.size for o in field] [2, 3]
The <textarea> element provides some additional attributes:
>>> ta = forms[1]["sometext"] >>> print ta.rows 5 >>> print ta.cols None >>> ta.value 'Some text.'
The <select> element provides access to the options as well:
>>> select = form["pick-two"] >>> select.multiple True >>> select.size 3 >>> select.type 'select' >>> select.value ['one', 'Fourth']>>> options = select.options >>> len(options) 4 >>> [opt.label for opt in options] ['First', 'Second', 'Third', 'Fourth'] >>> [opt.value for opt in options] ['one', 'two', 'three', 'Fourth']
Writing doctest setUp and tearDown functions can be a bit tedious, especially when setUp/tearDown functions are combined.
the zope.testing.setupstack module provides a small framework for automating test tear down. It provides a generic setUp function that sets up a stack. Normal test setUp functions call this function to set up the stack and then use the register function to register tear-down functions.
To see how this works we'll create a faux test:
>>> class Test:
... def __init__(self):
... self.globs = {}
>>> test = Test()
We'll register some tearDown functions that just print something:
>>> import sys
>>> import zope.testing.setupstack
>>> zope.testing.setupstack.register(
... test, lambda : sys.stdout.write('td 1\n'))
>>> zope.testing.setupstack.register(
... test, lambda : sys.stdout.write('td 2\n'))
Now, when we call the tearDown function:
>>> zope.testing.setupstack.tearDown(test) td 2 td 1
The registered tearDown functions are run. Note that they are run in the reverse order that they were registered.
Extra positional arguments can be passed to register:
>>> zope.testing.setupstack.register(
... test, lambda x, y, z: sys.stdout.write('%s %s %s\n' % (x, y, z)),
... 1, 2, z=9)
>>> zope.testing.setupstack.tearDown(test)
1 2 9
Often, tests create files as they demonstrate functionality. They need to arrange for the removeal of these files when the test is cleaned up.
The setUpDirectory function automates this. We'll get the current directory first:
>>> import os >>> here = os.getcwd()
We'll also create a new test:
>>> test = Test()
Now we'll call the setUpDirectory function:
>>> zope.testing.setupstack.setUpDirectory(test)
We don't have to call zope.testing.setupstack.setUp, because setUpDirectory calls it for us.
Now the current working directory has changed:
>>> here == os.getcwd() False
We can create files to out heart's content:
>>> open('Data.fs', 'w').write('xxx')
>>> os.path.exists('Data.fs')
True
We'll make the file read-only. This can cause problems on Windows, but setupstack takes care of that by making files writable before trying to remove them.
>>> import stat
>>> os.chmod('Data.fs', stat.S_IREAD)
On Unix systems, broken symlinks can cause problems because the chmod attempt by the teardown hook will fail; let's set up a broken symlink as well, and verify the teardown doesn't break because of that:
>>> if hasattr(os, 'symlink'):
... os.symlink('NotThere', 'BrokenLink')
When tearDown is called:
>>> zope.testing.setupstack.tearDown(test)
We'll be back where we started:
>>> here == os.getcwd() True
and the files we created will be gone (along with the temporary directory that was created:
>>> os.path.exists('Data.fs')
False