Debian Codegraph @

tests/test_fields/test_field_tracker.py

raw
1 from __future__ import annotations
2
3 from typing import TYPE_CHECKING, Any
4
5 from django.core.cache import cache
6 from django.core.exceptions import FieldError
7 from django.db import models
8 from django.db.models.fields.files import FieldFile
9 from django.test import TestCase
10
11 from model_utils import FieldTracker
12 from model_utils.tracker import DescriptorWrapper, FieldInstanceTracker
13 from tests.models import (
14 InheritedModelTracked,
15 InheritedTracked,
16 InheritedTrackedFK,
17 ModelTracked,
18 ModelTrackedFK,
19 ModelTrackedMultiple,
20 ModelTrackedNotDefault,
21 Tracked,
22 TrackedAbstract,
23 TrackedFileField,
24 TrackedFK,
25 TrackedMultiple,
26 TrackedNonFieldAttr,
27 TrackedNotDefault,
28 TrackerTimeStamped,
29 )
30
31 if TYPE_CHECKING:
32 MixinBase = TestCase
33 else:
34 MixinBase = object
35
36
37 class FieldTrackerMixin(MixinBase):
38
39 tracker: FieldInstanceTracker
40 instance: models.Model
41
42 def assertHasChanged(self, *, tracker: FieldInstanceTracker | None = None, **kwargs: Any) -> None:
43 if tracker is None:
44 tracker = self.tracker
45 for field, value in kwargs.items():
46 if value is None:
47 with self.assertRaises(FieldError):
48 tracker.has_changed(field)
49 else:
50 self.assertEqual(tracker.has_changed(field), value)
51
52 def assertPrevious(self, *, tracker: FieldInstanceTracker | None = None, **kwargs: Any) -> None:
53 if tracker is None:
54 tracker = self.tracker
55 for field, value in kwargs.items():
56 self.assertEqual(tracker.previous(field), value)
57
58 def assertChanged(self, *, tracker: FieldInstanceTracker | None = None, **kwargs: Any) -> None:
59 if tracker is None:
60 tracker = self.tracker
61 self.assertEqual(tracker.changed(), kwargs)
62
63 def assertCurrent(self, *, tracker: FieldInstanceTracker | None = None, **kwargs: Any) -> None:
64 if tracker is None:
65 tracker = self.tracker
66 self.assertEqual(tracker.current(), kwargs)
67
68 def update_instance(self, **kwargs: Any) -> None:
69 for field, value in kwargs.items():
70 setattr(self.instance, field, value)
71 self.instance.save()
72
73
74 class FieldTrackerCommonMixin(FieldTrackerMixin):
75
76 instance: (
77 Tracked | TrackedNotDefault | TrackedMultiple
78 | ModelTracked | ModelTrackedNotDefault | ModelTrackedMultiple
79 | TrackedAbstract
80 )
81
82 def test_pre_save_previous(self) -> None:
83 self.assertPrevious(name=None, number=None)
84 self.instance.name = 'new age'
85 self.instance.number = 8
86 self.assertPrevious(name=None, number=None)
87
88
89 class FieldTrackerTests(FieldTrackerCommonMixin, TestCase):
90
91 tracked_class: type[Tracked | ModelTracked | TrackedAbstract] = Tracked
92 instance: Tracked | ModelTracked | TrackedAbstract
93
94 def setUp(self) -> None:
95 self.instance = self.tracked_class()
96 self.tracker = self.instance.tracker
97
98 def test_descriptor(self) -> None:
99 tracker = self.tracked_class.tracker
100 self.assertTrue(isinstance(tracker, FieldTracker))
101
102 def test_pre_save_changed(self) -> None:
103 self.assertChanged(name=None)
104 self.instance.name = 'new age'
105 self.assertChanged(name=None)
106 self.instance.number = 8
107 self.assertChanged(name=None, number=None)
108 self.instance.name = ''
109 self.assertChanged(name=None, number=None)
110 self.instance.mutable = [1, 2, 3]
111 self.assertChanged(name=None, number=None, mutable=None)
112
113 def test_pre_save_has_changed(self) -> None:
114 self.assertHasChanged(name=True, number=False, mutable=False)
115 self.instance.name = 'new age'
116 self.assertHasChanged(name=True, number=False, mutable=False)
117 self.instance.number = 7
118 self.assertHasChanged(name=True, number=True)
119 self.instance.mutable = [1, 2, 3]
120 self.assertHasChanged(name=True, number=True, mutable=True)
121
122 def test_save_with_args(self) -> None:
123 self.instance.number = 1
124 self.instance.save(False, False, None, None)
125 self.assertChanged()
126
127 def test_first_save(self) -> None:
128 self.assertHasChanged(name=True, number=False, mutable=False)
129 self.assertPrevious(name=None, number=None, mutable=None)
130 self.assertCurrent(name='', number=None, id=None, mutable=None)
131 self.assertChanged(name=None)
132 self.instance.name = 'retro'
133 self.instance.number = 4
134 self.instance.mutable = [1, 2, 3]
135 self.assertHasChanged(name=True, number=True, mutable=True)
136 self.assertPrevious(name=None, number=None, mutable=None)
137 self.assertCurrent(name='retro', number=4, id=None, mutable=[1, 2, 3])
138 self.assertChanged(name=None, number=None, mutable=None)
139
140 self.instance.save(update_fields=[])
141 self.assertHasChanged(name=True, number=True, mutable=True)
142 self.assertPrevious(name=None, number=None, mutable=None)
143 self.assertCurrent(name='retro', number=4, id=None, mutable=[1, 2, 3])
144 self.assertChanged(name=None, number=None, mutable=None)
145 with self.assertRaises(ValueError):
146 self.instance.save(update_fields=['number'])
147
148 def test_post_save_has_changed(self) -> None:
149 self.update_instance(name='retro', number=4, mutable=[1, 2, 3])
150 self.assertHasChanged(name=False, number=False, mutable=False)
151 self.instance.name = 'new age'
152 self.assertHasChanged(name=True, number=False)
153 self.instance.number = 8
154 self.assertHasChanged(name=True, number=True)
155 self.instance.mutable[1] = 4
156 self.assertHasChanged(name=True, number=True, mutable=True)
157 self.instance.name = 'retro'
158 self.assertHasChanged(name=False, number=True, mutable=True)
159
160 def test_post_save_previous(self) -> None:
161 self.update_instance(name='retro', number=4, mutable=[1, 2, 3])
162 self.instance.name = 'new age'
163 self.assertPrevious(name='retro', number=4, mutable=[1, 2, 3])
164 self.instance.mutable[1] = 4
165 self.assertPrevious(name='retro', number=4, mutable=[1, 2, 3])
166
167 def test_post_save_changed(self) -> None:
168 self.update_instance(name='retro', number=4, mutable=[1, 2, 3])
169 self.assertChanged()
170 self.instance.name = 'new age'
171 self.assertChanged(name='retro')
172 self.instance.number = 8
173 self.assertChanged(name='retro', number=4)
174 self.instance.name = 'retro'
175 self.assertChanged(number=4)
176 self.instance.mutable[1] = 4
177 self.assertChanged(number=4, mutable=[1, 2, 3])
178 self.instance.mutable = [1, 2, 3]
179 self.assertChanged(number=4)
180
181 def test_current(self) -> None:
182 self.assertCurrent(id=None, name='', number=None, mutable=None)
183 self.instance.name = 'new age'
184 self.assertCurrent(id=None, name='new age', number=None, mutable=None)
185 self.instance.number = 8
186 self.assertCurrent(id=None, name='new age', number=8, mutable=None)
187 self.instance.mutable = [1, 2, 3]
188 self.assertCurrent(id=None, name='new age', number=8, mutable=[1, 2, 3])
189 self.instance.mutable[1] = 4
190 self.assertCurrent(id=None, name='new age', number=8, mutable=[1, 4, 3])
191 self.instance.save()
192 self.assertCurrent(id=self.instance.id, name='new age', number=8, mutable=[1, 4, 3])
193
194 def test_update_fields(self) -> None:
195 self.update_instance(name='retro', number=4, mutable=[1, 2, 3])
196 self.assertChanged()
197 self.instance.name = 'new age'
198 self.instance.number = 8
199 self.instance.mutable = [4, 5, 6]
200 self.assertChanged(name='retro', number=4, mutable=[1, 2, 3])
201 self.instance.save(update_fields=[])
202 self.assertChanged(name='retro', number=4, mutable=[1, 2, 3])
203 self.instance.save(update_fields=['name'])
204 in_db = self.tracked_class.objects.get(id=self.instance.id)
205 self.assertEqual(in_db.name, self.instance.name)
206 self.assertNotEqual(in_db.number, self.instance.number)
207 self.assertChanged(number=4, mutable=[1, 2, 3])
208 self.instance.save(update_fields=['number'])
209 self.assertChanged(mutable=[1, 2, 3])
210 self.instance.save(update_fields=['mutable'])
211 self.assertChanged()
212 in_db = self.tracked_class.objects.get(id=self.instance.id)
213 self.assertEqual(in_db.name, self.instance.name)
214 self.assertEqual(in_db.number, self.instance.number)
215 self.assertEqual(in_db.mutable, self.instance.mutable)
216
217 def test_refresh_from_db(self) -> None:
218 self.update_instance(name='retro', number=4, mutable=[1, 2, 3])
219 self.tracked_class.objects.filter(pk=self.instance.pk).update(
220 name='new age', number=8, mutable=[3, 2, 1])
221 self.assertChanged()
222 self.instance.name = 'like in db'
223 self.instance.number = 8
224 self.instance.mutable = [3, 2, 1]
225 self.assertChanged(name='retro', number=4, mutable=[1, 2, 3])
226 self.instance.refresh_from_db(fields=('name',))
227 self.assertChanged(number=4, mutable=[1, 2, 3])
228 self.instance.refresh_from_db(fields={'mutable'})
229 self.assertChanged(number=4)
230 self.instance.refresh_from_db()
231 self.assertChanged()
232
233 def test_with_deferred(self) -> None:
234 self.instance.name = 'new age'
235 self.instance.number = 1
236 self.instance.save()
237 item = self.tracked_class.objects.only('name').first()
238 assert item is not None
239 self.assertTrue(item.get_deferred_fields())
240
241 # has_changed() returns False for deferred fields, without un-deferring them.
242 # Use an if because ModelTracked doesn't support has_changed() in this case.
243 if self.tracked_class == Tracked:
244 self.assertFalse(item.tracker.has_changed('number'))
245 self.assertIsInstance(item.__class__.number, DescriptorWrapper)
246 self.assertTrue('number' in item.get_deferred_fields())
247
248 # previous() un-defers field and returns value
249 self.assertEqual(item.tracker.previous('number'), 1)
250 self.assertNotIn('number', item.get_deferred_fields())
251
252 # examining a deferred field un-defers it
253 item = self.tracked_class.objects.only('name').first()
254 assert item is not None
255 self.assertEqual(item.number, 1)
256 self.assertTrue('number' not in item.get_deferred_fields())
257 self.assertEqual(item.tracker.previous('number'), 1)
258 self.assertFalse(item.tracker.has_changed('number'))
259
260 # has_changed() returns correct values after deferred field is examined
261 self.assertFalse(item.tracker.has_changed('number'))
262 item.number = 2
263 self.assertTrue(item.tracker.has_changed('number'))
264
265 # previous() returns correct value after deferred field is examined
266 self.assertEqual(item.tracker.previous('number'), 1)
267
268 # assigning to a deferred field un-defers it
269 # Use an if because ModelTracked doesn't handle this case.
270 if self.tracked_class == Tracked:
271
272 item = self.tracked_class.objects.only('name').first()
273 assert item is not None
274 item.number = 2
275
276 # previous() fetches correct value from database after deferred field is assigned
277 self.assertEqual(item.tracker.previous('number'), 1)
278
279 # database fetch of previous() value doesn't affect current value
280 self.assertEqual(item.number, 2)
281
282 # has_changed() returns correct values after deferred field is assigned
283 self.assertTrue(item.tracker.has_changed('number'))
284 item.number = 1
285 self.assertFalse(item.tracker.has_changed('number'))
286
287
288 class FieldTrackerMultipleInstancesTests(TestCase):
289
290 def test_with_deferred_fields_access_multiple(self) -> None:
291 Tracked.objects.create(pk=1, name='foo', number=1)
292 Tracked.objects.create(pk=2, name='bar', number=2)
293
294 queryset = Tracked.objects.only('id')
295
296 for instance in queryset:
297 instance.name
298
299
300 class FieldTrackedModelCustomTests(FieldTrackerCommonMixin, TestCase):
301
302 tracked_class: type[TrackedNotDefault | ModelTrackedNotDefault] = TrackedNotDefault
303 instance: TrackedNotDefault | ModelTrackedNotDefault
304
305 def setUp(self) -> None:
306 self.instance = self.tracked_class()
307 self.tracker = self.instance.name_tracker
308
309 def test_pre_save_changed(self) -> None:
310 self.assertChanged(name=None)
311 self.instance.name = 'new age'
312 self.assertChanged(name=None)
313 self.instance.number = 8
314 self.assertChanged(name=None)
315 self.instance.name = ''
316 self.assertChanged(name=None)
317
318 def test_first_save(self) -> None:
319 self.assertHasChanged(name=True, number=None)
320 self.assertPrevious(name=None, number=None)
321 self.assertCurrent(name='')
322 self.assertChanged(name=None)
323 self.instance.name = 'retro'
324 self.instance.number = 4
325 self.assertHasChanged(name=True, number=None)
326 self.assertPrevious(name=None, number=None)
327 self.assertCurrent(name='retro')
328 self.assertChanged(name=None)
329
330 def test_pre_save_has_changed(self) -> None:
331 self.assertHasChanged(name=True, number=None)
332 self.instance.name = 'new age'
333 self.assertHasChanged(name=True, number=None)
334 self.instance.number = 7
335 self.assertHasChanged(name=True, number=None)
336
337 def test_post_save_has_changed(self) -> None:
338 self.update_instance(name='retro', number=4)
339 self.assertHasChanged(name=False, number=None)
340 self.instance.name = 'new age'
341 self.assertHasChanged(name=True, number=None)
342 self.instance.number = 8
343 self.assertHasChanged(name=True, number=None)
344 self.instance.name = 'retro'
345 self.assertHasChanged(name=False, number=None)
346
347 def test_post_save_previous(self) -> None:
348 self.update_instance(name='retro', number=4)
349 self.instance.name = 'new age'
350 self.assertPrevious(name='retro', number=None)
351
352 def test_post_save_changed(self) -> None:
353 self.update_instance(name='retro', number=4)
354 self.assertChanged()
355 self.instance.name = 'new age'
356 self.assertChanged(name='retro')
357 self.instance.number = 8
358 self.assertChanged(name='retro')
359 self.instance.name = 'retro'
360 self.assertChanged()
361
362 def test_current(self) -> None:
363 self.assertCurrent(name='')
364 self.instance.name = 'new age'
365 self.assertCurrent(name='new age')
366 self.instance.number = 8
367 self.assertCurrent(name='new age')
368 self.instance.save()
369 self.assertCurrent(name='new age')
370
371 def test_update_fields(self) -> None:
372 self.update_instance(name='retro', number=4)
373 self.assertChanged()
374 self.instance.name = 'new age'
375 self.instance.number = 8
376 self.instance.save(update_fields=['name', 'number'])
377 self.assertChanged()
378
379
380 class FieldTrackedModelAttributeTests(FieldTrackerMixin, TestCase):
381
382 tracked_class = TrackedNonFieldAttr
383 instance: TrackedNonFieldAttr
384
385 def setUp(self) -> None:
386 self.instance = self.tracked_class()
387 self.tracker = self.instance.tracker
388
389 def test_previous(self) -> None:
390 self.assertPrevious(rounded=None)
391 self.instance.number = 7.5
392 self.assertPrevious(rounded=None)
393 self.instance.save()
394 self.assertPrevious(rounded=8)
395 self.instance.number = 7.2
396 self.assertPrevious(rounded=8)
397 self.instance.save()
398 self.assertPrevious(rounded=7)
399
400 def test_has_changed(self) -> None:
401 self.assertHasChanged(rounded=False)
402 self.instance.number = 7.5
403 self.assertHasChanged(rounded=True)
404 self.instance.save()
405 self.assertHasChanged(rounded=False)
406 self.instance.number = 7.2
407 self.assertHasChanged(rounded=True)
408 self.instance.number = 7.8
409 self.assertHasChanged(rounded=False)
410
411 def test_changed(self) -> None:
412 self.assertChanged()
413 self.instance.number = 7.5
414 self.assertPrevious(rounded=None)
415 self.instance.save()
416 self.assertPrevious()
417 self.instance.number = 7.8
418 self.assertPrevious()
419 self.instance.number = 7.2
420 self.assertPrevious(rounded=8)
421 self.instance.save()
422 self.assertPrevious()
423
424 def test_current(self) -> None:
425 self.assertCurrent(rounded=None)
426 self.instance.number = 7.5
427 self.assertCurrent(rounded=8)
428 self.instance.save()
429 self.assertCurrent(rounded=8)
430
431
432 class FieldTrackedModelMultiTests(FieldTrackerCommonMixin, TestCase):
433
434 tracked_class: type[TrackedMultiple | ModelTrackedMultiple] = TrackedMultiple
435 instance: TrackedMultiple | ModelTrackedMultiple
436
437 def setUp(self) -> None:
438 self.instance = self.tracked_class()
439 self.trackers = [self.instance.name_tracker,
440 self.instance.number_tracker]
441
442 def test_pre_save_changed(self) -> None:
443 self.tracker = self.instance.name_tracker
444 self.assertChanged(name=None)
445 self.instance.name = 'new age'
446 self.assertChanged(name=None)
447 self.instance.number = 8
448 self.assertChanged(name=None)
449 self.instance.name = ''
450 self.assertChanged(name=None)
451 self.tracker = self.instance.number_tracker
452 self.assertChanged(number=None)
453 self.instance.name = 'new age'
454 self.assertChanged(number=None)
455 self.instance.number = 8
456 self.assertChanged(number=None)
457
458 def test_pre_save_has_changed(self) -> None:
459 self.tracker = self.instance.name_tracker
460 self.assertHasChanged(name=True, number=None)
461 self.instance.name = 'new age'
462 self.assertHasChanged(name=True, number=None)
463 self.tracker = self.instance.number_tracker
464 self.assertHasChanged(name=None, number=False)
465 self.instance.name = 'new age'
466 self.assertHasChanged(name=None, number=False)
467
468 def test_pre_save_previous(self) -> None:
469 for tracker in self.trackers:
470 self.tracker = tracker
471 super().test_pre_save_previous()
472
473 def test_post_save_has_changed(self) -> None:
474 self.update_instance(name='retro', number=4)
475 self.assertHasChanged(tracker=self.trackers[0], name=False, number=None)
476 self.assertHasChanged(tracker=self.trackers[1], name=None, number=False)
477 self.instance.name = 'new age'
478 self.assertHasChanged(tracker=self.trackers[0], name=True, number=None)
479 self.assertHasChanged(tracker=self.trackers[1], name=None, number=False)
480 self.instance.number = 8
481 self.assertHasChanged(tracker=self.trackers[0], name=True, number=None)
482 self.assertHasChanged(tracker=self.trackers[1], name=None, number=True)
483 self.instance.name = 'retro'
484 self.instance.number = 4
485 self.assertHasChanged(tracker=self.trackers[0], name=False, number=None)
486 self.assertHasChanged(tracker=self.trackers[1], name=None, number=False)
487
488 def test_post_save_previous(self) -> None:
489 self.update_instance(name='retro', number=4)
490 self.instance.name = 'new age'
491 self.instance.number = 8
492 self.assertPrevious(tracker=self.trackers[0], name='retro', number=None)
493 self.assertPrevious(tracker=self.trackers[1], name=None, number=4)
494
495 def test_post_save_changed(self) -> None:
496 self.update_instance(name='retro', number=4)
497 self.assertChanged(tracker=self.trackers[0])
498 self.assertChanged(tracker=self.trackers[1])
499 self.instance.name = 'new age'
500 self.assertChanged(tracker=self.trackers[0], name='retro')
501 self.assertChanged(tracker=self.trackers[1])
502 self.instance.number = 8
503 self.assertChanged(tracker=self.trackers[0], name='retro')
504 self.assertChanged(tracker=self.trackers[1], number=4)
505 self.instance.name = 'retro'
506 self.instance.number = 4
507 self.assertChanged(tracker=self.trackers[0])
508 self.assertChanged(tracker=self.trackers[1])
509
510 def test_current(self) -> None:
511 self.assertCurrent(tracker=self.trackers[0], name='')
512 self.assertCurrent(tracker=self.trackers[1], number=None)
513 self.instance.name = 'new age'
514 self.assertCurrent(tracker=self.trackers[0], name='new age')
515 self.assertCurrent(tracker=self.trackers[1], number=None)
516 self.instance.number = 8
517 self.assertCurrent(tracker=self.trackers[0], name='new age')
518 self.assertCurrent(tracker=self.trackers[1], number=8)
519 self.instance.save()
520 self.assertCurrent(tracker=self.trackers[0], name='new age')
521 self.assertCurrent(tracker=self.trackers[1], number=8)
522
523
524 class FieldTrackerForeignKeyMixin(FieldTrackerMixin):
525
526 fk_class: type[Tracked | ModelTracked]
527 tracked_class: type[TrackedFK | ModelTrackedFK]
528 instance: TrackedFK | ModelTrackedFK
529
530 def setUp(self) -> None:
531 self.old_fk = self.fk_class.objects.create(number=8)
532 self.instance = self.tracked_class.objects.create(fk=self.old_fk) # type: ignore[misc]
533
534 def test_default(self) -> None:
535 self.tracker = self.instance.tracker
536 self.assertChanged()
537 self.assertPrevious()
538 self.assertCurrent(id=self.instance.id, fk_id=self.old_fk.id)
539 self.instance.fk = self.fk_class.objects.create(number=8) # type: ignore[assignment]
540 self.assertChanged(fk_id=self.old_fk.id)
541 self.assertPrevious(fk_id=self.old_fk.id)
542 self.assertCurrent(id=self.instance.id, fk_id=self.instance.fk_id)
543
544 def test_custom(self) -> None:
545 self.tracker = self.instance.custom_tracker
546 self.assertChanged()
547 self.assertPrevious()
548 self.assertCurrent(fk_id=self.old_fk.id)
549 self.instance.fk = self.fk_class.objects.create(number=8) # type: ignore[assignment]
550 self.assertChanged(fk_id=self.old_fk.id)
551 self.assertPrevious(fk_id=self.old_fk.id)
552 self.assertCurrent(fk_id=self.instance.fk_id)
553
554 def test_custom_without_id(self) -> None:
555 with self.assertNumQueries(1):
556 self.tracked_class.objects.get()
557 self.tracker = self.instance.custom_tracker_without_id
558 self.assertChanged()
559 self.assertPrevious()
560 self.assertCurrent(fk=self.old_fk.id)
561 self.instance.fk = self.fk_class.objects.create(number=8) # type: ignore[assignment]
562 self.assertChanged(fk=self.old_fk.id)
563 self.assertPrevious(fk=self.old_fk.id)
564 self.assertCurrent(fk=self.instance.fk_id)
565
566
567 class FieldTrackerForeignKeyTests(FieldTrackerForeignKeyMixin, TestCase):
568
569 fk_class = Tracked
570 tracked_class = TrackedFK
571
572
573 class FieldTrackerForeignKeyPrefetchRelatedTests(FieldTrackerMixin, TestCase):
574 """Test that using `prefetch_related` on a tracked field does not raise a ValueError."""
575
576 fk_class = Tracked
577 tracked_class = TrackedFK
578 instance: TrackedFK
579
580 def setUp(self) -> None:
581 model_tracked = self.fk_class.objects.create(name="", number=0)
582 self.instance = self.tracked_class.objects.create(fk=model_tracked)
583
584 def test_default(self) -> None:
585 self.tracker = self.instance.tracker
586 self.assertIsNotNone(list(self.tracked_class.objects.prefetch_related("fk")))
587
588 def test_custom(self) -> None:
589 self.tracker = self.instance.custom_tracker
590 self.assertIsNotNone(list(self.tracked_class.objects.prefetch_related("fk")))
591
592 def test_custom_without_id(self) -> None:
593 self.tracker = self.instance.custom_tracker_without_id
594 self.assertIsNotNone(list(self.tracked_class.objects.prefetch_related("fk")))
595
596
597 class FieldTrackerTimeStampedTests(FieldTrackerMixin, TestCase):
598
599 fk_class = Tracked
600 tracked_class = TrackerTimeStamped
601 instance: TrackerTimeStamped
602
603 def setUp(self) -> None:
604 self.instance = self.tracked_class.objects.create(name='old', number=1)
605 self.tracker = self.instance.tracker
606
607 def test_set_modified_on_save(self) -> None:
608 old_modified = self.instance.modified
609 self.instance.name = 'new'
610 self.instance.save()
611 self.assertGreater(self.instance.modified, old_modified)
612 self.assertChanged()
613
614 def test_set_modified_on_save_update_fields(self) -> None:
615 old_modified = self.instance.modified
616 self.instance.name = 'new'
617 self.instance.save(update_fields=('name',))
618 self.assertGreater(self.instance.modified, old_modified)
619 self.assertChanged()
620
621
622 class InheritedFieldTrackerTests(FieldTrackerTests):
623
624 tracked_class = InheritedTracked
625
626 def test_child_fields_not_tracked(self) -> None:
627 self.name2 = 'test'
628 self.assertEqual(self.tracker.previous('name2'), None)
629 self.assertRaises(FieldError, self.tracker.has_changed, 'name2')
630
631
632 class FieldTrackerInheritedForeignKeyTests(FieldTrackerForeignKeyTests):
633
634 tracked_class = InheritedTrackedFK
635
636
637 class FieldTrackerFileFieldTests(FieldTrackerMixin, TestCase):
638
639 tracked_class = TrackedFileField
640 instance: TrackedFileField
641
642 def setUp(self) -> None:
643 self.instance = self.tracked_class()
644 self.tracker = self.instance.tracker
645 self.some_file = 'something.txt'
646 self.another_file = 'another.txt'
647
648 def test_saved_data_without_instance(self) -> None:
649 """
650 Tests that instance won't get copied by the Field Tracker.
651
652 This change was introduced in Django 3.1 with
653 https://github.com/django/django/pull/12055
654 It results in a dramatic CPU and memory usage of FieldTracker on FileField and
655 its subclasses.
656 The pickling/deepcopying the instance is useless in the context of FieldTracker
657 thus we are skipping it.
658 """
659 self.assertEqual(self.tracker.saved_data, {})
660 self.update_instance(some_file=self.some_file)
661 field_file_copy = self.tracker.saved_data.get('some_file')
662 assert field_file_copy is not None
663 self.assertEqual(field_file_copy.__getstate__().get('instance'), None)
664 self.assertEqual(self.instance.some_file.instance, self.instance)
665 self.assertIsInstance(self.instance.some_file, FieldFile)
666
667 def test_pre_save_changed(self) -> None:
668 self.assertChanged(some_file=None)
669 self.instance.some_file = self.some_file
670 self.assertChanged(some_file=None)
671
672 def test_pre_save_has_changed(self) -> None:
673 self.assertHasChanged(some_file=True)
674 self.instance.some_file = self.some_file
675 self.assertHasChanged(some_file=True)
676
677 def test_pre_save_previous(self) -> None:
678 self.assertPrevious(some_file=None)
679 self.instance.some_file = self.some_file
680 self.assertPrevious(some_file=None)
681
682 def test_post_save_changed(self) -> None:
683 self.update_instance(some_file=self.some_file)
684 self.assertChanged()
685 previous_file = self.instance.some_file
686 self.instance.some_file = self.another_file
687 self.assertChanged(some_file=previous_file)
688 # test deferred file field
689 deferred_instance = self.tracked_class.objects.defer('some_file')[0]
690 deferred_instance.some_file # access field to fetch from database
691 self.assertChanged(tracker=deferred_instance.tracker)
692
693 previous_file = deferred_instance.some_file
694 deferred_instance.some_file = self.another_file
695 self.assertChanged(
696 tracker=deferred_instance.tracker,
697 some_file=previous_file,
698 )
699
700 def test_post_save_has_changed(self) -> None:
701 self.update_instance(some_file=self.some_file)
702 self.assertHasChanged(some_file=False)
703 self.instance.some_file = self.another_file
704 self.assertHasChanged(some_file=True)
705
706 # test deferred file field
707 deferred_instance = self.tracked_class.objects.defer('some_file')[0]
708 deferred_instance.some_file # access field to fetch from database
709 self.assertHasChanged(
710 tracker=deferred_instance.tracker,
711 some_file=False,
712 )
713
714 deferred_instance.some_file = self.another_file
715 self.assertHasChanged(
716 tracker=deferred_instance.tracker,
717 some_file=True,
718 )
719
720 def test_post_save_previous(self) -> None:
721 self.update_instance(some_file=self.some_file)
722 previous_file = self.instance.some_file
723 self.instance.some_file = self.another_file
724 self.assertPrevious(some_file=previous_file)
725
726 # test deferred file field
727 deferred_instance = self.tracked_class.objects.defer('some_file')[0]
728 deferred_instance.some_file # access field to fetch from database
729 self.assertPrevious(
730 tracker=deferred_instance.tracker,
731 some_file=previous_file,
732 )
733
734 deferred_instance.some_file = self.another_file
735 self.assertPrevious(
736 tracker=deferred_instance.tracker,
737 some_file=previous_file,
738 )
739
740 def test_current(self) -> None:
741 self.assertCurrent(some_file=self.instance.some_file, id=None)
742 self.instance.some_file = self.some_file
743 self.assertCurrent(some_file=self.instance.some_file, id=None)
744
745 # test deferred file field
746 self.instance.save()
747 deferred_instance = self.tracked_class.objects.defer('some_file')[0]
748 deferred_instance.some_file # access field to fetch from database
749 self.assertCurrent(
750 some_file=self.instance.some_file,
751 id=self.instance.id,
752 )
753
754 self.instance.some_file = self.another_file
755 self.assertCurrent(
756 some_file=self.instance.some_file,
757 id=self.instance.id,
758 )
759
760
761 class ModelTrackerTests(FieldTrackerTests):
762
763 tracked_class: type[ModelTracked | TrackedAbstract] = ModelTracked
764 instance: ModelTracked
765
766 def test_cache_compatible(self) -> None:
767 cache.set('key', self.instance)
768 instance = cache.get('key')
769 instance.number = 1
770 instance.name = 'cached'
771 instance.save()
772 self.assertChanged()
773 instance.number = 2
774 self.assertHasChanged(number=True)
775
776 def test_pre_save_changed(self) -> None:
777 self.assertChanged()
778 self.instance.name = 'new age'
779 self.assertChanged()
780 self.instance.number = 8
781 self.assertChanged()
782 self.instance.name = ''
783 self.assertChanged()
784 self.instance.mutable = [1, 2, 3]
785 self.assertChanged()
786
787 def test_first_save(self) -> None:
788 self.assertHasChanged(name=True, number=True, mutable=True)
789 self.assertPrevious(name=None, number=None, mutable=None)
790 self.assertCurrent(name='', number=None, id=None, mutable=None)
791 self.assertChanged()
792 self.instance.name = 'retro'
793 self.instance.number = 4
794 self.instance.mutable = [1, 2, 3]
795 self.assertHasChanged(name=True, number=True, mutable=True)
796 self.assertPrevious(name=None, number=None, mutable=None)
797 self.assertCurrent(name='retro', number=4, id=None, mutable=[1, 2, 3])
798 self.assertChanged()
799
800 self.instance.save(update_fields=[])
801 self.assertHasChanged(name=True, number=True, mutable=True)
802 self.assertPrevious(name=None, number=None, mutable=None)
803 self.assertCurrent(name='retro', number=4, id=None, mutable=[1, 2, 3])
804 self.assertChanged()
805 with self.assertRaises(ValueError):
806 self.instance.save(update_fields=['number'])
807
808 def test_pre_save_has_changed(self) -> None:
809 self.assertHasChanged(name=True, number=True)
810 self.instance.name = 'new age'
811 self.assertHasChanged(name=True, number=True)
812 self.instance.number = 7
813 self.assertHasChanged(name=True, number=True)
814
815
816 class ModelTrackedModelCustomTests(FieldTrackedModelCustomTests):
817
818 tracked_class = ModelTrackedNotDefault
819
820 def test_first_save(self) -> None:
821 self.assertHasChanged(name=True, number=True)
822 self.assertPrevious(name=None, number=None)
823 self.assertCurrent(name='')
824 self.assertChanged()
825 self.instance.name = 'retro'
826 self.instance.number = 4
827 self.assertHasChanged(name=True, number=True)
828 self.assertPrevious(name=None, number=None)
829 self.assertCurrent(name='retro')
830 self.assertChanged()
831
832 def test_pre_save_has_changed(self) -> None:
833 self.assertHasChanged(name=True, number=True)
834 self.instance.name = 'new age'
835 self.assertHasChanged(name=True, number=True)
836 self.instance.number = 7
837 self.assertHasChanged(name=True, number=True)
838
839 def test_pre_save_changed(self) -> None:
840 self.assertChanged()
841 self.instance.name = 'new age'
842 self.assertChanged()
843 self.instance.number = 8
844 self.assertChanged()
845 self.instance.name = ''
846 self.assertChanged()
847
848
849 class ModelTrackedModelMultiTests(FieldTrackedModelMultiTests):
850
851 tracked_class = ModelTrackedMultiple
852
853 def test_pre_save_has_changed(self) -> None:
854 self.tracker = self.instance.name_tracker
855 self.assertHasChanged(name=True, number=True)
856 self.instance.name = 'new age'
857 self.assertHasChanged(name=True, number=True)
858 self.tracker = self.instance.number_tracker
859 self.assertHasChanged(name=True, number=True)
860 self.instance.name = 'new age'
861 self.assertHasChanged(name=True, number=True)
862
863 def test_pre_save_changed(self) -> None:
864 self.tracker = self.instance.name_tracker
865 self.assertChanged()
866 self.instance.name = 'new age'
867 self.assertChanged()
868 self.instance.number = 8
869 self.assertChanged()
870 self.instance.name = ''
871 self.assertChanged()
872 self.tracker = self.instance.number_tracker
873 self.assertChanged()
874 self.instance.name = 'new age'
875 self.assertChanged()
876 self.instance.number = 8
877 self.assertChanged()
878
879
880 class ModelTrackerForeignKeyTests(FieldTrackerForeignKeyMixin, TestCase):
881
882 fk_class = ModelTracked
883 tracked_class = ModelTrackedFK
884 instance: ModelTrackedFK
885
886 def test_custom_without_id(self) -> None:
887 with self.assertNumQueries(2):
888 self.tracked_class.objects.get()
889 self.tracker = self.instance.custom_tracker_without_id
890 self.assertChanged()
891 self.assertPrevious()
892 self.assertCurrent(fk=self.old_fk)
893 self.instance.fk = self.fk_class.objects.create(number=8)
894 self.assertNotEqual(self.instance.fk, self.old_fk)
895 self.assertChanged(fk=self.old_fk)
896 self.assertPrevious(fk=self.old_fk)
897 self.assertCurrent(fk=self.instance.fk)
898
899
900 class InheritedModelTrackerTests(ModelTrackerTests):
901
902 tracked_class = InheritedModelTracked
903
904 def test_child_fields_not_tracked(self) -> None:
905 self.name2 = 'test'
906 self.assertEqual(self.tracker.previous('name2'), None)
907 self.assertTrue(self.tracker.has_changed('name2'))
908
909
910 class AbstractModelTrackerTests(ModelTrackerTests):
911
912 tracked_class = TrackedAbstract
913
914
915 class TrackerContextDecoratorTests(TestCase):
916
917 def setUp(self) -> None:
918 self.instance = Tracked.objects.create(number=1)
919 self.tracker = self.instance.tracker
920
921 def assertChanged(self, *fields: str) -> None:
922 for f in fields:
923 self.assertTrue(self.tracker.has_changed(f))
924
925 def assertNotChanged(self, *fields: str) -> None:
926 for f in fields:
927 self.assertFalse(self.tracker.has_changed(f))
928
929 def test_context_manager(self) -> None:
930 with self.tracker:
931 with self.tracker:
932 self.instance.name = 'new'
933
934 self.assertChanged('name')
935
936 self.assertChanged('name')
937
938 self.assertNotChanged('name')
939
940 def test_context_manager_fields(self) -> None:
941 with self.tracker('number'):
942 with self.tracker('number', 'name'):
943 self.instance.name = 'new'
944 self.instance.number += 1
945
946 self.assertChanged('name', 'number')
947
948 self.assertChanged('number')
949 self.assertNotChanged('name')
950
951 self.assertNotChanged('number', 'name')
952
953 def test_tracker_decorator(self) -> None:
954
955 @Tracked.tracker
956 def tracked_method(obj: Tracked) -> None:
957 obj.name = 'new'
958 self.assertChanged('name')
959
960 tracked_method(self.instance)
961
962 self.assertNotChanged('name')
963
964 def test_tracker_decorator_fields(self) -> None:
965
966 @Tracked.tracker(fields=['name'])
967 def tracked_method(obj: Tracked) -> None:
968 obj.name = 'new'
969 obj.number += 1
970 self.assertChanged('name', 'number')
971
972 tracked_method(self.instance)
973
974 self.assertChanged('number')
975 self.assertNotChanged('name')
976
977 def test_tracker_context_with_save(self) -> None:
978
979 with self.tracker:
980 self.instance.name = 'new'
981 self.instance.save()
982
983 self.assertChanged('name')
984
985 self.assertNotChanged('name')