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_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 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 register_admin_models(admin_site: AdminSite):
"""Registers dynamically created preferences models for Admin interface.
:param admin_site: AdminSite object.
"""
global __MODELS_REGISTRY
prefs = get_prefs()
for app_label, prefs_items in prefs.items():
model_class = get_pref_model_class(app_label, prefs_items,
get_app_prefs)
if model_class is not None:
__MODELS_REGISTRY[app_label] = model_class
admin_site.register(model_class,
get_pref_model_admin_class(prefs_items))
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)
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 test_admin_registration(self):
"""
Test how the registration works
"""
class Model2Admin(PolymorphicParentModelAdmin):
base_model = Model2A
list_filter = (PolymorphicChildModelFilter,)
child_models = (Model2B, Model2C, Model2D)
class Model2ChildAdmin(PolymorphicChildModelAdmin):
base_model = Model2A
base_fieldsets = (
("Base fields", {
'fields': ('field1',)
}),
)
admin_site = AdminSite()
admin_site.register(Model2A, Model2Admin)
admin_site.register(Model2B, Model2ChildAdmin)
admin_site.register(Model2C, Model2ChildAdmin)
admin_site.register(Model2D, Model2ChildAdmin)
from django.contrib.auth.admin import UserAdmin
from django.contrib.admin import AdminSite, ModelAdmin
from django.db import models
from .models import *
from .modeladmin import *
##Admin Site
class AdminSite(AdminSite):
site_header = 'Ibérica'
#login_template ='admin/login.html'
#login_form = AuthForm
admin = AdminSite(name='Ibérica')
admin.register(Usuario.Usuario, UsuarioAdmin)
admin.register(Usuario.Persona)
admin.register(Programa.Disciplina)
admin.register(Programa.SubDisciplina)
admin.register(Programa.Nivel)
admin.register(Programa.Programa)
admin.register(Programa.Comprobante, ComprobanteAdmin)
admin.register(Programa.Inscripcion)
admin.register(Programa.Semana)
admin.register(Programa.Paquete)
admin.register(Programa.Grupo, GrupoModelAdmin)
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)
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
# #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)
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)
def formfield_for_foreignkey(self, db_field, request, **kwargs):
# Tell Django to populate ForeignKey widgets using a query
# on the 'other' database.
return super().formfield_for_foreignkey(db_field,
request,
using=self.using,
**kwargs)
def formfield_for_manytomany(self, db_field, request, **kwargs):
# Tell Django to populate ManyToMany widgets using a query
# on the 'other' database.
return super().formfield_for_manytomany(db_field,
request,
using=self.using,
**kwargs)
employee_admin_site = AdminSite(name='employees')
employee_admin_site.register(MyUser, MultiDBModelAdmin)
employee_admin_site.register(Group, MultiDBModelAdmin)
employee_admin_site.register(Position, MultiDBModelAdmin)
employee_admin_site.register(EmployeePosition, MultiDBModelAdmin)
employee_admin_site.register(EmployeeProfile, MultiDBModelAdmin)
employee_admin_site.register(Notification, MultiDBModelAdmin)
employee_admin_site.register(Post, MultiDBModelAdmin)
employee_admin_site.register(Topic, MultiDBModelAdmin)
employee_admin_site.register(Message, MultiDBModelAdmin)
from django.contrib.admin import AdminSite from .models import Agent, Order # регистрируем модели в админке admin_site = AdminSite(name='admin') admin_site.register([Agent, Order])
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)
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)
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))
from django.contrib.admin import AdminSite
from django.contrib.auth.models import Group
from django.contrib.auth.admin import GroupAdmin
from .users import MyCustomEmailUserAdmin
from ..users.models import MyCustomEmailUser
from .cliente import ClienteAdmin
from ..cliente.models import Cliente
from ..conductor.models import Conductor
class AdminSite(AdminSite):
"""
Instance of a django admin for private schema
"""
site_header = 'Admin tenant'
admin_site = AdminSite(name='admin')
admin_site.register(MyCustomEmailUser, MyCustomEmailUserAdmin)
admin_site.register(Cliente, ClienteAdmin)
admin_site.register(Group, GroupAdmin)
admin_site.register(Conductor)
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().setUpClass()
cls.admin_user = User.objects.create_superuser("admin",
"*****@*****.**",
password="******")
def setUp(self):
super().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([path("tmp-admin/", self.admin_site.urls)]))
def get_admin_instance(self, model):
try:
return self.admin_site._registry[model]
except KeyError:
raise ValueError(f"Model not registered with admin: {model}")
@classmethod
def tearDownClass(cls):
super().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,
f"Form errors in calling {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(lambda r: HttpResponse("OK?")).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 {}:\n{}".format(
request_url, errors.as_text()),
)
self.assertTrue(
"/login/?next=" not in response["Location"],
f"Received login response for {request_url}",
)
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.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)
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()))
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 = [
field.name for field in registered_model.list_filter.all()
],
search_fields = [
field.name for field in registered_model.search_fields.all()
],
raw_id_fields = [
field.name for field in registered_model.raw_id_fields.all()
],
)
)
admin_site.register(
ct.model_class(),
DynamicModelAdmin
)
urlpatterns.append(url('^%s/' % slug, include(admin_site.urls)))
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 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)
admin_site.register(Group)
admin_site.register(Bond)
admin_site.register(MoneyMarket)
admin_site.register(Residual)
admin_site.register(Trade)
admin_site.register(Cashflow)
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]
# Making a POST call with an unused ID should add the recipe.
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>',
})
response = self._post_add(modeladmin, formdata)
self.assertEquals(
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(opts.app_label,
opts.module_name))
# 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(opts.app_label,
opts.module_name))
request = self.factory.get(url)
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 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
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)
