Passing python script arguments to test modules

Question

I have several test modules that are all invoked together via a driver script that can take a variety of arguments. The tests themselves are written using the python unittest module.

import optparse
import unittest
import sys
import os

from tests import testvalidator
from tests import testmodifier
from tests import testimporter

#modify the path so that the test modules under /tests have access to the project root
sys.path.insert(0, os.path.dirname(__file__))

def run(verbosity):
    if verbosity == "0":
            sys.stdout = open(os.devnull, 'w')

    test_suite = unittest.TestSuite()
    test_suite.addTest(unittest.TestLoader().loadTestsFromTestCase(testvalidator.TestValidator))
    test_suite.addTest(unittest.TestLoader().loadTestsFromTestCase(testmodifier.TestModifier))
    test_suite.addTest(unittest.TestLoader().loadTestsFromTestCase(testimporter.TestDataImporter))

    unittest.TextTestRunner(verbosity=int(verbosity)).run(test_suite)

if __name__ == "__main__":

    #a simple way to control output verbosity
    parser = optparse.OptionParser()
    parser.add_option("--verbosity", "--verbosity", dest="verbosity", default="0")
    (options, args) = parser.parse_args()

    run(options.verbosity)

My issue is that, within these test modules, I have certain tests I'd like to skip based on different parameters passed to the driver. I'm aware that unittest provides a family of decorators meant to do this, but I don't know the best way to pass this information on to the individual modules. If I had a --skip-slow argument, for example, how could I then annotate tests as slow, and have them skipped?

Thank you for your time.

I may have found a solution you can use. Check my answer.

John Doe
– John Doe

2011-12-13 22:17:29 +00:00
Commented Dec 13, 2011 at 22:17 — John Doe
– John Doe, Commented Dec 13, 2011 at 22:17

John Doe · Accepted Answer · 2011-12-13 22:16:44Z

2

I had in fact been wondering this myself, and finally found the solution.

main file...

...
if __name__ == '__main__':
    args = argparser()

    from tests import *

    ...

And in your test modules, just do:

from __main__ import args

print args

I tested this out, and it worked rather nicely. Nice thing is how simple it is, and it's not too much of a hack at all.

answered Dec 13, 2011 at 22:16

John Doe

3,5241 gold badge21 silver badges21 bronze badges

Sign up to request clarification or add additional context in comments.

Comments

jcollado · Accepted Answer · 2011-12-13 21:17:08Z

2

You can use nose test runner with the attrib plugin that lets you select test cases based on attributes. In particular, the example in the plugin documentation uses @attr(slow) to mark slow test cases.

After that, from the command line:

To select all the test cases marked as slow:

$ nosetests -a slow
To select all the test cases not marked as slow:

$ nosetests -a '!slow'

answered Dec 13, 2011 at 21:17

jcollado

40.5k9 gold badges108 silver badges139 bronze badges

2 Comments

zchtodd Over a year ago

I probably need to acquaint myself with nose, as it seems unittest may not be up to this. I was holding out hope I wouldn't have to add a dependency.

jcollado Over a year ago

You can create you own attr decorator based on unittest.skipIf/unittest.skipUnless and some environment variable that is used in the condition that the skip decorators check, but I wouldn't say it's worth the effort when you have something that already works out of the box.

Jim DeLaHunt · Accepted Answer · 2018-09-06 08:14:14Z

Here's how I solved this problem. At the bottom of my module, I put this code to set a global variable based on the presence of a --slow argument in argv:

if __name__ == "__main__":
    try:
        i = sys.argv.index("--slow")
        run_slow_tests=True
        del sys.argv[i]
    except ValueError:
        pass

    unittest.main()

Then at the beginning of test functions which would be slow to run, I put this statement. It raises the unittest.SkipTest() exception if the flag isn't set to include slow tests.

if not run_slow_tests:
    raise unittest.SkipTest('Slow test skipped, unless --slow given in sys.argv.')

Then when I invoke the module normally, the slow tests are skipped.

% python src/my_test.py -v       
test_slow (__main__.Tests) ... skipped 'Slow test skipped, unless --slow given in sys.argv.'

----------------------------------------------------------------------
Ran 1 test in 0.000s

OK (skipped=1)

And when I add the --slow, the slow tests in that module run:

% python src/my_test.py -v --slow
test_slow (__main__.Tests) ... ok

----------------------------------------------------------------------
Ran 1 test in 10.110s

OK

Unfortunately, this doesn't work with Unittest's test discovery.

% python -m unittest discover src "*_test.py" --slow
usage: python -m unittest discover [-h] [-v] [-q] [--locals] [-f] [-c] [-b]
                                   [-k TESTNAMEPATTERNS] [-s START]
                                   [-p PATTERN] [-t TOP]
python -m unittest discover: error: unrecognized arguments: --slow

It also didn't work to use the @unittest.SkipUnless() decorator. I suspect this is because the decorator evaluates its arguments at module definition time, but the argument isn't set to the correct value until module run time, which is later.

It isn't perfect, but it lets me work within the Python standard library. A requirement like this is a good reason to adopt a better framework, such as nose tests. For my current project, I prefer to avoid installing any outside modules.

Collectives™ on Stack Overflow

Passing python script arguments to test modules

3 Answers 3

Comments

2 Comments

Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

3 Answers 3

Comments

2 Comments

Comments

Your Answer

Sign up or log in

Post as a guest

Related