Python unittest: как запустить только часть тестового файла?

По умолчанию unittest.main() использует загрузчик тестов по умолчанию для создания TestSuite из модуля, в котором выполняется main.

Вам не обязательно использовать это поведение по умолчанию.

Вы можете, например, создать три экземпляра unittest.TestSuite.

1. Быстрое подмножество.

   fast = TestSuite()
   fast.addTests(TestFastThis)
   fast.addTests(TestFastThat)
   

2. Медленное подмножество.

   slow = TestSuite()
   slow.addTests(TestSlowAnother)
   slow.addTests(TestSlowSomeMore)
   

3. Весь набор.

   alltests = unittest.TestSuite([fast, slow])
   

Обратите внимание, что я скорректировал имена TestCase, чтобы указать «Быстро» или «Медленно». Вы можете создать подкласс unittest.TestLoader для анализа имен классов и создания нескольких загрузчиков.

Затем ваша основная программа сможет анализировать аргументы командной строки с помощью optparse или argparse (доступно с версии 2.7 или 3.2), чтобы выбрать, какой пакет вы хотите запустить, быстро, медленно или все.

Или вы можете поверить в то, что sys.argv[1] - одно из трех значений, и использовать что-то столь же простое, как это

if __name__ == "__main__":
    suite = eval(sys.argv[1])  # Be careful with this line!
    unittest.TextTestRunner().run(suite)

Чтобы запустить только один конкретный тест, вы можете использовать:

python -m unittest test_module.TestClass.test_method

Дополнительную информацию можно найти здесь.

Я делаю это с помощью простого skipIf:

import os

SLOW_TESTS = int(os.getenv('SLOW_TESTS', '0'))

@unittest.skipIf(not SLOW_TESTS, "slow")
class CheckMyFeature(unittest.TestCase):
    def runTest(self):
        …

Таким образом, мне нужно только украсить уже существующий тестовый пример этой единственной строкой (нет необходимости создавать тестовые наборы или что-то подобное, только одна строка вызова os.getenv() в начале моего файла модульного теста), и по умолчанию этот тест пропускается.

Если я хочу выполнить его, несмотря на то, что он медленный, я просто вызываю свой скрипт следующим образом:

SLOW_TESTS=1 python -m unittest …

Фактически, можно передать имена тестового примера как sys.argv, и только эти случаи будут проверены.

Например, предположим, что у вас есть

class TestAccount(unittest.TestCase):
    ...

class TestCustomer(unittest.TestCase):
    ...

class TestShipping(unittest.TestCase):
    ...

account = TestAccount
customer = TestCustomer
shipping = TestShipping

Вы можете позвонить

python test.py account

иметь только тесты аккаунта, или даже

$ python test.py account customer

проверить оба случая

У вас есть два основных способа сделать это:

1. Определите свой собственный набор тестов для класса
2. Создайте фиктивные классы подключения к кластеру, которые будут возвращать фактические данные.

Я решительный сторонник второго подхода; модульный тест должен тестировать только саму единицу кода, а не сложные системы (например, базы данных или кластеры). Но я понимаю, что это не всегда возможно; иногда создание макетов просто слишком дорого, или цель теста действительно заключается в сложной системе.

Вернувшись к варианту (1), вы можете поступить следующим образом:

suite = unittest.TestSuite()
suite.addTest(MyUnitTestClass('quickRunningTest'))
suite.addTest(MyUnitTestClass('otherTest'))

а затем передать набор тестирующему исполнителю:

unittest.TextTestRunner().run(suite)

Дополнительная информация о документации Python: http://docs.python.org/library/unittest.html#testsuite-objects

Поскольку вы используете unittest.main(), вы можете просто запустить python tests.py --help, чтобы получить документацию:

Usage: tests.py [options] [test] [...]

Options:
  -h, --help       Show this message
  -v, --verbose    Verbose output
  -q, --quiet      Minimal output
  -f, --failfast   Stop on first failure
  -c, --catch      Catch control-C and display results
  -b, --buffer     Buffer stdout and stderr during test runs

Examples:
  tests.py                               - run default set of tests
  tests.py MyTestSuite                   - run suite 'MyTestSuite'
  tests.py MyTestCase.testSomething      - run MyTestCase.testSomething
  tests.py MyTestCase                    - run all 'test*' test methods
                                           in MyTestCase

То есть вы можете просто сделать

python tests.py TestClass.test_method

Я нашел другое решение, основанное на том, как работает декоратор unittest.skip. Установив __unittest_skip__ и __unittest_skip_why__.

На основе ярлыков

Я хотел применить систему маркировки, чтобы обозначить некоторые тесты как quick, slow, glacier, memoryhog, cpuhog, core и так далее.

Затем запустите all 'quick' tests или run everything except 'memoryhog' tests, вашу базовую настройку белого / черного списка.

Реализация

Я реализовал это в двух частях:

1. Сначала добавьте метки к тестам (с помощью специального декоратора класса @testlabel)
2. Пользовательский unittest.TestRunner, чтобы определить, какие тесты пропустить, и изменить содержимое списка тестов перед выполнением.

Рабочая реализация заключается в следующем: https://gist.github.com/fragmuffin/a245f59c3bdcd51/a245f59bdcd51

$ ./runtests.py --blacklist foo
test_foo (test_things.MyTest2) ... ok
test_bar (test_things.MyTest3) ... ok
test_one (test_things.MyTests1) ... skipped 'label exclusion'
test_two (test_things.MyTests1) ... skipped 'label exclusion'

----------------------------------------------------------------------
Ran 4 tests in 0.000s

OK (skipped=2)

Или вы можете использовать функцию unittest.SkipTest(). Например, добавьте метод skipOrRunTest в свой тестовый класс следующим образом:

def skipOrRunTest(self,testType):
    #testsToRun = 'ALL'
    #testsToRun = 'testType1, testType2, testType3, testType4,...etc'
    #testsToRun = 'testType1'
    #testsToRun = 'testType2'
    #testsToRun = 'testType3'
    testsToRun = 'testType4'              
    if ((testsToRun == 'ALL') or (testType in testsToRun)):
        return True 
    else:
        print "SKIPPED TEST because:\n\t testSuite '" + testType  + "' NOT IN testsToRun['" + testsToRun + "']" 
        self.skipTest("skipppy!!!")

Затем добавьте вызов этого метода skipOrRunTest в самое начало каждого из ваших модульных тестов следующим образом:

def testType4(self):
    self.skipOrRunTest('testType4')

Я создал декоратор, который позволяет помечать тесты как медленные и пропускать их с помощью переменной окружения.

from unittest import skip
import os

def slow_test(func):
    return skipIf('SKIP_SLOW_TESTS' in os.environ, 'Skipping slow test')(func)

Теперь вы можете пометить свои тесты как медленные следующим образом:

@slow_test
def test_my_funky_thing():
    perform_test()

И пропустите медленные тесты, установив переменную окружения SKIP_SLOW_TESTS:

SKIP_SLOW_TESTS=1 python -m unittest

Попробуйте использовать специальный тестер, например py.test, Nose или, возможно, даже zope.testing. Все они имеют параметры командной строки для выбора тестов.

Взгляните, например, на Nose.

Я попробовал ответ S.Lott:

if __name__ == "__main__":
    suite = eval(sys.argv[1])  # Be careful with this line!
    unittest.TextTestRunner().run(suite)

Но это дало мне следующую ошибку:

Traceback (most recent call last):
  File "functional_tests.py", line 178, in <module>
    unittest.TextTestRunner().run(suite)
  File "/usr/lib/python2.7/unittest/runner.py", line 151, in run
    test(result)
  File "/usr/lib/python2.7/unittest/case.py", line 188, in __init__
    testMethod = getattr(self, methodName)
TypeError: getattr(): attribute name must be string

Для меня сработало следующее:

if __name__ == "__main__":
    test_class = eval(sys.argv[1])
    suite = unittest.TestLoader().loadTestsFromTestCase(test_class)
    unittest.TextTestRunner().run(suite)

Цель: собрать набор тестовых файлов, чтобы их можно было запускать как единое целое, но мы все равно можем выбрать любой из них для запуска отдельно.

Проблема: метод обнаружения не позволяет легко выбрать один тестовый пример для запуска.

Дизайн: см. Ниже. Это сглаживает пространство имен, поэтому его можно выбирать по имени класса TestCase и опускать префикс tests1.test_core:

./run-tests TestCore.test_fmap

Код

  test_module_names = [
    'tests1.test_core',
    'tests2.test_other',
    'tests3.test_foo',
    ]

  loader = unittest.defaultTestLoader
  if args:
    alltests = unittest.TestSuite()
    for a in args:
      for m in test_module_names:
        try:
          alltests.addTest( loader.loadTestsFromName( m + '.' + a ) )
        except AttributeError as e:
          continue
  else:
    alltests = loader.loadTestsFromNames( test_module_names )

  runner = unittest.TextTestRunner( verbosity = opt.verbose )
  runner.run( alltests )

Это единственное, что у меня сработало.

if __name__ == '__main__':
    unittest.main(argv=sys.argv, testRunner = unittest.TextTestRunner(verbosity=2))

Когда я его вызвал, мне пришлось передать имя класса и имя теста. Немного неудобно, так как я не запомнил комбинацию имени класса и теста.

python ./tests.py class_Name.test_30311

Удаление имени класса и имени теста запускает все тесты в вашем файле. Я считаю, что с этим намного проще иметь дело, чем со встроенным методом, поскольку я на самом деле не меняю свою команду в CLI. Просто добавьте параметр.

Я нашел этот ответ, пытаясь понять, как просто запускать определенные классы тестов; Например,

class TestCase1(unittest.TestCase):
    def some_test(self):
        self.assertEqual(True, True)

class TestCase2(unittest.TestCase):
    def some_other_test(self):
        self.assertEqual(False, False)

Мне нужен был быстрый способ закомментировать TestCase1 или TestCase2, который не требовал от меня выбора более 100 строк кода, и в конце концов я остановился на этом:

if __name__ == "__main__":
    tests = []
    tests.append("TestCase1")
    # tests.append("TestCase2")
    unittest.main(defaultTest=tests)

Он просто использует аргумент defaultTest unittest.main(), чтобы указать, какие тестовые классы запускать.

Я нашел другой способ выбрать методы test_ *, которые я хочу запускать, только добавив к ним атрибут. В основном вы используете метакласс для украшения вызываемых объектов внутри класса TestCase, которые имеют атрибут StepDebug с декоратором unittest.skip. Более подробная информация находится в:

Пропуск всего блока проверяет, кроме одного, на Python с помощью декораторов и метаклассов

Я не знаю, лучше ли это решение, чем приведенные выше, я просто предлагаю его как вариант.

Иногда я запускаю каждую из своих тестовых функций вручную. Скажем, мой тестовый класс выглядит так ...

class TestStuff(unittest.TestCase):
    def test1():
    def test2():

Тогда я запускаю это ...

t = TestStuff()
t.test1()
t.test2()

(Я использую Spyder IDE для анализа данных, это может быть не идеально для IDE с инструментами тестирования Slicker)