def test_multi_value_max_values_single(self):
# test max_values option
options = core.Options(
arguments.MultiValueArgument('myarg', max_values=2))
dummy_tokens = DummyTokens('myval')
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertEqual(blocks, {})
self.assertEqual(len(kwargs), 1)
dummy_context = {}
self.assertEqual(kwargs['myarg'].resolve(dummy_context), ['myval'])
def test_multi_value_three_values(self):
options = core.Options(arguments.MultiValueArgument('myarg'))
# test triple token MVA
dummy_tokens = DummyTokens('myval', 'myval2', 'myval3')
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertEqual(blocks, {})
self.assertEqual(len(kwargs), 1)
dummy_context = {}
self.assertEqual(kwargs['myarg'].resolve(dummy_context),
['myval', 'myval2', 'myval3'])
def test_partial_breakpoints_both_trailing(self):
options = core.Options(
arguments.Argument('first'),
'also',
'using',
arguments.Argument('second', required=False),
)
dummy_tokens = DummyTokens('firstval', 'also', 'using')
self.assertRaises(exceptions.TrailingBreakpoint, options.parse,
dummy_parser, dummy_tokens)
def test_multikwarg_no_key(self):
options = core.Options(arguments.MultiKeywordArgument('multi'), )
with SettingsOverride(DEBUG=True):
dummy_tokens = DummyTokens('value')
self.assertRaises(template.TemplateSyntaxError, options.parse,
dummy_parser, dummy_tokens)
with SettingsOverride(DEBUG=False):
dummy_tokens = DummyTokens('value')
self.assertRaises(template.TemplateSyntaxError, options.parse,
dummy_parser, dummy_tokens)
class For(core.Tag):
name = 'ct_for'
options = core.Options(
CommaSeperatableMultiValueArgument('loopvars', resolve=False),
'in',
arguments.Argument('values'),
blocks=[('empty', 'pre_empty'), ('endfor', 'post_empty')],
)
def render_tag(self, context, loopvars, values, pre_empty, post_empty):
if 'forloop' in context:
parentloop = context['forloop']
else:
parentloop = {}
context.push()
if not hasattr(values, '__len__'):
values = list(values)
len_values = len(values)
if len_values < 1:
context.pop()
return post_empty.render(context)
nodelist = template.NodeList()
unpack = len(loopvars) > 1
# Create a forloop value in the context. We'll update counters on each
# iteration just below.
loop_dict = context['forloop'] = {'parentloop': parentloop}
for i, item in enumerate(values):
# Shortcuts for current loop iteration number.
loop_dict['counter0'] = i
loop_dict['counter'] = i+1
# Reverse counter iteration numbers.
loop_dict['revcounter'] = len_values - i
loop_dict['revcounter0'] = len_values - i - 1
# Boolean values designating first and last times through loop.
loop_dict['first'] = (i == 0)
loop_dict['last'] = (i == len_values - 1)
if unpack:
# If there are multiple loop variables, unpack the item into
# them.
context.update(dict(zip(loopvars, item)))
else:
context[loopvars[0]] = item
for node in pre_empty:
nodelist.append(node.render(context))
if unpack:
# The loop variables were pushed on to the context so pop them
# off again. This is necessary because the tag lets the length
# of loopvars differ to the length of each set of items and we
# don't want to leave any vars from the previous loop on the
# context.
context.pop()
context.pop()
return nodelist.render(context)
def test_breakpoint_breakpoint_expected_second(self):
options = core.Options(
arguments.Argument('myarg'),
'as',
arguments.Argument('varname'),
'using',
arguments.Argument('using'),
)
dummy_tokens = DummyTokens('myval', 'as', 'myname', 'something')
self.assertRaises(exceptions.BreakpointExpected, options.parse,
dummy_parser, dummy_tokens)
class KeywordArgumentTag2(KeywordArgumentTag):
name = 'kwarg_tag'
options = core.Options(
arguments.KeywordArgument(
'named',
defaultkey='defaultkey',
resolve=False,
required=False,
default='defaultvalue'
),
)
def test_partial_breakpoints_second_both(self):
options = core.Options(
arguments.Argument('first'),
'also',
'using',
arguments.Argument('second', required=False),
)
# check only using the second breakpoint
dummy_tokens = DummyTokens('firstval', 'using', 'secondval')
self.assertRaises(exceptions.BreakpointExpected, options.parse,
dummy_parser, dummy_tokens)
def test_simple_parsing(self):
"""
Test very basic single argument parsing
"""
options = core.Options(arguments.Argument('myarg'), )
dummy_tokens = DummyTokens('myval')
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertEqual(blocks, {})
self.assertEqual(len(kwargs), 1)
dummy_context = {}
self.assertEqual(kwargs['myarg'].resolve(dummy_context), 'myval')
def test_multi_value_no_resolve(self):
# test no resolve
options = core.Options(
arguments.MultiValueArgument('myarg', resolve=False))
argparser = parser.Parser(options)
dummy_tokens = DummyTokens('myval', "'myval2'")
kwargs, blocks = argparser.parse(dummy_parser, dummy_tokens)
self.assertEqual(blocks, {})
dummy_context = {}
self.assertEqual(kwargs['myarg'].resolve(dummy_context),
['myval', 'myval2'])
class Blocky(core.Tag):
options = core.Options(
blocks=['a', 'b', 'c', 'd', 'e'],
)
def render_tag(self, context, **nodelists):
tpl = "%(a)s;%(b)s;%(c)s;%(d)s;%(e)s"
data = {}
for key, value in nodelists.items():
data[key] = value.render(context)
return tpl % data
def test_flag_true_value(self):
"""
Test flag arguments
"""
options = core.Options(
arguments.Flag('myflag', true_values=['on'], false_values=['off']))
dummy_tokens = DummyTokens('on')
dummy_context = {}
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertEqual(blocks, {})
self.assertEqual(kwargs['myflag'].resolve(dummy_context), True)
def test_case_sensitive_flag_okay(self):
options = core.Options(
arguments.Flag('myflag',
true_values=['on'],
default=False,
case_sensitive=True))
dummy_tokens = DummyTokens('on')
dummy_context = {}
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertEqual(blocks, {})
self.assertEqual(kwargs['myflag'].resolve(dummy_context), True)
def test_optional_given(self):
options = core.Options(
arguments.Argument('myarg'),
arguments.Argument('optarg', required=False, default=None),
)
dummy_tokens = DummyTokens('myval', 'optval')
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertEqual(blocks, {})
self.assertEqual(len(kwargs), 2)
dummy_context = {}
self.assertEqual(kwargs['myarg'].resolve(dummy_context), 'myval')
self.assertEqual(kwargs['optarg'].resolve(dummy_context), 'optval')
class Now(core.Tag):
name = 'ct_now'
options = core.Options(
arguments.Argument('format_string'),
)
def render_tag(self, context, format_string):
from datetime import datetime
from django.utils.dateformat import DateFormat
df = DateFormat(datetime.now())
return df.format(format_string)
class Hello(core.Tag):
options = core.Options(
arguments.Argument('name', required=False, default='world'),
'as',
arguments.Argument('varname', required=False, resolve=False))
def render_tag(self, context, name, varname):
output = 'hello %s' % name
if varname:
context[varname] = output
return ''
return output
def test_custom_parser(self):
class CustomParser(parser.Parser):
def parse_blocks(self):
return
options = core.Options(blocks=[
('end_my_tag', 'nodelist'),
],
parser_class=CustomParser)
dummy_tokens = DummyTokens()
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertEqual(blocks, {})
def test_multi_value_defaults(self):
# test default
options = core.Options(
arguments.MultiValueArgument('myarg', default=['hello',
'world']), )
argparser = parser.Parser(options)
dummy_tokens = DummyTokens()
kwargs, blocks = argparser.parse(dummy_parser, dummy_tokens)
self.assertEqual(blocks, {})
dummy_context = {}
self.assertEqual(kwargs['myarg'].resolve(dummy_context),
['hello', 'world'])
def test_multiflag(self):
# test multi-flag
options = core.Options(
arguments.Flag('flagone', true_values=['on'], default=False),
arguments.Flag('flagtwo', false_values=['off'], default=True),
)
dummy_tokens = DummyTokens('On', 'On')
dummy_context = {}
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertEqual(blocks, {})
self.assertEqual(kwargs['flagone'].resolve(dummy_context), True)
self.assertEqual(kwargs['flagtwo'].resolve(dummy_context), True)
def test_06_complex(self):
"""
test a complex tag option parser
"""
options = core.Options(
arguments.Argument('singlearg'),
arguments.MultiValueArgument('multiarg', required=False),
'as',
arguments.Argument('varname', required=False),
'safe',
arguments.Flag('safe', true_values=['on', 'true'], default=False)
)
# test simple 'all arguments given'
dummy_tokens = DummyTokens(1, 2, 3, 'as', 4, 'safe', 'true')
dummy_context = {}
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertEqual(blocks, {})
self.assertEqual(len(kwargs), 4)
expected = [
('singlearg', 1),
('multiarg', [2, 3]),
('varname', 4),
('safe', True)
]
for key, value in expected:
self.assertEqual(kwargs[key].resolve(dummy_context), value)
# test 'only first argument given'
dummy_tokens = DummyTokens(1)
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertEqual(blocks, {})
self.assertEqual(len(kwargs), 4)
expected = [
('singlearg', 1),
('multiarg', []),
('varname', None),
('safe', False)
]
for key, value in expected:
self.assertEqual(kwargs[key].resolve(dummy_context), value)
# test first argument and last argument given
dummy_tokens = DummyTokens(2, 'safe', 'false')
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertEqual(blocks, {})
self.assertEqual(len(kwargs), 4)
expected = [
('singlearg', 2),
('multiarg', []),
('varname', None),
('safe', False)
]
for key, value in expected:
self.assertEqual(kwargs[key].resolve(dummy_context), value)
def test_multi_value_single_value(self):
"""
Test simple multi value arguments
"""
options = core.Options(arguments.MultiValueArgument('myarg'))
# test single token MVA
dummy_tokens = DummyTokens('myval')
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertEqual(blocks, {})
self.assertEqual(len(kwargs), 1)
dummy_context = {}
# test resolving to list
self.assertEqual(kwargs['myarg'].resolve(dummy_context), ['myval'])
class StartBlock(core.Tag):
options = core.Options(arguments.Argument("myarg", resolve=False),
blocks=[
BlockDefinition(
"nodelist",
VariableBlockName(
"end_block %(value)s", 'myarg'),
"end_block")
])
def render_tag(self, context, myarg, nodelist):
return "nodelist:%s;myarg:%s" % (nodelist.render(context),
myarg)
def test_breakpoints_not_enough_arguments(self):
"""
Test parsing with breakpoints
"""
options = core.Options(
arguments.Argument('myarg'),
'as',
arguments.Argument('varname'),
'using',
arguments.Argument('using'),
)
dummy_tokens = DummyTokens('myval')
self.assertRaises(exceptions.ArgumentRequiredError, options.parse,
dummy_parser, dummy_tokens)
def test_optional_firstonly(self):
options = core.Options(
arguments.Argument('first'),
'also',
'using',
arguments.Argument('second', required=False),
)
# check only using the first argument
dummy_tokens = DummyTokens('firstval')
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertEqual(blocks, {})
self.assertEqual(len(kwargs), 2)
dummy_context = {}
self.assertEqual(kwargs['first'].resolve(dummy_context), 'firstval')
self.assertEqual(kwargs['second'].resolve(dummy_context), None)
def test_optional_both(self):
options = core.Options(
arguments.Argument('first'),
'also',
'using',
arguments.Argument('second', required=False),
)
# check using both arguments and both breakpoints
dummy_tokens = DummyTokens('firstval', 'also', 'using', 'secondval')
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertEqual(blocks, {})
self.assertEqual(len(kwargs), 2)
dummy_context = {}
self.assertEqual(kwargs['first'].resolve(dummy_context), 'firstval')
self.assertEqual(kwargs['second'].resolve(dummy_context), 'secondval')
class SuppressException(helpers.AsTag):
options = core.Options(
arguments.Argument('name'),
'as',
arguments.Argument('var', resolve=False, required=False),
)
def get_value(self, context, name):
raise MyException(name)
def get_value_for_context(self, context, name):
try:
return self.get_value(context, name)
except MyException:
return message
class With(core.Tag):
name = 'ct_with'
options = core.Options(
arguments.Argument('value'),
'as',
arguments.Argument('varname', resolve=False),
blocks=['endwith'],
)
def render_tag(self, context, value, varname, endwith):
context.push()
context[varname] = value
output = endwith.render(context)
context.pop()
return output
def test_complex_only_first_argument(self):
options = core.Options(
arguments.Argument('singlearg'),
arguments.MultiValueArgument('multiarg', required=False), 'as',
arguments.Argument('varname', required=False), 'safe',
arguments.Flag('safe', true_values=['on', 'true'], default=False))
# test 'only first argument given'
dummy_tokens = DummyTokens(1)
dummy_context = {}
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertEqual(blocks, {})
self.assertEqual(len(kwargs), 4)
expected = [('singlearg', 1), ('multiarg', []), ('varname', None),
('safe', False)]
for key, value in expected:
self.assertEqual(kwargs[key].resolve(dummy_context), value)
class Cycle(core.Tag):
name = 'classy_cycle'
options = core.Options(
arguments.MultiValueArgument('values'),
'as',
arguments.Argument('varname', required=False, resolve=False),
)
def render_tag(self, context, values, varname):
if self not in context.render_context:
context.render_context[self] = itertools_cycle(values)
cycle_iter = context.render_context[self]
value = cycle_iter.next()
if varname:
context[varname] = value
return value
def test_breakpoint_okay(self):
options = core.Options(
arguments.Argument('myarg'),
'as',
arguments.Argument('varname'),
'using',
arguments.Argument('using'),
)
dummy_tokens = DummyTokens('myval', 'as', 'myname', 'using',
'something')
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertEqual(blocks, {})
self.assertEqual(len(kwargs), 3)
dummy_context = {}
self.assertEqual(kwargs['myarg'].resolve(dummy_context), 'myval')
self.assertEqual(kwargs['varname'].resolve(dummy_context), 'myname')
self.assertEqual(kwargs['using'].resolve(dummy_context), 'something')
