import os import sys import unittest from nose import case, loader from nose.config import Config from nose.importer import _import from helpers import iter_compat from mock import * class TestNoseTestLoader(unittest.TestCase): def setUp(self): cwd = os.path.dirname(__file__) self.support = os.path.abspath(os.path.join(cwd, 'support')) def test_load_from_name_dir(self): l = loader.TestLoader() name = os.path.join(self.support, 'test-dir') expect = [ 'test module test in %s' % name ] found = [] for test in l.loadTestsFromName(name): found.append(str(test)) # print found self.assertEqual(found, expect) def test_load_from_name_file(self): l = loader.TestLoader() name = os.path.join(self.support, 'test.py') expect = [ 'test module test in %s' % self.support ] found = [] for test in l.loadTestsFromName(name): found.append(str(test)) # print found self.assertEqual(found, expect) def test_load_from_name_module(self): c = Config() c.where = self.support l = loader.TestLoader(c) name = 'test' expect = [ 'test module test in %s' % self.support, 'test module test in %s/test-dir' % self.support ] found = [] for test in l.loadTestsFromName(name): found.append(str(test)) c.where = os.path.join(self.support, 'test-dir') for test in l.loadTestsFromName(name): found.append(str(test)) print found self.assertEqual(found, expect) def test_load_from_names(self): c = Config() c.where = self.support l = loader.TestLoader(c) foo = _import('foo', [self.support], c) expect = [ 'test module test in %s' % self.support, 'test module foo.test_foo in %s' % self.support ] found = [] tests = l.loadTestsFromNames(['test', 'foo.test_foo']) for t in iter_compat(tests): found.append(str(t)) self.assertEqual(found, expect) expect = [ 'test module foo in %s' % self.support ] tests = l.loadTestsFromNames(None, module=foo) found = [ str(tests) ] self.assertEqual(found, expect) def test_load_from_names_compat(self): c = Config() l = loader.TestLoader(c) # implicit : prepended when module specified names = ['TestNoseTestLoader.test_load_from_names_compat'] tests = l.loadTestsFromNames(names, sys.modules[__name__]) # should be... me expect = [ 'test_load_from_names_compat ' '(%s.TestNoseTestLoader)' % __name__ ] found = [] # print tests for test in iter_compat(tests): # print test for t in iter_compat(test): # print t found.append(str(t)) self.assertEqual(found, expect) # explict : ok too c.tests = [] found = [] names[0] = ':' + names[0] tests = l.loadTestsFromNames(names, sys.modules[__name__]) for test in iter_compat(tests): for t in iter_compat(test): found.append(str(t)) self.assertEqual(found, expect) def test_load_from_class(self): c = Config() class TC: test_not = 1 def test_me(self): pass def not_a_tes_t(self): pass class TC2(unittest.TestCase): def test_whatever(self): pass class TC3(TC2): def test_somethingelse(self): pass l = loader.TestLoader() cases = l.loadTestsFromTestCase(TC) # print cases assert isinstance(cases[0], case.MethodTestCase) assert len(cases) == 1 self.assertEqual(str(cases[0]), '%s.TC.test_me' % __name__) cases2 = l.loadTestsFromTestCase(TC2) # print cases2 assert isinstance(cases2[0], unittest.TestCase) assert len(cases2) == 1 self.assertEqual(str(cases2[0]), 'test_whatever (%s.TC2)' % __name__) cases3 = l.loadTestsFromTestCase(TC3) # print cases3 assert len(cases3) == 2 self.assertEqual(str(cases3[0]), 'test_somethingelse (%s.TC3)' % __name__) self.assertEqual(str(cases3[1]), 'test_whatever (%s.TC3)' % __name__) def test_load_generator_method(self): class TC(object): _setup = False def setUp(self): assert not self._setup self._setup = True def test_generator(self): for a in range(0,5): yield self.check, a def check(self, val): assert self._setup assert val >= 0 assert val <= 5 l = loader.TestLoader() cases = l.loadTestsFromTestCase(TC) count = 0 for suite in iter_compat(cases): for case in iter_compat(suite): assert str(case) == '%s.TC.test_generator:(%d,)' % \ (__name__, count) count += 1 assert count == 5 def test_load_generator_func(self): m = Mod('testo', __path__=None) def testfunc(i): pass def testgenf(): for i in range(0, 5): yield testfunc, i m.testgenf = testgenf l = loader.TestLoader() cases = l.loadTestsFromModule(m) print cases count = 0 for case in iter_compat(cases): # print case self.assertEqual(str(case), '%s.testgenf:(%d,)' % (__name__, count)) count += 1 assert count == 5 def test_get_module_funcs(self): from StringIO import StringIO m = Mod('testo', __path__=None) def test_func(): pass class NotTestFunc(object): def __call__(self): pass class Selector: classes = [] funcs = [] def wantClass(self, test): self.classes.append(test) return False def wantFunction(self, test): self.funcs.append(test) return True sel = Selector() m.test_func = test_func m.test_func_not_really = NotTestFunc() m.StringIO = StringIO m.buffer = StringIO() l = loader.TestLoader(selector=sel) tests = l.testsInModule(m) print tests print sel.funcs assert test_func in sel.funcs assert not m.test_func_not_really in sel.funcs assert len(sel.funcs) == 1 def test_pkg_layout_lib_tests(self): from mock import Result from nose.util import absdir r = Result() l = loader.TestLoader() where = absdir(os.path.join(os.path.dirname(__file__), 'support/pkgorg')) print "where", where print "/lib on path before load?", where + '/lib' in sys.path tests = l.loadTestsFromDir(where) print "/lib on path after load?", where + '/lib' in sys.path print "tests", tests for t in tests: print "test", t # this will raise an importerror if /lib isn't on the path t(r) assert where + '/lib' in sys.path if __name__ == '__main__': #import logging #logging.basicConfig() #logging.getLogger('').setLevel(0) unittest.main(testLoader=loader.TestLoader())