如何在目录中运行所有 Python 单元测试？

使用 Python 2.7 及更高版本，您不必编写新代码或使用第三方工具来执行此操作；通过命令行执行递归测试是内置的。将 __init__.py 放入您的测试目录并：

python -m unittest discover <test_directory>
# or
python -m unittest discover -s <directory> -p '*_test.py'

您可以在 python 2.7 或 python 3.x 单元测试文档中阅读更多内容。

2021 年更新：

许多现代 Python 项目使用更高级的工具，例如 pytest。例如，下拉 matplotlib 或 scikit-learn，您会看到他们都在使用它。

了解这些较新的工具很重要，因为当您有超过 7000 个测试时，您需要：

更高级的方法来总结通过、跳过、警告、错误的内容

简单的方法来看看他们是如何失败的

运行时完成百分比

总运行时间

生成测试报告的方法

等等等等

---

在 python 3 中，如果您使用 unittest.TestCase：

您的测试目录中必须有一个空（或其他）__init__.py 文件（必须命名为 test/）

您在 test/ 中的测试文件与模式 test_*.py 匹配。它们可以在 test/ 下的子目录中，这些子目录可以命名为任何东西。

然后，您可以使用以下命令运行所有测试：

python -m unittest

完毕！少于 100 行的解决方案。希望另一个 python 初学者通过找到这个来节省时间。

---

您可以使用可以为您执行此操作的测试运行程序。例如，nose 非常好。运行时，它将在当前树中找到测试并运行它们。

更新：

这是我的鼻子前几天的一些代码。您可能不想要明确的模块名称列表，但也许其余的对您有用。

testmodules = [
    'cogapp.test_makefiles',
    'cogapp.test_whiteutils',
    'cogapp.test_cogapp',
    ]

suite = unittest.TestSuite()

for t in testmodules:
    try:
        # If the module defines a suite() function, call it to get the suite.
        mod = __import__(t, globals(), locals(), ['suite'])
        suitefn = getattr(mod, 'suite')
        suite.addTest(suitefn())
    except (ImportError, AttributeError):
        # else, just load all the test cases from the module.
        suite.addTest(unittest.defaultTestLoader.loadTestsFromName(t))

unittest.TextTestRunner().run(suite)

---

现在可以直接从单元测试：unittest.TestLoader.discover。

import unittest
loader = unittest.TestLoader()
start_dir = 'path/to/your/test/files'
suite = loader.discover(start_dir)

runner = unittest.TextTestRunner()
runner.run(suite)

---

好吧，通过稍微研究一下上面的代码（特别是使用 TextTestRunner 和 defaultTestLoader），我能够非常接近。最终，我通过将所有测试套件传递给单个套件构造函数来修复我的代码，而不是“手动”添加它们，这解决了我的其他问题。所以这是我的解决方案。

import glob
import unittest

test_files = glob.glob('test_*.py')
module_strings = [test_file[0:len(test_file)-3] for test_file in test_files]
suites = [unittest.defaultTestLoader.loadTestsFromName(test_file) for test_file in module_strings]
test_suite = unittest.TestSuite(suites)
test_runner = unittest.TextTestRunner().run(test_suite)

是的，使用鼻子可能比这样做更容易，但这不是重点。

---

如果您想运行来自各种测试用例类的所有测试并且您很乐意明确指定它们，那么您可以这样做：

from unittest import TestLoader, TextTestRunner, TestSuite
from uclid.test.test_symbols import TestSymbols
from uclid.test.test_patterns import TestPatterns

if __name__ == "__main__":

    loader = TestLoader()
    tests = [
        loader.loadTestsFromTestCase(test)
        for test in (TestSymbols, TestPatterns)
    ]
    suite = TestSuite(tests)

    runner = TextTestRunner(verbosity=2)
    runner.run(suite)

其中 uclid 是我的项目，TestSymbols 和 TestPatterns 是 TestCase 的子类。

---

我使用 discover 方法和 load_tests 的重载以（我认为是最少的）代码行来实现此结果：

def load_tests(loader, tests, pattern):
''' Discover and load all unit tests in all files named ``*_test.py`` in ``./src/``
'''
    suite = TestSuite()
    for all_test_suite in unittest.defaultTestLoader.discover('src', pattern='*_tests.py'):
        for test_suite in all_test_suite:
            suite.addTests(test_suite)
    return suite

if __name__ == '__main__':
    unittest.main()

五分之一的执行就像

Ran 27 tests in 0.187s
OK

---

我尝试了各种方法，但似乎都有缺陷，或者我必须编写一些代码，这很烦人。但是在linux下有一个方便的方法，就是通过一定的模式找到每一个测试，然后一个一个地调用它们。

find . -name 'Test*py' -exec python '{}' \;

最重要的是，它绝对有效。

---

对于 打包 库或应用程序，您不想这样做。 setuptools will do it for you。

要使用此命令，您的项目测试必须通过函数、TestCase 类或方法或包含 TestCase 类的模块或包包装在 unittest 测试套件中。如果命名套件是一个模块，并且该模块具有附加的_tests() 函数，则会调用它并将结果（必须是 unittest.TestSuite）添加到要运行的测试中。如果命名套件是一个包，则任何子模块和子包都会递归地添加到整个测试套件中。

只需告诉它您的根测试包在哪里，例如：

setup(
    # ...
    test_suite = 'somepkg.test'
)

并运行 python setup.py test。

在 Python 3 中基于文件的发现可能会出现问题，除非您避免在测试套件中进行相对导入，因为 discover 使用文件导入。尽管它支持可选的 top_level_dir，但我遇到了一些无限递归错误。因此，对于未打包的代码，一个简单的解决方案是将以下内容放入测试包的 __init__.py 中（请参阅 load_tests Protocol）。

import unittest

from . import foo, bar


def load_tests(loader, tests, pattern):
    suite = unittest.TestSuite()
    suite.addTests(loader.loadTestsFromModule(foo))
    suite.addTests(loader.loadTestsFromModule(bar))

    return suite

---

这是一个老问题，但现在（2019 年）对我有用的是：

python -m unittest *_test.py

我的所有测试文件都与源文件位于同一文件夹中，并且以 _test 结尾。

---

我使用 PyDev/LiClipse 并没有真正弄清楚如何从 GUI 一次运行所有测试。 （编辑：您右键单击根测试文件夹并选择 Run as -> Python unit-test

这是我目前的解决方法：

import unittest

def load_tests(loader, tests, pattern):
    return loader.discover('.')

if __name__ == '__main__':
    unittest.main()

我将此代码放在我的测试目录中名为 all 的模块中。如果我将此模块作为 LiClipse 的单元测试运行，那么所有测试都会运行。如果我要求只重复特定或失败的测试，那么只会运行那些测试。它也不会干扰我的命令行测试运行器（nosetests）——它被忽略了。

您可能需要根据您的项目设置将参数更改为 discover。

---

根据 Stephen Cagle 的回答，我添加了对嵌套测试模块的支持。

import fnmatch
import os
import unittest

def all_test_modules(root_dir, pattern):
    test_file_names = all_files_in(root_dir, pattern)
    return [path_to_module(str) for str in test_file_names]

def all_files_in(root_dir, pattern):
    matches = []

    for root, dirnames, filenames in os.walk(root_dir):
        for filename in fnmatch.filter(filenames, pattern):
            matches.append(os.path.join(root, filename))

    return matches

def path_to_module(py_file):
    return strip_leading_dots( \
        replace_slash_by_dot(  \
            strip_extension(py_file)))

def strip_extension(py_file):
    return py_file[0:len(py_file) - len('.py')]

def replace_slash_by_dot(str):
    return str.replace('\\', '.').replace('/', '.')

def strip_leading_dots(str):
    while str.startswith('.'):
       str = str[1:len(str)]
    return str

module_names = all_test_modules('.', '*Tests.py')
suites = [unittest.defaultTestLoader.loadTestsFromName(mname) for mname 
    in module_names]

testSuite = unittest.TestSuite(suites)
runner = unittest.TextTestRunner(verbosity=1)
runner.run(testSuite)

该代码在 . 的所有子目录中搜索 *Tests.py 文件，然后加载这些文件。它期望每个 *Tests.py 包含一个类 *Tests(unittest.TestCase)，该类依次加载并一个接一个地执行。

这适用于目录/模块的任意深度嵌套，但中间的每个目录至少需要包含一个空的 __init__.py 文件。这允许测试通过用点替换斜杠（或反斜杠）来加载嵌套模块（参见 replace_slash_by_dot）。

---

我刚刚在我的基本测试目录中创建了一个 discover.py 文件，并为我的子目录中的任何内容添加了导入语句。然后 discover 能够通过在 discover.py 上运行它来找到我在这些目录中的所有测试

python -m unittest discover ./test -p '*.py'

# /test/discover.py
import unittest

from test.package1.mod1 import XYZTest
from test.package1.package2.mod2 import ABCTest
...

if __name__ == "__main__"
    unittest.main()

---

因为测试发现似乎是一个完整的主题，所以有一些专门的框架来测试发现：

鼻子

Py.Test

更多阅读：https://wiki.python.org/moin/PythonTestingToolsTaxonomy

---

此 BASH 脚本将从文件系统中的任何位置执行 python unittest 测试目录，无论您在哪个工作目录中：它的工作目录始终是该 test 目录所在的位置。

所有测试，独立 $PWD

unittest Python 模块对您的当前目录很敏感，除非您告诉它在哪里（使用 discover -s 选项）。

这在停留在 ./src 或 ./example 工作目录中并且您需要快速的整体单元测试时很有用：

#!/bin/bash
this_program="$0"
dirname="`dirname $this_program`"
readlink="`readlink -e $dirname`"

python -m unittest discover -s "$readlink"/test -v

选择测试，独立 $PWD

我将此实用程序文件命名为：runone.py 并像这样使用它：

runone.py <test-python-filename-minus-dot-py-fileextension>

#!/bin/bash
this_program="$0"
dirname="`dirname $this_program`"
readlink="`readlink -e $dirname`"

(cd "$dirname"/test; python -m unittest $1)

在生产过程中，无需 test/__init__.py 文件来负担您的包/内存开销。

---

遇到了同样的问题。

解决方案是为每个文件夹添加一个空 __init__.py 并使用 python -m unittest discover -s

项目结构

tests/
  __init__.py
  domain/
    value_object/
      __init__.py
      test_name.py
    __init__.py
  presentation/
    __init__.py
    test_app.py

并运行命令

python -m unittest discover -s tests/domain

得到预期的结果

.
----------------------------------------------------------------------
Ran 1 test in 0.007s

---

我没有包裹，正如本页所述，这是在发布发现时产生的问题。所以，我使用了以下解决方案。所有测试结果都将放在给定的输出文件夹中。

运行AllUT.py：

"""
The given script is executing all the Unit Test of the project stored at the
path %relativePath2Src% currently fixed coded for the given project. 

Prerequired:
    - Anaconda should be install
    - For the current user, an enviornment called "mtToolsEnv" should exists
    - xmlrunner Library should be installed
"""

import sys
import os
import xmlrunner
from Repository import repository 

relativePath2Src="./../.."
pythonPath=r'"C:\Users\%USERNAME%\.conda\envs\YourConfig\python.exe"' 
outputTestReportFolder=os.path.dirname(os.path.abspath(__file__))+r'\test-reports' #subfolder in current file path

class UTTesting():
    """
    Class tto run all the UT of the project
    """
    def __init__(self):
        """
        Initiate instance

        Returns
        -------
        None.

        """
        self.projectRepository = repository() 
        self.UTfile = [] #List all file
    
    def retrieveAllUT(self):
        """
        Generate the list of UT file in the project

        Returns
        -------
        None.

        """
        print(os.path.realpath(relativePath2Src))
        self.projectRepository.retriveAllFilePaths(relativePath2Src)
        #self.projectRepository.printAllFile() #debug
        for file2scan in self.projectRepository.devfile:
            if file2scan.endswith("_UT.py"):
                self.UTfile.append(file2scan)
                print(self.projectRepository.devfilepath[file2scan]+'/'+file2scan)
                
    
    def runUT(self,UTtoRun):
        """
        Run a single UT

        Parameters
        ----------
        UTtoRun : String
            File Name of the UT

        Returns
        -------
        None.

        """
        print(UTtoRun)
        if UTtoRun in self.projectRepository.devfilepath:
            UTtoRunFolderPath=os.path.realpath(os.path.join(self.projectRepository.devfilepath[UTtoRun]))
            UTtoRunPath = os.path.join(UTtoRunFolderPath, UTtoRun)
        print(UTtoRunPath)
        
        #set the correct execution context & run the test
        os.system(" cd " + UTtoRunFolderPath + \
                  " & " + pythonPath + " " + UTtoRunPath + " " + outputTestReportFolder )
        
        
    def runAllUT(self):
        """
        Run all the UT contained in self
        The function "retrieveAllUT" sjould ahve been performed before

        Returns
        -------
        None.

        """
        for UTfile in self.UTfile:
            self.runUT(UTfile)
                
    
                
if __name__ == "__main__":
    undertest=UTTesting()
    undertest.retrieveAllUT()
    undertest.runAllUT()

在我的特定项目中，我有一个在其他脚本中使用的类。对于您的用例来说，这可能有点过头了。

存储库.py

import os

class repository():
    """
    Class that decribed folder and file in a repository 
    """
    def __init__(self):
        """
        Initiate instance

        Returns
        -------
        None.

        """
        self.devfile = [] #List all file
        self.devfilepath = {} #List all file paths

    def retriveAllFilePaths(self,pathrepo):
        """
        Retrive all files and their path in the class

        Parameters
        ----------
        pathrepo : Path used for the parsin

        Returns
        -------
        None.

        """
        for path, subdirs, files in os.walk(pathrepo):
            for file_name in files:
                self.devfile.append(file_name)
                self.devfilepath[file_name] = path
                
    def printAllFile(self):
        """
        Display all file with paths

        Parameters
        ----------
        def printAllFile : TYPE
            DESCRIPTION.

        Returns
        -------
        None.

        """
        for file_loop in self.devfile:
            print(self.devfilepath[file_loop]+'/'+file_loop)

在您的测试文件中，您需要有一个这样的 main：

if __name__ == "__main__":
    import xmlrunner
    import sys
    
    if len(sys.argv) > 1:
        outputFolder = sys.argv.pop() #avoid conflic with unittest.main
    else:
        outputFolder = r'test-reports'
    print("Report will be created and store there: " + outputFolder)
    
    unittest.main(testRunner=xmlrunner.XMLTestRunner(output=outputFolder))

---

这是我通过创建 a wrapper 从命令行运行测试的方法：

#!/usr/bin/env python3
import os, sys, unittest, argparse, inspect, logging

if __name__ == '__main__':
    # Parse arguments.
    parser = argparse.ArgumentParser(add_help=False)
    parser.add_argument("-?", "--help",     action="help",                        help="show this help message and exit" )
    parser.add_argument("-v", "--verbose",  action="store_true", dest="verbose",  help="increase output verbosity" )
    parser.add_argument("-d", "--debug",    action="store_true", dest="debug",    help="show debug messages" )
    parser.add_argument("-h", "--host",     action="store",      dest="host",     help="Destination host" )
    parser.add_argument("-b", "--browser",  action="store",      dest="browser",  help="Browser driver.", choices=["Firefox", "Chrome", "IE", "Opera", "PhantomJS"] )
    parser.add_argument("-r", "--reports-dir", action="store",   dest="dir",      help="Directory to save screenshots.", default="reports")
    parser.add_argument('files', nargs='*')
    args = parser.parse_args()

    # Load files from the arguments.
    for filename in args.files:
        exec(open(filename).read())

    # See: http://codereview.stackexchange.com/q/88655/15346
    def make_suite(tc_class):
        testloader = unittest.TestLoader()
        testnames = testloader.getTestCaseNames(tc_class)
        suite = unittest.TestSuite()
        for name in testnames:
            suite.addTest(tc_class(name, cargs=args))
        return suite

    # Add all tests.
    alltests = unittest.TestSuite()
    for name, obj in inspect.getmembers(sys.modules[__name__]):
        if inspect.isclass(obj) and name.startswith("FooTest"):
            alltests.addTest(make_suite(obj))

    # Set-up logger
    verbose = bool(os.environ.get('VERBOSE', args.verbose))
    debug   = bool(os.environ.get('DEBUG', args.debug))
    if verbose or debug:
        logging.basicConfig( stream=sys.stdout )
        root = logging.getLogger()
        root.setLevel(logging.INFO if verbose else logging.DEBUG)
        ch = logging.StreamHandler(sys.stdout)
        ch.setLevel(logging.INFO if verbose else logging.DEBUG)
        ch.setFormatter(logging.Formatter('%(asctime)s %(levelname)s: %(name)s: %(message)s'))
        root.addHandler(ch)
    else:
        logging.basicConfig(stream=sys.stderr)

    # Run tests.
    result = unittest.TextTestRunner(verbosity=2).run(alltests)
    sys.exit(not result.wasSuccessful())

为简单起见，请原谅我的非PEP8编码标准。

然后，您可以为所有测试的通用组件创建 BaseTest 类，因此您的每个测试看起来就像：

from BaseTest import BaseTest
class FooTestPagesBasic(BaseTest):
    def test_foo(self):
        driver = self.driver
        driver.get(self.base_url + "/")

要运行，您只需将测试指定为命令行参数的一部分，例如：

./run_tests.py -h http://example.com/ tests/**/*.py

---