def test_form_rows_fields_exists(self):
"""
Check model fields appear in action form for each selected models
"""
with user_grant_permission(self.user, [
'demo.change_demomodel',
'demo.adminactions_byrowsupdate_demomodel'
]):
res = self._get_changelist_form_response()
form = res.forms['changelist-form']
self._select_rows(form, selected_rows=self._selected_rows)
res = self._get_action_form_response(change_list_response=res)
byrows_update_get_fields(ModelAdmin(DemoModel, self.site))
for r, value in enumerate(self._selected_values):
for fname in byrows_update_get_fields(
ModelAdmin(DemoModel, self.site)):
fname = 'form-%d-%s' % (r, fname)
try:
# Attempt split (admin datetime widget) fields first
assert res.form[fname + '_0']
except AssertionError:
# assert for non-split fields to return the regular
# field name upon errors
assert res.form[fname]
def test_log_actions(self):
ma = ModelAdmin(Band, self.site)
mock_request = MockRequest()
mock_request.user = User.objects.create(username='******')
content_type = get_content_type_for_model(self.band)
tests = (
(ma.log_addition, ADDITION, {
'added': {}
}),
(ma.log_change, CHANGE, {
'changed': {
'fields': ['name', 'bio']
}
}),
(ma.log_deletion, DELETION, str(self.band)),
)
for method, flag, message in tests:
with self.subTest(name=method.__name__):
created = method(mock_request, self.band, message)
fetched = LogEntry.objects.filter(
action_flag=flag).latest('id')
self.assertEqual(created, fetched)
self.assertEqual(fetched.action_flag, flag)
self.assertEqual(fetched.content_type, content_type)
self.assertEqual(fetched.object_id, str(self.band.pk))
self.assertEqual(fetched.user, mock_request.user)
if flag == DELETION:
self.assertEqual(fetched.change_message, '')
self.assertEqual(fetched.object_repr, message)
else:
self.assertEqual(fetched.change_message, str(message))
self.assertEqual(fetched.object_repr, str(self.band))
def test_default_foreign_key_widget(self):
# First, without any radio_fields specified, the widgets for ForeignKey
# and fields with choices specified ought to be a basic Select widget.
# ForeignKey widgets in the admin are wrapped with RelatedFieldWidgetWrapper so
# they need to be handled properly when type checking. For Select fields, all of
# the choices lists have a first entry of dashes.
cma = ModelAdmin(Concert, self.site)
cmafa = cma.get_form(request)
self.assertEqual(type(cmafa.base_fields["main_band"].widget.widget),
Select)
self.assertEqual(
list(cmafa.base_fields["main_band"].widget.choices),
[("", "---------"), (self.band.id, "The Doors")],
)
self.assertEqual(type(cmafa.base_fields["opening_band"].widget.widget),
Select)
self.assertEqual(
list(cmafa.base_fields["opening_band"].widget.choices),
[("", "---------"), (self.band.id, "The Doors")],
)
self.assertEqual(type(cmafa.base_fields["day"].widget), Select)
self.assertEqual(
list(cmafa.base_fields["day"].widget.choices),
[("", "---------"), (1, "Fri"), (2, "Sat")],
)
self.assertEqual(type(cmafa.base_fields["transport"].widget), Select)
self.assertEqual(
list(cmafa.base_fields["transport"].widget.choices),
[("", "---------"), (1, "Plane"), (2, "Train"), (3, "Bus")],
)
def change_decision_via_admin(self, decision, new_organization=None):
"""
Used for testing custom behaviour for Decision change in django
admin - see publicweb/admin.py, DecisionAdmin.save_model()
Requirement: logged in user is_staff and is_superuser.
"""
ma = ModelAdmin(Decision, AdminSite())
data = ma.get_form(None)(instance=decision).initial
for key, value in data.items():
if value == None:
data[key] = u''
man_data = {
'feedback_set-TOTAL_FORMS': u'1',
'feedback_set-INITIAL_FORMS': u'0',
'feedback_set-MAX_NUM_FORMS': u''
}
data.update(man_data)
if new_organization:
data['organization'] = new_organization.id
url = reverse('admin:publicweb_decision_change', args=[decision.id])
response = self.client.post(url, data, follow=True)
self.assertEquals(response.template_name,
'admin/decision_change_list.html',
"Failed to edit Decision via admin screen")
decision = Decision.objects.get(id=decision.id)
if new_organization:
self.assertEquals(decision.organization.id, new_organization.id)
def test_has_module_permission(self):
"""
as_module_permission returns True for users who have any permission
for the module and False for users who don't.
"""
ma = ModelAdmin(Band, AdminSite())
request = MockRequest()
request.user = self.MockAddUser()
self.assertTrue(ma.has_module_permission(request))
request.user = self.MockChangeUser()
self.assertTrue(ma.has_module_permission(request))
request.user = self.MockDeleteUser()
self.assertTrue(ma.has_module_permission(request))
original_app_label = ma.opts.app_label
ma.opts.app_label = 'anotherapp'
try:
request.user = self.MockAddUser()
self.assertFalse(ma.has_module_permission(request))
request.user = self.MockChangeUser()
self.assertFalse(ma.has_module_permission(request))
request.user = self.MockDeleteUser()
self.assertFalse(ma.has_module_permission(request))
finally:
ma.opts.app_label = original_app_label
def test_log_actions(self):
ma = ModelAdmin(Band, self.site)
mock_request = MockRequest()
mock_request.user = User.objects.create(username='******')
self.assertEqual(ma.log_addition(mock_request, self.band, 'added'), LogEntry.objects.latest('id'))
self.assertEqual(ma.log_change(mock_request, self.band, 'changed'), LogEntry.objects.latest('id'))
self.assertEqual(ma.log_change(mock_request, self.band, 'deleted'), LogEntry.objects.latest('id'))
def test_fieldsets(self):
model_admin = ModelAdmin(User, self.site)
self.assertEqual(
model_admin.get_fieldsets(request),
[(None, {'fields': [
'password',
'last_login',
'is_superuser',
'groups',
'user_permissions',
'is_removed',
'email',
'is_staff',
'is_active',
'date_joined',
'name'
]})]
)
self.assertEqual(
model_admin.get_fieldsets(request, self.user),
[(None, {'fields': [
'password',
'last_login',
'is_superuser',
'groups',
'user_permissions',
'is_removed',
'email',
'is_staff',
'is_active',
'date_joined',
'name'
]})]
)
def test_default_foreign_key_widget(self):
# First, without any radio_fields specified, the widgets for ForeignKey
# and fields with choices specified ought to be a basic Select widget.
# ForeignKey widgets in the admin are wrapped with RelatedFieldWidgetWrapper so
# they need to be handled properly when type checking. For Select fields, all of
# the choices lists have a first entry of dashes.
cma = ModelAdmin(Concert, self.site)
cmafa = cma.get_form(request)
self.assertEqual(type(cmafa.base_fields['main_band'].widget.widget),
Select)
self.assertEqual(list(cmafa.base_fields['main_band'].widget.choices),
[('', '---------'), (self.band.id, 'The Doors')])
self.assertEqual(type(cmafa.base_fields['opening_band'].widget.widget),
Select)
self.assertEqual(
list(cmafa.base_fields['opening_band'].widget.choices),
[('', '---------'), (self.band.id, 'The Doors')])
self.assertEqual(type(cmafa.base_fields['day'].widget), Select)
self.assertEqual(list(cmafa.base_fields['day'].widget.choices),
[('', '---------'), (1, 'Fri'), (2, 'Sat')])
self.assertEqual(type(cmafa.base_fields['transport'].widget), Select)
self.assertEqual(list(cmafa.base_fields['transport'].widget.choices),
[('', '---------'), (1, 'Plane'), (2, 'Train'),
(3, 'Bus')])
def test_09_model_fields(self):
ma = ModelAdmin(Sensor, self.site)
fields = [
'created_by', 'name', 'sku', 'serial_no', 'temp_units',
'pressure_units', 'alt_units', 'ws_units', 'climate', 'camera',
'link', 'ulink', 'dlink'
]
self.assertListEqual(fields, list(ma.get_fields(self.request)))
def test_11_model_fields(self):
ma = ModelAdmin(Event, self.site)
fields = [
'sensor', 'timestamp', 'location', 'status', 'camera', 'avg_temp',
'avg_pressure', 'pct_humidity', 'altitude', 'windspeed', 'deleted',
'link', 'ulink', 'dlink'
]
self.assertListEqual(fields, list(ma.get_fields(self.request)))
def test_default_ordering(self):
"""
The default ordering should be by name, as specified in the inner Meta
class.
"""
ma = ModelAdmin(Band, site)
names = [b.name for b in ma.get_queryset(request)]
self.assertEqual(["Aerosmith", "Radiohead", "Van Halen"], names)
def test_vatin_field_admin(self):
"""Admin form is generated."""
ma = ModelAdmin(VIESModel, self.site)
try:
ma.get_form(request)
except Exception as e:
self.fail(e.message)
def test_default_ordering(self):
"""
The default ordering should be by name, as specified in the inner Meta
class.
"""
ma = ModelAdmin(Band, None)
names = [b.name for b in ma.queryset(request)]
self.assertEqual(['Aerosmith', 'Radiohead', 'Van Halen'], names)
def test_form_rows_fields_exists(self):
"""
Check model fields appear in action form for each selected models
"""
with user_grant_permission(self.user, [
'demo.change_demomodel',
'demo.adminactions_byrowsupdate_demomodel'
]):
res = self._get_changelist_form_response()
form = res.forms['changelist-form']
self._select_rows(form, selected_rows=self._selected_rows)
res = self._get_action_form_response(change_list_response=res)
byrows_update_get_fields(ModelAdmin(DemoModel, self.site))
for r, value in enumerate(self._selected_values):
for fname in byrows_update_get_fields(
ModelAdmin(DemoModel, self.site)):
assert res.form["form-%d-%s" % (r, fname)]
def test_default_fields(self):
"""
Tests widget.
"""
ma = ModelAdmin(Pizza, AdminSite)
self.assertEqual(list(ma.get_form(request).base_fields),
['toppings', 'cheeses'])
self.assertEqual(list(ma.get_fields(request)), ['toppings', 'cheeses'])
self.assertEqual(ma.get_fields(request), ['toppings', 'cheeses'])
def test_get_queryset(self):
ps = PackageSubscription.objects.create(
radcheck=self.radcheck, package=self.package, start=self.now,
stop=self.now + timedelta(hours=settings.PACKAGE_TYPES_HOURS_MAP[self.package.package_type]))
ma = ModelAdmin(PackageSubscription, self.site)
qs = ma.get_queryset(self.request)
self.assertTrue(qs[0].stop > self.now)
def test_fields(self):
ma = ModelAdmin(CustomUser, self.site)
expected = [
'password', 'last_login', 'is_superuser', 'groups',
'user_permissions', 'email', 'is_active', 'is_admin', 'is_staff',
'is_company_admin', 'avatar', 'name', 'activation_key', 'company'
]
self.assertEqual(expected, ma.get_form(None).base_fields.keys())
def test_default_fields(self):
ma = ModelAdmin(Band, self.site)
self.assertEqual(list(ma.get_form(request).base_fields),
['name', 'bio', 'sign_date'])
self.assertEqual(list(ma.get_fields(request)),
['name', 'bio', 'sign_date'])
self.assertEqual(list(ma.get_fields(request, self.band)),
['name', 'bio', 'sign_date'])
self.assertIsNone(ma.get_exclude(request, self.band))
def test_default_fields(self):
ma = ModelAdmin(Category, self.site)
self.assertEqual(list(ma.get_form(request).base_fields),
['title', 'slug', 'description', 'parent'])
self.assertEqual(list(ma.get_fields(request)),
['title', 'slug', 'description', 'parent'])
self.assertEqual(list(ma.get_fields(request, self.category)),
['title', 'slug', 'description', 'parent'])
self.assertIsNone(ma.get_exclude(request, self.category))
def test_gps_get_queryset(self):
ga = GroupAccount.objects.create(name='CUG', max_no_of_users=10)
gps = GroupPackageSubscription.objects.create(group=ga,
package=self.package, start=self.now,
stop=self.now + timedelta(hours=settings.PACKAGE_TYPES_HOURS_MAP[self.package.package_type]))
ma = ModelAdmin(GroupPackageSubscription, self.site)
qs = ma.get_queryset(self.request)
self.assertTrue(qs[0].stop > self.now)
def test_default_fieldsets(self):
# fieldsets_add and fieldsets_change should return a special data structure that
# is used in the templates. They should generate the "right thing" whether we
# have specified a custom form, the fields argument, or nothing at all.
#
# Here's the default case. There are no custom form_add/form_change methods,
# no fields argument, and no fieldsets argument.
ma = ModelAdmin(Band, self.site)
self.assertEqual(ma.get_fieldsets(request), [(None, {'fields': ['name', 'bio', 'sign_date']})])
self.assertEqual(ma.get_fieldsets(request, self.band), [(None, {'fields': ['name', 'bio', 'sign_date']})])
def test_get_deleted_objects(self):
mock_request = MockRequest()
mock_request.user = User.objects.create_superuser(username='******',
email='*****@*****.**',
password='******')
ma = ModelAdmin(Band, self.site)
deletable_objects, model_count, perms_needed, protected = ma.get_deleted_objects(
[self.band], request)
self.assertEqual(deletable_objects, ['Band: The Doors'])
self.assertEqual(model_count, {'bands': 1})
self.assertEqual(perms_needed, set())
self.assertEqual(protected, [])
def test_fieldsets(self):
user = UserFactory()
ma = ModelAdmin(CustomUser, self.site)
expected = [(None, {
'fields': [
'password', 'last_login', 'is_superuser', 'groups',
'user_permissions', 'email', 'is_active', 'is_admin',
'is_staff', 'is_company_admin', 'avatar', 'name',
'activation_key', 'company'
]
})]
self.assertEqual(expected, ma.get_fieldsets(None, user))
def test_default_fields(self):
ma = ModelAdmin(Product, self.site)
default_list_fields = [
'title', 'creation_date', 'categories', 'status',
'start_publication', 'end_publication', 'excerpt', 'content',
'image', 'image_caption', 'owner'
]
self.assertEqual(list(ma.get_form(request).base_fields),
default_list_fields)
self.assertEqual(list(ma.get_fields(request)), default_list_fields)
self.assertEqual(list(ma.get_fields(request, self.product)),
default_list_fields)
self.assertIsNone(ma.get_exclude(request, self.product))
def test_has_delete_permission(self):
"""
has_delete_permission returns True for users who can delete objects and
False for users who can't.
"""
ma = ModelAdmin(Band, AdminSite())
request = MockRequest()
request.user = self.MockAddUser()
self.assertFalse(ma.has_delete_permission(request))
request.user = self.MockChangeUser()
self.assertFalse(ma.has_delete_permission(request))
request.user = self.MockDeleteUser()
self.assertTrue(ma.has_delete_permission(request))
def test_default_fields(self):
ma = ModelAdmin(Slide, self.site)
# self.assertEqual(list(ma.get_form(request).base_fields), ['name', 'bio', 'sign_date'])
# self.assertEqual(list(ma.get_fields(request)), ['name', 'bio', 'sign_date'])
self.assertEqual(list(ma.get_fields(request, self.slide)), [
'active', 'scan_run', 'slide_physical_id', 'rescan_number',
'slide_status', 'scenes', 'insert_before_one', 'scene_qc_1',
'insert_between_one_two', 'scene_qc_2', 'insert_between_two_three',
'scene_qc_3', 'insert_between_three_four', 'scene_qc_4',
'insert_between_four_five', 'scene_qc_5',
'insert_between_five_six', 'scene_qc_6', 'file_name', 'comments',
'file_size', 'processed'
])
def test_default_fields(self):
ma = ModelAdmin(Invoice, self.site)
self.assertEqual(
list(ma.get_form(request).base_fields),
["date", "customer", "invoiced", "draft", "cash", "paid_date"],
)
self.assertEqual(
list(ma.get_fields(request)),
["date", "customer", "invoiced", "draft", "cash", "paid_date"],
)
self.assertEqual(
list(ma.get_fields(request, self.invoice)),
["date", "customer", "invoiced", "draft", "cash", "paid_date"],
)
self.assertIsNone(ma.get_exclude(request, self.invoice))
def test_has_view_permission(self):
"""
has_view_permission() returns True for users who can view objects and
False for users who can't.
"""
ma = ModelAdmin(Band, AdminSite())
request = MockRequest()
request.user = self.MockViewUser()
self.assertIs(ma.has_view_permission(request), True)
request.user = self.MockAddUser()
self.assertIs(ma.has_view_permission(request), False)
request.user = self.MockChangeUser()
self.assertIs(ma.has_view_permission(request), True)
request.user = self.MockDeleteUser()
self.assertIs(ma.has_view_permission(request), False)
def test_get_actions_requires_change_perm(self):
user = User.objects.create_user(username='******',
email='*****@*****.**',
password='******')
mock_request = MockRequest()
mock_request.user = user
mock_request.GET = {}
ma = ModelAdmin(Band, self.site)
self.assertEqual(list(ma.get_actions(mock_request).keys()), [])
p = Permission.objects.get(codename='change_band',
content_type=get_content_type_for_model(
Band()))
user.user_permissions.add(p)
mock_request.user = User.objects.get(pk=user.pk)
self.assertEqual(list(ma.get_actions(mock_request).keys()),
['delete_selected'])
def test_admin_delete_user_with_watched_thread(self, get_current):
"""Test the admin delete view for a user with a watched thread."""
get_current.return_value.domain = 'testserver'
t = thread(save=True)
u = t.creator
watcher = user(save=True)
admin_user = user(is_staff=True, is_superuser=True, save=True)
self.client.login(username=admin_user.username, password='******')
self._toggle_watch_thread_as(t, watcher, turn_on=True)
url = reverse('admin:auth_user_delete', args=[u.id])
request = test_utils.RequestFactory().get(url)
request.user = admin_user
request.session = self.client.session
# The following blows up without our monkeypatch.
ModelAdmin(User, admin.site).delete_view(request, str(u.id))
