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)