def getTestsFromModule(module_path):
klass = getTestClassFromModule(module_path)
if klass is None:
raise UserWarning("No tests classes found in: '%s'" % module_path)
loader = TestLoader()
return loader.loadTestsFromTestCase(klass)
def run(self):
"""@todo: Docstring for run
:returns: @todo
"""
loader = TestLoader()
t = TextTestRunner()
t.run(loader.loadTestsFromModule(vimdown.tests))
def run_unit_tests():
"""
Discover all unit test cases located in the test directory and run
"""
test_dir = os.path.dirname(__file__)
top_dir = os.path.dirname(os.path.dirname(test_dir))
test_loader = TestLoader()
run_unittest(test_loader.discover(test_dir,
pattern="unit_test.py"))
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 findTestsInDirectory(path, recursive=True, pattern="test*.py"):
loader = TestLoader()
test_suite = loader.discover(path, pattern=pattern)
for (root, dirnames, filenames) in os.walk(path):
for directory in dirnames:
test_suite.addTests(
ErtTestRunner.findTestsInDirectory(os.path.join(root, directory), recursive, pattern)
)
return test_suite
def run(self, *args, **kwargs):
testloader = TestLoader()
testSuite = testloader.discover(self.test_suite, top_level_dir='src/main/python')
test_result = ExtendedTeamcityTestRunner().run(testSuite)
test_result.printResults()
if test_result.wasSuccessful():
exit(0)
else:
exit(1)
def findTestsInDirectory(path, recursive=True, pattern="test*.py"):
loader = TestLoader()
test_suite = loader.discover(path, pattern=pattern)
for (root, dirnames, filenames) in os.walk(path):
for directory in dirnames:
test_suite.addTests(
ErtTestRunner.findTestsInDirectory(
os.path.join(root, directory), recursive, pattern))
return test_suite
def run(self, *args, **kwargs):
testloader = TestLoader()
testSuite = testloader.discover(self.test_suite,
top_level_dir='src/main/python')
test_result = ExtendedTeamcityTestRunner().run(testSuite)
test_result.printResults()
if test_result.wasSuccessful():
exit(0)
else:
exit(1)
def get_tests(d = '.'):
T = TestLoader()
t = T.discover(d)
stack = [t]
tests = []
while stack:
s = stack.pop()
for t in s:
if isinstance(t, TestSuite):
stack.append(t)
else:
tests.append(t)
return [test_name(v) for v in tests] # all test qualified names from this dir
def main():
# flake8
flake8 = get_style_guide(exclude=['.tox', 'build'])
report = flake8.check_files([BASE_DIR])
exit_code = print_report(report, flake8)
if exit_code > 0:
return exit_code
# unit tests
suite = TestLoader().discover(CODE_DIR, top_level_dir=BASE_DIR)
result = TextTestRunner().run(suite)
if result.wasSuccessful():
return 0
else:
return 1
def run(self):
# Force an in-place build for testing speedups
cmd = self.reinitialize_command('build_ext')
setattr(cmd, 'inplace', 1)
self.run_command('build_ext')
if sys.version_info[0:2] <= (2, 6):
try:
from unittest2 import TextTestRunner, TestLoader
except ImportError:
raise ImportError(
"unittest2 is required to run tests with python-%d.%d" %
sys.version_info[0:2])
else:
from unittest import TextTestRunner, TestLoader
import shapely.tests
tests = TestLoader().loadTestsFromName('test_suite', shapely.tests)
runner = TextTestRunner(verbosity=2)
result = runner.run(tests)
if not result.wasSuccessful():
sys.exit(1)
import sys
import os
from os.path import dirname, pardir, join, realpath
cwd = dirname(realpath(__file__))
runtime = realpath(join(cwd, pardir, pardir, 'msrest'))
sys.path.append(runtime)
if sys.version_info[:2] < (2, 7, ):
try:
from unittest2 import TestLoader, TextTestRunner
except ImportError:
raise ImportError("The Python Client Runtime test suite requires "
"the unittest2 package to run on Python 2.6 and "
"below.\nPlease install this package to continue.")
else:
from unittest import TestLoader, TextTestRunner
if __name__ == '__main__':
runner = TextTestRunner(verbosity=2)
test_dir = os.path.dirname(__file__)
test_loader = TestLoader()
suite = test_loader.discover(test_dir, pattern="unittest_*.py")
runner.run(suite)
def test_suite():
from unittest2 import TestLoader, TestSuite
return TestLoader().loadTestsFromName(__name__)
def getTestsFromTestClass(test_class_path, argv=None):
klass = ErtTestRunner.importClass(test_class_path)
klass.argv = argv
loader = TestLoader()
return loader.loadTestsFromTestCase(klass)
import optparse
import os
import sys
from xmlrunner import XMLTestRunner
try:
from unittest2 import TestLoader, TextTestRunner
except ImportError:
from unittest import TestLoader, TextTestRunner
base_path = os.path.dirname(__file__)
parser = optparse.OptionParser()
parser.add_option("-x", "--xml-prefix",
dest="xml_prefix",
help="generate XML test report in given directory",
default=None)
(options, args) = parser.parse_args()
loader = TestLoader()
tests = loader.discover(os.path.join(base_path, 'cvmfs/test'),
pattern='*_test.py')
runner = None
if options.xml_prefix:
runner = XMLTestRunner(output=options.xml_prefix, verbosity=2)
else:
runner = TextTestRunner(verbosity=2)
runner.run(tests)
def getTestsFromTestClass(test_class_path, argv=None):
klass = importClass(test_class_path)
klass.argv = argv
loader = TestLoader()
return loader.loadTestsFromTestCase(klass)
def runTestsInClass(classpath, test_verbosity=3):
klass = ErtTestRunner.importClass(classpath)
loader = TestLoader()
tests = loader.loadTestsFromTestCase(klass)
testRunner = TextTestRunner(verbosity=test_verbosity)
testRunner.run(tests)
def runTestsInDirectory(path="."):
loader = TestLoader()
tests = loader.discover(path)
testRunner = TextTestRunner()
testRunner.run(tests)
def runTestsInClass(classpath):
klass = importClass(classpath)
loader = TestLoader()
tests = loader.loadTestsFromTestCase(klass)
testRunner = TextTestRunner()
testRunner.run(tests)
except ImportError:
raise ImportError("The ADAL test suite requires the unittest2 "
"package to run on Python 2.6 and below.\n"
"Please install this package to continue.")
else:
from unittest import TestLoader, TextTestRunner
if sys.version_info[:2] >= (3, 3, ):
from unittest import mock
else:
try:
import mock
except ImportError:
raise ImportError("The ADAL test suite requires the mock "
"package to run on Python 3.2 and below.\n"
"Please install this package to continue.")
if __name__ == '__main__':
runner = TextTestRunner(verbosity=2)
test_dir = os.path.dirname(__file__)
top_dir = os.path.dirname(os.path.dirname(test_dir))
test_loader = TestLoader()
suite = test_loader.discover(test_dir,
pattern="test_*.py",
top_level_dir=top_dir)
runner.run(suite)
def runTestsInClass(classpath, test_verbosity=3):
klass = ErtTestRunner.importClass(classpath)
loader = TestLoader()
tests = loader.loadTestsFromTestCase(klass)
testRunner = TextTestRunner(verbosity=test_verbosity)
testRunner.run(tests)
import os
import sys
from xmlrunner import XMLTestRunner
try:
from unittest2 import TestLoader, TextTestRunner
except ImportError:
from unittest import TestLoader, TextTestRunner
base_path = os.path.dirname(__file__)
parser = optparse.OptionParser()
parser.add_option("-x",
"--xml-prefix",
dest="xml_prefix",
help="generate XML test report in given directory",
default=None)
(options, args) = parser.parse_args()
loader = TestLoader()
tests = loader.discover(os.path.join(base_path, 'cvmfs/test'),
pattern='*_test.py')
runner = None
if options.xml_prefix:
runner = XMLTestRunner(output=options.xml_prefix, verbosity=2)
else:
runner = TextTestRunner(verbosity=2)
runner.run(tests)
def get_all_tests(self):
tests = TestLoader().discover(self.testroot)
return [test for test in iterate_tests(tests)]
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import sys
if sys.version_info[:2] <= (2,6):
from unittest2 import TestLoader, TextTestRunner
else:
from unittest import TestLoader, TextTestRunner
testdir = os.path.split(os.path.abspath(__file__))[0]
topdir = os.path.split(testdir)[0]
libdir = os.path.join(topdir, 'lib')
os.chdir(testdir)
sys.path.insert(0, libdir)
loader = TestLoader()
tests = loader.discover('.', 'flow_*.py')
runner = TextTestRunner(verbosity=2, buffer=True)
runner.run(tests)
def suite():
start_dir = os.path.dirname(__file__)
return TestLoader().discover(start_dir)
try:
import mock
except ImportError:
raise ImportError("The BatchApps Python Client test suite requires "
"the mock package to run on Python 3.2 and below.\n"
"Please install this package to continue.")
try:
from teamcity import is_running_under_teamcity
from teamcity.unittestpy import TeamcityTestRunner
TC_BUILD = is_running_under_teamcity()
except ImportError:
TC_BUILD = False
if __name__ == '__main__':
if TC_BUILD:
runner = TeamcityTestRunner()
else:
runner = TextTestRunner(verbosity=2)
test_dir = os.path.dirname(__file__)
top_dir = os.path.dirname(os.path.dirname(test_dir))
test_loader = TestLoader()
suite = test_loader.discover(test_dir,
pattern="unittest_*.py",
top_level_dir=top_dir)
runner.run(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)
# You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import sys
if sys.version_info[:2] <= (2, 6):
from unittest2 import TestLoader, TextTestRunner
else:
from unittest import TestLoader, TextTestRunner
testdir = os.path.split(os.path.abspath(__file__))[0]
topdir = os.path.split(testdir)[0]
libdir = os.path.join(topdir, 'lib')
os.chdir(testdir)
sys.path.insert(0, libdir)
loader = TestLoader()
tests = loader.discover('.', 'flow_*.py')
runner = TextTestRunner(verbosity=2, buffer=True)
runner.run(tests)
#!/usr/bin/env python
import os
import sys
from unittest2 import TestLoader, TextTestRunner
if __name__ == '__main__':
tests_dir = os.path.dirname(os.path.abspath(__file__))
authorize_dir = os.path.join(tests_dir, os.path.pardir)
sys.path.append(authorize_dir)
suite = TestLoader().discover(tests_dir)
runner = TextTestRunner(verbosity=1)
result = runner.run(suite)
sys.exit(not result.wasSuccessful())
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
import os
import sys
if sys.version_info[:2] <= (2,6):
from unittest2 import TestLoader, TextTestRunner
else:
from unittest import TestLoader, TextTestRunner
testdir = os.path.split(os.path.abspath(__file__))[0]
topdir = os.path.split(testdir)[0]
libdir = os.path.join(topdir, 'lib')
os.chdir(testdir)
sys.path.insert(0, libdir)
loader = TestLoader()
tests = loader.discover('.', 'test_*.py')
runner = TextTestRunner(verbosity=2, buffer=True)
runner.run(tests)
