"Testing default initializer"
text = """
ABC3 = (1, 2, 3)
1: ABC1* = ABC
1: ABC2* = ABC1 and ABC2
"""
data = self.params[1]
eng = Model( mode='plde', text=text )
eng.initialize( missing=helper.initializer( data, default=(1,1,1) ) )
for node in 'ABC1 ABC2'.split():
self.assertEqual( eng.start[node], (1, 1, 1) )
self.assertEqual( eng.start['ABC3'], (1.0, 2.0, 3.0) )
def get_suite():
suite = unittest.TestLoader().loadTestsFromTestCase( HelperTest )
return suite
if __name__ == '__main__':
unittest.TextTestRunner( verbosity=2 ).run( get_suite() )
fname = 'test-params.csv'
# this contains all parameters
params = helper.read_parameters( fname )
#print params[0].PIC['conc']
def test_runner(root_tmpdir, resultclass, failfast=False):
resultclass.root_tmpdir = root_tmpdir
return unittest.TextTestRunner(verbosity=255, resultclass=resultclass, failfast=failfast)
if tests.countTestCases() == 0:
print("%s had no unit tests" % parsed.pyfile)
sys.exit(1)
all_tests = {}
for test in tests:
for t in test:
all_tests[str(t)] = t
if parsed.test:
# A test name was passed in, so just try to run it.
if parsed.test in all_tests:
test_to_run = all_tests[parsed.test]
# Apparently the setupClass/tearDownClass aren't called when running an individual test
test_to_run.setUpClass()
runner = unittest.TextTestRunner(verbosity=parsed.verbosity, buffer=parsed.buffer)
results = runner.run(test_to_run)
test_to_run.tearDownClass()
sys.exit(int(not results.wasSuccessful()))
else:
print("%s not found in %s" % (parsed.test, parsed.pyfile))
sys.exit(1)
else:
# No test name passed in. Break out each test and run them in their own process
final_code = 0
for name in all_tests.keys():
cmd = [__file__, "-f", parsed.pyfile, "-v", str(parsed.verbosity), "-t", name]
if parsed.buffer:
cmd.append("-b")
ret = subprocess.call(cmd)
if ret != 0:
from com.db.conf import Conf
from com.db.library import Log
from com.db.library.Common import LoginApp
from com.db.library.Spider import Element
class TestCaseForgetPassword(TestCase):
def setUp(self):
self.driver = LoginApp().sysLogin()
Conf.DRIVER = self.driver
self.driver.implicitly_wait(30)
def test_case_001_forget_password(self):
Conf.CASE_NAME = "test_case_001_forget_password"
Log.start_test(Conf.CASE_NAME)
Element.find_element(self.driver, By.CLASS_NAME,
u'pass-fgtpwd').click()
Log.stop_test()
def tearDown(self):
self.driver.quit()
if __name__ == "__main__":
suite = unittest.TestSuite()
suite.addTest(TestCaseForgetPassword("test_case_001_forget_password"))
unittest.TextTestRunner().run(suite)
def test():
test = unittest.TestLoader().discover('project/tests', pattern='test_*.py')
result = unittest.TextTestRunner(verbosity=2).run(test)
if result.wasSuccessful():
return 0
return 1
def runTests():
suite = unittest.defaultTestLoader.loadTestsFromTestCase(TestStringMethods)
unittest.TextTestRunner(verbosity=2, failfast=True).run(suite)
def test(count):
"""运行单元测试"""
import unittest
test_suite = unittest.TestLoader().discover(('tests'))
unittest.TextTestRunner(verbosity=count).run(test_suite)
def main():
pytests = pysuite()
unittest.TextTestRunner(verbosity=2).run(pytests)
return
def test():
runner = unittest.TextTestRunner()
runner.run(suite())
def run_all():
# demo_test = unittest.TestLoader().loadTestsFromTestCase(PkiCatalogTests)
unittest.TextTestRunner(verbosity=3, stream=sys.stdout).run(suite())
def run_subset():
unittest.TextTestRunner(verbosity=3, stream=sys.stdout).run(suiteSubset())
parser.add_argument(
'--testdata',
help=
"test data directory (default is testdata folder within script directory)"
)
#### Parse Arguments
args = parser.parse_args()
global test_dir
if args.testdata:
test_dir = os.path.abspath(args.testdata)
else:
test_dir = os.path.join(script_dir, 'testdata')
if not os.path.isdir(test_dir):
parser.error("Test data folder does not exist: {}".format(test_dir))
test_cases = [
TestMosaicImageInfo, TestMosaicDataValues, TestMosaicCutlinesShp,
TestMosaicTilesShp, TestMiscFunctions
]
suites = []
for test_case in test_cases:
suite = unittest.TestLoader().loadTestsFromTestCase(test_case)
suites.append(suite)
alltests = unittest.TestSuite(suites)
unittest.TextTestRunner(verbosity=2).run(alltests)
def main():
suite = unittest.TestLoader().loadTestsFromTestCase(SolutionTester)
unittest.TextTestRunner(verbosity=2).run(suite)
def main():
pytests = pysuite()
alltests = unittest.TestSuite( (pytests, ) )
unittest.TextTestRunner(verbosity=2).run(alltests)
return
def _run_complete_suite():
from exactly_lib_test.cli_default.test_resources.internal_main_program_runner import \
main_program_runner_with_default_setup__in_same_process
unittest.TextTestRunner().run(complete_suite_for(main_program_runner_with_default_setup__in_same_process()))
## @file
# Unit tests for C based BaseTools
#
# Copyright (c) 2008, Intel Corporation. All rights reserved.<BR>
#
# SPDX-License-Identifier: BSD-2-Clause-Patent
#
##
# Import Modules
#
import os
import sys
import unittest
import TianoCompress
modules = (TianoCompress, )
def TheTestSuite():
suites = list(map(lambda module: module.TheTestSuite(), modules))
return unittest.TestSuite(suites)
if __name__ == '__main__':
allTests = TheTestSuite()
unittest.TextTestRunner().run(allTests)
def run_test(TestCase):
import cStringIO
stream = cStringIO.StringIO()
suite = unittest.TestLoader().loadTestsFromTestCase(TestCase)
unittest.TextTestRunner(stream=stream, verbosity=2).run(suite)
return stream.getvalue()
cleartext = BlockIo.Helper.decrypt(ciphertext, key)
self.assertEqual(cleartext, clear.encode('utf-8'))
class TestKeys(unittest.TestCase):
def setUp(self):
self.priv = "6b0e34587dece0ef042c4c7205ce6b3d4a64d0bc484735b9325f7971a0ead963"
self.passphrase = "deadbeeffeedface";
def test_key_init(self):
key = BlockIo.Key(unhexlify(self.priv))
self.assertEqual(key.pubkey_hex(), b'029c06f988dc6b44696e002e8abf496a13c73c2f1db3bde2dfb69be129f3711b01')
def test_from_passphrase(self):
key = BlockIo.Key.from_passphrase(unhexlify(self.passphrase))
self.assertEqual(key.pubkey_hex(), b'029023d9738c623cdd7e5fdd0f41666accb82f21df5d27dc5ef07040f7bdc5d9f5')
basicTest = unittest.TestLoader().loadTestsFromTestCase(TestBasicInteractions)
witdrawTest = unittest.TestLoader().loadTestsFromTestCase(TestWithdrawInteractions)
sigTest = unittest.TestLoader().loadTestsFromTestCase(TestDeterministicSignatures)
helperTest = unittest.TestLoader().loadTestsFromTestCase(TestHelpers)
keyTest = unittest.TestLoader().loadTestsFromTestCase(TestKeys)
# run dat shiznit
print("TESTING BLOCK-IO, api: v{av}; client: v{cv}".format(av=block_io.version, cv=block_io.clientVersion))
unittest.TextTestRunner(verbosity=2).run(helperTest)
unittest.TextTestRunner(verbosity=2).run(keyTest)
unittest.TextTestRunner(verbosity=2).run(sigTest)
unittest.TextTestRunner(verbosity=2).run(basicTest)
unittest.TextTestRunner(verbosity=2).run(witdrawTest)
except OSError:
pass
# See what pbap-client sees.
self.assertIn('Creating Session', lines)
self.assertIn('--- Select Phonebook PB ---', lines)
self.assertIn('--- GetSize ---', lines)
self.assertIn('Size = 0', lines)
self.assertIn('--- List vCard ---', lines)
self.assertIn(
'Transfer /org/bluez/obex/client/session0/transfer0 complete',
lines)
self.assertIn(
'Transfer /org/bluez/obex/client/session0/transfer1 complete',
lines)
self.assertIn(
'Transfer /org/bluez/obex/client/session0/transfer2 complete',
lines)
self.assertIn(
'Transfer /org/bluez/obex/client/session0/transfer3 complete',
lines)
self.assertIn('FINISHED', lines)
self.assertNotIn('ERROR', lines)
if __name__ == '__main__':
# avoid writing to stderr
unittest.main(testRunner=unittest.TextTestRunner(stream=sys.stdout,
verbosity=2))
def test_detect_empty_integer(self):
with self.assertRaisesRegexp(DecodingException,
"^Empty integer"):
bdecode(b"l4:spamiee")
def test_detect_leading_zeroes(self):
# Detect leading zero
with self.assertRaisesRegexp(DecodingException,
"^Leading zeroes"):
bdecode(b"i01e", strict=True)
# Detect leading zero of negative number
with self.assertRaisesRegexp(DecodingException,
"^Leading zeroes"):
bdecode(b"i-01e", strict=True)
# Detect negative zero
with self.assertRaisesRegexp(DecodingException,
"negative zero"):
bdecode(b"i-0e", strict=True)
# However, the zero itself must be accepted...
self.assertEquals(0, bdecode(b"i0e", strict=True))
def test_bad_sized_string(self):
with self.assertRaises(DecodingException):
bdecode(b"l12:normalstring-5:badstringe")
unittest.main(testRunner=unittest.TextTestRunner(verbosity=2), exit=False)
def test():
tests = unittest.TestLoader().discover('tests')
unittest.TextTestRunner().run(tests)
dest.write(bytes(score, 'utf-8'))
dest.write(b'\n')
if summary_file is not None:
avg_quality = score_sum / base_count if base_count > 0 else None
summary = dict(base_count=base_count, avg_quality=avg_quality)
summary_writer = csv.DictWriter(summary_file,
['avg_quality', 'base_count'],
lineterminator=os.linesep)
summary_writer.writeheader()
summary_writer.writerow(summary)
if __name__ == '__main__':
args = parseArgs()
censor(src=args.original_fastq,
bad_cycles_reader=csv.DictReader(args.bad_cycles_csv),
dest=args.censored_fastq,
use_gzip=not args.unzipped)
elif __name__ == '__live_coding__':
import unittest
from micall.tests.censor_fastq_test import CensorTest
suite = unittest.TestSuite()
suite.addTest(CensorTest("testSummaryEmpty"))
test_results = unittest.TextTestRunner().run(suite)
print(test_results.errors)
print(test_results.failures)
for i,(text,pageNumber,key) in enumerate(TOC):
yb = y - i*leading #baseline
canv.drawString(x,yb,text)
canv.drawRightString(x1,y-i*leading,str(pageNumber))
canv.endForm()
canv.restoreState()
headerStyle = makeHeaderStyle(0)
S = [Spacer(0,180),UseForm('TOC')]
RT = 'STARTUP COMPUTERS BLAH BUZZWORD STARTREK PRINTING PYTHON CHOMSKY'.split()
for i in range(chapters):
S.append(PageBreak())
S.append(HParagraph(i,'This is chapter %d' % (i+1), headerStyle))
txt = xmlEscape(randomtext.randomText(RT[i*13 % len(RT)], 15))
para = Paragraph(txt, makeBodyStyle())
S.append(para)
S.append(MakeForm('TOC'))
doc = MyDocTemplate(outputfile('test_platypus_toc_simple.pdf'))
doc.build(S)
def makeSuite():
return makeSuiteForClasses(TocTestCase)
#noruntests
if __name__ == "__main__":
unittest.TextTestRunner().run(makeSuite())
printLocation()
... def test_skipunless(self):
... raise RuntimeError
...
>>> suite = unittest.TestLoader().loadTestsFromTestCase(TestSkip)
>>> unittest.TextTestRunner(verbosity=2).run(suite)
test_always_run (__main__.TestSkip) ... ok
test_always_skip (__main__.TestSkip) ... skipped 'always skip this test'
test_skipif (__main__.TestSkip) ... skipped 'demo skipIf'
test_skipunless (__main__.TestSkip) ... skipped 'demo skipUnless'
----------------------------------------------------------------------
Ran 4 tests in 0.000s
OK (skipped=3)
Monolithic Test
>>> from __future__ import print_function
>>> import unittest
>>> class Monolithic(unittest.TestCase):
... def step1(self):
... print('step1')
... def step2(self):
... print('step2')
... def step3(self):
... print('step3')
... def _steps(self):
... for attr in sorted(dir(self)):
... if not attr.startswith('step'):
... continue
... yield attr
... def test_foo(self):
... for _s in self._steps():
... try:
... getattr(self, _s)()
... except Exception as e:
... self.fail('{} failed({})'.format(attr, e))
...
>>> suite = unittest.TestLoader().loadTestsFromTestCase(Monolithic)
>>> unittest.TextTestRunner().run(suite)
step1
step2
step3
.
----------------------------------------------------------------------
Ran 1 test in 0.000s
OK
<unittest.runner.TextTestResult run=1 errors=0 failures=0>
Cross-module variables to Test files
test_foo.py
from __future__ import print_function
import unittest
print(conf)
class TestFoo(unittest.TestCase):
def test_foo(self):
print(conf)
@unittest.skipIf(conf.isskip==True, "skip test")
def test_skip(self):
raise RuntimeError
test_bar.py
from __future__ import print_function
import unittest
import __builtin__
if __name__ == "__main__":
conf = type('TestConf', (object,), {})
conf.isskip = True
# make a cross-module variable
__builtin__.conf = conf
module = __import__('test_foo')
loader = unittest.TestLoader()
suite = loader.loadTestsFromTestCase(module.TestFoo)
unittest.TextTestRunner(verbosity=2).run(suite)
output:
$ python test_bar.py
<class '__main__.TestConf'>
test_foo (test_foo.TestFoo) ... <class '__main__.TestConf'>
ok
test_skip (test_foo.TestFoo) ... skipped 'skip test'
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK (skipped=1)
skip setup & teardown when the test is skipped
>>> from __future__ import print_function
>>> import unittest
>>> class TestSkip(unittest.TestCase):
... def setUp(self):
... print("setUp")
... def tearDown(self):
... print("tearDown")
... @unittest.skip("skip this test")
... def test_skip(self):
... raise RuntimeError
... def test_not_skip(self):
... self.assertTrue(True)
...
>>> suite = unittest.TestLoader().loadTestsFromTestCase(TestSkip)
>>> unittest.TextTestRunner(verbosity=2).run(suite)
test_not_skip (__main__.TestSkip) ... setUp
tearDown
ok
test_skip (__main__.TestSkip) ... skipped 'skip this test'
----------------------------------------------------------------------
Ran 2 tests in 0.000s
OK (skipped=1)
Re-using old test code
>>> from __future__ import print_function
>>> import unittest
>>> def old_func_test():
... assert "Hello" == "Hello"
...
>>> def old_func_setup():
... print("setup")
...
>>> def old_func_teardown():
... print("teardown")
...
>>> testcase = unittest.FunctionTestCase(old_func_test,
... setUp=old_func_setup,
... tearDown=old_func_teardown)
>>> suite = unittest.TestSuite([testcase])
>>> unittest.TextTestRunner().run(suite)
setup
teardown
.
----------------------------------------------------------------------
Ran 1 test in 0.000s
OK
<unittest.runner.TextTestResult run=1 errors=0 failures=0>
Testing your document is right
"""
This is an example of doctest
>>> fib(10)
55
"""
def fib(n):
""" This function calculate fib number.
Example:
>>> fib(10)
55
>>> fib(-1)
Traceback (most recent call last):
...
ValueError
"""
if n < 0:
raise ValueError('')
return 1 if n<=2 else fib(n-1) + fib(n-2)
if __name__ == "__main__":
import doctest
doctest.testmod()
output:
$ python demo_doctest.py -v
Trying:
fib(10)
Expecting:
55
ok
Trying:
fib(10)
Expecting:
55
ok
Trying:
fib(-1)
Expecting:
Traceback (most recent call last):
...
ValueError
ok
2 items passed all tests:
1 tests in __main__
2 tests in __main__.fib
3 tests in 2 items.
3 passed and 0 failed.
Test passed.
Re-using doctest to unittest
import unittest
import doctest
"""
This is an example of doctest
>>> fib(10)
55
"""
def fib(n):
""" This function calculate fib number.
Example:
>>> fib(10)
55
>>> fib(-1)
Traceback (most recent call last):
...
ValueError
"""
if n < 0:
raise ValueError('')
return 1 if n<=2 else fib(n-1) + fib(n-2)
if __name__ == "__main__":
finder = doctest.DocTestFinder()
suite = doctest.DocTestSuite(test_finder=finder)
unittest.TextTestRunner(verbosity=2).run(suite)
output:
fib (__main__)
Doctest: __main__.fib ... ok
----------------------------------------------------------------------
Ran 1 test in 0.023s
OK
Customize test report
from unittest import (
TestCase,
TestLoader,
TextTestResult,
TextTestRunner)
from pprint import pprint
import unittest
import os
OK = 'ok'
FAIL = 'fail'
ERROR = 'error'
SKIP = 'skip'
class JsonTestResult(TextTestResult):
def __init__(self, stream, descriptions, verbosity):
super_class = super(JsonTestResult, self)
super_class.__init__(stream, descriptions, verbosity)
# TextTestResult has no successes attr
self.successes = []
def addSuccess(self, test):
# addSuccess do nothing, so we need to overwrite it.
super(JsonTestResult, self).addSuccess(test)
self.successes.append(test)
def json_append(self, test, result, out):
suite = test.__class__.__name__
if suite not in out:
out[suite] = {OK: [], FAIL: [], ERROR:[], SKIP: []}
if result is OK:
out[suite][OK].append(test._testMethodName)
elif result is FAIL:
out[suite][FAIL].append(test._testMethodName)
elif result is ERROR:
out[suite][ERROR].append(test._testMethodName)
elif result is SKIP:
out[suite][SKIP].append(test._testMethodName)
else:
raise KeyError("No such result: {}".format(result))
return out
def jsonify(self):
json_out = dict()
for t in self.successes:
json_out = self.json_append(t, OK, json_out)
for t, _ in self.failures:
json_out = self.json_append(t, FAIL, json_out)
for t, _ in self.errors:
json_out = self.json_append(t, ERROR, json_out)
for t, _ in self.skipped:
json_out = self.json_append(t, SKIP, json_out)
return json_out
class TestSimple(TestCase):
def test_ok_1(self):
foo = True
self.assertTrue(foo)
def test_ok_2(self):
bar = True
self.assertTrue(bar)
def test_fail(self):
baz = False
self.assertTrue(baz)
def test_raise(self):
raise RuntimeError
@unittest.skip("Test skip")
def test_skip(self):
raise NotImplementedError
if __name__ == '__main__':
# redirector default output of unittest to /dev/null
with open(os.devnull, 'w') as null_stream:
# new a runner and overwrite resultclass of runner
runner = TextTestRunner(stream=null_stream)
runner.resultclass = JsonTestResult
# create a testsuite
suite = TestLoader().loadTestsFromTestCase(TestSimple)
# run the testsuite
result = runner.run(suite)
# print json output
pprint(result.jsonify())
output:
$ python test.py
{'TestSimple': {'error': ['test_raise'],
'fail': ['test_fail'],
'ok': ['test_ok_1', 'test_ok_2'],
'skip': ['test_skip']}}
Mock - using @patch substitute original method
# python-3.3 or above
>>> from unittest.mock import patch
>>> import os
>>> def fake_remove(path, *a, **k):
... print("remove done")
...
>>> @patch('os.remove', fake_remove)
... def test():
... try:
... os.remove('%$!?&*') # fake os.remove
... except OSError as e:
... print(e)
... else:
... print('test success')
...
>>> test()
remove done
test success
Note
Without mock, above test will always fail.
>>> import os
>>> def test():
... try:
... os.remove('%$!?&*')
... except OSError as e:
... print(e)
... else:
... print('test success')
...
>>> test()
[Errno 2] No such file or directory: '%$!?&*'
What with unittest.mock.patch do?
from unittest.mock import patch
import os
PATH = '$@!%?&'
def fake_remove(path):
print("Fake remove")
class SimplePatch:
def __init__(self, target, new):
self._target = target
self._new = new
def get_target(self, target):
target, attr = target.rsplit('.', 1)
getter = __import__(target)
return getter, attr
def __enter__(self):
orig, attr = self.get_target(self._target)
self.orig, self.attr = orig, attr
self.orig_attr = getattr(orig, attr)
setattr(orig, attr, self._new)
return self._new
def __exit__(self, *exc_info):
setattr(self.orig, self.attr, self.orig_attr)
del self.orig_attr
print('---> inside unittest.mock.patch scope')
with patch('os.remove', fake_remove):
os.remove(PATH)
print('---> inside simple patch scope')
with SimplePatch('os.remove', fake_remove):
os.remove(PATH)
print('---> outside patch scope')
try:
os.remove(PATH)
except OSError as e:
print(e)
output:
$ python3 simple_patch.py
---> inside unittest.mock.patch scope
Fake remove
---> inside simple patch scope
Fake remove
---> outside patch scope
[Errno 2] No such file or directory: '$@!%?&'
Mock - substitute open
>>> import urllib
>>> from unittest.mock import patch, mock_open
>>> def send_req(url):
... with urllib.request.urlopen(url) as f:
... if f.status == 200:
... return f.read()
... raise urllib.error.URLError
...
>>> fake_html = b'<html><h1>Mock Content</h1></html>'
>>> mock_urlopen = mock_open(read_data=fake_html)
>>> ret = mock_urlopen.return_value
>>> ret.status = 200
>>> @patch('urllib.request.urlopen', mock_urlopen)
... def test_send_req_success():
... try:
... ret = send_req('http://www.mockurl.com')
... assert ret == fake_html
... except Exception as e:
... print(e)
... else:
... print('test send_req success')
...
>>> test_send_req_success()
test send_req success
>>> ret = mock_urlopen.return_value
>>> ret.status = 404
>>> @patch('urllib.request.urlopen', mock_urlopen)
... def test_send_req_fail():
... try:
... ret = send_req('http://www.mockurl.com')
... assert ret == fake_html
... except Exception as e:
... print('test fail success')
...
>>> test_send_req_fail()
test fail success
gobject.threads_init()
SKIP_FILES = ['runtests',
'test_mainloop', # no os.fork on windows
'test_subprocess'] # blocks on testChildWatch
if __name__ == '__main__':
testdir = os.path.split(os.path.abspath(__file__))[0]
os.chdir(testdir)
def gettestnames():
files = glob.glob('*.py')
names = map(lambda x: x[:-3], files)
map(names.remove, SKIP_FILES)
return names
suite = unittest.TestSuite()
loader = unittest.TestLoader()
for name in gettestnames():
try:
suite.addTest(loader.loadTestsFromName(name))
except Exception, e:
print 'Could not load %s: %s' % (name, e)
testRunner = unittest.TextTestRunner()
testRunner.verbosity = 2
testRunner.run(suite)
def fib(n):
""" This function calculate fib number.
Example:
>>> fib(10)
55
>>> fib(-1)
Traceback (most recent call last):
...
ValueError
"""
if n < 0:
raise ValueError('')
return 1 if n<=2 else fib(n-1) + fib(n-2)
if __name__ == "__main__":
import doctest
doctest.testmod()
output:
$ python demo_doctest.py -v
Trying:
fib(10)
Expecting:
55
ok
Trying:
fib(10)
Expecting:
55
ok
Trying:
fib(-1)
Expecting:
Traceback (most recent call last):
...
ValueError
ok
2 items passed all tests:
1 tests in __main__
2 tests in __main__.fib
3 tests in 2 items.
3 passed and 0 failed.
Test passed.
Re-using doctest to unittest
import unittest
import doctest
"""
This is an example of doctest
>>> fib(10)
55
"""
def fib(n):
""" This function calculate fib number.
Example:
>>> fib(10)
55
>>> fib(-1)
Traceback (most recent call last):
...
ValueError
"""
if n < 0:
raise ValueError('')
return 1 if n<=2 else fib(n-1) + fib(n-2)
if __name__ == "__main__":
finder = doctest.DocTestFinder()
suite = doctest.DocTestSuite(test_finder=finder)
unittest.TextTestRunner(verbosity=2).run(suite)
output:
fib (__main__)
Doctest: __main__.fib ... ok
----------------------------------------------------------------------
Ran 1 test in 0.023s
OK
Customize test report
from unittest import (
TestCase,
TestLoader,
TextTestResult,
TextTestRunner)
from pprint import pprint
import unittest
import os
OK = 'ok'
FAIL = 'fail'
ERROR = 'error'
SKIP = 'skip'
class JsonTestResult(TextTestResult):
def __init__(self, stream, descriptions, verbosity):
super_class = super(JsonTestResult, self)
super_class.__init__(stream, descriptions, verbosity)
# TextTestResult has no successes attr
self.successes = []
def addSuccess(self, test):
# addSuccess do nothing, so we need to overwrite it.
super(JsonTestResult, self).addSuccess(test)
self.successes.append(test)
def json_append(self, test, result, out):
suite = test.__class__.__name__
if suite not in out:
out[suite] = {OK: [], FAIL: [], ERROR:[], SKIP: []}
if result is OK:
out[suite][OK].append(test._testMethodName)
elif result is FAIL:
out[suite][FAIL].append(test._testMethodName)
elif result is ERROR:
out[suite][ERROR].append(test._testMethodName)
elif result is SKIP:
out[suite][SKIP].append(test._testMethodName)
else:
raise KeyError("No such result: {}".format(result))
return out
def jsonify(self):
json_out = dict()
for t in self.successes:
json_out = self.json_append(t, OK, json_out)
for t, _ in self.failures:
json_out = self.json_append(t, FAIL, json_out)
for t, _ in self.errors:
json_out = self.json_append(t, ERROR, json_out)
for t, _ in self.skipped:
json_out = self.json_append(t, SKIP, json_out)
return json_out
class TestSimple(TestCase):
def test_ok_1(self):
foo = True
self.assertTrue(foo)
def test_ok_2(self):
bar = True
self.assertTrue(bar)
def test_fail(self):
baz = False
self.assertTrue(baz)
def test_raise(self):
raise RuntimeError
@unittest.skip("Test skip")
def test_skip(self):
raise NotImplementedError
if __name__ == '__main__':
# redirector default output of unittest to /dev/null
with open(os.devnull, 'w') as null_stream:
# new a runner and overwrite resultclass of runner
runner = TextTestRunner(stream=null_stream)
runner.resultclass = JsonTestResult
# create a testsuite
suite = TestLoader().loadTestsFromTestCase(TestSimple)
# run the testsuite
result = runner.run(suite)
# print json output
pprint(result.jsonify())
output:
$ python test.py
{'TestSimple': {'error': ['test_raise'],
'fail': ['test_fail'],
'ok': ['test_ok_1', 'test_ok_2'],
'skip': ['test_skip']}}
Mock - using @patch substitute original method
# python-3.3 or above
>>> from unittest.mock import patch
>>> import os
>>> def fake_remove(path, *a, **k):
... print("remove done")
...
>>> @patch('os.remove', fake_remove)
... def test():
... try:
... os.remove('%$!?&*') # fake os.remove
... except OSError as e:
... print(e)
... else:
... print('test success')
...
>>> test()
remove done
test success
Note
Without mock, above test will always fail.
>>> import os
>>> def test():
... try:
... os.remove('%$!?&*')
... except OSError as e:
... print(e)
... else:
... print('test success')
...
>>> test()
[Errno 2] No such file or directory: '%$!?&*'
What with unittest.mock.patch do?
from unittest.mock import patch
import os
PATH = '$@!%?&'
def fake_remove(path):
print("Fake remove")
class SimplePatch:
def __init__(self, target, new):
self._target = target
self._new = new
def get_target(self, target):
target, attr = target.rsplit('.', 1)
getter = __import__(target)
return getter, attr
def __enter__(self):
orig, attr = self.get_target(self._target)
self.orig, self.attr = orig, attr
self.orig_attr = getattr(orig, attr)
setattr(orig, attr, self._new)
return self._new
def __exit__(self, *exc_info):
setattr(self.orig, self.attr, self.orig_attr)
del self.orig_attr
print('---> inside unittest.mock.patch scope')
with patch('os.remove', fake_remove):
os.remove(PATH)
print('---> inside simple patch scope')
with SimplePatch('os.remove', fake_remove):
os.remove(PATH)
print('---> outside patch scope')
try:
os.remove(PATH)
except OSError as e:
print(e)
output:
$ python3 simple_patch.py
---> inside unittest.mock.patch scope
Fake remove
---> inside simple patch scope
Fake remove
---> outside patch scope
[Errno 2] No such file or directory: '$@!%?&'
Mock - substitute open
>>> import urllib
>>> from unittest.mock import patch, mock_open
>>> def send_req(url):
... with urllib.request.urlopen(url) as f:
... if f.status == 200:
... return f.read()
... raise urllib.error.URLError
...
>>> fake_html = b'<html><h1>Mock Content</h1></html>'
>>> mock_urlopen = mock_open(read_data=fake_html)
>>> ret = mock_urlopen.return_value
>>> ret.status = 200
>>> @patch('urllib.request.urlopen', mock_urlopen)
... def test_send_req_success():
... try:
... ret = send_req('http://www.mockurl.com')
... assert ret == fake_html
... except Exception as e:
... print(e)
... else:
... print('test send_req success')
...
>>> test_send_req_success()
test send_req success
>>> ret = mock_urlopen.return_value
>>> ret.status = 404
>>> @patch('urllib.request.urlopen', mock_urlopen)
... def test_send_req_fail():
... try:
... ret = send_req('http://www.mockurl.com')
... assert ret == fake_html
... except Exception as e:
... print('test fail success')
...
>>> test_send_req_fail()
test fail success
for exp in [1, 7]:
for mant in [1, 31]:
try:
t = CT(exp=exp, mant=mant)
except ValueError:
self.fail("CT constructor raised ExceptionType unexpectedly " +
"for exp={0}, mant={1}".format(exp, mant))
def test_invalid_ct_constructions(self):
def bad(args, kwargs): CT(**kwargs)
self.assertRaises(ValueError, bad, [], { "exp" : -1 })
self.assertRaises(ValueError, bad, [], { "mant" : -1 })
self.assertRaises(ValueError, bad, [], { "exp" : 8 })
self.assertRaises(ValueError, bad, [], { "mant" : 32 })
def test_ct_conversion_to_int(self):
self.assertEqual(int(CT(1,1)), 4)
self.assertEqual(int(CT(2,2)), 32)
self.assertEqual(int(CT(3,3)), 192)
def test_byte_generation(self):
self.assertEqual( bytearray(CT(1, 1))[0], int('00100001', 2))
self.assertEqual( bytearray(CT(7,31))[0], int('11111111', 2))
def test_compress(self):
self.assertEqual(1024, CT.compress(1024).decompress())
if __name__ == '__main__':
suite = unittest.TestLoader().loadTestsFromTestCase(TestCT)
unittest.TextTestRunner(verbosity=2).run(suite)
def test():
"""Run the unit tests."""
import unittest
tests = unittest.TestLoader().discover('tests')
unittest.TextTestRunner(verbosity=2).run(tests)
mode = 'solo'
test_case = args['testcase']
else:
parser.print_help()
else:
#Make sure user did not attempt to specify a test-case, show help if so.
if args['testcase'] == None:
if args['admin']:
mode = 'admin'
elif args['dev']:
mode = 'developer'
else:
mode = 'default'
else:
#If user didn't specify admin or dev, assume solo mode.
if not args['admin'] and not args['dev']:
mode = 'solo'
test_case = args['testcase']
else:
parser.print_help()
#If the user wants a log, give them a log.
log = False
if args['log']:
log = True
#Run the test suite.
runner = unittest.TextTestRunner(verbosity=2)
test_suite = suite(mode, test_case, log)
runner.run(test_suite)
def test_main():
testsuite = suite()
runner = unittest.TextTestRunner(sys.stdout, verbosity=2)
result = runner.run(testsuite)
