Debian Codegraph @

tests/model_regress/tests.py

raw
1 import copy
2 import datetime
3 from operator import attrgetter
4
5 from django.core.exceptions import ValidationError
6 from django.db import models, router
7 from django.db.models.sql import InsertQuery
8 from django.test import TestCase, skipUnlessDBFeature
9 from django.test.utils import isolate_apps
10 from django.utils.timezone import get_fixed_timezone
11
12 from .models import (
13 Article,
14 Department,
15 Event,
16 Model1,
17 Model2,
18 Model3,
19 NonAutoPK,
20 Party,
21 Worker,
22 )
23
24
25 class ModelTests(TestCase):
26 def test_model_init_too_many_args(self):
27 msg = "Number of args exceeds number of fields"
28 with self.assertRaisesMessage(IndexError, msg):
29 Worker(1, 2, 3, 4)
30
31 # The bug is that the following queries would raise:
32 # "TypeError: Related Field has invalid lookup: gte"
33 def test_related_gte_lookup(self):
34 """
35 Regression test for #10153: foreign key __gte lookups.
36 """
37 Worker.objects.filter(department__gte=0)
38
39 def test_related_lte_lookup(self):
40 """
41 Regression test for #10153: foreign key __lte lookups.
42 """
43 Worker.objects.filter(department__lte=0)
44
45 def test_sql_insert_compiler_return_id_attribute(self):
46 """
47 Regression test for #14019: SQLInsertCompiler.as_sql() failure
48 """
49 db = router.db_for_write(Party)
50 query = InsertQuery(Party)
51 query.insert_values([Party._meta.fields[0]], [], raw=False)
52 # this line will raise an AttributeError without the accompanying fix
53 query.get_compiler(using=db).as_sql()
54
55 def test_empty_choice(self):
56 # NOTE: Part of the regression test here is merely parsing the model
57 # declaration. The verbose_name, in particular, did not always work.
58 a = Article.objects.create(
59 headline="Look at me!", pub_date=datetime.datetime.now()
60 )
61 # An empty choice field should return None for the display name.
62 self.assertIs(a.get_status_display(), None)
63
64 # Empty strings should be returned as string
65 a = Article.objects.get(pk=a.pk)
66 self.assertEqual(a.misc_data, "")
67
68 def test_long_textfield(self):
69 # TextFields can hold more than 4000 characters (this was broken in
70 # Oracle).
71 a = Article.objects.create(
72 headline="Really, really big",
73 pub_date=datetime.datetime.now(),
74 article_text="ABCDE" * 1000,
75 )
76 a = Article.objects.get(pk=a.pk)
77 self.assertEqual(len(a.article_text), 5000)
78
79 def test_long_unicode_textfield(self):
80 # TextFields can hold more than 4000 bytes also when they are
81 # less than 4000 characters
82 a = Article.objects.create(
83 headline="Really, really big",
84 pub_date=datetime.datetime.now(),
85 article_text="\u05d0\u05d1\u05d2" * 1000,
86 )
87 a = Article.objects.get(pk=a.pk)
88 self.assertEqual(len(a.article_text), 3000)
89
90 def test_date_lookup(self):
91 # Regression test for #659
92 Party.objects.create(when=datetime.datetime(1999, 12, 31))
93 Party.objects.create(when=datetime.datetime(1998, 12, 31))
94 Party.objects.create(when=datetime.datetime(1999, 1, 1))
95 Party.objects.create(when=datetime.datetime(1, 3, 3))
96 self.assertQuerySetEqual(Party.objects.filter(when__month=2), [])
97 self.assertQuerySetEqual(
98 Party.objects.filter(when__month=1),
99 [datetime.date(1999, 1, 1)],
100 attrgetter("when"),
101 )
102 self.assertQuerySetEqual(
103 Party.objects.filter(when__month=12),
104 [
105 datetime.date(1999, 12, 31),
106 datetime.date(1998, 12, 31),
107 ],
108 attrgetter("when"),
109 ordered=False,
110 )
111 self.assertQuerySetEqual(
112 Party.objects.filter(when__year=1998),
113 [
114 datetime.date(1998, 12, 31),
115 ],
116 attrgetter("when"),
117 )
118 # Regression test for #8510
119 self.assertQuerySetEqual(
120 Party.objects.filter(when__day="31"),
121 [
122 datetime.date(1999, 12, 31),
123 datetime.date(1998, 12, 31),
124 ],
125 attrgetter("when"),
126 ordered=False,
127 )
128 self.assertQuerySetEqual(
129 Party.objects.filter(when__month="12"),
130 [
131 datetime.date(1999, 12, 31),
132 datetime.date(1998, 12, 31),
133 ],
134 attrgetter("when"),
135 ordered=False,
136 )
137 self.assertQuerySetEqual(
138 Party.objects.filter(when__year="1998"),
139 [
140 datetime.date(1998, 12, 31),
141 ],
142 attrgetter("when"),
143 )
144
145 # Regression test for #18969
146 self.assertQuerySetEqual(
147 Party.objects.filter(when__year=1),
148 [
149 datetime.date(1, 3, 3),
150 ],
151 attrgetter("when"),
152 )
153 self.assertQuerySetEqual(
154 Party.objects.filter(when__year="1"),
155 [
156 datetime.date(1, 3, 3),
157 ],
158 attrgetter("when"),
159 )
160
161 def test_date_filter_null(self):
162 # Date filtering was failing with NULL date values in SQLite
163 # (regression test for #3501, among other things).
164 Party.objects.create(when=datetime.datetime(1999, 1, 1))
165 Party.objects.create()
166 p = Party.objects.filter(when__month=1)[0]
167 self.assertEqual(p.when, datetime.date(1999, 1, 1))
168 self.assertQuerySetEqual(
169 Party.objects.filter(pk=p.pk).dates("when", "month"),
170 [1],
171 attrgetter("month"),
172 )
173
174 def test_get_next_prev_by_field(self):
175 # get_next_by_FIELD() and get_previous_by_FIELD() don't crash when
176 # microseconds values are stored in the database.
177 Event.objects.create(when=datetime.datetime(2000, 1, 1, 16, 0, 0))
178 Event.objects.create(when=datetime.datetime(2000, 1, 1, 6, 1, 1))
179 Event.objects.create(when=datetime.datetime(2000, 1, 1, 13, 1, 1))
180 e = Event.objects.create(when=datetime.datetime(2000, 1, 1, 12, 0, 20, 24))
181 self.assertEqual(
182 e.get_next_by_when().when, datetime.datetime(2000, 1, 1, 13, 1, 1)
183 )
184 self.assertEqual(
185 e.get_previous_by_when().when, datetime.datetime(2000, 1, 1, 6, 1, 1)
186 )
187
188 def test_get_next_prev_by_field_unsaved(self):
189 msg = "get_next/get_previous cannot be used on unsaved objects."
190 with self.assertRaisesMessage(ValueError, msg):
191 Event().get_next_by_when()
192 with self.assertRaisesMessage(ValueError, msg):
193 Event().get_previous_by_when()
194
195 def test_primary_key_foreign_key_types(self):
196 # Check Department and Worker (non-default PK type)
197 d = Department.objects.create(id=10, name="IT")
198 w = Worker.objects.create(department=d, name="Full-time")
199 self.assertEqual(str(w), "Full-time")
200
201 @skipUnlessDBFeature("supports_timezones")
202 def test_timezones(self):
203 # Saving and updating with timezone-aware datetime Python objects.
204 # Regression test for #10443.
205 # The idea is that all these creations and saving should work without
206 # crashing. It's not rocket science.
207 dt1 = datetime.datetime(2008, 8, 31, 16, 20, tzinfo=get_fixed_timezone(600))
208 dt2 = datetime.datetime(2008, 8, 31, 17, 20, tzinfo=get_fixed_timezone(600))
209 obj = Article.objects.create(
210 headline="A headline", pub_date=dt1, article_text="foo"
211 )
212 obj.pub_date = dt2
213 obj.save()
214 self.assertEqual(
215 Article.objects.filter(headline="A headline").update(pub_date=dt1), 1
216 )
217
218 def test_chained_fks(self):
219 """
220 Chained foreign keys with to_field produce incorrect query.
221 """
222
223 m1 = Model1.objects.create(pkey=1000)
224 m2 = Model2.objects.create(model1=m1)
225 m3 = Model3.objects.create(model2=m2)
226
227 # this is the actual test for #18432
228 m3 = Model3.objects.get(model2=1000)
229 m3.model2
230
231 @isolate_apps("model_regress")
232 def test_metaclass_can_access_attribute_dict(self):
233 """
234 Model metaclasses have access to the class attribute dict in
235 __init__() (#30254).
236 """
237
238 class HorseBase(models.base.ModelBase):
239 def __init__(cls, name, bases, attrs):
240 super().__init__(name, bases, attrs)
241 cls.horns = 1 if "magic" in attrs else 0
242
243 class Horse(models.Model, metaclass=HorseBase):
244 name = models.CharField(max_length=255)
245 magic = True
246
247 self.assertEqual(Horse.horns, 1)
248
249
250 class ModelValidationTest(TestCase):
251 def test_pk_validation(self):
252 NonAutoPK.objects.create(name="one")
253 again = NonAutoPK(name="one")
254 with self.assertRaises(ValidationError):
255 again.validate_unique()
256
257
258 class EvaluateMethodTest(TestCase):
259 """
260 Regression test for #13640: cannot filter by objects with 'evaluate' attr
261 """
262
263 def test_model_with_evaluate_method(self):
264 """
265 You can filter by objects that have an 'evaluate' attr
266 """
267 dept = Department.objects.create(pk=1, name="abc")
268 dept.evaluate = "abc"
269 Worker.objects.filter(department=dept)
270
271
272 class ModelFieldsCacheTest(TestCase):
273 def test_fields_cache_reset_on_copy(self):
274 department1 = Department.objects.create(id=1, name="department1")
275 department2 = Department.objects.create(id=2, name="department2")
276 worker1 = Worker.objects.create(name="worker", department=department1)
277 worker2 = copy.copy(worker1)
278
279 self.assertEqual(worker2.department, department1)
280 # Changing related fields doesn't mutate the base object.
281 worker2.department = department2
282 self.assertEqual(worker2.department, department2)
283 self.assertEqual(worker1.department, department1)