def test_netutils_filters_in_jinja(self):
"""Import the list of all Jinja filters from Netutils and validate that all of them have been properly loaded in Django Jinja"""
filters = jinja2_convenience_function()
for filter in filters.keys():
try:
render_jinja2("{{ data | " + filter + " }}", {"data": None})
except TemplateAssertionError:
raise
except Exception:
self.assertTrue(True)
def render(self, context):
try:
return render_jinja2(self.template, context)
except TemplateError as e:
logger.warning("Failed to render computed field %s: %s", self.slug,
e)
return self.fallback_value
def render_body(self, context):
"""
Render the body template, if defined. Otherwise, jump the context as a JSON object.
"""
if self.body_template:
return render_jinja2(self.body_template, context)
else:
return json.dumps(context, cls=JSONEncoder)
def render(self, queryset):
"""
Render the contents of the template.
"""
context = {"queryset": queryset}
output = render_jinja2(self.template_code, context)
# Replace CRLF-style line terminators
output = output.replace("\r\n", "\n")
return output
def rendered_parameters(self, obj=None):
"""Render self.parameters as a Jinja2 template with the given object as context."""
try:
return {
key: render_jinja2(value, {"obj": obj})
for key, value in self.parameters.items()
}
except (TemplateSyntaxError, UndefinedError) as exc:
raise SecretParametersError(
self, registry["secrets_providers"].get(self.provider),
str(exc)) from exc
def render_headers(self, context):
"""
Render additional_headers and return a dict of Header: Value pairs.
"""
if not self.additional_headers:
return {}
ret = {}
data = render_jinja2(self.additional_headers, context)
for line in data.splitlines():
header, value = line.split(":")
ret[header.strip()] = value.strip()
return ret
def render(self, context):
try:
rendered = render_jinja2(self.template, context)
# If there is an undefined variable within a template, it returns nothing
# Doesn't raise an exception either most likely due to using Undefined rather
# than StrictUndefined, but return fallback_value if None is returned
if rendered is None:
logger.warning("Failed to render computed field %s", self.slug)
return self.fallback_value
return rendered
except Exception as exc:
logger.warning("Failed to render computed field %s: %s", self.slug,
exc)
return self.fallback_value
def test_templatetags_helpers_in_jinja(self):
"""
Only validate that all templatetags helpers have been properly registered as Django Jinja
no need to check the returned value since we already have some unit tests for that
"""
helpers_to_validate = [
"placeholder",
"render_json",
"render_yaml",
"render_markdown",
"meta",
"viewname",
"validated_viewname",
"bettertitle",
"humanize_speed",
"tzoffset",
"fgcolor",
"divide",
"percentage",
"get_docs_url",
"has_perms",
"has_one_or_more_perms",
"split",
"as_range",
"meters_to_feet",
"get_item",
]
# For each helper, try to render a jinja template with render_jinja2 and fail if TemplateAssertionError is raised
for helper in helpers_to_validate:
try:
render_jinja2("{{ data | " + helper + " }}", {"data": None})
except TemplateAssertionError:
raise
except Exception:
self.assertTrue(True)
def render_jinja_template(obj, logger, template):
"""
Helper function to render Jinja templates.
Args:
obj (Device): The Device object from Nautobot.
logger (NornirLogger): Logger to log error messages to.
template (str): A Jinja2 template to be rendered.
Returns:
str: The ``template`` rendered.
Raises:
NornirNautobotException: When there is an error rendering the ``template``.
"""
try:
return render_jinja2(template_code=template, context={"obj": obj})
except jinja_errors.UndefinedError as error:
error_msg = (
"Jinja encountered and UndefinedError`, check the template for missing variable definitions.\n"
f"Template:\n{template}"
)
logger.log_failure(obj, error_msg)
raise NornirNautobotException from error
except jinja_errors.TemplateSyntaxError as error: # Also catches subclass of TemplateAssertionError
error_msg = (
f"Jinja encountered a SyntaxError at line number {error.lineno},"
f"check the template for invalid Jinja syntax.\nTemplate:\n{template}"
)
logger.log_failure(obj, error_msg)
raise NornirNautobotException from error
# Intentionally not catching TemplateNotFound errors since template is passes as a string and not a filename
except jinja_errors.TemplateError as error: # Catches all remaining Jinja errors
error_msg = (
"Jinja encountered an unexpected TemplateError; check the template for correctness\n"
f"Template:\n{template}"
)
logger.log_failure(error_msg)
raise NornirNautobotException from error
