1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
|
"""Tests for flexmock teardown."""
# pylint: disable=missing-docstring,no-member
from flexmock import exceptions, flexmock
from flexmock._api import UPDATED_ATTRS, flexmock_teardown
from tests import some_module
from tests.utils import assert_raises
class TeardownTestCase:
def test_flexmock_should_properly_restore_static_methods(self):
class User:
@staticmethod
def get_stuff():
return "ok!"
assert isinstance(User.__dict__["get_stuff"], staticmethod)
assert User.get_stuff() == "ok!"
flexmock(User).should_receive("get_stuff")
assert User.get_stuff() is None
flexmock_teardown()
assert User.get_stuff() == "ok!"
assert isinstance(User.__dict__["get_stuff"], staticmethod)
def test_flexmock_should_properly_restore_undecorated_static_methods(self):
class User:
def get_stuff():
return "ok!"
get_stuff = staticmethod(get_stuff) # pylint: disable=no-staticmethod-decorator
assert User.get_stuff() == "ok!"
flexmock(User).should_receive("get_stuff")
assert User.get_stuff() is None
flexmock_teardown()
assert User.get_stuff() == "ok!"
def test_flexmock_should_properly_restore_module_level_functions(self):
flexmock(some_module).should_receive("module_function").with_args(1, 2)
assert some_module.module_function(1, 2) is None
flexmock_teardown()
assert some_module.module_function(1, 2) == -1
def test_flexmock_should_revert_new_instances_on_teardown(self):
class User:
pass
class Group:
pass
user = User()
group = Group()
flexmock(Group).new_instances(user)
assert user is Group()
flexmock_teardown()
assert group.__class__ is Group().__class__
def test_flexmock_should_cleanup_added_methods_and_attributes(self):
class Group:
pass
group = Group()
flexmock(Group)
assert "should_receive" in Group.__dict__
assert "should_receive" not in group.__dict__
flexmock(group)
assert "should_receive" in group.__dict__
flexmock_teardown()
for method in UPDATED_ATTRS:
assert method not in Group.__dict__
assert method not in group.__dict__
def test_class_attributes_are_unchanged_after_mocking(self):
class Base:
@classmethod
def class_method(cls):
pass
@staticmethod
def static_method():
pass
def instance_method(self):
pass
class Child(Base):
pass
instance = Base()
base_attrs = list(vars(Base).keys())
instance_attrs = list(vars(instance).keys())
child_attrs = list(vars(Child).keys())
flexmock(Base).should_receive("class_method").once()
flexmock(Base).should_receive("static_method").once()
Base.class_method()
Base.static_method()
flexmock(instance).should_receive("class_method").once()
flexmock(instance).should_receive("static_method").once()
flexmock(instance).should_receive("instance_method").once()
instance.class_method()
instance.static_method()
instance.instance_method()
flexmock(Child).should_receive("class_method").once()
flexmock(Child).should_receive("static_method").once()
Child.class_method()
Child.static_method()
flexmock_teardown()
assert base_attrs == list(vars(Base).keys())
assert instance_attrs == list(vars(instance).keys())
assert child_attrs == list(vars(Child).keys())
def test_class_attributes_are_unchanged_after_spying(self):
class Base:
@classmethod
def class_method(cls):
pass
@staticmethod
def static_method():
pass
def instance_method(self):
pass
class Child(Base):
pass
instance = Base()
base_attrs = list(vars(Base).keys())
instance_attrs = list(vars(instance).keys())
child_attrs = list(vars(Child).keys())
flexmock(Base).should_call("class_method").times(3) # TODO: should be once #80
flexmock(Base).should_call("static_method").times(3) # TODO: should be once #80
Base.class_method()
Base.static_method()
flexmock(instance).should_call("class_method").once()
flexmock(instance).should_call("static_method").once()
flexmock(instance).should_call("instance_method").once()
instance.class_method()
instance.static_method()
instance.instance_method()
flexmock(Child).should_call("class_method").once()
flexmock(Child).should_call("static_method").once()
Child.class_method()
Child.static_method()
flexmock_teardown()
assert base_attrs == list(vars(Base).keys())
assert instance_attrs == list(vars(instance).keys())
assert child_attrs == list(vars(Child).keys())
def test_flexmock_should_cleanup_after_exception(self):
class User:
def method2(self):
pass
class Group:
def method1(self):
pass
flexmock(Group)
flexmock(User)
Group.should_receive("method1").once()
User.should_receive("method2").once()
with assert_raises(
exceptions.MethodCallError,
"method1() expected to be called exactly 1 time, called 0 times",
):
flexmock_teardown()
for method in UPDATED_ATTRS:
assert method not in dir(Group)
for method in UPDATED_ATTRS:
assert method not in dir(User)
def test_flexmock_teardown_called_between_tests_part1(self):
flexmock().should_receive("method1").ordered()
def test_flexmock_teardown_called_between_tests_part2(self):
mock = flexmock().should_receive("method2").ordered().mock()
# Raises CallOrderError if flexmock teardown is not automatically called
# after test part 1 above
mock.method2()
|
