class AppConstantsTest(parameterized.TestCase, absltest.TestCase):
def test_get_default_constants(self):
constants = app_constants.get_default_constants()
self.assertLen(constants, 7)
@flagsaver.flagsaver(app_constants_test_flag='valid')
def test_get_constants_from_flags(self):
constants = app_constants.get_constants_from_flags(module=__name__)
self.assertLen(constants, 1)
self.assertEqual('valid', constants['app_constants_test_flag'].value)
def test_get_constants_from_flags__not_parsed(self):
FLAGS.__dict__['__flags_parsed'] = False
constants = app_constants.get_constants_from_flags(module=__name__)
FLAGS.__dict__['__flags_parsed'] = True
self.assertLen(constants, 1)
self.assertEqual('', constants['app_constants_test_flag'].value)
@parameterized.parameters(
('DEFAULT', None, 'new', 'new'),
('', utils.StringParser(True), '', ''),
('yes', utils.YesNoParser(), 'no', False),
('', utils.ListParser(True), 'this,one', ['this', 'one']),
('', utils.StringParser(False), 'asdf', 'asdf'),
('1', flags.IntegerParser(), '10', 10),
('*****@*****.**', utils.EmailParser(), '*****@*****.**', '*****@*****.**'),
)
def test_constant_constructor(self, default, parser, new_value, expected):
test_constant = app_constants.Constant('name', 'message', default,
parser)
self.assertEqual('name: {}'.format(default), str(test_constant))
self.assertEqual(
"<Constant('name', 'message', {!r}, {!r})>".format(
default, parser), repr(test_constant))
self.assertEqual(
app_constants.Constant('name', 'message', default, parser),
test_constant)
self.assertNotEqual(
app_constants.Constant('other', 'message', default, parser),
test_constant)
test_constant.value = new_value
self.assertTrue(test_constant.valid)
self.assertEqual(test_constant.value, expected)
def test_constant_prompt(self):
test_constant = app_constants.Constant('name', 'messsage', '',
utils.StringParser(False))
self.assertFalse(test_constant.valid)
with mock.patch.object(utils, 'prompt', return_value='VALID!'):
test_constant.prompt()
self.assertTrue(test_constant.valid)
def prompt_int(message, minimum=None, maximum=None, **kwargs):
"""Prompts the user for an integer.
Args:
message: str, the info message to display before prompting for user input.
minimum: int, the minimum accepted value.
maximum: int, the maximum accepted value.
**kwargs: keyword arguments to be passed to prompt.
Returns:
A user provided int.
"""
parser = flags.IntegerParser(lower_bound=minimum, upper_bound=maximum)
return prompt(message, parser=parser, **kwargs)
def testParserWrapping(self):
"""Tests callback based Parser wrapping."""
parser = flags.IntegerParser()
test_config = mock_config.get_config()
overrides = {}
wrapped_parser = config_flags._ConfigFieldParser(
parser, 'integer', test_config, overrides)
wrapped_parser.parse('12321')
self.assertEqual(test_config.integer, 12321)
self.assertEqual(overrides, {'integer': 12321})
self.assertEqual(wrapped_parser.flag_type(), parser.flag_type())
self.assertEqual(wrapped_parser.syntactic_help, parser.syntactic_help)
self.assertEqual(wrapped_parser.convert('3'), parser.convert('3'))
# types.StringType: flags.ArgumentParser(),
# types.TupleType: tuple_parser.TupleParser(), # OK For Python 3
# }
# The possible breaking changes are:
# - A Python 3 int could be a Python 2 long, which was not previously supported.
# We then add support for long.
# - Only Python 2 str were supported (not unicode). Python 3 will behave the
# same with the str semantic change.
_FIELD_TYPE_TO_PARSER = {
float: flags.FloatParser(),
bool: flags.BooleanParser(),
# Implementing a custom parser to override `Tuple` arguments.
tuple: tuple_parser.TupleParser(),
}
for t in six.integer_types:
_FIELD_TYPE_TO_PARSER[t] = flags.IntegerParser()
for t in six.string_types:
_FIELD_TYPE_TO_PARSER[t] = flags.ArgumentParser()
_FIELD_TYPE_TO_PARSER[str] = flags.ArgumentParser()
_FIELD_TYPE_TO_SERIALIZER = {
t: flags.ArgumentSerializer()
for t in _FIELD_TYPE_TO_PARSER
}
class UnsupportedOperationError(flags.Error):
pass
class FlagOrderError(flags.Error):
pass
def __init__(self, *args, **kwargs):
super(_VerbosityFlag, self).__init__(flags.IntegerParser(),
flags.ArgumentSerializer(), *args,
**kwargs)
def __init__(self, default, help_string):
super().__init__(default, help_string, flags.IntegerParser())
FLAGS = flags.FLAGS
# Forward for backwards compatability.
GetValue = config_path.get_value
GetType = config_path.get_type
SetValue = config_path.set_value
# Prevent this module being considered for `FLAGS.find_module_defining_flag`.
flags._helpers.disclaim_module_ids.add(id(sys.modules[__name__])) # pylint: disable=protected-access
_FIELD_TYPE_TO_PARSER = {
float: flags.FloatParser(),
bool: flags.BooleanParser(),
tuple: tuple_parser.TupleParser(),
int: flags.IntegerParser(),
str: flags.ArgumentParser()
}
_FIELD_TYPE_TO_SERIALIZER = {
t: flags.ArgumentSerializer()
for t in _FIELD_TYPE_TO_PARSER
}
class UnsupportedOperationError(flags.Error):
pass
class FlagOrderError(flags.Error):
pass
def __init__(
self,
default: Optional[int],
help_string: Optional[str] = None,
):
super().__init__(default, help_string, flags.IntegerParser())
