def test_restoring_page_custom_move_to(self):
from wagtail_recycle_bin.wagtail_hooks import urlconf_time
root_page = Page.objects.get(url_path="/")
top = Page(title="1p", has_unpublished_changes=False, live=True)
root_page.add_child(instance=top)
sub_page = Page(title="1p 1u",
has_unpublished_changes=True,
live=False)
top.add_child(instance=sub_page)
with self.register_hook("before_delete_page", recycle_delete):
delete_url = reverse("wagtailadmin_pages:delete",
args=(sub_page.id, ))
self.client.post(delete_url)
sub_page.refresh_from_db()
with self.register_hook("register_admin_urls", urlconf_time):
restore_url = reverse(
"wagtail_recycle_bin_move",
args=(sub_page.id, ),
)
self.client.post(restore_url, {"move_page": str(root_page.id)})
sub_page.refresh_from_db()
self.assertIn(
sub_page.id,
list(root_page.get_children().values_list("id", flat=True)),
)
self.assertEqual(RecycleBin.objects.count(), 0)
def test_cant_move_pages_between_locales(self):
user = get_user_model().objects.get(email="*****@*****.**")
homepage = Page.objects.get(url_path="/home/").specific
root = Page.objects.get(url_path="/").specific
fr_locale = Locale.objects.create(language_code="fr")
fr_page = root.add_child(instance=Page(
title="French page",
slug="french-page",
locale=fr_locale,
))
fr_homepage = root.add_child(instance=Page(
title="French homepage",
slug="french-homepage",
locale=fr_locale,
))
french_page_perms = fr_page.permissions_for_user(user)
# fr_page can be moved into fr_homepage but not homepage
self.assertFalse(french_page_perms.can_move_to(homepage))
self.assertTrue(french_page_perms.can_move_to(fr_homepage))
# All pages can be moved to the root, regardless what language they are
self.assertTrue(french_page_perms.can_move_to(root))
events_index = Page.objects.get(url_path="/home/events/")
events_index_perms = events_index.permissions_for_user(user)
self.assertTrue(events_index_perms.can_move_to(root))
def test_removing_page_unpublishes_all_sub_pages(self):
root_page = Page.objects.get(url_path="/")
top = Page(title="1p", has_unpublished_changes=False, live=True)
root_page.add_child(instance=top)
sub_page = Page(title="1p 1u",
has_unpublished_changes=True,
live=False)
top.add_child(instance=sub_page)
sub_page = Page(title="1p 2p",
has_unpublished_changes=False,
live=True)
top.add_child(instance=sub_page)
sub_page_id = sub_page.id
sub_sub_page = Page(title="1p 2p 3u",
has_unpublished_changes=True,
live=False)
sub_page.add_child(instance=sub_sub_page)
self.assertEqual(top.get_descendants(inclusive=True).live().count(), 2)
self.assertEqual(
top.get_descendants(inclusive=True).not_live().count(), 2)
with self.register_hook("before_delete_page", recycle_delete):
delete_url = reverse("wagtailadmin_pages:delete", args=(top.id, ))
self.client.post(delete_url)
top.refresh_from_db()
self.assertEqual(top.get_descendants(inclusive=True).live().count(), 0)
self.assertEqual(
top.get_descendants(inclusive=True).not_live().count(), 4)
def _setUpVeterisSubsite(self):
main = getPage("/home/")
home = Page(slug="veteris", title="Veteris Council")
main.add_child(instance=home)
home.save_revision().publish()
activities = Page(slug="activities", title="Veteris Calendar")
home.add_child(instance=activities)
activities.save_revision().publish()
Site.objects.create(hostname='veteris.joy.test',
root_page_id=home.id,
is_default_site=False)
events = CalendarPage(owner=self.user,
slug="veteris-events",
title="Veteris Events")
home.add_child(instance=events)
events.save_revision().publish()
committee = RecurringEventPage(owner=self.user,
slug="veteris-committee",
title="Committee Meeting",
repeat=Recurrence(
dtstart=dt.date(1970, 1, 5),
freq=MONTHLY,
byweekday=[MO],
until=dt.date(1978, 8, 7)),
time_from=dt.time(14),
time_to=dt.time(15))
events.add_child(instance=committee)
committee.save_revision().publish()
def setUp(self):
super(TestMultipleSites, self).setUp()
root = Page.objects.get(pk=1)
root_a = Page(
title='Home A', slug='home-a')
root.add_child(instance=root_a)
root_b = Page(
title='Home B', slug='home-b')
root.add_child(instance=root_b)
self.index_a = NewsIndex(title='News A', slug='news-a')
root_a.add_child(instance=self.index_a)
self.index_b = NewsIndex(title='News B', slug='news-b')
root_b.add_child(instance=self.index_b)
self.site_a = Site.objects.create(
hostname='site-a.com',
root_page=root_a)
self.site_b = Site.objects.create(
hostname='site-b.org',
root_page=root_b)
self.item_a = NewsItem.objects.create(
newsindex=self.index_a, title='Post A', date=dt(2015, 8, 1))
self.item_b = NewsItem.objects.create(
newsindex=self.index_b, title='Post B', date=dt(2015, 8, 2))
def test_restoring_page_re_publishes(self):
from wagtail_recycle_bin.wagtail_hooks import urlconf_time
root_page = Page.objects.get(url_path="/")
top = Page(title="1p", has_unpublished_changes=False, live=True)
root_page.add_child(instance=top)
sub_page = Page(title="1p 1u",
has_unpublished_changes=True,
live=False)
top.add_child(instance=sub_page)
sub_page = Page(title="1p 2p",
has_unpublished_changes=False,
live=True)
top.add_child(instance=sub_page)
sub_page_id = sub_page.id
sub_sub_page = Page(title="1p 2p 3u",
has_unpublished_changes=True,
live=False)
sub_page.add_child(instance=sub_sub_page)
self.assertEqual(top.get_descendants(inclusive=True).live().count(), 2)
self.assertEqual(
top.get_descendants(inclusive=True).not_live().count(), 2)
with self.register_hook("before_delete_page", recycle_delete):
delete_url = reverse("wagtailadmin_pages:delete", args=(top.id, ))
self.client.post(delete_url)
top.refresh_from_db()
self.assertEqual(top.get_descendants(inclusive=True).live().count(), 0)
self.assertEqual(
top.get_descendants(inclusive=True).not_live().count(), 4)
with self.register_hook("register_admin_urls", urlconf_time):
restore_url = reverse("wagtail_recycle_bin_restore",
args=(top.id, ))
self.client.get(restore_url)
top.refresh_from_db()
self.assertEqual(top.get_descendants(inclusive=True).live().count(), 2)
self.assertEqual(
top.get_descendants(inclusive=True).not_live().count(), 2)
self.assertEqual(RecycleBin.objects.count(), 0)
self.assertEqual(RecycleBinPage.objects.first().get_children().count(),
0)
def make_test_page(cls, title, root_page=None):
if not root_page:
root_page = Site.objects.get(is_default_site=True).root_page
page = Page(title=title, slug=slugify(title))
root_page.add_child(instance=page)
return page
def setUp(self):
self.root_page = Page.objects.get(depth=1)
self.home_page = Page.objects.get(depth=2)
self.second_home_page = self.root_page.add_child(
instance=Page(title="Second homepage", slug="home-1")
)
def test_not_translation_of(self):
en_homepage = Page.objects.get(url_path="/home/")
# Create a translation of the homepage
fr_locale = Locale.objects.create(language_code="fr")
root_page = Page.objects.get(depth=1)
fr_homepage = root_page.add_child(instance=Page(
title="French homepage",
slug="home-fr",
locale=fr_locale,
translation_key=en_homepage.translation_key,
))
with self.assertNumQueries(1):
translations = list(Page.objects.not_translation_of(en_homepage))
# Check that every single page is in the queryset, except for fr_homepage
for page in Page.objects.all():
if page in [fr_homepage]:
self.assertNotIn(page, translations)
else:
self.assertIn(page, translations)
# Test with inclusive
with self.assertNumQueries(1):
translations = list(
Page.objects.not_translation_of(en_homepage, inclusive=True))
# Check that every single page is in the queryset, except for fr_homepage and en_homepage
for page in Page.objects.all():
if page in [en_homepage, fr_homepage]:
self.assertNotIn(page, translations)
else:
self.assertIn(page, translations)
def setUp(self):
self.root_page = Page.objects.get(id=2)
# Add child pages
self.child_pages = [
Page(title=f"Hello world!-{i}",
slug=f"hello-world-{i}",
live=False) for i in range(1, 5)
]
self.pages_to_be_published = self.child_pages[:3]
self.pages_not_to_be_published = self.child_pages[3:]
for child_page in self.child_pages:
self.root_page.add_child(instance=child_page)
self.url = reverse('wagtail_bulk_action',
args=(
'wagtailcore',
'page',
'publish',
)) + '?'
for child_page in self.pages_to_be_published:
self.url += f'id={child_page.id}&'
self.redirect_url = reverse('wagtailadmin_explore',
args=(self.root_page.id, ))
self.user = self.login()
def setUp(self):
self.login()
page = Page(title="Test Page")
root = WagtailSite.objects.get().root_page
root.add_child(instance=page)
self.comment_parent = XtdComment.objects.create(
content_type=ContentType.objects.get_for_model(Page),
object_pk=page.pk,
site=Site.objects.get_current(),
)
self.comment_child_1 = XtdComment.objects.create(
content_type=ContentType.objects.get_for_model(Page),
object_pk=page.pk,
site=Site.objects.get_current(),
parent_id=self.comment_parent.pk,
)
self.comment_child_2 = XtdComment.objects.create(
content_type=ContentType.objects.get_for_model(Page),
object_pk=page.pk,
site=Site.objects.get_current(),
parent_id=self.comment_parent.pk,
)
def handle(self, *args, **options):
# Get blogpage content type
blogpage_content_type, created = ContentType.objects.get_or_create(
model='blogpage',
app_label='blog',
defaults={'name': 'page'} if DJANGO_VERSION < (1, 8) else {})
# Get root page
rootpage = Page.objects.first()
# Set site root page as root site page
site = Site.objects.first()
site.root_page = rootpage
site.save()
# Create example blog page
blogpage = Page(
title="Blog",
content_type=blogpage_content_type,
slug='blog',
)
# Add blog page as a child for homepage
rootpage.add_child(instance=blogpage)
revision = blogpage.save_revision()
revision.publish()
def test_basepage_can_exist_under(root_page):
page = IndustryPageFactory(parent=root_page)
assert isinstance(page, BasePage)
dummy_ctype = ContentType.objects.create(app_label='blah', model='blah')
test_parent = Page(slug='basic', title='Page')
test_parent.content_type = dummy_ctype
assert page.can_exist_under(test_parent) is False
def test_valid_post_redirects__to_the_forms_post_redirect_page(self):
redirect_to = self.page.add_child(
instance=Page(title="another", slug="another"))
form = self.test_form()
form.post_redirect_page = redirect_to
form.save()
fake_request = self.rf.post(
"/fake/",
{
"singleline": "Bill",
"multiline": "Bill",
"date": "2018-01-01",
"datetime": "2018-01-01 00:00:00",
"email": "*****@*****.**",
"url": "http://google.co.uk",
"number": 1,
"dropdown": "Option 1",
"radio": "Option 1",
"checkboxes": "Option 1",
"checkbox": "on",
"hidden": "secret",
"singlefile": self.get_file(),
"multifile": self.get_file(),
"form_id": form.pk,
"form_reference": "some-ref",
},
)
fake_request.user = AnonymousUser()
response = process_form(self.page, fake_request)
response.client = Client()
self.assertRedirects(response, redirect_to.get_url(fake_request))
def test_submit_page_translation_view_test_post_multiple_locales(self):
# Needs an extra page to hit recursive function
en_blog_post_sub = Page(title="Blog post sub", slug="blog-post-sub")
self.en_blog_post.add_child(instance=en_blog_post_sub)
url = reverse("simple_translation:submit_page_translation",
args=(self.en_blog_post.id, ))
de = Locale.objects.get(language_code="de").id
fr = Locale.objects.get(language_code="fr").id
data = {"locales": [de, fr], "include_subtree": True}
self.login()
with self.assertRaisesMessage(ParentNotTranslatedError, ""):
self.client.post(url, data)
url = reverse("simple_translation:submit_page_translation",
args=(self.en_blog_index.id, ))
response = self.client.post(url, data)
assert response.status_code == 302
assert response.url == f"/admin/pages/{self.en_blog_index.get_parent().id}/"
response = self.client.get(response.url) # follow the redirect
assert [msg.message for msg in response.context["messages"]
] == ["The page 'Blog' was successfully created in 2 locales"]
def process_request(self, request):
maintenance = getattr(settings, 'MAINTENANCE_MODE', None)
template_name = getattr(
settings,
'MAINTENANCE_MODE_TEMPLATE', 'core/maintenance_mode.html'
)
if maintenance and reverse('health') not in request.path:
page_ctx = getattr(
settings,
'MAINTENANCE_MODE_PAGE_CONTEXT',
{'title': 'Maintenance Mode'}
)
class Page(object):
depth = 2
def __init__(self, ctx):
for k, v in ctx.items():
setattr(self, k, v)
return render(
request, template_name, context={
'self': Page(page_ctx),
'request': request,
'ENV': getattr(settings, 'ENV', 'dev'),
'STATIC_URL': getattr(settings, 'STATIC_URL', 'dev'),
}
)
def django_db_setup(django_db_setup, django_db_blocker):
with django_db_blocker.unblock():
root_page = Page(title='test', path='test', depth=1)
root_page.save()
site = Site(hostname='www.example.com', root_page=root_page)
site.save()
count_settings = AnimalCountSettings(site_id=site.id)
count_settings.save()
def testFromUnsupported(self):
page = Page(owner=self.user,
slug="thoughts",
title="My thoughts for today")
self.home.add_child(instance=page)
page.save_revision().publish()
with self.assertRaises(CalendarTypeError):
VCalendar.fromPage(page, self._getRequest("/thoughts/"))
def _setUpNovaSubsite(self):
main = getPage("/home/")
home = Page(slug="nova", title="Nova Homepage")
main.add_child(instance=home)
home.save_revision().publish()
activities = Page(slug="activities", title="Nova Activities")
home.add_child(instance=activities)
activities.save_revision().publish()
Site.objects.create(hostname='nova.joy.test',
root_page_id=home.id,
is_default_site=False)
events = CalendarPage(owner=self.user,
slug="nova-events",
title="Nova Events")
home.add_child(instance=events)
events.save_revision().publish()
committee = RecurringEventPage(owner=self.user,
slug="executive-meeting",
title="Executive Committee Meeting",
repeat=Recurrence(dtstart=dt.date(
1984, 8, 5),
freq=WEEKLY,
byweekday=[TH]),
time_from=dt.time(13),
time_to=dt.time(15))
events.add_child(instance=committee)
committee.save_revision().publish()
event = SimpleEventPage(owner=self.user,
slug="rubbish-blitz",
title="Rubbish Blitz",
date=dt.date(1984, 9, 13),
time_from=dt.time(12, 30),
time_to=dt.time(17))
events.add_child(instance=event)
event.save_revision().publish()
cancellation = CancellationPage(
owner=self.user,
slug="1984-09-13-cancellation",
title="Cancellation for Thursday 13th of September",
overrides=committee,
except_date=dt.date(1984, 9, 13),
cancellation_title="Meeting Cancelled",
cancellation_details="The committee will be at "
"the working bee")
committee.add_child(instance=cancellation)
cancellation.save_revision().publish()
def test_update_wont_move_pages(self):
page = Page(title='Test Page', )
home = Page.objects.get(slug='home')
home.add_child(instance=page)
csv_data = StringIO('id,parent\r\n' f'3,1\r\n')
successes, errors = import_pages(csv_data, Page)
self.assertEqual(successes, [])
self.assertEqual([repr(e) for e in errors], [
"Error(Errors processing row number 1: {'parent': [ValidationError(['Cannot change parent page, moving pages is not yet supported.'])]})"
])
def setUp(self):
self.user = User.objects.create_user('i', '*****@*****.**', 's3(r3t')
self.main = getPage("/home/")
self.sub = Page(slug="nova", title="Nova Homepage")
self.main.add_child(instance=self.sub)
self.sub.save_revision().publish()
Site.objects.create(hostname='nova.joy.test',
root_page_id=self.sub.id,
is_default_site=False)
SpecificCalendarPage.is_creatable = True
GeneralCalendarPage.is_creatable = True
def test_empty_bin_removes_pages_older_than_setting(self):
root_page = Page.objects.get(url_path="/")
new_page = Page(title="new page")
root_page.add_child(instance=new_page)
RecycleBin.objects.create(page=new_page)
old_page = Page(title="new page oldie")
root_page.add_child(instance=old_page)
RecycleBin.objects.create(page=old_page)
RecycleBin.objects.filter(page__title="new page oldie").update(
time_recycled=datetime.now() - timedelta(days=31)
)
self.assertEqual(RecycleBin.objects.count(), 2)
call_command("empty_recycle_bin", older_than_days=30)
self.assertFalse(RecycleBin.objects.filter(page_id=old_page.id).exists())
self.assertTrue(RecycleBin.objects.filter(page_id=new_page.id).exists())
self.assertEqual(RecycleBin.objects.count(), 1)
def test_generate_page_data(self):
root_page = Page.objects.get(url_path="/")
top = Page(title="1p", has_unpublished_changes=False, live=True)
root_page.add_child(instance=top)
sub_page = Page(title="1p 1u", has_unpublished_changes=True, live=False)
top.add_child(instance=sub_page)
sub_page = Page(title="1p 2p", has_unpublished_changes=False, live=True)
top.add_child(instance=sub_page)
sub_page_id = sub_page.id
sub_sub_page = Page(title="1p 2p 3u", has_unpublished_changes=True, live=False)
sub_page.add_child(instance=sub_sub_page)
self.assertEqual(top.get_descendants().live().count(), 1)
self.assertEqual(top.get_descendants().not_live().count(), 2)
self.assertEqual(
json.loads(generate_page_data(top)), {"published": [top.id, sub_page_id]}
)
def test_slugurl_tag_returns_url_for_current_site(self):
home_page = Page.objects.get(url_path='/home/')
new_home_page = home_page.copy(update_attrs={'title': "New home page", 'slug': 'new-home'})
second_site = Site.objects.create(hostname='site2.example.com', root_page=new_home_page)
# Add a page to the new site that has a slug that is the same as one on
# the first site, but is in a different position in the treeself.
new_christmas_page = Page(title='Christmas', slug='christmas')
new_home_page.add_child(instance=new_christmas_page)
request = HttpRequest()
request.META['HTTP_HOST'] = second_site.hostname
request.META['SERVER_PORT'] = second_site.port
url = slugurl(context=template.Context({'request': request}), slug='christmas')
self.assertEqual(url, '/christmas/')
def test_issue_2599(self):
homepage = Page.objects.get(id=2)
child1 = Page(title="child1")
homepage.add_child(instance=child1)
child2 = Page(title="child2")
homepage.add_child(instance=child2)
child1.delete()
self.login()
post_data = {
"title": "New page!",
"content": "Some content",
"slug": "hello-world",
"action-submit": "Submit",
}
preview_url = reverse(
"wagtailadmin_pages:preview_on_add",
args=("tests", "simplepage", homepage.id),
)
response = self.client.post(preview_url, post_data)
# Check the JSON response
self.assertEqual(response.status_code, 200)
self.assertJSONEqual(response.content.decode(), {"is_valid": True})
response = self.client.get(preview_url)
# Check the HTML response
self.assertEqual(response.status_code, 200)
self.assertTemplateUsed(response, "tests/simple_page.html")
self.assertContains(response, "New page!")
# Check that the treebeard attributes were set correctly on the page object
self.assertEqual(response.context["self"].depth, homepage.depth + 1)
self.assertTrue(response.context["self"].path.startswith(
homepage.path))
self.assertEqual(response.context["self"].get_parent(), homepage)
def test_create_sets_locale_to_parent_locale(self):
# We need to make sure the page's locale it set to the parent in the create view so that any customisations
# for that language will take effect.
fr_locale = Locale.objects.create(language_code="fr")
fr_homepage = self.root_page.add_child(instance=Page(
title="Home",
slug="home-fr",
locale=fr_locale,
))
response = self.client.get(reverse('wagtailadmin_pages:add', args=('tests', 'simplepage', fr_homepage.id)))
self.assertEqual(response.context['page'].locale, fr_locale)
def test_buttons(self):
root_page = Page.objects.get(url_path="/")
top_page = Page(title="top_page")
root_page.add_child(instance=top_page)
sub_page = Page(title="sub_page")
top_page.add_child(instance=sub_page)
sub_sub_page = Page(title="sub_sub_page")
sub_page.add_child(instance=sub_sub_page)
with self.register_hook("before_delete_page", recycle_delete):
delete_url = reverse("wagtailadmin_pages:delete",
args=(sub_sub_page.id, ))
self.client.post(delete_url)
delete_url = reverse("wagtailadmin_pages:delete",
args=(top_page.id, ))
self.client.post(delete_url)
index = recycle_admin_url_helper.get_action_url("index")
resp = self.client.get(index)
# Since sub_sub_pages parent is now in the recycle bin we should not show the "Restore"-button.
self.assertFalse(
reverse("wagtail_recycle_bin_restore", args=(
sub_sub_page.id, )) in str(resp.content))
self.assertTrue(
reverse("wagtail_recycle_bin_move", args=(
sub_sub_page.id, )) in str(resp.content))
# However - top page still has a parent (root) and should be able to be restored.
self.assertTrue(
reverse("wagtail_recycle_bin_restore", args=(
top_page.id, )) in str(resp.content))
self.assertTrue(
reverse("wagtail_recycle_bin_move", args=(
top_page.id, )) in str(resp.content))
def setUp(self):
self.root_page = Page.objects.get(id=2)
# Add child pages
self.child_pages = [
Page(title=f"Hello world!-{i}",
slug=f"hello-world-{i}",
live=False) for i in range(1, 5)
]
self.pages_to_be_published = self.child_pages[:3]
self.pages_not_to_be_published = self.child_pages[3:]
for child_page in self.child_pages:
self.root_page.add_child(instance=child_page)
# map of the form { page: [child_pages] } to be added
self.grandchildren_pages = {
self.pages_to_be_published[0]:
[Page(title="Hello world!-a", slug="hello-world-a", live=False)],
self.pages_to_be_published[1]: [
Page(title="Hello world!-b", slug="hello-world-b", live=False),
Page(title="Hello world!-c", slug="hello-world-c", live=False)
]
}
for child_page, grandchild_pages in self.grandchildren_pages.items():
for grandchild_page in grandchild_pages:
child_page.add_child(instance=grandchild_page)
self.url = reverse('wagtail_bulk_action',
args=(
'wagtailcore',
'page',
'publish',
)) + '?'
for child_page in self.pages_to_be_published:
self.url += f'&id={child_page.id}'
self.user = self.login()
def test_update_wont_publish_or_unpublish_if_live_column_is_missing(self):
live_page = Page(title='Live Page', live=True)
draft_page = Page(title='Draft Page', live=False)
home = Page.objects.get(slug='home')
home.add_child(instance=live_page)
home.add_child(instance=draft_page)
csv_data = StringIO('id,title\r\n'
f'3,Updated Live Page\r\n'
f'4,Updated Draft Page\r\n')
successes, errors = import_pages(csv_data, Page)
self.assertEqual(successes, [
'Updated page Updated Live Page with id 3',
'Updated page Updated Draft Page with id 4',
])
self.assertEqual(errors, [])
live_page.refresh_from_db()
self.assertEqual(live_page.title, 'Updated Live Page')
self.assertTrue(live_page.live)
draft_page.refresh_from_db()
self.assertEqual(draft_page.title, 'Updated Draft Page')
self.assertFalse(draft_page.live)
def test_auto_recache(root_page, example_svg_upload):
page = Page(title="nnep", slug="nnep")
page.set_url_path(root_page)
root_page.add_child(instance=page)
page.save()
assert page.url
map = ImageMap.objects.create(svg=example_svg_upload)
map.regions.create(element_id='blue', link_page=page)
map.recache_svg(save=True)
assert 'nnep' in map.rendered_svg
page.slug = 'ffflop'
page.save() # The `post_save` triggers will get called...
assert 'ffflop' in ImageMap.objects.get(pk=map.pk).rendered_svg
