Debian Codegraph @

tests/auth_tests/test_migrations.py

raw
1 from importlib import import_module
2
3 from django.apps import apps
4 from django.contrib.auth.models import Permission, User
5 from django.contrib.contenttypes.models import ContentType
6 from django.db import connection, connections
7 from django.test import TransactionTestCase
8 from django.test.utils import captured_stdout
9
10 from .models import Proxy, UserProxy
11
12 update_proxy_permissions = import_module(
13 "django.contrib.auth.migrations.0011_update_proxy_permissions"
14 )
15
16
17 class ProxyModelWithDifferentAppLabelTests(TransactionTestCase):
18 available_apps = [
19 "auth_tests",
20 "django.contrib.auth",
21 "django.contrib.contenttypes",
22 ]
23
24 def setUp(self):
25 """
26 Create proxy permissions with content_type to the concrete model
27 rather than the proxy model (as they were before Django 2.2 and
28 migration 11).
29 """
30 Permission.objects.all().delete()
31 self.concrete_content_type = ContentType.objects.get_for_model(UserProxy)
32 self.default_permission = Permission.objects.create(
33 content_type=self.concrete_content_type,
34 codename="add_userproxy",
35 name="Can add userproxy",
36 )
37 self.custom_permission = Permission.objects.create(
38 content_type=self.concrete_content_type,
39 codename="use_different_app_label",
40 name="May use a different app label",
41 )
42
43 def test_proxy_model_permissions_contenttype(self):
44 proxy_model_content_type = ContentType.objects.get_for_model(
45 UserProxy, for_concrete_model=False
46 )
47 self.assertEqual(
48 self.default_permission.content_type, self.concrete_content_type
49 )
50 self.assertEqual(
51 self.custom_permission.content_type, self.concrete_content_type
52 )
53 with connection.schema_editor() as editor:
54 update_proxy_permissions.update_proxy_model_permissions(apps, editor)
55 self.default_permission.refresh_from_db()
56 self.assertEqual(self.default_permission.content_type, proxy_model_content_type)
57 self.custom_permission.refresh_from_db()
58 self.assertEqual(self.custom_permission.content_type, proxy_model_content_type)
59
60 def test_user_has_now_proxy_model_permissions(self):
61 user = User.objects.create()
62 user.user_permissions.add(self.default_permission)
63 user.user_permissions.add(self.custom_permission)
64 for permission in [self.default_permission, self.custom_permission]:
65 self.assertTrue(user.has_perm("auth." + permission.codename))
66 self.assertFalse(user.has_perm("auth_tests." + permission.codename))
67 with connection.schema_editor() as editor:
68 update_proxy_permissions.update_proxy_model_permissions(apps, editor)
69 # Reload user to purge the _perm_cache.
70 user = User._default_manager.get(pk=user.pk)
71 for permission in [self.default_permission, self.custom_permission]:
72 self.assertFalse(user.has_perm("auth." + permission.codename))
73 self.assertTrue(user.has_perm("auth_tests." + permission.codename))
74
75 def test_migrate_backwards(self):
76 with connection.schema_editor() as editor:
77 update_proxy_permissions.update_proxy_model_permissions(apps, editor)
78 update_proxy_permissions.revert_proxy_model_permissions(apps, editor)
79 self.default_permission.refresh_from_db()
80 self.assertEqual(
81 self.default_permission.content_type, self.concrete_content_type
82 )
83 self.custom_permission.refresh_from_db()
84 self.assertEqual(
85 self.custom_permission.content_type, self.concrete_content_type
86 )
87
88 def test_user_keeps_same_permissions_after_migrating_backward(self):
89 user = User.objects.create()
90 user.user_permissions.add(self.default_permission)
91 user.user_permissions.add(self.custom_permission)
92 for permission in [self.default_permission, self.custom_permission]:
93 self.assertTrue(user.has_perm("auth." + permission.codename))
94 self.assertFalse(user.has_perm("auth_tests." + permission.codename))
95 with connection.schema_editor() as editor:
96 update_proxy_permissions.update_proxy_model_permissions(apps, editor)
97 update_proxy_permissions.revert_proxy_model_permissions(apps, editor)
98 # Reload user to purge the _perm_cache.
99 user = User._default_manager.get(pk=user.pk)
100 for permission in [self.default_permission, self.custom_permission]:
101 self.assertTrue(user.has_perm("auth." + permission.codename))
102 self.assertFalse(user.has_perm("auth_tests." + permission.codename))
103
104
105 class ProxyModelWithSameAppLabelTests(TransactionTestCase):
106 available_apps = [
107 "auth_tests",
108 "django.contrib.auth",
109 "django.contrib.contenttypes",
110 ]
111
112 def setUp(self):
113 """
114 Create proxy permissions with content_type to the concrete model
115 rather than the proxy model (as they were before Django 2.2 and
116 migration 11).
117 """
118 Permission.objects.all().delete()
119 self.concrete_content_type = ContentType.objects.get_for_model(Proxy)
120 self.default_permission = Permission.objects.create(
121 content_type=self.concrete_content_type,
122 codename="add_proxy",
123 name="Can add proxy",
124 )
125 self.custom_permission = Permission.objects.create(
126 content_type=self.concrete_content_type,
127 codename="display_proxys",
128 name="May display proxys information",
129 )
130
131 def test_proxy_model_permissions_contenttype(self):
132 proxy_model_content_type = ContentType.objects.get_for_model(
133 Proxy, for_concrete_model=False
134 )
135 self.assertEqual(
136 self.default_permission.content_type, self.concrete_content_type
137 )
138 self.assertEqual(
139 self.custom_permission.content_type, self.concrete_content_type
140 )
141 with connection.schema_editor() as editor:
142 update_proxy_permissions.update_proxy_model_permissions(apps, editor)
143 self.default_permission.refresh_from_db()
144 self.custom_permission.refresh_from_db()
145 self.assertEqual(self.default_permission.content_type, proxy_model_content_type)
146 self.assertEqual(self.custom_permission.content_type, proxy_model_content_type)
147
148 def test_user_still_has_proxy_model_permissions(self):
149 user = User.objects.create()
150 user.user_permissions.add(self.default_permission)
151 user.user_permissions.add(self.custom_permission)
152 for permission in [self.default_permission, self.custom_permission]:
153 self.assertTrue(user.has_perm("auth_tests." + permission.codename))
154 with connection.schema_editor() as editor:
155 update_proxy_permissions.update_proxy_model_permissions(apps, editor)
156 # Reload user to purge the _perm_cache.
157 user = User._default_manager.get(pk=user.pk)
158 for permission in [self.default_permission, self.custom_permission]:
159 self.assertTrue(user.has_perm("auth_tests." + permission.codename))
160
161 def test_migrate_backwards(self):
162 with connection.schema_editor() as editor:
163 update_proxy_permissions.update_proxy_model_permissions(apps, editor)
164 update_proxy_permissions.revert_proxy_model_permissions(apps, editor)
165 self.default_permission.refresh_from_db()
166 self.assertEqual(
167 self.default_permission.content_type, self.concrete_content_type
168 )
169 self.custom_permission.refresh_from_db()
170 self.assertEqual(
171 self.custom_permission.content_type, self.concrete_content_type
172 )
173
174 def test_user_keeps_same_permissions_after_migrating_backward(self):
175 user = User.objects.create()
176 user.user_permissions.add(self.default_permission)
177 user.user_permissions.add(self.custom_permission)
178 for permission in [self.default_permission, self.custom_permission]:
179 self.assertTrue(user.has_perm("auth_tests." + permission.codename))
180 with connection.schema_editor() as editor:
181 update_proxy_permissions.update_proxy_model_permissions(apps, editor)
182 update_proxy_permissions.revert_proxy_model_permissions(apps, editor)
183 # Reload user to purge the _perm_cache.
184 user = User._default_manager.get(pk=user.pk)
185 for permission in [self.default_permission, self.custom_permission]:
186 self.assertTrue(user.has_perm("auth_tests." + permission.codename))
187
188 def test_migrate_with_existing_target_permission(self):
189 """
190 Permissions may already exist:
191
192 - Old workaround was to manually create permissions for proxy models.
193 - Model may have been concrete and then converted to proxy.
194
195 Output a reminder to audit relevant permissions.
196 """
197 proxy_model_content_type = ContentType.objects.get_for_model(
198 Proxy, for_concrete_model=False
199 )
200 Permission.objects.create(
201 content_type=proxy_model_content_type,
202 codename="add_proxy",
203 name="Can add proxy",
204 )
205 Permission.objects.create(
206 content_type=proxy_model_content_type,
207 codename="display_proxys",
208 name="May display proxys information",
209 )
210 with captured_stdout() as stdout:
211 with connection.schema_editor() as editor:
212 update_proxy_permissions.update_proxy_model_permissions(apps, editor)
213 self.assertIn(
214 "A problem arose migrating proxy model permissions", stdout.getvalue()
215 )
216
217
218 class MultiDBProxyModelAppLabelTests(TransactionTestCase):
219 databases = {"default", "other"}
220 available_apps = [
221 "auth_tests",
222 "django.contrib.auth",
223 "django.contrib.contenttypes",
224 ]
225
226 def setUp(self):
227 ContentType.objects.all().delete()
228 Permission.objects.using("other").delete()
229 concrete_content_type = ContentType.objects.db_manager("other").get_for_model(
230 Proxy
231 )
232 self.permission = Permission.objects.using("other").create(
233 content_type=concrete_content_type,
234 codename="add_proxy",
235 name="Can add proxy",
236 )
237
238 def test_migrate_other_database(self):
239 proxy_model_content_type = ContentType.objects.db_manager(
240 "other"
241 ).get_for_model(Proxy, for_concrete_model=False)
242 with connections["other"].schema_editor() as editor:
243 update_proxy_permissions.update_proxy_model_permissions(apps, editor)
244 self.permission.refresh_from_db()
245 self.assertEqual(self.permission.content_type, proxy_model_content_type)