| 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) |