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'])
class Firstof(core.Tag):
name = 'ct_firstof'
options = core.Options(arguments.MultiValueArgument('values'), )
def render_tag(self, context, values):
for value in values:
if value:
return smart_unicode(value)
return u''
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_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_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_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'])
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_05_multi_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'])
# test double token MVA
dummy_tokens = DummyTokens('myval', 'myval2')
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertEqual(blocks, {})
self.assertEqual(len(kwargs), 1)
self.assertEqual(kwargs['myarg'].resolve(dummy_context),
['myval', 'myval2'])
# 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)
self.assertEqual(kwargs['myarg'].resolve(dummy_context),
['myval', 'myval2', 'myval3'])
# 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'])
dummy_tokens = DummyTokens('myval', 'myval2')
kwargs, blocks = options.parse(dummy_parser, dummy_tokens)
self.assertEqual(blocks, {})
self.assertEqual(len(kwargs), 1)
self.assertEqual(kwargs['myarg'].resolve(dummy_context),
['myval', 'myval2'])
dummy_tokens = DummyTokens('myval', 'myval2', 'myval3')
self.assertRaises(exceptions.TooManyArguments,
options.parse, dummy_parser, dummy_tokens)
# 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, {})
self.assertEqual(kwargs['myarg'].resolve(dummy_context),
['myval', 'myval2'])
# 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, {})
self.assertEqual(kwargs['myarg'].resolve(dummy_context),
['hello', 'world'])
def test_multi_value_max_values_too_many(self):
options = core.Options(
arguments.MultiValueArgument('myarg', max_values=2))
dummy_tokens = DummyTokens('myval', 'myval2', 'myval3')
self.assertRaises(exceptions.TooManyArguments, options.parse,
dummy_parser, dummy_tokens)
