Suite¶
Suite class is provider for nose.suite.ContextSuite. Major task is collect test cases and construction suite to run.
Simple example¶
>>> from noseapp import Suite
>>> suite = Suite(__name__)
Callbacks¶
class MySuite(Suite):
def setUp(self):
# Will be called before run suite
pass
def tearDown(self):
# Will be called after run suite
pass
suite = MySuite(__name__)
Require extensions¶
>>> suite = Suite(__name__, require=['extension_name'])
>>> suite.ext('extension_name')
Set default require¶
If all suites must have common require, then you can create base class and use DEFAULT_REQUIRE constant.
class MySuite(Suite):
DEFAULT_REQUIRE = [
'extension_name',
]
suite = MySuite(__name__, require=['something_else'])
suite.ext('extension_name')
suite.ext('something_else')
Usage skip¶
suite = Suite(__name__)
@suite.register(skip='TODO: ...') # skip class. you may use skip decorator for that.
class MyTestCase(TestCase):
@suite.skip('TODO: ...')
def test_one(self):
pass
@suite.skip_if(True, 'Message')
def test_two(self):
pass
@suite.skip_unless(False, 'Message')
def test_three(self):
pass
@suite.register(skip='TODO: ...')
def my_test(case):
pass
@suite.skip_if(True, 'Message')
@suite.register(simple=True)
def my_simple_test():
pass
Add callbacks¶
suite = Suite(__name__)
@suite.add_pre_run
def pre_run_test(test):
"""
:param test: instance of test case class
"""
# Callback will be called before run test
pass
# or
@suite.add_pre_run(lambda t: None)
@suite.add_post_run
def post_run_test(test):
"""
:param test: instance of test case class
"""
# Callback will be called after run test
pass
# or
@suite.add_post_run(lambda t: None)
@suite.add_setup
def setup():
pass
# or
@suite.add_setup(lambda: None)
@suite.add_teardown
def teardown():
pass
# or
@suite.add_teardown(lambda: None)
them maybe more...
Test case class¶
from noseapp import TestCase
class MyTestCase(TestCase):
def assertCallable(self, obj, msg=None):
self.assertTrue(callable(obj), (msg or 'not callable'))
class MySuite(Suite):
test_case_class = MyTestCase
suite = MySuite('name')
@suite.register
def test_case(case):
"""
:type case: MyTestCase
"""
case.assertCallable(lambda: None)
@suite.register
class CheckCallable(suite.TestCase):
def test(self):
self.assertCallable(lambda: None)
Usage extensions¶
Extensions will be available after build suite only, usage callbacks for that.
class MySuite(Suite):
DEFAULT_REQUIRE = [
'example_ex_name',
]
def setUp(self):
extension = self.ext('example_ex_name')
extension.do_something()
def tearDown(self):
extension = self.ext('example_ex_name')
extension.do_something()
Suite management by context object¶
from noseapp.suite.context import SuiteContext
COMMON_REQUIRE = [
'extension_name',
]
def common_pre_run(case):
case.do_something()
def common_post_run(case):
case.do_something()
def common_setup():
pass
def common_teardown():
pass
class MySuiteContext(SuiteContext):
def __init__(self, *require):
super(MySuiteContext, self).__init__(list(require))
self.require.extend(COMMON_REQUIRE)
self.add_pre_run(common_pre_run)
self.add_post_run(common_post_run)
self.add_setup(common_setup)
self.add_teardown(common_teardown)
suite = Suite(__name__, context=MySuiteContext())
suite2 = Suite(__name__, context=MySuiteContext('other_extension'))