Debian Codegraph @

tests/signals/tests.py

raw
1 from unittest import mock
2
3 from asgiref.sync import markcoroutinefunction
4
5 from django import dispatch
6 from django.apps.registry import Apps
7 from django.db import models
8 from django.db.models import signals
9 from django.dispatch import receiver
10 from django.test import SimpleTestCase, TestCase
11 from django.test.utils import isolate_apps
12
13 from .models import Author, Book, Car, Page, Person
14
15
16 class BaseSignalSetup:
17 def setUp(self):
18 # Save up the number of connected signals so that we can check at the
19 # end that all the signals we register get properly unregistered (#9989)
20 self.pre_signals = (
21 len(signals.pre_save.receivers),
22 len(signals.post_save.receivers),
23 len(signals.pre_delete.receivers),
24 len(signals.post_delete.receivers),
25 )
26
27 def tearDown(self):
28 # All our signals got disconnected properly.
29 post_signals = (
30 len(signals.pre_save.receivers),
31 len(signals.post_save.receivers),
32 len(signals.pre_delete.receivers),
33 len(signals.post_delete.receivers),
34 )
35 self.assertEqual(self.pre_signals, post_signals)
36
37
38 class SignalTests(BaseSignalSetup, TestCase):
39 def test_model_pre_init_and_post_init(self):
40 data = []
41
42 def pre_init_callback(sender, args, **kwargs):
43 data.append(kwargs["kwargs"])
44
45 signals.pre_init.connect(pre_init_callback)
46
47 def post_init_callback(sender, instance, **kwargs):
48 data.append(instance)
49
50 signals.post_init.connect(post_init_callback)
51
52 p1 = Person(first_name="John", last_name="Doe")
53 self.assertEqual(data, [{}, p1])
54
55 def test_save_signals(self):
56 data = []
57
58 def pre_save_handler(signal, sender, instance, **kwargs):
59 data.append((instance, sender, kwargs.get("raw", False)))
60
61 def post_save_handler(signal, sender, instance, **kwargs):
62 data.append(
63 (instance, sender, kwargs.get("created"), kwargs.get("raw", False))
64 )
65
66 signals.pre_save.connect(pre_save_handler, weak=False)
67 signals.post_save.connect(post_save_handler, weak=False)
68 try:
69 p1 = Person.objects.create(first_name="John", last_name="Smith")
70
71 self.assertEqual(
72 data,
73 [
74 (p1, Person, False),
75 (p1, Person, True, False),
76 ],
77 )
78 data[:] = []
79
80 p1.first_name = "Tom"
81 p1.save()
82 self.assertEqual(
83 data,
84 [
85 (p1, Person, False),
86 (p1, Person, False, False),
87 ],
88 )
89 data[:] = []
90
91 # Calling an internal method purely so that we can trigger a "raw" save.
92 p1.save_base(raw=True)
93 self.assertEqual(
94 data,
95 [
96 (p1, Person, True),
97 (p1, Person, False, True),
98 ],
99 )
100 data[:] = []
101
102 p2 = Person(first_name="James", last_name="Jones")
103 p2.id = 99999
104 p2.save()
105 self.assertEqual(
106 data,
107 [
108 (p2, Person, False),
109 (p2, Person, True, False),
110 ],
111 )
112 data[:] = []
113 p2.id = 99998
114 p2.save()
115 self.assertEqual(
116 data,
117 [
118 (p2, Person, False),
119 (p2, Person, True, False),
120 ],
121 )
122
123 # The sender should stay the same when using defer().
124 data[:] = []
125 p3 = Person.objects.defer("first_name").get(pk=p1.pk)
126 p3.last_name = "Reese"
127 p3.save()
128 self.assertEqual(
129 data,
130 [
131 (p3, Person, False),
132 (p3, Person, False, False),
133 ],
134 )
135 finally:
136 signals.pre_save.disconnect(pre_save_handler)
137 signals.post_save.disconnect(post_save_handler)
138
139 def test_delete_signals(self):
140 data = []
141
142 def pre_delete_handler(signal, sender, instance, origin, **kwargs):
143 data.append((instance, sender, instance.id is None, origin))
144
145 # #8285: signals can be any callable
146 class PostDeleteHandler:
147 def __init__(self, data):
148 self.data = data
149
150 def __call__(self, signal, sender, instance, origin, **kwargs):
151 self.data.append((instance, sender, instance.id is None, origin))
152
153 post_delete_handler = PostDeleteHandler(data)
154
155 signals.pre_delete.connect(pre_delete_handler, weak=False)
156 signals.post_delete.connect(post_delete_handler, weak=False)
157 try:
158 p1 = Person.objects.create(first_name="John", last_name="Smith")
159 p1.delete()
160 self.assertEqual(
161 data,
162 [
163 (p1, Person, False, p1),
164 (p1, Person, False, p1),
165 ],
166 )
167 data[:] = []
168
169 p2 = Person(first_name="James", last_name="Jones")
170 p2.id = 99999
171 p2.save()
172 p2.id = 99998
173 p2.save()
174 p2.delete()
175 self.assertEqual(
176 data,
177 [
178 (p2, Person, False, p2),
179 (p2, Person, False, p2),
180 ],
181 )
182 data[:] = []
183
184 self.assertQuerySetEqual(
185 Person.objects.all(),
186 [
187 "James Jones",
188 ],
189 str,
190 )
191 finally:
192 signals.pre_delete.disconnect(pre_delete_handler)
193 signals.post_delete.disconnect(post_delete_handler)
194
195 def test_delete_signals_origin_model(self):
196 data = []
197
198 def pre_delete_handler(signal, sender, instance, origin, **kwargs):
199 data.append((sender, origin))
200
201 def post_delete_handler(signal, sender, instance, origin, **kwargs):
202 data.append((sender, origin))
203
204 person = Person.objects.create(first_name="John", last_name="Smith")
205 book = Book.objects.create(name="Rayuela")
206 Page.objects.create(text="Page 1", book=book)
207 Page.objects.create(text="Page 2", book=book)
208
209 signals.pre_delete.connect(pre_delete_handler, weak=False)
210 signals.post_delete.connect(post_delete_handler, weak=False)
211 try:
212 # Instance deletion.
213 person.delete()
214 self.assertEqual(data, [(Person, person), (Person, person)])
215 data[:] = []
216 # Cascade deletion.
217 book.delete()
218 self.assertEqual(
219 data,
220 [
221 (Page, book),
222 (Page, book),
223 (Book, book),
224 (Page, book),
225 (Page, book),
226 (Book, book),
227 ],
228 )
229 finally:
230 signals.pre_delete.disconnect(pre_delete_handler)
231 signals.post_delete.disconnect(post_delete_handler)
232
233 def test_delete_signals_origin_queryset(self):
234 data = []
235
236 def pre_delete_handler(signal, sender, instance, origin, **kwargs):
237 data.append((sender, origin))
238
239 def post_delete_handler(signal, sender, instance, origin, **kwargs):
240 data.append((sender, origin))
241
242 Person.objects.create(first_name="John", last_name="Smith")
243 book = Book.objects.create(name="Rayuela")
244 Page.objects.create(text="Page 1", book=book)
245 Page.objects.create(text="Page 2", book=book)
246
247 signals.pre_delete.connect(pre_delete_handler, weak=False)
248 signals.post_delete.connect(post_delete_handler, weak=False)
249 try:
250 # Queryset deletion.
251 qs = Person.objects.all()
252 qs.delete()
253 self.assertEqual(data, [(Person, qs), (Person, qs)])
254 data[:] = []
255 # Cascade deletion.
256 qs = Book.objects.all()
257 qs.delete()
258 self.assertEqual(
259 data,
260 [
261 (Page, qs),
262 (Page, qs),
263 (Book, qs),
264 (Page, qs),
265 (Page, qs),
266 (Book, qs),
267 ],
268 )
269 finally:
270 signals.pre_delete.disconnect(pre_delete_handler)
271 signals.post_delete.disconnect(post_delete_handler)
272
273 def test_decorators(self):
274 data = []
275
276 @receiver(signals.pre_save, weak=False)
277 def decorated_handler(signal, sender, instance, **kwargs):
278 data.append(instance)
279
280 @receiver(signals.pre_save, sender=Car, weak=False)
281 def decorated_handler_with_sender_arg(signal, sender, instance, **kwargs):
282 data.append(instance)
283
284 try:
285 c1 = Car.objects.create(make="Volkswagen", model="Passat")
286 self.assertEqual(data, [c1, c1])
287 finally:
288 signals.pre_save.disconnect(decorated_handler)
289 signals.pre_save.disconnect(decorated_handler_with_sender_arg, sender=Car)
290
291 def test_save_and_delete_signals_with_m2m(self):
292 data = []
293
294 def pre_save_handler(signal, sender, instance, **kwargs):
295 data.append("pre_save signal, %s" % instance)
296 if kwargs.get("raw"):
297 data.append("Is raw")
298
299 def post_save_handler(signal, sender, instance, **kwargs):
300 data.append("post_save signal, %s" % instance)
301 if "created" in kwargs:
302 if kwargs["created"]:
303 data.append("Is created")
304 else:
305 data.append("Is updated")
306 if kwargs.get("raw"):
307 data.append("Is raw")
308
309 def pre_delete_handler(signal, sender, instance, **kwargs):
310 data.append("pre_delete signal, %s" % instance)
311 data.append("instance.id is not None: %s" % (instance.id is not None))
312
313 def post_delete_handler(signal, sender, instance, **kwargs):
314 data.append("post_delete signal, %s" % instance)
315 data.append("instance.id is not None: %s" % (instance.id is not None))
316
317 signals.pre_save.connect(pre_save_handler, weak=False)
318 signals.post_save.connect(post_save_handler, weak=False)
319 signals.pre_delete.connect(pre_delete_handler, weak=False)
320 signals.post_delete.connect(post_delete_handler, weak=False)
321 try:
322 a1 = Author.objects.create(name="Neal Stephenson")
323 self.assertEqual(
324 data,
325 [
326 "pre_save signal, Neal Stephenson",
327 "post_save signal, Neal Stephenson",
328 "Is created",
329 ],
330 )
331 data[:] = []
332
333 b1 = Book.objects.create(name="Snow Crash")
334 self.assertEqual(
335 data,
336 [
337 "pre_save signal, Snow Crash",
338 "post_save signal, Snow Crash",
339 "Is created",
340 ],
341 )
342 data[:] = []
343
344 # Assigning and removing to/from m2m shouldn't generate an m2m signal.
345 b1.authors.set([a1])
346 self.assertEqual(data, [])
347 b1.authors.set([])
348 self.assertEqual(data, [])
349 finally:
350 signals.pre_save.disconnect(pre_save_handler)
351 signals.post_save.disconnect(post_save_handler)
352 signals.pre_delete.disconnect(pre_delete_handler)
353 signals.post_delete.disconnect(post_delete_handler)
354
355 def test_disconnect_in_dispatch(self):
356 """
357 Signals that disconnect when being called don't mess future
358 dispatching.
359 """
360
361 class Handler:
362 def __init__(self, param):
363 self.param = param
364 self._run = False
365
366 def __call__(self, signal, sender, **kwargs):
367 self._run = True
368 signal.disconnect(receiver=self, sender=sender)
369
370 a, b = Handler(1), Handler(2)
371 signals.post_save.connect(a, sender=Person, weak=False)
372 signals.post_save.connect(b, sender=Person, weak=False)
373 Person.objects.create(first_name="John", last_name="Smith")
374
375 self.assertTrue(a._run)
376 self.assertTrue(b._run)
377 self.assertEqual(signals.post_save.receivers, [])
378
379 @mock.patch("weakref.ref")
380 def test_lazy_model_signal(self, ref):
381 def callback(sender, args, **kwargs):
382 pass
383
384 signals.pre_init.connect(callback)
385 signals.pre_init.disconnect(callback)
386 self.assertTrue(ref.called)
387 ref.reset_mock()
388
389 signals.pre_init.connect(callback, weak=False)
390 signals.pre_init.disconnect(callback)
391 ref.assert_not_called()
392
393 @isolate_apps("signals", kwarg_name="apps")
394 def test_disconnect_model(self, apps):
395 received = []
396
397 def receiver(**kwargs):
398 received.append(kwargs)
399
400 class Created(models.Model):
401 pass
402
403 signals.post_init.connect(receiver, sender=Created, apps=apps)
404 try:
405 self.assertIs(
406 signals.post_init.disconnect(receiver, sender=Created, apps=apps),
407 True,
408 )
409 self.assertIs(
410 signals.post_init.disconnect(receiver, sender=Created, apps=apps),
411 False,
412 )
413 Created()
414 self.assertEqual(received, [])
415 finally:
416 signals.post_init.disconnect(receiver, sender=Created)
417
418
419 class LazyModelRefTests(BaseSignalSetup, SimpleTestCase):
420 def setUp(self):
421 super().setUp()
422 self.received = []
423
424 def receiver(self, **kwargs):
425 self.received.append(kwargs)
426
427 def test_invalid_sender_model_name(self):
428 msg = (
429 "Invalid model reference 'invalid'. String model references must be of the "
430 "form 'app_label.ModelName'."
431 )
432 with self.assertRaisesMessage(ValueError, msg):
433 signals.post_init.connect(self.receiver, sender="invalid")
434
435 def test_already_loaded_model(self):
436 signals.post_init.connect(self.receiver, sender="signals.Book", weak=False)
437 try:
438 instance = Book()
439 self.assertEqual(
440 self.received,
441 [{"signal": signals.post_init, "sender": Book, "instance": instance}],
442 )
443 finally:
444 signals.post_init.disconnect(self.receiver, sender=Book)
445
446 @isolate_apps("signals", kwarg_name="apps")
447 def test_not_loaded_model(self, apps):
448 signals.post_init.connect(
449 self.receiver, sender="signals.Created", weak=False, apps=apps
450 )
451
452 try:
453
454 class Created(models.Model):
455 pass
456
457 instance = Created()
458 self.assertEqual(
459 self.received,
460 [
461 {
462 "signal": signals.post_init,
463 "sender": Created,
464 "instance": instance,
465 }
466 ],
467 )
468 finally:
469 signals.post_init.disconnect(self.receiver, sender=Created)
470
471 @isolate_apps("signals", kwarg_name="apps")
472 def test_disconnect_registered_model(self, apps):
473 received = []
474
475 def receiver(**kwargs):
476 received.append(kwargs)
477
478 class Created(models.Model):
479 pass
480
481 signals.post_init.connect(receiver, sender="signals.Created", apps=apps)
482 try:
483 self.assertIsNone(
484 signals.post_init.disconnect(
485 receiver, sender="signals.Created", apps=apps
486 )
487 )
488 self.assertIsNone(
489 signals.post_init.disconnect(
490 receiver, sender="signals.Created", apps=apps
491 )
492 )
493 Created()
494 self.assertEqual(received, [])
495 finally:
496 signals.post_init.disconnect(receiver, sender="signals.Created")
497
498 @isolate_apps("signals", kwarg_name="apps")
499 def test_disconnect_unregistered_model(self, apps):
500 received = []
501
502 def receiver(**kwargs):
503 received.append(kwargs)
504
505 signals.post_init.connect(receiver, sender="signals.Created", apps=apps)
506 try:
507 self.assertIsNone(
508 signals.post_init.disconnect(
509 receiver, sender="signals.Created", apps=apps
510 )
511 )
512 self.assertIsNone(
513 signals.post_init.disconnect(
514 receiver, sender="signals.Created", apps=apps
515 )
516 )
517
518 class Created(models.Model):
519 pass
520
521 Created()
522 self.assertEqual(received, [])
523 finally:
524 signals.post_init.disconnect(receiver, sender="signals.Created")
525
526 def test_register_model_class_senders_immediately(self):
527 """
528 Model signals registered with model classes as senders don't use the
529 Apps.lazy_model_operation() mechanism.
530 """
531 # Book isn't registered with apps2, so it will linger in
532 # apps2._pending_operations if ModelSignal does the wrong thing.
533 apps2 = Apps()
534 signals.post_init.connect(self.receiver, sender=Book, apps=apps2)
535 self.assertEqual(list(apps2._pending_operations), [])
536
537
538 class SyncHandler:
539 param = 0
540
541 def __call__(self, **kwargs):
542 self.param += 1
543 return self.param
544
545
546 class AsyncHandler:
547 param = 0
548
549 def __init__(self):
550 markcoroutinefunction(self)
551
552 async def __call__(self, **kwargs):
553 self.param += 1
554 return self.param
555
556
557 class AsyncReceiversTests(SimpleTestCase):
558 async def test_asend(self):
559 sync_handler = SyncHandler()
560 async_handler = AsyncHandler()
561 signal = dispatch.Signal()
562 signal.connect(sync_handler)
563 signal.connect(async_handler)
564 result = await signal.asend(self.__class__)
565 self.assertEqual(result, [(sync_handler, 1), (async_handler, 1)])
566
567 def test_send(self):
568 sync_handler = SyncHandler()
569 async_handler = AsyncHandler()
570 signal = dispatch.Signal()
571 signal.connect(sync_handler)
572 signal.connect(async_handler)
573 result = signal.send(self.__class__)
574 self.assertEqual(result, [(sync_handler, 1), (async_handler, 1)])
575
576 def test_send_robust(self):
577 class ReceiverException(Exception):
578 pass
579
580 receiver_exception = ReceiverException()
581
582 async def failing_async_handler(**kwargs):
583 raise receiver_exception
584
585 sync_handler = SyncHandler()
586 async_handler = AsyncHandler()
587 signal = dispatch.Signal()
588 signal.connect(failing_async_handler)
589 signal.connect(async_handler)
590 signal.connect(sync_handler)
591 result = signal.send_robust(self.__class__)
592 # The ordering here is different than the order that signals were
593 # connected in.
594 self.assertEqual(
595 result,
596 [
597 (sync_handler, 1),
598 (failing_async_handler, receiver_exception),
599 (async_handler, 1),
600 ],
601 )
602
603 async def test_asend_robust(self):
604 class ReceiverException(Exception):
605 pass
606
607 receiver_exception = ReceiverException()
608
609 async def failing_async_handler(**kwargs):
610 raise receiver_exception
611
612 sync_handler = SyncHandler()
613 async_handler = AsyncHandler()
614 signal = dispatch.Signal()
615 signal.connect(failing_async_handler)
616 signal.connect(async_handler)
617 signal.connect(sync_handler)
618 result = await signal.asend_robust(self.__class__)
619 # The ordering here is different than the order that signals were
620 # connected in.
621 self.assertEqual(
622 result,
623 [
624 (sync_handler, 1),
625 (failing_async_handler, receiver_exception),
626 (async_handler, 1),
627 ],
628 )
629
630 async def test_asend_only_async_receivers(self):
631 async_handler = AsyncHandler()
632 signal = dispatch.Signal()
633 signal.connect(async_handler)
634
635 result = await signal.asend(self.__class__)
636 self.assertEqual(result, [(async_handler, 1)])
637
638 async def test_asend_robust_only_async_receivers(self):
639 async_handler = AsyncHandler()
640 signal = dispatch.Signal()
641 signal.connect(async_handler)
642
643 result = await signal.asend_robust(self.__class__)
644 self.assertEqual(result, [(async_handler, 1)])