def test_default_change_form_template(self):
site = AdminSite()
site.register(SimpleModel, TranslatableAdmin)
admin = site._registry[SimpleModel]
self.assertEqual(admin.default_change_form_template, "admin/change_form.html")
# Avoid str + __proxy__ errors
self.assertEqual("default/" + admin.default_change_form_template, "default/admin/change_form.html")
def test_history_form_view_accepts_additional_context(self):
request = RequestFactory().post("/")
request.session = "session"
request._messages = FallbackStorage(request)
request.user = self.user
poll = Poll.objects.create(question="why?", pub_date=today)
poll.question = "how?"
poll.save()
history = poll.history.all()[0]
admin_site = AdminSite()
admin = SimpleHistoryAdmin(Poll, admin_site)
with patch("simple_history.admin.render") as mock_render:
admin.history_form_view(
request,
poll.id,
history.pk,
extra_context={"anything_else": "will be merged into context"},
)
context = {
# Verify this is set for original object
"anything_else": "will be merged into context",
"original": poll,
"change_history": False,
"title": "Revert %s" % force_text(poll),
"adminform": ANY,
"object_id": poll.id,
"is_popup": False,
"media": ANY,
"errors": ANY,
"app_label": "tests",
"original_opts": ANY,
"changelist_url": "/admin/tests/poll/",
"change_url": ANY,
"history_url": "/admin/tests/poll/1/history/",
"add": False,
"change": True,
"has_add_permission": admin.has_add_permission(request),
"has_change_permission": admin.has_change_permission(request, poll),
"has_delete_permission": admin.has_delete_permission(request, poll),
"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 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_text(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),
"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 __init__(self, *args, **kwargs):
BaseAdminSite.__init__(self, *args, **kwargs)
self.register(db.User, UserAdmin)
self.register(db.Group, GroupAdmin)
self.register(db.Verbiage, VerbiageAdmin)
self.register(db.NewsArticle, ArticleAdmin)
self.register(db.ForumPost, ArticleAdmin)
self.register(db.UserInfo, UserInfoAdmin)
self.register(db.Comment, CommentAdmin)
self.register(db.RideRequest, GeoAdmin)
self.register(db.Ride, GeoAdmin)
def __init__(self, *args, **kwargs):
BaseAdminSite.__init__(self, *args, **kwargs)
self.register(db.User, UserAdmin)
self.register(db.Group, GroupAdmin)
self.register(db.Carousel, CarouselAdmin)
self.register(db.Verbiage, VerbiageAdmin)
self.register(db.NewsArticle, ArticleAdmin)
self.register(db.ForumPost, ArticleAdmin)
self.register(db.UserInfo, UserInfoAdmin)
self.register(db.Comment, CommentAdmin)
self.register(db.RideRequest, GeoAdmin)
self.register(db.Ride, GeoAdmin)
self.register(db.SpamText, admin.ModelAdmin)
self.register(db.List, ListAdmin)
self.register(db.ListMember, ListMemberAdmin)
def setUp(self):
super(TestPublishableAdmin, self).setUp()
self.page1 = Page.objects.create(slug='page1', title='page 1')
self.page2 = Page.objects.create(slug='page2', title='page 2')
self.page1.publish()
self.page2.publish()
self.author1 = Author.objects.create(name='a1')
self.author2 = Author.objects.create(name='a2')
self.author1.publish()
self.author2.publish()
self.admin_site = AdminSite('Test Admin')
class PageBlockInline(PublishableStackedInline):
model = PageBlock
class PageAdmin(PublishableAdmin):
inlines = [PageBlockInline]
self.admin_site.register(Page, PageAdmin)
self.page_admin = PageAdmin(Page, self.admin_site)
# override urls, so reverse works
settings.ROOT_URLCONF = patterns(
'',
('^admin/',
include(self.admin_site.urls)),
)
def setUp(self):
super(AdminTestCase, self).setUp()
# Have a separate site, to avoid dependency on polymorphic wrapping or standard admin configuration
self.admin_site = AdminSite()
if self.model is not None:
self.admin_register(self.model, self.admin_class)
def test_no_blogpage_admin(self):
"""
When there is no page type mounted, the admin page should still be accessable.
"""
date = datetime(year=2016, month=5, day=1)
entry = Entry.objects.language('en-us').create(author=self.user, slug='hello-fr', publication_date=date)
url = reverse(admin_urlname(entry._meta, 'change'), args=(entry.pk,))
# Make an admin site, avoid dependency on URLs
admin = AdminSite()
admin.register(Entry, EntryAdmin)
model_admin = admin._registry[Entry]
request = RequestFactory().get(url)
request.user = self.user
response = model_admin.change_view(request, str(entry.pk))
self.assertContains(response, 'page needs to be created first')
def get_urls(self):
from django.conf.urls.defaults import patterns, url, include
from obadmin.admin.urls import urlpatterns as local_urls
url_patterns = local_urls
url_patterns += AdminSite.get_urls(self)
return url_patterns
def setUp(self):
super(PublishPage, self).setUp()
self.admin_site = AdminSite('Test Admin')
class PageAdmin(PublishableAdmin):
pass
self.admin_site.register(Page, PageAdmin)
self.page_admin = PageAdmin(Page, self.admin_site)
def get_urls(self):
urlpatterns = DjangoAdminSite.get_urls(self)
urlpatterns += patterns('',
url(r'^confirm_script$', is_staff(ConfirmScriptView.as_view()), name='confirm_script'),
url(r'^run_script$', is_staff(RunScriptView.as_view()), name='run_script'),
url(r'^kill_script$', is_staff(KillScriptView.as_view()), name='kill_script')
)
return urlpatterns
def get_urls(self):
"""
Add some extra URLs to the admin site, as per
https://docs.djangoproject.com/en/dev/ref/contrib/admin/#adding-views-to-admin-sites
"""
from obadmin.admin.urls import urlpatterns as local_urls
url_patterns = local_urls
url_patterns += AdminSite.get_urls(self)
return url_patterns
class PublishPage(TestCase):
def setUp(self):
super(PublishPage, self).setUp()
self.admin_site = AdminSite('Test Admin')
class PageAdmin(PublishableAdmin):
pass
self.admin_site.register(Page, PageAdmin)
self.page_admin = PageAdmin(Page, self.admin_site)
def test_should_be_publish(self):
self.page1 = Page.objects.create(slug='page1', title='page 1')
user1 = User.objects.create_superuser('test1', '*****@*****.**',
'pass')
self.factory = RequestFactory()
request = self.factory.post('/publish/change_view',
data={'_publish': ''})
request.user = user1
self.page_admin.change_view(request, str(self.page1.id))
self.assertEqual(Page.objects.filter(Page.Q_PUBLISHED,
slug=self.page1.slug).count(), 1)
def test_should_be_republish(self):
self.page1 = Page.objects.create(slug='page1', title='page 1')
self.page1.publish()
user1 = User.objects.create_superuser('test1', '*****@*****.**',
'pass')
self.factory = RequestFactory()
request = self.factory.post('/publish/change_view',
data={'_publish': ''})
request.user = user1
self.page_admin.change_view(request, str(self.page1.id))
self.assertEqual(Page.objects.filter(Page.Q_PUBLISHED,
slug=self.page1.slug).count(), 1)
def setUp(self):
super(TestPublishSelectedAction, self).setUp()
self.fp1 = Page.objects.create(slug='fp1', title='FP1')
self.fp2 = Page.objects.create(slug='fp2', title='FP2')
self.fp3 = Page.objects.create(slug='fp3', title='FP3')
self.admin_site = AdminSite('Test Admin')
self.page_admin = PublishableAdmin(Page, self.admin_site)
# override urls, so reverse works
settings.ROOT_URLCONF = patterns(
'',
('^admin/',
include(self.admin_site.urls)),
)
class TestGetGrootPermissions(TestCase):
def setUp(self):
self.site = AdminSite(name='admin')
def test_default_perms(self):
self.site.register(Author, AuthorAdmin)
author_admin = self.site._registry[Author]
permissions = author_admin.get_groot_permissions(request=None)
self.assertListEqual(
list(permissions.values_list('codename', flat=True)),
['add_author', 'change_author', 'delete_author'],
)
def test_limited_perms(self):
self.site.register(Author, AuthorAdmin, groot_permissions=('add_author',))
author_admin = self.site._registry[Author]
permissions = author_admin.get_groot_permissions(request=None)
self.assertListEqual(
list(permissions.values_list('codename', flat=True)), ['add_author'],
)
def setUp(self):
# Admin objects for all tests.
self.factory = RequestFactory()
self.admin_site = AdminSite()
self.admin_user = User.objects.get(is_superuser=True)
self.settings = override_settings(
MIDDLEWARE_CLASSES = (
'django.middleware.common.CommonMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
)
)
self.settings.enable()
def test_submit_inactive_account_reminder_success(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="*****@*****.**")
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_graceful_m2m_fail(self):
"""
Regression test for #12203/#12237 - Fail more gracefully when a M2M field that
specifies the 'through' option is included in the 'fields' or the 'fieldsets'
ModelAdmin options.
"""
class BookAdmin(admin.ModelAdmin):
fields = ['authors']
errors = BookAdmin(Book, AdminSite()).check()
expected = [
checks.Error(
("The value of 'fields' cannot include the ManyToManyField 'authors', "
"because that field manually specifies a relationship model."
),
hint=None,
obj=BookAdmin,
id='admin.E013',
)
]
self.assertEqual(errors, expected)
def test_generic_inline_model_admin_non_generic_model(self):
"""
Ensure that a model without a GenericForeignKey raises problems if it's included
in an GenericInlineModelAdmin definition.
"""
class BookInline(GenericStackedInline):
model = Book
class SongAdmin(admin.ModelAdmin):
inlines = [BookInline]
errors = SongAdmin(Song, AdminSite()).check()
expected = [
checks.Error(
"'admin_checks.Book' has no GenericForeignKey.",
hint=None,
obj=BookInline,
id='admin.E301',
)
]
self.assertEqual(errors, expected)
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_generic_inline_model_admin_bad_fk_field(self):
"""
A GenericInlineModelAdmin errors if the ct_fk_field points to a
nonexistent field.
"""
class InfluenceInline(GenericStackedInline):
model = Influence
ct_fk_field = 'nonexistent'
class SongAdmin(admin.ModelAdmin):
inlines = [InfluenceInline]
errors = SongAdmin(Song, AdminSite()).check()
expected = [
checks.Error(
"'ct_fk_field' references 'nonexistent', which is not a field on 'admin_checks.Influence'.",
obj=InfluenceInline,
id='admin.E303',
)
]
self.assertEqual(errors, expected)
def test_cannot_include_through(self):
class FieldsetBookAdmin(admin.ModelAdmin):
fieldsets = (
('Header 1', {
'fields': ('name', )
}),
('Header 2', {
'fields': ('authors', )
}),
)
errors = FieldsetBookAdmin(Book, AdminSite()).check()
expected = [
checks.Error(
"The value of 'fieldsets[1][1][\"fields\"]' cannot include the ManyToManyField "
"'authors', because that field manually specifies a relationship model.",
obj=FieldsetBookAdmin,
id='admin.E013',
)
]
self.assertEqual(errors, expected)
def test_acoes_deveria_ter_menu_remover_resultado_preliminar(
self, menu, reverse):
menu.items = []
mocked_url = mock.Mock()
reverse.return_value = mocked_url
def mocked_add(name, url):
menu.items.append((name, url))
menu.return_value.add = mocked_add
resultado_admin = admin.ResultadoPreliminarAdmin(
models.ResultadoPreliminar, AdminSite())
obj = mock.Mock()
obj.fase.edital.resultado_preliminar.resultado = obj
delattr(obj.fase.edital, "resultado")
resultado_admin.acoes(obj)
self.assertEqual(
("Remover resultado preliminar do edital", mocked_url),
menu.items[1])
def test_edital_display_deveria_retornar_valor_formatado(self):
resultado_admin = admin.ResultadoPreliminarAdmin(
models.ResultadoPreliminar, AdminSite())
self.campus_patcher = mock.patch.multiple(
cursos.models.Campus,
cria_usuarios_diretores=mock.DEFAULT,
adiciona_permissao_diretores=mock.DEFAULT,
remove_permissao_diretores=mock.DEFAULT)
self.fase_analise_patcher = mock.patch.multiple(
models.FaseAnalise,
atualizar_grupos_permissao=mock.DEFAULT,
)
self.campus_patcher.start()
self.fase_analise_patcher.start()
resultado = recipes.resultado_preliminar.make()
self.campus_patcher.stop()
self.fase_analise_patcher.stop()
edital = resultado.fase.edital
self.assertEqual(f"{edital.numero}/{edital.ano}",
resultado_admin.edital_display(resultado))
def test_all_history_view(self):
request = RequestFactory().post('/')
request.session = 'session'
request._messages = FallbackStorage(request)
request.user = self.user
poll = Poll.objects.create(question="why?", pub_date=today)
poll.question = "how?"
poll.save()
history = poll.history.all()[0]
admin_site = AdminSite()
admin = AllHistoryAdmin(Poll, admin_site)
admin.show_all_history = True
with patch('simple_history.admin.render') as mock_render:
with patch('simple_history.admin.SIMPLE_HISTORY_EDIT', True):
admin.all_history_view(request, )
context = {
# Verify this is set for history object not poll object
'title':
'All History: %s' % force_text(Poll._meta.verbose_name.title()),
'action_list':
ANY,
'module_name':
"Polls",
'root_path':
getattr(admin_site, 'root_path', None),
'app_label':
'tests',
'opts':
ANY,
'admin_user_view':
ANY
}
mock_render.assert_called_once_with(request,
admin.objects_history_template,
context, **extra_kwargs)
def test_subscribers(self):
model_admin = django_vox.admin.NotificationAdmin(models.Subscriber, AdminSite())
queryset = models.Subscriber.objects.all()
get_anon_request = MockAnonRequest("GET")
get_request = MockRequest("GET")
bad_post_request = MockRequest("POST", {"post": "yes", "action": "notify"})
post_data = {
"post": "yes",
"action": "notify",
"backend": "email-html",
"_selected_action": 1,
"subject": "foo",
"content": "bar",
}
post_request = MockRequest("POST", post_data)
with self.assertRaises(PermissionDenied):
django_vox.admin.notify(model_admin, get_anon_request, queryset)
result = django_vox.admin.notify(model_admin, get_request, queryset)
assert 200 == result.status_code
# This shouldn't actually send, because it's missing required data
assert 0 == len(mail.outbox)
django_vox.admin.notify(model_admin, bad_post_request, queryset)
assert 0 == len(mail.outbox)
# now let's actually try to send this thing
django_vox.admin.notify(model_admin, post_request, queryset)
assert 1 == len(mail.outbox)
assert "bar" == mail.outbox[0].body
# test message sending failure
with self.settings(EMAIL_BACKEND="Can't import this!"):
django_vox.admin.notify(model_admin, post_request, queryset)
failed_message = django_vox.models.FailedMessage.objects.all()
assert len(failed_message) == 1
assert (
"Can't import this! doesn't look like a module path"
== failed_message[0].error
)
def test_cannot_include_through(self):
class FieldsetBookAdmin(admin.ModelAdmin):
fieldsets = (
("Header 1", {
"fields": ("name", )
}),
("Header 2", {
"fields": ("authors", )
}),
)
errors = FieldsetBookAdmin(Book, AdminSite()).check()
expected = [
checks.Error(
"The value of 'fieldsets[1][1][\"fields\"]' cannot include the "
"ManyToManyField 'authors', because that field manually specifies a "
"relationship model.",
obj=FieldsetBookAdmin,
id="admin.E013",
)
]
self.assertEqual(errors, expected)
def test_response_change(self):
"""
Test the response_change method that it works with a _change_history
in the POST and settings.SIMPLE_HISTORY_EDIT set to True
"""
request = RequestFactory().post("/")
request.POST = {"_change_history": True}
request.session = "session"
request._messages = FallbackStorage(request)
request.path = "/awesome/url/"
poll = Poll.objects.create(question="why?", pub_date=today)
poll.question = "how?"
poll.save()
admin_site = AdminSite()
admin = SimpleHistoryAdmin(Poll, admin_site)
with patch("simple_history.admin.SIMPLE_HISTORY_EDIT", True):
response = admin.response_change(request, poll)
self.assertEqual(response["Location"], "/awesome/url/")
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'.",
obj=InfluenceInline,
id='admin.E304',
)
]
self.assertEqual(errors, expected)
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 setUpTestData(cls):
cls.site = AdminSite()
cls.company = Company.objects.create(name='Company')
company2 = Company.objects.create(name='Company2')
cls.dish = Dish.objects.create(name='Dish1',
company=cls.company,
price=10,
preparation_time='15min')
cls.dish2 = Dish.objects.create(name='Dish2',
company=company2,
price=10,
preparation_time='15min')
cls.da = DishAdmin(Dish, cls.site)
user = mock.Mock(spec=User)
user.company = cls.company
cls.request = mock.Mock(spec=Request)
cls.request.user = user
def test_nonfirst_fieldset(self):
"""
The second fieldset's fields must be a list/tuple.
"""
class NotATupleAdmin(admin.ModelAdmin):
fieldsets = [
(None, {
"fields": ("title",)
}),
('foo', {
"fields": "author" # not a tuple
}),
]
errors = NotATupleAdmin(Song, AdminSite()).check()
expected = [
checks.Error(
"The value of 'fieldsets[1][1]['fields']' must be a list or tuple.",
obj=NotATupleAdmin,
id='admin.E008',
)
]
self.assertEqual(errors, expected)
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'.",
obj=SongInline,
id='admin.E201',
)
]
self.assertEqual(errors, expected)
def test_date_field_filter(self):
class Musician2(models.Model):
birthday = models.DateField()
class Meta:
app_label = 'test'
class Album2(models.Model):
artist = models.ForeignKey(Musician2, on_delete=models.CASCADE, null=True, blank=True)
class Meta:
app_label = 'test'
class TestAdmin(TestRelatedFieldAdmin):
list_display = ('artist__birthday__month',)
admin = TestAdmin(Album2, AdminSite())
artist = Musician2(birthday=datetime.date(2020, 2, 2))
self.assertEqual(admin.artist__birthday__month(Album2(artist=artist)), 2)
self.assertEqual(admin.get_list_display(None), ('artist__birthday__month',))
admin.get_queryset(None)
admin.fake_qs.select_related.assert_called_with()
def test_submit_premium_offer_discount_already_sent_too_recently(
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="******")
user.userprofile.premium_offer = "premium_offer_discount_20"
user.userprofile.premium_offer_expiration = datetime.now() + timedelta(
days=1)
user.userprofile.premium_offer_sent = sent = datetime.now(
) - timedelta(days=20)
user.userprofile.receive_marketing_and_commercial_material = True
user.userprofile.save()
admin.submit_premium_offer_discount(
request, BroadcastEmail.objects.filter(pk=email.pk))
taskMock.assert_not_called()
user.userprofile.refresh_from_db()
self.assertEqual(sent, user.userprofile.premium_offer_sent)
def test_dynamic_inline_admins_fieldsets(self):
"""
Tests if ``_order`` is moved to the end of the last fieldsets fields.
"""
class MyModelInline(BaseDynamicInlineAdmin, InlineModelAdmin):
model = RichTextPage
fieldsets = (
("Fieldset 1", {
"fields": ("a", )
}),
("Fieldset 2", {
"fields": ("_order", "b")
}),
("Fieldset 3", {
"fields": ("c")
}),
)
request = self._request_factory.get("/admin/")
inline = MyModelInline(None, AdminSite())
fieldsets = inline.get_fieldsets(request)
self.assertEqual(fieldsets[-1][1]["fields"][-1], "_order")
self.assertNotIn("_order", fieldsets[1][1]["fields"])
def test_related_field(self):
class Musician(models.Model):
first_name = models.CharField(max_length=50)
class Meta:
app_label = 'test'
class Album(models.Model):
artist = models.ForeignKey(Musician, on_delete=models.CASCADE, null=True, blank=True)
class Meta:
app_label = 'test'
class TestAdmin(TestRelatedFieldAdmin):
list_display = ('artist__first_name',)
admin = TestAdmin(Album, AdminSite())
album = Album(artist=Musician(first_name='Foo'))
self.assertEqual(admin.artist__first_name(album), 'Foo')
self.assertEqual(admin.get_list_display(None), ('artist__first_name',))
admin.get_queryset(None)
admin.fake_qs.select_related.assert_called_with('artist')
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.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_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.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 setUp(self):
self.site = AdminSite(name='admin')
class TestPublishableAdmin(TestCase):
def setUp(self):
super(TestPublishableAdmin, self).setUp()
self.page1 = Page.objects.create(slug='page1', title='page 1')
self.page2 = Page.objects.create(slug='page2', title='page 2')
self.page1.publish()
self.page2.publish()
self.author1 = Author.objects.create(name='a1')
self.author2 = Author.objects.create(name='a2')
self.author1.publish()
self.author2.publish()
self.admin_site = AdminSite('Test Admin')
class PageBlockInline(PublishableStackedInline):
model = PageBlock
class PageAdmin(PublishableAdmin):
inlines = [PageBlockInline]
self.admin_site.register(Page, PageAdmin)
self.page_admin = PageAdmin(Page, self.admin_site)
# override urls, so reverse works
settings.ROOT_URLCONF = patterns(
'',
('^admin/',
include(self.admin_site.urls)),
)
def test_get_publish_status_display(self):
page = Page.objects.create(slug="hhkkk", title="hjkhjkh")
self.failUnlessEqual('Changed - not yet published',
self.page_admin.get_publish_status_display(page))
page.publish()
self.failUnlessEqual('Published',
self.page_admin.get_publish_status_display(page))
page.save()
self.failUnlessEqual('Changed',
self.page_admin.get_publish_status_display(page))
page.delete()
self.failUnlessEqual('To be deleted',
self.page_admin.get_publish_status_display(page))
def test_queryset(self):
# make sure we only get back draft objects
request = None
self.failUnlessEqual(
set([self.page1, self.page1.public, self.page2,
self.page2.public]),
set(Page.objects.all())
)
self.failUnlessEqual(
set([self.page1, self.page2]),
set(self.page_admin.queryset(request))
)
def test_get_actions_global_delete_replaced(self):
from publish.actions import delete_selected
class request(object):
GET = {}
actions = self.page_admin.get_actions(request)
self.failUnless('delete_selected' in actions)
action, name, description = actions['delete_selected']
self.failUnlessEqual(delete_selected, action)
self.failUnlessEqual('delete_selected', name)
self.failUnlessEqual(delete_selected.short_description, description)
def test_formfield_for_foreignkey(self):
# foreign key forms fields in admin
# for publishable models should be filtered
# to hide public object
request = None
parent_field = None
for field in Page._meta.fields:
if field.name == 'parent':
parent_field = field
break
self.failUnless(parent_field)
choice_field = self.page_admin.formfield_for_foreignkey(parent_field,
request)
self.failUnless(choice_field)
self.failUnless(isinstance(choice_field, ModelChoiceField))
self.failUnlessEqual(
set([self.page1, self.page1.public, self.page2,
self.page2.public]),
set(Page.objects.all())
)
self.failUnlessEqual(
set([self.page1, self.page2]),
set(choice_field.queryset)
)
def test_formfield_for_manytomany(self):
request = None
authors_field = None
for field in Page._meta.many_to_many:
if field.name == 'authors':
authors_field = field
break
self.failUnless(authors_field)
choice_field = self.page_admin.formfield_for_manytomany(authors_field,
request)
self.failUnless(choice_field)
self.failUnless(isinstance(choice_field, ModelMultipleChoiceField))
self.failUnlessEqual(
set([self.author1, self.author1.public, self.author2,
self.author2.public]),
set(Author.objects.all())
)
self.failUnlessEqual(
set([self.author1, self.author2]),
set(choice_field.queryset)
)
def test_has_change_permission(self):
class dummy_request(object):
method = 'GET'
REQUEST = {}
class user(object):
@classmethod
def has_perm(cls, permission):
return True
self.failUnless(self.page_admin.has_change_permission(dummy_request))
self.failUnless(
self.page_admin.has_change_permission(dummy_request, self.page1))
self.failIf(self.page_admin.has_change_permission(dummy_request,
self.page1.public))
# can view deleted items
self.page1.publish_state = Publishable.PUBLISH_DELETE
self.failUnless(
self.page_admin.has_change_permission(dummy_request, self.page1))
# but cannot modify them
dummy_request.method = 'POST'
self.failIf(
self.page_admin.has_change_permission(dummy_request, self.page1))
def test_has_delete_permission(self):
class dummy_request(object):
method = 'GET'
REQUEST = {}
class user(object):
@classmethod
def has_perm(cls, permission):
return True
self.failUnless(self.page_admin.has_delete_permission(dummy_request))
self.failUnless(
self.page_admin.has_delete_permission(dummy_request, self.page1))
self.failIf(self.page_admin.has_delete_permission(dummy_request,
self.page1.public))
def test_change_view_normal(self):
class dummy_request(object):
method = 'GET'
REQUEST = {}
COOKIES = {}
META = {}
@classmethod
def is_ajax(cls):
return False
@classmethod
def is_secure(cls):
return False
class user(object):
@classmethod
def has_perm(cls, permission):
return True
@classmethod
def get_and_delete_messages(cls):
return []
response = self.page_admin.change_view(dummy_request,
str(self.page1.id))
self.failUnless(response is not None)
self.failIf('deleted' in _get_rendered_content(response))
def test_change_view_not_deleted(self):
class dummy_request(object):
method = 'GET'
COOKIES = {}
META = {}
@classmethod
def is_ajax(cls):
return False
@classmethod
def is_secure(cls):
return False
class user(object):
@classmethod
def has_perm(cls, permission):
return True
try:
self.page_admin.change_view(dummy_request,
unicode(self.page1.public.id))
self.fail()
except Http404:
pass
def test_change_view_deleted(self):
class dummy_request(object):
method = 'GET'
REQUEST = {}
COOKIES = {}
META = {}
@classmethod
def is_ajax(cls):
return False
@classmethod
def is_secure(cls):
return False
class user(object):
@classmethod
def has_perm(cls, permission):
return True
@classmethod
def get_and_delete_messages(cls):
return []
self.page1.delete()
response = self.page_admin.change_view(dummy_request,
str(self.page1.id))
self.failUnless(response is not None)
self.failUnless('deleted' in _get_rendered_content(response))
def test_change_view_deleted_POST(self):
class dummy_request(object):
csrf_processing_done = True
method = 'POST'
COOKIES = {}
META = {}
POST = {}
@classmethod
def is_ajax(cls):
return False
@classmethod
def is_secure(cls):
return False
self.page1.delete()
try:
self.page_admin.change_view(dummy_request, str(self.page1.id))
self.fail()
except PermissionDenied:
pass
def test_change_view_delete_inline(self):
block = PageBlock.objects.create(page=self.page1,
content='some content')
page1 = Page.objects.get(pk=self.page1.pk)
page1.publish()
user1 = User.objects.create_user('test1', '*****@*****.**', 'jkljkl')
# fake selecting the delete tickbox for the block
class dummy_request(object):
csrf_processing_done = True
method = 'POST'
POST = {
'slug': page1.slug,
'title': page1.title,
'content': page1.content,
'pub_date_0': '2010-02-12',
'pub_date_1': '17:40:00',
'pageblock_set-TOTAL_FORMS': '2',
'pageblock_set-INITIAL_FORMS': '1',
'pageblock_set-0-id': str(block.id),
'pageblock_set-0-page': str(page1.id),
'pageblock_set-0-DELETE': 'yes'
}
REQUEST = POST
FILES = {}
COOKIES = {}
META = {}
@classmethod
def is_ajax(cls):
return False
@classmethod
def is_secure(cls):
return False
class user(object):
pk = user1.pk
@classmethod
def is_authenticated(self):
return True
@classmethod
def has_perm(cls, permission):
return True
@classmethod
def get_and_delete_messages(cls):
return []
class message_set(object):
@classmethod
def create(cls, message=''):
pass
class _messages(object):
@classmethod
def add(cls, *message):
pass
block = PageBlock.objects.get(id=block.id)
public_block = block.public
response = self.page_admin.change_view(dummy_request, str(page1.id))
self.assertEqual(302, response.status_code)
# the block should have been deleted (but not the public one)
self.failUnlessEqual([public_block], list(PageBlock.objects.all()))
from django.conf import settings
from django.contrib.admin import AdminSite
from django.contrib.auth.models import User
from django.contrib.auth.admin import UserAdmin
from django.contrib.flatpages.models import FlatPage
from django.contrib.flatpages.admin import FlatPageAdmin
site = AdminSite()
class CustomUserAdmin(UserAdmin):
# Remove group editing
fieldsets = UserAdmin.fieldsets[:-1]
def has_delete_permission(self, request, obj=None):
return getattr(settings, 'BACKOFFICE', False)
class CustomFlatPageAdmin(FlatPageAdmin):
list_filter = []
site.register(User, CustomUserAdmin)
site.register(FlatPage, CustomFlatPageAdmin)
from __future__ import unicode_literals
from django.contrib.admin import AdminSite, ModelAdmin, TabularInline
from admin_enhancer import admin as enhanced_admin
from .models import Author, Book, Character, Theme
site = AdminSite()
class EnhancedModelAdmin(enhanced_admin.EnhancedModelAdminMixin, ModelAdmin):
pass
class CharacterInline(enhanced_admin.EnhancedAdminMixin, TabularInline):
model = Character
class BookAdmin(EnhancedModelAdmin):
inlines = (CharacterInline,)
filter_horizontal = ('themes',)
site.register(Author, EnhancedModelAdmin)
site.register(Book, BookAdmin)
site.register(Theme, EnhancedModelAdmin)
list_filter = ["category_id", "designation"]
inlines = [AttendanceInline]
class AttendanceAdmin(admin.ModelAdmin):
list_display = ("employee_id", "date", "shift", "project")
list_filter = ["employee_id", "date", "project"]
class PaymentAdmin(admin.ModelAdmin):
list_display = ("paid_date", "amount", "paid_details", "project_id")
list_filter = ["project_id", "amount", "paid_date"]
class EmpPaymentAdmin(admin.ModelAdmin):
list_display = ("employee", "amount", "type", "month", "year")
list_filter = ["employee", "month", "year"]
site = AdminSite()
site.site_header = "Omar and Assosciates"
site.register(Project, ProjectAdmin)
site.register(Category)
site.register(Dealer)
site.register(Expense, ExpenseAdmin)
site.register(Employee, EmployeeAdmin)
site.register(Attendance, AttendanceAdmin)
site.register(EmployeePayment, EmpPaymentAdmin)
site.register(Payment, PaymentAdmin)
actions = super(PollAdmin, self).get_change_actions(request, object_id, form_url)
actions = list(actions)
if not request.user.is_superuser:
return []
obj = self.model.objects.get(pk=object_id)
if obj.question.endswith('?'):
actions.remove('question_mark')
return actions
admin.site.register(Poll, PollAdmin)
class CommentAdmin(DjangoObjectActions, admin.ModelAdmin):
# Object actions
################
def hodor(self, request, obj):
if not obj.comment:
# bail because we need a comment
return
obj.comment = ' '.join(['hodor' for x in obj.comment.split()])
obj.save()
change_actions = ('hodor', )
admin.site.register(Comment, CommentAdmin)
support_admin = AdminSite(name='support')
support_admin.register(Poll, PollAdmin)
class AdminTest(AppTestCase):
"""
Test the admin functions.
"""
def setUp(self):
# Admin objects for all tests.
self.factory = RequestFactory()
self.admin_site = AdminSite()
self.admin_user = User.objects.get(is_superuser=True)
self.settings = override_settings(
MIDDLEWARE_CLASSES = (
'django.middleware.common.CommonMiddleware',
'django.contrib.sessions.middleware.SessionMiddleware',
'django.middleware.csrf.CsrfViewMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'django.contrib.messages.middleware.MessageMiddleware',
)
)
self.settings.enable()
def tearDown(self):
self.settings.disable()
def test_add_page(self):
"""
Test adding an object with placeholder field via the admin.
"""
self.admin_site.register(PlaceholderFieldTestPage, PlaceholderFieldTestPageAdmin)
modeladmin = self.admin_site._registry[PlaceholderFieldTestPage]
# Get all post data.
# Includes all inlines, so all inline formsets of other plugins will be added (with TOTAL_FORMS 0)
contents_slot = PlaceholderFieldTestPage.contents.slot
formdata = self._get_management_form_data(modeladmin)
formdata.update({
'title': 'TEST1',
'placeholder-fs-TOTAL_FORMS': '1',
'placeholder-fs-MAX_NUM_FORMS': '', # Needed for Django <= 1.4.3
'placeholder-fs-INITIAL_FORMS': '0', # Needed for Django 1.3
'placeholder-fs-0-slot': contents_slot,
'placeholder-fs-0-role': Placeholder.MAIN,
'rawhtmltestitem-TOTAL_FORMS': '1',
'rawhtmltestitem-MAX_NUM_FORMS': '',
'rawhtmltestitem-INITIAL_FORMS': '0',
'rawhtmltestitem-0-placeholder': '', # The placeholder is not defined yet, as item is not yet created.
'rawhtmltestitem-0-placeholder_slot': contents_slot, # BaseContentItemFormSet resolves the placeholder after it's created
'rawhtmltestitem-0-sort_order': '1',
'rawhtmltestitem-0-html': u'<b>foo</b>',
})
# Make a POST to the admin page.
response = self._post_add(modeladmin, formdata)
self.assertEqual(response.status_code, 302, "No redirect, received:\n\n{0}".format(self._render_response(response)))
# Check that the page exists.
page = PlaceholderFieldTestPage.objects.get(title='TEST1')
# Check that the placeholder is created,
# and properly links back to it's parent.
placeholder = page.contents
self.assertEqual(placeholder.slot, contents_slot)
self.assertEqual(placeholder.role, Placeholder.MAIN)
self.assertEqual(placeholder.parent, page)
# Check that the ContentItem is created,
# and properly links back to it's parent.
rawhtmltestitem = RawHtmlTestItem.objects.get(html=u'<b>foo</b>')
self.assertEqual(rawhtmltestitem.placeholder, placeholder)
self.assertEqual(rawhtmltestitem.parent, page)
# Also check reverse relation of placeholder
rawhtmltestitem = placeholder.contentitems.all()[0]
self.assertEqual(rawhtmltestitem.html, u'<b>foo</b>')
def _post_add(self, modeladmin, formdata):
opts = modeladmin.opts
url = reverse('admin:{0}_{1}_add'.format(*_get_url_format(opts)))
# Build request
formdata['csrfmiddlewaretoken'] = 'foo'
request = self.factory.post(url, data=formdata)
request.COOKIES[settings.CSRF_COOKIE_NAME] = 'foo'
# Add properties which middleware would typically do
request.session = {}
request.user = self.admin_user
MessageMiddleware().process_request(request)
# Make a direct call, circumvents login page.
return modeladmin.add_view(request)
def _get_management_form_data(self, modeladmin):
"""
Return the formdata that the management forms need.
"""
opts = modeladmin.opts
url = reverse('admin:{0}_{1}_add'.format(*_get_url_format(opts)))
request = self.factory.get(url)
request.user = self.admin_user
if hasattr(modeladmin, 'get_inline_instances'):
inline_instances = modeladmin.get_inline_instances(request) # Django 1.4
else:
inline_instances = [inline_class(modeladmin.model, self.admin_site) for inline_class in modeladmin.inlines]
forms = []
for inline_instance in inline_instances:
FormSet = inline_instance.get_formset(request)
formset = FormSet(instance=modeladmin.model())
forms.append(formset.management_form)
# In a primitive way, get the form fields.
# This is not exactly the same as a POST, since that runs through clean()
formdata = {}
for form in forms:
for boundfield in form:
formdata[boundfield.html_name] = boundfield.value()
return formdata
def _render_response(self, response):
if hasattr(response, 'render'):
# TemplateResponse
return u"== Context ==\n{0}\n\n== Response ==\n{1}".format(pformat(response.context_data), response.render().content)
else:
return response.content
class AdminTestCase(TestCase):
"""
Testing the admin site
"""
#: The model to test
model = None
#: The admin class to test
admin_class = None
@classmethod
def setUpClass(cls):
super(AdminTestCase, cls).setUpClass()
cls.admin_user = User.objects.create_superuser('admin', '*****@*****.**', password='******')
def setUp(self):
super(AdminTestCase, self).setUp()
# Have a separate site, to avoid dependency on polymorphic wrapping or standard admin configuration
self.admin_site = AdminSite()
if self.model is not None:
self.admin_register(self.model, self.admin_class)
def tearDown(self):
clear_url_caches()
set_urlconf(None)
def register(self, model):
"""Decorator, like admin.register()"""
def _dec(admin_class):
self.admin_register(model, admin_class)
return admin_class
return _dec
def admin_register(self, model, admin_site):
"""Register an model with admin to the test case, test client and URL reversing code."""
self.admin_site.register(model, admin_site)
# Make sure the URLs are reachable by reverse()
clear_url_caches()
set_urlconf(tuple([
url('^tmp-admin/', self.admin_site.urls)
]))
def get_admin_instance(self, model):
try:
return self.admin_site._registry[model]
except KeyError:
raise ValueError("Model not registered with admin: {}".format(model))
@classmethod
def tearDownClass(cls):
super(AdminTestCase, cls).tearDownClass()
clear_url_caches()
set_urlconf(None)
def get_add_url(self, model):
admin_instance = self.get_admin_instance(model)
return reverse(admin_urlname(admin_instance.opts, 'add'))
def get_changelist_url(self, model):
admin_instance = self.get_admin_instance(model)
return reverse(admin_urlname(admin_instance.opts, 'changelist'))
def get_change_url(self, model, object_id):
admin_instance = self.get_admin_instance(model)
return reverse(admin_urlname(admin_instance.opts, 'change'), args=(object_id,))
def get_history_url(self, model, object_id):
admin_instance = self.get_admin_instance(model)
return reverse(admin_urlname(admin_instance.opts, 'history'), args=(object_id,))
def get_delete_url(self, model, object_id):
admin_instance = self.get_admin_instance(model)
return reverse(admin_urlname(admin_instance.opts, 'delete'), args=(object_id,))
def admin_get_add(self, model, qs=''):
"""
Make a direct "add" call to the admin page, circumvening login checks.
"""
admin_instance = self.get_admin_instance(model)
request = self.create_admin_request('get', self.get_add_url(model) + qs)
response = admin_instance.add_view(request)
self.assertEqual(response.status_code, 200)
return response
def admin_post_add(self, model, formdata, qs=''):
"""
Make a direct "add" call to the admin page, circumvening login checks.
"""
admin_instance = self.get_admin_instance(model)
request = self.create_admin_request('post', self.get_add_url(model) + qs, data=formdata)
response = admin_instance.add_view(request)
self.assertFormSuccess(request.path, response)
return response
def admin_get_changelist(self, model):
"""
Make a direct "add" call to the admin page, circumvening login checks.
"""
admin_instance = self.get_admin_instance(model)
request = self.create_admin_request('get', self.get_changelist_url(model))
response = admin_instance.changelist_view(request)
self.assertEqual(response.status_code, 200)
return response
def admin_get_change(self, model, object_id, query=None, **extra):
"""
Perform a GET request on the admin page
"""
admin_instance = self.get_admin_instance(model)
request = self.create_admin_request('get', self.get_change_url(model, object_id), data=query, **extra)
response = admin_instance.change_view(request, str(object_id))
self.assertEqual(response.status_code, 200)
return response
def admin_post_change(self, model, object_id, formdata, **extra):
"""
Make a direct "add" call to the admin page, circumvening login checks.
"""
admin_instance = self.get_admin_instance(model)
request = self.create_admin_request('post', self.get_change_url(model, object_id), data=formdata, **extra)
response = admin_instance.change_view(request, str(object_id))
self.assertFormSuccess(request.path, response)
return response
def admin_get_history(self, model, object_id, query=None, **extra):
"""
Perform a GET request on the admin page
"""
admin_instance = self.get_admin_instance(model)
request = self.create_admin_request('get', self.get_history_url(model, object_id), data=query, **extra)
response = admin_instance.history_view(request, str(object_id))
self.assertEqual(response.status_code, 200)
return response
def admin_get_delete(self, model, object_id, query=None, **extra):
"""
Perform a GET request on the admin delete page
"""
admin_instance = self.get_admin_instance(model)
request = self.create_admin_request('get', self.get_delete_url(model, object_id), data=query, **extra)
response = admin_instance.delete_view(request, str(object_id))
self.assertEqual(response.status_code, 200)
return response
def admin_post_delete(self, model, object_id, **extra):
"""
Make a direct "add" call to the admin page, circumvening login checks.
"""
if not extra:
extra = {'data': {'post': 'yes'}}
admin_instance = self.get_admin_instance(model)
request = self.create_admin_request('post', self.get_delete_url(model, object_id), **extra)
response = admin_instance.delete_view(request, str(object_id))
self.assertEqual(response.status_code, 302, "Form errors in calling {0}".format(request.path))
return response
def create_admin_request(self, method, url, data=None, **extra):
"""
Construct an Request instance for the admin view.
"""
factory_method = getattr(RequestFactory(), method)
if data is not None:
if method != 'get':
data['csrfmiddlewaretoken'] = 'foo'
dummy_request = factory_method(url, data=data)
dummy_request.user = self.admin_user
# Add the management form fields if needed.
# base_data = self._get_management_form_data(dummy_request)
# base_data.update(data)
# data = base_data
request = factory_method(url, data=data, **extra)
request.COOKIES[settings.CSRF_COOKIE_NAME] = 'foo'
request.csrf_processing_done = True
# Add properties which middleware would typically do
request.session = {}
request.user = self.admin_user
MessageMiddleware().process_request(request)
return request
def assertFormSuccess(self, request_url, response):
"""
Assert that the response was a redirect, not a form error.
"""
self.assertIn(response.status_code, [200, 302])
if response.status_code != 302:
context_data = response.context_data
if 'errors' in context_data:
errors = response.context_data['errors']
elif 'form' in context_data:
errors = context_data['form'].errors
else:
raise KeyError("Unknown field for errors in the TemplateResponse!")
self.assertEqual(response.status_code, 302,
"Form errors in calling {0}:\n{1}".format(request_url, errors.as_text()))
self.assertTrue('/login/?next=' not in response['Location'],
"Received login response for {0}".format(request_url))
class TestPublishSelectedAction(TestCase):
def setUp(self):
super(TestPublishSelectedAction, self).setUp()
self.fp1 = Page.objects.create(slug='fp1', title='FP1')
self.fp2 = Page.objects.create(slug='fp2', title='FP2')
self.fp3 = Page.objects.create(slug='fp3', title='FP3')
self.admin_site = AdminSite('Test Admin')
self.page_admin = PublishableAdmin(Page, self.admin_site)
# override urls, so reverse works
settings.ROOT_URLCONF = patterns(
'',
('^admin/',
include(self.admin_site.urls)),
)
def test_publish_selected_confirm(self):
pages = Page.objects.exclude(id=self.fp3.id)
class dummy_request(object):
META = {}
POST = {}
class user(object):
@classmethod
def has_perm(cls, *arg):
return True
@classmethod
def get_and_delete_messages(cls):
return []
response = publish_selected(self.page_admin, dummy_request, pages)
self.failIf(Page.objects.published().count() > 0)
self.failUnless(response is not None)
self.failUnlessEqual(200, response.status_code)
def test_publish_selected_confirmed(self):
pages = Page.objects.exclude(id=self.fp3.id)
class dummy_request(object):
POST = {'post': True}
class user(object):
@classmethod
def is_authenticated(cls):
return True
@classmethod
def has_perm(cls, *arg):
return True
class message_set(object):
@classmethod
def create(cls, message=None):
self._message = message
class _messages(object):
@classmethod
def add(cls, *message):
self._message = message
response = publish_selected(self.page_admin, dummy_request, pages)
self.failUnlessEqual(2, Page.objects.published().count())
self.failUnless(getattr(self, '_message', None) is not None)
self.failUnless(response is None)
def test_convert_all_published_to_html(self):
self.admin_site.register(Page, PublishableAdmin)
all_published = NestedSet()
page = Page.objects.create(slug='here', title='title')
block = PageBlock.objects.create(page=page, content='stuff here')
all_published.add(page)
all_published.add(block, parent=page)
converted = _convert_all_published_to_html(self.admin_site,
all_published)
expected = [
u'<a href="../../example_app/page/%d/">Page: here (Changed - '
u'not yet published)</a>' % page.id,
[u'Page block: PageBlock object']]
self.failUnlessEqual(expected, converted)
def test_publish_selected_does_not_have_permission(self):
self.admin_site.register(Page, PublishableAdmin)
pages = Page.objects.exclude(id=self.fp3.id)
class dummy_request(object):
POST = {}
META = {}
class user(object):
@classmethod
def has_perm(cls, *arg):
return False
@classmethod
def get_and_delete_messages(cls):
return []
response = publish_selected(self.page_admin, dummy_request, pages)
self.failIf(response is None)
# publish button should not be in response
self.failIf('value="publish_selected"' in response.content)
self.failIf('value="Yes, Publish"' in response.content)
self.failIf('form' in response.content)
self.failIf(Page.objects.published().count() > 0)
def test_publish_selected_does_not_have_related_permission(self):
# check we can't publish when we don't have permission
# for a related model (in this case authors)
self.admin_site.register(Author, PublishableAdmin)
author = Author.objects.create(name='John')
self.fp1.authors.add(author)
pages = Page.objects.draft()
class dummy_request(object):
POST = {'post': True}
class _messages(object):
@classmethod
def add(cls, *args):
return 'message'
class user(object):
pk = 1
@classmethod
def is_authenticated(cls):
return True
@classmethod
def has_perm(cls, perm):
return perm != 'example_app.publish_author'
try:
publish_selected(self.page_admin, dummy_request, pages)
self.fail()
except PermissionDenied:
pass
self.failIf(Page.objects.published().count() > 0)
def test_publish_selected_logs_publication(self):
self.admin_site.register(Page, PublishableAdmin)
pages = Page.objects.exclude(id=self.fp3.id)
class dummy_request(object):
POST = {'post': True}
class user(object):
pk = 1
@classmethod
def is_authenticated(cls):
return True
@classmethod
def has_perm(cls, perm):
return perm != 'example_app.publish_author'
class message_set(object):
@classmethod
def create(cls, message=None):
pass
class _messages(object):
@classmethod
def add(cls, *message):
pass
publish_selected(self.page_admin, dummy_request, pages)
# should have logged two publications
from django.contrib.admin.models import LogEntry
from django.contrib.contenttypes.models import ContentType
ContentType.objects.get_for_model(self.fp1).pk
self.failUnlessEqual(2, LogEntry.objects.filter().count())
class AdminTest(AppTestCase):
"""
Test the admin functions.
"""
def setUp(self):
# Admin objects for all tests.
self.factory = RequestFactory()
self.admin_site = AdminSite()
self.admin_user = User.objects.get(is_superuser=True)
self.settings = override_settings(MIDDLEWARE_CLASSES=(
"django.middleware.common.CommonMiddleware",
"django.contrib.sessions.middleware.SessionMiddleware",
"django.middleware.csrf.CsrfViewMiddleware",
"django.contrib.auth.middleware.AuthenticationMiddleware",
"django.contrib.messages.middleware.MessageMiddleware",
))
self.settings.enable()
def tearDown(self):
self.settings.disable()
def test_add_page(self):
"""
Test adding an object with placeholder field via the admin.
"""
self.admin_site.register(PlaceholderFieldTestPage,
PlaceholderFieldTestPageAdmin)
modeladmin = self.admin_site._registry[PlaceholderFieldTestPage]
# Get all post data.
# Includes all inlines, so all inline formsets of other plugins will be added (with TOTAL_FORMS 0)
contents_slot = PlaceholderFieldTestPage.contents.slot
formdata = self._get_management_form_data(modeladmin)
formdata.update({
"title": "TEST1",
"placeholder-fs-TOTAL_FORMS": "1",
"placeholder-fs-0-slot": contents_slot,
"placeholder-fs-0-role": Placeholder.MAIN,
"rawhtmltestitem-TOTAL_FORMS": "1",
"rawhtmltestitem-MAX_NUM_FORMS": "",
"rawhtmltestitem-INITIAL_FORMS": "0",
"rawhtmltestitem-0-placeholder":
"", # The placeholder is not defined yet, as item is not yet created.
"rawhtmltestitem-0-placeholder_slot":
contents_slot, # BaseContentItemFormSet resolves the placeholder after it's created
"rawhtmltestitem-0-sort_order": "1",
"rawhtmltestitem-0-html": "<b>foo</b>",
})
# Make a POST to the admin page.
response = self._post_add(modeladmin, formdata)
self.assertEqual(
response.status_code,
302,
f"No redirect, received:\n\n{self._render_response(response)}",
)
# Check that the page exists.
page = PlaceholderFieldTestPage.objects.get(title="TEST1")
# Check that the placeholder is created,
# and properly links back to it's parent.
placeholder = page.contents
self.assertEqual(placeholder.slot, contents_slot)
self.assertEqual(placeholder.role, Placeholder.MAIN)
self.assertEqual(placeholder.parent, page)
# Check that the ContentItem is created,
# and properly links back to it's parent.
rawhtmltestitem = RawHtmlTestItem.objects.get(html="<b>foo</b>")
self.assertEqual(rawhtmltestitem.placeholder, placeholder)
self.assertEqual(rawhtmltestitem.parent, page)
# Also check reverse relation of placeholder
rawhtmltestitem = placeholder.contentitems.all()[0]
self.assertEqual(rawhtmltestitem.html, "<b>foo</b>")
def test_copy_language_backend(self):
"""
Testing how the copy button works.
It calls the ``get_placeholder_data_view`` function.
"""
self.admin_site.register(PlaceholderFieldTestPage,
PlaceholderFieldTestPageAdmin)
modeladmin = self.admin_site._registry[PlaceholderFieldTestPage]
page = factories.create_page()
placeholder = factories.create_placeholder(page=page)
item1 = factories.create_content_item(RawHtmlTestItem,
placeholder=placeholder,
html="AA")
item2 = factories.create_content_item(RawHtmlTestItem,
placeholder=placeholder,
html="BB")
request = self._get_request(
admin_urlname(page._meta, "get_placeholder_data"))
data = modeladmin.get_placeholder_data_view(request, page.pk).jsondata
self.assertEqual(len(data["formset_forms"]), 2)
self.assertEqual(data["formset_forms"][0]["model"], "RawHtmlTestItem")
self.assertEqual(data["formset_forms"][0]["contentitem_id"], item1.pk)
self.assertEqual(data["formset_forms"][1]["contentitem_id"], item2.pk)
self.assertTrue("AA" in data["formset_forms"][0]["html"])
def _get_request(self, url, data=None):
request = self.factory.post(url, data=data or {})
request.csrf_processing_done = True
request.session = {}
request.user = self.admin_user
MessageMiddleware().process_request(request)
return request
def _post_add(self, modeladmin, formdata):
opts = modeladmin.opts
url = reverse(f"admin:{opts.app_label}_{opts.model_name}_add")
# Build request
# Add properties which middleware would typically do
request = self._get_request(url, data=formdata)
# Make a direct call, circumvents login page.
return modeladmin.add_view(request)
def _get_management_form_data(self, modeladmin):
"""
Return the formdata that the management forms need.
"""
opts = modeladmin.opts
url = reverse(f"admin:{opts.app_label}_{opts.model_name}_add")
request = self.factory.get(url)
request.user = self.admin_user
inline_instances = modeladmin.get_inline_instances(request)
forms = []
for inline_instance in inline_instances:
FormSet = inline_instance.get_formset(request)
formset = FormSet(instance=modeladmin.model())
forms.append(formset.management_form)
# In a primitive way, get the form fields.
# This is not exactly the same as a POST, since that runs through clean()
formdata = {}
for form in forms:
for boundfield in form:
formdata[boundfield.html_name] = boundfield.value()
return formdata
def _render_response(self, response):
if hasattr(response, "render"):
# TemplateResponse
return "== Context ==\n{}\n\n== Response ==\n{}".format(
pformat(response.context_data),
response.render().content)
else:
return response.content
# #Uncomment this to test issue #1:
#from fuzziverse.user_admin import user_admin_site
from django.contrib.admin import AdminSite
user_admin_site = AdminSite()
from nested_inline.admin import NestedStackedInline, NestedModelAdmin
from fuzziverse import models
class FileUploadInline(NestedStackedInline):
model = models.InputTestCase
min_num = 0
extra = 1
class ReportInline(NestedStackedInline):
model = models.Report
min_num = 0
extra = 1
class FuzzingAttemptInline(NestedStackedInline):
model = models.FuzzingAttempt
min_num = 0
extra = 1
inlines = [FileUploadInline]
readonly_fields = ['created']
class ApplicationAdmin(NestedModelAdmin):
inlines = [ReportInline, FuzzingAttemptInline]
search_fields = ['name']
user_admin_site.register(models.Application, ApplicationAdmin)
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)
self.rf = RequestFactory()
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)
from django.conf.urls.defaults import patterns, url, include
from django.contrib.admin import AdminSite as DjangoAdminSite, ModelAdmin
from .models import get_active_models, RegisteredModel
urlpatterns = patterns("admin_customizer.views",
url('^$', 'admin_index', name="admin_customizer-admin_index"),
)
active_models, checksum = get_active_models()
list_display_through = RegisteredModel._meta.get_field_by_name(
"list_display")[0].rel.through._meta.db_table
for slug, models in active_models.items():
admin_site = DjangoAdminSite(name=slug, app_name=slug)
for registered_model in models:
ct = registered_model.model
DynamicModelAdmin = type(
str("%(site_name)s_%(app_label)s_%(model_name)s_Admin" % dict(
site_name = slug,
app_label = ct.app_label,
model_name = ct.model,
)),
(ModelAdmin,),
dict(
list_display = [
field.name for field in registered_model.list_display.extra(
order_by = [list_display_through+'.id']
)
],
list_filter = [
from django.contrib.auth.models import User, Group from django.contrib.auth.admin import UserAdmin, GroupAdmin from django.contrib.admin import AdminSite root_site = AdminSite(name='root') root_site.register(User, UserAdmin) root_site.register(Group, GroupAdmin) tenant_site = AdminSite(name='tenant') tenant_site.register(User, UserAdmin) tenant_site.register(Group, GroupAdmin)
def setUp(self):
super().setUp()
self.site = AdminSite()
from django.contrib import admin
from django.contrib.admin import AdminSite
from django.contrib.auth.admin import UserAdmin
from django.contrib.auth.models import User, Group, Permission
from trancheur.models import Bond, MoneyMarket, Residual, Trade
from cashflow.models import Cashflow
class AdminSite(AdminSite):
site_title = 'FlexInvest Admin'
index_title = 'Home'
branding = "admin/logo.png"
admin_site = AdminSite()
def deactivate_account(modeladmin, request, queryset):
queryset.update(is_active=False)
deactivate_account.short_description = "Deactivate selected users"
def activate_account(modeladmin, request, queryset):
queryset.update(is_active=True)
activate_account.short_description = "Activate selected users"
class UserAdmin(UserAdmin):
list_display = ('username', 'is_active', 'last_login', 'date_joined',)
list_filter = ('groups', 'is_active',)
date_hierarchy = 'date_joined'
actions = [deactivate_account, activate_account]
admin_site.register(User, UserAdmin)
admin_site.register(Permission)
