def test_pagecontenttypefilter_queryset(self):
# Ensures that the queryset returned by filtering is correct.
request = self._build_request()
# Add some pages with different content types.
with search.update_index():
content_type = ContentType.objects.get_for_model(PageContent)
content_type_2 = ContentType.objects.get_for_model(PageContentWithFields)
self._make_page('Food', content_type)
self._make_page('Barred', content_type)
self._make_page('Bazooka', content_type_2)
# Test with no filters. Should be the same as Page.objects.all().
filterer = PageContentTypeFilter(request, {}, Page, self.page_admin)
queryset = filterer.queryset(request, Page.objects.all())
self.assertEqual(queryset.count(), Page.objects.all().count())
# Test with a content type filter. It should return a subset of the
# pages.
content_type_id = ContentType.objects.get_for_model(PageContent).id
parameters = {'page_type': content_type_id}
filterer = PageContentTypeFilter(request, parameters, Page, self.page_admin)
queryset = filterer.queryset(request, Page.objects.all())
self.assertEqual(
queryset.count(),
Page.objects.filter(
content_type_id=content_type_id
).count()
)
# The above will not be sufficient - we need to ensure that it is not
# the same as the unfiltered queryset, not merely that the filtered
# length is correct.
self.assertNotEqual(queryset.count(), Page.objects.all().count())
def setUp(self):
self.site = AdminSite()
self.article_admin = ArticleAdmin(Article, self.site)
self.factory = RequestFactory()
self.request = self.factory.get('/')
with search.update_index():
self.date = now()
self.date_str = '/{}/{}/{}'.format(
self.date.strftime('%Y'),
self.date.strftime('%b').lower(),
self.date.strftime('%d').lstrip('0'),
)
content_type = ContentType.objects.get_for_model(NewsFeed)
self.page = Page.objects.create(
title='News Feed',
slug='news',
content_type=content_type,
)
self.feed = NewsFeed.objects.create(page=self.page, )
self.category = Category.objects.create(slug='foo')
self.article = Article.objects.create(
news_feed=self.feed,
title='Foo',
slug='foo',
date=self.date,
)
def test_page_get_absolute_url(self):
with search.update_index():
Page.objects.all().delete()
content_type = ContentType.objects.get_for_model(TestPageContent)
new_page = Page(
content_type=content_type,
parent=None,
left=None,
right=None,
)
self.assertIsNone(new_page.cached_url)
new_page.save()
self.assertEqual(new_page.cached_url, '/')
TestPageContent.objects.create(
page=new_page,
)
self.assertEqual(new_page.get_absolute_url(), '/')
self.assertEqual(new_page.get_absolute_url(True), '/')
new_page = Page.objects.get(pk=new_page.pk)
self.assertEqual(new_page.cached_url, '/')
self.assertEqual(new_page.get_absolute_url(), '/')
def test_pagecontenttypefilter_queryset(self):
# Ensures that the queryset returned by filtering is correct.
request = self._build_request()
# Add some pages with different content types.
with search.update_index():
content_type = ContentType.objects.get_for_model(TestPageContent)
content_type_2 = ContentType.objects.get_for_model(
TestPageContentWithFields)
self._make_page('Food', content_type)
self._make_page('Barred', content_type)
self._make_page('Bazooka', content_type_2)
# Test with no filters. Should be the same as Page.objects.all().
filterer = PageContentTypeFilter(request, {}, Page, self.page_admin)
queryset = filterer.queryset(request, Page.objects.all())
self.assertEqual(queryset.count(), Page.objects.all().count())
# Test with a content type filter. It should return a subset of the
# pages.
content_type_id = ContentType.objects.get_for_model(TestPageContent).id
parameters = {'page_type': content_type_id}
filterer = PageContentTypeFilter(request, parameters, Page,
self.page_admin)
queryset = filterer.queryset(request, Page.objects.all())
self.assertEqual(
queryset.count(),
Page.objects.filter(content_type_id=content_type_id).count())
# The above will not be sufficient - we need to ensure that it is not
# the same as the unfiltered queryset, not merely that the filtered
# length is correct.
self.assertNotEqual(queryset.count(), Page.objects.all().count())
def test_publicationmiddleware_preview(self):
with search.update_index():
page_obj = Page.objects.create(
title='Foo',
content_type=ContentType.objects.get_for_model(TestContentBase),
is_online=False,
)
content_obj = TestContentBase.objects.create(page=page_obj)
middleware = [
'django.contrib.sessions.middleware.SessionMiddleware',
'django.contrib.auth.middleware.AuthenticationMiddleware',
'cms.middleware.PublicationMiddleware',
'cms.apps.pages.middleware.PageMiddleware',
]
with self.settings(MIDDLEWARE=middleware):
request = self.client.get(page_obj.get_absolute_url())
self.assertEqual(request.status_code, 404)
# Ensure preview mode (without a valid token) fails for
# non-authenticated users.
request = self.client.get(page_obj.get_absolute_url() + '?preview=1')
self.assertEqual(request.status_code, 404)
request = self.client.get(page_obj.get_preview_url())
self.assertEqual(request.status_code, 200)
def test_pageadmin_sitemap_json_view(self):
request = self._build_request()
response = self.page_admin.sitemap_json_view(request)
sitemap = '{"createHomepageUrl": "/admin/pages/page/add/?from=sitemap", "addUrl": "/admin/pages/page/add/?from=sitemap&parent=__id__", "canAdd": true, "changeUrl": "/admin/pages/page/__id__/change/?from=sitemap", "entries": [{"isOnline": true, "canDelete": true, "title": "Homepage", "canChange": true, "id": ' + str(self.homepage.pk) + ', "children": []}], "deleteUrl": "/admin/pages/page/__id__/delete/?from=sitemap", "moveUrl": "/admin/pages/page/move-page/"}'
self.assertDictEqual(json.loads(response.content.decode()), json.loads(sitemap))
self.assertEqual(response['Content-Type'], "application/json; charset=utf-8")
# Add a child page.
with search.update_index():
content_type = ContentType.objects.get_for_model(PageContentWithFields)
self.content_page = Page.objects.create(
title="Content page",
slug='content_page',
parent=self.homepage,
content_type=content_type,
)
PageContentWithFields.objects.create(
page=self.content_page,
)
request.pages.homepage = Page.objects.get(slug='homepage')
response = self.page_admin.sitemap_json_view(request)
sitemap = '{"createHomepageUrl": "/admin/pages/page/add/?from=sitemap", "addUrl": "/admin/pages/page/add/?from=sitemap&parent=__id__", "canAdd": true, "changeUrl": "/admin/pages/page/__id__/change/?from=sitemap", "entries": [{"isOnline": true, "canDelete": true, "title": "Homepage", "canChange": true, "id": ' + str(self.homepage.pk) + ', "children": [{"isOnline": true, "canDelete": true, "title": "Content page", "canChange": true, "id": ' + str(self.content_page.pk) + ', "children": []}]}], "deleteUrl": "/admin/pages/page/__id__/delete/?from=sitemap", "moveUrl": "/admin/pages/page/move-page/"}'
self.assertDictEqual(json.loads(response.content.decode()), json.loads(sitemap))
self.assertEqual(response['Content-Type'], "application/json; charset=utf-8")
request.pages.homepage = None
response = self.page_admin.sitemap_json_view(request)
sitemap = '{"createHomepageUrl": "/admin/pages/page/add/?from=sitemap", "addUrl": "/admin/pages/page/add/?from=sitemap&parent=__id__", "canAdd": true, "changeUrl": "/admin/pages/page/__id__/change/?from=sitemap", "entries": [], "deleteUrl": "/admin/pages/page/__id__/delete/?from=sitemap", "moveUrl": "/admin/pages/page/move-page/"}'
self.assertDictEqual(json.loads(response.content.decode()), json.loads(sitemap))
self.assertEqual(response['Content-Type'], "application/json; charset=utf-8")
def test_get_related_objects_admin_urls_from_model_inline_with_image(self):
with search.update_index():
self.test_page_model = Page.objects.create(
title='Test page',
content_type=ContentType.objects.get_for_model(
TestContentBase),
)
self.test_content_base = TestContentBase.objects.create(
page=self.test_page_model, )
test_model_1a_inline = TestModelOneInline.objects.create(
parent=self.test_model_1a, image=self.test_file)
self.clear_image_references(
[self.test_model_1a, self.test_model_1b, self.test_model_2a])
expected_outcome = [
{
'title':
str(test_model_1a_inline),
'model_name':
test_model_1a_inline._meta.verbose_name,
'admin_url':
reverse(
f'admin:{self.test_model_1a._meta.app_label}_{self.test_model_1a._meta.model_name}_change',
args=[self.test_model_1a.pk]),
},
]
self.assertEqual(get_related_objects_admin_urls(self.test_file),
expected_outcome)
def setUp(self):
structure = {
'title':
'Homepage',
'children': [{
'title':
'Tree 1 - Page 1',
'children': [{
'title': 'Tree 1 - Page 2'
}, {
'title': 'Tree 1 - Page 3'
}]
}, {
'title': 'Tree 2 - Page 1'
}, {
'title':
'Tree 3 - Page 1',
'children': [{
'title':
'Tree 3 - Page 2',
'children': [{
'title': 'Tree 3 - Page 4'
}, {
'title': 'Tree 3 - Page 5'
}]
}, {
'title': 'Tree 3 - Page 3'
}]
}]
}
content_type = ContentType.objects.get_for_model(TestPageContent)
self.page_ids = {}
self.pages = {}
def _add_page(page, parent=None):
slug = page['title'].replace(' ', '_').replace('-', '_')
page_obj = Page.objects.create(
title=page['title'],
slug=slug,
content_type=content_type,
parent=parent,
)
TestPageContent.objects.create(page=page_obj, )
self.page_ids[slug] = page_obj.pk
if page.get('children', None):
for child in page['children']:
_add_page(child, page_obj)
with search.update_index():
_add_page(structure)
self._rebuild_page_dict()
def testNestedUpdateInSkipContext(self):
with watson.skip_index_update():
self.test21.title = "baar"
self.test21.save()
with watson.update_index():
self.test11.title = "fooo"
self.test11.save()
# We should get "fooo", but not "baar"
self.assertEqual(watson.search("fooo").count(), 1)
self.assertEqual(watson.search("baar").count(), 0)
def testNestedUpdateInSkipContext(self):
with watson.skip_index_update():
self.test21.title = "baar"
self.test21.save()
with watson.update_index():
self.test11.title = "fooo"
self.test11.save()
# We should get "fooo", but not "baar"
self.assertEqual(watson.search("fooo").count(), 1)
self.assertEqual(watson.search("baar").count(), 0)
def testSearchIndexUpdateAbandonedOnError(self):
try:
with watson.update_index():
self.test11.title = "fooo"
self.test11.save()
raise Exception("Foo")
except:
pass
# Test a search that should get not model.
self.assertEqual(watson.search("fooo").count(), 0)
def _create(cls, model_class, *args, **kwargs):
with search.update_index():
email = super(FullEmailFactory, cls)._create(model_class, *args, **kwargs)
body = BodyFactory(data="This mail body is searchable")
part = PartListFactory(body=body)
HeaderFactory(part=part, name="From")
HeaderFactory(part=part, name="Subject")
HeaderFactory(part=part, name="Content-Type", data="text/plain; charset=\"ascii\"")
return email
def testSearchIndexUpdateAbandonedOnError(self):
try:
with watson.update_index():
self.test11.title = "fooo"
self.test11.save()
raise Exception("Foo")
except:
pass
# Test a search that should get not model.
self.assertEqual(watson.search("fooo").count(), 0)
def _create(cls, model_class, *args, **kwargs):
with search.update_index():
email = super(FullEmailFactory, cls)._create(model_class, *args, **kwargs)
body = BodyFactory(data="This mail body is searchable")
part = PartListFactory(email=email, body=body)
HeaderFactory(part=part, name="From")
HeaderFactory(part=part, name="Subject")
HeaderFactory(part=part, name="Content-Type", data="text/plain; charset=\"ascii\"")
return email
def setUp(self):
self.factory = RequestFactory()
self.request = self.factory.get('/')
File.objects.all().delete()
# A valid GIF.
self.name_1 = '{}-{}.gif'.format(now().strftime('%Y-%m-%d_%H-%M-%S'),
random.randint(0, six.MAXSIZE))
base64_string = b'R0lGODlhAQABAAAAACH5BAEKAAEALAAAAAABAAEAAAICTAEAOw=='
self.obj_1 = File.objects.create(title="Foo",
file=SimpleUploadedFile(
self.name_1,
base64.b64decode(base64_string),
content_type="image/gif"))
with search.update_index():
content_type = ContentType.objects.get_for_model(
TestTemplatetagPage)
self.homepage = Page.objects.create(
title="Homepage",
slug='homepage',
content_type=content_type,
)
TestTemplatetagPage.objects.create(page=self.homepage, )
self.section = Page.objects.create(parent=self.homepage,
title="Section",
slug='section',
content_type=content_type,
hide_from_anonymous=True)
TestTemplatetagPage.objects.create(page=self.section, )
self.subsection = Page.objects.create(
parent=self.section,
title="Subsection",
slug='subsection',
content_type=content_type,
)
TestTemplatetagPage.objects.create(page=self.subsection, )
self.subsubsection = Page.objects.create(
parent=self.subsection,
title="Subsubsection",
slug='subsubsection',
content_type=content_type,
)
TestTemplatetagPage.objects.create(page=self.subsubsection, )
def setUp(self):
with search.update_index():
content_type = ContentType.objects.get_for_model(
TestPageContentWithSections)
self.homepage = Page.objects.create(
title='Homepage',
slug='homepage',
content_type=content_type,
)
TestPageContentWithSections.objects.create(page=self.homepage, )
def setUp(self):
with search.update_index():
content_type = ContentType.objects.get_for_model(TestPageContentWithSections)
self.homepage = Page.objects.create(
title="Homepage",
slug='homepage',
content_type=content_type,
)
TestPageContentWithSections.objects.create(
page=self.homepage,
)
def duplicate_for_country_group(request, *args, **kwargs):
# Get the current page
original_page = get_object_or_404(Page, pk=kwargs.get('page', None))
original_content = original_page.content
if request.method == 'POST':
with update_index():
page = deepcopy(original_page)
page.pk = None
page.is_content_object = True
page.owner = original_page
page.country_group = CountryGroup.objects.get(
pk=request.POST.get('country_group'))
page.save()
content = deepcopy(original_content)
content.pk = None
content.page = page
content.save()
for link in dir(original_page):
if link.endswith('_set') and getattr(
original_page, link
).__class__.__name__ == 'RelatedManager' and link not in [
'child_set', 'owner_set', 'link_to_page'
]:
objects = getattr(original_page, link).all()
for page_object in objects:
new_object = deepcopy(page_object)
new_object.pk = None
new_object.page = page
new_object.save()
return redirect('/admin/pages/page/{}'.format(page.pk))
country_groups = CountryGroup.objects.all()
if not country_groups:
messages.add_message(
request, messages.ERROR,
'You need to add at least one country group first before you can add a copy of this page'
)
return redirect('/admin/pages/page/{}'.format(original_page.pk))
context = dict(original_page=original_page,
country_groups=country_groups)
return TemplateResponse(request,
'admin/pages/page/language_duplicate.html',
context)
def setUp(self):
self.site = AdminSite()
self.page_admin = PageAdmin(Page, self.site)
with search.update_index():
content_type = ContentType.objects.get_for_model(TestPageContent)
self.homepage = Page.objects.create(
title="Homepage",
slug='homepage',
content_type=content_type,
)
TestPageContent.objects.create(page=self.homepage, )
def duplicate_object(original_object, changes=None):
with update_index():
copied_object = deepcopy(original_object)
copied_object.pk = None
if callable(changes):
copied_object = changes(copied_object, original_object)
AdminClass = admin.site._registry[original_object.__class__]
for content_cls, admin_cls in AdminClass.inlines:
pass
copied_object.save()
def setUp(self):
# Note: as this is the only page in the database, it's absolute URL
# will simply be '/'
with search.update_index():
content_type = ContentType.objects.get_for_model(Faqs)
self.page = Page.objects.create(
content_type=content_type,
title='Foo',
slug='foo',
)
self.faq_page = Faqs.objects.create(
page=self.page,
)
def test_page_save__create_with_sides(self):
with search.update_index():
content_type = ContentType.objects.get_for_model(TestPageContent)
# Create a page with a manual left and right defined.
page_obj = Page.objects.create(
title='Foo',
content_type=content_type,
parent=self.pages['Tree_1___Page_1'],
left=7,
right=8,
)
TestPageContent.objects.create(page=page_obj, )
self.assertEqual(page_obj.title, 'Foo')
def setUp(self):
self.site = AdminSite()
self.page_admin = PageAdmin(Page, self.site)
with search.update_index():
content_type = ContentType.objects.get_for_model(PageContent)
self.homepage = Page.objects.create(
title="Homepage",
slug='homepage',
content_type=content_type,
)
PageContent.objects.create(
page=self.homepage,
)
def test_alternate_page_version(self):
_generate_pages(self)
# Create a country group.
group = CountryGroup.objects.create(
name='Foo',
)
group2 = CountryGroup.objects.create(
name='Bar',
)
# Create a country.
Country.objects.create(
code='GB',
group=group,
)
country2 = Country.objects.create(
code='FR',
group=group2,
default=False,
)
# Create an alternate version of the page with the country.
with search.update_index():
content_type = ContentType.objects.get_for_model(TestMiddlewarePage)
alternate_page = Page.objects.create(
is_content_object=True,
owner=self.homepage,
country_group=group2,
left=self.homepage.left,
right=self.homepage.right,
content_type=content_type,
)
TestMiddlewarePage.objects.create(
page=alternate_page,
)
self.request = self.factory.get('/')
self.request.country = country2
self.page_manager = RequestPageManager(self.request)
alternate_check = self.page_manager.alternate_page_version(self.homepage)
self.assertEqual(alternate_check, alternate_page)
def test_pageadmin_sitemap_json_view(self):
request = self._build_request()
response = self.page_admin.sitemap_json_view(request)
sitemap = '{"createHomepageUrl": "/admin/pages/page/add/?from=sitemap", "addUrl": "/admin/pages/page/add/?from=sitemap&parent=__id__", "canAdd": true, "changeUrl": "/admin/pages/page/__id__/change/?from=sitemap", "entries": [{"isOnline": true, "canDelete": true, "title": "Homepage", "canChange": true, "id": ' + str(
self.homepage.pk
) + ', "children": []}], "deleteUrl": "/admin/pages/page/__id__/delete/?from=sitemap", "moveUrl": "/admin/pages/page/move-page/"}'
self.assertDictEqual(json.loads(response.content.decode()),
json.loads(sitemap))
self.assertEqual(response['Content-Type'],
"application/json; charset=utf-8")
# Add a child page.
with search.update_index():
content_type = ContentType.objects.get_for_model(
TestPageContentWithFields)
self.content_page = Page.objects.create(
title="Content page",
slug='content_page',
parent=self.homepage,
content_type=content_type,
)
TestPageContentWithFields.objects.create(page=self.content_page, )
request.pages.homepage = Page.objects.get(slug='homepage')
response = self.page_admin.sitemap_json_view(request)
sitemap = '{"createHomepageUrl": "/admin/pages/page/add/?from=sitemap", "addUrl": "/admin/pages/page/add/?from=sitemap&parent=__id__", "canAdd": true, "changeUrl": "/admin/pages/page/__id__/change/?from=sitemap", "entries": [{"isOnline": true, "canDelete": true, "title": "Homepage", "canChange": true, "id": ' + str(
self.homepage.pk
) + ', "children": [{"isOnline": true, "canDelete": true, "title": "Content page", "canChange": true, "id": ' + str(
self.content_page.pk
) + ', "children": []}]}], "deleteUrl": "/admin/pages/page/__id__/delete/?from=sitemap", "moveUrl": "/admin/pages/page/move-page/"}'
self.assertDictEqual(json.loads(response.content.decode()),
json.loads(sitemap))
self.assertEqual(response['Content-Type'],
"application/json; charset=utf-8")
request.pages.homepage = None
response = self.page_admin.sitemap_json_view(request)
sitemap = '{"createHomepageUrl": "/admin/pages/page/add/?from=sitemap", "addUrl": "/admin/pages/page/add/?from=sitemap&parent=__id__", "canAdd": true, "changeUrl": "/admin/pages/page/__id__/change/?from=sitemap", "entries": [], "deleteUrl": "/admin/pages/page/__id__/delete/?from=sitemap", "moveUrl": "/admin/pages/page/move-page/"}'
self.assertDictEqual(json.loads(response.content.decode()),
json.loads(sitemap))
self.assertEqual(response['Content-Type'],
"application/json; charset=utf-8")
def test_alternate_page_version(self):
_generate_pages(self)
# Create a country group.
group = CountryGroup.objects.create(
name='Foo',
)
group2 = CountryGroup.objects.create(
name='Bar',
)
# Create a country.
Country.objects.create(
code='GB',
group=group,
)
country2 = Country.objects.create(
code='FR',
group=group2,
default=False,
)
# Create an alternate version of the page with the country.
with search.update_index():
content_type = ContentType.objects.get_for_model(TestMiddlewarePage)
alternate_page = Page.objects.create(
owner=self.homepage,
country_group=group2,
left=self.homepage.left,
right=self.homepage.right,
content_type=content_type,
)
TestMiddlewarePage.objects.create(
page=alternate_page,
)
self.request = self.factory.get('/')
self.request.country = country2
self.page_manager = RequestPageManager(self.request)
alternate_check = self.page_manager.alternate_page_version(self.homepage)
self.assertEqual(alternate_check, alternate_page)
def setUp(self):
call_command('installwatson')
with search.update_index():
content_type = ContentType.objects.get_for_model(TestPageContent)
self.homepage = Page.objects.create(
title="Homepage",
slug='homepage',
content_type=content_type,
)
TestPageContent.objects.create(
page=self.homepage,
)
self.section = Page.objects.create(
parent=self.homepage,
title="Section",
content_type=content_type,
)
TestPageContent.objects.create(
page=self.section,
)
self.subsection = Page.objects.create(
parent=self.section,
title="Subsection",
content_type=content_type,
)
TestPageContent.objects.create(
page=self.subsection,
)
self.subsubsection = Page.objects.create(
parent=self.subsection,
title="Subsubsection",
content_type=content_type,
)
TestPageContent.objects.create(
page=self.subsubsection,
)
def test_page_save__create_with_sides(self):
with search.update_index():
content_type = ContentType.objects.get_for_model(TestPageContent)
# Create a page with a manual left and right defined.
page_obj = Page.objects.create(
title='Foo',
content_type=content_type,
parent=self.pages['Tree_1___Page_1'],
left=7,
right=8,
)
TestPageContent.objects.create(
page=page_obj,
)
self.assertEqual(page_obj.title, 'Foo')
def _create_objects(self):
with search.update_index():
self.date = now()
content_type = ContentType.objects.get_for_model(NewsFeed)
self.page = Page.objects.create(
title='News Feed',
content_type=content_type,
)
self.feed = NewsFeed.objects.create(
page=self.page,
)
self.category = Category.objects.create(
slug='foo'
)
self.article = Article.objects.create(
news_feed=self.feed,
title='Foo',
slug='foo',
# The seconds subtraction is because of time-rounding
# in the base publication manager.
date=self.date - timedelta(seconds=61),
)
self.article.categories.add(self.category)
self.article_2 = Article.objects.create(
news_feed=self.feed,
title='Foo 2',
slug='foo2',
date=self.date + timedelta(days=10)
)
self.article_3 = Article.objects.create(
news_feed=self.feed,
title='Foo 3',
slug='foo3',
status='approved',
date=self.date - timedelta(seconds=61),
)
def duplicate_page(original_page, page_changes=None):
'''
Takes a page and duplicates it as a child of the original's parent page.
Expects to be passed the original page and an optional function
'''
from .admin import page_admin
original_content = original_page.content
with update_index():
page = deepcopy(original_page)
page.pk = None
if callable(page_changes):
page = page_changes(page, original_page)
page.save()
content = deepcopy(original_content)
content.pk = None
content.page = page
content.save()
# This doesn't copy m2m relations on the copied inline
for content_cls, admin_cls in page_admin.content_inlines:
if not isinstance(content, content_cls):
continue
model_cls = admin_cls.model
fk = _get_foreign_key(Page, model_cls, fk_name=admin_cls.fk_name)
related_items = model_cls.objects.filter(**{
fk.name: original_page.pk
}).distinct().all()
for item in related_items:
new_object = deepcopy(item)
new_object.pk = None
setattr(new_object, fk.name, page)
new_object = overlay_obj(new_object,
item,
exclude=[fk.name, 'pk', 'id'],
commit=True)
new_object.save()
return page
def setUp(self):
# Note: as this is the only page in the database, it's absolute URL
# will simply be '/'
with search.update_index():
content_type = ContentType.objects.get_for_model(Careers)
self.page = Page.objects.create(
content_type=content_type,
title='Foo',
slug='foo',
)
self.job_page = Careers.objects.create(page=self.page, )
self.job = Career.objects.create(
page=self.job_page,
slug='foo-bar',
title='Tester',
)
def test_pagecontenttypefilter_lookups(self):
# Add some pages with different content types.
with search.update_index():
content_type = ContentType.objects.get_for_model(PageContent)
content_type_2 = ContentType.objects.get_for_model(PageContentWithFields)
self._make_page('John', content_type)
self._make_page('Paul', content_type)
self._make_page('Ringo', content_type_2)
request = self._build_request()
filterer = PageContentTypeFilter(request, {}, Page, self.page_admin)
lookups = filterer.lookups(request, Page.objects.all())
# Make sure that something has been returned...
self.assertTrue(len(lookups) > 0)
# ...and that they are of the correct content type.
self.assertTrue(len(lookups) == len(get_registered_content()))
# Ensure that the lookup names have been ordered.
lookup_names = [lookup[1] for lookup in lookups]
self.assertEqual(lookup_names, sorted(lookup_names))
def process_pun_form(request):
did_post = False
form = PunForm(request.POST)
if form.is_valid():
# this is working, redirect needs fixed. But currently users do not have profiles automatically
tags = re.split("; |, ", form.cleaned_data["tags"])
# converting text to tag objects
tag_objs = []
for tag in tags:
tag_objs.append(Tag.objects.get_or_create(text=tag)[0])
pun = Pun(text=form.cleaned_data["puntext"], owner=request.user, NSFW=form.cleaned_data["NSFW"], flagCount=0)
with watson.update_index():
try:
pun.save()
except IntegrityError:
return (PunForm(), did_post)
for tag in tag_objs:
pun.tags.add(tag)
# adding tag objects to the pun
did_post = True
return (form, did_post)
def test_page_get_absolute_url(self):
with search.update_index():
Page.objects.all().delete()
content_type = ContentType.objects.get_for_model(TestPageContent)
new_page = Page(
content_type=content_type,
parent=None,
left=None,
right=None,
)
new_page.save()
TestPageContent.objects.create(page=new_page, )
self.assertEqual(new_page.get_absolute_url(), '/')
new_page = Page.objects.get(pk=new_page.pk)
self.assertEqual(new_page.get_absolute_url(), '/')
def setUp(self):
# Note: as this is the only page in the database, it's absolute URL
# will simply be '/'
with search.update_index():
content_type = ContentType.objects.get_for_model(People)
self.page = Page.objects.create(
content_type=content_type,
title='Foo',
slug='foo',
)
self.person_page = People.objects.create(
page=self.page,
)
self.person = Person.objects.create(
page=self.person_page,
slug='foo-bar',
first_name='Foo',
last_name='Bar',
)
def test_pageadmin_get_all_children(self):
self.assertListEqual(self.page_admin.get_all_children(self.homepage), [])
# Add a child page.
with search.update_index():
content_type = ContentType.objects.get_for_model(PageContentWithFields)
self.content_page = Page.objects.create(
title="Content page",
slug='content_page',
parent=self.homepage,
content_type=content_type,
)
PageContentWithFields.objects.create(
page=self.content_page,
)
# The `children` attribute is cached as long as we use the original
# reference, so get the Page again.
self.homepage = Page.objects.get(slug='homepage')
self.assertListEqual(self.page_admin.get_all_children(self.homepage), [self.content_page])
def test_pagecontenttypefilter_lookups(self):
# Add some pages with different content types.
with search.update_index():
content_type = ContentType.objects.get_for_model(TestPageContent)
content_type_2 = ContentType.objects.get_for_model(
TestPageContentWithFields)
self._make_page('John', content_type)
self._make_page('Paul', content_type)
self._make_page('Ringo', content_type_2)
request = self._build_request()
filterer = PageContentTypeFilter(request, {}, Page, self.page_admin)
lookups = filterer.lookups(request, Page.objects.all())
# Make sure that something has been returned...
self.assertTrue(len(lookups) > 0)
# ...and that they are of the correct content type.
self.assertTrue(len(lookups) == len(get_registered_content()))
# Ensure that the lookup names have been ordered.
lookup_names = [lookup[1] for lookup in lookups]
self.assertEqual(lookup_names, sorted(lookup_names))
def setUp(self):
# Note: as this is the only page in the database, it's absolute URL
# will simply be '/'
with search.update_index():
content_type = ContentType.objects.get_for_model(Faqs)
self.page = Page.objects.create(
content_type=content_type,
title='Foo',
slug='foo',
)
self.faq_page = Faqs.objects.create(
page=self.page,
)
self.faq = Faq.objects.create(
page=self.faq_page,
question='What colour is the sky?',
answer='Blue',
slug='what-colour-sky'
)
def test_pageadmin_get_all_children(self):
self.assertListEqual(self.page_admin.get_all_children(self.homepage),
[])
# Add a child page.
with search.update_index():
content_type = ContentType.objects.get_for_model(
TestPageContentWithFields)
self.content_page = Page.objects.create(
title="Content page",
slug='content_page',
parent=self.homepage,
content_type=content_type,
)
TestPageContentWithFields.objects.create(page=self.content_page, )
# The `children` attribute is cached as long as we use the original
# reference, so get the Page again.
self.homepage = Page.objects.get(slug='homepage')
self.assertListEqual(self.page_admin.get_all_children(self.homepage),
[self.content_page])
def setUp(self):
call_command('installwatson')
with search.update_index():
content_type = ContentType.objects.get_for_model(TestPageContent)
self.homepage = Page.objects.create(
title='Homepage',
slug='homepage',
content_type=content_type,
)
TestPageContent.objects.create(page=self.homepage, )
self.section = Page.objects.create(
parent=self.homepage,
title='Section',
content_type=content_type,
)
TestPageContent.objects.create(page=self.section, )
self.subsection = Page.objects.create(
parent=self.section,
title='Subsection',
content_type=content_type,
)
TestPageContent.objects.create(page=self.subsection, )
self.subsubsection = Page.objects.create(
parent=self.subsection,
title='Subsubsection',
content_type=content_type,
)
TestPageContent.objects.create(page=self.subsubsection, )
def test_index_redirect(self):
with update_index():
page = Page.objects.create(
title='Homepage',
content_type=ContentType.objects.get_for_model(Link),
)
Link.objects.create(
page=page,
link_url='http://www.example.com/',
)
factory = RequestFactory()
request = factory.get('/')
class Object:
pass
setattr(request, 'pages', Object)
request.pages.current = page
view = index(request)
self.assertEqual(view.status_code, 302)
self.assertEqual(view['Location'], 'http://www.example.com/')
def test_index_redirect(self):
with update_index():
page = Page.objects.create(
title="Homepage",
content_type=ContentType.objects.get_for_model(Link),
)
Link.objects.create(
page=page,
link_url="http://www.example.com/",
)
factory = RequestFactory()
request = factory.get('/')
class Object(object):
pass
setattr(request, 'pages', Object)
request.pages.current = page
view = index(request)
self.assertEquals(view.status_code, 302)
self.assertEquals(view["Location"], "http://www.example.com/")
def test_pageadmin_get_form(self):
request = self._build_request(
page_type=ContentType.objects.get_for_model(PageContent).pk
)
form = self.page_admin.get_form(request)
keys = ['title', 'slug', 'parent', 'requires_authentication',
'publication_date', 'expiry_date', 'is_online', 'short_title',
'in_navigation', 'hide_from_anonymous', 'browser_title',
'meta_description', 'sitemap_priority', 'sitemap_changefreq',
'robots_index', 'robots_follow', 'robots_archive', 'og_title',
'og_description', 'og_image', 'twitter_card', 'twitter_title',
'twitter_description', 'twitter_image']
self.assertListEqual(list(form.base_fields.keys()), keys)
request = self._build_request()
# Test a page with a content model with fields.
with search.update_index():
content_type = ContentType.objects.get_for_model(PageContentWithFields)
self.content_page = Page.objects.create(
title="Content page",
slug='content_page',
parent=self.homepage,
content_type=content_type,
)
PageContentWithFields.objects.create(
page=self.content_page,
)
form = self.page_admin.get_form(request, obj=self.content_page)
keys = ['title', 'slug', 'parent', 'description', 'inline_model',
'requires_authentication', 'publication_date', 'expiry_date',
'is_online', 'short_title', 'in_navigation',
'hide_from_anonymous', 'browser_title', 'meta_description',
'sitemap_priority', 'sitemap_changefreq', 'robots_index',
'robots_follow', 'robots_archive', 'og_title', 'og_description',
'og_image', 'twitter_card', 'twitter_title',
'twitter_description', 'twitter_image']
self.assertListEqual(list(form.base_fields.keys()), keys)
self.assertIsInstance(form.base_fields['inline_model'].widget, RelatedFieldWidgetWrapper)
setattr(PageContentWithFields, 'filter_horizontal', ['inline_model'])
form = self.page_admin.get_form(request, obj=self.content_page)
self.assertIsInstance(form.base_fields['inline_model'].widget, FilteredSelectMultiple)
# No homepage.
self.assertEqual(form.base_fields['parent'].choices, [(self.homepage.pk, 'Homepage')])
request.pages.homepage = None
form = self.page_admin.get_form(request, obj=self.content_page)
self.assertListEqual(form.base_fields['parent'].choices, [('', '---------')])
self.content_page.is_content_object = True
form = self.page_admin.get_form(request, obj=self.content_page)
keys = ['title', 'description', 'inline_model',
'requires_authentication', 'publication_date', 'expiry_date',
'is_online', 'short_title', 'in_navigation',
'hide_from_anonymous', 'browser_title', 'meta_description',
'sitemap_priority', 'sitemap_changefreq', 'robots_index',
'robots_follow', 'robots_archive', 'og_title', 'og_description',
'og_image', 'twitter_card', 'twitter_title',
'twitter_description', 'twitter_image']
self.assertListEqual(list(form.base_fields.keys()), keys)
self.content_page.is_content_object = False
# Trigger the `content_cls.DoesNotExist` exception.
content_cls = self.page_admin.get_page_content_cls(request, self.content_page)
class Obj(object):
def __getattr__(self, name):
return getattr(self.page, name)
@property
def content(self):
raise content_cls.DoesNotExist
def __init__(self, page, *args, **kwargs):
self.page = page
obj = Obj(self.content_page)
self.page_admin.get_form(request, obj=obj)
def test_pageadmin_move_page_view(self):
request = self._build_request()
request.POST['page'] = self.homepage.pk
request.POST['direction'] = 'up'
response = self.page_admin.move_page_view(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b"Page could not be moved, as nothing to swap with.")
request.POST['direction'] = 'down'
response = self.page_admin.move_page_view(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content, b"Page could not be moved, as nothing to swap with.")
request.POST['direction'] = 'foo'
self.orig_stderr = sys.stderr
sys.stderr = open(os.devnull, 'w')
with self.assertRaises(ValueError):
self.page_admin.move_page_view(request)
sys.stderr = self.orig_stderr
# Add some child pages.
with search.update_index():
content_type = ContentType.objects.get_for_model(PageContent)
content_page_1 = Page.objects.create(
title="Foo",
slug='foo',
parent=self.homepage,
content_type=content_type,
)
PageContent.objects.create(
page=content_page_1,
)
# Create an alternative page.
alternative_page = Page.objects.create(
is_content_object=True,
owner=content_page_1,
left=content_page_1.left,
right=content_page_1.right,
content_type=content_type,
)
PageContent.objects.create(
page=alternative_page,
)
content_page_2 = Page.objects.create(
title="Bar",
slug='bar',
parent=self.homepage,
content_type=content_type,
)
PageContent.objects.create(
page=content_page_2,
)
self.homepage = Page.objects.get(pk=self.homepage.pk)
content_page_1 = Page.objects.get(pk=content_page_1.pk)
alternative_page = Page.objects.get(pk=alternative_page.pk)
content_page_2 = Page.objects.get(pk=content_page_2.pk)
self.assertEqual(self.homepage.left, 1)
self.assertEqual(self.homepage.right, 6)
self.assertEqual(content_page_1.left, 2)
self.assertEqual(content_page_1.right, 3)
self.assertEqual(alternative_page.left, 2)
self.assertEqual(alternative_page.right, 3)
self.assertEqual(content_page_2.left, 4)
self.assertEqual(content_page_2.right, 5)
# Move the page
request.POST['page'] = content_page_1.pk
request.POST['direction'] = 'down'
response = self.page_admin.move_page_view(request)
self.homepage = Page.objects.get(pk=self.homepage.pk)
content_page_1 = Page.objects.get(pk=content_page_1.pk)
alternative_page = Page.objects.get(pk=alternative_page.pk)
content_page_2 = Page.objects.get(pk=content_page_2.pk)
self.assertEqual(self.homepage.left, 1)
self.assertEqual(self.homepage.right, 6)
self.assertEqual(content_page_1.left, 4)
self.assertEqual(content_page_1.right, 5)
self.assertEqual(alternative_page.left, 4)
self.assertEqual(alternative_page.right, 5)
self.assertEqual(content_page_2.left, 2)
self.assertEqual(content_page_2.right, 3)
if six.PY2:
self.assertEqual(response.content, "Page #" + six.text_type(content_page_1.pk) + " was moved down.")
else:
self.assertEqual(response.content, bytes("Page #" + six.text_type(content_page_1.pk) + " was moved down.", 'utf-8'))
self.assertEqual(response.status_code, 200)
request.user.has_perm = lambda x: False
response = self.page_admin.move_page_view(request)
self.assertEqual(response.status_code, 403)
def testSearchIndexUpdateDeferredByContext(self):
with watson.update_index():
self.test11.title = "fooo"
self.test11.save()
self.assertEqual(watson.search("fooo").count(), 0)
self.assertEqual(watson.search("fooo").count(), 1)
def test_pageadmin_duplicate_for_country_group(self):
# Test without country groups first.
factory = RequestFactory()
request = factory.get('/?preview=a')
# Allow the messages framework to work.
setattr(request, 'session', 'session')
messages = FallbackStorage(request)
setattr(request, '_messages', messages)
response = self.page_admin.duplicate_for_country_group(request, page=self.homepage.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(response['Location'], '/admin/pages/page/' + str(self.homepage.pk))
self.assertEqual(len(request._messages._queued_messages), 1)
self.assertEqual(
request._messages._queued_messages[0].message,
"You need to add at least one country group first before you can add a copy of this page"
)
# Create country groups.
self.country_group = CountryGroup.objects.create(
name="United Kingdom"
)
self.country = Country.objects.create(
name="United Kingdom",
code="GB",
group=self.country_group
)
request = self._build_request()
response = self.page_admin.duplicate_for_country_group(request, page=self.homepage.pk)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context_data['original_page'], self.homepage)
request = self._build_request(method='POST')
request.POST = dict(
country_group=self.country_group.pk
)
response = self.page_admin.duplicate_for_country_group(request, page=self.homepage.pk)
self.assertEquals(Page.objects.filter(owner=self.homepage, is_content_object=True).count(), 1)
with search.update_index():
content_type_2 = ContentType.objects.get_for_model(
PageContentWithFields)
inline_page = Page.objects.create(
parent=self.homepage,
title="Inline page",
content_type=content_type_2,
)
PageContentWithFields.objects.create(
page=inline_page,
)
inline_model = InlineModel.objects.create(
page=inline_page,
)
request = self._build_request(method='POST')
request.POST = dict(
country_group=self.country_group.pk
)
response = self.page_admin.duplicate_for_country_group(request, page=inline_page.pk)
self.assertEquals(Page.objects.filter(owner=inline_page, is_content_object=True).count(), 1)
inline_page_clone = Page.objects.get(owner=inline_page, is_content_object=True)
self.assertEquals(inline_page_clone.inlinemodel_set.count(), 1)
def test_pageadmin_get_fieldsets(self):
request = self._build_request(
page_type=ContentType.objects.get_for_model(PageContent).pk
)
request2 = self._build_request(
page_type=ContentType.objects.get_for_model(PageContentWithFields).pk
)
with search.update_index():
content_type = ContentType.objects.get_for_model(PageContentWithFields)
self.content_page = Page.objects.create(
title="Content page",
slug='content_page',
parent=self.homepage,
content_type=content_type,
)
PageContentWithFields.objects.create(
page=self.content_page,
)
pagecontent_fields = [
(None, {
'fields': ('title', 'slug', 'parent')
}),
("Security", {
"fields": ("requires_authentication",),
}),
('Publication', {
'fields': ('publication_date', 'expiry_date', 'is_online'),
'classes': ('collapse',)
}),
('Navigation', {
'fields': ('short_title', 'in_navigation', "hide_from_anonymous",),
'classes': ('collapse',)
}),
('Search engine optimization', {
'fields': ('browser_title', 'meta_description', 'sitemap_priority', 'sitemap_changefreq', 'robots_index', 'robots_follow', 'robots_archive'),
'classes': ('collapse',)
}),
("Open Graph", {
"fields": ("og_title", "og_description", "og_image"),
"classes": ("collapse",)
}),
("Twitter card", {
"fields": ("twitter_card", "twitter_title", "twitter_description", "twitter_image"),
"classes": ("collapse",)
})
]
pagecontentwithfields_fields = [
(None, {
'fields': ('title', 'slug', 'parent')
}),
('Page content', {
'fields': ['description', 'inline_model']
}),
("Security", {
"fields": ("requires_authentication",),
}),
('Publication', {
'fields': ('publication_date', 'expiry_date', 'is_online'),
'classes': ('collapse',)
}),
('Navigation', {
'fields': ('short_title', 'in_navigation', "hide_from_anonymous",),
'classes': ('collapse',)
}),
('Search engine optimization', {
'fields': ('browser_title', 'meta_description', 'sitemap_priority', 'sitemap_changefreq', 'robots_index', 'robots_follow', 'robots_archive'),
'classes': ('collapse',)
}),
("Open Graph", {
"fields": ("og_title", "og_description", "og_image"),
"classes": ("collapse",)
}),
("Twitter card", {
"fields": ("twitter_card", "twitter_title", "twitter_description", "twitter_image"),
"classes": ("collapse",)
})
]
self.assertEqual(self.page_admin.get_fieldsets(request), pagecontent_fields)
self.assertEqual(self.page_admin.get_fieldsets(request2), pagecontentwithfields_fields)
def setUp(self):
structure = {
'title': 'Homepage',
'children': [
{
'title': 'Tree 1 - Page 1',
'children': [
{
'title': 'Tree 1 - Page 2'
},
{
'title': 'Tree 1 - Page 3'
}
]
},
{
'title': 'Tree 2 - Page 1'
},
{
'title': 'Tree 3 - Page 1',
'children': [
{
'title': 'Tree 3 - Page 2',
'children': [
{
'title': 'Tree 3 - Page 4'
},
{
'title': 'Tree 3 - Page 5'
}
]
},
{
'title': 'Tree 3 - Page 3'
}
]
}
]
}
content_type = ContentType.objects.get_for_model(TestPageContent)
self.page_ids = {}
self.pages = {}
def _add_page(page, parent=None):
slug = page['title'].replace(' ', '_').replace('-', '_')
page_obj = Page.objects.create(
title=page['title'],
slug=slug,
content_type=content_type,
parent=parent,
)
TestPageContent.objects.create(
page=page_obj,
)
self.page_ids[slug] = page_obj.pk
if page.get('children', None):
for child in page['children']:
_add_page(child, page_obj)
with search.update_index():
_add_page(structure)
self._rebuild_page_dict()
def test_process_response(self):
request = self.factory.get('/')
response = HttpResponse()
middleware = PageMiddleware()
self.assertEqual(middleware.process_response(request, response), response)
response = HttpResponseNotFound()
page_request = self.factory.get('')
request.pages = RequestPageManager(page_request)
self.assertEqual(middleware.process_response(request, response), response)
_generate_pages(self)
request = self.factory.get('/foo/')
request.pages = RequestPageManager(request)
processed_response = middleware.process_response(request, response)
self.assertEqual(processed_response.status_code, 200)
self.assertEqual(processed_response.template_name, (
'pages/testmiddlewarepage.html',
'pages/base.html',
'base.html'
))
request = self.factory.get('/')
request_foo = self.factory.get('/foo/')
request.pages = RequestPageManager(request_foo)
processed_response = middleware.process_response(request, response)
self.assertEqual(processed_response['Location'], '/foo/')
self.assertEqual(processed_response.status_code, 301)
self.assertEqual(processed_response.content, b'')
request = self.factory.get('/foobar/')
request.pages = RequestPageManager(request)
processed_response = middleware.process_response(request, response)
self.assertEqual(processed_response.status_code, 404)
with search.update_index():
content_type = ContentType.objects.get_for_model(TestMiddlewarePageURLs)
self.content_url = Page.objects.create(
title="Foo",
slug='urls',
parent=self.homepage,
content_type=content_type,
)
TestMiddlewarePageURLs.objects.create(
page=self.content_url,
)
request = self.factory.get('/urls/')
request.pages = RequestPageManager(request)
processed_response = middleware.process_response(request, HttpResponseNotFound())
self.assertEqual(processed_response.status_code, 200)
self.assertEqual(processed_response.content, b'Hello!')
with search.update_index():
content_type = ContentType.objects.get_for_model(TestMiddlewarePageURLs)
self.content_url = Page.objects.create(
title="Foo",
slug='raise404',
parent=self.homepage,
content_type=content_type,
)
TestMiddlewarePageURLs.objects.create(
page=self.content_url,
)
request = self.factory.get('/raise404/')
request.pages = RequestPageManager(request)
processed_response = middleware.process_response(request, HttpResponseNotFound())
self.assertEqual(processed_response.status_code, 404)
with self.settings(DEBUG=True):
request = self.factory.get('/raise404/')
request.pages = RequestPageManager(request)
processed_response = middleware.process_response(request, HttpResponseNotFound())
self.assertEqual(processed_response.status_code, 404)
request = self.factory.get('/auth/')
request.user = MockUser(authenticated=False)
request.pages = RequestPageManager(request)
processed_response = middleware.process_response(request, response)
self.assertEqual(processed_response['Location'], '/accounts/login/?next=/auth/')
self.assertEqual(processed_response.status_code, 302)
request = self.factory.get('/auth/')
request.user = MockUser(authenticated=True)
request.pages = RequestPageManager(request)
processed_response = middleware.process_response(request, response)
self.assertEqual(processed_response.status_code, 200)
request = self.factory.get('/media/')
request.pages = RequestPageManager(request)
processed_response = middleware.process_response(request, response)
self.assertEqual(processed_response, response)
request = self.factory.get('/foo/')
request.country = Country.objects.create(
code='GB',
)
request.pages = RequestPageManager(request)
processed_response = middleware.process_response(request, response)
self.assertEqual(processed_response.status_code, 200)
def _generate_pages(self):
with search.update_index():
content_type = ContentType.objects.get_for_model(TestMiddlewarePage)
self.homepage = Page.objects.create(
title="Homepage",
slug='homepage',
content_type=content_type,
)
TestMiddlewarePage.objects.create(
page=self.homepage,
)
self.page_1 = Page.objects.create(
title='Foo',
slug='foo',
parent=self.homepage,
content_type=content_type,
)
TestMiddlewarePage.objects.create(
page=self.page_1,
)
self.page_2 = Page.objects.create(
title='Bar',
slug='bar',
parent=self.page_1,
content_type=content_type,
)
TestMiddlewarePage.objects.create(
page=self.page_2,
)
self.country_group = CountryGroup.objects.create(
name="United States of America"
)
self.country = Country.objects.create(
name="United States of America",
code="US",
group=self.country_group
)
self.country_gb = Country.objects.create(
name="United Kingdom",
code="GB"
)
self.homepage_alt = Page.objects.create(
title="Homepage",
slug='homepage',
owner=self.homepage,
country_group=self.country_group,
content_type=content_type,
left=0,
right=0,
)
TestMiddlewarePage.objects.create(
page=self.homepage_alt,
)
self.auth_page = Page.objects.create(
title='Auth Page',
slug='auth',
parent=self.homepage,
content_type=content_type,
requires_authentication=True,
)
TestMiddlewarePage.objects.create(
page=self.auth_page,
)
def test_pageadmin_get_form(self):
request = self._build_request(
page_type=ContentType.objects.get_for_model(TestPageContent).pk)
form = self.page_admin.get_form(request)
keys = [
'title', 'slug', 'parent', 'requires_authentication',
'publication_date', 'expiry_date', 'is_online', 'short_title',
'in_navigation', 'hide_from_anonymous', 'browser_title',
'meta_description', 'sitemap_priority', 'sitemap_changefreq',
'robots_index', 'robots_follow', 'robots_archive', 'og_title',
'og_description', 'og_image', 'twitter_card', 'twitter_title',
'twitter_description', 'twitter_image'
]
self.assertListEqual(list(form.base_fields.keys()), keys)
request = self._build_request()
# Test a page with a content model with fields.
with search.update_index():
content_type = ContentType.objects.get_for_model(
TestPageContentWithFields)
self.content_page = Page.objects.create(
title="Content page",
slug='content_page',
parent=self.homepage,
content_type=content_type,
)
TestPageContentWithFields.objects.create(page=self.content_page, )
form = self.page_admin.get_form(request, obj=self.content_page)
keys = [
'title', 'slug', 'parent', 'description', 'inline_model',
'requires_authentication', 'publication_date', 'expiry_date',
'is_online', 'short_title', 'in_navigation', 'hide_from_anonymous',
'browser_title', 'meta_description', 'sitemap_priority',
'sitemap_changefreq', 'robots_index', 'robots_follow',
'robots_archive', 'og_title', 'og_description', 'og_image',
'twitter_card', 'twitter_title', 'twitter_description',
'twitter_image'
]
self.assertListEqual(list(form.base_fields.keys()), keys)
self.assertIsInstance(form.base_fields['inline_model'].widget,
RelatedFieldWidgetWrapper)
setattr(TestPageContentWithFields, 'filter_horizontal',
['inline_model'])
form = self.page_admin.get_form(request, obj=self.content_page)
self.assertIsInstance(form.base_fields['inline_model'].widget,
FilteredSelectMultiple)
# No homepage.
self.assertEqual(form.base_fields['parent'].choices,
[(self.homepage.pk, 'Homepage')])
request.pages.homepage = None
form = self.page_admin.get_form(request, obj=self.content_page)
self.assertListEqual(form.base_fields['parent'].choices,
[('', '---------')])
self.content_page.version_for = self.homepage
form = self.page_admin.get_form(request, obj=self.content_page)
keys = [
'title', 'description', 'inline_model', 'requires_authentication',
'publication_date', 'expiry_date', 'is_online', 'short_title',
'in_navigation', 'hide_from_anonymous', 'browser_title',
'meta_description', 'sitemap_priority', 'sitemap_changefreq',
'robots_index', 'robots_follow', 'robots_archive', 'og_title',
'og_description', 'og_image', 'twitter_card', 'twitter_title',
'twitter_description', 'twitter_image'
]
self.assertListEqual(list(form.base_fields.keys()), keys)
self.content_page.version_for = None
# Trigger the `content_cls.DoesNotExist` exception.
content_cls = self.page_admin.get_page_content_cls(
request, self.content_page)
class Obj:
def __getattr__(self, name):
return getattr(self.page, name)
@property
def content(self):
raise content_cls.DoesNotExist
def __init__(self, page, *args, **kwargs):
self.page = page
obj = Obj(self.content_page)
self.page_admin.get_form(request, obj=obj)
def testSearchIndexUpdateDeferredByContext(self):
with watson.update_index():
self.test11.title = "fooo"
self.test11.save()
self.assertEqual(watson.search("fooo").count(), 0)
self.assertEqual(watson.search("fooo").count(), 1)
def _generate_pages(self):
with search.update_index():
content_type = ContentType.objects.get_for_model(TestMiddlewarePage)
self.homepage = Page.objects.create(
title="Homepage",
slug='homepage',
content_type=content_type,
)
TestMiddlewarePage.objects.create(
page=self.homepage,
)
self.page_1 = Page.objects.create(
title='Foo',
slug='foo',
parent=self.homepage,
content_type=content_type,
)
TestMiddlewarePage.objects.create(
page=self.page_1,
)
self.page_2 = Page.objects.create(
title='Bar',
slug='bar',
parent=self.page_1,
content_type=content_type,
)
TestMiddlewarePage.objects.create(
page=self.page_2,
)
self.country_group = CountryGroup.objects.create(
name="United States of America"
)
self.country = Country.objects.create(
name="United States of America",
code="US",
group=self.country_group
)
self.country_gb = Country.objects.create(
name="United Kingdom",
code="GB"
)
self.homepage_alt = Page.objects.create(
title="Homepage",
slug='homepage',
owner=self.homepage,
is_content_object=True,
country_group=self.country_group,
content_type=content_type,
left=0,
right=0,
)
TestMiddlewarePage.objects.create(
page=self.homepage_alt,
)
self.auth_page = Page.objects.create(
title='Auth Page',
slug='auth',
parent=self.homepage,
content_type=content_type,
requires_authentication=True,
)
TestMiddlewarePage.objects.create(
page=self.auth_page,
)
def test_pageadmin_move_page_view(self):
request = self._build_request()
request.POST['page'] = self.homepage.pk
request.POST['direction'] = 'up'
response = self.page_admin.move_page_view(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content,
b"Page could not be moved, as nothing to swap with.")
request.POST['direction'] = 'down'
response = self.page_admin.move_page_view(request)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.content,
b"Page could not be moved, as nothing to swap with.")
request.POST['direction'] = 'foo'
self.orig_stderr = sys.stderr
sys.stderr = open(os.devnull, 'w')
with self.assertRaises(ValueError):
self.page_admin.move_page_view(request)
sys.stderr = self.orig_stderr
# Add some child pages.
with search.update_index():
content_type = ContentType.objects.get_for_model(TestPageContent)
content_page_1 = Page.objects.create(
title="Foo",
slug='foo',
parent=self.homepage,
content_type=content_type,
)
TestPageContent.objects.create(page=content_page_1, )
# Create an alternative page.
alternative_page = Page.objects.create(
owner=content_page_1,
left=content_page_1.left,
right=content_page_1.right,
content_type=content_type,
)
TestPageContent.objects.create(page=alternative_page, )
content_page_2 = Page.objects.create(
title="Bar",
slug='bar',
parent=self.homepage,
content_type=content_type,
)
TestPageContent.objects.create(page=content_page_2, )
self.homepage = Page.objects.get(pk=self.homepage.pk)
content_page_1 = Page.objects.get(pk=content_page_1.pk)
alternative_page = Page.objects.get(pk=alternative_page.pk)
content_page_2 = Page.objects.get(pk=content_page_2.pk)
self.assertEqual(self.homepage.left, 1)
self.assertEqual(self.homepage.right, 6)
self.assertEqual(content_page_1.left, 2)
self.assertEqual(content_page_1.right, 3)
self.assertEqual(alternative_page.left, 2)
self.assertEqual(alternative_page.right, 3)
self.assertEqual(content_page_2.left, 4)
self.assertEqual(content_page_2.right, 5)
# Move the page
request.POST['page'] = content_page_1.pk
request.POST['direction'] = 'down'
response = self.page_admin.move_page_view(request)
self.homepage = Page.objects.get(pk=self.homepage.pk)
content_page_1 = Page.objects.get(pk=content_page_1.pk)
alternative_page = Page.objects.get(pk=alternative_page.pk)
content_page_2 = Page.objects.get(pk=content_page_2.pk)
self.assertEqual(self.homepage.left, 1)
self.assertEqual(self.homepage.right, 6)
self.assertEqual(content_page_1.left, 4)
self.assertEqual(content_page_1.right, 5)
self.assertEqual(alternative_page.left, 4)
self.assertEqual(alternative_page.right, 5)
self.assertEqual(content_page_2.left, 2)
self.assertEqual(content_page_2.right, 3)
self.assertEqual(
response.content,
bytes("Page #" + str(content_page_1.pk) + " was moved down.",
'utf-8'))
self.assertEqual(response.status_code, 200)
request.user.has_perm = lambda x: False
response = self.page_admin.move_page_view(request)
self.assertEqual(response.status_code, 403)
def test_process_response(self):
request = self.factory.get('/')
response = HttpResponse()
middleware = PageMiddleware()
self.assertEqual(middleware.process_response(request, response), response)
response = HttpResponseNotFound()
page_request = self.factory.get('')
request.pages = RequestPageManager(page_request)
self.assertEqual(middleware.process_response(request, response), response)
_generate_pages(self)
request = self.factory.get('/foo/')
request.pages = RequestPageManager(request)
processed_response = middleware.process_response(request, response)
self.assertEqual(processed_response.status_code, 200)
self.assertEqual(processed_response.template_name, (
'pages/testmiddlewarepage.html',
'pages/base.html',
'base.html'
))
request = self.factory.get('/')
request_foo = self.factory.get('/foo/')
request.pages = RequestPageManager(request_foo)
processed_response = middleware.process_response(request, response)
self.assertEqual(processed_response['Location'], '/foo/')
self.assertEqual(processed_response.status_code, 301)
self.assertEqual(processed_response.content, b'')
request = self.factory.get('/foobar/')
request.pages = RequestPageManager(request)
processed_response = middleware.process_response(request, response)
self.assertEqual(processed_response.status_code, 404)
with search.update_index():
content_type = ContentType.objects.get_for_model(TestMiddlewarePageURLs)
self.content_url = Page.objects.create(
title="Foo",
slug='urls',
parent=self.homepage,
content_type=content_type,
)
TestMiddlewarePageURLs.objects.create(
page=self.content_url,
)
request = self.factory.get('/urls/')
request.pages = RequestPageManager(request)
processed_response = middleware.process_response(request, HttpResponseNotFound())
self.assertEqual(processed_response.status_code, 500)
with search.update_index():
content_type = ContentType.objects.get_for_model(TestMiddlewarePageURLs)
self.content_url = Page.objects.create(
title="Foo",
slug='raise404',
parent=self.homepage,
content_type=content_type,
)
TestMiddlewarePageURLs.objects.create(
page=self.content_url,
)
request = self.factory.get('/raise404/')
request.pages = RequestPageManager(request)
processed_response = middleware.process_response(request, HttpResponseNotFound())
self.assertEqual(processed_response.status_code, 404)
with self.settings(DEBUG=True):
request = self.factory.get('/raise404/')
request.pages = RequestPageManager(request)
processed_response = middleware.process_response(request, HttpResponseNotFound())
self.assertEqual(processed_response.status_code, 404)
request = self.factory.get('/auth/')
request.user = MockUser(authenticated=False)
request.pages = RequestPageManager(request)
processed_response = middleware.process_response(request, response)
self.assertEqual(processed_response['Location'], '/accounts/login/?next=/auth/')
self.assertEqual(processed_response.status_code, 302)
request = self.factory.get('/auth/')
request.user = MockUser(authenticated=True)
request.pages = RequestPageManager(request)
processed_response = middleware.process_response(request, response)
self.assertEqual(processed_response.status_code, 200)
request = self.factory.get('/media/')
request.pages = RequestPageManager(request)
processed_response = middleware.process_response(request, response)
self.assertEqual(processed_response, response)
request = self.factory.get('/foo/')
request.country = Country.objects.create(
code='GB',
)
request.pages = RequestPageManager(request)
processed_response = middleware.process_response(request, response)
self.assertEqual(processed_response.status_code, 200)
def test_pageadmin_duplicate_for_country_group(self):
# Test without country groups first.
factory = RequestFactory()
request = factory.get('/?preview=a')
# Allow the messages framework to work.
setattr(request, 'session', 'session')
messages = FallbackStorage(request)
setattr(request, '_messages', messages)
response = self.page_admin.duplicate_for_country_group(
request, page=self.homepage.pk)
self.assertEqual(response.status_code, 302)
self.assertEqual(response['Location'],
'/admin/pages/page/' + str(self.homepage.pk))
self.assertEqual(len(request._messages._queued_messages), 1)
self.assertEqual(
request._messages._queued_messages[0].message,
"You need to add at least one country group first before you can add a copy of this page"
)
# Create country groups.
self.country_group = CountryGroup.objects.create(name="United Kingdom")
self.country = Country.objects.create(name="United Kingdom",
code="GB",
group=self.country_group)
request = self._build_request()
response = self.page_admin.duplicate_for_country_group(
request, page=self.homepage.pk)
self.assertEqual(response.status_code, 200)
self.assertEqual(response.context_data['original_page'], self.homepage)
request = self._build_request(method='POST')
request.POST = dict(country_group=self.country_group.pk)
response = self.page_admin.duplicate_for_country_group(
request, page=self.homepage.pk)
self.assertEqual(
Page.objects.filter(owner=self.homepage,
is_canonical_page=False).count(), 1)
with search.update_index():
content_type_2 = ContentType.objects.get_for_model(
TestPageContentWithFields)
inline_page = Page.objects.create(
parent=self.homepage,
title="Inline page",
content_type=content_type_2,
)
TestPageContentWithFields.objects.create(page=inline_page, )
inline_model = TestInlineModel.objects.create(page=inline_page, )
request = self._build_request(method='POST')
request.POST = dict(country_group=self.country_group.pk)
response = self.page_admin.duplicate_for_country_group(
request, page=inline_page.pk)
self.assertEqual(
Page.objects.filter(owner=inline_page,
is_canonical_page=False).count(), 1)
inline_page_clone = Page.objects.get(owner=inline_page,
is_canonical_page=False)
self.assertEqual(inline_page_clone.testinlinemodel_set.count(), 1)
