Debian Codegraph @

tests/field_defaults/tests.py

raw
1 from datetime import datetime
2 from decimal import Decimal
3 from math import pi
4
5 from django.core.exceptions import ValidationError
6 from django.db import connection
7 from django.db.models import Case, F, FloatField, Value, When
8 from django.db.models.expressions import (
9 Expression,
10 ExpressionList,
11 ExpressionWrapper,
12 Func,
13 OrderByList,
14 RawSQL,
15 )
16 from django.db.models.functions import Collate
17 from django.db.models.lookups import GreaterThan
18 from django.test import (
19 SimpleTestCase,
20 TestCase,
21 override_settings,
22 skipIfDBFeature,
23 skipUnlessDBFeature,
24 )
25 from django.utils import timezone
26
27 from .models import (
28 Article,
29 DBArticle,
30 DBDefaults,
31 DBDefaultsFK,
32 DBDefaultsFunction,
33 DBDefaultsPK,
34 )
35
36
37 class DefaultTests(TestCase):
38 def test_field_defaults(self):
39 a = Article()
40 now = datetime.now()
41 a.save()
42
43 self.assertIsInstance(a.id, int)
44 self.assertEqual(a.headline, "Default headline")
45 self.assertLess((now - a.pub_date).seconds, 5)
46
47 @skipUnlessDBFeature(
48 "can_return_columns_from_insert", "supports_expression_defaults"
49 )
50 def test_field_db_defaults_returning(self):
51 a = DBArticle()
52 a.save()
53 self.assertIsInstance(a.id, int)
54 self.assertEqual(a.headline, "Default headline")
55 self.assertIsInstance(a.pub_date, datetime)
56 self.assertEqual(a.cost, Decimal("3.33"))
57
58 @skipIfDBFeature("can_return_columns_from_insert")
59 @skipUnlessDBFeature("supports_expression_defaults")
60 def test_field_db_defaults_refresh(self):
61 a = DBArticle()
62 a.save()
63 a.refresh_from_db()
64 self.assertIsInstance(a.id, int)
65 self.assertEqual(a.headline, "Default headline")
66 self.assertIsInstance(a.pub_date, datetime)
67 self.assertEqual(a.cost, Decimal("3.33"))
68
69 def test_null_db_default(self):
70 obj1 = DBDefaults.objects.create()
71 if not connection.features.can_return_columns_from_insert:
72 obj1.refresh_from_db()
73 self.assertEqual(obj1.null, 1.1)
74
75 obj2 = DBDefaults.objects.create(null=None)
76 self.assertIsNone(obj2.null)
77
78 @skipUnlessDBFeature("supports_expression_defaults")
79 @override_settings(USE_TZ=True)
80 def test_db_default_function(self):
81 m = DBDefaultsFunction.objects.create()
82 if not connection.features.can_return_columns_from_insert:
83 m.refresh_from_db()
84 self.assertAlmostEqual(m.number, pi)
85 self.assertEqual(m.year, timezone.now().year)
86 self.assertAlmostEqual(m.added, pi + 4.5)
87 self.assertEqual(m.multiple_subfunctions, 4.5)
88
89 @skipUnlessDBFeature("insert_test_table_with_defaults")
90 def test_both_default(self):
91 create_sql = connection.features.insert_test_table_with_defaults
92 with connection.cursor() as cursor:
93 cursor.execute(create_sql.format(DBDefaults._meta.db_table))
94 obj1 = DBDefaults.objects.get()
95 self.assertEqual(obj1.both, 2)
96
97 obj2 = DBDefaults.objects.create()
98 self.assertEqual(obj2.both, 1)
99
100 def test_pk_db_default(self):
101 obj1 = DBDefaultsPK.objects.create()
102 if not connection.features.can_return_columns_from_insert:
103 # refresh_from_db() cannot be used because that needs the pk to
104 # already be known to Django.
105 obj1 = DBDefaultsPK.objects.get(pk="en")
106 self.assertEqual(obj1.pk, "en")
107 self.assertEqual(obj1.language_code, "en")
108
109 obj2 = DBDefaultsPK.objects.create(language_code="de")
110 self.assertEqual(obj2.pk, "de")
111 self.assertEqual(obj2.language_code, "de")
112
113 def test_foreign_key_db_default(self):
114 parent1 = DBDefaultsPK.objects.create(language_code="fr")
115 child1 = DBDefaultsFK.objects.create()
116 if not connection.features.can_return_columns_from_insert:
117 child1.refresh_from_db()
118 self.assertEqual(child1.language_code, parent1)
119
120 parent2 = DBDefaultsPK.objects.create()
121 if not connection.features.can_return_columns_from_insert:
122 # refresh_from_db() cannot be used because that needs the pk to
123 # already be known to Django.
124 parent2 = DBDefaultsPK.objects.get(pk="en")
125 child2 = DBDefaultsFK.objects.create(language_code=parent2)
126 self.assertEqual(child2.language_code, parent2)
127
128 @skipUnlessDBFeature(
129 "can_return_columns_from_insert", "supports_expression_defaults"
130 )
131 def test_case_when_db_default_returning(self):
132 m = DBDefaultsFunction.objects.create()
133 self.assertEqual(m.case_when, 3)
134
135 @skipIfDBFeature("can_return_columns_from_insert")
136 @skipUnlessDBFeature("supports_expression_defaults")
137 def test_case_when_db_default_no_returning(self):
138 m = DBDefaultsFunction.objects.create()
139 m.refresh_from_db()
140 self.assertEqual(m.case_when, 3)
141
142 @skipUnlessDBFeature("supports_expression_defaults")
143 def test_bulk_create_all_db_defaults(self):
144 articles = [DBArticle(), DBArticle()]
145 DBArticle.objects.bulk_create(articles)
146
147 headlines = DBArticle.objects.values_list("headline", flat=True)
148 self.assertSequenceEqual(headlines, ["Default headline", "Default headline"])
149
150 @skipUnlessDBFeature("supports_expression_defaults")
151 def test_bulk_create_all_db_defaults_one_field(self):
152 pub_date = datetime.now()
153 articles = [DBArticle(pub_date=pub_date), DBArticle(pub_date=pub_date)]
154 DBArticle.objects.bulk_create(articles)
155
156 headlines = DBArticle.objects.values_list("headline", "pub_date", "cost")
157 self.assertSequenceEqual(
158 headlines,
159 [
160 ("Default headline", pub_date, Decimal("3.33")),
161 ("Default headline", pub_date, Decimal("3.33")),
162 ],
163 )
164
165 @skipUnlessDBFeature("supports_expression_defaults")
166 def test_bulk_create_mixed_db_defaults(self):
167 articles = [DBArticle(), DBArticle(headline="Something else")]
168 DBArticle.objects.bulk_create(articles)
169
170 headlines = DBArticle.objects.values_list("headline", flat=True)
171 self.assertCountEqual(headlines, ["Default headline", "Something else"])
172
173 @skipUnlessDBFeature("supports_expression_defaults")
174 @override_settings(USE_TZ=True)
175 def test_bulk_create_mixed_db_defaults_function(self):
176 instances = [DBDefaultsFunction(), DBDefaultsFunction(year=2000)]
177 DBDefaultsFunction.objects.bulk_create(instances)
178
179 years = DBDefaultsFunction.objects.values_list("year", flat=True)
180 self.assertCountEqual(years, [2000, timezone.now().year])
181
182 def test_full_clean(self):
183 obj = DBArticle()
184 obj.full_clean()
185 obj.save()
186 obj.refresh_from_db()
187 self.assertEqual(obj.headline, "Default headline")
188
189 obj = DBArticle(headline="Other title")
190 obj.full_clean()
191 obj.save()
192 obj.refresh_from_db()
193 self.assertEqual(obj.headline, "Other title")
194
195 obj = DBArticle(headline="")
196 with self.assertRaises(ValidationError):
197 obj.full_clean()
198
199
200 class AllowedDefaultTests(SimpleTestCase):
201 def test_allowed(self):
202 class Max(Func):
203 function = "MAX"
204
205 tests = [
206 Value(10),
207 Max(1, 2),
208 RawSQL("Now()", ()),
209 Value(10) + Value(7), # Combined expression.
210 ExpressionList(Value(1), Value(2)),
211 ExpressionWrapper(Value(1), output_field=FloatField()),
212 Case(When(GreaterThan(2, 1), then=3), default=4),
213 ]
214 for expression in tests:
215 with self.subTest(expression=expression):
216 self.assertIs(expression.allowed_default, True)
217
218 def test_disallowed(self):
219 class Max(Func):
220 function = "MAX"
221
222 tests = [
223 Expression(),
224 F("field"),
225 Max(F("count"), 1),
226 Value(10) + F("count"), # Combined expression.
227 ExpressionList(F("count"), Value(2)),
228 ExpressionWrapper(F("count"), output_field=FloatField()),
229 Collate(Value("John"), "nocase"),
230 OrderByList("field"),
231 ]
232 for expression in tests:
233 with self.subTest(expression=expression):
234 self.assertIs(expression.allowed_default, False)