def load_tests(loader, tests, pattern):
from unittest import TestSuite
from . import future, pair, source, async, limit, file, buffered, event
suite = TestSuite()
for test in (future, pair, source, async, limit, file, buffered, event):
suite.addTests(loader.loadTestsFromModule(test))
def test_suite():
result = TestSuite()
from . import testemail
loader = TestLoader()
result.addTests(loader.loadTestsFromModule(testemail))
return result
def load_tests():
test_suite = TestSuite()
this_dir = os.path.dirname(__file__)
loader = TestLoader()
package_tests = loader.discover(start_dir=this_dir)
test_suite.addTests(package_tests)
return test_suite
def gen_suite():
suite = TestSuite()
suite.addTest(suite_from_file('search_strings.txt', True))
# suite.addTest(suite_from_file('mobile_useragents.txt', True))
# suite.addTest(suite_from_file('other_useragents.txt', False))
suite.addTests(TestLoader().loadTestsFromTestCase(TestHTTPHeaders))
return suite
def load_doctests(
loader: Any, tests: TestSuite, ignore: Any, module: ModuleType,
additional_skip_names: Optional[
List[Union[str, ModuleType]]] = None,
modules_to_reload: Optional[List[ModuleType]] = None,
modules_to_patch: Optional[Dict[str, ModuleType]] = None,
allow_root_user: bool = True,
use_known_patches: bool = True,
patch_open_code: PatchMode = PatchMode.OFF,
patch_default_args: bool = False
) -> TestSuite: # pylint:disable=unused-argument
"""Load the doctest tests for the specified module into unittest.
Args:
loader, tests, ignore : arguments passed in from `load_tests()`
module: module under test
remaining args: see :py:class:`TestCase` for an explanation
File `example_test.py` in the pyfakefs release provides a usage example.
"""
_patcher = Patcher(additional_skip_names=additional_skip_names,
modules_to_reload=modules_to_reload,
modules_to_patch=modules_to_patch,
allow_root_user=allow_root_user,
use_known_patches=use_known_patches,
patch_open_code=patch_open_code,
patch_default_args=patch_default_args)
globs = _patcher.replace_globs(vars(module))
tests.addTests(doctest.DocTestSuite(module,
globs=globs,
setUp=_patcher.setUp,
tearDown=_patcher.tearDown))
return tests
def suite():
from unittest import TestSuite, defaultTestLoader
suite = TestSuite()
suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestRDFHelp))
suite.addTests(defaultTestLoader.loadTestsFromTestCase(TestRDFSchemas))
return suite
def load_tests (loader, tests, pattern):
from unittest import TestSuite
from . import future, pair, source, async, limit, file, buffered, event
suite = TestSuite ()
for test in (future, pair, source, async, limit, file, buffered, event):
suite.addTests (loader.loadTestsFromModule (test))
def load_tests(loader, tests, pattern):
''' Ensure TestHTMLBlocks doesn't get run twice by excluding it here. '''
suite = TestSuite()
for test_class in [TestDefaultwMdInHTML, TestMdInHTML, TestMarkdownInHTMLPostProcessor]:
tests = loader.loadTestsFromTestCase(test_class)
suite.addTests(tests)
return suite
def test_suite():
suite = TestSuite()
basicsearchtest = layered(
doctest.DocFileSuite(
"tests/basicsearch.txt",
package="collective.searchandreplace",
optionflags=oflags,
),
layer=SEARCH_REPLACE_FUNCTIONAL_LAYER,
)
searchavailabletest = layered(
doctest.DocFileSuite(
"tests/searchavailable.txt",
package="collective.searchandreplace",
optionflags=oflags,
),
layer=SEARCH_REPLACE_FUNCTIONAL_LAYER,
)
suite.addTests([
basicsearchtest,
searchavailabletest,
])
return suite
def load_tests(loader, tests, pattern):
suite = TestSuite()
for all_test_suite in defaultTestLoader.discover('.', pattern='*tests.py'):
for test_suite in all_test_suite:
suite.addTests(test_suite)
return suite
def suite():
users = [user_staff, user_staff, user_none
] + users_sponsors + users_secretariat
settings.ENABLE_CAPTCHA = False
settings.TEMPLATE_STRING_IF_INVALID = "BAD TEMPLATE"
suite = TestSuite()
suite.addTests(
LoginTestCase.parametrize(AccountManagementTest,
[user_staff, user_staff, user_none]))
suite.addTests(
LoginTestCase.parametrize(CreateConferenceTest,
[user_staff, user_none]))
suite.addTests(
LoginTestCase.parametrize(AccountManagementTest,
[sponsor1, sponsor2, sponsor3, sponsor4]))
#suite.addTests(LoginTestCase.parametrize(CreateSchoolTest, users))
suite.addTests(
LoginTestCase.parametrize(AccountManagementTest,
users_secretariat + users_sponsors))
#suite.addTests(LoginTestCase.parametrize(ConferenceTest, users))
suite.addTests(LoginTestCase.parametrize(ConfigureRegistrationTest, users))
#suite.addTests(LoginTestCase.parametrize(SchoolRegistrationTest, users))
#suite.addTests(LoginTestCase.parametrize(CountryAssignmentTest, users))
#suite.addTests(LoginTestCase.parametrize(DelegateRegistrationTest, users))
#suite.addTests(LoginTestCase.parametrize(PaymentsTest, users))
#suite.addTests(LoginTestCase.parametrize(ConferenceTest, users))
return suite
def suite():
import tests.sigv4_test
ts = TestSuite()
ts.addTests(tests.sigv4_test.get_test_cases())
return ts
def loadTestsFromName(self, name, module=None):
suite = TestSuite()
for test in findTests(name):
sys.path.insert(0, name) # python3 compatibility
suite.addTests(super(TestLoader, self).loadTestsFromName(test))
del sys.path[0] # python3 compatibility
return suite
def suite():
ts = TestSuite()
tests = [BenchMarkTest, BenchmarkModuleTest]
ts.addTests(map(makeSuite, tests))
return ts
def suite():
"""Suite of TestCases for Django"""
suite = TestSuite()
loader = TestLoader()
test_cases = (ManagersTestCase, EntryTestCase,
EntryGetBaseModelTestCase, SignalsTestCase,
EntryHtmlContentTestCase, CategoryTestCase,
ZinniaViewsTestCase, ZinniaFeedsTestCase,
ZinniaSitemapsTestCase, ComparisonTestCase,
DirectoryPingerTestCase, ExternalUrlsPingerTestCase,
TemplateTagsTestCase, QuickEntryTestCase,
URLShortenerTestCase, EntryCommentModeratorTestCase,
ZinniaCustomDetailViews, SpamCheckerTestCase,
EntryAdminTestCase, CategoryAdminTestCase,
MixinTestCase, LongEnoughTestCase,
AuthorTestCase)
if 'django_xmlrpc' in settings.INSTALLED_APPS:
test_cases += (PingBackTestCase, MetaWeblogTestCase)
for test_class in test_cases:
tests = loader.loadTestsFromTestCase(test_class)
suite.addTests(tests)
return suite
def suite():
suite = TestSuite()
suite.addTests(
defaultTestLoader.loadTestsFromTestCase(TestSubmissionModule))
suite.addTests(
defaultTestLoader.loadTestsFromTestCase(TestSubmission))
return suite
def all_tests():
suite = TestSuite()
loader = TestLoader()
suite.addTests(loader.loadTestsFromTestCase(RewriterTest))
return suite
def suite():
"""Suite of TestCases for Django"""
suite = TestSuite()
loader = TestLoader()
test_cases = (ManagersTestCase, EntryTestCase,
LoadModelClassTestCase, SignalsTestCase,
EntryHtmlContentTestCase, CategoryTestCase,
ZinniaViewsTestCase, ZinniaFeedsTestCase,
ZinniaSitemapsTestCase, ComparisonTestCase,
DirectoryPingerTestCase, ExternalUrlsPingerTestCase,
TemplateTagsTestCase, QuickEntryTestCase,
URLShortenerTestCase, EntryCommentModeratorTestCase,
ZinniaCustomDetailViews, SpamCheckerTestCase,
EntryAdminTestCase, CategoryAdminTestCase,
MixinTestCase, LongEnoughTestCase,
AuthorTestCase, FlagsTestCase,
AuthorListFilterTestCase, CategoryListFilterTestCase,
TranslatedURLsTestCase, EntryAbsoluteUrlTestCase,
MarkupsTestCase, FailImportMarkupTestCase,
PingBackTestCase, MetaWeblogTestCase,
HTMLPreviewTestCase,
EntryAdminFormTestCase, CategoryAdminFormTestCase,
MPTTModelChoiceIteratorTestCase,
MPTTModelMultipleChoiceFieldTestCase,
MPTTFilteredSelectMultipleTestCase
)
for test_class in test_cases:
tests = loader.loadTestsFromTestCase(test_class)
suite.addTests(tests)
return suite
def gen_suite():
suite = TestSuite()
suite.addTest(suite_from_file('search_strings.txt', True))
# suite.addTest(suite_from_file('mobile_useragents.txt', True))
# suite.addTest(suite_from_file('other_useragents.txt', False))
suite.addTests(TestLoader().loadTestsFromTestCase(TestHTTPHeaders))
return suite
def main():
os.environ["PYTHON_API_KEY"] = api_key
test_suites = _collect_test_suites()
main_test_suite = TestSuite()
for test_suite in test_suites:
main_test_suite.addTests(test_suite)
concurrent_suite = ConcurrentStreamTestSuite(
lambda: ((case, None) for case in main_test_suite))
result = StreamToDict(callback)
result.startTestRun()
try:
concurrent_suite.run(result)
finally:
result.stopTestRun()
all = SUCCESS + FAILS
print("All: " + str(all) + " SUCCESS: " + str(SUCCESS) + " FAILS: " +
str(FAILS))
if 'FAILED' in globals() and FAILED:
sys.exit(1)
def load_tests():
test_suite = TestSuite()
this_dir = os.path.dirname(__file__)
loader = TestLoader()
package_tests = loader.discover(start_dir=this_dir)
test_suite.addTests(package_tests)
return test_suite
def handle(self, *args, **options):
suite = TestSuite()
env = options['environment'][0]
if options['test_case'] is not None:
test_case = options['test_case']
else:
test_case = None
if env == 'unit':
pattern = '*UnitTest.py'
elif env == 'integration':
pattern = '*IntegrationTest.py'
elif env == 'functional':
pattern = '*FunctionalTest.py'
else:
raise ValueError('Invalid environment')
if test_case is not None:
pattern = test_case + ".py"
for all_test_suite in unittest.defaultTestLoader.discover(
'tests', pattern=pattern):
for test_suite in all_test_suite:
try:
suite.addTests(test_suite)
except Exception as e:
print("Error while adding test suite (" + str(test_suite) +
"): " + str(e))
raise e
runner = TextTestRunner(verbosity=1)
result = runner.run(suite)
sys.exit(not result.wasSuccessful())
def suite():
suite = TestSuite()
for m in UNIT_TESTS:
suite.addTests(TestLoader().loadTestsFromName(m))
for m in DOC_TESTS:
suite.addTest(DocTestSuite(__import__(m, {}, {}, [''])))
return suite
def loadTestsFromName(self, name, module=None):
suite = TestSuite()
for test in findTests(name):
sys.path.insert(0, name) # python3 compatibility
suite.addTests(super(TestLoader, self).loadTestsFromName(test))
del sys.path[0] # python3 compatibility
return suite
def load_tests(loader, tests, pattern):
suite = TestSuite()
for test_class in (RunMainPage, NewUserReg, UserLogIn, Logout, ResetPassword, UpdateUserInfo, BrandPage,
TakeActionVisitor, TakeActionUser):
tests = loader.loadTestsFromTestCase(test_class)
suite.addTests(tests)
return suite
def test_suite():
from unittest import TestSuite, makeSuite
tests = []
tests.append(makeSuite(DeviceIdTest))
suite = TestSuite()
suite.addTests(tests)
return suite
def test_suite():
result = TestSuite()
from . import test_news_merge
loader = TestLoader()
result.addTests(loader.loadTestsFromModule(test_news_merge))
return result
class TestHTMLTestRunner(TestCase):
def setUp(self):
self.suite = TestSuite()
self.loader = TestLoader()
self.suite.addTests(self.loader.loadTestsFromModule(tests.SampleTestPass))
self.suite.addTests(self.loader.loadTestsFromModule(tests.SampleTestFail))
self.suite.addTests(self.loader.loadTestsFromModule(tests.SampleTestBasic))
self.results_output_buffer = StringIO()
HTMLTestRunner(stream=self.results_output_buffer).run(self.suite)
self.byte_output = self.results_output_buffer.getvalue()
def test_SampleTestPass(self):
output1="".join(self.byte_output.split())
output2="".join(SampleTestPass.EXPECTED_RESULT.split())
self.assertGreater(output1.find(output2),0)
@skip("Test Skipping")
def test_SampleTestSkip(self):
self.fail("This error should never be displayed")
def test_SampleTestFail(self):
output1="".join(self.byte_output.split())
output2="".join(SampleTestFail.EXPECTED_RESULT.split())
self.assertGreater(output1.find(output2),0)
def test_SampleTestBasic(self):
output1="".join(self.byte_output.split())
output2="".join(SampleTestBasic.EXPECTED_RESULT.split())
self.assertGreater(output1.find(output2),0)
def load_tests( # pylint: disable=unused-argument
loader: TestLoader,
tests: TestSuite,
ignore: typing.Optional[str] = None) -> TestSuite:
"""Load doctests"""
tests.addTests(doctest.DocTestSuite("django_ca.subject"))
return tests
def load_tests(loader, tests, pattern):
suite = TestSuite()
for all_test_suite in defaultTestLoader.discover('.', pattern='*tests.py'):
for test_suite in all_test_suite:
suite.addTests(test_suite)
return suite
def suite():
suite = TestSuite()
loader = TestLoader()
for test_class in test_cases:
tests = loader.loadTestsFromTestCase(test_class)
suite.addTests(tests)
return suite
def suite():
"""Suite of TestCases for Django"""
suite = TestSuite()
loader = TestLoader()
test_cases = (ManagersTestCase, EntryTestCase, LoadModelClassTestCase,
SignalsTestCase, EntryHtmlContentTestCase, CategoryTestCase,
ZinniaViewsTestCase, ZinniaFeedsTestCase,
ZinniaSitemapsTestCase, ComparisonTestCase,
DirectoryPingerTestCase, ExternalUrlsPingerTestCase,
TemplateTagsTestCase, QuickEntryTestCase,
URLShortenerTestCase, EntryCommentModeratorTestCase,
ZinniaCustomDetailViews, SpamCheckerTestCase,
EntryAdminTestCase, CategoryAdminTestCase, MixinTestCase,
LongEnoughTestCase, AuthorTestCase, FlagsTestCase,
AuthorListFilterTestCase, CategoryListFilterTestCase,
TranslatedURLsTestCase, EntryAbsoluteUrlTestCase)
if 'django_xmlrpc' in settings.INSTALLED_APPS:
test_cases += (PingBackTestCase, MetaWeblogTestCase)
for test_class in test_cases:
tests = loader.loadTestsFromTestCase(test_class)
suite.addTests(tests)
return suite
def make_test_suite():
"""Load unittests placed in pybrain/tests/unittests, then return a
TestSuite object of those."""
# [...]/pybrain/pybrain [cut] /tests/runtests.py
path = os.path.abspath(__file__).rsplit(os.sep+'tests', 1)[0]
sys.path.append(path.rstrip('pybrain'))
top_testdir = os.path.join(path, 'tests', 'unittests')
testdirs = getSubDirectories(top_testdir)
# Initialize the testsuite to add to
suite = TestSuite()
optionflags = doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE | doctest.IGNORE_EXCEPTION_DETAIL
for testdir in testdirs:
# All unittest modules have to start with 'test_' and have to be, of
# course, python files
module_names = [f[:-3] for f in os.listdir(testdir)
if f.startswith('test_') and f.endswith('.py')]
if not module_names:
logging.info('No tests found in %s' % testdir)
continue
# "Magically" import the tests package and its test-modules that we've
# found
test_package_path = 'pybrain.tests.unittests'
sub_path = os.path.relpath(testdir, top_testdir).split(os.sep)
test_package_path = '.'.join([test_package_path]+sub_path)
test_package = __import__(test_package_path, fromlist=module_names)
# Put the test modules in a list that can be passed to the testsuite
modules = (getattr(test_package, n) for n in module_names)
modules = [(m, missingDependencies(m)) for m in modules]
untests = [(m, md) for m, md in modules if md]
modules = [m for m, md in modules if not md]
# print(out modules that are missing dependencies)
for module, miss_dep in untests: # Mr Dep is not around, though
logging.warning('Module %s is missing dependencies: %s' % (
module.__name__, ', '.join(miss_dep)))
# print(out a list of tests that are found)
for m in modules:
logging.info('Tests found: %s' % m.__name__)
# Build up the testsuite
suite.addTests([TestLoader().loadTestsFromModule(m) for m in modules])
# Add doctests from the unittest modules to the suite
for mod in modules:
try:
suite.addTest(doctest.DocTestSuite(mod, optionflags=optionflags))
except ValueError:
# No tests found.
pass
return suite
def load_tests(loader, tests, pattern):
logger = logging.getLogger()
logger.setLevel(logging.ERROR)
suite = TestSuite()
for test_class in test_cases:
tests = loader.loadTestsFromTestCase(test_class)
suite.addTests(tests)
return suite
def load_tests(loader, tests, pattern):
from unittest import TestSuite
from . import tests
suite = TestSuite()
for test in (tests,):
suite.addTests(loader.loadTestsFromModule(test))
return suite
def run_unittest_suite(self):
suite = TestSuite()
for name in self.test_dict.keys():
testClass = self.test_dict[name]['test']
testClass.RESULTS_PKL = self.test_dict[name]['resultsd']
_suite = TestLoader().loadTestsFromTestCase(testClass)
suite.addTests(_suite)
TextTestRunner(verbosity=2).run(suite)
def test_suite():
from unittest import TestSuite, makeSuite
suite = TestSuite()
suite.addTests(makeSuite(RecurrenceTest))
suite.layer = layer.ZCMLLayer
return suite
def suite():
""" returns all the testcases in this module """
suite = TestSuite()
suite.addTests(TestLoaderFiltered().loadTestsFromTestCase(
TclModuleGeneratorTest, sys.argv[1:]))
suite.addTests(TestLoaderFiltered().loadTestsFromTestCase(
LuaModuleGeneratorTest, sys.argv[1:]))
return suite
def test_suite():
suite = TestSuite()
suite.addTests(makeSuite(ATEventProviderTest))
suite.addTests(makeSuite(TopicEventProviderTest))
suite.layer = layer.ZCMLLayer
return suite
def load_tests(loader, tests, pattern):
suite = TestSuite()
names = ('phonio.test.softphone_test',
'phonio.test.dialer_test' )
for name in names:
tests = loader.loadTestsFromName(name)
suite.addTests(tests)
return suite
def test_suites():
test_loader = TestLoader()
test_suite = TestSuite()
# test_suite.addTest(UserGUI('test_U0001'))
test_suite.addTests([
test_loader.loadTestsFromTestCase(UserGUI),
])
return test_suite
def load_tests(*_):
"""Load doctests as unittest test suite.
For the parameters, see :mod:`unittest`. The parameters are unused here.
"""
suite = TestSuite()
suite.addTests(DocTestSuite('COT.ui.cli'))
return suite
def suite():
from unittest import TestSuite, defaultTestLoader
suite = TestSuite()
for testcase in [ExerimentsTestCases,
TestEmailNotify,
TestSequencer]:
suite.addTests(defaultTestLoader.loadTestsFromTestCase(testcase))
return suite
def suite(app, modnames=[], return_covermods=False):
"""Generate the test suite.
First argument is always the instance to use. Use a real one or a temporary.
The second argument is a list of modules to be tested. If it is empty (which
it is by default), all sub-modules of the pyClanSphere package are tested.
If the second argument is True, this function returns two objects: a
TestSuite instance and a list of the names of the tested modules. Otherwise
(which is the default) it only returns the former. This is done so that
this function can be used as setuptools' test_suite.
"""
# the app object is used for two purposes:
# 1) plugins are not usable (i.e. not testable) without an initialised app
# 2) for functions that require an application object as argument, you can
# write >>> my_function(app, ...) in the tests
# The instance directory of this object is located in the tests directory.
#
# setup isn't imported at module level because this way coverage
# can track the whole pyClanSphere imports
if return_covermods:
covermods = []
suite = TestSuite()
if modnames == []:
modnames = find_tp_modules()
test_files = os.listdir(dirname(__file__))
for modname in modnames:
# the fromlist must contain something, otherwise the pyClanSphere
# package is returned, not our module
try:
mod = __import__(modname, None, None, [''])
except ImportError, exc:
# some plugins can have external dependencies (e.g. creoleparser,
# pygments) that are not installed on the machine the tests are
# run on. Therefore, just skip those (with an error message)
if 'plugins.' in modname:
if 'versions.' not in modname and 'tests.' not in modname:
sys.stderr.write('could not import plugin %s: %s\n' % (modname, exc))
continue
else:
raise
suites = [DocTestSuite(mod, extraglobs={'app': app})]
filename = modname[10:] + '.txt'
if filename in test_files:
globs = {'app': app}
globs.update(mod.__dict__)
suites.append(DocFileSuite(filename, globs=globs))
for i, subsuite in enumerate(suites):
# skip modules without any tests
if subsuite.countTestCases():
suite.addTest(subsuite)
if return_covermods and i == 0:
covermods.append(mod)
if 'tests.' in modname:
suite.addTests(defaultTestLoader.discover(modname))
def suite():
"""Suite of TestCases for Django"""
suite = TestSuite()
loader = TestLoader()
test_cases = (
# Models
EntryTestCase,
AuthorTestCase,
CategoryTestCase,
ManagersTestCase,
LoadModelClassTestCase,
# Admin
EntryAdminTestCase,
CategoryAdminTestCase,
EntryAdminFormTestCase,
CategoryAdminFormTestCase,
AuthorListFilterTestCase,
CategoryListFilterTestCase,
MPTTModelChoiceIteratorTestCase,
MPTTModelMultipleChoiceFieldTestCase,
MPTTFilteredSelectMultipleTestCase,
# Front
MixinTestCase,
ViewsTestCase,
CustomDetailViewsTestCase,
FeedsTestCase,
SitemapsTestCase,
ComparisonTestCase,
TemplateTagsTestCase,
# HTML
HTMLPreviewTestCase,
EntryHtmlContentTestCase,
MarkupsTestCase,
MarkupFailImportTestCase,
# URLs
URLShortenerTestCase,
TranslatedURLsTestCase,
EntryAbsoluteUrlTestCase,
# Discussions
FlagsTestCase,
SignalsTestCase,
LongEnoughTestCase,
SpamCheckerTestCase,
CommentModeratorTestCase,
# Pinging
DirectoryPingerTestCase,
ExternalUrlsPingerTestCase,
# XML-RPC
PingBackTestCase,
MetaWeblogTestCase,
)
for test_class in test_cases:
tests = loader.loadTestsFromTestCase(test_class)
suite.addTests(tests)
return suite
def load_tests(*_):
"""Load doctests as unittest test suite.
For the parameters, see :mod:`unittest`. The parameters are unused here.
"""
suite = TestSuite()
suite.addTests(DocTestSuite('COT.data_validation'))
suite.addTests(DocTestSuite('COT.utilities'))
return suite
def create_test_suite():
"""create a unittest.TestSuite with available tests"""
from unittest import TestLoader, TestSuite
loader = TestLoader()
suite = TestSuite()
for test_name in available_tests:
exec("from . import " + test_name)
suite.addTests(loader.loadTestsFromModule(eval(test_name)))
return suite
def test_suite():
from unittest import TestSuite, makeSuite
suite = TestSuite()
suite.addTests((DocFileSuite(
'storage.txt',
tearDown=tearDown,
optionflags=doctest.NORMALIZE_WHITESPACE | doctest.ELLIPSIS,
), ))
return suite
def load_tests(loader, tests, pattern):
from unittest import TestSuite, TestLoader
if not ZODB:
from unittest import SkipTest
raise SkipTest("ZODB not installed")
suite = TestSuite()
suite.addTests(TestLoader().loadTestsFromTestCase(ZODBGraphTestCase))
suite.addTests(TestLoader().loadTestsFromTestCase(ZODBContextTestCase))
return suite
def load_tests (loader, tests, pattern):
from unittest import TestSuite
from . import hub, result, expr, proxy, conn
suite = TestSuite ()
for test in (hub, result, expr, proxy, conn,):
suite.addTests (loader.loadTestsFromModule (test))
return suite
def run_unittest_suite(self):
suite = TestSuite()
for name in self.test_dict.keys():
testClass = self.test_dict[name]['test']
testClass.WORK_DIR = self.test_dict[name]['work_dir']
testClass.RESULTS_PKL = os.path.join(testClass.WORK_DIR, AMPLE_PKL)
_suite = TestLoader().loadTestsFromTestCase(testClass)
suite.addTests(_suite)
TextTestRunner(verbosity=2).run(suite)
def build_suite(self, test_labels, extra_tests=None, **kwargs):
suite = TestSuite()
loader = TestLoader()
for fname in _get_module_names('.'):
module = _import(_to_importable_name(fname))
for test_case in _get_module_testcases(module):
suite.addTests(loader.loadTestsFromTestCase(test_case))
return reorder_suite(suite, (TestCase,))
def test_suite():
try:
sparrow.database('rdflib', 'memory')
except ConnectionError:
print('rdflib not installed?')
return TestSuite()
suite = TestSuite()
suite.addTests(make_suite(RDFLibTest, RDFLibQueryTest))
return suite
def load_tests(loader, tests, pattern):
from unittest import TestSuite, TestLoader
if not ZODB:
from unittest import SkipTest
raise SkipTest("ZODB not installed")
suite = TestSuite()
suite.addTests(TestLoader().loadTestsFromTestCase(ZODBGraphTestCase))
suite.addTests(TestLoader().loadTestsFromTestCase(ZODBContextTestCase))
return suite
def load_tests(loader, tests, pattern):
file_system = OSFileSystem()
repository = FileBasedTestRepository(file_system, Path.fromText("tests/acceptance/scenarios"), YamlCodec())
runner = EndToEndRunner(file_system)
generate = Generator(repository, runner)
suite = TestSuite()
tests = loader.loadTestsFromTestCase(generate.test_class())
suite.addTests(tests)
return suite
def load_tests(loader, tests, pattern):
lines = "-" * 100
suite = TestSuite()
testCases = test_cases
print testCases
for test_class in testCases:
tests = loader.loadTestsFromTestCase(test_class)
suite.addTests(tests)
return suite
