Debian Codegraph @

tests/backends/test_ddl_references.py

raw
1 from django.db import connection
2 from django.db.backends.ddl_references import (
3 Columns,
4 Expressions,
5 ForeignKeyName,
6 IndexName,
7 Statement,
8 Table,
9 )
10 from django.db.models import ExpressionList, F
11 from django.db.models.functions import Upper
12 from django.db.models.indexes import IndexExpression
13 from django.db.models.sql import Query
14 from django.test import SimpleTestCase, TransactionTestCase
15
16 from .models import Person
17
18
19 class TableTests(SimpleTestCase):
20 def setUp(self):
21 self.reference = Table("table", lambda table: table.upper())
22
23 def test_references_table(self):
24 self.assertIs(self.reference.references_table("table"), True)
25 self.assertIs(self.reference.references_table("other"), False)
26
27 def test_rename_table_references(self):
28 self.reference.rename_table_references("other", "table")
29 self.assertIs(self.reference.references_table("table"), True)
30 self.assertIs(self.reference.references_table("other"), False)
31 self.reference.rename_table_references("table", "other")
32 self.assertIs(self.reference.references_table("table"), False)
33 self.assertIs(self.reference.references_table("other"), True)
34
35 def test_repr(self):
36 self.assertEqual(repr(self.reference), "<Table 'TABLE'>")
37
38 def test_str(self):
39 self.assertEqual(str(self.reference), "TABLE")
40
41
42 class ColumnsTests(TableTests):
43 def setUp(self):
44 self.reference = Columns(
45 "table", ["first_column", "second_column"], lambda column: column.upper()
46 )
47
48 def test_references_column(self):
49 self.assertIs(self.reference.references_column("other", "first_column"), False)
50 self.assertIs(self.reference.references_column("table", "third_column"), False)
51 self.assertIs(self.reference.references_column("table", "first_column"), True)
52
53 def test_rename_column_references(self):
54 self.reference.rename_column_references("other", "first_column", "third_column")
55 self.assertIs(self.reference.references_column("table", "first_column"), True)
56 self.assertIs(self.reference.references_column("table", "third_column"), False)
57 self.assertIs(self.reference.references_column("other", "third_column"), False)
58 self.reference.rename_column_references("table", "third_column", "first_column")
59 self.assertIs(self.reference.references_column("table", "first_column"), True)
60 self.assertIs(self.reference.references_column("table", "third_column"), False)
61 self.reference.rename_column_references("table", "first_column", "third_column")
62 self.assertIs(self.reference.references_column("table", "first_column"), False)
63 self.assertIs(self.reference.references_column("table", "third_column"), True)
64
65 def test_repr(self):
66 self.assertEqual(
67 repr(self.reference), "<Columns 'FIRST_COLUMN, SECOND_COLUMN'>"
68 )
69
70 def test_str(self):
71 self.assertEqual(str(self.reference), "FIRST_COLUMN, SECOND_COLUMN")
72
73
74 class IndexNameTests(ColumnsTests):
75 def setUp(self):
76 def create_index_name(table_name, column_names, suffix):
77 return ", ".join(
78 "%s_%s_%s" % (table_name, column_name, suffix)
79 for column_name in column_names
80 )
81
82 self.reference = IndexName(
83 "table", ["first_column", "second_column"], "suffix", create_index_name
84 )
85
86 def test_repr(self):
87 self.assertEqual(
88 repr(self.reference),
89 "<IndexName 'table_first_column_suffix, table_second_column_suffix'>",
90 )
91
92 def test_str(self):
93 self.assertEqual(
94 str(self.reference), "table_first_column_suffix, table_second_column_suffix"
95 )
96
97
98 class ForeignKeyNameTests(IndexNameTests):
99 def setUp(self):
100 def create_foreign_key_name(table_name, column_names, suffix):
101 return ", ".join(
102 "%s_%s_%s" % (table_name, column_name, suffix)
103 for column_name in column_names
104 )
105
106 self.reference = ForeignKeyName(
107 "table",
108 ["first_column", "second_column"],
109 "to_table",
110 ["to_first_column", "to_second_column"],
111 "%(to_table)s_%(to_column)s_fk",
112 create_foreign_key_name,
113 )
114
115 def test_references_table(self):
116 super().test_references_table()
117 self.assertIs(self.reference.references_table("to_table"), True)
118
119 def test_references_column(self):
120 super().test_references_column()
121 self.assertIs(
122 self.reference.references_column("to_table", "second_column"), False
123 )
124 self.assertIs(
125 self.reference.references_column("to_table", "to_second_column"), True
126 )
127
128 def test_rename_table_references(self):
129 super().test_rename_table_references()
130 self.reference.rename_table_references("to_table", "other_to_table")
131 self.assertIs(self.reference.references_table("other_to_table"), True)
132 self.assertIs(self.reference.references_table("to_table"), False)
133
134 def test_rename_column_references(self):
135 super().test_rename_column_references()
136 self.reference.rename_column_references(
137 "to_table", "second_column", "third_column"
138 )
139 self.assertIs(self.reference.references_column("table", "second_column"), True)
140 self.assertIs(
141 self.reference.references_column("to_table", "to_second_column"), True
142 )
143 self.reference.rename_column_references(
144 "to_table", "to_first_column", "to_third_column"
145 )
146 self.assertIs(
147 self.reference.references_column("to_table", "to_first_column"), False
148 )
149 self.assertIs(
150 self.reference.references_column("to_table", "to_third_column"), True
151 )
152
153 def test_repr(self):
154 self.assertEqual(
155 repr(self.reference),
156 "<ForeignKeyName 'table_first_column_to_table_to_first_column_fk, "
157 "table_second_column_to_table_to_first_column_fk'>",
158 )
159
160 def test_str(self):
161 self.assertEqual(
162 str(self.reference),
163 "table_first_column_to_table_to_first_column_fk, "
164 "table_second_column_to_table_to_first_column_fk",
165 )
166
167
168 class MockReference:
169 def __init__(
170 self, representation, referenced_tables, referenced_columns, referenced_indexes
171 ):
172 self.representation = representation
173 self.referenced_tables = referenced_tables
174 self.referenced_columns = referenced_columns
175 self.referenced_indexes = referenced_indexes
176
177 def references_table(self, table):
178 return table in self.referenced_tables
179
180 def references_column(self, table, column):
181 return (table, column) in self.referenced_columns
182
183 def references_index(self, table, index):
184 return (table, index) in self.referenced_indexes
185
186 def rename_table_references(self, old_table, new_table):
187 if old_table in self.referenced_tables:
188 self.referenced_tables.remove(old_table)
189 self.referenced_tables.add(new_table)
190
191 def rename_column_references(self, table, old_column, new_column):
192 column = (table, old_column)
193 if column in self.referenced_columns:
194 self.referenced_columns.remove(column)
195 self.referenced_columns.add((table, new_column))
196
197 def __str__(self):
198 return self.representation
199
200
201 class StatementTests(SimpleTestCase):
202 def test_references_table(self):
203 statement = Statement(
204 "", reference=MockReference("", {"table"}, {}, {}), non_reference=""
205 )
206 self.assertIs(statement.references_table("table"), True)
207 self.assertIs(statement.references_table("other"), False)
208
209 def test_references_column(self):
210 statement = Statement(
211 "",
212 reference=MockReference("", {}, {("table", "column")}, {}),
213 non_reference="",
214 )
215 self.assertIs(statement.references_column("table", "column"), True)
216 self.assertIs(statement.references_column("other", "column"), False)
217
218 def test_references_index(self):
219 statement = Statement(
220 "",
221 reference=MockReference("", {}, {}, {("table", "index")}),
222 non_reference="",
223 )
224 self.assertIs(statement.references_index("table", "index"), True)
225 self.assertIs(statement.references_index("other", "index"), False)
226
227 def test_rename_table_references(self):
228 reference = MockReference("", {"table"}, {}, {})
229 statement = Statement("", reference=reference, non_reference="")
230 statement.rename_table_references("table", "other")
231 self.assertEqual(reference.referenced_tables, {"other"})
232
233 def test_rename_column_references(self):
234 reference = MockReference("", {}, {("table", "column")}, {})
235 statement = Statement("", reference=reference, non_reference="")
236 statement.rename_column_references("table", "column", "other")
237 self.assertEqual(reference.referenced_columns, {("table", "other")})
238
239 def test_repr(self):
240 reference = MockReference("reference", {}, {}, {})
241 statement = Statement(
242 "%(reference)s - %(non_reference)s",
243 reference=reference,
244 non_reference="non_reference",
245 )
246 self.assertEqual(repr(statement), "<Statement 'reference - non_reference'>")
247
248 def test_str(self):
249 reference = MockReference("reference", {}, {}, {})
250 statement = Statement(
251 "%(reference)s - %(non_reference)s",
252 reference=reference,
253 non_reference="non_reference",
254 )
255 self.assertEqual(str(statement), "reference - non_reference")
256
257
258 class ExpressionsTests(TransactionTestCase):
259 available_apps = []
260
261 def setUp(self):
262 compiler = Person.objects.all().query.get_compiler(connection.alias)
263 self.editor = connection.schema_editor()
264 self.expressions = Expressions(
265 table=Person._meta.db_table,
266 expressions=ExpressionList(
267 IndexExpression(F("first_name")),
268 IndexExpression(F("last_name").desc()),
269 IndexExpression(Upper("last_name")),
270 ).resolve_expression(compiler.query),
271 compiler=compiler,
272 quote_value=self.editor.quote_value,
273 )
274
275 def test_references_table(self):
276 self.assertIs(self.expressions.references_table(Person._meta.db_table), True)
277 self.assertIs(self.expressions.references_table("other"), False)
278
279 def test_references_column(self):
280 table = Person._meta.db_table
281 self.assertIs(self.expressions.references_column(table, "first_name"), True)
282 self.assertIs(self.expressions.references_column(table, "last_name"), True)
283 self.assertIs(self.expressions.references_column(table, "other"), False)
284
285 def test_rename_table_references(self):
286 table = Person._meta.db_table
287 self.expressions.rename_table_references(table, "other")
288 self.assertIs(self.expressions.references_table(table), False)
289 self.assertIs(self.expressions.references_table("other"), True)
290 self.assertIn(
291 "%s.%s"
292 % (
293 self.editor.quote_name("other"),
294 self.editor.quote_name("first_name"),
295 ),
296 str(self.expressions),
297 )
298
299 def test_rename_table_references_without_alias(self):
300 compiler = Query(Person, alias_cols=False).get_compiler(connection=connection)
301 table = Person._meta.db_table
302 expressions = Expressions(
303 table=table,
304 expressions=ExpressionList(
305 IndexExpression(Upper("last_name")),
306 IndexExpression(F("first_name")),
307 ).resolve_expression(compiler.query),
308 compiler=compiler,
309 quote_value=self.editor.quote_value,
310 )
311 expressions.rename_table_references(table, "other")
312 self.assertIs(expressions.references_table(table), False)
313 self.assertIs(expressions.references_table("other"), True)
314 expected_str = "(UPPER(%s)), %s" % (
315 self.editor.quote_name("last_name"),
316 self.editor.quote_name("first_name"),
317 )
318 self.assertEqual(str(expressions), expected_str)
319
320 def test_rename_column_references(self):
321 table = Person._meta.db_table
322 self.expressions.rename_column_references(table, "first_name", "other")
323 self.assertIs(self.expressions.references_column(table, "other"), True)
324 self.assertIs(self.expressions.references_column(table, "first_name"), False)
325 self.assertIn(
326 "%s.%s" % (self.editor.quote_name(table), self.editor.quote_name("other")),
327 str(self.expressions),
328 )
329
330 def test_str(self):
331 table_name = self.editor.quote_name(Person._meta.db_table)
332 expected_str = "%s.%s, %s.%s DESC, (UPPER(%s.%s))" % (
333 table_name,
334 self.editor.quote_name("first_name"),
335 table_name,
336 self.editor.quote_name("last_name"),
337 table_name,
338 self.editor.quote_name("last_name"),
339 )
340 self.assertEqual(str(self.expressions), expected_str)