Debian Codegraph @

tests/composite_pk/test_checks.py

raw
1 from django.core import checks
2 from django.db import connection, models
3 from django.db.models import F
4 from django.test import TestCase, skipUnlessAnyDBFeature
5 from django.test.utils import isolate_apps
6
7
8 @isolate_apps("composite_pk")
9 class CompositePKChecksTests(TestCase):
10 maxDiff = None
11
12 def test_composite_pk_must_be_unique_strings(self):
13 test_cases = (
14 (),
15 (0,),
16 (1,),
17 ("id", False),
18 ("id", "id"),
19 (("id",),),
20 )
21
22 for i, args in enumerate(test_cases):
23 with (
24 self.subTest(args=args),
25 self.assertRaisesMessage(
26 ValueError, "CompositePrimaryKey args must be unique strings."
27 ),
28 ):
29 models.CompositePrimaryKey(*args)
30
31 def test_composite_pk_must_include_at_least_2_fields(self):
32 expected_message = "CompositePrimaryKey must include at least two fields."
33 with self.assertRaisesMessage(ValueError, expected_message):
34 models.CompositePrimaryKey("id")
35
36 def test_composite_pk_cannot_have_a_default(self):
37 expected_message = "CompositePrimaryKey cannot have a default."
38 with self.assertRaisesMessage(ValueError, expected_message):
39 models.CompositePrimaryKey("tenant_id", "id", default=(1, 1))
40
41 def test_composite_pk_cannot_have_a_database_default(self):
42 expected_message = "CompositePrimaryKey cannot have a database default."
43 with self.assertRaisesMessage(ValueError, expected_message):
44 models.CompositePrimaryKey("tenant_id", "id", db_default=models.F("id"))
45
46 def test_composite_pk_cannot_have_a_db_column(self):
47 expected_message = "CompositePrimaryKey cannot have a db_column."
48 with self.assertRaisesMessage(ValueError, expected_message):
49 models.CompositePrimaryKey("tenant_id", "id", db_column="tenant_pk")
50
51 def test_composite_pk_cannot_be_editable(self):
52 expected_message = "CompositePrimaryKey cannot be editable."
53 with self.assertRaisesMessage(ValueError, expected_message):
54 models.CompositePrimaryKey("tenant_id", "id", editable=True)
55
56 def test_composite_pk_must_be_a_primary_key(self):
57 expected_message = "CompositePrimaryKey must be a primary key."
58 with self.assertRaisesMessage(ValueError, expected_message):
59 models.CompositePrimaryKey("tenant_id", "id", primary_key=False)
60
61 def test_composite_pk_must_be_blank(self):
62 expected_message = "CompositePrimaryKey must be blank."
63 with self.assertRaisesMessage(ValueError, expected_message):
64 models.CompositePrimaryKey("tenant_id", "id", blank=False)
65
66 def test_composite_pk_must_not_have_other_pk_field(self):
67 class Foo(models.Model):
68 pk = models.CompositePrimaryKey("foo_id", "id")
69 foo_id = models.IntegerField()
70 id = models.IntegerField(primary_key=True)
71
72 self.assertEqual(
73 Foo.check(databases=self.databases),
74 [
75 checks.Error(
76 "The model cannot have more than one field with "
77 "'primary_key=True'.",
78 obj=Foo,
79 id="models.E026",
80 ),
81 ],
82 )
83
84 def test_composite_pk_cannot_include_nullable_field(self):
85 class Foo(models.Model):
86 pk = models.CompositePrimaryKey("foo_id", "id")
87 foo_id = models.IntegerField()
88 id = models.IntegerField(null=True)
89
90 self.assertEqual(
91 Foo.check(databases=self.databases),
92 [
93 checks.Error(
94 "'id' cannot be included in the composite primary key.",
95 hint="'id' field may not set 'null=True'.",
96 obj=Foo,
97 id="models.E042",
98 ),
99 ],
100 )
101
102 def test_composite_pk_can_include_fk_name(self):
103 class Foo(models.Model):
104 pass
105
106 class Bar(models.Model):
107 pk = models.CompositePrimaryKey("foo", "id")
108 foo = models.ForeignKey(Foo, on_delete=models.CASCADE)
109 id = models.SmallIntegerField()
110
111 self.assertEqual(Foo.check(databases=self.databases), [])
112 self.assertEqual(Bar.check(databases=self.databases), [])
113
114 def test_composite_pk_cannot_include_same_field(self):
115 class Foo(models.Model):
116 pass
117
118 class Bar(models.Model):
119 pk = models.CompositePrimaryKey("foo", "foo_id")
120 foo = models.ForeignKey(Foo, on_delete=models.CASCADE)
121 id = models.SmallIntegerField()
122
123 self.assertEqual(Foo.check(databases=self.databases), [])
124 self.assertEqual(
125 Bar.check(databases=self.databases),
126 [
127 checks.Error(
128 "'foo_id' cannot be included in the composite primary key.",
129 hint="'foo_id' and 'foo' are the same fields.",
130 obj=Bar,
131 id="models.E042",
132 ),
133 ],
134 )
135
136 def test_composite_pk_cannot_include_composite_pk_field(self):
137 class Foo(models.Model):
138 pk = models.CompositePrimaryKey("id", "pk")
139 id = models.SmallIntegerField()
140
141 self.assertEqual(
142 Foo.check(databases=self.databases),
143 [
144 checks.Error(
145 "'pk' cannot be included in the composite primary key.",
146 hint="'pk' field has no column.",
147 obj=Foo,
148 id="models.E042",
149 ),
150 ],
151 )
152
153 def test_composite_pk_cannot_include_db_column(self):
154 class Foo(models.Model):
155 pk = models.CompositePrimaryKey("foo", "bar")
156 foo = models.SmallIntegerField(db_column="foo_id")
157 bar = models.SmallIntegerField(db_column="bar_id")
158
159 class Bar(models.Model):
160 pk = models.CompositePrimaryKey("foo_id", "bar_id")
161 foo = models.SmallIntegerField(db_column="foo_id")
162 bar = models.SmallIntegerField(db_column="bar_id")
163
164 self.assertEqual(Foo.check(databases=self.databases), [])
165 self.assertEqual(
166 Bar.check(databases=self.databases),
167 [
168 checks.Error(
169 "'foo_id' cannot be included in the composite primary key.",
170 hint="'foo_id' is not a valid field.",
171 obj=Bar,
172 id="models.E042",
173 ),
174 checks.Error(
175 "'bar_id' cannot be included in the composite primary key.",
176 hint="'bar_id' is not a valid field.",
177 obj=Bar,
178 id="models.E042",
179 ),
180 ],
181 )
182
183 def test_foreign_object_can_refer_composite_pk(self):
184 class Foo(models.Model):
185 pass
186
187 class Bar(models.Model):
188 pk = models.CompositePrimaryKey("foo_id", "id")
189 foo = models.ForeignKey(Foo, on_delete=models.CASCADE)
190 id = models.IntegerField()
191
192 class Baz(models.Model):
193 pk = models.CompositePrimaryKey("foo_id", "id")
194 foo = models.ForeignKey(Foo, on_delete=models.CASCADE)
195 id = models.IntegerField()
196 bar_id = models.IntegerField()
197 bar = models.ForeignObject(
198 Bar,
199 on_delete=models.CASCADE,
200 from_fields=("foo_id", "bar_id"),
201 to_fields=("foo_id", "id"),
202 )
203
204 self.assertEqual(Foo.check(databases=self.databases), [])
205 self.assertEqual(Bar.check(databases=self.databases), [])
206 self.assertEqual(Baz.check(databases=self.databases), [])
207
208 def test_composite_pk_must_be_named_pk(self):
209 class Foo(models.Model):
210 primary_key = models.CompositePrimaryKey("foo_id", "id")
211 foo_id = models.IntegerField()
212 id = models.IntegerField()
213
214 self.assertEqual(
215 Foo.check(databases=self.databases),
216 [
217 checks.Error(
218 "'CompositePrimaryKey' must be named 'pk'.",
219 obj=Foo._meta.get_field("primary_key"),
220 id="fields.E013",
221 ),
222 ],
223 )
224
225 @skipUnlessAnyDBFeature(
226 "supports_virtual_generated_columns",
227 "supports_stored_generated_columns",
228 )
229 def test_composite_pk_cannot_include_generated_field(self):
230 class Foo(models.Model):
231 pk = models.CompositePrimaryKey("id", "foo")
232 id = models.IntegerField()
233 foo = models.GeneratedField(
234 expression=F("id"),
235 output_field=models.IntegerField(),
236 db_persist=connection.features.supports_stored_generated_columns,
237 )
238
239 self.assertEqual(
240 Foo.check(databases=self.databases),
241 [
242 checks.Error(
243 "'foo' cannot be included in the composite primary key.",
244 hint="'foo' field is a generated field.",
245 obj=Foo,
246 id="models.E042",
247 ),
248 ],
249 )
250
251 def test_composite_pk_cannot_include_non_local_field(self):
252 class Foo(models.Model):
253 a = models.SmallIntegerField()
254
255 class Bar(Foo):
256 pk = models.CompositePrimaryKey("a", "b")
257 b = models.SmallIntegerField()
258
259 self.assertEqual(Foo.check(databases=self.databases), [])
260 self.assertEqual(
261 Bar.check(databases=self.databases),
262 [
263 checks.Error(
264 "'a' cannot be included in the composite primary key.",
265 hint="'a' field is not a local field.",
266 obj=Bar,
267 id="models.E042",
268 ),
269 ],
270 )
271
272 def test_proxy_model_can_subclass_model_with_composite_pk(self):
273 class Foo(models.Model):
274 pk = models.CompositePrimaryKey("a", "b")
275 a = models.SmallIntegerField()
276 b = models.SmallIntegerField()
277
278 class Bar(Foo):
279 class Meta:
280 proxy = True
281
282 self.assertEqual(Foo.check(databases=self.databases), [])
283 self.assertEqual(Bar.check(databases=self.databases), [])
284
285 def test_proxy_model_does_not_check_superclass_composite_pk_errors(self):
286 class Foo(models.Model):
287 pk = models.CompositePrimaryKey("a", "b")
288 a = models.SmallIntegerField()
289
290 class Bar(Foo):
291 class Meta:
292 proxy = True
293
294 self.assertEqual(
295 Foo.check(databases=self.databases),
296 [
297 checks.Error(
298 "'b' cannot be included in the composite primary key.",
299 hint="'b' is not a valid field.",
300 obj=Foo,
301 id="models.E042",
302 ),
303 ],
304 )
305 self.assertEqual(Bar.check(databases=self.databases), [])