def test_breakpoint_trailing(self):
options = core.Options(
arguments.Argument('myarg'),
'as',
arguments.Argument('varname', required=False),
)
dummy_tokens = DummyTokens('myval', 'as')
self.assertRaises(exceptions.TrailingBreakpoint, options.parse,
dummy_parser, dummy_tokens)
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_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_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)
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 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_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')
def test_complext_first_and_last_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 first argument and last argument given
dummy_tokens = DummyTokens(2, 'safe', 'false')
dummy_context = {}
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)
class Inc(helpers.InclusionTag):
template = 'test.html'
options = core.Options(arguments.Argument('var'), )
def get_context(self, context, var):
return {'var': var}
class Dummy(helpers.AsTag):
options = core.Options(
'as',
arguments.Argument('varname', resolve=False, required=False),
)
def get_value(self, context):
return "dummy"
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')
def test_complex_all_arguments(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)
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')
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)
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 = compat_next(cycle_iter)
if varname:
context[varname] = value
return value
class Fail4(helpers.AsTag):
options = core.Options(
'as',
arguments.Argument('varname', resolve=False),
)
def test_simple_parsing_too_many_arguments(self):
options = core.Options(arguments.Argument('myarg'), )
dummy_tokens = DummyTokens('myval', 'myval2')
self.assertRaises(exceptions.TooManyArguments, options.parse,
dummy_parser, dummy_tokens)
