def test_generic_inline_model_admin_non_gfk_fk_field(self):
"""
A GenericInlineModelAdmin raises problems if the ct_fk_field points to
a field that isn't part of a GenericForeignKey.
"""
class InfluenceInline(GenericStackedInline):
model = Influence
ct_fk_field = 'name'
class SongAdmin(admin.ModelAdmin):
inlines = [InfluenceInline]
errors = SongAdmin(Song, AdminSite()).check()
expected = [
checks.Error(
"'admin_checks.Influence' has no GenericForeignKey using "
"content type field 'content_type' and object ID field 'name'.",
hint=None,
obj=InfluenceInline,
id='admin.E304',
)
]
self.assertEqual(errors, expected)
def test_admin_defaults(self):
""" Test UserAdmin default construction """
site = AdminSite()
admin = UserAdmin(User, site)
self.assertEqual(
admin.list_display,
('id', 'email', 'first_name', 'last_name',)
)
self.assertEqual(admin.list_filter, ())
self.assertEqual(admin.ordering, ('id',))
self.assertEqual(
admin.search_fields,
('id', 'email', 'first_name', 'last_name')
)
self.assertEqual(
admin.fieldsets,
(
('Personal info', {
'fields': ('email', 'title', 'first_name', 'last_name',)
}),
('Permissions', {
'fields': ('is_superuser', 'groups', 'user_permissions')
}),
),
)
self.assertEqual(
admin.add_fieldsets,
(
(None, {
'fields': (
'email', 'title', 'first_name', 'last_name',
'password1', 'password2'
),
}),
),
)
def test_submit_premium_offer_discount_two_users(self, messageUserMock,
taskMock):
request = RequestFactory().get("/")
email = BroadcastEmail.objects.create(subject="test")
admin = BroadcastEmailAdmin(model=BroadcastEmail,
admin_site=AdminSite())
user = User.objects.create(username="******",
password="******",
email="*****@*****.**")
user.userprofile.premium_offer = "premium_offer_discount_20"
user.userprofile.premium_offer_expiration = datetime.now() + timedelta(
days=1)
user.userprofile.receive_marketing_and_commercial_material = True
user.userprofile.save()
user2 = User.objects.create(username="******",
password="******",
email="*****@*****.**")
user2.userprofile.premium_offer = "premium_offer_discount_50"
user2.userprofile.premium_offer_expiration = datetime.now(
) + timedelta(days=1)
user2.userprofile.receive_marketing_and_commercial_material = True
user2.userprofile.save()
admin.submit_premium_offer_discount(
request, BroadcastEmail.objects.filter(pk=email.pk))
args, kwargs = taskMock.call_args
taskMock.assert_called()
self.assertEquals(["*****@*****.**", "*****@*****.**"],
list(args[1]))
user.userprofile.refresh_from_db()
user2.userprofile.refresh_from_db()
self.assertIsNotNone(user.userprofile.premium_offer_sent)
self.assertIsNotNone(user2.userprofile.premium_offer_sent)
def setUp(self):
self.factory = RequestFactory()
self.user = User.objects.create_superuser(username='******',
email='test@localhost',
password='******')
self.site = AdminSite()
Booking.objects.create(
event_type_id="1",
spot_start="2019-01-01 14:30:00-0400",
spot_end="2019-01-01 14:40:00-0400",
approval_status=Booking.APPROVAL_STATUS_NEW,
)
Booking.objects.create(
event_type_id="2",
spot_start="2019-01-01 14:40:00-0400",
spot_end="2019-01-01 14:50:00-0400",
approval_status=Booking.APPROVAL_STATUS_DECLINED,
)
Booking.objects.create(
event_type_id="2",
spot_start="2019-01-01 14:50:00-0400",
spot_end="2019-01-01 15:00:00-0400",
approval_status=Booking.APPROVAL_STATUS_APPROVED,
approval_protected=True)
def test_readonly_and_editable(self):
class SongAdmin(admin.ModelAdmin):
readonly_fields = ["original_release"]
list_display = ["pk", "original_release"]
list_editable = ["original_release"]
fieldsets = [
(
None,
{
"fields": ["title", "original_release"],
},
),
]
errors = SongAdmin(Song, AdminSite()).check()
expected = [
checks.Error(
"The value of 'list_editable[0]' refers to 'original_release', "
"which is not editable through the admin.",
obj=SongAdmin,
id="admin.E125",
)
]
self.assertEqual(errors, expected)
def test_submit_inactive_account_reminder_already_sent_but_long_ago(
self, messageUserMock, taskMock):
request = RequestFactory().get("/")
email = BroadcastEmail.objects.create(subject="test")
admin = BroadcastEmailAdmin(model=BroadcastEmail,
admin_site=AdminSite())
user = User.objects.create(username="******",
password="******",
email="*****@*****.**")
user.userprofile.inactive_account_reminder_sent = timezone.now(
) - timedelta(days=90)
user.userprofile.save()
image = Image.objects.create(user=user)
image.uploaded = image.uploaded - timedelta(61)
image.save()
admin.submit_inactive_email_reminder(
request, BroadcastEmail.objects.filter(pk=email.pk))
args, kwargs = taskMock.call_args
taskMock.assert_called()
self.assertEqual(["*****@*****.**"], list(args[1]))
def test_exclude_inline_model_admin(self):
"""
Regression test for #9932 - exclude in InlineModelAdmin should not
contain the ForeignKey field used in ModelAdmin.model
"""
class SongInline(admin.StackedInline):
model = Song
exclude = ['album']
class AlbumAdmin(admin.ModelAdmin):
model = Album
inlines = [SongInline]
errors = AlbumAdmin(Album, AdminSite()).check()
expected = [
checks.Error(
("Cannot exclude the field 'album', because it is the foreign key "
"to the parent model 'admin_checks.Album'."),
hint=None,
obj=SongInline,
id='admin.E201',
)
]
self.assertEqual(errors, expected)
def test_callable_field(self):
class Musician1(models.Model):
def get_foo(self):
return 'Foo'
class Meta:
app_label = 'test'
class Album1(models.Model):
artist = models.ForeignKey(Musician1, on_delete=models.CASCADE, null=True, blank=True)
class Meta:
app_label = 'test'
class TestAdmin(TestRelatedFieldAdmin):
list_display = ('artist__get_foo',)
admin = TestAdmin(Album1, AdminSite())
album = Album1(artist=Musician1())
self.assertEqual(admin.artist__get_foo(album), 'Foo')
self.assertEqual(admin.get_list_display(None), ('artist__get_foo',))
admin.get_queryset(None)
admin.fake_qs.select_related.assert_called_with('artist')
def setUp(self):
self.users_credentials = {
'superuser': {
'username': '******',
'password': '******',
},
'goadmin': {
'username': '******',
'password': '******',
},
'moadmin': {
'username': '******',
'password': '******',
}
}
self.mo_admin_instance = MemberOrganisationOwnerAdmin(
CompanyOrganisationOwner, AdminSite()
)
self.group = Group.objects.get(name=self.group_name)
self.request_factory = RequestFactory()
self.mixer = Mixer(locale='en')
self.model_instances = self.create_required_instances()
def test_fieldsets_fields_non_tuple(self):
"""
The first fieldset's fields must be a list/tuple.
"""
class NotATupleAdmin(admin.ModelAdmin):
list_display = ["pk", "title"]
list_editable = ["title"]
fieldsets = [
(
None,
{
"fields": "title" # not a tuple
}),
]
errors = NotATupleAdmin(Song, AdminSite()).check()
expected = [
checks.Error(
"The value of 'fieldsets[0][1]['fields']' must be a list or tuple.",
obj=NotATupleAdmin,
id='admin.E008',
)
]
self.assertEqual(errors, expected)
def report_ticket_inline(model_admin_util):
model_admin_util.inline_model_admin = admin.ReportTicketInline(
Ticket, AdminSite())
return model_admin_util
obj.comment = " ".join(["hodor" for x in obj.comment.split()])
obj.save()
change_actions = ("hodor",)
admin.site.register(Comment, CommentAdmin)
class RelatedDataAdmin(DjangoObjectActions, admin.ModelAdmin):
# Object actions
################
def fill_up(self, request, obj):
if not obj.extra_data:
# bail because we need a comment
obj.extra_data = "hodor"
else:
obj.extra_data = ""
obj.save()
change_actions = ("fill_up",)
admin.site.register(RelatedData, RelatedDataAdmin)
support_admin = AdminSite(name="support")
support_admin.register(Poll, PollAdmin)
def test_custom_modelforms_with_fields_fieldsets(self):
"""
# Regression test for #8027: custom ModelForms with fields/fieldsets
"""
errors = ValidFields(Song, AdminSite()).check()
self.assertEqual(errors, [])
def test_get_password_yes(self):
model_admin = AclAdmin(model=ACL, admin_site=AdminSite())
self.acl.set_password('1234')
self.assertEqual(model_admin.get_password(self.acl), 'yes')
class PageAdmin(admin.ModelAdmin):
inlines = [PageInline]
class MenuAdmin(admin.ModelAdmin):
inlines = [MenuInline]
admin.site.register(Student, MyUserAdmin)
admin.site.register(Course)
admin.site.register(Group, GroupAdmin)
admin.site.register(Enroll, EnrollAdmin)
admin.site.register(Period)
admin.site.register(Category)
admin.site.register(MenuItem, MenuAdmin)
admin.site.register(Page, PageAdmin)
admin.site.site_header = _("Academica administrator site")
admin_site = AdminSite(name='matricula_admin')
admin_site.site_header = _("Academica administrator site")
admin_site.register(Student, MyUserAdmin)
admin_site.register(Course)
admin_site.register(Group, GroupAdmin)
admin_site.register(Enroll, EnrollAdmin)
admin_site.register(Period)
admin_site.register(Category)
admin_site.register(MenuItem, MenuItemAdmin)
admin_site.register(Page, PageAdmin)
def report_admin():
model_admin = admin.ReportAdmin(Report, AdminSite())
model_admin.message_user = Mock(name='message_user')
return model_admin
def test_get_password_no(self):
model_admin = AclAdmin(model=ACL, admin_site=AdminSite())
self.assertEqual(model_admin.get_password(self.acl), 'no')
def test_history_form_view_getting_history_abstract_external(self):
request = RequestFactory().post("/")
request.session = "session"
request._messages = FallbackStorage(request)
request.user = self.user
request.POST = {"_change_history": True}
obj = ConcreteExternal.objects.create(name="test")
obj.name = "new_test"
obj.save()
history = obj.history.all()[0]
admin_site = AdminSite()
admin = SimpleHistoryAdmin(ConcreteExternal, admin_site)
with patch("simple_history.admin.render") as mock_render:
with patch("simple_history.admin.SIMPLE_HISTORY_EDIT", True):
admin.history_form_view(request, obj.id, history.pk)
context = {
# Verify this is set for history object
"original":
history.instance,
"change_history":
True,
"title":
"Revert %s" % force_str(history.instance),
"adminform":
ANY,
"object_id":
obj.id,
"is_popup":
False,
"media":
ANY,
"errors":
ANY,
"app_label":
"tests",
"original_opts":
ANY,
"changelist_url":
"/admin/tests/concreteexternal/",
"change_url":
ANY,
"history_url":
"/admin/tests/concreteexternal/{pk}/history/".format(pk=obj.pk),
"add":
False,
"change":
True,
"has_add_permission":
admin.has_add_permission(request),
"has_change_permission":
admin.has_change_permission(request, obj),
"has_delete_permission":
admin.has_delete_permission(request, obj),
"revert_disabled":
admin.revert_disabled,
"has_file_field":
True,
"has_absolute_url":
False,
"form_url":
"",
"opts":
ANY,
"content_type_id":
ANY,
"save_as":
admin.save_as,
"save_on_top":
admin.save_on_top,
"root_path":
getattr(admin_site, "root_path", None),
}
context.update(admin_site.each_context(request))
mock_render.assert_called_once_with(request,
admin.object_history_form_template,
context)
def setUp(self) -> None:
self.site = AdminSite()
self.admin = admin.BankAccountAdmin(BankAccount, admin_site=self.site)
def test_readonly_lambda(self):
class SongAdmin(admin.ModelAdmin):
readonly_fields = (lambda obj: "test", )
errors = SongAdmin(Song, AdminSite()).check()
self.assertEqual(errors, [])
def test_readonly(self):
class SongAdmin(admin.ModelAdmin):
readonly_fields = ("title", )
errors = SongAdmin(Song, AdminSite()).check()
self.assertEqual(errors, [])
def setUp(self):
self.ticket_admin = admin.TicketAdmin(Ticket, AdminSite())
self.fake_pk = 1
def test_readonly_method_on_model(self):
class SongAdmin(admin.ModelAdmin):
readonly_fields = ("readonly_method_on_model", )
errors = SongAdmin(Song, AdminSite()).check()
self.assertEqual(errors, [])
def source_admin_util(model_admin_util):
model_admin_util.model_admin = admin.SourceAdmin(Source, AdminSite())
model_admin_util.model_admin.message_user = Mock(name='message_user')
model_admin_util.obj = Mock(spec=Source)
return model_admin_util
def test_nested_fields(self):
class NestedFieldsAdmin(admin.ModelAdmin):
fields = ('price', ('name', 'subtitle'))
errors = NestedFieldsAdmin(Book, AdminSite()).check()
self.assertEqual(errors, [])
def setUpClass(cls):
super().setUpClass()
cls.model_admin = FlaggedContentAdmin(Flag, AdminSite())
def setUp(self) -> None:
self.site = AdminSite()
self.admin = admin.BankAccountAdmin(BankAccount, admin_site=self.site)
self.rf = RequestFactory()
class MyAdminSite(AdminSite):
@never_cache
def login(self, request, extra_context=None):
if request.method == 'GET' and self.has_permission(request):
# Already logged-in, redirect to admin index
index_path = reverse('admin:index', current_app=self.name)
return HttpResponseRedirect(index_path)
raise Http404
def admin_view(self, view, cacheable=False):
def inner(request, *args, **kwargs):
if not self.has_permission(request):
raise Http404
return view(request, *args, **kwargs)
if not cacheable:
inner = never_cache(inner)
# We add csrf_protect here so this function can be used as a utility
# function for any view, without having to repeat 'csrf_protect'.
if not getattr(view, 'csrf_exempt', False):
inner = csrf_protect(inner)
return update_wrapper(inner, view)
if settings.IS_PRODUCTION:
site = MyAdminSite()
else:
site = AdminSite()
def setUp(self):
super().setUp()
self.site = AdminSite()
def admin(self):
return admin.GenericLogModelAdmin(TriggerLog, AdminSite())
