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')