标签: python-unittest

使用 Python Unittest，这是一个测试套件的示例：

import unittest

# Here's our "unit".
def IsOdd(n):
    return n % 2 == 1

# Here's our "unit tests".
class IsOddTests(unittest.TestCase):

    def testOne(self):
        self.failUnless(IsOdd(1))

    def testTwo(self):
        self.failIf(IsOdd(2))

def main():
    unittest.main(verbosity=2)

if __name__ == '__main__':
    main()

结果：

testOne (__main__.IsOddTests) ... ok
testTwo (__main__.IsOddTests) ... ok

----------------------------------------------------------------------
Ran 2 tests in 0.000s

OK

是否可以增强测试的显示，例如：

Testing ODD method
Testing with value is 1 (__main__.IsOddTests) ... ok
Testing with value is 2 (__main__.IsOddTests) ... ok

----------------------------------------------------------------------
Ran 2 tests in 0.000s …

我有一个python模块文件(func.py)和一个单元测试文件(f_test.py):

# func.py

def f(x):
    return x + 1

x = input("Enter x: "))

print("f(x): " + str(f(x)))

和

# f_test.py

import unittest
from func import f

class MyTest(unittest.TestCase):
    def test(self):
        self.assertEqual(f(1), 2)

当我运行时,f_test.py我希望测试套件能够被执行(成功).相反,我看到以下输入:

Finding files... done.
Importing test modules ... Enter x:

如果我func.py从那时注释掉输入/输出行,我会得到预期的行为.如何在不修改的情况下实现它func.py？

有一个FooObject只有一个version字段和一个update()方法的类。

class FooObject(models.Model):
  version = models.CharField(max_length=100)

我想update使用 Python 的Mock工具覆盖单元测试的方法。我该怎么做？我应该用patch它吗？

foo_object.update = Mock(self.version = '123')

我正在使用 Python 2.6.6

我想要做的是用 Mock 替换对象的创建，以确保进行正确的调用。应该是直截了当的。

我的模块：

import dir.SubModule

class Cls( object ):
    def Start( self ):
        self.__obj = dir.SubModule.SubCls()
        self.__obj.foo()

我的测试：

import MyModule
import unittest
from mock import Mock, MagicMock, patch

class MyTest( unittest.TestCase ):
    def setUp( self ):
        self.uut = MyModule.Cls()

    def test_one( self ):
        with patch( 'dir.SubModule.SubCls', spec=True ) as mockObj:
            print "mock calls before"
            print mockObj.mock_calls
            self.uut.Start()

            print "called: "      + str( mockObj.called )
            print "foo called: " + str( mockObj.foo.called )
            print "call_count: "  + …

import unittest

class TestTemplate(unittest.TestCase):

    @classmethod
    def setUpClass(self):
        self.result = 'error'
        print "setUpClass"

    @classmethod
    def tearDownClass(self):
        print "The value of result is, ",self.result
        if self.result == 'ok':
            print "it is working"
        print "The value of cls result is : ", self.result
        print "TearDownClass"


class MyTest(TestTemplate):

    def test_method_one(self):
        self.result = 'ok'
        print self.result


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

在tearDownClassself.result 的值是error，而是应该是okay因为我在方法中改变了它？这有什么解决办法吗？

我在python中运行以下单元测试,结果应该是正确的,但是单元测试出错了.

这是什么错误？

这是我必须测试的课程

class Strategy:
    _a = 0
    _b = 0
    _result = 0

    def __init__(self, a, b):

        try:
            int(a)
            int(b)
        except ValueError:
            raise ValueError()

        self._a = a
        self._b = b

这是我的单位测试

def test_invalideValue(self):
    with self.assertRaises(ValueError) as cm:
        StrategyAddition('A', 3)

    self.assertEqual(cm.exception, ValueError())

而这就是看跌期权

Failure
Traceback (most recent call last):
  File "C:\Users\Michi\workspace_python\DesignPatternPython\Strategy\TestStrategy.py", line 24, in test_invalideValue
    self.assertEqual(cm.exception, ValueError())
AssertionError: ValueError() != ValueError()

我正在对某些功能进行测试。我有一个使用数据库查询的函数。因此，我浏览了博客和文档，这些博客和文档说我们必须创建一个内存或测试数据库才能使用此类功能。以下是我的功能，

def already_exists(story_data,c):
    # TODO(salmanhaseeb): Implement de-dupe functionality by checking if it already
    # exists in the DB.
    c.execute("""SELECT COUNT(*) from posts where post_id = ?""", (story_data.post_id,))
    (number_of_rows,)=c.fetchone()
    if number_of_rows > 0:
        return True
    return False

该函数访问生产数据库。我的问题是，在测试时，我创建一个内存数据库并在那里填充我的值，我将查询该数据库（测试数据库）。但我想测试我的already_exists()函数，从测试调用我的already_exists函数后，我的生产数据库将被命中。在测试此功能时如何使我的测试数据库命中？

@patch('module1.api.method1')  
@patch('module1.api.method2')
class TestApi(unittest.TestCase):

        @patch('module1.api.connec1')    
        @patch('module1.api.connec2')  
        def test_some_method(self, mockMethod1, mockMethod2, 
                                mockConnec1, mockConnec2):
            # some code.....

测试方法中提到的模拟对象的顺序是否应该与patch? 我们是否需要提及所有类级别和方法级别补丁的模拟对象？

如果有 20 个补丁对象，方法会一样吗？

请检查以下代码：

import unittest


def fn():
    raise KeyError('my message')


class Test(unittest.TestCase):
    def test_passes(self):
        with self.assertRaisesRegex(KeyError, 'my message'):
            fn()

        with self.assertRaisesRegex(KeyError, 'my'):
            fn()

    def test_fails(self):
        # Why does this test fail?
        # Isn't '^my message$' a valid regex?
        # How do I check if the message is exactly 'my message'?
        with self.assertRaisesRegex(KeyError, '^my message$'):
            fn()


unittest.main()

在输出中，我收到以下测试消息test_fails：

AssertionError：“^我的消息$”与“'我的消息'”不匹配

我缺少什么？

正如评论中提到的，这些是我的问题：

• 为什么这个测试会失败？
• 不是'^my message$'有效的正则表达式吗？
• 如何检查该消息是否是exactly 'my message'？

我有一个超类，它在初始化期间调用某个独立的方法。就像是

class MasterClass:
    def __init__(self, *args, **kwargs):
        if type(self).__name__ == "SpecificClass":
            call_a_module_method()

我想测试调用这个类的子类SpecificClass是否会call_a_module_method调用方法。

我是单元测试的新手，我正在尝试为我编写的代码编写一个测试，这是一个注释系统，可将注释和一些额外信息保存到数据库中。这是代码：

@app.route("/", methods=["GET", "POST"])
def home():

    if request.method == "POST":
        ip_address = request.remote_addr
        entry_content = request.form.get("content")
        formatted_date = datetime.datetime.today().strftime("%Y-%m-%d/%H:%M")
        app.db.entries.insert({
            "content": entry_content, 
            "date": formatted_date, 
            "IP": ip_address})

    return "GET method called"

我想编写一个测试来检查POST它的一部分，但我不知道如何在POST方法中传递内容并确保一切正常。

你能帮我解决这个问题吗？

这里有两个变量:earnings_forecast,actual_earning(数值变量)

我想断言这两个变量是否相等,相对于actual_earning变量可接受±2%的差异.

假设: earnings_forecast = 6 actual_earnings = 5.19

我不能使用,assertEqual(earnings_forecast, actual_earnings)因为它会尝试做一个完全匹配,而我想断言这两个变量几乎相等,可接受的±2%差异.