如何模拟Python静态方法和类方法 [英] How to mock Python static methods and class methods
问题描述
如何模拟具有未绑定方法的类?例如,此类具有@classmethod
和@staticmethod
:
How do I mock a class that has unbound methods? For example, this class has a @classmethod
and a @staticmethod
:
class Calculator(object):
def __init__(self, multiplier):
self._multiplier = multiplier
def multiply(self, n):
return self._multiplier * n
@classmethod
def increment(cls, n):
return n + 1
@staticmethod
def decrement(n):
return n - 1
calculator = Calculator(2)
assert calculator.multiply(3) == 6
assert calculator.increment(3) == 4
assert calculator.decrement(3) == 2
assert Calculator.increment(3) == 4
assert Calculator.decrement(3) == 2
以上内容几乎描述了我的问题.以下是一个有效的示例,演示了我尝试过的事情.
The above pretty much describes my question. The following is a working example that demonstrates the things I have tried.
类Machine
包含Calculator
的实例.我将使用Calculator
的模拟测试Machine
.为了演示我的问题,Machine
通过Calculator
的实例和Calculator
类调用未绑定的方法:
Class Machine
contains an instance of Calculator
. I will be testing Machine
with a mock of Calculator
. To demonstrate my issue, Machine
calls the unbound methods via an instance of Calculator
and via the Calculator
class:
class Machine(object):
def __init__(self, calculator):
self._calculator = calculator
def mult(self, n):
return self._calculator.multiply(n)
def incr_bound(self, n):
return self._calculator.increment(n)
def decr_bound(self, n):
return self._calculator.decrement(n)
def incr_unbound(self, n):
return Calculator.increment(n)
def decr_unbound(self, n):
return Calculator.decrement(n)
machine = Machine(Calculator(3))
assert machine.mult(3) == 9
assert machine.incr_bound(3) == 4
assert machine.incr_unbound(3) == 4
assert machine.decr_bound(3) == 2
assert machine.decr_unbound(3) == 2
上面的所有功能代码都可以正常工作.接下来是不起作用的部分.
All the functional code above works fine. Next is the part that does not work.
我创建了一个Calculator
的模拟物,用于测试Machine
:
I create a mock of Calculator
to use in testing Machine
:
from mock import Mock
def MockCalculator(multiplier):
mock = Mock(spec=Calculator, name='MockCalculator')
def multiply_proxy(n):
'''Multiply by 2*multiplier instead so we can see the difference'''
return 2 * multiplier * n
mock.multiply = multiply_proxy
def increment_proxy(n):
'''Increment by 2 instead of 1 so we can see the difference'''
return n + 2
mock.increment = increment_proxy
def decrement_proxy(n):
'''Decrement by 2 instead of 1 so we can see the difference'''
return n - 2
mock.decrement = decrement_proxy
return mock
在下面的单元测试中,绑定方法如我所希望的那样使用MockCalculator
.但是,对Calculator.increment()
和Calculator.decrement()
的调用仍然使用Calculator
:
In the unit test below, the bound methods use MockCalculator
as I had hoped. However, the calls to Calculator.increment()
and Calculator.decrement()
still use Calculator
:
import unittest
class TestMachine(unittest.TestCase):
def test_bound(self):
'''The bound methods of Calculator are replaced with MockCalculator'''
machine = Machine(MockCalculator(3))
self.assertEqual(machine.mult(3), 18)
self.assertEqual(machine.incr_bound(3), 5)
self.assertEqual(machine.decr_bound(3), 1)
def test_unbound(self):
'''Machine.incr_unbound() and Machine.decr_unbound() are still using
Calculator.increment() and Calculator.decrement(n), which is wrong.
'''
machine = Machine(MockCalculator(3))
self.assertEqual(machine.incr_unbound(3), 4) # I wish this was 5
self.assertEqual(machine.decr_unbound(3), 2) # I wish this was 1
所以我尝试修补Calculator.increment()
和Calculator.decrement()
:
def MockCalculatorImproved(multiplier):
mock = Mock(spec=Calculator, name='MockCalculatorImproved')
def multiply_proxy(n):
'''Multiply by 2*multiplier instead of multiplier so we can see the difference'''
return 2 * multiplier * n
mock.multiply = multiply_proxy
return mock
def increment_proxy(n):
'''Increment by 2 instead of 1 so we can see the difference'''
return n + 2
def decrement_proxy(n):
'''Decrement by 2 instead of 1 so we can see the difference'''
return n - 2
from mock import patch
@patch.object(Calculator, 'increment', increment_proxy)
@patch.object(Calculator, 'decrement', decrement_proxy)
class TestMachineImproved(unittest.TestCase):
def test_bound(self):
'''The bound methods of Calculator are replaced with MockCalculator'''
machine = Machine(MockCalculatorImproved(3))
self.assertEqual(machine.mult(3), 18)
self.assertEqual(machine.incr_bound(3), 5)
self.assertEqual(machine.decr_bound(3), 1)
def test_unbound(self):
'''machine.incr_unbound() and Machine.decr_unbound() should use
increment_proxy() and decrement_proxy(n).
'''
machine = Machine(MockCalculatorImproved(3))
self.assertEqual(machine.incr_unbound(3), 5)
self.assertEqual(machine.decr_unbound(3), 1)
即使进行了修补,未绑定的方法也希望将Calculator
的实例作为参数:
Even after patching, the unbound methods want an instance of Calculator
as an argument:
TypeError:必须以计算器实例作为第一个参数来调用未绑定的方法increment_proxy()(取而代之的是int实例)
TypeError: unbound method increment_proxy() must be called with Calculator instance as first argument (got int instance instead)
如何模拟类方法Calculator.increment()
和静态方法Calculator.decrement()
?
How do I mock out class method Calculator.increment()
and static method Calculator.decrement()
?
推荐答案
C#,Java和C ++程序员倾向于过度使用Python中的类和静态方法. Python的方法是使用模块函数.
C#, Java and C++ programmers tend to overuse class and static methods in Python. The Pythonic approach is to use module functions.
因此,首先,这是测试中的重构软件,其中方法increment()
和decrement()
作为模块功能.界面确实发生了变化,但是功能是相同的:
So first, here is the refactored software under test, with methods increment()
and decrement()
as module functions. The interface does change, but the functionality is the same:
# Module machines
class Calculator(object):
def __init__(self, multiplier):
self._multiplier = multiplier
def multiply(self, n):
return self._multiplier * n
def increment(n):
return n + 1
def decrement(n):
return n - 1
calculator = Calculator(2)
assert calculator.multiply(3) == 6
assert increment(3) == 4
assert decrement(3) == 2
class Machine(object):
'''A larger machine that has a calculator.'''
def __init__(self, calculator):
self._calculator = calculator
def mult(self, n):
return self._calculator.multiply(n)
def incr(self, n):
return increment(n)
def decr(self, n):
return decrement(n)
machine = Machine(Calculator(3))
assert machine.mult(3) == 9
assert machine.incr(3) == 4
assert machine.decr(3) == 2
添加函数increment_mock()
和decrement_mock()
以模拟increment()
和decrement()
:
from mock import Mock
import machines
def MockCalculator(multiplier):
mock = Mock(spec=machines.Calculator, name='MockCalculator')
def multiply_proxy(n):
'''Multiply by 2*multiplier instead of multiplier so we can see the
difference.
'''
return 2 * multiplier * n
mock.multiply = multiply_proxy
return mock
def increment_mock(n):
'''Increment by 2 instead of 1 so we can see the difference.'''
return n + 2
def decrement_mock(n):
'''Decrement by 2 instead of 1 so we can see the difference.'''
return n - 2
现在大部分.修补increment()
和decrement()
以将其替换为它们的模拟:
And now for the good part. Patch increment()
and decrement()
to replace them with their mocks:
import unittest
from mock import patch
import machines
@patch('machines.increment', increment_mock)
@patch('machines.decrement', decrement_mock)
class TestMachine(unittest.TestCase):
def test_mult(self):
'''The bound method of Calculator is replaced with MockCalculator'''
machine = machines.Machine(MockCalculator(3))
self.assertEqual(machine.mult(3), 18)
def test_incr(self):
'''increment() is replaced with increment_mock()'''
machine = machines.Machine(MockCalculator(3))
self.assertEqual(machine.incr(3), 5)
def test_decr(self):
'''decrement() is replaced with decrement_mock()'''
machine = machines.Machine(MockCalculator(3))
self.assertEqual(machine.decr(3), 1)
这篇关于如何模拟Python静态方法和类方法的文章就介绍到这了,希望我们推荐的答案对大家有所帮助,也希望大家多多支持IT屋!