我们在用Unittest框架时，生成html格式的报告一般都是用HTMLTestRunner.py这个第三方库，大概使用方法如下：
with open(config.report_file, 'wb') as fp:
HTMLTestRunner(stream=fp,
title='[{}] 接口测试报告'.format(date),
verbosity=2,
description='每日定时接口测试，监控线上接口情况').run(suite)
我们实例化一个HTMLTestRunner类的对象，并调用该类的run()方法，传入的是unittest.TestSuite类的对象suite，执行测试用例（测试套件）生成测试结果并写入html模板中，生成网页报告。在我们使用的时候，只要调用HTMLTestRunner().run()就行了，那么HTMLTestRunner().run()内部做了哪些事呢？
在HTMLTestRunner.py中有一个类HTMLTestRunner，该类有一个方法run，该方法如下：
# HTMLTestRunner.py
class HTMLTestRunner(Template_mixin):
......
......
def run(self, test):
"Run the given test case or test suite."
result = _TestResult(self.verbosity)
test(result)
self.stopTime = datetime.datetime.now()
self.generateReport(test, result)
print('\nTime Elapsed: %s' % (self.stopTime-self.startTime), file=sys.stderr)
return result
run()接收一个参数test，根据注释我们知道该参数代表test case 或者 test suite，也就是我们写的测试用例或由测试用例组成的测试套件，那么test实际上就是TestSuite类或者TestCase类的实例对象，然后其中有一行代码：
test(result)
这时候就纳闷了，test是一个TestSuite或TestCase类的实例对象，把实例对象当成函数调用是什么意思？
我们来写一个类试试：
class Human:
def __init__(self, name):
self.name = name
def eat(self):
return '%s is eat' % self.name
one = Human('CJ')
one()
# TypeError: 'Human' object is not callable
定义一个Human类，然后实例化一个对象one，把one当作函数直接调用，即one()，结果会报错TypeError: 'Human' object is not callable，看来我们的代码存在问题。
这时候，我们引入一个东西，魔术方法__call__()
python中一切皆对象，函数也是对象，同时也是可调用对象（callable）。关于可调用对象，我们平时自定义的函数、内置函数和类都属于可调用对象，但凡是可以把一对括号
()应用到某个对象身上都可称之为可调用对象，判断对象是否为可调用对象可以用函数callable一个类实例要变成一个可调用对象，只需要实现一个特殊方法
__call__()。
修改上面的例子：
class Human:
def __init__(self, name):
self.name = name
def eat(self):
return '%s is eat' % self.name
def __call__(self, *args, **kwargs):
print('object is callable')
one = Human('CJ')
one()
# object is callable
再次调用one实例对象后，输出了__call()__方法里面打印的内容，这说明，在类里面实现了__call__()魔术方法后，可以把类的实例化对象当成函数调用，而实际调用的就是__call__()方法。
那么再回到上面的框架里面，既然可以写成test(result)，那说明test这个对象的类里面，一定实现了__call__()方法，所以我们再去看看__call__()方法里面是怎么处理的。因为test是TestSuite类的实例，所以我们看看TestSuite类是怎么实现__call__()的
# unittest\suite.py
class TestSuite(BaseTestSuite):
......
def run(self, result, debug=False):
......
return result
在unittest\suite.py中，TestSuite里面有一个run()方法，并没有实现__call__()方法，但是TestSuite是继承自BaseTestSuite，我们再看看BaseTestSuite
# unittest\suite.py
class BaseTestSuite(object):
......
def run(self, result):
for index, test in enumerate(self):
if result.shouldStop:
break
test(result)
if self._cleanup:
self._removeTestAtIndex(index)
return result
def __call__(self, *args, **kwds):
return self.run(*args, **kwds)
在BaseTestSuite中，确实有__call__()，并且也有run()方法，而__call__()实际又调用了self.run()方法。
这里需要注意，由于TestSuite类是继承自BaseTestSuite，并且两者都实现了run()方法，那么实际执行的时候，如果该类是属于TestSuite，那么最终实际执行的是TestSuite().run()，而不是BaseTestSuite().run()
那么，此时，梳理出来的步骤就是：
我们初始化一个HTMLTestRunner类的实例，调用类方法run()，传入的参数是TestSuite类的实例，
在HTMLTestRunner的run()方法中，把TestSuite类的实例当成函数调用，这是由于TestSuite类的父类BaseTestSuite实现了魔术方法__call__()，而__call__()里面是调用self.run()，所有本质上调用的则是TestSuite类的run()方法，继续来看TestSuite里面run()做了些什么东西
# unittest\suite.py
class TestSuite(BaseTestSuite):
def run(self, result, debug=False):
topLevel = False
if getattr(result, '_testRunEntered', False) is False:
result._testRunEntered = topLevel = True
for index, test in enumerate(self):
if result.shouldStop:
break
if _isnotsuite(test):
self._tearDownPreviousClass(test, result)
self._handleModuleFixture(test, result)
self._handleClassSetUp(test, result)
result._previousTestClass = test.__class__
if (getattr(test.__class__, '_classSetupFailed', False) or
getattr(result, '_moduleSetUpFailed', False)):
continue
if not debug:
test(result)
else:
test.debug()
if self._cleanup:
self._removeTestAtIndex(index)
if topLevel:
self._tearDownPreviousClass(None, result)
self._handleModuleTearDown(result)
result._testRunEntered = False
return result
for index, test in enumerate(self):
self代表的是TestSuite类实例，经过枚举及for循环得到的test是TestCase实例
然后下面又是熟悉的test(result)，那么跟上面的原理一样，TestCase类或者它的父类里面肯定实现了__call__()方法，并且__call__()里面实际调用的是TestCase().run()方法，所以这里真正执行的就是TestCase().run()，TestCase().run()里面则实现的是每个测试用例的执行过程，最终得到执行的结果。
源码也印证了确实如此：
class TestCase(object):
....
....
def run(self, result=None):
....
return result
def __call__(self, *args, **kwds):
return self.run(*args, **kwds)
至此，完整的流程应该是：
我们初始化一个HTMLTestRunner类的实例，调用类方法run()，传入的参数是TestSuite类的实例，
由于TestSuite类实现了__call__()魔术方法，所以在HTMLTestRunner的run()方法中
把TestSuite类实例当成函数调用，达到调用TestSuite类的run()方法的目的，在TestSuite的run()方法里遍历出TestCase对象，而又由于TestCase类也实现了__call__()魔术方法，把TestCase对象当成函数调用，实际执行的是TestCase的run()，最终完成测试得到结果。