[英]Pytest: Mock multiple calls of same method with different side_effect
我有一个像下面这样的单元测试:
# utilities.py
def get_side_effects():
def side_effect_func3(self):
# Need the "self" to do some stuff at run time.
return {"final":"some3"}
def side_effect_func2(self):
# Need the "self" to do some stuff at run time.
return {"status":"some2"}
def side_effect_func1(self):
# Need the "self" to do some stuff at run time.
return {"name":"some1"}
return side_effect_func1, side_effect_func2, side_effect_func2
#################
# test_a.py
def test_endtoend():
s1, s2, s3 = utilities.get_side_effects()
m1 = mock.MagicMock()
m1.side_effect = s1
m2 = mock.MagicMock()
m2.side_effect = s2
m3 = mock.MagicMock()
m3.side_effect = s3
with mock.patch("a.get_request", m3):
with mock.patch("a.get_request", m2):
with mock.patch("a.get_request", m1):
foo = a() # Class to test
result = foo.run()
作为foo.run()
代码运行的一部分,多次调用get_request
。 我想为get_request
方法的每次调用使用不同的 side_effect 函数,在这种情况下它是side_effect_func1
、 side_effect_func2
、 side_effect_func3
。 但我注意到只有m1
模拟对象处于活动状态,即只调用side_effect_func1
而不是其他 2. 我如何实现这一点?
我也尝试了下面的方法,但是没有调用实际的 side_effect 函数,它们总是返回function object
,但实际上并不执行 side_effect 函数。
# utilities.py
def get_side_effects():
def side_effect_func3(self):
# Need the "self" to do some stuff at run time.
return {"final":"some3"}
def side_effect_func2(self):
# Need the "self" to do some stuff at run time.
return {"status":"some2"}
def side_effect_func1(self):
# Need the "self" to do some stuff at run time.
return {"name":"some1"}
all_get_side_effects = []
all_get_side_effects.append(side_effect_func1)
all_get_side_effects.append(side_effect_func2)
all_get_side_effects.append(side_effect_func3)
return all_get_side_effects
#########################
# test_a.py
def test_endtoend():
all_side_effects = utilities.get_side_effects()
m = mock.MagicMock()
m.side_effect = all_side_effects
with mock.patch("a.get_request", m):
foo = a() # Class to test
result = foo.run()
您的第一次尝试不起作用,因为每个模拟只是替换了前一个(外面的两个模拟什么也不做)。
您的第二次尝试不起作用,因为副作用被重载以用于可迭代对象( docs )的不同目的:
如果
side_effect
是一个可迭代对象,那么每次调用模拟都会从可迭代对象返回下一个值。
相反,您可以使用一个可调用的类来实现副作用,该类连续地维护有关实际调用哪个底层函数的某种状态。
具有两个函数的基本示例:
>>> class SideEffect:
... def __init__(self, *fns):
... self.fs = iter(fns)
... def __call__(self, *args, **kwargs):
... f = next(self.fs)
... return f(*args, **kwargs)
...
>>> def sf1():
... print("called sf1")
... return 1
...
>>> def sf2():
... print("called sf2")
... return 2
...
>>> def foo():
... print("called actual func")
... return "f"
...
>>> with mock.patch("__main__.foo", side_effect=SideEffect(sf1, sf2)) as m:
... first = foo()
... second = foo()
...
called sf1
called sf2
>>> assert first == 1
>>> assert second == 2
>>> assert m.call_count == 2
声明:本站的技术帖子网页,遵循CC BY-SA 4.0协议,如果您需要转载,请注明本站网址或者原文地址。任何问题请咨询:yoyou2525@163.com.