def test_edit_accordion_group(rf, admin_site, bootstrap_accordion):
request = rf.get('/')
accordion_plugin, accordion_model = bootstrap_accordion
first_group = accordion_model.get_first_child()
group_model, group_plugin = first_group.get_plugin_instance(admin_site)
data = {'heading': "Hello", 'body_padding': 'on'}
ModelForm = group_plugin.get_form(request, group_model)
form = ModelForm(data, None, instance=group_model)
assert form.is_valid()
group_plugin.save_model(request, group_model, form, False)
assert group_model.glossary['heading'] == "Hello"
assert group_model.glossary['body_padding'] is True
# render the plugin
build_plugin_tree([accordion_model, group_model])
context = RequestContext(request)
content_renderer = ContentRenderer(request)
html = content_renderer.render_plugin(accordion_model, context).strip()
html = html.replace('\n', '').replace('\t', '')
expected = """<div id="cmsplugin_{accordion_id}" class="accordion"><div class="card">
<div class="card-header" id="heading_{group_id}"><h5 class="mb-0">
<button class="btn btn-link" type="button" data-toggle="collapse" data-target="#collapse_{group_id}" aria-expanded="true" aria-controls="collapse_{group_id}">
Hello</button></h5></div>
<div id="collapse_{group_id}" class="collapse" aria-labelledby="heading_{group_id}" data-parent="#cmsplugin_{accordion_id}">
<div class="card-body"></div></div></div></div>""".format(
accordion_id=accordion_model.id, group_id=group_model.id)
expected = expected.replace('\n', '').replace('\t', '')
assert html == expected
def test_plugin_icon(self):
icon_widget = IconFieldWidget()
self.assertTrue(isinstance(icon_widget.get_fontawesome_icons, list),
"Could not get Fontawesome icon list")
self.assertGreaterEqual(len(icon_widget.get_fontawesome_icons), 0,
"Could not get any Fontawesome icons")
data = {'icon': 'fab fa-bible'}
placeholder = Placeholder.objects.create(slot='content')
model_instance = add_plugin(placeholder, IconPlugin, 'en', data=data)
plugin_instance = model_instance.get_plugin_class_instance()
context = plugin_instance.render({}, model_instance, None)
self.assertDictEqual(data, context['instance']._json,
"_json field data is not as expected")
renderer = ContentRenderer(request=RequestFactory())
html = renderer.render_plugin(model_instance, {})
test_context = {'instance': {'glossary': data}}
test_html = render_to_string(template_name=IconPlugin.render_template,
context=test_context,
request=RequestFactory())
self.assertHTMLEqual(test_html, html,
"Rendered HTML differs from what it should be")
def test_cms_plugin_renders_in_cms_page(rf):
fd = FormDefinition.objects.create(
mail_to='*****@*****.**',
mail_subject='Someone sent you a greeting: {{ test }}'
)
field = FormDefinitionField.objects.create(
form_definition=fd,
name='test',
label=get_random_string(),
field_class='django.forms.CharField',
)
page = api.create_page("test", "page.html", "en")
assert isinstance(page, Page)
ph = page.get_placeholders()[0]
assert isinstance(ph, Placeholder)
plugin = api.add_plugin(ph, FormDesignerPlugin, "en", form_definition=fd)
assert isinstance(plugin, CMSFormDefinition)
assert plugin.form_definition == fd
request = rf.get("/")
request.user = AnonymousUser()
request.current_page = page
if CMS_VERSION >= Ver('3.4'):
from cms.plugin_rendering import ContentRenderer
renderer = ContentRenderer(request)
context = RequestContext(request)
context['request'] = request
content = renderer.render_plugin(plugin, context)
else:
from cms.page_rendering import render_page
response = render_page(request, page, "fi", "test")
response.render()
content = response.content.decode("utf8")
assert field.label in content
assert "<form" in content
def item_description(self, item):
if not item.lead_in:
request = get_request()
c = ContentRenderer(request)
html = c.render_placeholder(item.content, RequestContext(request))
return remove_control_characters(html)
return item.lead_in
def get_rendered_plugin(self, obj):
from cms.plugin_rendering import ContentRenderer
request = self._context.request
renderer = ContentRenderer(request)
# Avoid errors if plugin require a request object
# when rendering.
return renderer.render_plugin(obj, self.context)
def test_cms_plugin_renders_in_cms_page(rf):
fd = FormDefinition.objects.create(
mail_to='*****@*****.**',
mail_subject='Someone sent you a greeting: {{ test }}')
field = FormDefinitionField.objects.create(
form_definition=fd,
name='test',
label=get_random_string(),
field_class='django.forms.CharField',
)
page = api.create_page("test", "page.html", "en")
assert isinstance(page, Page)
ph = page.get_placeholders()[0]
assert isinstance(ph, Placeholder)
plugin = api.add_plugin(ph, FormDesignerPlugin, "en", form_definition=fd)
assert isinstance(plugin, CMSFormDefinition)
assert plugin.form_definition == fd
request = rf.get("/")
request.user = AnonymousUser()
request.current_page = page
if CMS_VERSION >= Ver('3.4'):
from cms.plugin_rendering import ContentRenderer
renderer = ContentRenderer(request)
context = RequestContext(request)
context['request'] = request
content = renderer.render_plugin(plugin, context)
else:
from cms.page_rendering import render_page
response = render_page(request, page, "fi", "test")
response.render()
content = response.content.decode("utf8")
assert field.label in content
assert "<form" in content
def placeholder_html(placeholder, request, language):
if hasattr(placeholder, '_plugins_cache'):
del placeholder._plugins_cache
context = SekizaiContext({'request': request})
renderer = ContentRenderer(request)
return renderer.render_placeholder(placeholder, context,
language=language).strip()
def test_large_banner_no_background_image(self):
"""
Instanciating this plugin with an instance but no background image should render
a default image in the html.
The default image is defined as background image in the CSS.
"""
placeholder = Placeholder.objects.create(slot="test")
# Create random values for parameters with a factory
large_banner = LargeBannerFactory(background_image=None)
fields_list = ["title", "background_image", "logo", "logo_alt_text"]
model_instance = add_plugin(
placeholder,
LargeBannerPlugin,
"en",
**{field: getattr(large_banner, field) for field in fields_list}
)
# Get the generated html
renderer = ContentRenderer(request=RequestFactory())
html = renderer.render_plugin(model_instance, {})
# Check that all expected elements are in the html
self.assertIn('class="large-banner"', html)
self.assertFalse('class="large-banner__background"' in html)
def test_cms_plugins_organization_render_context_variant(self):
"""
The organization plugin should render according to variant variable
eventually present in the context of its container.
"""
# Create an blogpost
organization = OrganizationFactory(page_title="public title")
organization_page = organization.extended_object
# Create a page to add the plugin to
page = create_i18n_page("A page")
placeholder = page.placeholders.get(slot="maincontent")
# Add blogpost plugin with default template
model_instance = add_plugin(
placeholder,
OrganizationPlugin,
"en",
page=organization_page,
variant="small",
)
# Get generated html
request = RequestFactory()
request.current_page = page
request.user = AnonymousUser()
context = {
"current_page": page,
"organization_variant": "xxl",
"request": request,
}
renderer = ContentRenderer(request=request)
html = renderer.render_plugin(model_instance, context)
self.assertIn("organization-small", html)
def test_cms_plugins_lti_consumer_context_and_html(self):
"""
Instanciating this plugin with an instance should populate the context
and render in the template.
"""
placeholder = Placeholder.objects.create(slot="test")
lti_consumer = LTIConsumerFactory()
model_instance = add_plugin(
placeholder,
LTIConsumerPlugin,
"en",
url=lti_consumer.url,
lti_provider_id=lti_consumer.lti_provider_id,
)
plugin_instance = model_instance.get_plugin_class_instance()
context = plugin_instance.render({}, model_instance, None)
# Check if instance is in context
self.assertEqual(model_instance, context["instance"])
# Get generated html for LTI consumer url
renderer = ContentRenderer(request=RequestFactory())
html = renderer.render_plugin(model_instance, {})
# Check rendered url is correct after save and sanitize
self.assertIn(lti_consumer.url, html)
self.assertIn("student", html)
def test_cms_plugins_blogpost_cascade_variant(self):
"""
If the variant is not specified on the blogpost plugin, it should render
according to variant variable eventually present in the context of its
container.
"""
# Create an blogpost
blogpost = BlogPostFactory(page_title="public title",
should_publish=True)
blogpost_page = blogpost.extended_object
# Create a page to add the plugin to
page = create_i18n_page("A page")
placeholder = page.placeholders.get(slot="maincontent")
# Add blogpost plugin with default template
model_instance = add_plugin(placeholder,
BlogPostPlugin,
"en",
page=blogpost_page)
# Get generated html
request = RequestFactory()
request.current_page = page
request.path_info = "/en/my-path/"
request.user = AnonymousUser()
context = {
"current_page": page,
"blogpost_variant": "xxl",
"request": request
}
renderer = ContentRenderer(request=request)
html = renderer.render_plugin(model_instance, context)
self.assertIn("blogpost-xxl", html)
def test_cms_plugins_simpletext_context_and_html(self):
"""
Instanciating this plugin with an instance should populate the context
and render in the template.
"""
placeholder = Placeholder.objects.create(slot="test")
# Create random values for parameters with a factory
simpletext = SimpleTextFactory()
model_instance = add_plugin(placeholder,
CKEditorPlugin,
"en",
body=simpletext.body)
plugin_instance = model_instance.get_plugin_class_instance()
context = plugin_instance.render({}, model_instance, None)
# Check if "instance" is in context
self.assertIn("instance", context)
# Check if parameters, generated by the factory, are correctly set in "instance" of context
self.assertEqual(context["instance"].body, simpletext.body)
# Get generated html for simpletext body
renderer = ContentRenderer(request=RequestFactory())
html = renderer.render_plugin(model_instance, {})
# Check rendered body is correct after save and sanitize
self.assertInHTML(simpletext.body, html)
def test_plugin_bem_classes_applied(self):
"""
test if BEM style classes are applied to this plugins output
:return:
"""
placeholder = Placeholder.objects.create(slot='test')
data = {
'anchor': 'anchor-value',
'layout': 'layout-value',
'color': 'color-value',
'background': 'background-value',
}
data.update(self.get_plugin_default_data())
model_instance = add_plugin(
placeholder,
self.plugin_class,
'en',
**data
)
renderer = ContentRenderer(request=RequestFactory())
html = renderer.render_plugin(model_instance, {})
plugin_name = model_instance.__class__.__name__.lower()
self.assertIn('plugin_{}'.format(model_instance.pk), force_text(html))
self.assertIn('plugin-{}'.format(plugin_name), force_text(html))
self.assertIn('plugin-{}_{}'.format(plugin_name, 'layout-value'), force_text(html))
self.assertIn('plugin-{}_{}'.format(plugin_name, 'color-value'), force_text(html))
self.assertIn('plugin-{}_{}'.format(plugin_name, 'background-value'), force_text(html))
self.assertIn('plugin-{}_anchor-{}'.format(plugin_name, 'anchor-value'), force_text(html))
def test_edit_bootstrap_row(rf, bootstrap_row):
row_plugin, row_model = bootstrap_row
request = rf.get('/')
ModelForm = row_plugin.get_form(request, row_model)
data = {'num_children': 3}
form = ModelForm(data, None, instance=row_model)
assert form.is_valid()
row_plugin.save_model(request, row_model, form, False)
container_model, container_plugin = row_model.parent.get_plugin_instance()
plugin_list = [container_model, row_model]
# we now should have three columns attached to the row
assert row_model.get_descendant_count() == 3
for cms_plugin in row_model.get_descendants():
column_model, column_plugin = cms_plugin.get_plugin_instance()
assert isinstance(column_model, CascadeElement)
assert isinstance(column_plugin, BootstrapColumnPlugin)
assert column_model.parent.id == row_model.id
plugin_list.append(column_model)
# change data inside the first column
cms_plugin = row_model.get_descendants().first()
column_model, column_plugin = cms_plugin.get_plugin_instance()
data = {
'xs-column-width': 'col',
'sm-column-offset': 'offset-sm-1',
'sm-column-width': 'col-sm-3'
}
ModelForm = column_plugin.get_form(request, column_model)
form = ModelForm(data, None, instance=column_model)
assert form.is_valid()
column_plugin.save_model(request, column_model, form, True)
# change data inside the last column
cms_plugin = row_model.get_descendants().last()
column_model, column_plugin = cms_plugin.get_plugin_instance()
data = {
'xs-column-width': 'col',
'sm-responsive-utils': 'hidden-sm',
'sm-column-width': 'col-sm-4'
}
ModelForm = column_plugin.get_form(request, column_model)
form = ModelForm(data, None, instance=column_model)
assert form.is_valid()
column_plugin.save_model(request, column_model, form, False)
# render the plugin and check the output
context = {
'request': request,
}
content_renderer = ContentRenderer(request)
row_model.parent.child_plugin_instances
for plugin in plugin_list:
plugin.refresh_from_db()
build_plugin_tree(plugin_list)
html = content_renderer.render_plugin(container_model, context)
html = strip_spaces_between_tags(html).strip()
assert html == '<div class="container"><div class="row"><div class="col col-sm-3 offset-sm-1">' \
'</div><div class="col"></div><div class="col col-sm-4 hidden-sm"></div></div></div>'
def test_simple_icon(rf, simple_icon):
"""Render a SimpleIconPlugin"""
simple_icon_plugin, simple_icon_model = simple_icon
request = rf.get('/')
context = RequestContext(request)
content_renderer = ContentRenderer(request)
html = content_renderer.render_plugin(simple_icon_model, context).strip()
assert html == '<i class="icon-icon-skiing"></i>'
def render_plugin(self, instance):
context = RequestContext(self.request, {'request': self.request})
if get_cms_version() >= (3, 4):
renderer = ContentRenderer(request=self.request)
return renderer.render_plugin(instance, context)
else:
return instance.render_plugin(context)
def _render_via_cms():
from cms.plugin_rendering import ContentRenderer
renderer = ContentRenderer(request)
context = RequestContext(request)
# Avoid errors if plugin require a request object
# when rendering.
context['request'] = request
return renderer.render_plugin(plugin, context)
def _render_via_cms():
from cms.plugin_rendering import ContentRenderer
renderer = ContentRenderer(request)
context = RequestContext(request)
# Avoid errors if plugin require a request object
# when rendering.
context['request'] = request
return renderer.render_plugin(plugin, context)
def test_plugin_html(self):
placeholder = Placeholder.objects.create(slot='test')
model_instance = add_plugin(placeholder, self.plugin_class, 'en', **{
'body': '<strong>Test</strong>',
})
renderer = ContentRenderer(request=RequestFactory())
html = renderer.render_plugin(model_instance, {})
self.assertInHTML('<strong>Test</strong>', force_text(html))
def render_placeholder(placeholder, request):
"""
See http://docs.django-cms.org/en/develop/upgrade/3.4.html#manual-plugin-rendering
"""
renderer = ContentRenderer(request)
context = RequestContext(request)
context['request'] = request
content = renderer.render_placeholder(placeholder, context=context)
return content
def test_cms_plugins_htmlsitemap_no_children(self):
"""An HTML sitemap plugin without any children should render an empty sitemap."""
placeholder = Placeholder.objects.create(slot="maincontent")
model_instance = add_plugin(placeholder, HTMLSitemapPlugin, "en")
renderer = ContentRenderer(request=RequestFactory())
html = renderer.render_plugin(model_instance, {})
self.assertHTMLEqual(html, '<div class="sitemap"></div>')
def test_plugin_html(self):
placeholder = Placeholder.objects.create(slot='test')
model_instance = add_plugin(placeholder,
IconPlugin,
'en',
icon='fa-bath')
renderer = ContentRenderer(request=RequestFactory())
html = renderer.render_plugin(model_instance, {})
self.assertEqual(html, '<i class="fa fa-bath"></i>')
def test_plugin_html(self):
placeholder = Placeholder.objects.create(slot='test')
model_instance = add_plugin(
placeholder,
MyPlugin,
'en',
)
renderer = ContentRenderer(request=RequestFactory())
html = renderer.render_plugin(model_instance, {})
self.assertEqual(html, '<strong>Test</strong>')
def test_plugin_html(self):
placeholder = Placeholder.objects.create(slot='test')
model_instance = add_plugin(
placeholder,
HelloWorldPluginBase,
'en',
)
renderer = ContentRenderer(request=RequestFactory())
html = renderer.render_plugin(model_instance, {})
self.assertEqual(html, '<p>Hello world!</p>')
def get_rendered(self, obj):
from django.template import RequestContext
from cms.plugin_rendering import ContentRenderer
request = self._context.get('request', {})
renderer = ContentRenderer(request)
context = RequestContext(request)
# Avoid errors if plugin require a request object
# when rendering.
context['request'] = request
return renderer.render_plugin(obj, context)
def render(self, request):
context = Context({"request": request})
from cms.plugin_rendering import ContentRenderer
renderer = ContentRenderer(request)
return renderer.render_plugin(
instance=self,
context=context,
placeholder=self.placeholder,
)
def render_placeholder(context, placeholder, use_cache=False):
request = context.get("request")
if request is None:
return ""
renderer = ContentRenderer(request=request)
content = renderer.render_placeholder(placeholder,
context=context,
nodelist=None,
editable=False,
use_cache=use_cache)
return content
def test_plugin_html(self):
placeholder = Placeholder.objects.create(slot='content')
model_instance = add_plugin(
placeholder,
PlaintextPlugin,
self.language,
body=self.plaintext_body,
)
renderer = ContentRenderer(request=RequestFactory())
html = renderer.render_plugin(model_instance, {})
self.assertEqual(html, self.plaintext_body)
def render(self, request):
context = Context({'request': request})
try:
from cms.plugin_rendering import ContentRenderer
renderer = ContentRenderer(request)
return renderer.render_plugin(
instance=self,
context=context,
placeholder=self.placeholder,
)
except ImportError:
return self.render_plugin(context)
def render_placeholder(context, placeholder, use_cache=False):
request = context.get('request')
if request is None:
return ''
renderer = ContentRenderer(request=request)
content = renderer.render_placeholder(
placeholder,
context=context,
nodelist=None,
editable=False,
use_cache=use_cache
)
return content
def test_plugin_html(self):
placeholder = Placeholder.objects.create(slot='test')
model_instance = add_plugin(
placeholder,
SlickSliderPlugin,
'de'
)
model_instance.copy_relations(self.slider)
renderer = ContentRenderer(request=RequestFactory())
from sekizai.context import SekizaiContext
html = renderer.render_plugin(model_instance, SekizaiContext())
self.assertIn('class="slider-wrapper"', html)
self.assertIn('id="slider-%s' % model_instance.id, html)
def plain_text(self):
"""
Renders all the plaintext plugins from the placeholder field
"""
# We need to use this weird ContentRenderer in order to render the plugins
renderer = ContentRenderer(request=RequestFactory())
text = ""
for plugin in self.content.cmsplugin_set.all():
html = renderer.render_plugin(plugin, {})
text += strip_tags(html)
return text.strip()
def test_cms_plugins_lti_consumer_context_and_html(self):
"""
Instanciating this plugin with an instance should render the template.
"""
placeholder = Placeholder.objects.create(slot="test")
url = "http://localhost:8060/lti/videos/"
resizing = random.choice([True, False])
edit = random.choice([True, False])
lti_providers = {
"lti_provider_test": {
"base_url": "http://localhost:8060/lti/videos/",
"is_base_url_regex": False,
"automatic_resizing": resizing,
"inline_ratio": 0.3312,
"oauth_consumer_key": "TestOauthConsumerKey",
"shared_secret": "TestSharedSecret",
}
}
request = RequestFactory()
request.user = AnonymousUser()
request.session = {}
request.path = "/"
request.toolbar = CMSToolbar(request)
request.toolbar.edit_mode_active = edit
global_context = {"request": request}
model_instance = add_plugin(
placeholder,
LTIConsumerPlugin,
"en",
url=url,
lti_provider_id="lti_provider_test",
)
plugin_instance = model_instance.get_plugin_class_instance()
# Check context
with override_settings(RICHIE_LTI_PROVIDERS=lti_providers):
context = plugin_instance.render(global_context, model_instance,
None)
self.assertEqual(context["instance"], model_instance)
renderer = ContentRenderer(request=request)
with override_settings(RICHIE_LTI_PROVIDERS=lti_providers):
html = renderer.render_plugin(model_instance, global_context)
self.assertIn(str(model_instance.pk), html)
self.assertIn('style="padding-bottom: 33.12%"', html)
def _get_value(self, context, editable=True, **kwargs):
renderer = ContentRenderer(context['request'])
placeholder = kwargs.get('placeholder')
if not placeholder:
return ''
if isinstance(placeholder, string_types):
placeholder = Placeholder.objects.get(slot=placeholder)
content = renderer.render_placeholder(
placeholder=placeholder,
context=context,
language=kwargs.get('language'),
editable=editable,
use_cache=False,
width=kwargs.get('width'),
)
return strip_tags(content).replace('\n', '').replace('\t', '')
def _render(self, instance):
context = SekizaiContext()
context['request'] = self.request
try:
# django CMS 3.4+
from cms.plugin_rendering import ContentRenderer
renderer = ContentRenderer(self.request)
context['cms_content_renderer'] = renderer
rendered = renderer.render_placeholder(
instance, context, language=self.language, editable=False
)
except ImportError:
# django CMS 3.3 and below
from cms.plugin_rendering import render_placeholder
rendered = render_placeholder(
instance, context, lang=self.language, editable=False
)
flat = flatten_context(context)
return rendered.strip(), flat
def render_plugin_preview(context, plugin):
request = context['request']
if LTE_CMS_3_3:
return plugin.render_plugin(context)
try:
content_renderer = request.toolbar.content_renderer
except AttributeError:
from cms.plugin_rendering import ContentRenderer
content_renderer = ContentRenderer(request)
content = content_renderer.render_plugin(
instance=plugin,
context=context,
editable=False,
)
return content
def render_plugin(request, plugin_instance):
renderer = ContentRenderer(request)
context = {'request': request}
return renderer.render_plugin(plugin_instance, context)
