def parse(cls, parser, token: Token):
# here is how split_contents() works:
# {% formfield player.f1 label="f1 label" %}
# ...yields:
# ['formfield', 'player.f1', 'label="f1 label"']
# {% formfield player.f2 "f2 label with no kwarg" %}
# ...yields:
# ['formfield', 'player.f2', '"f2 label with no kwarg"']
# handle where the user did {% formfield player.f label = "foo" %}
token.contents = token.contents.replace('label = ', 'label=')
bits = token.split_contents()
tagname = bits.pop(0)
if len(bits) < 1:
raise TemplateSyntaxError(f"{tagname} requires the name of the field.")
field_name = bits.pop(0)
if bits[:1] == ['with']:
bits.pop(0)
arg_dict = token_kwargs(bits, parser, support_legacy=False)
if bits:
raise TemplateSyntaxError(f'Unused parameter to formfield tag: {bits[0]}')
return cls(field_name, **arg_dict)
def test_base_repr(self):
"""
Test whether repr shows some meaningful output (both with compile and non-compile)
"""
class ArgsTest1(BaseNode):
max_args = 2
allowed_kwargs = ("kw", )
class ArgsTest2(BaseNode):
max_args = 2
allowed_kwargs = ("kw", )
compile_kwargs = False
node = ArgsTest1.parse(
parser=_get_parser(),
token=Token(TOKEN_TEXT, 'ArgsTest 1 2 kw=foo|default:"1" '),
)
self.assertEqual(repr(node),
'<ArgsTest1: {% ArgsTest 1 2 kw=foo|default:"1" %}>')
node = ArgsTest2.parse(
parser=_get_parser(),
token=Token(TOKEN_TEXT, 'ArgsTest 1 2 kw=foo|default:"1" '),
)
self.assertEqual(repr(node),
'<ArgsTest2: {% ArgsTest 1 2 kw=foo|default:"1" %}>')
def test_token_smart_split(self):
"""
#7027 -- _() syntax should work with spaces
"""
token = Token(TokenType.BLOCK, 'sometag _("Page not found") value|yesno:_("yes,no")')
split = token.split_contents()
self.assertEqual(split, ["sometag", '_("Page not found")', 'value|yesno:_("yes,no")'])
def test_token_smart_split(self):
"""
#7027 -- _() syntax should work with spaces
"""
token = Token(TokenType.BLOCK, 'sometag _("Page not found") value|yesno:_("yes,no")')
split = token.split_contents()
self.assertEqual(split, ["sometag", '_("Page not found")', 'value|yesno:_("yes,no")'])
def test_invalid_call(self):
wf = self.wrapped_function
# Check raising TemplateSyntaxError if call with too few arguments
self.assertRaises(TemplateSyntaxError, wf, None, Token(TokenType.TEXT, 'elem1 elem2'))
# Check raising TemplateSyntaxError if call with too many arguments
self.assertRaises(TemplateSyntaxError, wf, None, Token(TokenType.TEXT, 'elem1 elem2 elem3 elem4'))
def test_repr(self):
block_translate_node = BlockTranslateNode(extra_context={}, singular=[
Token(TokenType.TEXT, 'content'),
Token(TokenType.VAR, 'variable'),
])
self.assertEqual(
repr(block_translate_node),
'<BlockTranslateNode: extra_context={} '
'singular=[<Text token: "content...">, <Var token: "variable...">] '
'plural=None>',
)
def test_repr(self):
block_translate_node = BlockTranslateNode(
extra_context={},
singular=[
Token(TokenType.TEXT, "content"),
Token(TokenType.VAR, "variable"),
],
)
self.assertEqual(
repr(block_translate_node),
"<BlockTranslateNode: extra_context={} "
'singular=[<Text token: "content...">, <Var token: "variable...">] '
"plural=None>",
)
def test_tag_update_query_string(self):
request = mock.Mock()
request.get_full_path = mock.Mock(return_value='/fake')
parser = Parser('')
token = Token(TOKEN_TEXT, 'tag with "page"="2"')
node = tag_update_query_string(parser, token)
self.assertEqual(node.render({'request': request}), u'/fake?page=2')
token = Token(TOKEN_TEXT, 'tag with page=num_page')
node = tag_update_query_string(parser, token)
self.assertEqual(
node.render({
'request': request,
'page': 'page',
'num_page': 2
}), u'/fake?page=2')
def map(parser, token):
_, tag_name, list = token.split_contents()
var_name = uuid.uuid4().hex
fake_token = Token(TOKEN_BLOCK, '%s %s' % (tag_name, var_name))
tag = parser.tags[tag_name](parser, fake_token)
return MapNode(var_name, tag, list)
def test_parse_tag_token(self):
token = Token(token_type='TOKEN_TEXT',
contents='sortable_link test_field test_title')
result = parse_tag_token(token)
self.assertEqual(result, (u'test_field', u'test_title'))
def test_unquoted_kwargs_raises_templatesyntaxerror(self):
token = Token(
token_type=TokenType.TEXT,
contents=
'imagequery image_model "query" image.Thumb sthpacific=True')
with self.assertRaises(TemplateSyntaxError):
query_tag(self.parser, token)
def test_unicorn_args_and_kwargs():
# args after the component name get ignored
token = Token(TokenType.TEXT,
"unicorn 'todo' '1' 2 hello='world' test=3 '4'")
unicorn_node = unicorn(None, token)
assert unicorn_node.kwargs == {"hello": "world", "test": 3}
def test_malformed_kwargs_raises_templatesyntaxerror(self):
token = Token(
token_type = TokenType.TEXT,
contents = 'image image_model image.Thumb sth-pacific="True"'
)
with self.assertRaises(TemplateSyntaxError):
image_tag(self.parser, token)
def second_pass_render(request, content):
"""
Split on the secret delimiter and generate the token list by passing
through text outside of phased blocks as single text tokens and tokenizing
text inside the phased blocks. This ensures that nothing outside of the
phased blocks is tokenized, thus eliminating the possibility of a template
code injection vulnerability.
"""
result = tokens = []
for index, bit in enumerate(content.split(
settings.PHASED_SECRET_DELIMITER)):
if index % 2:
tokens = Lexer(bit, None).tokenize()
else:
tokens.append(Token(TOKEN_TEXT, bit))
context = RequestContext(
request, restore_csrf_token(request, unpickle_context(bit)))
rendered = Parser(tokens).parse().render(context)
if settings.PHASED_SECRET_DELIMITER in rendered:
rendered = second_pass_render(request, rendered)
result.append(rendered)
return "".join(result)
def choose_from_list(parser: Parser, token: Token):
try:
tag_name, first, last, how_many = token.split_contents()
except ValueError:
msg = "lotto first:int last:int how_many:int"
raise template.TemplateSyntaxError(msg)
return ChooseNode(first, last, how_many)
def test_not_enough_args_raises_templatesyntaxerror(self):
token = Token(
token_type = TokenType.TEXT,
contents = 'imagequery image_model "query"'
)
with self.assertRaises(TemplateSyntaxError):
query_tag(self.parser, token)
def test_sortable_class(self):
token = Token(token_type='TOKEN_TEXT',
contents='sortable_class test_field test_title')
result = sortable_class(None, token)
self.assertEqual(result.default_direction, 'asc')
self.assertEqual(result.field_name, 'test_field')
self.assertEqual(result.title, 'test_title')
def test_sortable_link_desc(self):
token = Token(token_type='TOKEN_VAR',
contents='sortable_link -test_field test_title')
result = sortable_link(None, token)
self.assertEqual(result.default_direction, 'desc')
self.assertEqual(result.field_name, 'test_field')
self.assertEqual(result.title, 'test_title')
def url(self, sitetree_item, context=None):
"""Resolves item's URL.
:param TreeItemBase sitetree_item: TreeItemBase heir object, 'url' property of which
is processed as URL pattern or simple URL.
:param Context context:
:rtype: str|unicode
"""
context = context or self.current_page_context
resolve_var = self.resolve_var
if not isinstance(sitetree_item, MODEL_TREE_ITEM_CLASS):
sitetree_item = resolve_var(sitetree_item, context)
resolved_url = self._items_urls.get(sitetree_item)
if resolved_url is not None:
return resolved_url
# Resolve only if item's URL is marked as pattern.
if sitetree_item.urlaspattern:
url = sitetree_item.url
view_path = url
all_arguments = []
if ' ' in url:
view_path = url.split(' ')
# We should try to resolve URL parameters from site tree item.
for view_argument in view_path[1:]:
resolved = resolve_var(view_argument)
# We enclose arg in double quotes as already resolved.
all_arguments.append('"%s"' % resolved)
view_path = view_path[0].strip('"\' ')
url_pattern = "'%s' %s" % (view_path, ' '.join(all_arguments))
else:
url_pattern = '%s' % sitetree_item.url
if sitetree_item.urlaspattern:
# Form token to pass to Django 'url' tag.
url_token = 'url %s as item.url_resolved' % url_pattern
url_tag(Parser(None),
Token(token_type=TOKEN_BLOCK,
contents=url_token)).render(context)
resolved_url = context[
'item.url_resolved'] or UNRESOLVED_ITEM_MARKER
else:
resolved_url = url_pattern
self._items_urls[sitetree_item] = resolved_url
return resolved_url
def test_single_argument_with_plus_sets_title_to_field_name(self):
token = Token(token_type='TOKEN_TEXT',
contents='sortable_link +test_field')
result = sortable_class(None, token)
self.assertEqual(result.default_direction, 'asc')
self.assertEqual(result.field_name, 'test_field')
self.assertEqual(result.title, 'Test_field')
class FakeNode(template.Node):
# must mock token or error handling code will fail and not reveal real error
token = Token(TOKEN_TEXT, '', (0, 0), 0)
def render(self, context):
args = [expression.resolve(context) for expression in expressions]
url = reverse(url_name, args=args)
return ("<div data-name=\"{}\" data-value={}></div>"
.format(url_name, json.dumps(url)))
def url(self, sitetree_item: Union['TreeItemBase', FilterExpression], context: Context = None) -> str:
"""Resolves item's URL.
:param sitetree_item: TreeItemBase heir object, 'url' property of which
is processed as URL pattern or simple URL.
:param context:
"""
context = context or self.current_page_context
resolve_var = self.resolve_var
if not isinstance(sitetree_item, MODEL_TREE_ITEM_CLASS):
sitetree_item = resolve_var(sitetree_item, context)
resolved_url = self._items_urls.get(sitetree_item)
if resolved_url is not None:
return resolved_url
# Resolve only if item's URL is marked as pattern.
if sitetree_item.urlaspattern:
url = sitetree_item.url
view_path = url
all_arguments = []
if ' ' in url:
view_path = url.split(' ')
# We should try to resolve URL parameters from site tree item.
for view_argument in view_path[1:]:
resolved = resolve_var(view_argument)
# We enclose arg in double quotes as already resolved.
all_arguments.append(f'"{resolved}"')
view_path = view_path[0].strip('"\' ')
url_pattern = f"'{view_path}' {' '.join(all_arguments)}"
else:
url_pattern = f'{sitetree_item.url}'
if sitetree_item.urlaspattern:
# Form token to pass to Django 'url' tag.
url_token = f'url {url_pattern} as item.url_resolved'
url_tag(
Parser([]),
Token(token_type=TOKEN_BLOCK, contents=url_token)
).render(context)
resolved_url = context['item.url_resolved'] or UNRESOLVED_ITEM_MARKER
else:
resolved_url = url_pattern
self._items_urls[sitetree_item] = resolved_url
return resolved_url
def test_unicorn_render_context_variable():
token = Token(
TokenType.TEXT,
"unicorn 'tests.templatetags.test_unicorn_render.FakeComponentKwargs' test_kwarg=test_var.nested",
)
unicorn_node = unicorn(None, token)
context = {"test_var": {"nested": "variable!"}}
actual = unicorn_node.render(context)
assert "->variable!<-" in actual
def test_unicorn_render_kwarg():
token = Token(
TokenType.TEXT,
"unicorn 'tests.templatetags.test_unicorn_render.FakeComponentKwargs' test_kwarg='tested!'",
)
unicorn_node = unicorn(None, token)
context = {}
actual = unicorn_node.render(context)
assert "->tested!<-" in actual
def test_unicorn_render_id_use_pk():
token = Token(
TokenType.TEXT,
"unicorn 'tests.templatetags.test_unicorn_render.FakeComponentModel' model_id=model.id",
)
unicorn_node = unicorn(None, token)
context = {"model": {"pk": 123}}
actual = unicorn_node.render(context)
assert "==123==" in actual
def test_unicorn_render_kwarg():
token = Token(
TokenType.TEXT,
"unicorn 'tests.templatetags.test_unicorn_render.FakeComponentKwargs' test_kwarg='tested!'",
)
unicorn_node = unicorn(Parser([]), token)
context = {}
actual = unicorn_node.render(Context(context))
assert "<b>tested!</b>" in actual
def test_unicorn_render_with_invalid_html():
token = Token(
TokenType.TEXT,
"unicorn 'tests.templatetags.test_unicorn_render.FakeComponentKwargsWithHtmlEntity' test_kwarg=test_var.nested",
)
unicorn_node = unicorn(Parser([]), token)
context = {"test_var": {"nested": "variable!"}}
actual = unicorn_node.render(Context(context))
assert "->variable!<-" in actual
def loremi(count, method, random=False):
from django.template.base import Context, Token, Parser, TOKEN_TEXT
from django.template.defaulttags import lorem
c = Context()
lorem_str = "lorem %s %s" % (count, method)
if random:
lorem_str += " random"
t = Token(TOKEN_TEXT, lorem_str)
p = Parser(t)
return lorem(p, t).render(c)
def do_static_build(parser, token):
file_name = token.split_contents()[1][1:-1]
with open(os.path.join(HOME, 'assets.json')) as data_file:
import json as json_lib
file_name = json_lib.load(data_file)[file_name]
contents = 'static \'' + 'build/' + file_name + '\''
new_token = Token(token_type=token.token_type, contents=contents)
return StaticFilesNode.handle_token(parser, new_token)
def test_unicorn_render_parent_component_one_script_tag(settings):
settings.DEBUG = True
token = Token(
TokenType.TEXT,
"unicorn 'tests.templatetags.test_unicorn_render.FakeComponentParent'",
)
unicorn_node = unicorn(None, token)
context = {}
html = unicorn_node.render(context)
assert '<script type="module"' in html
assert len(re.findall('<script type="module"', html)) == 1
def test_unicorn_render_child_component_no_script_tag(settings):
settings.DEBUG = True
token = Token(
TokenType.TEXT,
"unicorn 'tests.templatetags.test_unicorn_render.FakeComponentKwargs' parent=view",
)
unicorn_node = unicorn(None, token)
view = FakeComponentParent(component_name="test", component_id="asdf")
context = {"view": view}
html = unicorn_node.render(context)
assert "<script" not in html
def minified_js(parser: Parser, token: Token) -> MinifiedJSNode:
try:
tag_name, sourcefile = token.split_contents()
except ValueError:
raise TemplateSyntaxError("%s token requires an argument" % (token,))
if not (sourcefile[0] == sourcefile[-1] and sourcefile[0] in ('"', "'")):
raise TemplateSyntaxError("%s tag should be quoted" % (tag_name,))
sourcefile = sourcefile[1:-1]
if sourcefile not in settings.JS_SPECS:
raise TemplateSyntaxError("%s tag invalid argument: no JS file %s"
% (tag_name, sourcefile))
return MinifiedJSNode(sourcefile)