def makeSuite(self):
class TC(SeleniumTestCase):
def runTest(self):
self.wd.get("http://google.com")
self.assertEqual(self.wd.title, "Google")
return TestSuite([TC()])
def suite(self):
""" Returns a TestSuite that can be run
TestSuite is computed according to what is defined in the specification
"""
all_suites = TestSuite()
if self._create_allowed:
maker = CreateTestMaker(self._sdk_parent_object, self._sdk_object, self._helper)
suite = maker.suite()
all_suites.addTests(suite)
if self._update_allowed:
maker = UpdateTestMaker(self._sdk_parent_object, self._sdk_object, self._helper)
suite = maker.suite()
all_suites.addTests(suite)
if self._delete_allowed:
maker = DeleteTestMaker(self._sdk_parent_object, self._sdk_object, self._helper)
suite = maker.suite()
all_suites.addTests(suite)
if self._get_allowed:
maker = GetTestMaker(self._sdk_parent_object, self._sdk_object, self._helper)
suite = maker.suite()
all_suites.addTests(suite)
if self._get_all_allowed:
maker = GetAllTestMaker(self._sdk_parent_object, self._sdk_object, self._helper)
suite = maker.suite()
all_suites.addTests(suite)
return all_suites
def load_tests(loader, standard_tests, pattern):
"""Returns the test suite for this module."""
suite = TestSuite()
suite.addTest(loader.loadTestsFromTestCase(OperatorsTest))
suite.addTest(loader.loadTestsFromTestCase(QueryCreationTest))
suite.addTest(loader.loadTestsFromTestCase(SearchTest))
return suite
def load_tests(loader, standard_tests, pattern):
"""Returns the test suite for this module."""
suite = TestSuite()
suite.addTest(loader.loadTestsFromTestCase(HelpersTest))
suite.addTest(loader.loadTestsFromTestCase(ModelHelpersTest))
suite.addTest(loader.loadTestsFromTestCase(FunctionEvaluationTest))
return suite
def suite():
suite = TestSuite()
suite.addTest(defaultTestLoader.loadTestsFromTestCase(TestParseLine))
suite.addTest(defaultTestLoader.loadTestsFromTestCase(TestFuzzyMatch))
if is_win:
suite.addTest(defaultTestLoader.loadTestsFromTestCase(TestAppIdentification))
return suite
def makeSuite(self):
class TC(LiveWebServerSeleniumTestCase):
def runTest(self):
self.wd.get('http://%s:%s' % (LOCALHOST, self.webserver.port))
self.assertTrue(False)
return TestSuite([TC()])
def allTest():
''''' 创建测试集'''
suite1 = TestLoader().loadTestsFromTestCase(login_case_ddt.LoginCase)
suite2 = TestLoader().loadTestsFromTestCase(
release_topic_case_ddt.ReleasdTopic)
alltests = TestSuite([suite1, suite2])
return alltests
def makeSuite(self):
class TC(LiveWebServerSeleniumTestCase):
def runTest(self):
self.wd.get('http://%s:%s' % (LOCALHOST, self.webserver.port))
self.wd.find_element_by_css_selector(
"#this-does-not-exist").click()
return TestSuite([TC()])
def suite():
"""Returns the test suite for this module."""
result = TestSuite()
loader = defaultTestLoader
result.addTest(loader.loadTestsFromModule(test_manager))
result.addTest(loader.loadTestsFromModule(test_search))
result.addTest(loader.loadTestsFromModule(test_validation))
result.addTest(loader.loadTestsFromModule(test_views))
return result
def suite():
"""Returns the test suite for this module."""
result = TestSuite()
loader = defaultTestLoader
result.addTest(loader.loadTestsFromModule(test_api))
return result
def test_doc(self):
suite = TestSuite()
for filename in os.listdir('../'):
if filename.endswith(".py"):
suite.addTest(doctest.DocFileSuite('../' + filename))
runner = TextTestRunner(verbosity=2)
runner.run(suite)
def test_given(tests):
module = sys.modules[__name__]
if tests == None:
defaultTest = None
else:
loader = TestLoader()
defaultTest = TestSuite()
tests = loader.loadTestsFromNames(tests, module)
defaultTest.addTests(tests)
main(defaultTest=defaultTest)
def test_suite():
suite = TestSuite()
OPTIONFLAGS = (doctest.ELLIPSIS | doctest.NORMALIZE_WHITESPACE)
for testfile in ('testBrowserLayers.txt', 'testCustomizeView.txt'):
suite.addTest(FunctionalDocFileSuite(testfile,
optionflags=OPTIONFLAGS,
package="plone.app.customerize.tests",
test_class=CustomerizeFunctionalTestCase),
)
return suite
def load_tests(loader, standard_tests, pattern):
"""Loads the tests from this module"""
suite = TestSuite()
# Only enable if you have a local server running.
# TODO: Consider automatic skipping if zmq fails to connect
# suite.addTest(loader.loadTestsFromTestCase(LiveGuessApiTestCase))
suite.addTest(loader.loadTestsFromTestCase(ClientTestCase))
suite.addTest(loader.loadTestsFromTestCase(CORSTestCase))
return suite
def suite():
suite = TestSuite()
for test in make_json_suite():
for p in test['pass']:
datum = json.loads(json.dumps(p.datum))
suite.addTest(make_pass(test['schema'], datum))
suite.addTest(make_reserialize(test['schema'], datum))
for f in test['fail']:
datum = json.loads(json.dumps(f.datum))
suite.addTest(make_fail(test['schema'], datum))
return suite
def makeSuite(self):
class TC(LiveWebServerSeleniumTestCase):
def runTest(self):
self.wd.get('http://%s:%s' % (LOCALHOST, self.webserver.port))
self.wd.implicitly_wait(0)
ScreenshotOnExceptionWebDriverWait(
self.wd,
10).until(lambda s: self.wd.find_element_by_css_selector(
"#this-does-not-exist"))
return TestSuite([TC()])
def suite(self):
""" Inject generated tests
"""
GetTestCase.parent = self.parent
GetTestCase.sdkobject = self.sdkobject
GetTestCase.helper = self.helper
tests = self.make_tests(sdkobject=self.sdkobject, testcase=GetTestCase)
for test_name, test_func in tests.items():
setattr(GetTestCase, test_name, test_func)
return TestSuite(list(map(GetTestCase, tests)))
def suite(self):
""" Inject generated tests
"""
DeleteTestCase.parent = self.parent
DeleteTestCase.sdkobject = self.sdkobject
DeleteTestCase.helper = self.helper
tests = self.make_tests(sdkobject=self.sdkobject, testcase=DeleteTestCase)
for test_name, test_func in tests.iteritems():
setattr(DeleteTestCase, test_name, test_func)
return TestSuite(map(DeleteTestCase, tests))
def makeSuite(self):
class TC(TestCase):
def runTest(self):
raise ValueError("We should never get here")
return TestSuite([TC()])
def test_suite():
from unittest2 import TestSuite, makeSuite
suite = TestSuite()
suite.addTest(makeSuite(BasicTests))
return suite
file_content = file.read()
p = ast.parse(file_content)
classes = [
node.name for node in ast.walk(p)
if isinstance(node, ast.ClassDef)
]
for cls in classes:
# class_to_test = module_name + '.' + cls
file_report_name = module_name + '_' + cls
print(file_report_name)
report_path = 'test/report/Report_' + file_report_name + '.html'
f_load = open(report_path, 'w')
f_load.close()
runner = HTMLTestRunner(
stream=open(report_path, "wb"),
title="Unit Test Reports",
description='This is Unit test report of system.')
loader = TestLoader()
m = importlib.import_module(module_name)
# class_to_test = 'm.' + cls
suite = TestSuite(
(loader.loadTestsFromTestCase(getattr(m, cls)), ))
# run the test
runner.run(suite)
def suite():
import teleport_test, language_test
main = defaultTestLoader.loadTestsFromModule(teleport_test)
language = language_test.suite()
return TestSuite([main, language])
def load_tests(loader, standard_tests, pattern):
"""Returns the test suite for this module."""
suite = TestSuite()
suite.addTest(loader.loadTestsFromTestCase(ProcessorsTest))
return suite
def test_suite():
from unittest2 import TestSuite, makeSuite
suite = TestSuite()
suite.addTest(makeSuite(PreconditionTests))
suite.addTest(makeSuite(PreconditionRegistryTests))
return suite
def suite():
s = TestSuite()
def load_tests(loader, standard_tests, pattern):
"""Returns the test suite for this module."""
suite = TestSuite()
suite.addTest(loader.loadTestsFromTestCase(APIManagerTest))
suite.addTest(loader.loadTestsFromTestCase(FSATest))
return suite
def load_tests(loader, standard_tests, pattern):
"""Returns the test suite for this module."""
suite = TestSuite()
suite.addTest(loader.loadTestsFromTestCase(SimpleValidationTest))
suite.addTest(loader.loadTestsFromTestCase(SAVTest))
return suite
