Python unittest: программировать множественные тесты?

Возможный дубликат:
Как создать динамические (параметризованные) модульные тесты в python?

У меня есть функция для проверки, under_test и набор ожидаемых пар ввода/вывода:

[
(2, 332),
(234, 99213),
(9, 3),
# ...
]

Я хотел бы, чтобы каждая из этих пар ввода/вывода тестировалась в своем собственном методе test_*. Возможно ли это?

Это то, что я хочу, но заставляя каждую пару вход/выход в один тест:

class TestPreReqs(unittest.TestCase):

    def setUp(self):
        self.expected_pairs = [(23, 55), (4, 32)]

    def test_expected(self):
        for exp in self.expected_pairs:
            self.assertEqual(under_test(exp[0]), exp[1])

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

(Кроме того, действительно ли я хочу поставить это определение self.expected_pairs в setUp?)

ОБНОВЛЕНИЕ: Попытка doublep:

class TestPreReqs(unittest.TestCase):

    def setUp(self):
        expected_pairs = [
                          (2, 3),
                          (42, 11),
                          (3, None),
                          (31, 99),
                         ]

        for k, pair in expected_pairs:
            setattr(TestPreReqs, 'test_expected_%d' % k, create_test(pair))

    def create_test (pair):
        def do_test_expected(self):
            self.assertEqual(get_pre_reqs(pair[0]), pair[1])
        return do_test_expected


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

Это не работает. Выполняются 0 тестов. Я неправильно применил пример?

ОТВЕТЫ

Ответ 1

Не тестировалось:

class TestPreReqs(unittest.TestCase):
    ...

def create_test (pair):
    def do_test_expected(self):
        self.assertEqual(under_test(pair[0]), pair[1])
    return do_test_expected

for k, pair in enumerate ([(23, 55), (4, 32)]):
    test_method = create_test (pair)
    test_method.__name__ = 'test_expected_%d' % k
    setattr (TestPreReqs, test_method.__name__, test_method)

Если вы часто используете это, вы можете превзойти это, используя функции утилиты и/или декораторы, я думаю. Обратите внимание, что пары не являются атрибутом объекта TestPreReqs в этом примере (и поэтому setUp отсутствует). Скорее, они "жестко связаны" в некотором смысле с классом TestPreReqs.

Ответ 2

Мне нужно было сделать что-то подобное. Я создал простые подклассы TestCase, которые взяли значение в их __init__, например:

class KnownGood(unittest.TestCase):
    def __init__(self, input, output):
        super(KnownGood, self).__init__()
        self.input = input
        self.output = output
    def runTest(self):
        self.assertEqual(function_to_test(self.input), self.output)

Затем я сделал тестовый набор с этими значениями:

def suite():
    suite = unittest.TestSuite()
    suite.addTests(KnownGood(input, output) for input, output in known_values)
    return suite

Затем вы можете запустить его из основного метода:

if __name__ == '__main__':
    unittest.TextTestRunner().run(suite())

Преимущества этого:

  • Когда вы добавляете больше значений, количество зарегистрированных тестов увеличивается, и вы чувствуете, что делаете больше.
  • Каждый отдельный тестовый пример может завершиться неудачно.
  • Это концептуально просто, так как каждое значение ввода/вывода преобразуется в одну TestCase

Ответ 3

Как и в случае с Python, существует сложный способ обеспечения простого решения.

В этом случае мы можем использовать метапрограммирование, декораторы и различные отличные трюки Python для достижения хорошего результата. Вот как будет выглядеть окончательный тест:

import unittest

# some magic code will be added here later

class DummyTest(unittest.TestCase):
  @for_examples(1, 2)
  @for_examples(3, 4)
  def test_is_smaller_than_four(self, value):
    self.assertTrue(value < 4)

  @for_examples((1,2),(2,4),(3,7))
  def test_double_of_X_is_Y(self, x, y):
    self.assertEqual(2 * x, y)

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

При выполнении этого script результат:

..F...F
======================================================================
FAIL: test_double_of_X_is_Y(3,7)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/Users/xdecoret/Documents/foo.py", line 22, in method_for_example
    method(self, *example)
  File "/Users/xdecoret/Documents/foo.py", line 41, in test_double_of_X_is_Y
    self.assertEqual(2 * x, y)
AssertionError: 6 != 7

======================================================================
FAIL: test_is_smaller_than_four(4)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "/Users/xdecoret/Documents/foo.py", line 22, in method_for_example
    method(self, *example)
  File "/Users/xdecoret/Documents/foo.py", line 37, in test_is_smaller_than_four
    self.assertTrue(value < 4)
AssertionError

----------------------------------------------------------------------
Ran 7 tests in 0.001s

FAILED (failures=2)

который достигает нашей цели:

  • это ненавязчиво: мы получаем из TestCase как обычно
  • мы пишем параметризованные тесты только один раз
  • каждое значение примера считается индивидуальным тестом
  • декоратор может быть уложен в штабель, поэтому легко использовать наборы примеров (например, используя функцию для создания списка значений из файлов примеров или каталогов)
  • обледенение на торте, оно работает для произвольной сущности подписи

Итак, как это работает. В принципе, декоратор хранит примеры в атрибуте функции. Мы используем metaclass для замены каждой украшенной функции списком функций. И мы заменяем unittest.TestCase нашим новым. Магический код (который будет вставлен в комментарии "magic" выше):

__examples__ = "__examples__"

def for_examples(*examples):
    def decorator(f, examples=examples):
      setattr(f, __examples__, getattr(f, __examples__,()) + examples)
      return f
    return decorator

class TestCaseWithExamplesMetaclass(type):
  def __new__(meta, name, bases, dict):
    def tuplify(x):
      if not isinstance(x, tuple):
        return (x,)
      return x
    for methodname, method in dict.items():
      if hasattr(method, __examples__):
        dict.pop(methodname)
        examples = getattr(method, __examples__)
        delattr(method, __examples__)
        for example in (tuplify(x) for x in examples):
          def method_for_example(self, method = method, example = example):
            method(self, *example)
          methodname_for_example = methodname + "(" + ", ".join(str(v) for v in example) + ")"
          dict[methodname_for_example] = method_for_example
    return type.__new__(meta, name, bases, dict)

class TestCaseWithExamples(unittest.TestCase):
  __metaclass__ = TestCaseWithExamplesMetaclass
  pass

unittest.TestCase = TestCaseWithExamples

Если кто-то хочет упаковать это красиво или предложить патч для unittest, не стесняйтесь! Цитата моего имени будет оценена.

- Изменить --------

Код может быть сделан намного проще и полностью инкапсулирован в декораторе, если вы готовы использовать интроспекцию кадра (импортируйте модуль sys)

def for_examples(*parameters):

  def tuplify(x):
    if not isinstance(x, tuple):
      return (x,)
    return x

  def decorator(method, parameters=parameters):
    for parameter in (tuplify(x) for x in parameters):

      def method_for_parameter(self, method=method, parameter=parameter):
        method(self, *parameter)
      args_for_parameter = ",".join(repr(v) for v in parameter)
      name_for_parameter = method.__name__ + "(" + args_for_parameter + ")"
      frame = sys._getframe(1)  # pylint: disable-msg=W0212
      frame.f_locals[name_for_parameter] = method_for_parameter
    return None
  return decorator

Ответ 4

нос (предложенный @Paul Hankin)

#!/usr/bin/env python
# file: test_pairs_nose.py
from nose.tools import eq_ as eq

from mymodule import f

def test_pairs(): 
    for input, output in [ (2, 332), (234, 99213), (9, 3), ]:
        yield _test_f, input, output

def _test_f(input, output):
    try:
        eq(f(input), output)
    except AssertionError:
        if input == 9: # expected failure
            from nose.exc import SkipTest
            raise SkipTest("expected failure")
        else:
            raise

if __name__=="__main__":
   import nose; nose.main()

Пример:

$ nosetests test_pairs_nose -v
test_pairs_nose.test_pairs(2, 332) ... ok
test_pairs_nose.test_pairs(234, 99213) ... ok
test_pairs_nose.test_pairs(9, 3) ... SKIP: expected failure

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

OK (SKIP=1)

unittest (подход похож на @doublep one)

#!/usr/bin/env python
import unittest2 as unittest
from mymodule import f

def add_tests(generator):
    def class_decorator(cls):
        """Add tests to `cls` generated by `generator()`."""
        for f, input, output in generator():
            test = lambda self, i=input, o=output, f=f: f(self, i, o)
            test.__name__ = "test_%s(%r, %r)" % (f.__name__, input, output)
            setattr(cls, test.__name__, test)
        return cls
    return class_decorator

def _test_pairs():
    def t(self, input, output):
        self.assertEqual(f(input), output)

    for input, output in [ (2, 332), (234, 99213), (9, 3), ]:
        tt = t if input != 9 else unittest.expectedFailure(t)
        yield tt, input, output

class TestCase(unittest.TestCase):
    pass
TestCase = add_tests(_test_pairs)(TestCase)

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

Пример:

$ python test_pairs_unit2.py -v
test_t(2, 332) (__main__.TestCase) ... ok
test_t(234, 99213) (__main__.TestCase) ... ok
test_t(9, 3) (__main__.TestCase) ... expected failure

----------------------------------------------------------------------
Ran 3 tests in 0.000s

OK (expected failures=1)

Если вы не хотите устанавливать unittest2, то добавьте:

try:    
    import unittest2 as unittest
except ImportError:
    import unittest
    if not hasattr(unittest, 'expectedFailure'):
       import functools
       def _expectedFailure(func):
           @functools.wraps(func)
           def wrapper(*args, **kwargs):
               try:
                   func(*args, **kwargs)
               except AssertionError:
                   pass
               else:
                   raise AssertionError("UnexpectedSuccess")
           return wrapper
       unittest.expectedFailure = _expectedFailure

Ответ 5

Некоторые из инструментов, доступных для выполнения параметризованных тестов в Python:

См. также вопрос 1676269 для получения дополнительных ответов на этот вопрос.

Ответ 7

Я думаю, что решение Рори является самым чистым и коротким. Однако эта вариация doublep "создает синтетические функции в TestCase" также работает:

from functools import partial
class TestAllReports(unittest.TestCase):
    pass

def test_spamreport(name):
    assert classify(getSample(name))=='spamreport', name

for rep in REPORTS:
    testname = 'test_'+rep
    testfunc = partial(test_spamreport, rep)
    testfunc.__doc__ = testname
    setattr( TestAllReports, testname, testfunc )

if __name__=='__main__':
    unittest.main(argv=sys.argv + ['--verbose'])