410

我有一个包含我的 Python 单元测试的目录。每个单元测试模块的格式为test_*.py。我正在尝试创建一个名为all_test.py的文件,您猜对了,它将运行上述测试表单中的所有文件并返回结果。到目前为止,我已经尝试了两种方法;两者都失败了。我将展示这两种方法,我希望有人知道如何正确地做到这一点。

对于我的第一次勇敢尝试,我想“如果我只是在文件中导入所有测试模块,然后调用这个小unittest.main()玩意儿,它会起作用,对吗?” 好吧,事实证明我错了。

import glob
import unittest

testSuite = unittest.TestSuite()
test_file_strings = glob.glob('test_*.py')
module_strings = [str[0:len(str)-3] for str in test_file_strings]

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

这不起作用,我得到的结果是:

$ python all_test.py 

----------------------------------------------------------------------
Ran 0 tests in 0.000s

OK

不过,对于我的第二次尝试,好吧,也许我会尝试以更“手动”的方式进行整个测试。所以我试图在下面这样做:

import glob
import unittest

testSuite = unittest.TestSuite()
test_file_strings = glob.glob('test_*.py')
module_strings = [str[0:len(str)-3] for str in test_file_strings]
[__import__(str) for str in module_strings]
suites = [unittest.TestLoader().loadTestsFromName(str) for str in module_strings]
[testSuite.addTest(suite) for suite in suites]
print testSuite 

result = unittest.TestResult()
testSuite.run(result)
print result

#Ok, at this point I have a result
#How do I display it as the normal unit test command line output?
if __name__ == "__main__":
    unittest.main()

这也不起作用,但它似乎如此接近!

$ python all_test.py 
<unittest.TestSuite tests=[<unittest.TestSuite tests=[<unittest.TestSuite tests=[<test_main.TestMain testMethod=test_respondes_to_get>]>]>]>
<unittest.TestResult run=1 errors=0 failures=0>

----------------------------------------------------------------------
Ran 0 tests in 0.000s

OK

我似乎有某种套件,我可以执行结果。我有点担心它说我只有run=1,似乎应该是这样run=2,但这是进步。但是如何将结果传递并显示给 main?或者我如何基本上让它工作,这样我就可以运行这个文件,然后运行这个目录中的所有单元测试?

4

17 回答 17

608

使用 Python 2.7 及更高版本,您不必编写新代码或使用第三方工具来执行此操作;通过命令行执行递归测试是内置的。将一个__init__.py放在您的测试目录中,然后:

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

您可以在python 2.7python 3.x unittest 文档中阅读更多内容。


2021 年更新:

许多现代 python 项目使用更高级的工具,如pytest。例如,下拉matplotlibscikit-learn,你会看到他们都在使用它。

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

  • 更高级的方法来总结通过、跳过、警告、错误的内容
  • 简单的方法来看看他们是如何失败的
  • 运行时完成百分比
  • 总运行时间
  • 生成测试报告的方法
  • 等等等等
于 2013-03-26T06:09:40.927 回答
194

在 python 3 中,如果您使用的是unittest.TestCase

  • 您的目录中必须有一个空(或其他)__init__.py文件test必须命名test/
  • 您里面的测试文件test/与模式匹配test_*.py。它们可以位于 下的子目录中test/,并且这些子目录可以命名为任何名称。

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

python -m unittest

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

于 2017-05-02T08:27:43.123 回答
111

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

更新:

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

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)
于 2009-11-13T23:12:06.337 回答
79

现在可以直接从 unittest: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)
于 2016-11-05T11:25:46.140 回答
33

好吧,通过研究上面的代码(特别是使用TextTestRunnerand 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)

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

于 2009-11-14T19:18:22.243 回答
27

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

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并且TestPatternsTestCase.

于 2011-07-31T01:58:04.753 回答
15

我已经使用了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
于 2012-02-16T13:04:49.207 回答
9

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

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

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

于 2013-11-05T02:24:33.807 回答
8

如果是打包的库或应用程序,您不想这样做。setuptools 会为你做的

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

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

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

并运行python setup.py test

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

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
于 2015-08-08T13:51:07.527 回答
5

这是一个老问题,但现在(2019 年)对我有用的是:

python -m unittest *_test.py

我所有的测试文件都与源文件在同一个文件夹中,它们以_test.

于 2019-09-30T09:17:38.083 回答
4

我使用 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根据您的项目设置更改参数。

于 2014-07-22T14:53:27.970 回答
3

根据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)。

于 2014-07-03T19:37:12.927 回答
3

我刚刚在我的基本测试目录中创建了一个 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()
于 2020-10-27T21:34:52.860 回答
1

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

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

于 2014-09-15T08:00:01.883 回答
1

此 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文件来负担你的包/内存开销。

于 2018-08-12T22:43:43.587 回答
0

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

运行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))
于 2021-10-21T07:38:04.737 回答
-3

这是我通过创建一个包装器来从命令行运行测试的方法:

#!/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
于 2015-05-24T11:13:48.480 回答