def test_kwarg_default(self):
options = core.Options(
arguments.KeywordArgument('kwarg',
required=False,
defaultkey='mykey'), )
dummy_tokens = DummyTokens()
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertTrue('kwarg' in kwargs)
self.assertEqual(kwargs['kwarg'].resolve({}), {'mykey': None})
options = core.Options(
arguments.KeywordArgument('kwarg', required=False,
default='hello'), )
dummy_tokens = DummyTokens()
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertTrue('kwarg' in kwargs)
self.assertEqual(kwargs['kwarg'].resolve({}), {})
options = core.Options(
arguments.KeywordArgument('kwarg',
required=False,
default='hello',
defaultkey='key'), )
dummy_tokens = DummyTokens()
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertTrue('kwarg' in kwargs)
self.assertEqual(kwargs['kwarg'].resolve({}), {'key': 'hello'})
def test_non_required_multikwarg(self):
options = core.Options(
arguments.MultiKeywordArgument('multi', required=False), )
dummy_tokens = DummyTokens()
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertTrue('multi' in kwargs)
self.assertEqual(kwargs['multi'], {})
options = core.Options(
arguments.MultiKeywordArgument('multi',
required=False,
default={'hello': 'world'}), )
dummy_tokens = DummyTokens()
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertTrue('multi' in kwargs)
self.assertEqual(kwargs['multi'].resolve({}), {'hello': 'world'})
def test_strict_string(self):
options = core.Options(
arguments.StringArgument('string', resolve=False), )
with SettingsOverride(DEBUG=False):
#test ok
dummy_tokens = DummyTokens('string')
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
dummy_context = {}
self.assertEqual(kwargs['string'].resolve(dummy_context), 'string')
#test warning
dummy_tokens = DummyTokens(1)
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
dummy_context = {}
message = values.StrictStringValue.errors['clean'] % {
'value': repr(1)
}
self.assertWarns(exceptions.TemplateSyntaxWarning, message,
kwargs['string'].resolve, dummy_context)
with SettingsOverride(DEBUG=True):
# test exception
dummy_tokens = DummyTokens(1)
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
dummy_context = {}
self.assertRaises(template.TemplateSyntaxError,
kwargs['string'].resolve, dummy_context)
class Inc(helpers.InclusionTag):
template = 'test.html'
options = core.Options(arguments.Argument('var'), )
def get_context(self, context, var):
return {'var': var}
def test_flag_wrong_value(self):
options = core.Options(
arguments.Flag('myflag', true_values=['on'], false_values=['off']))
# test exceptions
dummy_tokens = DummyTokens('myval')
self.assertRaises(exceptions.InvalidFlag, options.parse, dummy_parser,
dummy_tokens)
class ResolveKwarg(core.Tag):
name = 'kwarg'
options = core.Options(arguments.KeywordArgument('named'), )
def render_tag(self, context, named):
return '%s:%s' % (list(named.keys())[0], list(
named.values())[0])
class Dummy(helpers.AsTag):
options = core.Options(
'as',
arguments.Argument('varname', resolve=False, required=False),
)
def get_value(self, context):
return "dummy"
def test_flag_false_value(self):
options = core.Options(
arguments.Flag('myflag', true_values=['on'], false_values=['off']))
dummy_tokens = DummyTokens('off')
dummy_context = {}
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertEqual(blocks, {})
self.assertEqual(kwargs['myflag'].resolve(dummy_context), False)
class KeywordArgumentTag2(KeywordArgumentTag):
name = 'kwarg_tag'
options = core.Options(
arguments.KeywordArgument('named',
defaultkey='defaultkey',
resolve=False,
required=False,
default='defaultvalue'), )
def test_integer_variable(self):
options = core.Options(
arguments.IntegerArgument('integer', resolve=False), )
# test okay
with SettingsOverride(DEBUG=False):
dummy_tokens = DummyTokens('1')
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
dummy_context = {}
self.assertEqual(kwargs['integer'].resolve(dummy_context), 1)
# test warning
dummy_tokens = DummyTokens('one')
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
dummy_context = {}
one = repr('one')
message = arguments.IntegerValue.errors['clean'] % {'value': one}
self.assertWarns(exceptions.TemplateSyntaxWarning, message,
kwargs['integer'].resolve, dummy_context)
self.assertEqual(kwargs['integer'].resolve(dummy_context),
values.IntegerValue.value_on_error)
# test exception
with SettingsOverride(DEBUG=True):
dummy_tokens = DummyTokens('one')
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
dummy_context = {}
message = values.IntegerValue.errors['clean'] % {
'value': repr('one')
}
self.assertRaises(template.TemplateSyntaxError,
kwargs['integer'].resolve, dummy_context)
# test the same as above but with resolving
class IntegerTag(core.Tag):
options = core.Options(arguments.IntegerArgument('integer'))
def render_tag(self, context, integer):
return integer
with TemplateTags(IntegerTag):
tpl = template.Template("{% integer_tag i %}")
with SettingsOverride(DEBUG=False):
# test okay
context = template.Context({'i': '1'})
self.assertEqual(tpl.render(context), '1')
# test warning
context = template.Context({'i': 'one'})
message = values.IntegerValue.errors['clean'] % {
'value': repr('one')
}
self.assertWarns(exceptions.TemplateSyntaxWarning, message,
tpl.render, context)
self.assertEqual(int(tpl.render(context)),
values.IntegerValue.value_on_error)
# test exception
with SettingsOverride(DEBUG=True):
context = template.Context({'i': 'one'})
message = arguments.IntegerValue.errors['clean'] % {'value': one}
self.assertRaises(template.TemplateSyntaxError, tpl.render,
context)
def test_choice_argument(self):
options = core.Options(
arguments.ChoiceArgument('choice', choices=['one', 'two',
'three']), )
# this is settings dependant!
with SettingsOverride(DEBUG=True):
for good in ('one', 'two', 'three'):
dummy_tokens = DummyTokens(good)
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
dummy_context = {}
self.assertEqual(kwargs['choice'].resolve(dummy_context), good)
bad = 'four'
dummy_tokens = DummyTokens(bad)
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
dummy_context = {}
self.assertRaises(template.TemplateSyntaxError,
kwargs['choice'].resolve, dummy_context)
with SettingsOverride(DEBUG=False):
self.assertEqual(kwargs['choice'].resolve(dummy_context), 'one')
# test other value class
class IntegerChoiceArgument(arguments.ChoiceArgument):
value_class = values.IntegerValue
default = 2
options = core.Options(
IntegerChoiceArgument('choice',
choices=[1, 2, 3],
default=default), )
with SettingsOverride(DEBUG=True):
for good in ('1', '2', '3'):
dummy_tokens = DummyTokens(good)
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
dummy_context = {}
self.assertEqual(kwargs['choice'].resolve(dummy_context),
int(good))
bad = '4'
dummy_tokens = DummyTokens(bad)
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
dummy_context = {}
self.assertRaises(template.TemplateSyntaxError,
kwargs['choice'].resolve, dummy_context)
with SettingsOverride(DEBUG=False):
self.assertEqual(kwargs['choice'].resolve(dummy_context), default)
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)
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_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_multi_value_max_values_double(self):
options = core.Options(
arguments.MultiValueArgument('myarg', max_values=2))
dummy_tokens = DummyTokens('myval', 'myval2')
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'])
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)
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_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_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_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_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'])
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')
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_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)
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_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'])
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_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'])
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)
