def test_account(self):
"""
Test account creation.
"""
# Verification not required - test an active user is created.
data = self.account_data("test1")
settings.ACCOUNTS_VERIFICATION_REQUIRED = False
response = self.client.post(reverse("signup"), data, follow=True)
self.assertEqual(response.status_code, 200)
users = User.objects.filter(email=data["email"], is_active=True)
self.assertEqual(len(users), 1)
# Verification required - test an inactive user is created,
settings.ACCOUNTS_VERIFICATION_REQUIRED = True
data = self.account_data("test2")
emails = len(mail.outbox)
response = self.client.post(reverse("signup"), data, follow=True)
self.assertEqual(response.status_code, 200)
users = User.objects.filter(email=data["email"], is_active=False)
self.assertEqual(len(users), 1)
# Test the verification email.
self.assertEqual(len(mail.outbox), emails + 1)
self.assertEqual(len(mail.outbox[0].to), 1)
self.assertEqual(mail.outbox[0].to[0], data["email"])
# Test the verification link.
new_user = users[0]
verification_url = reverse(
"signup_verify",
kwargs={
"uidb36": int_to_base36(new_user.id),
"token": default_token_generator.make_token(new_user),
})
response = self.client.get(verification_url, follow=True)
self.assertEqual(response.status_code, 200)
users = User.objects.filter(email=data["email"], is_active=True)
self.assertEqual(len(users), 1)
def test_account(self):
"""
Test account creation.
"""
# Verification not required - test an active user is created.
data = self.account_data("test1")
settings.ACCOUNTS_VERIFICATION_REQUIRED = False
response = self.client.post(reverse("signup"), data, follow=True)
self.assertEqual(response.status_code, 200)
users = User.objects.filter(email=data["email"], is_active=True)
self.assertEqual(len(users), 1)
# Verification required - test an inactive user is created,
settings.ACCOUNTS_VERIFICATION_REQUIRED = True
data = self.account_data("test2")
emails = len(mail.outbox)
response = self.client.post(reverse("signup"), data, follow=True)
self.assertEqual(response.status_code, 200)
users = User.objects.filter(email=data["email"], is_active=False)
self.assertEqual(len(users), 1)
# Test the verification email.
self.assertEqual(len(mail.outbox), emails + 1)
self.assertEqual(len(mail.outbox[0].to), 1)
self.assertEqual(mail.outbox[0].to[0], data["email"])
# Test the verification link.
new_user = users[0]
verification_url = reverse("signup_verify", kwargs={
"uidb36": int_to_base36(new_user.id),
"token": default_token_generator.make_token(new_user),
})
response = self.client.get(verification_url, follow=True)
self.assertEqual(response.status_code, 200)
users = User.objects.filter(email=data["email"], is_active=True)
self.assertEqual(len(users), 1)
def test_blog_views(self):
"""
Basic status code test for blog views.
"""
response = self.client.get(reverse("blog_post_list"))
self.assertEqual(response.status_code, 200)
response = self.client.get(reverse("blog_post_feed", args=("rss",)))
self.assertEqual(response.status_code, 200)
response = self.client.get(reverse("blog_post_feed", args=("atom",)))
self.assertEqual(response.status_code, 200)
blog_post = BlogPost.objects.create(title="Post", user=self._user, status=CONTENT_STATUS_PUBLISHED)
response = self.client.get(blog_post.get_absolute_url())
self.assertEqual(response.status_code, 200)
def test_blog_views(self):
"""
Basic status code test for blog views.
"""
response = self.client.get(reverse("blog_post_list"))
self.assertEqual(response.status_code, 200)
response = self.client.get(reverse("blog_post_feed", args=("rss", )))
self.assertEqual(response.status_code, 200)
response = self.client.get(reverse("blog_post_feed", args=("atom", )))
self.assertEqual(response.status_code, 200)
blog_post = BlogPost.objects.create(title="Post",
user=self._user,
status=CONTENT_STATUS_PUBLISHED)
response = self.client.get(blog_post.get_absolute_url())
self.assertEqual(response.status_code, 200)
def get_absolute_url(self):
"""
URL for a page - for ``Link`` page types, simply return its
slug since these don't have an actual URL pattern. Also handle
the special case of the homepage being a page object.
"""
slug = self.slug
if self.content_model == "link":
# Ensure the URL is absolute.
slug = urljoin('/', slug)
return slug
if slug == "/":
return reverse("home")
else:
return reverse("page", kwargs={"slug": slug})
def get_absolute_url(self):
"""
URL for a page - for ``Link`` page types, simply return its
slug since these don't have an actual URL pattern. Also handle
the special case of the homepage being a page object.
"""
slug = self.slug
if self.content_model == "link":
# Ensure the URL is absolute.
slug = urljoin('/', slug)
return slug
if slug == "/":
return reverse("home")
else:
return reverse("page", kwargs={"slug": slug})
def get_absolute_url(self):
"""
URLs for blog posts can either be just their slug, or prefixed
with a portion of the post's publish date, controlled by the
setting ``BLOG_URLS_DATE_FORMAT``, which can contain the value
``year``, ``month``, or ``day``. Each of these maps to the name
of the corresponding urlpattern, and if defined, we loop through
each of these and build up the kwargs for the correct urlpattern.
The order which we loop through them is important, since the
order goes from least granualr (just year) to most granular
(year/month/day).
"""
url_name = "blog_post_detail"
kwargs = {"slug": self.slug}
date_parts = ("year", "month", "day")
if settings.BLOG_URLS_DATE_FORMAT in date_parts:
url_name = "blog_post_detail_%s" % settings.BLOG_URLS_DATE_FORMAT
for date_part in date_parts:
date_value = str(getattr(self.publish_date, date_part))
if len(date_value) == 1:
date_value = "0%s" % date_value
kwargs[date_part] = date_value
if date_part == settings.BLOG_URLS_DATE_FORMAT:
break
return reverse(url_name, kwargs=kwargs)
def old_account_redirect(request, url_suffix):
"""
Catches and redirects any unmatched account URLs to their
correct version (account/ to accounts/) as per #934.
The URL is constructed manually, handling slashes as appropriate.
"""
if url_suffix is None:
correct_url = reverse("account_redirect")
else:
correct_url = "{account_url}{middle_slash}{suffix}{slash}".format(
account_url=reverse("account_redirect"),
middle_slash="/" if not settings.APPEND_SLASH else "",
suffix=url_suffix,
slash="/" if settings.APPEND_SLASH else "")
next = next_url(request)
if next:
correct_url += "?next=%s" % next
return redirect(correct_url)
def overridden(self):
"""
Returns ``True`` if the page's slug has an explicitly defined
urlpattern and is therefore considered to be overridden.
"""
from mezzanine.pages.views import page
page_url = reverse("page", kwargs={"slug": self.slug})
resolved_view = resolve(page_url)[0]
return resolved_view != page
def overridden(self):
"""
Returns ``True`` if the page's slug has an explicitly defined
urlpattern and is therefore considered to be overridden.
"""
from mezzanine.pages.views import page
page_url = reverse("page", kwargs={"slug": self.slug})
resolved_view = resolve(page_url)[0]
return resolved_view != page
def test_login_protected_blog(self):
"""
Test the blog is login protected if its page has login_required
set to True.
"""
slug = settings.BLOG_SLUG or "/"
RichTextPage.objects.create(title="blog", slug=slug, login_required=True)
response = self.client.get(reverse("blog_post_list"), follow=True)
self.assertEqual(response.status_code, 200)
self.assertTrue(len(response.redirect_chain) > 0)
redirect_path = urlparse(response.redirect_chain[0][0]).path
self.assertEqual(redirect_path, settings.LOGIN_URL)
def test_device_specific_template(self):
"""
Test that an alternate template is rendered when a mobile
device is used.
"""
ua = settings.DEVICE_USER_AGENTS[0][1][0]
kwargs = {"slug": "device-test"}
url = reverse("page", kwargs=kwargs)
kwargs["status"] = CONTENT_STATUS_PUBLISHED
RichTextPage.objects.get_or_create(**kwargs)
default = self.client.get(url)
mobile = self.client.get(url, HTTP_USER_AGENT=ua)
self.assertNotEqual(default.template_name[0], mobile.template_name[0])
def test_device_specific_template(self):
"""
Test that an alternate template is rendered when a mobile
device is used.
"""
ua = settings.DEVICE_USER_AGENTS[0][1][0]
kwargs = {"slug": "device-test"}
url = reverse("page", kwargs=kwargs)
kwargs["status"] = CONTENT_STATUS_PUBLISHED
RichTextPage.objects.get_or_create(**kwargs)
default = self.client.get(url)
mobile = self.client.get(url, HTTP_USER_AGENT=ua)
self.assertNotEqual(default.template_name[0], mobile.template_name[0])
def try_url(url_name):
"""
Mimics Django's ``url`` template tag but fails silently. Used for
url names in admin templates as these won't resolve when admin
tests are running.
"""
from warnings import warn
warn("try_url is deprecated, use the url tag with the 'as' arg instead.")
try:
url = reverse(url_name)
except NoReverseMatch:
return ""
return url
def comments_for(context, obj):
"""
Provides a generic context variable name for the object that
comments are being rendered for.
"""
form = ThreadedCommentForm(context["request"], obj)
try:
context["posted_comment_form"]
except KeyError:
context["posted_comment_form"] = form
context["unposted_comment_form"] = form
context["comment_url"] = reverse("comment")
context["object_for_comments"] = obj
return context
def comments_for(context, obj):
"""
Provides a generic context variable name for the object that
comments are being rendered for.
"""
form = ThreadedCommentForm(context["request"], obj)
try:
context["posted_comment_form"]
except KeyError:
context["posted_comment_form"] = form
context["unposted_comment_form"] = form
context["comment_url"] = reverse("comment")
context["object_for_comments"] = obj
return context
def test_login_protected_blog(self):
"""
Test the blog is login protected if its page has login_required
set to True.
"""
slug = settings.BLOG_SLUG or "/"
RichTextPage.objects.create(title="blog",
slug=slug,
login_required=True)
response = self.client.get(reverse("blog_post_list"), follow=True)
self.assertEqual(response.status_code, 200)
self.assertTrue(len(response.redirect_chain) > 0)
redirect_path = urlparse(response.redirect_chain[0][0]).path
self.assertEqual(redirect_path, settings.LOGIN_URL)
def translate_url(context, language):
"""
Translates the current URL for the given language code, eg:
{% translate_url de %}
"""
try:
request = context["request"]
except KeyError:
return ""
view = resolve(request.path)
current_language = translation.get_language()
translation.activate(language)
try:
url_name = (view.url_name if not view.namespace
else '%s:%s' % (view.namespace, view.url_name))
url = reverse(url_name, args=view.args, kwargs=view.kwargs)
except NoReverseMatch:
url_name = "admin:" + view.url_name
url = reverse(url_name, args=view.args, kwargs=view.kwargs)
translation.activate(current_language)
if context['request'].META["QUERY_STRING"]:
url += "?" + context['request'].META["QUERY_STRING"]
return url
def test_admin_sites_dropdown(self):
"""
Ensures the site selection dropdown appears in the admin.
"""
self.client.login(username=self._username, password=self._password)
response = self.client.get("/admin/", follow=True)
set_site_url = reverse("set_site")
# Set site URL shouldn't appear without multiple sites.
self.assertNotContains(response, set_site_url)
site1 = Site.objects.create(domain="test-site-dropdown1.com", name="test-site-dropdown1.com")
site2 = Site.objects.create(domain="test-site-dropdown2.com", name="test-site-dropdown2.com")
response = self.client.get("/admin/", follow=True)
self.assertContains(response, set_site_url)
self.assertContains(response, site1.name)
self.assertContains(response, site2.name)
site1.delete()
site2.delete()
def initial_validation(request, prefix):
"""
Returns the related model instance and post data to use in the
comment/rating views below.
Both comments and ratings have a ``prefix_ACCOUNT_REQUIRED``
setting. If this is ``True`` and the user is unauthenticated, we
store their post data in their session, and redirect to login with
the view's url (also defined by the prefix arg) as the ``next``
param. We can then check the session data once they log in,
and complete the action authenticated.
On successful post, we pass the related object and post data back,
which may have come from the session, for each of the comments and
ratings view functions to deal with as needed.
"""
post_data = request.POST
settings.use_editable()
login_required_setting_name = prefix.upper() + "S_ACCOUNT_REQUIRED"
posted_session_key = "unauthenticated_" + prefix
redirect_url = ""
if getattr(settings, login_required_setting_name, False):
if not request.user.is_authenticated():
request.session[posted_session_key] = request.POST
error(
request,
_("You must be logged in. Please log in or "
"sign up to complete this action."))
redirect_url = "%s?next=%s" % (settings.LOGIN_URL, reverse(prefix))
elif posted_session_key in request.session:
post_data = request.session.pop(posted_session_key)
if not redirect_url:
try:
model = get_model(*post_data.get("content_type", "").split(".", 1))
if model:
obj = model.objects.get(id=post_data.get("object_pk", None))
except (TypeError, ObjectDoesNotExist):
redirect_url = "/"
if redirect_url:
if request.is_ajax():
return HttpResponse(dumps({"location": redirect_url}))
else:
return redirect(redirect_url)
return obj, post_data
def test_admin_sites_dropdown(self):
"""
Ensures the site selection dropdown appears in the admin.
"""
self.client.login(username=self._username, password=self._password)
response = self.client.get('/admin/', follow=True)
set_site_url = reverse("set_site")
# Set site URL shouldn't appear without multiple sites.
self.assertNotContains(response, set_site_url)
site1 = Site.objects.create(domain="test-site-dropdown1.com",
name="test-site-dropdown1.com")
site2 = Site.objects.create(domain="test-site-dropdown2.com",
name="test-site-dropdown2.com")
response = self.client.get('/admin/', follow=True)
self.assertContains(response, set_site_url)
self.assertContains(response, site1.name)
self.assertContains(response, site2.name)
site1.delete()
site2.delete()
def initial_validation(request, prefix):
"""
Returns the related model instance and post data to use in the
comment/rating views below.
Both comments and ratings have a ``prefix_ACCOUNT_REQUIRED``
setting. If this is ``True`` and the user is unauthenticated, we
store their post data in their session, and redirect to login with
the view's url (also defined by the prefix arg) as the ``next``
param. We can then check the session data once they log in,
and complete the action authenticated.
On successful post, we pass the related object and post data back,
which may have come from the session, for each of the comments and
ratings view functions to deal with as needed.
"""
post_data = request.POST
settings.use_editable()
login_required_setting_name = prefix.upper() + "S_ACCOUNT_REQUIRED"
posted_session_key = "unauthenticated_" + prefix
redirect_url = ""
if getattr(settings, login_required_setting_name, False):
if not request.user.is_authenticated():
request.session[posted_session_key] = request.POST
error(request, _("You must be logged in. Please log in or "
"sign up to complete this action."))
redirect_url = "%s?next=%s" % (settings.LOGIN_URL, reverse(prefix))
elif posted_session_key in request.session:
post_data = request.session.pop(posted_session_key)
if not redirect_url:
try:
model = get_model(*post_data.get("content_type", "").split(".", 1))
if model:
obj = model.objects.get(id=post_data.get("object_pk", None))
except (TypeError, ObjectDoesNotExist):
redirect_url = "/"
if redirect_url:
if request.is_ajax():
return HttpResponse(dumps({"location": redirect_url}))
else:
return redirect(redirect_url)
return obj, post_data
def test_rating(self):
"""
Test that ratings can be posted and avarage/count are calculated.
"""
blog_post = BlogPost.objects.create(title="Ratings", user=self._user,
status=CONTENT_STATUS_PUBLISHED)
data = RatingForm(None, blog_post).initial
for value in settings.RATINGS_RANGE:
data["value"] = value
response = self.client.post(reverse("rating"), data=data)
# Django doesn't seem to support unicode cookie keys correctly on
# Python 2. See https://code.djangoproject.com/ticket/19802
response.delete_cookie(native_str("mezzanine-rating"))
blog_post = BlogPost.objects.get(id=blog_post.id)
count = len(settings.RATINGS_RANGE)
_sum = sum(settings.RATINGS_RANGE)
average = _sum / count
self.assertEqual(blog_post.rating_count, count)
self.assertEqual(blog_post.rating_sum, _sum)
self.assertEqual(blog_post.rating_average, average)
def process_view(self, request, view_func, view_args, view_kwargs):
login_type = request.POST.get("mezzanine_login_interface")
if login_type and not request.user.is_authenticated():
response = view_func(request, *view_args, **view_kwargs)
if request.user.is_authenticated():
if login_type == "admin":
next = request.get_full_path()
if (request.user.username == DEFAULT_USERNAME and
request.user.check_password(DEFAULT_PASSWORD)):
error(request, mark_safe(_(
"Your account is using the default password, "
"please <a href='%s'>change it</a> immediately.")
% reverse("user_change_password",
args=(request.user.id,))))
else:
next = next_url(request) or "/"
return HttpResponseRedirect(next)
else:
return response
return None
def test_rating(self):
"""
Test that ratings can be posted and avarage/count are calculated.
"""
blog_post = BlogPost.objects.create(title="Ratings",
user=self._user,
status=CONTENT_STATUS_PUBLISHED)
data = RatingForm(None, blog_post).initial
for value in settings.RATINGS_RANGE:
data["value"] = value
response = self.client.post(reverse("rating"), data=data)
# Django doesn't seem to support unicode cookie keys correctly on
# Python 2. See https://code.djangoproject.com/ticket/19802
response.delete_cookie(native_str("mezzanine-rating"))
blog_post = BlogPost.objects.get(id=blog_post.id)
count = len(settings.RATINGS_RANGE)
_sum = sum(settings.RATINGS_RANGE)
average = _sum / count
self.assertEqual(blog_post.rating_count, count)
self.assertEqual(blog_post.rating_sum, _sum)
self.assertEqual(blog_post.rating_average, average)
def process_view(self, request, view_func, view_args, view_kwargs):
login_type = request.POST.get("mezzanine_login_interface")
if login_type and not request.user.is_authenticated():
response = view_func(request, *view_args, **view_kwargs)
if request.user.is_authenticated():
if login_type == "admin":
next = request.get_full_path()
if (request.user.username == DEFAULT_USERNAME
and request.user.check_password(DEFAULT_PASSWORD)):
error(
request,
mark_safe(
_("Your account is using the default password, "
"please <a href='%s'>change it</a> immediately."
) % reverse("user_change_password",
args=(request.user.id, ))))
else:
next = next_url(request) or "/"
return HttpResponseRedirect(next)
else:
return response
return None
def set_site(request):
"""
Put the selected site ID into the session - posted to from
the "Select site" drop-down in the header of the admin. The
site ID is then used in favour of the current request's
domain in ``mezzanine.core.managers.CurrentSiteManager``.
"""
site_id = int(request.GET["site_id"])
if not request.user.is_superuser:
try:
SitePermission.objects.get(user=request.user, sites=site_id)
except SitePermission.DoesNotExist:
raise PermissionDenied
request.session["site_id"] = site_id
admin_url = reverse("admin:index")
next = next_url(request) or admin_url
# Don't redirect to a change view for an object that won't exist
# on the selected site - go to its list view instead.
if next.startswith(admin_url):
parts = next.split("/")
if len(parts) > 4 and parts[4].isdigit():
next = "/".join(parts[:4])
return redirect(next)
def set_site(request):
"""
Put the selected site ID into the session - posted to from
the "Select site" drop-down in the header of the admin. The
site ID is then used in favour of the current request's
domain in ``mezzanine.core.managers.CurrentSiteManager``.
"""
site_id = int(request.GET["site_id"])
if not request.user.is_superuser:
try:
SitePermission.objects.get(user=request.user, sites=site_id)
except SitePermission.DoesNotExist:
raise PermissionDenied
request.session["site_id"] = site_id
admin_url = reverse("admin:index")
next = next_url(request) or admin_url
# Don't redirect to a change view for an object that won't exist
# on the selected site - go to its list view instead.
if next.startswith(admin_url):
parts = next.split("/")
if len(parts) > 4 and parts[4].isdigit():
next = "/".join(parts[:4])
return redirect(next)
def send_verification_mail(request, user, verification_type):
"""
Sends an email with a verification link to users when
``ACCOUNTS_VERIFICATION_REQUIRED`` is ```True`` and they're signing
up, or when they reset a lost password.
The ``verification_type`` arg is both the name of the urlpattern for
the verification link, as well as the names of the email templates
to use.
"""
verify_url = reverse(verification_type, kwargs={
"uidb36": int_to_base36(user.id),
"token": default_token_generator.make_token(user),
}) + "?next=" + (next_url(request) or "/")
context = {
"request": request,
"user": user,
"verify_url": verify_url,
}
subject_template_name = "email/%s_subject.txt" % verification_type
subject = subject_template(subject_template_name, context)
send_mail_template(subject, "email/%s" % verification_type,
settings.DEFAULT_FROM_EMAIL, user.email,
context=context)
def test_blog_post_list_can_use_any_page_type(self):
"""Test that the blog post list can use any Page type."""
slug = settings.BLOG_SLUG or "/"
Page.objects.create(title="blog", slug=slug)
response = self.client.get(reverse("blog_post_list"))
self.assertEqual(response.status_code, 200)
def _static_proxy(self, querystring):
self.client.login(username=self._username, password=self._password)
proxy_url = '%s?%s' % (reverse('static_proxy'), querystring)
response = self.client.get(proxy_url)
self.assertEqual(response.status_code, 200)
def item_author_link(self, item):
username = item.user.username
return reverse("blog_post_list_author", kwargs={"username": username})
def link(self):
return reverse("blog_post_list")
def rows(self, csv=False):
"""
Returns each row based on the selected criteria.
"""
# Store the index of each field against its ID for building each
# entry row with columns in the correct order. Also store the IDs of
# fields with a type of FileField or Date-like for special handling of
# their values.
field_indexes = {}
file_field_ids = []
date_field_ids = []
for field in self.form_fields:
if self.cleaned_data["field_%s_export" % field.id]:
field_indexes[field.id] = len(field_indexes)
if field.is_a(fields.FILE):
file_field_ids.append(field.id)
elif field.is_a(*fields.DATES):
date_field_ids.append(field.id)
num_columns = len(field_indexes)
include_entry_time = self.cleaned_data["field_0_export"]
if include_entry_time:
num_columns += 1
# Get the field entries for the given form and filter by entry_time
# if specified.
field_entries = FieldEntry.objects.filter(entry__form=self.form
).order_by("-entry__id").select_related("entry")
if self.cleaned_data["field_0_filter"] == FILTER_CHOICE_BETWEEN:
time_from = self.cleaned_data["field_0_from"]
time_to = self.cleaned_data["field_0_to"]
if time_from and time_to:
field_entries = field_entries.filter(
entry__entry_time__range=(time_from, time_to))
# Loop through each field value ordered by entry, building up each
# entry as a row. Use the ``valid_row`` flag for marking a row as
# invalid if it fails one of the filtering criteria specified.
current_entry = None
current_row = None
valid_row = True
for field_entry in field_entries:
if field_entry.entry_id != current_entry:
# New entry, write out the current row and start a new one.
if valid_row and current_row is not None:
if not csv:
current_row.insert(0, current_entry)
yield current_row
current_entry = field_entry.entry_id
current_row = [""] * num_columns
valid_row = True
if include_entry_time:
current_row[-1] = field_entry.entry.entry_time
field_value = field_entry.value or ""
# Check for filter.
field_id = field_entry.field_id
filter_type = self.cleaned_data.get("field_%s_filter" % field_id)
filter_args = None
if filter_type:
if filter_type == FILTER_CHOICE_BETWEEN:
f, t = "field_%s_from" % field_id, "field_%s_to" % field_id
filter_args = [self.cleaned_data[f], self.cleaned_data[t]]
else:
field_name = "field_%s_contains" % field_id
filter_args = self.cleaned_data[field_name]
if filter_args:
filter_args = [filter_args]
if filter_args:
# Convert dates before checking filter.
if field_id in date_field_ids:
y, m, d = field_value.split(" ")[0].split("-")
dte = date(int(y), int(m), int(d))
filter_args.append(dte)
else:
filter_args.append(field_value)
filter_func = FILTER_FUNCS[filter_type]
if not filter_func(*filter_args):
valid_row = False
# Create download URL for file fields.
if field_entry.value and field_id in file_field_ids:
url = reverse("admin:form_file", args=(field_entry.id,))
field_value = self.request.build_absolute_uri(url)
if not csv:
parts = (field_value, split(field_entry.value)[1])
field_value = mark_safe("<a href=\"%s\">%s</a>" % parts)
# Only use values for fields that were selected.
try:
current_row[field_indexes[field_id]] = field_value
except KeyError:
pass
# Output the final row.
if valid_row and current_row is not None:
if not csv:
current_row.insert(0, current_entry)
yield current_row
def test_blog_post_list_can_use_any_page_type(self):
"""Test that the blog post list can use any Page type."""
slug = settings.BLOG_SLUG or "/"
Page.objects.create(title="blog", slug=slug)
response = self.client.get(reverse("blog_post_list"))
self.assertEqual(response.status_code, 200)
def admin_app_list(request):
"""
Adopted from ``django.contrib.admin.sites.AdminSite.index``.
Returns a list of lists of models grouped and ordered according to
``mezzanine.conf.ADMIN_MENU_ORDER``. Called from the
``admin_dropdown_menu`` template tag as well as the ``app_list``
dashboard widget.
"""
app_dict = {}
# Model or view --> (group index, group title, item index, item title).
menu_order = {}
for (group_index, group) in enumerate(settings.ADMIN_MENU_ORDER):
group_title, items = group
group_title = group_title.title()
for (item_index, item) in enumerate(items):
if isinstance(item, (tuple, list)):
item_title, item = item
else:
item_title = None
menu_order[item] = (group_index, group_title,
item_index, item_title)
# Add all registered models, using group and title from menu order.
for (model, model_admin) in admin.site._registry.items():
opts = model._meta
in_menu = not hasattr(model_admin, "in_menu") or model_admin.in_menu()
if in_menu and request.user.has_module_perms(opts.app_label):
perms = model_admin.get_model_perms(request)
admin_url_name = ""
if perms["change"]:
admin_url_name = "changelist"
change_url = admin_url(model, admin_url_name)
else:
change_url = None
if perms["add"]:
admin_url_name = "add"
add_url = admin_url(model, admin_url_name)
else:
add_url = None
if admin_url_name:
model_label = "%s.%s" % (opts.app_label, opts.object_name)
try:
app_index, app_title, model_index, model_title = \
menu_order[model_label]
except KeyError:
app_index = None
app_title = opts.app_label.title()
model_index = None
model_title = None
else:
del menu_order[model_label]
if not model_title:
model_title = capfirst(model._meta.verbose_name_plural)
if app_title not in app_dict:
app_dict[app_title] = {
"index": app_index,
"name": app_title,
"models": [],
}
app_dict[app_title]["models"].append({
"index": model_index,
"perms": model_admin.get_model_perms(request),
"name": model_title,
"admin_url": change_url,
"add_url": add_url
})
# Menu may also contain view or url pattern names given as (title, name).
for (item_url, item) in menu_order.items():
app_index, app_title, item_index, item_title = item
try:
item_url = reverse(item_url)
except NoReverseMatch:
continue
if app_title not in app_dict:
app_dict[app_title] = {
"index": app_index,
"name": app_title,
"models": [],
}
app_dict[app_title]["models"].append({
"index": item_index,
"perms": {"custom": True},
"name": item_title,
"admin_url": item_url,
})
app_list = list(app_dict.values())
sort = lambda x: (x["index"] if x["index"] is not None else 999, x["name"])
for app in app_list:
app["models"].sort(key=sort)
app_list.sort(key=sort)
return app_list
def _static_proxy(self, querystring):
self.client.login(username=self._username, password=self._password)
proxy_url = "%s?%s" % (reverse("static_proxy"), querystring)
response = self.client.get(proxy_url)
self.assertEqual(response.status_code, 200)
