| 1 |
import datetime |
| 2 |
import unittest |
| 3 |
|
| 4 |
from django.apps.registry import Apps |
| 5 |
from django.core.exceptions import ValidationError |
| 6 |
from django.db import models |
| 7 |
from django.test import TestCase |
| 8 |
|
| 9 |
from .models import ( |
| 10 |
CustomPKModel, |
| 11 |
FlexibleDatePost, |
| 12 |
ModelToValidate, |
| 13 |
Post, |
| 14 |
UniqueErrorsModel, |
| 15 |
UniqueFieldsModel, |
| 16 |
UniqueForDateModel, |
| 17 |
UniqueFuncConstraintModel, |
| 18 |
UniqueTogetherModel, |
| 19 |
) |
| 20 |
|
| 21 |
|
| 22 |
class GetUniqueCheckTests(unittest.TestCase): |
| 23 |
def test_unique_fields_get_collected(self): |
| 24 |
m = UniqueFieldsModel() |
| 25 |
self.assertEqual( |
| 26 |
( |
| 27 |
[ |
| 28 |
(UniqueFieldsModel, ("id",)), |
| 29 |
(UniqueFieldsModel, ("unique_charfield",)), |
| 30 |
(UniqueFieldsModel, ("unique_integerfield",)), |
| 31 |
], |
| 32 |
[], |
| 33 |
), |
| 34 |
m._get_unique_checks(), |
| 35 |
) |
| 36 |
|
| 37 |
def test_unique_together_gets_picked_up_and_converted_to_tuple(self): |
| 38 |
m = UniqueTogetherModel() |
| 39 |
self.assertEqual( |
| 40 |
( |
| 41 |
[ |
| 42 |
(UniqueTogetherModel, ("ifield", "cfield")), |
| 43 |
(UniqueTogetherModel, ("ifield", "efield")), |
| 44 |
(UniqueTogetherModel, ("id",)), |
| 45 |
], |
| 46 |
[], |
| 47 |
), |
| 48 |
m._get_unique_checks(), |
| 49 |
) |
| 50 |
|
| 51 |
def test_unique_together_normalization(self): |
| 52 |
""" |
| 53 |
Test the Meta.unique_together normalization with different sorts of |
| 54 |
objects. |
| 55 |
""" |
| 56 |
data = { |
| 57 |
"2-tuple": (("foo", "bar"), (("foo", "bar"),)), |
| 58 |
"list": (["foo", "bar"], (("foo", "bar"),)), |
| 59 |
"already normalized": ( |
| 60 |
(("foo", "bar"), ("bar", "baz")), |
| 61 |
(("foo", "bar"), ("bar", "baz")), |
| 62 |
), |
| 63 |
"set": ( |
| 64 |
{("foo", "bar"), ("bar", "baz")}, # Ref #21469 |
| 65 |
(("foo", "bar"), ("bar", "baz")), |
| 66 |
), |
| 67 |
} |
| 68 |
|
| 69 |
for unique_together, normalized in data.values(): |
| 70 |
|
| 71 |
class M(models.Model): |
| 72 |
foo = models.IntegerField() |
| 73 |
bar = models.IntegerField() |
| 74 |
baz = models.IntegerField() |
| 75 |
|
| 76 |
Meta = type( |
| 77 |
"Meta", (), {"unique_together": unique_together, "apps": Apps()} |
| 78 |
) |
| 79 |
|
| 80 |
checks, _ = M()._get_unique_checks() |
| 81 |
for t in normalized: |
| 82 |
check = (M, t) |
| 83 |
self.assertIn(check, checks) |
| 84 |
|
| 85 |
def test_primary_key_is_considered_unique(self): |
| 86 |
m = CustomPKModel() |
| 87 |
self.assertEqual( |
| 88 |
([(CustomPKModel, ("my_pk_field",))], []), m._get_unique_checks() |
| 89 |
) |
| 90 |
|
| 91 |
def test_unique_for_date_gets_picked_up(self): |
| 92 |
m = UniqueForDateModel() |
| 93 |
self.assertEqual( |
| 94 |
( |
| 95 |
[(UniqueForDateModel, ("id",))], |
| 96 |
[ |
| 97 |
(UniqueForDateModel, "date", "count", "start_date"), |
| 98 |
(UniqueForDateModel, "year", "count", "end_date"), |
| 99 |
(UniqueForDateModel, "month", "order", "end_date"), |
| 100 |
], |
| 101 |
), |
| 102 |
m._get_unique_checks(), |
| 103 |
) |
| 104 |
|
| 105 |
def test_unique_for_date_exclusion(self): |
| 106 |
m = UniqueForDateModel() |
| 107 |
self.assertEqual( |
| 108 |
( |
| 109 |
[(UniqueForDateModel, ("id",))], |
| 110 |
[ |
| 111 |
(UniqueForDateModel, "year", "count", "end_date"), |
| 112 |
(UniqueForDateModel, "month", "order", "end_date"), |
| 113 |
], |
| 114 |
), |
| 115 |
m._get_unique_checks(exclude="start_date"), |
| 116 |
) |
| 117 |
|
| 118 |
def test_func_unique_constraint_ignored(self): |
| 119 |
m = UniqueFuncConstraintModel() |
| 120 |
self.assertEqual( |
| 121 |
m._get_unique_checks(), |
| 122 |
([(UniqueFuncConstraintModel, ("id",))], []), |
| 123 |
) |
| 124 |
|
| 125 |
|
| 126 |
class PerformUniqueChecksTest(TestCase): |
| 127 |
def test_primary_key_unique_check_not_performed_when_adding_and_pk_not_specified( |
| 128 |
self, |
| 129 |
): |
| 130 |
# Regression test for #12560 |
| 131 |
with self.assertNumQueries(0): |
| 132 |
mtv = ModelToValidate(number=10, name="Some Name") |
| 133 |
setattr(mtv, "_adding", True) |
| 134 |
mtv.full_clean() |
| 135 |
|
| 136 |
def test_primary_key_unique_check_performed_when_adding_and_pk_specified(self): |
| 137 |
# Regression test for #12560 |
| 138 |
with self.assertNumQueries(1): |
| 139 |
mtv = ModelToValidate(number=10, name="Some Name", id=123) |
| 140 |
setattr(mtv, "_adding", True) |
| 141 |
mtv.full_clean() |
| 142 |
|
| 143 |
def test_primary_key_unique_check_not_performed_when_not_adding(self): |
| 144 |
# Regression test for #12132 |
| 145 |
with self.assertNumQueries(0): |
| 146 |
mtv = ModelToValidate(number=10, name="Some Name") |
| 147 |
mtv.full_clean() |
| 148 |
|
| 149 |
def test_unique_db_default(self): |
| 150 |
UniqueFieldsModel.objects.create(unique_charfield="foo", non_unique_field=42) |
| 151 |
um = UniqueFieldsModel(unique_charfield="bar", non_unique_field=42) |
| 152 |
with self.assertRaises(ValidationError) as cm: |
| 153 |
um.full_clean() |
| 154 |
self.assertEqual( |
| 155 |
cm.exception.message_dict, |
| 156 |
{ |
| 157 |
"unique_integerfield": [ |
| 158 |
"Unique fields model with this Unique integerfield already exists." |
| 159 |
] |
| 160 |
}, |
| 161 |
) |
| 162 |
|
| 163 |
def test_unique_for_date(self): |
| 164 |
Post.objects.create( |
| 165 |
title="Django 1.0 is released", |
| 166 |
slug="Django 1.0", |
| 167 |
subtitle="Finally", |
| 168 |
posted=datetime.date(2008, 9, 3), |
| 169 |
) |
| 170 |
p = Post(title="Django 1.0 is released", posted=datetime.date(2008, 9, 3)) |
| 171 |
with self.assertRaises(ValidationError) as cm: |
| 172 |
p.full_clean() |
| 173 |
self.assertEqual( |
| 174 |
cm.exception.message_dict, |
| 175 |
{"title": ["Title must be unique for Posted date."]}, |
| 176 |
) |
| 177 |
|
| 178 |
# Should work without errors |
| 179 |
p = Post(title="Work on Django 1.1 begins", posted=datetime.date(2008, 9, 3)) |
| 180 |
p.full_clean() |
| 181 |
|
| 182 |
# Should work without errors |
| 183 |
p = Post(title="Django 1.0 is released", posted=datetime.datetime(2008, 9, 4)) |
| 184 |
p.full_clean() |
| 185 |
|
| 186 |
p = Post(slug="Django 1.0", posted=datetime.datetime(2008, 1, 1)) |
| 187 |
with self.assertRaises(ValidationError) as cm: |
| 188 |
p.full_clean() |
| 189 |
self.assertEqual( |
| 190 |
cm.exception.message_dict, |
| 191 |
{"slug": ["Slug must be unique for Posted year."]}, |
| 192 |
) |
| 193 |
|
| 194 |
p = Post(subtitle="Finally", posted=datetime.datetime(2008, 9, 30)) |
| 195 |
with self.assertRaises(ValidationError) as cm: |
| 196 |
p.full_clean() |
| 197 |
self.assertEqual( |
| 198 |
cm.exception.message_dict, |
| 199 |
{"subtitle": ["Subtitle must be unique for Posted month."]}, |
| 200 |
) |
| 201 |
|
| 202 |
p = Post(title="Django 1.0 is released") |
| 203 |
with self.assertRaises(ValidationError) as cm: |
| 204 |
p.full_clean() |
| 205 |
self.assertEqual( |
| 206 |
cm.exception.message_dict, {"posted": ["This field cannot be null."]} |
| 207 |
) |
| 208 |
|
| 209 |
def test_unique_for_date_with_nullable_date(self): |
| 210 |
""" |
| 211 |
unique_for_date/year/month checks shouldn't trigger when the |
| 212 |
associated DateField is None. |
| 213 |
""" |
| 214 |
FlexibleDatePost.objects.create( |
| 215 |
title="Django 1.0 is released", |
| 216 |
slug="Django 1.0", |
| 217 |
subtitle="Finally", |
| 218 |
posted=datetime.date(2008, 9, 3), |
| 219 |
) |
| 220 |
p = FlexibleDatePost(title="Django 1.0 is released") |
| 221 |
p.full_clean() |
| 222 |
|
| 223 |
p = FlexibleDatePost(slug="Django 1.0") |
| 224 |
p.full_clean() |
| 225 |
|
| 226 |
p = FlexibleDatePost(subtitle="Finally") |
| 227 |
p.full_clean() |
| 228 |
|
| 229 |
def test_unique_errors(self): |
| 230 |
UniqueErrorsModel.objects.create(name="Some Name", no=10) |
| 231 |
m = UniqueErrorsModel(name="Some Name", no=11) |
| 232 |
with self.assertRaises(ValidationError) as cm: |
| 233 |
m.full_clean() |
| 234 |
self.assertEqual( |
| 235 |
cm.exception.message_dict, {"name": ["Custom unique name message."]} |
| 236 |
) |
| 237 |
|
| 238 |
m = UniqueErrorsModel(name="Some Other Name", no=10) |
| 239 |
with self.assertRaises(ValidationError) as cm: |
| 240 |
m.full_clean() |
| 241 |
self.assertEqual( |
| 242 |
cm.exception.message_dict, {"no": ["Custom unique number message."]} |
| 243 |
) |