Debian Codegraph @

tests/dispatch/tests.py

raw
1 import weakref
2 from types import TracebackType
3
4 from django.dispatch import Signal, receiver
5 from django.test import SimpleTestCase
6 from django.test.utils import garbage_collect, override_settings
7
8
9 def receiver_1_arg(val, **kwargs):
10 return val
11
12
13 class Callable:
14 def __call__(self, val, **kwargs):
15 return val
16
17 def a(self, val, **kwargs):
18 return val
19
20
21 a_signal = Signal()
22 b_signal = Signal()
23 c_signal = Signal()
24 d_signal = Signal(use_caching=True)
25
26
27 class DispatcherTests(SimpleTestCase):
28 def assertTestIsClean(self, signal):
29 """Assert that everything has been cleaned up automatically"""
30 # Note that dead weakref cleanup happens as side effect of using
31 # the signal's receivers through the signals API. So, first do a
32 # call to an API method to force cleanup.
33 self.assertFalse(signal.has_listeners())
34 self.assertEqual(signal.receivers, [])
35
36 @override_settings(DEBUG=True)
37 def test_cannot_connect_no_kwargs(self):
38 def receiver_no_kwargs(sender):
39 pass
40
41 msg = "Signal receivers must accept keyword arguments (**kwargs)."
42 with self.assertRaisesMessage(ValueError, msg):
43 a_signal.connect(receiver_no_kwargs)
44 self.assertTestIsClean(a_signal)
45
46 @override_settings(DEBUG=True)
47 def test_cannot_connect_non_callable(self):
48 msg = "Signal receivers must be callable."
49 with self.assertRaisesMessage(TypeError, msg):
50 a_signal.connect(object())
51 self.assertTestIsClean(a_signal)
52
53 def test_send(self):
54 a_signal.connect(receiver_1_arg, sender=self)
55 result = a_signal.send(sender=self, val="test")
56 self.assertEqual(result, [(receiver_1_arg, "test")])
57 a_signal.disconnect(receiver_1_arg, sender=self)
58 self.assertTestIsClean(a_signal)
59
60 def test_send_no_receivers(self):
61 result = a_signal.send(sender=self, val="test")
62 self.assertEqual(result, [])
63
64 def test_send_connected_no_sender(self):
65 a_signal.connect(receiver_1_arg)
66 result = a_signal.send(sender=self, val="test")
67 self.assertEqual(result, [(receiver_1_arg, "test")])
68 a_signal.disconnect(receiver_1_arg)
69 self.assertTestIsClean(a_signal)
70
71 def test_send_different_no_sender(self):
72 a_signal.connect(receiver_1_arg, sender=object)
73 result = a_signal.send(sender=self, val="test")
74 self.assertEqual(result, [])
75 a_signal.disconnect(receiver_1_arg, sender=object)
76 self.assertTestIsClean(a_signal)
77
78 def test_garbage_collected(self):
79 a = Callable()
80 a_signal.connect(a.a, sender=self)
81 del a
82 garbage_collect()
83 result = a_signal.send(sender=self, val="test")
84 self.assertEqual(result, [])
85 self.assertTestIsClean(a_signal)
86
87 def test_cached_garbaged_collected(self):
88 """
89 Make sure signal caching sender receivers don't prevent garbage
90 collection of senders.
91 """
92
93 class sender:
94 pass
95
96 wref = weakref.ref(sender)
97 d_signal.connect(receiver_1_arg)
98 d_signal.send(sender, val="garbage")
99 del sender
100 garbage_collect()
101 try:
102 self.assertIsNone(wref())
103 finally:
104 # Disconnect after reference check since it flushes the tested cache.
105 d_signal.disconnect(receiver_1_arg)
106
107 def test_multiple_registration(self):
108 a = Callable()
109 a_signal.connect(a)
110 a_signal.connect(a)
111 a_signal.connect(a)
112 a_signal.connect(a)
113 a_signal.connect(a)
114 a_signal.connect(a)
115 result = a_signal.send(sender=self, val="test")
116 self.assertEqual(len(result), 1)
117 self.assertEqual(len(a_signal.receivers), 1)
118 del a
119 del result
120 garbage_collect()
121 self.assertTestIsClean(a_signal)
122
123 def test_uid_registration(self):
124 def uid_based_receiver_1(**kwargs):
125 pass
126
127 def uid_based_receiver_2(**kwargs):
128 pass
129
130 a_signal.connect(uid_based_receiver_1, dispatch_uid="uid")
131 a_signal.connect(uid_based_receiver_2, dispatch_uid="uid")
132 self.assertEqual(len(a_signal.receivers), 1)
133 a_signal.disconnect(dispatch_uid="uid")
134 self.assertTestIsClean(a_signal)
135
136 def test_send_robust_success(self):
137 a_signal.connect(receiver_1_arg)
138 result = a_signal.send_robust(sender=self, val="test")
139 self.assertEqual(result, [(receiver_1_arg, "test")])
140 a_signal.disconnect(receiver_1_arg)
141 self.assertTestIsClean(a_signal)
142
143 def test_send_robust_no_receivers(self):
144 result = a_signal.send_robust(sender=self, val="test")
145 self.assertEqual(result, [])
146
147 def test_send_robust_ignored_sender(self):
148 a_signal.connect(receiver_1_arg)
149 result = a_signal.send_robust(sender=self, val="test")
150 self.assertEqual(result, [(receiver_1_arg, "test")])
151 a_signal.disconnect(receiver_1_arg)
152 self.assertTestIsClean(a_signal)
153
154 def test_send_robust_fail(self):
155 def fails(val, **kwargs):
156 raise ValueError("this")
157
158 a_signal.connect(fails)
159 try:
160 with self.assertLogs("django.dispatch", "ERROR") as cm:
161 result = a_signal.send_robust(sender=self, val="test")
162 err = result[0][1]
163 self.assertIsInstance(err, ValueError)
164 self.assertEqual(err.args, ("this",))
165 self.assertIs(hasattr(err, "__traceback__"), True)
166 self.assertIsInstance(err.__traceback__, TracebackType)
167
168 log_record = cm.records[0]
169 self.assertEqual(
170 log_record.getMessage(),
171 "Error calling "
172 "DispatcherTests.test_send_robust_fail.<locals>.fails in "
173 "Signal.send_robust() (this)",
174 )
175 self.assertIsNotNone(log_record.exc_info)
176 _, exc_value, _ = log_record.exc_info
177 self.assertIsInstance(exc_value, ValueError)
178 self.assertEqual(str(exc_value), "this")
179 finally:
180 a_signal.disconnect(fails)
181 self.assertTestIsClean(a_signal)
182
183 def test_disconnection(self):
184 receiver_1 = Callable()
185 receiver_2 = Callable()
186 receiver_3 = Callable()
187 a_signal.connect(receiver_1)
188 a_signal.connect(receiver_2)
189 a_signal.connect(receiver_3)
190 a_signal.disconnect(receiver_1)
191 del receiver_2
192 garbage_collect()
193 a_signal.disconnect(receiver_3)
194 self.assertTestIsClean(a_signal)
195
196 def test_values_returned_by_disconnection(self):
197 receiver_1 = Callable()
198 receiver_2 = Callable()
199 a_signal.connect(receiver_1)
200 receiver_1_disconnected = a_signal.disconnect(receiver_1)
201 receiver_2_disconnected = a_signal.disconnect(receiver_2)
202 self.assertTrue(receiver_1_disconnected)
203 self.assertFalse(receiver_2_disconnected)
204 self.assertTestIsClean(a_signal)
205
206 def test_has_listeners(self):
207 self.assertFalse(a_signal.has_listeners())
208 self.assertFalse(a_signal.has_listeners(sender=object()))
209 receiver_1 = Callable()
210 a_signal.connect(receiver_1)
211 self.assertTrue(a_signal.has_listeners())
212 self.assertTrue(a_signal.has_listeners(sender=object()))
213 a_signal.disconnect(receiver_1)
214 self.assertFalse(a_signal.has_listeners())
215 self.assertFalse(a_signal.has_listeners(sender=object()))
216
217
218 class ReceiverTestCase(SimpleTestCase):
219 def test_receiver_single_signal(self):
220 @receiver(a_signal)
221 def f(val, **kwargs):
222 self.state = val
223
224 self.state = False
225 a_signal.send(sender=self, val=True)
226 self.assertTrue(self.state)
227
228 def test_receiver_signal_list(self):
229 @receiver([a_signal, b_signal, c_signal])
230 def f(val, **kwargs):
231 self.state.append(val)
232
233 self.state = []
234 a_signal.send(sender=self, val="a")
235 c_signal.send(sender=self, val="c")
236 b_signal.send(sender=self, val="b")
237 self.assertIn("a", self.state)
238 self.assertIn("b", self.state)
239 self.assertIn("c", self.state)