Я пишу некоторые unittests в python, которые тестируют, если я получаю целое число. Однако иногда это целое число может быть отключено на 1 или 2, и мне все равно. По сути, я хочу сказать, что полученное целое число находится в определенном диапазоне, например:

Есть ли приемлемый способ сделать это? Или мне нужно сделать что-то вроде этого:

ИЗМЕНИТЬ На сегодняшний день ответы на них:

Есть ли какая-либо польза от этого в моем примере с двумя утверждениями?

Ответы

Ответ 1

Вы можете использовать " скованное сравнение:

self.assertTrue(998 <= my_integer <= 1000)

Ответ 2

В Python есть встроенная функция, которую вы можете использовать для этого: assertAlmostEqual.

self.assertAlmostEqual(myinteger, 999, delta=1)
# is equivalent to
self.assertTrue(998 <= myinteger <= 1000)
# ... but gives better error messages.

Необязательный параметр delta указывает допустимое расстояние от тестируемого значения.

Ответ 3

Я не думаю, что неплохо использовать assertTrue со сравнением внутри - таким образом вы теряете любую информацию в сообщении FAIL:

AssertionError: False is not true

Это не полезно вообще, и вы в основном возвращаетесь к "raw" assert, и вы теряете много преимуществ методов unittest.

Я бы рекомендовал либо:

Создание собственного пользовательского подтверждения

в котором вы можете печатать более значимые сообщения. Например:

import unittest

class BetweenAssertMixin(object):
    def assertBetween(self, x, lo, hi):
        if not (lo <= x <= hi):
            raise AssertionError('%r not between %r and %r' % (x, lo, hi))

class Test1(unittest.TestCase, BetweenAssertMixin):
    def test_between(self):
        self.assertBetween(999, 998, 1000)

    def test_too_low(self):
        self.assertBetween(997, 998, 1000)

    def test_too_high(self):
        self.assertBetween(1001, 998, 1000)

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

то у вас будет следующий результат (сокращенный):

======================================================================
FAIL: test_too_high (__main__.Test1)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "example.py", line 19, in test_too_high
    self.assertBetween(1001, 998, 1000)
  File "example.py", line 8, in assertBetween
    raise AssertionError('%r is not between %r and %r' % (x, lo, hi))
AssertionError: 1001 is not between 998 and 1000
======================================================================
FAIL: test_too_low (__main__.Test1)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "example.py", line 16, in test_too_low
    self.assertBetween(997, 998, 1000)
  File "example.py", line 8, in assertBetween
    raise AssertionError('%r is not between %r and %r' % (x, lo, hi))
AssertionError: 997 is not between 998 and 1000
----------------------------------------------------------------------

Или используйте `assertLessEqual` и `assertGreaterEqual`

если вы не хотите, чтобы пользовательский assert (который добавляет еще одну запись трассировки и несколько строк кода):

...
def test_no_custom_assert(self):
    my_integer = 100
    self.assertGreaterEqual(my_integer, 998)
    self.assertLessEqual(my_integer, 1000)
...

который немного длиннее (он может быть короче, чем добавление пользовательского утверждения, если он используется только один раз), чем assertTrue(998 <= my_integer <= 1000), но вы все равно получите хорошие сообщения об ошибках (также без дополнительной записи трассировки):

======================================================================
FAIL: test_no_custom_assert (__main__.Test1)
----------------------------------------------------------------------
Traceback (most recent call last):
  File "example.py", line 23, in test_no_custom_assert
    self.assertGreaterEqual(my_integer, 998)
AssertionError: 100 not greater than or equal to 998

Ответ 4

self.assertTrue(998 <= my_integer <= 1000)

Ответ 5

Другая опция - проверить, есть ли тестируемый результат в range, используя функцию assertIn. Например, в Python 3:

self.assertIn(my_integer, range(998, 1001))

Или, в Python 2:

self.assertIn(my_integer, xrange(998, 1001))

Это особенно полезно при проверке, нет ли целого числа в диапазоне:

self.assertNotIn(my_integer, range(998, 1001))

Обратите внимание, что это не полезно для нецелых чисел:

self.assertIn(999.9, xrange(998, 1001))  # will raise an AssertionError

Утверждать, что целое число находится в пределах диапазона