From 23f1811b9dc83baf1b60c5ecf2afe74bbda513f7 Mon Sep 17 00:00:00 2001 From: Maarten ter Huurne Date: Wed, 22 Mar 2023 18:50:18 +0100 Subject: [PATCH] Annotate return type of test methods --- tests/test_choices.py | 100 ++++++------ tests/test_fields/test_field_tracker.py | 150 +++++++++--------- tests/test_fields/test_monitor_field.py | 40 ++--- tests/test_fields/test_split_field.py | 28 ++-- tests/test_fields/test_status_field.py | 10 +- tests/test_fields/test_urlsafe_token_field.py | 24 +-- tests/test_fields/test_uuid_field.py | 16 +- tests/test_inheritance_iterable.py | 2 +- .../test_managers/test_inheritance_manager.py | 96 +++++------ tests/test_managers/test_join_manager.py | 10 +- tests/test_managers/test_query_manager.py | 8 +- .../test_managers/test_softdelete_manager.py | 8 +- tests/test_managers/test_status_manager.py | 4 +- tests/test_miscellaneous.py | 10 +- tests/test_models/test_deferred_fields.py | 6 +- tests/test_models/test_softdeletable_model.py | 14 +- tests/test_models/test_status_model.py | 14 +- tests/test_models/test_timeframed_model.py | 16 +- tests/test_models/test_timestamped_model.py | 24 +-- tests/test_models/test_uuid_model.py | 4 +- 20 files changed, 295 insertions(+), 289 deletions(-) diff --git a/tests/test_choices.py b/tests/test_choices.py index 8916e97..d653cd7 100644 --- a/tests/test_choices.py +++ b/tests/test_choices.py @@ -6,61 +6,61 @@ from model_utils import Choices class ChoicesTests(TestCase): - def setUp(self): + def setUp(self) -> None: self.STATUS = Choices('DRAFT', 'PUBLISHED') - def test_getattr(self): + def test_getattr(self) -> None: self.assertEqual(self.STATUS.DRAFT, 'DRAFT') - def test_indexing(self): + def test_indexing(self) -> None: self.assertEqual(self.STATUS['PUBLISHED'], 'PUBLISHED') - def test_iteration(self): + def test_iteration(self) -> None: self.assertEqual(tuple(self.STATUS), (('DRAFT', 'DRAFT'), ('PUBLISHED', 'PUBLISHED'))) - def test_reversed(self): + def test_reversed(self) -> None: self.assertEqual(tuple(reversed(self.STATUS)), (('PUBLISHED', 'PUBLISHED'), ('DRAFT', 'DRAFT'))) - def test_len(self): + def test_len(self) -> None: self.assertEqual(len(self.STATUS), 2) - def test_repr(self): + def test_repr(self) -> None: self.assertEqual(repr(self.STATUS), "Choices" + repr(( ('DRAFT', 'DRAFT', 'DRAFT'), ('PUBLISHED', 'PUBLISHED', 'PUBLISHED'), ))) - def test_wrong_length_tuple(self): + def test_wrong_length_tuple(self) -> None: with self.assertRaises(ValueError): Choices(('a',)) - def test_contains_value(self): + def test_contains_value(self) -> None: self.assertTrue('PUBLISHED' in self.STATUS) self.assertTrue('DRAFT' in self.STATUS) - def test_doesnt_contain_value(self): + def test_doesnt_contain_value(self) -> None: self.assertFalse('UNPUBLISHED' in self.STATUS) - def test_deepcopy(self): + def test_deepcopy(self) -> None: import copy self.assertEqual(list(self.STATUS), list(copy.deepcopy(self.STATUS))) - def test_equality(self): + def test_equality(self) -> None: self.assertEqual(self.STATUS, Choices('DRAFT', 'PUBLISHED')) - def test_inequality(self): + def test_inequality(self) -> None: self.assertNotEqual(self.STATUS, ['DRAFT', 'PUBLISHED']) self.assertNotEqual(self.STATUS, Choices('DRAFT')) - def test_composability(self): + def test_composability(self) -> None: self.assertEqual(Choices('DRAFT') + Choices('PUBLISHED'), self.STATUS) self.assertEqual(Choices('DRAFT') + ('PUBLISHED',), self.STATUS) self.assertEqual(('DRAFT',) + Choices('PUBLISHED'), self.STATUS) - def test_option_groups(self): + def test_option_groups(self) -> None: c = Choices(('group a', ['one', 'two']), ['group b', ('three',)]) self.assertEqual( list(c), @@ -72,47 +72,47 @@ class ChoicesTests(TestCase): class LabelChoicesTests(ChoicesTests): - def setUp(self): + def setUp(self) -> None: self.STATUS = Choices( ('DRAFT', 'is draft'), ('PUBLISHED', 'is published'), 'DELETED', ) - def test_iteration(self): + def test_iteration(self) -> None: self.assertEqual(tuple(self.STATUS), ( ('DRAFT', 'is draft'), ('PUBLISHED', 'is published'), ('DELETED', 'DELETED'), )) - def test_reversed(self): + def test_reversed(self) -> None: self.assertEqual(tuple(reversed(self.STATUS)), ( ('DELETED', 'DELETED'), ('PUBLISHED', 'is published'), ('DRAFT', 'is draft'), )) - def test_indexing(self): + def test_indexing(self) -> None: self.assertEqual(self.STATUS['PUBLISHED'], 'is published') - def test_default(self): + def test_default(self) -> None: self.assertEqual(self.STATUS.DELETED, 'DELETED') - def test_provided(self): + def test_provided(self) -> None: self.assertEqual(self.STATUS.DRAFT, 'DRAFT') - def test_len(self): + def test_len(self) -> None: self.assertEqual(len(self.STATUS), 3) - def test_equality(self): + def test_equality(self) -> None: self.assertEqual(self.STATUS, Choices( ('DRAFT', 'is draft'), ('PUBLISHED', 'is published'), 'DELETED', )) - def test_inequality(self): + def test_inequality(self) -> None: self.assertNotEqual(self.STATUS, [ ('DRAFT', 'is draft'), ('PUBLISHED', 'is published'), @@ -120,27 +120,27 @@ class LabelChoicesTests(ChoicesTests): ]) self.assertNotEqual(self.STATUS, Choices('DRAFT')) - def test_repr(self): + def test_repr(self) -> None: self.assertEqual(repr(self.STATUS), "Choices" + repr(( ('DRAFT', 'DRAFT', 'is draft'), ('PUBLISHED', 'PUBLISHED', 'is published'), ('DELETED', 'DELETED', 'DELETED'), ))) - def test_contains_value(self): + def test_contains_value(self) -> None: self.assertTrue('PUBLISHED' in self.STATUS) self.assertTrue('DRAFT' in self.STATUS) # This should be True, because both the display value # and the internal representation are both DELETED. self.assertTrue('DELETED' in self.STATUS) - def test_doesnt_contain_value(self): + def test_doesnt_contain_value(self) -> None: self.assertFalse('UNPUBLISHED' in self.STATUS) - def test_doesnt_contain_display_value(self): + def test_doesnt_contain_display_value(self) -> None: self.assertFalse('is draft' in self.STATUS) - def test_composability(self): + def test_composability(self) -> None: self.assertEqual( Choices(('DRAFT', 'is draft',)) + Choices(('PUBLISHED', 'is published'), 'DELETED'), self.STATUS @@ -156,7 +156,7 @@ class LabelChoicesTests(ChoicesTests): self.STATUS ) - def test_option_groups(self): + def test_option_groups(self) -> None: c = Choices( ('group a', [(1, 'one'), (2, 'two')]), ['group b', ((3, 'three'),)] @@ -171,64 +171,64 @@ class LabelChoicesTests(ChoicesTests): class IdentifierChoicesTests(ChoicesTests): - def setUp(self): + def setUp(self) -> None: self.STATUS = Choices( (0, 'DRAFT', 'is draft'), (1, 'PUBLISHED', 'is published'), (2, 'DELETED', 'is deleted')) - def test_iteration(self): + def test_iteration(self) -> None: self.assertEqual(tuple(self.STATUS), ( (0, 'is draft'), (1, 'is published'), (2, 'is deleted'), )) - def test_reversed(self): + def test_reversed(self) -> None: self.assertEqual(tuple(reversed(self.STATUS)), ( (2, 'is deleted'), (1, 'is published'), (0, 'is draft'), )) - def test_indexing(self): + def test_indexing(self) -> None: self.assertEqual(self.STATUS[1], 'is published') - def test_getattr(self): + def test_getattr(self) -> None: self.assertEqual(self.STATUS.DRAFT, 0) - def test_len(self): + def test_len(self) -> None: self.assertEqual(len(self.STATUS), 3) - def test_repr(self): + def test_repr(self) -> None: self.assertEqual(repr(self.STATUS), "Choices" + repr(( (0, 'DRAFT', 'is draft'), (1, 'PUBLISHED', 'is published'), (2, 'DELETED', 'is deleted'), ))) - def test_contains_value(self): + def test_contains_value(self) -> None: self.assertTrue(0 in self.STATUS) self.assertTrue(1 in self.STATUS) self.assertTrue(2 in self.STATUS) - def test_doesnt_contain_value(self): + def test_doesnt_contain_value(self) -> None: self.assertFalse(3 in self.STATUS) - def test_doesnt_contain_display_value(self): + def test_doesnt_contain_display_value(self) -> None: self.assertFalse('is draft' in self.STATUS) - def test_doesnt_contain_python_attr(self): + def test_doesnt_contain_python_attr(self) -> None: self.assertFalse('PUBLISHED' in self.STATUS) - def test_equality(self): + def test_equality(self) -> None: self.assertEqual(self.STATUS, Choices( (0, 'DRAFT', 'is draft'), (1, 'PUBLISHED', 'is published'), (2, 'DELETED', 'is deleted') )) - def test_inequality(self): + def test_inequality(self) -> None: self.assertNotEqual(self.STATUS, [ (0, 'DRAFT', 'is draft'), (1, 'PUBLISHED', 'is published'), @@ -236,7 +236,7 @@ class IdentifierChoicesTests(ChoicesTests): ]) self.assertNotEqual(self.STATUS, Choices('DRAFT')) - def test_composability(self): + def test_composability(self) -> None: self.assertEqual( Choices( (0, 'DRAFT', 'is draft'), @@ -267,7 +267,7 @@ class IdentifierChoicesTests(ChoicesTests): self.STATUS ) - def test_option_groups(self): + def test_option_groups(self) -> None: c = Choices( ('group a', [(1, 'ONE', 'one'), (2, 'TWO', 'two')]), ['group b', ((3, 'THREE', 'three'),)] @@ -283,26 +283,26 @@ class IdentifierChoicesTests(ChoicesTests): class SubsetChoicesTest(TestCase): - def setUp(self): + def setUp(self) -> None: self.choices = Choices( (0, 'a', 'A'), (1, 'b', 'B'), ) - def test_nonexistent_identifiers_raise(self): + def test_nonexistent_identifiers_raise(self) -> None: with self.assertRaises(ValueError): self.choices.subset('a', 'c') - def test_solo_nonexistent_identifiers_raise(self): + def test_solo_nonexistent_identifiers_raise(self) -> None: with self.assertRaises(ValueError): self.choices.subset('c') - def test_empty_subset_passes(self): + def test_empty_subset_passes(self) -> None: subset = self.choices.subset() self.assertEqual(subset, Choices()) - def test_subset_returns_correct_subset(self): + def test_subset_returns_correct_subset(self) -> None: subset = self.choices.subset('a') self.assertEqual(subset, Choices((0, 'a', 'A'))) diff --git a/tests/test_fields/test_field_tracker.py b/tests/test_fields/test_field_tracker.py index f239bd3..91a84c9 100644 --- a/tests/test_fields/test_field_tracker.py +++ b/tests/test_fields/test_field_tracker.py @@ -65,7 +65,7 @@ class FieldTrackerTestCase(TestCase): class FieldTrackerCommonTests: - def test_pre_save_previous(self): + def test_pre_save_previous(self) -> None: self.assertPrevious(name=None, number=None) self.instance.name = 'new age' self.instance.number = 8 @@ -76,14 +76,14 @@ class FieldTrackerTests(FieldTrackerTestCase, FieldTrackerCommonTests): tracked_class: type[models.Model] = Tracked - def setUp(self): + def setUp(self) -> None: self.instance = self.tracked_class() self.tracker = self.instance.tracker - def test_descriptor(self): + def test_descriptor(self) -> None: self.assertTrue(isinstance(self.tracked_class.tracker, FieldTracker)) - def test_pre_save_changed(self): + def test_pre_save_changed(self) -> None: self.assertChanged(name=None) self.instance.name = 'new age' self.assertChanged(name=None) @@ -94,7 +94,7 @@ class FieldTrackerTests(FieldTrackerTestCase, FieldTrackerCommonTests): self.instance.mutable = [1, 2, 3] self.assertChanged(name=None, number=None, mutable=None) - def test_pre_save_has_changed(self): + def test_pre_save_has_changed(self) -> None: self.assertHasChanged(name=True, number=False, mutable=False) self.instance.name = 'new age' self.assertHasChanged(name=True, number=False, mutable=False) @@ -103,12 +103,12 @@ class FieldTrackerTests(FieldTrackerTestCase, FieldTrackerCommonTests): self.instance.mutable = [1, 2, 3] self.assertHasChanged(name=True, number=True, mutable=True) - def test_save_with_args(self): + def test_save_with_args(self) -> None: self.instance.number = 1 self.instance.save(False, False, None, None) self.assertChanged() - def test_first_save(self): + def test_first_save(self) -> None: self.assertHasChanged(name=True, number=False, mutable=False) self.assertPrevious(name=None, number=None, mutable=None) self.assertCurrent(name='', number=None, id=None, mutable=None) @@ -129,7 +129,7 @@ class FieldTrackerTests(FieldTrackerTestCase, FieldTrackerCommonTests): with self.assertRaises(ValueError): self.instance.save(update_fields=['number']) - def test_post_save_has_changed(self): + def test_post_save_has_changed(self) -> None: self.update_instance(name='retro', number=4, mutable=[1, 2, 3]) self.assertHasChanged(name=False, number=False, mutable=False) self.instance.name = 'new age' @@ -141,14 +141,14 @@ class FieldTrackerTests(FieldTrackerTestCase, FieldTrackerCommonTests): self.instance.name = 'retro' self.assertHasChanged(name=False, number=True, mutable=True) - def test_post_save_previous(self): + def test_post_save_previous(self) -> None: self.update_instance(name='retro', number=4, mutable=[1, 2, 3]) self.instance.name = 'new age' self.assertPrevious(name='retro', number=4, mutable=[1, 2, 3]) self.instance.mutable[1] = 4 self.assertPrevious(name='retro', number=4, mutable=[1, 2, 3]) - def test_post_save_changed(self): + def test_post_save_changed(self) -> None: self.update_instance(name='retro', number=4, mutable=[1, 2, 3]) self.assertChanged() self.instance.name = 'new age' @@ -162,7 +162,7 @@ class FieldTrackerTests(FieldTrackerTestCase, FieldTrackerCommonTests): self.instance.mutable = [1, 2, 3] self.assertChanged(number=4) - def test_current(self): + def test_current(self) -> None: self.assertCurrent(id=None, name='', number=None, mutable=None) self.instance.name = 'new age' self.assertCurrent(id=None, name='new age', number=None, mutable=None) @@ -175,7 +175,7 @@ class FieldTrackerTests(FieldTrackerTestCase, FieldTrackerCommonTests): self.instance.save() self.assertCurrent(id=self.instance.id, name='new age', number=8, mutable=[1, 4, 3]) - def test_update_fields(self): + def test_update_fields(self) -> None: self.update_instance(name='retro', number=4, mutable=[1, 2, 3]) self.assertChanged() self.instance.name = 'new age' @@ -198,7 +198,7 @@ class FieldTrackerTests(FieldTrackerTestCase, FieldTrackerCommonTests): self.assertEqual(in_db.number, self.instance.number) self.assertEqual(in_db.mutable, self.instance.mutable) - def test_refresh_from_db(self): + def test_refresh_from_db(self) -> None: self.update_instance(name='retro', number=4, mutable=[1, 2, 3]) self.tracked_class.objects.filter(pk=self.instance.pk).update( name='new age', number=8, mutable=[3, 2, 1]) @@ -214,7 +214,7 @@ class FieldTrackerTests(FieldTrackerTestCase, FieldTrackerCommonTests): self.instance.refresh_from_db() self.assertChanged() - def test_with_deferred(self): + def test_with_deferred(self) -> None: self.instance.name = 'new age' self.instance.number = 1 self.instance.save() @@ -268,7 +268,7 @@ class FieldTrackerTests(FieldTrackerTestCase, FieldTrackerCommonTests): class FieldTrackerMultipleInstancesTests(TestCase): - def test_with_deferred_fields_access_multiple(self): + def test_with_deferred_fields_access_multiple(self) -> None: Tracked.objects.create(pk=1, name='foo', number=1) Tracked.objects.create(pk=2, name='bar', number=2) @@ -283,11 +283,11 @@ class FieldTrackedModelCustomTests(FieldTrackerTestCase, tracked_class: type[models.Model] = TrackedNotDefault - def setUp(self): + def setUp(self) -> None: self.instance = self.tracked_class() self.tracker = self.instance.name_tracker - def test_pre_save_changed(self): + def test_pre_save_changed(self) -> None: self.assertChanged(name=None) self.instance.name = 'new age' self.assertChanged(name=None) @@ -296,7 +296,7 @@ class FieldTrackedModelCustomTests(FieldTrackerTestCase, self.instance.name = '' self.assertChanged(name=None) - def test_first_save(self): + def test_first_save(self) -> None: self.assertHasChanged(name=True, number=None) self.assertPrevious(name=None, number=None) self.assertCurrent(name='') @@ -308,14 +308,14 @@ class FieldTrackedModelCustomTests(FieldTrackerTestCase, self.assertCurrent(name='retro') self.assertChanged(name=None) - def test_pre_save_has_changed(self): + def test_pre_save_has_changed(self) -> None: self.assertHasChanged(name=True, number=None) self.instance.name = 'new age' self.assertHasChanged(name=True, number=None) self.instance.number = 7 self.assertHasChanged(name=True, number=None) - def test_post_save_has_changed(self): + def test_post_save_has_changed(self) -> None: self.update_instance(name='retro', number=4) self.assertHasChanged(name=False, number=None) self.instance.name = 'new age' @@ -325,12 +325,12 @@ class FieldTrackedModelCustomTests(FieldTrackerTestCase, self.instance.name = 'retro' self.assertHasChanged(name=False, number=None) - def test_post_save_previous(self): + def test_post_save_previous(self) -> None: self.update_instance(name='retro', number=4) self.instance.name = 'new age' self.assertPrevious(name='retro', number=None) - def test_post_save_changed(self): + def test_post_save_changed(self) -> None: self.update_instance(name='retro', number=4) self.assertChanged() self.instance.name = 'new age' @@ -340,7 +340,7 @@ class FieldTrackedModelCustomTests(FieldTrackerTestCase, self.instance.name = 'retro' self.assertChanged() - def test_current(self): + def test_current(self) -> None: self.assertCurrent(name='') self.instance.name = 'new age' self.assertCurrent(name='new age') @@ -349,7 +349,7 @@ class FieldTrackedModelCustomTests(FieldTrackerTestCase, self.instance.save() self.assertCurrent(name='new age') - def test_update_fields(self): + def test_update_fields(self) -> None: self.update_instance(name='retro', number=4) self.assertChanged() self.instance.name = 'new age' @@ -362,11 +362,11 @@ class FieldTrackedModelAttributeTests(FieldTrackerTestCase): tracked_class = TrackedNonFieldAttr - def setUp(self): + def setUp(self) -> None: self.instance = self.tracked_class() self.tracker = self.instance.tracker - def test_previous(self): + def test_previous(self) -> None: self.assertPrevious(rounded=None) self.instance.number = 7.5 self.assertPrevious(rounded=None) @@ -377,7 +377,7 @@ class FieldTrackedModelAttributeTests(FieldTrackerTestCase): self.instance.save() self.assertPrevious(rounded=7) - def test_has_changed(self): + def test_has_changed(self) -> None: self.assertHasChanged(rounded=False) self.instance.number = 7.5 self.assertHasChanged(rounded=True) @@ -388,7 +388,7 @@ class FieldTrackedModelAttributeTests(FieldTrackerTestCase): self.instance.number = 7.8 self.assertHasChanged(rounded=False) - def test_changed(self): + def test_changed(self) -> None: self.assertChanged() self.instance.number = 7.5 self.assertPrevious(rounded=None) @@ -401,7 +401,7 @@ class FieldTrackedModelAttributeTests(FieldTrackerTestCase): self.instance.save() self.assertPrevious() - def test_current(self): + def test_current(self) -> None: self.assertCurrent(rounded=None) self.instance.number = 7.5 self.assertCurrent(rounded=8) @@ -414,12 +414,12 @@ class FieldTrackedModelMultiTests(FieldTrackerTestCase, tracked_class: type[models.Model] = TrackedMultiple - def setUp(self): + def setUp(self) -> None: self.instance = self.tracked_class() self.trackers = [self.instance.name_tracker, self.instance.number_tracker] - def test_pre_save_changed(self): + def test_pre_save_changed(self) -> None: self.tracker = self.instance.name_tracker self.assertChanged(name=None) self.instance.name = 'new age' @@ -435,7 +435,7 @@ class FieldTrackedModelMultiTests(FieldTrackerTestCase, self.instance.number = 8 self.assertChanged(number=None) - def test_pre_save_has_changed(self): + def test_pre_save_has_changed(self) -> None: self.tracker = self.instance.name_tracker self.assertHasChanged(name=True, number=None) self.instance.name = 'new age' @@ -445,12 +445,12 @@ class FieldTrackedModelMultiTests(FieldTrackerTestCase, self.instance.name = 'new age' self.assertHasChanged(name=None, number=False) - def test_pre_save_previous(self): + def test_pre_save_previous(self) -> None: for tracker in self.trackers: self.tracker = tracker super().test_pre_save_previous() - def test_post_save_has_changed(self): + def test_post_save_has_changed(self) -> None: self.update_instance(name='retro', number=4) self.assertHasChanged(tracker=self.trackers[0], name=False, number=None) self.assertHasChanged(tracker=self.trackers[1], name=None, number=False) @@ -465,14 +465,14 @@ class FieldTrackedModelMultiTests(FieldTrackerTestCase, self.assertHasChanged(tracker=self.trackers[0], name=False, number=None) self.assertHasChanged(tracker=self.trackers[1], name=None, number=False) - def test_post_save_previous(self): + def test_post_save_previous(self) -> None: self.update_instance(name='retro', number=4) self.instance.name = 'new age' self.instance.number = 8 self.assertPrevious(tracker=self.trackers[0], name='retro', number=None) self.assertPrevious(tracker=self.trackers[1], name=None, number=4) - def test_post_save_changed(self): + def test_post_save_changed(self) -> None: self.update_instance(name='retro', number=4) self.assertChanged(tracker=self.trackers[0]) self.assertChanged(tracker=self.trackers[1]) @@ -487,7 +487,7 @@ class FieldTrackedModelMultiTests(FieldTrackerTestCase, self.assertChanged(tracker=self.trackers[0]) self.assertChanged(tracker=self.trackers[1]) - def test_current(self): + def test_current(self) -> None: self.assertCurrent(tracker=self.trackers[0], name='') self.assertCurrent(tracker=self.trackers[1], number=None) self.instance.name = 'new age' @@ -506,11 +506,11 @@ class FieldTrackerForeignKeyTests(FieldTrackerTestCase): fk_class: type[models.Model] = Tracked tracked_class: type[models.Model] = TrackedFK - def setUp(self): + def setUp(self) -> None: self.old_fk = self.fk_class.objects.create(number=8) self.instance = self.tracked_class.objects.create(fk=self.old_fk) - def test_default(self): + def test_default(self) -> None: self.tracker = self.instance.tracker self.assertChanged() self.assertPrevious() @@ -520,7 +520,7 @@ class FieldTrackerForeignKeyTests(FieldTrackerTestCase): self.assertPrevious(fk_id=self.old_fk.id) self.assertCurrent(id=self.instance.id, fk_id=self.instance.fk_id) - def test_custom(self): + def test_custom(self) -> None: self.tracker = self.instance.custom_tracker self.assertChanged() self.assertPrevious() @@ -530,7 +530,7 @@ class FieldTrackerForeignKeyTests(FieldTrackerTestCase): self.assertPrevious(fk_id=self.old_fk.id) self.assertCurrent(fk_id=self.instance.fk_id) - def test_custom_without_id(self): + def test_custom_without_id(self) -> None: with self.assertNumQueries(1): self.tracked_class.objects.get() self.tracker = self.instance.custom_tracker_without_id @@ -549,19 +549,19 @@ class FieldTrackerForeignKeyPrefetchRelatedTests(FieldTrackerTestCase): fk_class = Tracked tracked_class = TrackedFK - def setUp(self): + def setUp(self) -> None: model_tracked = self.fk_class.objects.create(name="", number=0) self.instance = self.tracked_class.objects.create(fk=model_tracked) - def test_default(self): + def test_default(self) -> None: self.tracker = self.instance.tracker self.assertIsNotNone(list(self.tracked_class.objects.prefetch_related("fk"))) - def test_custom(self): + def test_custom(self) -> None: self.tracker = self.instance.custom_tracker self.assertIsNotNone(list(self.tracked_class.objects.prefetch_related("fk"))) - def test_custom_without_id(self): + def test_custom_without_id(self) -> None: self.tracker = self.instance.custom_tracker_without_id self.assertIsNotNone(list(self.tracked_class.objects.prefetch_related("fk"))) @@ -571,18 +571,18 @@ class FieldTrackerTimeStampedTests(FieldTrackerTestCase): fk_class = Tracked tracked_class = TrackerTimeStamped - def setUp(self): + def setUp(self) -> None: self.instance = self.tracked_class.objects.create(name='old', number=1) self.tracker = self.instance.tracker - def test_set_modified_on_save(self): + def test_set_modified_on_save(self) -> None: old_modified = self.instance.modified self.instance.name = 'new' self.instance.save() self.assertGreater(self.instance.modified, old_modified) self.assertChanged() - def test_set_modified_on_save_update_fields(self): + def test_set_modified_on_save_update_fields(self) -> None: old_modified = self.instance.modified self.instance.name = 'new' self.instance.save(update_fields=('name',)) @@ -594,7 +594,7 @@ class InheritedFieldTrackerTests(FieldTrackerTests): tracked_class = InheritedTracked - def test_child_fields_not_tracked(self): + def test_child_fields_not_tracked(self) -> None: self.name2 = 'test' self.assertEqual(self.tracker.previous('name2'), None) self.assertRaises(FieldError, self.tracker.has_changed, 'name2') @@ -609,13 +609,13 @@ class FieldTrackerFileFieldTests(FieldTrackerTestCase): tracked_class = TrackedFileField - def setUp(self): + def setUp(self) -> None: self.instance = self.tracked_class() self.tracker = self.instance.tracker self.some_file = 'something.txt' self.another_file = 'another.txt' - def test_saved_data_without_instance(self): + def test_saved_data_without_instance(self) -> None: """ Tests that instance won't get copied by the Field Tracker. @@ -634,22 +634,22 @@ class FieldTrackerFileFieldTests(FieldTrackerTestCase): self.assertEqual(self.instance.some_file.instance, self.instance) self.assertIsInstance(self.instance.some_file, FieldFile) - def test_pre_save_changed(self): + def test_pre_save_changed(self) -> None: self.assertChanged(some_file=None) self.instance.some_file = self.some_file self.assertChanged(some_file=None) - def test_pre_save_has_changed(self): + def test_pre_save_has_changed(self) -> None: self.assertHasChanged(some_file=True) self.instance.some_file = self.some_file self.assertHasChanged(some_file=True) - def test_pre_save_previous(self): + def test_pre_save_previous(self) -> None: self.assertPrevious(some_file=None) self.instance.some_file = self.some_file self.assertPrevious(some_file=None) - def test_post_save_changed(self): + def test_post_save_changed(self) -> None: self.update_instance(some_file=self.some_file) self.assertChanged() previous_file = self.instance.some_file @@ -667,7 +667,7 @@ class FieldTrackerFileFieldTests(FieldTrackerTestCase): some_file=previous_file, ) - def test_post_save_has_changed(self): + def test_post_save_has_changed(self) -> None: self.update_instance(some_file=self.some_file) self.assertHasChanged(some_file=False) self.instance.some_file = self.another_file @@ -687,7 +687,7 @@ class FieldTrackerFileFieldTests(FieldTrackerTestCase): some_file=True, ) - def test_post_save_previous(self): + def test_post_save_previous(self) -> None: self.update_instance(some_file=self.some_file) previous_file = self.instance.some_file self.instance.some_file = self.another_file @@ -707,7 +707,7 @@ class FieldTrackerFileFieldTests(FieldTrackerTestCase): some_file=previous_file, ) - def test_current(self): + def test_current(self) -> None: self.assertCurrent(some_file=self.instance.some_file, id=None) self.instance.some_file = self.some_file self.assertCurrent(some_file=self.instance.some_file, id=None) @@ -732,7 +732,7 @@ class ModelTrackerTests(FieldTrackerTests): tracked_class: type[models.Model] = ModelTracked - def test_cache_compatible(self): + def test_cache_compatible(self) -> None: cache.set('key', self.instance) instance = cache.get('key') instance.number = 1 @@ -742,7 +742,7 @@ class ModelTrackerTests(FieldTrackerTests): instance.number = 2 self.assertHasChanged(number=True) - def test_pre_save_changed(self): + def test_pre_save_changed(self) -> None: self.assertChanged() self.instance.name = 'new age' self.assertChanged() @@ -753,7 +753,7 @@ class ModelTrackerTests(FieldTrackerTests): self.instance.mutable = [1, 2, 3] self.assertChanged() - def test_first_save(self): + def test_first_save(self) -> None: self.assertHasChanged(name=True, number=True, mutable=True) self.assertPrevious(name=None, number=None, mutable=None) self.assertCurrent(name='', number=None, id=None, mutable=None) @@ -774,7 +774,7 @@ class ModelTrackerTests(FieldTrackerTests): with self.assertRaises(ValueError): self.instance.save(update_fields=['number']) - def test_pre_save_has_changed(self): + def test_pre_save_has_changed(self) -> None: self.assertHasChanged(name=True, number=True) self.instance.name = 'new age' self.assertHasChanged(name=True, number=True) @@ -786,7 +786,7 @@ class ModelTrackedModelCustomTests(FieldTrackedModelCustomTests): tracked_class = ModelTrackedNotDefault - def test_first_save(self): + def test_first_save(self) -> None: self.assertHasChanged(name=True, number=True) self.assertPrevious(name=None, number=None) self.assertCurrent(name='') @@ -798,14 +798,14 @@ class ModelTrackedModelCustomTests(FieldTrackedModelCustomTests): self.assertCurrent(name='retro') self.assertChanged() - def test_pre_save_has_changed(self): + def test_pre_save_has_changed(self) -> None: self.assertHasChanged(name=True, number=True) self.instance.name = 'new age' self.assertHasChanged(name=True, number=True) self.instance.number = 7 self.assertHasChanged(name=True, number=True) - def test_pre_save_changed(self): + def test_pre_save_changed(self) -> None: self.assertChanged() self.instance.name = 'new age' self.assertChanged() @@ -819,7 +819,7 @@ class ModelTrackedModelMultiTests(FieldTrackedModelMultiTests): tracked_class = ModelTrackedMultiple - def test_pre_save_has_changed(self): + def test_pre_save_has_changed(self) -> None: self.tracker = self.instance.name_tracker self.assertHasChanged(name=True, number=True) self.instance.name = 'new age' @@ -829,7 +829,7 @@ class ModelTrackedModelMultiTests(FieldTrackedModelMultiTests): self.instance.name = 'new age' self.assertHasChanged(name=True, number=True) - def test_pre_save_changed(self): + def test_pre_save_changed(self) -> None: self.tracker = self.instance.name_tracker self.assertChanged() self.instance.name = 'new age' @@ -851,7 +851,7 @@ class ModelTrackerForeignKeyTests(FieldTrackerForeignKeyTests): fk_class = ModelTracked tracked_class = ModelTrackedFK - def test_custom_without_id(self): + def test_custom_without_id(self) -> None: with self.assertNumQueries(2): self.tracked_class.objects.get() self.tracker = self.instance.custom_tracker_without_id @@ -869,7 +869,7 @@ class InheritedModelTrackerTests(ModelTrackerTests): tracked_class = InheritedModelTracked - def test_child_fields_not_tracked(self): + def test_child_fields_not_tracked(self) -> None: self.name2 = 'test' self.assertEqual(self.tracker.previous('name2'), None) self.assertTrue(self.tracker.has_changed('name2')) @@ -882,7 +882,7 @@ class AbstractModelTrackerTests(ModelTrackerTests): class TrackerContextDecoratorTests(TestCase): - def setUp(self): + def setUp(self) -> None: self.instance = Tracked.objects.create(number=1) self.tracker = self.instance.tracker @@ -894,7 +894,7 @@ class TrackerContextDecoratorTests(TestCase): for f in fields: self.assertFalse(self.tracker.has_changed(f)) - def test_context_manager(self): + def test_context_manager(self) -> None: with self.tracker: with self.tracker: self.instance.name = 'new' @@ -905,7 +905,7 @@ class TrackerContextDecoratorTests(TestCase): self.assertNotChanged('name') - def test_context_manager_fields(self): + def test_context_manager_fields(self) -> None: with self.tracker('number'): with self.tracker('number', 'name'): self.instance.name = 'new' @@ -918,7 +918,7 @@ class TrackerContextDecoratorTests(TestCase): self.assertNotChanged('number', 'name') - def test_tracker_decorator(self): + def test_tracker_decorator(self) -> None: @Tracked.tracker def tracked_method(obj): @@ -929,7 +929,7 @@ class TrackerContextDecoratorTests(TestCase): self.assertNotChanged('name') - def test_tracker_decorator_fields(self): + def test_tracker_decorator_fields(self) -> None: @Tracked.tracker(fields=['name']) def tracked_method(obj): @@ -942,7 +942,7 @@ class TrackerContextDecoratorTests(TestCase): self.assertChanged('number') self.assertNotChanged('name') - def test_tracker_context_with_save(self): + def test_tracker_context_with_save(self) -> None: with self.tracker: self.instance.name = 'new' diff --git a/tests/test_fields/test_monitor_field.py b/tests/test_fields/test_monitor_field.py index 143417c..9c9ba84 100644 --- a/tests/test_fields/test_monitor_field.py +++ b/tests/test_fields/test_monitor_field.py @@ -10,33 +10,33 @@ from tests.models import DoubleMonitored, Monitored, MonitorWhen, MonitorWhenEmp class MonitorFieldTests(TestCase): - def setUp(self): + def setUp(self) -> None: with time_machine.travel(datetime(2016, 1, 1, 10, 0, 0, tzinfo=timezone.utc)): self.instance = Monitored(name='Charlie') self.created = self.instance.name_changed - def test_save_no_change(self): + def test_save_no_change(self) -> None: self.instance.save() self.assertEqual(self.instance.name_changed, self.created) - def test_save_changed(self): + def test_save_changed(self) -> None: with time_machine.travel(datetime(2016, 1, 1, 12, 0, 0, tzinfo=timezone.utc)): self.instance.name = 'Maria' self.instance.save() self.assertEqual(self.instance.name_changed, datetime(2016, 1, 1, 12, 0, 0, tzinfo=timezone.utc)) - def test_double_save(self): + def test_double_save(self) -> None: self.instance.name = 'Jose' self.instance.save() changed = self.instance.name_changed self.instance.save() self.assertEqual(self.instance.name_changed, changed) - def test_no_monitor_arg(self): + def test_no_monitor_arg(self) -> None: with self.assertRaises(TypeError): MonitorField() - def test_monitor_default_is_none_when_nullable(self): + def test_monitor_default_is_none_when_nullable(self) -> None: self.assertIsNone(self.instance.name_changed_nullable) expected_datetime = datetime(2022, 1, 18, 12, 0, 0, tzinfo=timezone.utc) @@ -51,33 +51,33 @@ class MonitorWhenFieldTests(TestCase): """ Will record changes only when name is 'Jose' or 'Maria' """ - def setUp(self): + def setUp(self) -> None: with time_machine.travel(datetime(2016, 1, 1, 10, 0, 0, tzinfo=timezone.utc)): self.instance = MonitorWhen(name='Charlie') self.created = self.instance.name_changed - def test_save_no_change(self): + def test_save_no_change(self) -> None: self.instance.save() self.assertEqual(self.instance.name_changed, self.created) - def test_save_changed_to_Jose(self): + def test_save_changed_to_Jose(self) -> None: with time_machine.travel(datetime(2016, 1, 1, 12, 0, 0, tzinfo=timezone.utc)): self.instance.name = 'Jose' self.instance.save() self.assertEqual(self.instance.name_changed, datetime(2016, 1, 1, 12, 0, 0, tzinfo=timezone.utc)) - def test_save_changed_to_Maria(self): + def test_save_changed_to_Maria(self) -> None: with time_machine.travel(datetime(2016, 1, 1, 12, 0, 0, tzinfo=timezone.utc)): self.instance.name = 'Maria' self.instance.save() self.assertEqual(self.instance.name_changed, datetime(2016, 1, 1, 12, 0, 0, tzinfo=timezone.utc)) - def test_save_changed_to_Pedro(self): + def test_save_changed_to_Pedro(self) -> None: self.instance.name = 'Pedro' self.instance.save() self.assertEqual(self.instance.name_changed, self.created) - def test_double_save(self): + def test_double_save(self) -> None: self.instance.name = 'Jose' self.instance.save() changed = self.instance.name_changed @@ -89,20 +89,20 @@ class MonitorWhenEmptyFieldTests(TestCase): """ Monitor should never be updated id when is an empty list. """ - def setUp(self): + def setUp(self) -> None: self.instance = MonitorWhenEmpty(name='Charlie') self.created = self.instance.name_changed - def test_save_no_change(self): + def test_save_no_change(self) -> None: self.instance.save() self.assertEqual(self.instance.name_changed, self.created) - def test_save_changed_to_Jose(self): + def test_save_changed_to_Jose(self) -> None: self.instance.name = 'Jose' self.instance.save() self.assertEqual(self.instance.name_changed, self.created) - def test_save_changed_to_Maria(self): + def test_save_changed_to_Maria(self) -> None: self.instance.name = 'Maria' self.instance.save() self.assertEqual(self.instance.name_changed, self.created) @@ -110,18 +110,18 @@ class MonitorWhenEmptyFieldTests(TestCase): class MonitorDoubleFieldTests(TestCase): - def setUp(self): + def setUp(self) -> None: DoubleMonitored.objects.create(name='Charlie', name2='Charlie2') - def test_recursion_error_with_only(self): + def test_recursion_error_with_only(self) -> None: # Any field passed to only() is generating a recursion error list(DoubleMonitored.objects.only('id')) - def test_recursion_error_with_defer(self): + def test_recursion_error_with_defer(self) -> None: # Only monitored fields passed to defer() are failing list(DoubleMonitored.objects.defer('name')) - def test_monitor_still_works_with_deferred_fields_filtered_out_of_save_initial(self): + def test_monitor_still_works_with_deferred_fields_filtered_out_of_save_initial(self) -> None: obj = DoubleMonitored.objects.defer('name').get(name='Charlie') with time_machine.travel(datetime(2016, 12, 1, tzinfo=timezone.utc)): obj.name = 'Charlie2' diff --git a/tests/test_fields/test_split_field.py b/tests/test_fields/test_split_field.py index 3199b56..9dd27a1 100644 --- a/tests/test_fields/test_split_field.py +++ b/tests/test_fields/test_split_field.py @@ -9,62 +9,62 @@ class SplitFieldTests(TestCase): full_text = 'summary\n\n\n\nmore' excerpt = 'summary\n' - def setUp(self): + def setUp(self) -> None: self.post = Article.objects.create( title='example post', body=self.full_text) - def test_unicode_content(self): + def test_unicode_content(self) -> None: self.assertEqual(str(self.post.body), self.full_text) - def test_excerpt(self): + def test_excerpt(self) -> None: self.assertEqual(self.post.body.excerpt, self.excerpt) - def test_content(self): + def test_content(self) -> None: self.assertEqual(self.post.body.content, self.full_text) - def test_has_more(self): + def test_has_more(self) -> None: self.assertTrue(self.post.body.has_more) - def test_not_has_more(self): + def test_not_has_more(self) -> None: post = Article.objects.create(title='example 2', body='some text\n\nsome more\n') self.assertFalse(post.body.has_more) - def test_load_back(self): + def test_load_back(self) -> None: post = Article.objects.get(pk=self.post.pk) self.assertEqual(post.body.content, self.post.body.content) self.assertEqual(post.body.excerpt, self.post.body.excerpt) - def test_assign_to_body(self): + def test_assign_to_body(self) -> None: new_text = 'different\n\n\n\nother' self.post.body = new_text self.post.save() self.assertEqual(str(self.post.body), new_text) - def test_assign_to_content(self): + def test_assign_to_content(self) -> None: new_text = 'different\n\n\n\nother' self.post.body.content = new_text self.post.save() self.assertEqual(str(self.post.body), new_text) - def test_assign_to_excerpt(self): + def test_assign_to_excerpt(self) -> None: with self.assertRaises(AttributeError): self.post.body.excerpt = 'this should fail' - def test_access_via_class(self): + def test_access_via_class(self) -> None: with self.assertRaises(AttributeError): Article.body - def test_assign_splittext(self): + def test_assign_splittext(self) -> None: a = Article(title='Some Title') a.body = self.post.body self.assertEqual(a.body.excerpt, 'summary\n') - def test_value_to_string(self): + def test_value_to_string(self) -> None: f = self.post._meta.get_field('body') self.assertEqual(f.value_to_string(self.post), self.full_text) - def test_abstract_inheritance(self): + def test_abstract_inheritance(self) -> None: class Child(SplitFieldAbstractParent): pass diff --git a/tests/test_fields/test_status_field.py b/tests/test_fields/test_status_field.py index a24ce45..fe79e11 100644 --- a/tests/test_fields/test_status_field.py +++ b/tests/test_fields/test_status_field.py @@ -13,22 +13,22 @@ from tests.models import ( class StatusFieldTests(TestCase): - def test_status_with_default_filled(self): + def test_status_with_default_filled(self) -> None: instance = StatusFieldDefaultFilled() self.assertEqual(instance.status, instance.STATUS.yes) - def test_status_with_default_not_filled(self): + def test_status_with_default_not_filled(self) -> None: instance = StatusFieldDefaultNotFilled() self.assertEqual(instance.status, instance.STATUS.no) - def test_no_check_for_status(self): + def test_no_check_for_status(self) -> None: field = StatusField(no_check_for_status=True) # this model has no STATUS attribute, so checking for it would error field.prepare_class(Article) - def test_get_status_display(self): + def test_get_status_display(self) -> None: instance = StatusFieldDefaultFilled() self.assertEqual(instance.get_status_display(), "Yes") - def test_choices_name(self): + def test_choices_name(self) -> None: StatusFieldChoicesName() diff --git a/tests/test_fields/test_urlsafe_token_field.py b/tests/test_fields/test_urlsafe_token_field.py index 3feffde..6146fe6 100644 --- a/tests/test_fields/test_urlsafe_token_field.py +++ b/tests/test_fields/test_urlsafe_token_field.py @@ -9,41 +9,41 @@ from model_utils.fields import UrlsafeTokenField class UrlsaftTokenFieldTests(TestCase): - def test_editable_default(self): + def test_editable_default(self) -> None: field = UrlsafeTokenField() self.assertFalse(field.editable) - def test_editable(self): + def test_editable(self) -> None: field = UrlsafeTokenField(editable=True) self.assertTrue(field.editable) - def test_max_length_default(self): + def test_max_length_default(self) -> None: field = UrlsafeTokenField() self.assertEqual(field.max_length, 128) - def test_max_length(self): + def test_max_length(self) -> None: field = UrlsafeTokenField(max_length=256) self.assertEqual(field.max_length, 256) - def test_factory_default(self): + def test_factory_default(self) -> None: field = UrlsafeTokenField() self.assertIsNone(field._factory) - def test_factory_not_callable(self): + def test_factory_not_callable(self) -> None: with self.assertRaises(TypeError): UrlsafeTokenField(factory='INVALID') - def test_get_default(self): + def test_get_default(self) -> None: field = UrlsafeTokenField() value = field.get_default() self.assertEqual(len(value), field.max_length) - def test_get_default_with_non_default_max_length(self): + def test_get_default_with_non_default_max_length(self) -> None: field = UrlsafeTokenField(max_length=64) value = field.get_default() self.assertEqual(len(value), 64) - def test_get_default_with_factory(self): + def test_get_default_with_factory(self) -> None: token = 'SAMPLE_TOKEN' factory = Mock(return_value=token) field = UrlsafeTokenField(factory=factory) @@ -52,12 +52,12 @@ class UrlsaftTokenFieldTests(TestCase): self.assertEqual(value, token) factory.assert_called_once_with(field.max_length) - def test_no_default_param(self): + def test_no_default_param(self) -> None: field = UrlsafeTokenField(default='DEFAULT') self.assertIs(field.default, NOT_PROVIDED) - def test_deconstruct(self): - def test_factory(): + def test_deconstruct(self) -> None: + def test_factory() -> None: pass instance = UrlsafeTokenField(factory=test_factory) name, path, args, kwargs = instance.deconstruct() diff --git a/tests/test_fields/test_uuid_field.py b/tests/test_fields/test_uuid_field.py index 7401566..4c77aaa 100644 --- a/tests/test_fields/test_uuid_field.py +++ b/tests/test_fields/test_uuid_field.py @@ -10,31 +10,31 @@ from model_utils.fields import UUIDField class UUIDFieldTests(TestCase): - def test_uuid_version_default(self): + def test_uuid_version_default(self) -> None: instance = UUIDField() self.assertEqual(instance.default, uuid.uuid4) - def test_uuid_version_1(self): + def test_uuid_version_1(self) -> None: instance = UUIDField(version=1) self.assertEqual(instance.default, uuid.uuid1) - def test_uuid_version_2_error(self): + def test_uuid_version_2_error(self) -> None: self.assertRaises(ValidationError, UUIDField, 'version', 2) - def test_uuid_version_3(self): + def test_uuid_version_3(self) -> None: instance = UUIDField(version=3) self.assertEqual(instance.default, uuid.uuid3) - def test_uuid_version_4(self): + def test_uuid_version_4(self) -> None: instance = UUIDField(version=4) self.assertEqual(instance.default, uuid.uuid4) - def test_uuid_version_5(self): + def test_uuid_version_5(self) -> None: instance = UUIDField(version=5) self.assertEqual(instance.default, uuid.uuid5) - def test_uuid_version_bellow_min(self): + def test_uuid_version_bellow_min(self) -> None: self.assertRaises(ValidationError, UUIDField, 'version', 0) - def test_uuid_version_above_max(self): + def test_uuid_version_above_max(self) -> None: self.assertRaises(ValidationError, UUIDField, 'version', 6) diff --git a/tests/test_inheritance_iterable.py b/tests/test_inheritance_iterable.py index d7cf943..e9896c5 100644 --- a/tests/test_inheritance_iterable.py +++ b/tests/test_inheritance_iterable.py @@ -7,7 +7,7 @@ from tests.models import InheritanceManagerTestChild1, InheritanceManagerTestPar class InheritanceIterableTest(TestCase): - def test_prefetch(self): + def test_prefetch(self) -> None: qs = InheritanceManagerTestChild1.objects.all().prefetch_related( Prefetch( 'normal_field', diff --git a/tests/test_managers/test_inheritance_manager.py b/tests/test_managers/test_inheritance_manager.py index 89c5bd9..68e8a74 100644 --- a/tests/test_managers/test_inheritance_manager.py +++ b/tests/test_managers/test_inheritance_manager.py @@ -1,8 +1,11 @@ from __future__ import annotations +from typing import TYPE_CHECKING + from django.db import models from django.test import TestCase +from model_utils.managers import InheritanceManager from tests.models import ( InheritanceManagerTestChild1, InheritanceManagerTestChild2, @@ -16,19 +19,22 @@ from tests.models import ( TimeFrame, ) +if TYPE_CHECKING: + from django.db.models.fields.related_descriptors import RelatedManager + class InheritanceManagerTests(TestCase): - def setUp(self): + def setUp(self) -> None: self.child1 = InheritanceManagerTestChild1.objects.create() self.child2 = InheritanceManagerTestChild2.objects.create() self.grandchild1 = InheritanceManagerTestGrandChild1.objects.create() self.grandchild1_2 = \ InheritanceManagerTestGrandChild1_2.objects.create() - def get_manager(self): + def get_manager(self) -> InheritanceManager[InheritanceManagerTestParent]: return InheritanceManagerTestParent.objects - def test_normal(self): + def test_normal(self) -> None: children = { InheritanceManagerTestParent(pk=self.child1.pk), InheritanceManagerTestParent(pk=self.child2.pk), @@ -37,14 +43,14 @@ class InheritanceManagerTests(TestCase): } self.assertEqual(set(self.get_manager().all()), children) - def test_select_all_subclasses(self): + def test_select_all_subclasses(self) -> None: children = {self.child1, self.child2} children.add(self.grandchild1) children.add(self.grandchild1_2) self.assertEqual( set(self.get_manager().select_subclasses()), children) - def test_select_subclasses_invalid_relation(self): + def test_select_subclasses_invalid_relation(self) -> None: """ If an invalid relation string is provided, we can provide the user with a list which is valid, rather than just have the select_related() @@ -54,7 +60,7 @@ class InheritanceManagerTests(TestCase): with self.assertRaisesRegex(ValueError, regex): self.get_manager().select_subclasses('user') - def test_select_specific_subclasses(self): + def test_select_specific_subclasses(self) -> None: children = { self.child1, InheritanceManagerTestParent(pk=self.child2.pk), @@ -69,7 +75,7 @@ class InheritanceManagerTests(TestCase): children, ) - def test_select_specific_grandchildren(self): + def test_select_specific_grandchildren(self) -> None: children = { InheritanceManagerTestParent(pk=self.child1.pk), InheritanceManagerTestParent(pk=self.child2.pk), @@ -85,7 +91,7 @@ class InheritanceManagerTests(TestCase): children, ) - def test_children_and_grandchildren(self): + def test_children_and_grandchildren(self) -> None: children = { self.child1, InheritanceManagerTestParent(pk=self.child2.pk), @@ -102,24 +108,24 @@ class InheritanceManagerTests(TestCase): children, ) - def test_get_subclass(self): + def test_get_subclass(self) -> None: self.assertEqual( self.get_manager().get_subclass(pk=self.child1.pk), self.child1) - def test_get_subclass_on_queryset(self): + def test_get_subclass_on_queryset(self) -> None: self.assertEqual( self.get_manager().all().get_subclass(pk=self.child1.pk), self.child1) - def test_prior_select_related(self): + def test_prior_select_related(self) -> None: with self.assertNumQueries(1): obj = self.get_manager().select_related( "inheritancemanagertestchild1").select_subclasses( "inheritancemanagertestchild2").get(pk=self.child1.pk) obj.inheritancemanagertestchild1 - def test_manually_specifying_parent_fk_including_grandchildren(self): + def test_manually_specifying_parent_fk_including_grandchildren(self) -> None: """ given a Model which inherits from another Model, but also declares the OneToOne link manually using `related_name` and `parent_link`, @@ -150,7 +156,7 @@ class InheritanceManagerTests(TestCase): self.assertEqual(set(results.subclasses), set(expected_related_names)) - def test_manually_specifying_parent_fk_single_subclass(self): + def test_manually_specifying_parent_fk_single_subclass(self) -> None: """ Using a string related_name when the relation is manually defined instead of implicit should still work in the same way. @@ -170,11 +176,11 @@ class InheritanceManagerTests(TestCase): self.assertEqual(set(results.subclasses), set(expected_related_names)) - def test_filter_on_values_queryset(self): + def test_filter_on_values_queryset(self) -> None: queryset = InheritanceManagerTestChild1.objects.values('id').filter(pk=self.child1.pk) self.assertEqual(list(queryset), [{'id': self.child1.pk}]) - def test_values_list_on_select_subclasses(self): + def test_values_list_on_select_subclasses(self) -> None: """ Using `select_subclasses` in conjunction with `values_list()` raised an exception in `_get_sub_obj_recurse()` because the result of `values_list()` @@ -219,14 +225,14 @@ class InheritanceManagerTests(TestCase): class InheritanceManagerUsingModelsTests(TestCase): - def setUp(self): + def setUp(self) -> None: self.parent1 = InheritanceManagerTestParent.objects.create() self.child1 = InheritanceManagerTestChild1.objects.create() self.child2 = InheritanceManagerTestChild2.objects.create() self.grandchild1 = InheritanceManagerTestGrandChild1.objects.create() self.grandchild1_2 = InheritanceManagerTestGrandChild1_2.objects.create() - def test_select_subclass_by_child_model(self): + def test_select_subclass_by_child_model(self) -> None: """ Confirm that passing a child model works the same as passing the select_related manually @@ -238,7 +244,7 @@ class InheritanceManagerUsingModelsTests(TestCase): self.assertEqual(objs.subclasses, objsmodels.subclasses) self.assertEqual(list(objs), list(objsmodels)) - def test_select_subclass_by_grandchild_model(self): + def test_select_subclass_by_grandchild_model(self) -> None: """ Confirm that passing a grandchild model works the same as passing the select_related manually @@ -251,7 +257,7 @@ class InheritanceManagerUsingModelsTests(TestCase): self.assertEqual(objs.subclasses, objsmodels.subclasses) self.assertEqual(list(objs), list(objsmodels)) - def test_selecting_all_subclasses_specifically_grandchildren(self): + def test_selecting_all_subclasses_specifically_grandchildren(self) -> None: """ A bare select_subclasses() should achieve the same results as doing select_subclasses and specifying all possible subclasses. @@ -268,7 +274,7 @@ class InheritanceManagerUsingModelsTests(TestCase): self.assertEqual(set(objs.subclasses), set(objsmodels.subclasses)) self.assertEqual(list(objs), list(objsmodels)) - def test_selecting_all_subclasses_specifically_children(self): + def test_selecting_all_subclasses_specifically_children(self) -> None: """ A bare select_subclasses() should achieve the same results as doing select_subclasses and specifying all possible subclasses. @@ -296,7 +302,7 @@ class InheritanceManagerUsingModelsTests(TestCase): self.assertEqual(set(objs.subclasses), set(objsmodels.subclasses)) self.assertEqual(list(objs), list(objsmodels)) - def test_select_subclass_just_self(self): + def test_select_subclass_just_self(self) -> None: """ Passing in the same model as the manager/queryset is bound against (ie: the root parent) should have no effect on the result set. @@ -312,7 +318,7 @@ class InheritanceManagerUsingModelsTests(TestCase): InheritanceManagerTestParent(pk=self.grandchild1_2.pk), ]) - def test_select_subclass_invalid_related_model(self): + def test_select_subclass_invalid_related_model(self) -> None: """ Confirming that giving a stupid model doesn't work. """ @@ -321,7 +327,7 @@ class InheritanceManagerUsingModelsTests(TestCase): InheritanceManagerTestParent.objects.select_subclasses( TimeFrame).order_by('pk') - def test_mixing_strings_and_classes_with_grandchildren(self): + def test_mixing_strings_and_classes_with_grandchildren(self) -> None: """ Given arguments consisting of both strings and model classes, ensure the right resolutions take place, accounting for the extra @@ -342,7 +348,7 @@ class InheritanceManagerUsingModelsTests(TestCase): ] self.assertEqual(list(objs), expecting2) - def test_mixing_strings_and_classes_with_children(self): + def test_mixing_strings_and_classes_with_children(self) -> None: """ Given arguments consisting of both strings and model classes, ensure the right resolutions take place, walking down as far as @@ -364,7 +370,7 @@ class InheritanceManagerUsingModelsTests(TestCase): ] self.assertEqual(list(objs), expecting2) - def test_duplications(self): + def test_duplications(self) -> None: """ Check that even if the same thing is provided as a string and a model that the right results are retrieved. @@ -381,7 +387,7 @@ class InheritanceManagerUsingModelsTests(TestCase): InheritanceManagerTestParent(pk=self.grandchild1_2.pk), ]) - def test_child_doesnt_accidentally_get_parent(self): + def test_child_doesnt_accidentally_get_parent(self) -> None: """ Given a Child model which also has an InheritanceManager, none of the returned objects should be Parent objects. @@ -394,7 +400,7 @@ class InheritanceManagerUsingModelsTests(TestCase): InheritanceManagerTestChild1(pk=self.grandchild1_2.pk), ], list(objs)) - def test_manually_specifying_parent_fk_only_specific_child(self): + def test_manually_specifying_parent_fk_only_specific_child(self) -> None: """ given a Model which inherits from another Model, but also declares the OneToOne link manually using `related_name` and `parent_link`, @@ -418,7 +424,7 @@ class InheritanceManagerUsingModelsTests(TestCase): self.assertEqual(set(results.subclasses), set(expected_related_names)) - def test_extras_descend(self): + def test_extras_descend(self) -> None: """ Ensure that extra(select=) values are copied onto sub-classes. """ @@ -427,25 +433,25 @@ class InheritanceManagerUsingModelsTests(TestCase): ) self.assertTrue(all(result.foo == (result.id + 1) for result in results)) - def test_limit_to_specific_subclass(self): + def test_limit_to_specific_subclass(self) -> None: child3 = InheritanceManagerTestChild3.objects.create() results = InheritanceManagerTestParent.objects.instance_of(InheritanceManagerTestChild3) self.assertEqual([child3], list(results)) - def test_limit_to_specific_subclass_with_custom_db_column(self): + def test_limit_to_specific_subclass_with_custom_db_column(self) -> None: item = InheritanceManagerTestChild3_1.objects.create() results = InheritanceManagerTestParent.objects.instance_of(InheritanceManagerTestChild3_1) self.assertEqual([item], list(results)) - def test_limit_to_specific_grandchild_class(self): + def test_limit_to_specific_grandchild_class(self) -> None: grandchild1 = InheritanceManagerTestGrandChild1.objects.get() results = InheritanceManagerTestParent.objects.instance_of(InheritanceManagerTestGrandChild1) self.assertEqual([grandchild1], list(results)) - def test_limit_to_child_fetches_grandchildren_as_child_class(self): + def test_limit_to_child_fetches_grandchildren_as_child_class(self) -> None: # Not sure if this is the desired behaviour...? children = InheritanceManagerTestChild1.objects.all() @@ -453,7 +459,7 @@ class InheritanceManagerUsingModelsTests(TestCase): self.assertEqual(set(children), set(results)) - def test_can_fetch_limited_class_grandchildren(self): + def test_can_fetch_limited_class_grandchildren(self) -> None: # Not sure if this is the desired behaviour...? children = InheritanceManagerTestChild1.objects.select_subclasses() @@ -461,7 +467,7 @@ class InheritanceManagerUsingModelsTests(TestCase): self.assertEqual(set(children), set(results)) - def test_selecting_multiple_instance_classes(self): + def test_selecting_multiple_instance_classes(self) -> None: child3 = InheritanceManagerTestChild3.objects.create() children1 = InheritanceManagerTestChild1.objects.all() @@ -469,7 +475,7 @@ class InheritanceManagerUsingModelsTests(TestCase): self.assertEqual(set([child3] + list(children1)), set(results)) - def test_selecting_multiple_instance_classes_including_grandchildren(self): + def test_selecting_multiple_instance_classes_including_grandchildren(self) -> None: child3 = InheritanceManagerTestChild3.objects.create() grandchild1 = InheritanceManagerTestGrandChild1.objects.get() @@ -477,7 +483,7 @@ class InheritanceManagerUsingModelsTests(TestCase): self.assertEqual({child3, grandchild1}, set(results)) - def test_select_subclasses_interaction_with_instance_of(self): + def test_select_subclasses_interaction_with_instance_of(self) -> None: child3 = InheritanceManagerTestChild3.objects.create() results = InheritanceManagerTestParent.objects.select_subclasses(InheritanceManagerTestChild1).instance_of(InheritanceManagerTestChild3) @@ -486,7 +492,7 @@ class InheritanceManagerUsingModelsTests(TestCase): class InheritanceManagerRelatedTests(InheritanceManagerTests): - def setUp(self): + def setUp(self) -> None: self.related = InheritanceManagerTestRelated.objects.create() self.child1 = InheritanceManagerTestChild1.objects.create( related=self.related) @@ -495,16 +501,16 @@ class InheritanceManagerRelatedTests(InheritanceManagerTests): self.grandchild1 = InheritanceManagerTestGrandChild1.objects.create(related=self.related) self.grandchild1_2 = InheritanceManagerTestGrandChild1_2.objects.create(related=self.related) - def get_manager(self): + def get_manager(self) -> RelatedManager[InheritanceManagerTestParent]: # type: ignore[override] return self.related.imtests - def test_get_method_with_select_subclasses(self): + def test_get_method_with_select_subclasses(self) -> None: self.assertEqual( InheritanceManagerTestParent.objects.select_subclasses().get( id=self.child1.id), self.child1) - def test_get_method_with_select_subclasses_check_for_useless_join(self): + def test_get_method_with_select_subclasses_check_for_useless_join(self) -> None: child4 = InheritanceManagerTestChild4.objects.create(related=self.related, other_onetoone=self.child1) self.assertEqual( str(InheritanceManagerTestChild4.objects.select_subclasses().filter( @@ -512,26 +518,26 @@ class InheritanceManagerRelatedTests(InheritanceManagerTests): str(InheritanceManagerTestChild4.objects.select_subclasses().select_related(None).filter( id=child4.id).query)) - def test_annotate_with_select_subclasses(self): + def test_annotate_with_select_subclasses(self) -> None: qs = InheritanceManagerTestParent.objects.select_subclasses().annotate( models.Count('id')) self.assertEqual(qs.get(id=self.child1.id).id__count, 1) - def test_annotate_with_named_arguments_with_select_subclasses(self): + def test_annotate_with_named_arguments_with_select_subclasses(self) -> None: qs = InheritanceManagerTestParent.objects.select_subclasses().annotate( test_count=models.Count('id')) self.assertEqual(qs.get(id=self.child1.id).test_count, 1) - def test_annotate_before_select_subclasses(self): + def test_annotate_before_select_subclasses(self) -> None: qs = InheritanceManagerTestParent.objects.annotate( models.Count('id')).select_subclasses() self.assertEqual(qs.get(id=self.child1.id).id__count, 1) - def test_annotate_with_named_arguments_before_select_subclasses(self): + def test_annotate_with_named_arguments_before_select_subclasses(self) -> None: qs = InheritanceManagerTestParent.objects.annotate( test_count=models.Count('id')).select_subclasses() self.assertEqual(qs.get(id=self.child1.id).test_count, 1) - def test_clone_when_inheritance_queryset_selects_subclasses_should_clone_them_too(self): + def test_clone_when_inheritance_queryset_selects_subclasses_should_clone_them_too(self) -> None: qs = InheritanceManagerTestParent.objects.select_subclasses() self.assertEqual(qs.subclasses, qs._clone().subclasses) diff --git a/tests/test_managers/test_join_manager.py b/tests/test_managers/test_join_manager.py index 3a6699c..44bdcfc 100644 --- a/tests/test_managers/test_join_manager.py +++ b/tests/test_managers/test_join_manager.py @@ -6,7 +6,7 @@ from tests.models import BoxJoinModel, JoinItemForeignKey class JoinManagerTest(TestCase): - def setUp(self): + def setUp(self) -> None: for i in range(20): BoxJoinModel.objects.create(name=f'name_{i}') @@ -15,24 +15,24 @@ class JoinManagerTest(TestCase): ) JoinItemForeignKey.objects.create(weight=20) - def test_self_join(self): + def test_self_join(self) -> None: a_slice = BoxJoinModel.objects.all()[0:10] with self.assertNumQueries(1): result = a_slice.join() self.assertEqual(result.count(), 10) - def test_self_join_with_where_statement(self): + def test_self_join_with_where_statement(self) -> None: qs = BoxJoinModel.objects.filter(name='name_1') result = qs.join() self.assertEqual(result.count(), 1) - def test_join_with_other_qs(self): + def test_join_with_other_qs(self) -> None: item_qs = JoinItemForeignKey.objects.filter(weight=10) boxes = BoxJoinModel.objects.all().join(qs=item_qs) self.assertEqual(boxes.count(), 1) self.assertEqual(boxes[0].name, 'name_1') - def test_reverse_join(self): + def test_reverse_join(self) -> None: box_qs = BoxJoinModel.objects.filter(name='name_1') items = JoinItemForeignKey.objects.all().join(box_qs) self.assertEqual(items.count(), 1) diff --git a/tests/test_managers/test_query_manager.py b/tests/test_managers/test_query_manager.py index 85aa9e9..03ec814 100644 --- a/tests/test_managers/test_query_manager.py +++ b/tests/test_managers/test_query_manager.py @@ -6,7 +6,7 @@ from tests.models import Post class QueryManagerTests(TestCase): - def setUp(self): + def setUp(self) -> None: data = ((True, True, 0), (True, False, 4), (False, False, 2), @@ -16,14 +16,14 @@ class QueryManagerTests(TestCase): for p, c, o in data: Post.objects.create(published=p, confirmed=c, order=o) - def test_passing_kwargs(self): + def test_passing_kwargs(self) -> None: qs = Post.public.all() self.assertEqual([p.order for p in qs], [0, 1, 4, 5]) - def test_passing_Q(self): + def test_passing_Q(self) -> None: qs = Post.public_confirmed.all() self.assertEqual([p.order for p in qs], [0, 1]) - def test_ordering(self): + def test_ordering(self) -> None: qs = Post.public_reversed.all() self.assertEqual([p.order for p in qs], [5, 4, 1, 0]) diff --git a/tests/test_managers/test_softdelete_manager.py b/tests/test_managers/test_softdelete_manager.py index e4c64b5..01fffc4 100644 --- a/tests/test_managers/test_softdelete_manager.py +++ b/tests/test_managers/test_softdelete_manager.py @@ -7,21 +7,21 @@ from tests.models import CustomSoftDelete class CustomSoftDeleteManagerTests(TestCase): - def test_custom_manager_empty(self): + def test_custom_manager_empty(self) -> None: qs = CustomSoftDelete.available_objects.only_read() self.assertEqual(qs.count(), 0) - def test_custom_qs_empty(self): + def test_custom_qs_empty(self) -> None: qs = CustomSoftDelete.available_objects.all().only_read() self.assertEqual(qs.count(), 0) - def test_is_read(self): + def test_is_read(self) -> None: for is_read in [True, False, True, False]: CustomSoftDelete.available_objects.create(is_read=is_read) qs = CustomSoftDelete.available_objects.only_read() self.assertEqual(qs.count(), 2) - def test_is_read_removed(self): + def test_is_read_removed(self) -> None: for is_read, is_removed in [(True, True), (True, False), (False, False), (False, True)]: CustomSoftDelete.available_objects.create(is_read=is_read, is_removed=is_removed) qs = CustomSoftDelete.available_objects.only_read() diff --git a/tests/test_managers/test_status_manager.py b/tests/test_managers/test_status_manager.py index ef467a0..a4b69b2 100644 --- a/tests/test_managers/test_status_manager.py +++ b/tests/test_managers/test_status_manager.py @@ -10,10 +10,10 @@ from tests.models import StatusManagerAdded class StatusManagerAddedTests(TestCase): - def test_manager_available(self): + def test_manager_available(self) -> None: self.assertTrue(isinstance(StatusManagerAdded.active, QueryManager)) - def test_conflict_error(self): + def test_conflict_error(self) -> None: with self.assertRaises(ImproperlyConfigured): class ErrorModel(StatusModel): STATUS = ( diff --git a/tests/test_miscellaneous.py b/tests/test_miscellaneous.py index 8faaedd..0fbfecc 100644 --- a/tests/test_miscellaneous.py +++ b/tests/test_miscellaneous.py @@ -7,23 +7,23 @@ from model_utils.fields import get_excerpt class MigrationsTests(TestCase): - def test_makemigrations(self): + def test_makemigrations(self) -> None: call_command('makemigrations', dry_run=True) class GetExcerptTests(TestCase): - def test_split(self): + def test_split(self) -> None: e = get_excerpt("some content\n\n\n\nsome more") self.assertEqual(e, 'some content\n') - def test_auto_split(self): + def test_auto_split(self) -> None: e = get_excerpt("para one\n\npara two\n\npara three") self.assertEqual(e, 'para one\n\npara two') - def test_middle_of_para(self): + def test_middle_of_para(self) -> None: e = get_excerpt("some text\n\nmore text") self.assertEqual(e, 'some text') - def test_middle_of_line(self): + def test_middle_of_line(self) -> None: e = get_excerpt("some text more text") self.assertEqual(e, "some text more text") diff --git a/tests/test_models/test_deferred_fields.py b/tests/test_models/test_deferred_fields.py index a3a4283..f51e5eb 100644 --- a/tests/test_models/test_deferred_fields.py +++ b/tests/test_models/test_deferred_fields.py @@ -6,7 +6,7 @@ from tests.models import ModelWithCustomDescriptor class CustomDescriptorTests(TestCase): - def setUp(self): + def setUp(self) -> None: self.instance = ModelWithCustomDescriptor.objects.create( custom_field='1', tracked_custom_field='1', @@ -14,7 +14,7 @@ class CustomDescriptorTests(TestCase): tracked_regular_field=1, ) - def test_custom_descriptor_works(self): + def test_custom_descriptor_works(self) -> None: instance = self.instance self.assertEqual(instance.custom_field, '1') self.assertEqual(instance.__dict__['custom_field'], 1) @@ -27,7 +27,7 @@ class CustomDescriptorTests(TestCase): self.assertEqual(instance.custom_field, '2') self.assertEqual(instance.__dict__['custom_field'], 2) - def test_deferred(self): + def test_deferred(self) -> None: instance = ModelWithCustomDescriptor.objects.only('id').get( pk=self.instance.pk) self.assertIn('custom_field', instance.get_deferred_fields()) diff --git a/tests/test_models/test_softdeletable_model.py b/tests/test_models/test_softdeletable_model.py index 38332d7..1f58f43 100644 --- a/tests/test_models/test_softdeletable_model.py +++ b/tests/test_models/test_softdeletable_model.py @@ -7,7 +7,7 @@ from tests.models import SoftDeletable class SoftDeletableModelTests(TestCase): - def test_can_only_see_not_removed_entries(self): + def test_can_only_see_not_removed_entries(self) -> None: SoftDeletable.available_objects.create(name='a', is_removed=True) SoftDeletable.available_objects.create(name='b', is_removed=False) @@ -16,7 +16,7 @@ class SoftDeletableModelTests(TestCase): self.assertEqual(queryset.count(), 1) self.assertEqual(queryset[0].name, 'b') - def test_instance_cannot_be_fully_deleted(self): + def test_instance_cannot_be_fully_deleted(self) -> None: instance = SoftDeletable.available_objects.create(name='a') instance.delete() @@ -24,7 +24,7 @@ class SoftDeletableModelTests(TestCase): self.assertEqual(SoftDeletable.available_objects.count(), 0) self.assertEqual(SoftDeletable.all_objects.count(), 1) - def test_instance_cannot_be_fully_deleted_via_queryset(self): + def test_instance_cannot_be_fully_deleted_via_queryset(self) -> None: SoftDeletable.available_objects.create(name='a') SoftDeletable.available_objects.all().delete() @@ -32,12 +32,12 @@ class SoftDeletableModelTests(TestCase): self.assertEqual(SoftDeletable.available_objects.count(), 0) self.assertEqual(SoftDeletable.all_objects.count(), 1) - def test_delete_instance_no_connection(self): + def test_delete_instance_no_connection(self) -> None: obj = SoftDeletable.available_objects.create(name='a') self.assertRaises(ConnectionDoesNotExist, obj.delete, using='other') - def test_instance_purge(self): + def test_instance_purge(self) -> None: instance = SoftDeletable.available_objects.create(name='a') instance.delete(soft=False) @@ -45,11 +45,11 @@ class SoftDeletableModelTests(TestCase): self.assertEqual(SoftDeletable.available_objects.count(), 0) self.assertEqual(SoftDeletable.all_objects.count(), 0) - def test_instance_purge_no_connection(self): + def test_instance_purge_no_connection(self) -> None: instance = SoftDeletable.available_objects.create(name='a') self.assertRaises(ConnectionDoesNotExist, instance.delete, using='other', soft=False) - def test_deprecation_warning(self): + def test_deprecation_warning(self) -> None: self.assertWarns(DeprecationWarning, SoftDeletable.objects.all) diff --git a/tests/test_models/test_status_model.py b/tests/test_models/test_status_model.py index 35c3808..8d6e89d 100644 --- a/tests/test_models/test_status_model.py +++ b/tests/test_models/test_status_model.py @@ -9,12 +9,12 @@ from tests.models import CustomManagerStatusModel, Status, StatusPlainTuple class StatusModelTests(TestCase): - def setUp(self): + def setUp(self) -> None: self.model = Status self.on_hold = Status.STATUS.on_hold self.active = Status.STATUS.active - def test_created(self): + def test_created(self) -> None: with time_machine.travel(datetime(2016, 1, 1)): c1 = self.model.objects.create() self.assertTrue(c1.status_changed, datetime(2016, 1, 1)) @@ -23,7 +23,7 @@ class StatusModelTests(TestCase): self.assertEqual(self.model.active.count(), 2) self.assertEqual(self.model.deleted.count(), 0) - def test_modification(self): + def test_modification(self) -> None: t1 = self.model.objects.create() date_created = t1.status_changed t1.status = self.on_hold @@ -39,7 +39,7 @@ class StatusModelTests(TestCase): t1.save() self.assertTrue(t1.status_changed > date_active_again) - def test_save_with_update_fields_overrides_status_changed_provided(self): + def test_save_with_update_fields_overrides_status_changed_provided(self) -> None: ''' Tests if the save method updated status_changed field accordingly when update_fields is used as an argument @@ -54,7 +54,7 @@ class StatusModelTests(TestCase): self.assertEqual(t1.status_changed, datetime(2020, 1, 2, tzinfo=timezone.utc)) - def test_save_with_update_fields_overrides_status_changed_not_provided(self): + def test_save_with_update_fields_overrides_status_changed_not_provided(self) -> None: ''' Tests if the save method updated status_changed field accordingly when update_fields is used as an argument @@ -71,7 +71,7 @@ class StatusModelTests(TestCase): class StatusModelPlainTupleTests(StatusModelTests): - def setUp(self): + def setUp(self) -> None: self.model = StatusPlainTuple self.on_hold = StatusPlainTuple.STATUS[2][0] self.active = StatusPlainTuple.STATUS[0][0] @@ -79,7 +79,7 @@ class StatusModelPlainTupleTests(StatusModelTests): class StatusModelDefaultManagerTests(TestCase): - def test_default_manager_is_not_status_model_generated_ones(self): + def test_default_manager_is_not_status_model_generated_ones(self) -> None: # Regression test for GH-251 # The logic behind order for managers seems to have changed in Django 1.10 # and affects default manager. diff --git a/tests/test_models/test_timeframed_model.py b/tests/test_models/test_timeframed_model.py index 3cf3d73..246b399 100644 --- a/tests/test_models/test_timeframed_model.py +++ b/tests/test_models/test_timeframed_model.py @@ -12,36 +12,36 @@ from tests.models import TimeFrame, TimeFrameManagerAdded class TimeFramedModelTests(TestCase): - def setUp(self): + def setUp(self) -> None: self.now = datetime.now() - def test_not_yet_begun(self): + def test_not_yet_begun(self) -> None: TimeFrame.objects.create(start=self.now + timedelta(days=2)) self.assertEqual(TimeFrame.timeframed.count(), 0) - def test_finished(self): + def test_finished(self) -> None: TimeFrame.objects.create(end=self.now - timedelta(days=1)) self.assertEqual(TimeFrame.timeframed.count(), 0) - def test_no_end(self): + def test_no_end(self) -> None: TimeFrame.objects.create(start=self.now - timedelta(days=10)) self.assertEqual(TimeFrame.timeframed.count(), 1) - def test_no_start(self): + def test_no_start(self) -> None: TimeFrame.objects.create(end=self.now + timedelta(days=2)) self.assertEqual(TimeFrame.timeframed.count(), 1) - def test_within_range(self): + def test_within_range(self) -> None: TimeFrame.objects.create(start=self.now - timedelta(days=1), end=self.now + timedelta(days=1)) self.assertEqual(TimeFrame.timeframed.count(), 1) class TimeFrameManagerAddedTests(TestCase): - def test_manager_available(self): + def test_manager_available(self) -> None: self.assertTrue(isinstance(TimeFrameManagerAdded.timeframed, QueryManager)) - def test_conflict_error(self): + def test_conflict_error(self) -> None: with self.assertRaises(ImproperlyConfigured): class ErrorModel(TimeFramedModel): timeframed = models.BooleanField() diff --git a/tests/test_models/test_timestamped_model.py b/tests/test_models/test_timestamped_model.py index 193af3e..1cc8d51 100644 --- a/tests/test_models/test_timestamped_model.py +++ b/tests/test_models/test_timestamped_model.py @@ -9,19 +9,19 @@ from tests.models import TimeStamp, TimeStampWithStatusModel class TimeStampedModelTests(TestCase): - def test_created(self): + def test_created(self) -> None: with time_machine.travel(datetime(2016, 1, 1, tzinfo=timezone.utc)): t1 = TimeStamp.objects.create() self.assertEqual(t1.created, datetime(2016, 1, 1, tzinfo=timezone.utc)) - def test_created_sets_modified(self): + def test_created_sets_modified(self) -> None: ''' Ensure that on creation that modified is set exactly equal to created. ''' t1 = TimeStamp.objects.create() self.assertEqual(t1.created, t1.modified) - def test_modified(self): + def test_modified(self) -> None: with time_machine.travel(datetime(2016, 1, 1, tzinfo=timezone.utc)): t1 = TimeStamp.objects.create() @@ -30,7 +30,7 @@ class TimeStampedModelTests(TestCase): self.assertEqual(t1.modified, datetime(2016, 1, 2, tzinfo=timezone.utc)) - def test_overriding_created_via_object_creation_also_uses_creation_date_for_modified(self): + def test_overriding_created_via_object_creation_also_uses_creation_date_for_modified(self) -> None: """ Setting the created date when first creating an object should be permissible. @@ -40,7 +40,7 @@ class TimeStampedModelTests(TestCase): self.assertEqual(t1.created, different_date) self.assertEqual(t1.modified, different_date) - def test_overriding_modified_via_object_creation(self): + def test_overriding_modified_via_object_creation(self) -> None: """ Setting the modified date explicitly should be possible when first creating an object, but not thereafter. @@ -50,7 +50,7 @@ class TimeStampedModelTests(TestCase): self.assertEqual(t1.modified, different_date) self.assertNotEqual(t1.created, different_date) - def test_overriding_created_after_object_created(self): + def test_overriding_created_after_object_created(self) -> None: """ The created date may be changed post-create """ @@ -60,7 +60,7 @@ class TimeStampedModelTests(TestCase): t1.save() self.assertEqual(t1.created, different_date) - def test_overriding_modified_after_object_created(self): + def test_overriding_modified_after_object_created(self) -> None: """ The modified date should always be updated when the object is saved, regardless of attempts to change it. @@ -71,7 +71,7 @@ class TimeStampedModelTests(TestCase): t1.save() self.assertNotEqual(t1.modified, different_date) - def test_overrides_using_save(self): + def test_overrides_using_save(self) -> None: """ The first time an object is saved, allow modification of both created and modified fields. @@ -92,7 +92,7 @@ class TimeStampedModelTests(TestCase): self.assertNotEqual(t1.modified, different_date2) self.assertNotEqual(t1.modified, different_date) - def test_save_with_update_fields_overrides_modified_provided_within_a(self): + def test_save_with_update_fields_overrides_modified_provided_within_a(self) -> None: """ Tests if the save method updated modified field accordingly when update_fields is used as an argument @@ -113,7 +113,7 @@ class TimeStampedModelTests(TestCase): t1.save(update_fields=update_fields) self.assertEqual(t1.modified, datetime(2020, 1, 2, tzinfo=timezone.utc)) - def test_save_is_skipped_for_empty_update_fields_iterable(self): + def test_save_is_skipped_for_empty_update_fields_iterable(self) -> None: tests = ( [], # list (), # tuple @@ -133,7 +133,7 @@ class TimeStampedModelTests(TestCase): self.assertEqual(t1.test_field, 0) self.assertEqual(t1.modified, datetime(2020, 1, 1, tzinfo=timezone.utc)) - def test_save_updates_modified_value_when_update_fields_explicitly_set_to_none(self): + def test_save_updates_modified_value_when_update_fields_explicitly_set_to_none(self) -> None: with time_machine.travel(datetime(2020, 1, 1, tzinfo=timezone.utc)): t1 = TimeStamp.objects.create() @@ -142,7 +142,7 @@ class TimeStampedModelTests(TestCase): self.assertEqual(t1.modified, datetime(2020, 1, 2, tzinfo=timezone.utc)) - def test_model_inherit_timestampmodel_and_statusmodel(self): + def test_model_inherit_timestampmodel_and_statusmodel(self) -> None: with time_machine.travel(datetime(2020, 1, 1, tzinfo=timezone.utc)): t1 = TimeStampWithStatusModel.objects.create() diff --git a/tests/test_models/test_uuid_model.py b/tests/test_models/test_uuid_model.py index 62dcae3..d9d71d9 100644 --- a/tests/test_models/test_uuid_model.py +++ b/tests/test_models/test_uuid_model.py @@ -7,13 +7,13 @@ from tests.models import CustomNotPrimaryUUIDModel, CustomUUIDModel class UUIDFieldTests(TestCase): - def test_uuid_model_with_uuid_field_as_primary_key(self): + def test_uuid_model_with_uuid_field_as_primary_key(self) -> None: instance = CustomUUIDModel() instance.save() self.assertEqual(instance.id.__class__.__name__, 'UUID') self.assertEqual(instance.id, instance.pk) - def test_uuid_model_with_uuid_field_as_not_primary_key(self): + def test_uuid_model_with_uuid_field_as_not_primary_key(self) -> None: instance = CustomNotPrimaryUUIDModel() instance.save() self.assertEqual(instance.uuid.__class__.__name__, 'UUID')