blocks|key|598820|text|所以我查看了一下我的Python27/Lib目录...|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|598821|unittest.main实际上是一个类unittest.TestProgram的别名。因此，您构建了一个实例，它的__init__将运行，该实例将执行一系列健全性检查和配置，包括动态导入从中调用它的模块(它使用__import__函数，默认情况下使用__main__作为要导入的模块的名称)。因此，现在它有一个self.module属性，其中包含一个表示源代码的模块对象。|598822|最后，它转到下面的代码：|598823|self.test+=+self.testLoader.loadTestsFromModule(self.module)|code-block|syntax|javascript|598824|其中self.testLoader是unittest.TestLoader的一个实例。该方法除了其他内容外，还包含：|598825|++++for+name+in+dir(module):
++++++++obj+=+getattr(module,+name)
++++++++if+isinstance(obj,+type)+and+issubclass(obj,+case.TestCase):
++++++++++++tests.append(self.loadTestsFromTestCase(obj))|598826|因此，它使用模块对象的dir来获取您定义的所有全局变量(包括类)的名称，将其过滤为仅从unittest.TestCase派生的类(在本地，case.TestCase是该类的别名)，然后在这些类中查找测试方法以添加到tests列表中。该搜索的行为类似：|598827|++++def+isTestMethod(attrname,+testCaseClass=testCaseClass,
+++++++++++++++++++++prefix=self.testMethodPrefix):
++++++++return+attrname.startswith(prefix)+and+\
++++++++++++hasattr(getattr(testCaseClass,+attrname),+'__call__')
++++testFnNames+=+filter(isTestMethod,+dir(testCaseClass))|598828|因此，它使用类的dir来获取要尝试的名称列表，查找具有这些名称的属性，并选择以self.testMethodPrefix开头的属性(缺省情况下为'test')和可调用的属性(具有__call__属性)。(我真的很惊讶他们在这里没有使用内置的callable函数。我猜这是为了避免拾取嵌套类。)|598829|entityMap^0|A|C|0|0|D|K|K|1M|8|2Y|A|3I|8|4C|B|0|0|0|2|F|I|J|0|0|B|3|17|H|1X|D|2Z|5|0|0|8|3|13|L|20|6|2H|8|3C|8|0^^$0|@$1|2|3|4|5|6|7|10|8|@$9|11|A|12|B|C]]|D|@]|E|$]]|$1|F|3|G|5|6|7|13|8|@$9|14|A|15|B|C]|$9|16|A|17|B|C]|$9|18|A|19|B|C]|$9|1A|A|1B|B|C]|$9|1C|A|1D|B|C]|$9|1E|A|1F|B|C]]|D|@]|E|$]]|$1|H|3|I|5|6|7|1G|8|@]|D|@]|E|$]]|$1|J|3|K|5|L|7|1H|8|@]|D|@]|E|$M|N]]|$1|O|3|P|5|6|7|1I|8|@$9|1J|A|1K|B|C]|$9|1L|A|1M|B|C]]|D|@]|E|$]]|$1|Q|3|R|5|L|7|1N|8|@]|D|@]|E|$M|N]]|$1|S|3|T|5|6|7|1O|8|@$9|1P|A|1Q|B|C]|$9|1R|A|1S|B|C]|$9|1T|A|1U|B|C]|$9|1V|A|1W|B|C]]|D|@]|E|$]]|$1|U|3|V|5|L|7|1X|8|@]|D|@]|E|$M|N]]|$1|W|3|X|5|6|7|1Y|8|@$9|1Z|A|20|B|C]|$9|21|A|22|B|C]|$9|23|A|24|B|C]|$9|25|A|26|B|C]|$9|27|A|28|B|C]]|D|@]|E|$]]|$1|Y|3|-4|5|6|7|29|8|@]|D|@]|E|$]]]|Z|$]]

So I looked around in my <code>Python27/Lib</code> directory...

<code>unittest.main</code> is actually an alias for a class, <code>unittest.TestProgram</code>. So what happens is you construct an instance of this, and its <code>__init__</code> runs, which does a bunch of sanity checks and configuration, including a dynamic import of the module that you called it from (it uses the <code>__import__</code> function, with <code>__main__</code> as the name of the module to import, by default). So now it has a <code>self.module</code> attribute that contains a module object that represents your source.

Eventually, it gets to this code:

<pre><code>self.test = self.testLoader.loadTestsFromModule(self.module)
</code></pre>

where <code>self.testLoader</code> is an instance of <code>unittest.TestLoader</code>. That method contains, among other stuff:

<pre><code> for name in dir(module):
 obj = getattr(module, name)
 if isinstance(obj, type) and issubclass(obj, case.TestCase):
 tests.append(self.loadTestsFromTestCase(obj))
</code></pre>

So it uses the <code>dir</code> of your module object to get the names of all the global variables you defined (including classes), filters that to just the classes that derive from <code>unittest.TestCase</code> (locally, <code>case.TestCase</code> is an alias for that), and then looks for test methods inside those classes to add to the <code>tests</code> list. That search behaves similarly:

<pre><code> def isTestMethod(attrname, testCaseClass=testCaseClass,
 prefix=self.testMethodPrefix):
 return attrname.startswith(prefix) and \
 hasattr(getattr(testCaseClass, attrname), '__call__')
 testFnNames = filter(isTestMethod, dir(testCaseClass))
</code></pre>

so it uses the <code>dir</code> of the class to get a list of names to try, looks for attributes with those names, and selects those that start with the <code>self.testMethodPrefix</code> (<code>'test'</code> by default) and that are callable (have, in turn, a <code>__call__</code> attribute). (I'm actually surprised they don't use the built-in <code>callable</code> function here. I guess this is to avoid picking up nested classes.)

blocks|key|598873|text|我写了一些代码，试图实现与下面的unittest.main()类似的行为。总之，我遍历模块，对于不是以“unittest”开头的模块，我检查它的成员。然后，如果这些成员是一个类，并且是unittest.TestCase的子类，我将解析该类的成员。然后，如果这些类的成员是以“test”开头的函数或方法，我会将其添加到测试列表中。类对象的__dict__用于内省方法/函数，因为使用inspect.getmembers可能会显示太多内容。最后，将测试列表转换为元组并包装为套件。然后在详细级别2使用运行器运行套件。当然，请注意，如果您不想要这个限制，可以删除函数/方法名称开头的检查'test‘的正则表达式，以便将bar_test()包含在测试列表中。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|598874|#!/usr/bin/env+python

import+unittest
import+inspect
import+sys
import+re

class+Foo(unittest.TestCase):
+++@staticmethod
+++def+test_baz():
++++++pass

+++@classmethod
+++def+test_mu(cls):
++++++pass

+++def+test_foo(self):
++++++self.assertEqual('foo',+'foo')

+++def+bar_test(self):
++++++self.assertEqual('bar',+'bar')

class+Bar:
+++pass

if+__name__+==+'__main__':
+++runner+=+unittest.TextTestRunner(verbosity=2)
+++tests+=+[]
+++is_member_valid_test_class+=+lambda+member:+inspect.isclass(member)+and+\
++++++issubclass(member,+unittest.TestCase)

+++for+module_name,+module_obj+in+sys.modules.items():
++++++if+not+re.match(r'unittest',+module_name):
+++++++++for+cls_name,+cls+in+inspect.getmembers(
++++++++++++module_obj,+is_member_valid_test_class):
++++++++++++for+methname,+methobj+in+cls.__dict__.items():
+++++++++++++++if+inspect.isroutine(methobj)+and+re.match(r'test',+methname):
++++++++++++++++++tests.append(cls(methname))

+++suite+=+unittest.TestSuite(tests=tuple(tests))
+++runner.run(suite)|code-block|syntax|javascript|598875|结果输出为：|598876|test_foo+(__main__.Foo)+...+ok
test_baz+(__main__.Foo)+...+ok
test_mu+(__main__.Foo)+...+ok

----------------------------------------------------------------------
Ran+3+tests+in+0.001s

OK|598877|entityMap^0|4O|8|0|0|0|0^^$0|@$1|2|3|4|5|6|7|Q|8|@$9|R|A|S|B|C]]|D|@]|E|$]]|$1|F|3|G|5|H|7|T|8|@]|D|@]|E|$I|J]]|$1|K|3|L|5|6|7|U|8|@]|D|@]|E|$]]|$1|M|3|N|5|H|7|V|8|@]|D|@]|E|$I|J]]|$1|O|3|-4|5|6|7|W|8|@]|D|@]|E|$]]]|P|$]]

I wrote some code that attempts to do behave similarly to unittest.main() below. In summary, I iterate through the modules, and for the modules that don't start with the name 'unittest', I inspect its members. Then if those members is a class and is a subclass of unittest.TestCase, I parse through that class' members. Then if those class' members is a function or method that starts with 'test', I add it to the list of tests. The class object's <code>__dict__</code> is used to introspect the methods/functions since using inspect.getmembers may show too much. Finally that list of tests is converted to a tuple and wrapped up as a suite. Then the suite is ran using the runner at verbosity level 2. Note that, of course, removing the regex that checks for 'test' at the beginning of a function/method name can be removed to include bar_test() to the list of tests if you don't want that restriction.

<pre><code>#!/usr/bin/env python

import unittest
import inspect
import sys
import re

class Foo(unittest.TestCase):
 @staticmethod
 def test_baz():
 pass

 @classmethod
 def test_mu(cls):
 pass

 def test_foo(self):
 self.assertEqual('foo', 'foo')

 def bar_test(self):
 self.assertEqual('bar', 'bar')

class Bar:
 pass

if __name__ == '__main__':
 runner = unittest.TextTestRunner(verbosity=2)
 tests = []
 is_member_valid_test_class = lambda member: inspect.isclass(member) and \
 issubclass(member, unittest.TestCase)

 for module_name, module_obj in sys.modules.items():
 if not re.match(r'unittest', module_name):
 for cls_name, cls in inspect.getmembers(
 module_obj, is_member_valid_test_class):
 for methname, methobj in cls.__dict__.items():
 if inspect.isroutine(methobj) and re.match(r'test', methname):
 tests.append(cls(methname))

 suite = unittest.TestSuite(tests=tuple(tests))
 runner.run(suite)
</code></pre>

The resulting output is:

<pre><code>test_foo (__main__.Foo) ... ok
test_baz (__main__.Foo) ... ok
test_mu (__main__.Foo) ... ok

----------------------------------------------------------------------
Ran 3 tests in 0.001s

OK
</code></pre>

I was wondering when we run <code>unittest.main()</code>, how does Python know what subclasses <code>unittest.Testcase</code> has?

For example, if I add a class <code>FromRomanBadInput(unittest.TestCase)</code>, how does <code>unittest</code> know to run this?

How does Python's unittest module detect test cases?

Python

我想知道当我们运行unittest.main()时，Python是如何知道unittest.Testcase有哪些子类的？例如，如果我添加了一个类FromRomanBadInput(unittest.TestCase)，unittest如何知道要运行它？

问Python的unittest模块如何检测测试用例？
EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python的unittest模块如何检测测试用例？EN

社区

活动

资源

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问Python的unittest模块如何检测测试用例？
EN