def test_render_js_init_with_can_choose_root_true(self):
# construct an alternative page chooser panel object, with can_choose_root=True
MyPageChooserPanel = PageChooserPanel('page', can_choose_root=True).bind_to_model(PageChooserModel)
PageChooserForm = MyPageChooserPanel.get_form_class(PageChooserModel)
form = PageChooserForm(instance=self.test_instance)
page_chooser_panel = MyPageChooserPanel(instance=self.test_instance, form=form)
result = page_chooser_panel.render_as_field()
# the canChooseRoot flag on createPageChooser should now be true
expected_js = 'createPageChooser("{id}", ["{model}"], {parent}, true);'.format(
id="id_page", model="wagtailcore.page", parent=self.events_index_page.id)
self.assertIn(expected_js, result)
def test_autodetect_page_type(self):
# Model has a foreign key to EventPage, which we want to autodetect
# instead of specifying the page type in PageChooserPanel
MyPageChooserPanel = PageChooserPanel('page').bind_to_model(EventPageChooserModel)
PageChooserForm = MyPageChooserPanel.get_form_class(EventPageChooserModel)
form = PageChooserForm(instance=self.test_instance)
page_chooser_panel = self.MyPageChooserPanel(instance=self.test_instance, form=form)
result = page_chooser_panel.render_as_field()
expected_js = 'createPageChooser("{id}", "{model}", {parent});'.format(
id="id_page", model="tests.eventpage", parent=self.events_index_page.id)
self.assertIn(expected_js, result)
def test_override_page_type(self):
# Model has a foreign key to Page, but we specify EventPage in the PageChooserPanel
# to restrict the chooser to that page type
MyPageChooserPanel = PageChooserPanel('page', 'tests.EventPage').bind_to_model(EventPageChooserModel)
PageChooserForm = MyPageChooserPanel.get_form_class(EventPageChooserModel)
form = PageChooserForm(instance=self.test_instance)
page_chooser_panel = self.MyPageChooserPanel(instance=self.test_instance, form=form)
result = page_chooser_panel.render_as_field()
expected_js = 'createPageChooser("{id}", "{model}", {parent});'.format(
id="id_page", model="tests.eventpage", parent=self.events_index_page.id)
self.assertIn(expected_js, result)
class UniversalBlogPageRelatedLink(Orderable, models.Model):
"""
Common model needed for "pages related links" feature,
which is accessible when editing a UniversalBlogPage.
"""
title = models.CharField(max_length=255, help_text="Link title")
link_external = models.URLField("External link", blank=True)
link_page = models.ForeignKey('wagtailcore.Page',
null=True,
blank=True,
related_name='+')
link_document = models.ForeignKey('wagtaildocs.Document',
null=True,
blank=True,
related_name='+')
page = ParentalKey('home.UniversalBlogPage', related_name='related_links')
@property
def link(self):
if self.link_page:
return self.link_page.url
elif self.link_document:
return self.link_document.url
else:
return self.link_external
panels = [
FieldPanel('title'),
FieldPanel('link_external'),
PageChooserPanel('link_page'),
DocumentChooserPanel('link_document'),
]
class BookTechRelationship(models.Model):
book = ParentalKey(Book, related_name='techs')
tech = models.ForeignKey('techs.Tech')
panels = [
PageChooserPanel('tech', 'techs.Tech'),
]
class SeriesArticleLink(Orderable, models.Model):
override_image = models.ForeignKey(
'images.AttributedImage',
null=True,
blank=True,
on_delete=models.SET_NULL,
related_name='+',
help_text="This field is optional. If not provided, the image will be "
"pulled from the article page automatically. This field "
"allows you to override the automatic image.")
override_text = RichTextField(
blank=True,
default="",
help_text="This field is optional. If not provided, the text will be "
"pulled from the article page automatically. This field "
"allows you to override the automatic text.")
article = models.ForeignKey("ArticlePage",
null=True,
blank=True,
on_delete=models.SET_NULL,
related_name='series_links')
series = ParentalKey("SeriesPage", related_name='related_article_links')
panels = [
PageChooserPanel("article", 'articles.ArticlePage'),
FieldPanel("override_text"),
ImageChooserPanel("override_image"),
]
class PressReleasePage(ContentPage):
date = models.DateField(default=datetime.date.today)
formatted_title = models.CharField(max_length=255, null=True, blank=True, default='',
help_text="Use if you need italics in the title. e.g. <em>Italicized words</em>")
category = models.CharField(max_length=255,
choices=constants.press_release_page_categories.items())
read_next = models.ForeignKey('PressReleasePage', blank=True, null=True,
default=get_previous_press_release_page,
on_delete=models.SET_NULL)
content_panels = ContentPage.content_panels + [
FieldPanel('formatted_title'),
FieldPanel('date'),
InlinePanel('authors', label="Authors"),
FieldPanel('category'),
PageChooserPanel('read_next'),
]
@property
def content_section(self):
return ''
@property
def get_update_type(self):
return constants.update_types['press-release']
"""
Because we removed the boilerplate from all 2016 releases
this flag is used to show it in the templates as a print-only element
"""
@property
def no_boilerplate(self):
return self.date.year >= 2016
class EmailLinkFields(LinkFields):
link_email = models.EmailField(blank=True, null=False)
class Meta:
abstract = True
content_panels = [
MultiFieldPanel([
PageChooserPanel('link_page'),
FieldPanel('link_url'),
FieldPanel('link_email'),
FieldPanel('link_text'),
], 'Link'),
]
def clean(self):
errors = {}
fields = [
f for f in [self.link_email, self.link_page, self.link_url]
if f is not None if f is not ''
]
if len(fields) > 1:
error_message = 'Please choose one of link url, link page or link email.'
errors.update({'link_email': _(error_message)}, )
errors.update({'link_page': _(error_message)}, )
errors.update({'link_url': _(error_message)}, )
if errors:
raise ValidationError(errors)
return super().clean()
class LinkFields(models.Model):
caption = models.CharField(max_length=255, blank=True)
link_external = models.URLField("External link", blank=True)
link_page = models.ForeignKey(
'wagtailcore.Page',
null=True,
blank=True,
related_name='+'
)
@property
def link(self):
if self.link_page:
return self.link_page.url
else:
return self.link_external
panels = [
FieldPanel('caption'),
FieldPanel('link_external'),
PageChooserPanel('link_page')
]
class Meta:
abstract = True
def setUp(self):
model = PageChooserModel # a model with a foreign key to Page which we want to render as a page chooser
# a PageChooserPanel class that works on PageChooserModel's 'page' field
self.MyPageChooserPanel = PageChooserPanel('page').bind_to_model(PageChooserModel)
# build a form class containing the fields that MyPageChooserPanel wants
self.PageChooserForm = self.MyPageChooserPanel.get_form_class(PageChooserModel)
# a test instance of PageChooserModel, pointing to the 'christmas' page
self.christmas_page = Page.objects.get(slug='christmas')
self.events_index_page = Page.objects.get(slug='events')
self.test_instance = model.objects.create(page=self.christmas_page)
self.form = self.PageChooserForm(instance=self.test_instance)
self.page_chooser_panel = self.MyPageChooserPanel(instance=self.test_instance, form=self.form)
class Advert(LinkFields):
page = models.ForeignKey(
Page,
related_name='adverts',
null=True,
blank=True
)
title = models.CharField(max_length=150, null=True)
image = models.ForeignKey(
Image, null=True, blank=True, on_delete=models.SET_NULL
)
button_text = models.CharField(max_length=150, null=True)
text = RichTextField(blank=True)
panels = [
PageChooserPanel('page'),
FieldPanel('title'),
ImageChooserPanel('image'),
FieldPanel('text'),
FieldPanel('button_text'),
MultiFieldPanel(LinkFields.panels, "Link"),
]
def __unicode__(self):
return self.title
class LinkFields(LinkFieldUrl, LinkFieldPage, LinkFieldDocument,
LinkFieldImage):
link_text = models.CharField(max_length=40, blank=True)
@property
def link(self):
if self.link_page:
return self.link_page
elif self.link_document:
return self.link_document
elif self.link_image:
return self.link_image
else:
return self.link_external
panels = [
FieldPanel('link_text'),
FieldPanel('link_external'),
PageChooserPanel('link_page'),
DocumentChooserPanel('link_document'),
ImageChooserPanel('link_image')
]
class Meta:
abstract = True
class FacultyResources(models.Model):
resource = models.ForeignKey(
Resource,
null=True,
help_text="Manage resources through snippets.",
related_name='+')
link_external = models.URLField("External link", blank=True)
link_page = models.ForeignKey('wagtailcore.Page',
null=True,
blank=True,
related_name='+')
link_document = models.ForeignKey('wagtaildocs.Document',
null=True,
blank=True,
related_name='+')
api_fields = (
'resource',
'link_external',
'link_page',
'link_document',
)
panels = [
SnippetChooserPanel('resource', Resource),
FieldPanel('link_external'),
PageChooserPanel('link_page'),
DocumentChooserPanel('link_document'),
]
def test_target_content_type_nonexistent_type(self):
result = PageChooserPanel(
'barbecue',
'snowman.lorry'
)
self.assertRaises(ImproperlyConfigured,
result.target_content_type)
class NewsItem(AbstractNewsItem):
title = models.CharField(max_length=32)
page = models.ForeignKey('wagtailcore.Page', related_name='+', null=True,
blank=True)
tags = ClusterTaggableManager(through=NewsItemTag, blank=True)
panels = [
FieldPanel('title'),
PageChooserPanel('page'),
FieldPanel('tags'),
FieldPanel('date'),
]
search_fields = AbstractNewsItem.search_fields + [
index.SearchField('title'),
]
def __str__(self):
return self.title
def get_context(self, request, *args, **kwargs):
context = super(NewsItem, self).get_context(request, *args, **kwargs)
context['foo'] = 'bar'
return context
def get_description(self):
return "This post was published on {0}, with a title of {1}".format(self.date, self.title)
class HeroVideoFieldsLogo(HeroVideoFields):
hero_logo = models.ForeignKey(
'images.CustomImage',
null=True,
blank=True,
related_name='+',
help_text="Shows the brand logo on the hero instead of a text heading.",
on_delete=models.SET_NULL,
verbose_name="Brand Logo")
content_panels = [
MultiFieldPanel([
MediaChooserPanel('hero_video'),
ImageChooserPanel('hero_fallback_image'),
ImageChooserPanel('hero_logo'),
FieldPanel('hero_strapline'),
FieldPanel('hero_strapline_hex'),
MultiFieldPanel([
PageChooserPanel('link_page'),
FieldPanel('link_youtube'),
FieldPanel('link_text'),
], 'Hero Clickthrough Link')
], 'Hero Video'),
]
class Meta:
abstract = True
class HomePage(Page):
parent_page_types = ['wagtailcore.Page']
body = models.TextField(blank=True, help_text=md_format_help)
num_recent_recipes = models.PositiveIntegerField(default=6)
featured_recipe = models.ForeignKey(RecipePage,
null=True,
blank=True,
on_delete=models.SET_NULL)
content_panels = Page.content_panels + [
FieldPanel('body', classname="full"),
InlinePanel('header_icons', label='Header Icons'),
PageChooserPanel('featured_recipe'),
]
class Meta:
verbose_name = "Homepage"
def get_context(self, request, *args, **kwargs):
"""
Add recipes to the context for recipe category listings
"""
context = super(HomePage, self).get_context(request, *args, **kwargs)
recent_recipes = RecipePage.objects.live().order_by(
'-post_date')[:self.num_recent_recipes]
context['recent_recipes'] = recent_recipes
return context
class LessonTechRelationship(models.Model):
lesson = ParentalKey(Lesson, related_name='techs')
tech = models.ForeignKey('techs.Tech')
panels = [
PageChooserPanel('tech', 'techs.Tech'),
]
def test_target_content_type_malformed_type(self):
result = PageChooserPanel(
'barbecue',
'snowman'
).bind_to_model(PageChooserModel)
self.assertRaises(ImproperlyConfigured,
result.target_content_type)
class LessonBookRelationship(models.Model):
lesson = ParentalKey(Lesson, related_name='books')
book = models.ForeignKey(Book)
panels = [
PageChooserPanel('book', 'books.Book'),
]
class LinkFields(models.Model):
link_external = models.URLField("External link", blank=True)
link_page = models.ForeignKey('wagtailcore.Page',
null=True,
blank=True,
related_name='+')
link_document = models.ForeignKey('wagtaildocs.Document',
null=True,
blank=True,
related_name='+')
@property
def link(self):
if self.link_page:
return self.link_page.url
elif self.link_document:
return self.link_document.url
else:
return self.link_external
panels = [
FieldPanel('link_external'),
PageChooserPanel('link_page'),
DocumentChooserPanel('link_document'),
]
class Meta:
abstract = True
class AbstractLinkField(models.Model):
"""Abstract class for link fields."""
link_document = models.ForeignKey('wagtaildocs.Document',
blank=True,
null=True,
related_name='+')
link_external = models.URLField('External link', blank=True, null=True)
link_page = models.ForeignKey('wagtailcore.Page',
blank=True,
null=True,
related_name='+')
panels = [
DocumentChooserPanel('link_document'),
FieldPanel('link_external'),
PageChooserPanel('link_page')
]
@property
def link(self):
if self.link_page:
return self.link_page.url
elif self.link_document:
return self.link_document.url
else:
return self.link_external
class Meta:
abstract = True
class ProjectTechRelationship(models.Model):
project = ParentalKey(Project, related_name='techs')
tech = models.ForeignKey('techs.Tech')
panels = [
PageChooserPanel('tech', 'techs.Tech'),
]
def test_target_models_nonexistent_type(self):
result = PageChooserPanel(
'barbecue',
'snowman.lorry'
).bind_to_model(PageChooserModel)
self.assertRaises(ImproperlyConfigured,
result.target_models)
class RecipeInRecipe(models.Model):
link_external = models.URLField("External link", blank=True)
heading = models.CharField(
max_length=255,
help_text="Heading text for subrecipe (optional)",
blank=True,
null=True)
recipe_in_recipe_page = models.ForeignKey(
'Recipe',
null=True,
blank=True,
related_name='+',
on_delete=models.SET_NULL,
)
panels = [
PageChooserPanel('recipe_in_recipe_page'),
]
class Meta:
abstract = True
def get_context(self, request):
context = super(RecipeInRecipe, self).get_context(request)
context['RecipeInRecipe'] = RecipeInRecipe.objects.all()
return context
class DigestPage(ContentPage):
date = models.DateField(default=datetime.date.today)
read_next = models.ForeignKey('DigestPage', blank=True, null=True,
default=get_previous_digest_page,
on_delete=models.SET_NULL)
content_panels = ContentPage.content_panels + [
FieldPanel('date'),
InlinePanel('authors', label="Authors"),
PageChooserPanel('read_next'),
]
template = 'home/updates/digest_page.html'
search_fields = ContentPage.search_fields + [
index.FilterField('date')
]
@property
def content_section(self):
return ''
@property
def get_update_type(self):
return constants.update_types['weekly-digest']
@property
def get_author_office(self):
return 'Press Office'
class LinkFields(models.Model):
link_external = models.URLField('External link', blank=True)
link_page = models.ForeignKey('wagtailcore.Page',
null=True,
blank=True,
on_delete=models.SET_NULL,
related_name='+')
link_document = models.ForeignKey('wagtaildocs.Document',
null=True,
blank=True,
on_delete=models.SET_NULL,
related_name='+')
@property
def link(self):
if self.link_page:
return self.link_page.url
elif self.link_external:
return self.link_external
else:
return '/'
panels = [
PageChooserPanel('link_page'),
FieldPanel('link_external'),
]
# DocumentChooserPanel('link_document'),
class Meta:
abstract = True
class EventIndexPageFeaturedPage(RelatedPage):
source_page = ParentalKey('events.EventIndexPage',
related_name='featured_pages')
panels = [
PageChooserPanel('page', page_type='events.EventPage'),
]
class MultilingualMenuItem(models.Model):
link_text_de = models.CharField(
verbose_name=_('link text (de)'),
max_length=255,
blank=True,
)
link_text_fr = models.CharField(
verbose_name=_('link text (fr)'),
max_length=255,
blank=True,
)
translated_link_text = TranslatedField('link_text', 'link_text_de',
'link_text_fr')
class Meta:
abstract = True
ordering = ('sort_order', )
def menu_text(self):
return self.translated_link_text or getattr(
self.link_page, 'translated_title', None) or self.link_page.title
panels = (
PageChooserPanel('link_page'),
FieldPanel('link_url'),
FieldPanel('url_append'),
FieldPanel('link_text'),
FieldPanel('link_text_de'),
FieldPanel('link_text_fr'),
FieldPanel('handle'),
FieldPanel('allow_subnav'),
)
class LinkFields(models.Model):
link_external = models.CharField(
"External link",
max_length=500,
blank=True,
help_text="Please provide an external URL, or select a page below.")
link_page = models.ForeignKey(Page,
verbose_name="Internal link",
null=True,
blank=True,
on_delete=models.SET_NULL,
related_name='+')
@property
def link(self):
if self.link_page:
return self.link_page.url
else:
return self.link_external
panels = [
FieldPanel('link_external'),
PageChooserPanel('link_page'),
]
class Meta:
abstract = True
class NewsletterArticleLink(Orderable, models.Model):
article = models.ForeignKey("wagtailcore.Page",
null=True,
blank=True,
on_delete=models.SET_NULL,
related_name='+',
help_text="Link to an internal article")
override_text = RichTextField(blank=True,
default="",
help_text="Text to describe article.")
override_image = models.ForeignKey(
'images.AttributedImage',
null=True,
blank=True,
on_delete=models.SET_NULL,
related_name='+',
help_text=
"Circular Image to accompany article if article image not selected")
newsletter = ParentalKey("NewsletterPage", related_name='article_links')
def __str__(self):
return "{}".format(self.article.title)
panels = [
PageChooserPanel("article",
['articles.ArticlePage', 'articles.SeriesPage']),
FieldPanel("override_text"),
ImageChooserPanel("override_image"),
]
class PreviewArticle(Orderable):
page = ParentalKey('HomePage', related_name='preview_articles')
article = models.ForeignKey(ArticlePage)
panels = [
PageChooserPanel('article'),
]
class RecordPage(ContentPage):
date = models.DateField(default=datetime.date.today)
category = models.CharField(max_length=255,
choices=constants.record_page_categories.items())
read_next = models.ForeignKey('RecordPage', blank=True, null=True,
default=get_previous_record_page,
on_delete=models.SET_NULL)
related_section_title = models.CharField(max_length=255, blank=True,
default="Explore campaign finance data")
related_section_url = models.CharField(max_length=255, blank=True,
default="/data/")
content_panels = ContentPage.content_panels + [
FieldPanel('date'),
FieldPanel('category'),
InlinePanel('authors', label="Authors"),
PageChooserPanel('read_next'),
FieldPanel('related_section_title'),
FieldPanel('related_section_url'),
]
@property
def content_section(self):
return ''
@property
def get_update_type(self):
return constants.update_types['fec-record']
class TestPageChooserPanel(TestCase):
def setUp(self):
model = PageChooserModel
self.chosen_page = Page.objects.get(pk=2)
test_instance = model.objects.create(page=self.chosen_page)
self.dotted_model = model._meta.app_label + '.' + model._meta.model_name
self.page_chooser_panel_class = PageChooserPanel('page', model)
form_class = get_form_for_model(model, widgets=self.page_chooser_panel_class.widget_overrides())
form = form_class(instance=test_instance)
form.errors['page'] = form.error_class(['errors'])
self.page_chooser_panel = self.page_chooser_panel_class(instance=test_instance,
form=form)
def test_render_js_init(self):
result = self.page_chooser_panel.render_as_field()
self.assertIn(
'createPageChooser("{id}", "{model}", {parent});'.format(
id="id_page", model=self.dotted_model, parent=self.chosen_page.get_parent().id),
result)
def test_get_chosen_item(self):
result = self.page_chooser_panel.get_chosen_item()
self.assertEqual(result, self.chosen_page)
def test_render_as_field(self):
result = self.page_chooser_panel.render_as_field()
self.assertIn('<p class="help">help text</p>', result)
self.assertIn('<span>errors</span>', result)
def test_widget_overrides(self):
result = self.page_chooser_panel.widget_overrides()
self.assertIsInstance(result['page'], AdminPageChooser)
def test_target_content_type(self):
result = PageChooserPanel(
'barbecue',
'wagtailcore.site'
).target_content_type()
self.assertEqual(result.name, 'site')
def test_target_content_type_malformed_type(self):
result = PageChooserPanel(
'barbecue',
'snowman'
)
self.assertRaises(ImproperlyConfigured,
result.target_content_type)
def test_target_content_type_nonexistent_type(self):
result = PageChooserPanel(
'barbecue',
'snowman.lorry'
)
self.assertRaises(ImproperlyConfigured,
result.target_content_type)
def setUp(self):
model = PageChooserModel
self.chosen_page = Page.objects.get(pk=2)
test_instance = model.objects.create(page=self.chosen_page)
self.dotted_model = model._meta.app_label + '.' + model._meta.model_name
self.page_chooser_panel_class = PageChooserPanel('page', model)
form_class = get_form_for_model(model, widgets=self.page_chooser_panel_class.widget_overrides())
form = form_class(instance=test_instance)
form.errors['page'] = form.error_class(['errors'])
self.page_chooser_panel = self.page_chooser_panel_class(instance=test_instance,
form=form)
def setUp(self):
model = PageChooserModel # a model with a foreign key to Page which we want to render as a page chooser
# a PageChooserPanel class that works on PageChooserModel's 'page' field
self.MyPageChooserPanel = PageChooserPanel('page').bind_to_model(PageChooserModel)
# build a form class containing the fields that MyPageChooserPanel wants
self.PageChooserForm = self.MyPageChooserPanel.get_form_class(PageChooserModel)
# a test instance of PageChooserModel, pointing to the 'christmas' page
self.christmas_page = Page.objects.get(slug='christmas')
self.events_index_page = Page.objects.get(slug='events')
self.test_instance = model.objects.create(page=self.christmas_page)
self.form = self.PageChooserForm(instance=self.test_instance)
self.page_chooser_panel = self.MyPageChooserPanel(instance=self.test_instance, form=self.form)
def setUp(self):
fake_field = self.FakeField()
fake_instance = self.FakeInstance()
self.page_chooser_panel = PageChooserPanel('barbecue')(
instance=fake_instance,
form={'barbecue': fake_field})
class TestPageChooserPanel(TestCase):
class FakeField(object):
label = 'label'
help_text = 'help text'
errors = ['errors']
id_for_label = 'id for label'
class FakeInstance(object):
class FakePage(object):
class FakeParent(object):
id = 1
name = 'fake page'
def get_parent(self):
return self.FakeParent()
def __init__(self):
fake_page = self.FakePage()
self.barbecue = fake_page
def setUp(self):
fake_field = self.FakeField()
fake_instance = self.FakeInstance()
self.page_chooser_panel = PageChooserPanel('barbecue')(
instance=fake_instance,
form={'barbecue': fake_field})
def test_render_js(self):
result = self.page_chooser_panel.render_js()
self.assertEqual(result,
"createPageChooser(fixPrefix('id for label'), 'wagtailcore.page', 1);")
def test_get_chosen_item(self):
result = self.page_chooser_panel.get_chosen_item()
self.assertEqual(result.name, 'fake page')
def test_render_as_field(self):
result = self.page_chooser_panel.render_as_field()
self.assertIn('<p class="help">help text</p>', result)
self.assertIn('<span>errors</span>', result)
def test_widget_overrides(self):
result = self.page_chooser_panel.widget_overrides()
self.assertEqual(result, {'barbecue': HiddenInput})
def test_target_content_type(self):
result = PageChooserPanel(
'barbecue',
'wagtailcore.site'
).target_content_type()
self.assertEqual(result.name, 'site')
def test_target_content_type_malformed_type(self):
result = PageChooserPanel(
'barbecue',
'snowman'
)
self.assertRaises(ImproperlyConfigured,
result.target_content_type)
def test_target_content_type_nonexistent_type(self):
result = PageChooserPanel(
'barbecue',
'snowman.lorry'
)
self.assertRaises(ImproperlyConfigured,
result.target_content_type)
class TestPageChooserPanel(TestCase):
fixtures = ['test.json']
def setUp(self):
model = PageChooserModel # a model with a foreign key to Page which we want to render as a page chooser
# a PageChooserPanel class that works on PageChooserModel's 'page' field
self.MyPageChooserPanel = PageChooserPanel('page').bind_to_model(PageChooserModel)
# build a form class containing the fields that MyPageChooserPanel wants
self.PageChooserForm = self.MyPageChooserPanel.get_form_class(PageChooserModel)
# a test instance of PageChooserModel, pointing to the 'christmas' page
self.christmas_page = Page.objects.get(slug='christmas')
self.events_index_page = Page.objects.get(slug='events')
self.test_instance = model.objects.create(page=self.christmas_page)
self.form = self.PageChooserForm(instance=self.test_instance)
self.page_chooser_panel = self.MyPageChooserPanel(instance=self.test_instance, form=self.form)
def test_page_chooser_uses_correct_widget(self):
self.assertEqual(type(self.form.fields['page'].widget), AdminPageChooser)
def test_render_js_init(self):
result = self.page_chooser_panel.render_as_field()
expected_js = 'createPageChooser("{id}", "{model}", {parent});'.format(
id="id_page", model="wagtailcore.page", parent=self.events_index_page.id)
self.assertIn(expected_js, result)
def test_get_chosen_item(self):
result = self.page_chooser_panel.get_chosen_item()
self.assertEqual(result, self.christmas_page)
def test_render_as_field(self):
result = self.page_chooser_panel.render_as_field()
self.assertIn('<p class="help">help text</p>', result)
self.assertIn('<span class="title">Christmas</span>', result)
self.assertIn(
'<a href="/admin/pages/%d/edit/" class="edit-link button button-small button-secondary" target="_blank">Edit this page</a>' % self.christmas_page.id,
result)
def test_render_error(self):
form = self.PageChooserForm({'page': ''}, instance=self.test_instance)
self.assertFalse(form.is_valid())
page_chooser_panel = self.MyPageChooserPanel(instance=self.test_instance, form=form)
self.assertIn('<span>This field is required.</span>', page_chooser_panel.render_as_field())
def test_override_page_type(self):
# Model has a foreign key to Page, but we specify EventPage in the PageChooserPanel
# to restrict the chooser to that page type
MyPageChooserPanel = PageChooserPanel('page', 'tests.EventPage').bind_to_model(EventPageChooserModel)
PageChooserForm = MyPageChooserPanel.get_form_class(EventPageChooserModel)
form = PageChooserForm(instance=self.test_instance)
page_chooser_panel = self.MyPageChooserPanel(instance=self.test_instance, form=form)
result = page_chooser_panel.render_as_field()
expected_js = 'createPageChooser("{id}", "{model}", {parent});'.format(
id="id_page", model="tests.eventpage", parent=self.events_index_page.id)
self.assertIn(expected_js, result)
def test_autodetect_page_type(self):
# Model has a foreign key to EventPage, which we want to autodetect
# instead of specifying the page type in PageChooserPanel
MyPageChooserPanel = PageChooserPanel('page').bind_to_model(EventPageChooserModel)
PageChooserForm = MyPageChooserPanel.get_form_class(EventPageChooserModel)
form = PageChooserForm(instance=self.test_instance)
page_chooser_panel = self.MyPageChooserPanel(instance=self.test_instance, form=form)
result = page_chooser_panel.render_as_field()
expected_js = 'createPageChooser("{id}", "{model}", {parent});'.format(
id="id_page", model="tests.eventpage", parent=self.events_index_page.id)
self.assertIn(expected_js, result)
def test_target_content_type(self):
result = PageChooserPanel(
'barbecue',
'wagtailcore.site'
).bind_to_model(PageChooserModel).target_content_type()
self.assertEqual(result.name, 'site')
def test_target_content_type_malformed_type(self):
result = PageChooserPanel(
'barbecue',
'snowman'
).bind_to_model(PageChooserModel)
self.assertRaises(ImproperlyConfigured,
result.target_content_type)
def test_target_content_type_nonexistent_type(self):
result = PageChooserPanel(
'barbecue',
'snowman.lorry'
).bind_to_model(PageChooserModel)
self.assertRaises(ImproperlyConfigured,
result.target_content_type)
