def setUp(self):
super(MarkFlagsAsMutualExclusiveTest, self).setUp()
self.flag_values = _flagvalues.FlagValues()
_defines.DEFINE_string('flag_one',
None,
'flag one',
flag_values=self.flag_values)
_defines.DEFINE_string('flag_two',
None,
'flag two',
flag_values=self.flag_values)
_defines.DEFINE_string('flag_three',
None,
'flag three',
flag_values=self.flag_values)
_defines.DEFINE_integer('int_flag_one',
None,
'int flag one',
flag_values=self.flag_values)
_defines.DEFINE_integer('int_flag_two',
None,
'int flag two',
flag_values=self.flag_values)
_defines.DEFINE_multi_string('multi_flag_one',
None,
'multi flag one',
flag_values=self.flag_values)
_defines.DEFINE_multi_string('multi_flag_two',
None,
'multi flag two',
flag_values=self.flag_values)
def test_allow_overwrite_false(self):
fv = _flagvalues.FlagValues()
_defines.DEFINE_string('default_none',
None,
'help',
allow_overwrite=False,
flag_values=fv)
_defines.DEFINE_string('default_foo',
'foo',
'help',
allow_overwrite=False,
flag_values=fv)
fv.mark_as_parsed()
self.assertEqual('foo', fv.default_foo)
self.assertEqual(None, fv.default_none)
fv(['', '--default_foo=notFoo', '--default_none=notNone'])
self.assertEqual('notFoo', fv.default_foo)
self.assertEqual('notNone', fv.default_none)
fv.unparse_flags()
self.assertEqual('foo', fv['default_foo'].value)
self.assertEqual(None, fv['default_none'].value)
fv(['', '--default_foo=alsoNotFoo', '--default_none=alsoNotNone'])
self.assertEqual('alsoNotFoo', fv.default_foo)
self.assertEqual('alsoNotNone', fv.default_none)
def test_flags_into_string_deterministic(self):
flag_values = _flagvalues.FlagValues()
_defines.DEFINE_string('fa',
'x',
'',
flag_values=flag_values,
module_name='mb')
_defines.DEFINE_string('fb',
'x',
'',
flag_values=flag_values,
module_name='mb')
_defines.DEFINE_string('fc',
'x',
'',
flag_values=flag_values,
module_name='ma')
_defines.DEFINE_string('fd',
'x',
'',
flag_values=flag_values,
module_name='ma')
expected = ('--fc=x\n' '--fd=x\n' '--fa=x\n' '--fb=x\n')
flags_by_module_items = sorted(
flag_values.flags_by_module_dict().items(), reverse=True)
for _, module_flags in flags_by_module_items:
module_flags.sort(reverse=True)
flag_values.__dict__['__flags_by_module'] = collections.OrderedDict(
flags_by_module_items)
actual = flag_values.flags_into_string()
self.assertEqual(expected, actual)
def setUp(self):
self.fv = _flagvalues.FlagValues()
_defines.DEFINE_string('long_name',
'default',
'help',
flag_values=self.fv,
short_name='s')
def setUp(self):
super(FlagHolderTest, self).setUp()
self.fv = _flagvalues.FlagValues()
self.name_flag = _defines.DEFINE_string('name',
'default',
'help',
flag_values=self.fv)
def test_catch_none_as_default(self):
_defines.DEFINE_string('string_flag_1',
None,
'string flag 1',
flag_values=self.flag_values)
_defines.DEFINE_string('string_flag_2',
None,
'string flag 2',
flag_values=self.flag_values)
_validators.mark_flags_as_required(['string_flag_1', 'string_flag_2'],
flag_values=self.flag_values)
argv = ('./program', '--string_flag_1=value_1')
expected = (
r'flag --string_flag_2=None: Flag --string_flag_2 must be specified\.'
)
self.assertRaisesRegexp(_exceptions.IllegalFlagValueError, expected,
self.flag_values, argv)
def test_unparsed_flags_access_raises_after_unparse_flags(self):
fv = _flagvalues.FlagValues()
_defines.DEFINE_string('a_str', 'default_value', 'help', flag_values=fv)
fv.mark_as_parsed()
self.assertEqual(fv.a_str, 'default_value')
fv.unparse_flags()
with self.assertRaises(_exceptions.UnparsedFlagAccessError):
_ = fv.a_str
def _get_test_flag_values(self):
"""Get a _flagvalues.FlagValues() instance, set up for tests."""
flag_values = _flagvalues.FlagValues()
_defines.DEFINE_string('strf', '', '', flag_values=flag_values)
_defines.DEFINE_boolean('boolf', 0, '', flag_values=flag_values)
return flag_values
def test_validate_all_flags(self):
fv = _flagvalues.FlagValues()
_defines.DEFINE_string('name', None, '', flag_values=fv)
_validators.mark_flag_as_required('name', flag_values=fv)
with self.assertRaises(_exceptions.IllegalFlagValueError):
fv.validate_all_flags()
fv.name = 'test'
fv.validate_all_flags()
def setUp(self):
super(FlagsDashSyntaxTest, self).setUp()
self.fv = _flagvalues.FlagValues()
_defines.DEFINE_string('long_name',
'default',
'help',
flag_values=self.fv,
short_name='s')
def test_success(self):
_defines.DEFINE_string('string_flag_1',
None,
'string flag 1',
flag_values=self.flag_values)
_defines.DEFINE_string('string_flag_2',
None,
'string flag 2',
flag_values=self.flag_values)
flag_names = ['string_flag_1', 'string_flag_2']
_validators.mark_flags_as_required(flag_names,
flag_values=self.flag_values)
argv = ('./program', '--string_flag_1=value_1',
'--string_flag_2=value_2')
self.flag_values(argv)
self.assertEqual('value_1', self.flag_values.string_flag_1)
self.assertEqual('value_2', self.flag_values.string_flag_2)
def test_success(self):
_defines.DEFINE_string('string_flag',
None,
'string flag',
flag_values=self.flag_values)
_validators.mark_flag_as_required('string_flag',
flag_values=self.flag_values)
argv = ('./program', '--string_flag=value')
self.flag_values(argv)
self.assertEqual('value', self.flag_values.string_flag)
def test_catch_setting_none_after_program_start(self):
_defines.DEFINE_string('string_flag_1',
'value_1',
'string flag 1',
flag_values=self.flag_values)
_defines.DEFINE_string('string_flag_2',
'value_2',
'string flag 2',
flag_values=self.flag_values)
_validators.mark_flags_as_required(['string_flag_1', 'string_flag_2'],
flag_values=self.flag_values)
argv = ('./program', '--string_flag_1=value_1')
self.flag_values(argv)
self.assertEqual('value_1', self.flag_values.string_flag_1)
expected = (
'flag --string_flag_1=None: Flag --string_flag_1 must have a value '
'other than None.')
with self.assertRaises(_exceptions.IllegalFlagValueError) as cm:
self.flag_values.string_flag_1 = None
self.assertEqual(expected, str(cm.exception))
def test_flag_default_not_none_warning(self):
_defines.DEFINE_string('flag_not_none',
'',
'empty default',
flag_values=self.flag_values)
with warnings.catch_warnings(record=True) as w:
warnings.simplefilter('always')
_validators.mark_flag_as_required('flag_not_none',
flag_values=self.flag_values)
self.assertLen(w, 1)
self.assertIn('--flag_not_none has a non-None default value',
str(w[0].message))
def test_get_flags_for_module(self):
fv = _flagvalues.FlagValues()
_defines.DEFINE_string('foo', None, 'help', flag_values=fv)
module_foo.define_flags(fv)
flags = fv.get_flags_for_module('__main__')
self.assertEqual({'foo'}, {flag.name for flag in flags})
flags = fv.get_flags_for_module(module_foo)
self.assertEqual({'tmod_foo_bool', 'tmod_foo_int', 'tmod_foo_str'},
{flag.name
for flag in flags})
def test_using_default_value_none(self):
fv = _flagvalues.FlagValues()
_defines.DEFINE_string('default_none', None, 'help', flag_values=fv)
self.assertTrue(fv['default_none'].using_default_value)
fv(['', '--default_none=notNone'])
self.assertFalse(fv['default_none'].using_default_value)
fv.unparse_flags()
self.assertTrue(fv['default_none'].using_default_value)
fv(['', '--default_none=alsoNotNone'])
self.assertFalse(fv['default_none'].using_default_value)
fv.unparse_flags()
self.assertTrue(fv['default_none'].using_default_value)
def test_catch_setting_none_after_program_start(self):
_defines.DEFINE_string('string_flag_1',
'value_1',
'string flag 1',
flag_values=self.flag_values)
_defines.DEFINE_string('string_flag_2',
'value_2',
'string flag 2',
flag_values=self.flag_values)
_validators.mark_flags_as_required(['string_flag_1', 'string_flag_2'],
flag_values=self.flag_values)
argv = ('./program', '--string_flag_1=value_1')
self.flag_values(argv)
self.assertEqual('value_1', self.flag_values.string_flag_1)
expected = (
'flag --string_flag_1=None: Flag --string_flag_1 must be specified.'
)
try:
self.flag_values.string_flag_1 = None
raise AssertionError('Failed to detect non-set required flag.')
except _exceptions.IllegalFlagValueError as e:
self.assertEqual(expected, str(e))
def run_test(argv, defined_py_flags, expected_argv):
fv = _flagvalues.FlagValues()
fv.set_gnu_getopt(True)
for f in defined_py_flags:
if f.startswith('b'):
_defines.DEFINE_boolean(f, False, 'help', flag_values=fv)
else:
_defines.DEFINE_string(f,
'default',
'help',
flag_values=fv)
output_argv = fv(argv, known_only=True)
self.assertEqual(expected_argv, output_argv)
def test_catch_none_as_default(self):
_defines.DEFINE_string('string_flag',
None,
'string flag',
flag_values=self.flag_values)
_validators.mark_flag_as_required('string_flag',
flag_values=self.flag_values)
argv = ('./program', )
expected = (
r'flag --string_flag=None: Flag --string_flag must be specified\.')
with self.assertRaisesRegex(_exceptions.IllegalFlagValueError,
expected):
self.flag_values(argv)
def test_flags_dir(self):
flag_values = _flagvalues.FlagValues()
flag_name1 = 'bool_flag'
flag_name2 = 'string_flag'
flag_name3 = 'float_flag'
description = 'Description'
_defines.DEFINE_boolean(
flag_name1, None, description, flag_values=flag_values)
_defines.DEFINE_string(
flag_name2, None, description, flag_values=flag_values)
self.assertEqual(sorted([flag_name1, flag_name2]), dir(flag_values))
_defines.DEFINE_float(
flag_name3, None, description, flag_values=flag_values)
self.assertEqual(
sorted([flag_name1, flag_name2, flag_name3]), dir(flag_values))
def test_using_default_value_not_none(self):
fv = _flagvalues.FlagValues()
_defines.DEFINE_string('default_foo', 'foo', 'help', flag_values=fv)
fv.mark_as_parsed()
self.assertTrue(fv['default_foo'].using_default_value)
fv(['', '--default_foo=foo'])
self.assertFalse(fv['default_foo'].using_default_value)
fv(['', '--default_foo=notFoo'])
self.assertFalse(fv['default_foo'].using_default_value)
fv.unparse_flags()
self.assertTrue(fv['default_foo'].using_default_value)
fv(['', '--default_foo=alsoNotFoo'])
self.assertFalse(fv['default_foo'].using_default_value)
def test_catch_setting_none_after_program_start(self):
_defines.DEFINE_string('string_flag',
'value',
'string flag',
flag_values=self.flag_values)
_validators.mark_flag_as_required('string_flag',
flag_values=self.flag_values)
argv = ('./program', )
self.flag_values(argv)
self.assertEqual('value', self.flag_values.string_flag)
expected = (
'flag --string_flag=None: Flag --string_flag must have a value '
'other than None.')
try:
self.flag_values.string_flag = None
raise AssertionError('Failed to detect non-set required flag.')
except _exceptions.IllegalFlagValueError as e:
self.assertEqual(expected, str(e))
def test_hasattr_raises_in_py3(self):
fv = _flagvalues.FlagValues()
_defines.DEFINE_string('name', 'default', 'help', flag_values=fv)
with self.assertRaises(_exceptions.UnparsedFlagAccessError):
_ = hasattr(fv, 'name')
def test_hasattr_logs_in_py2(self):
fv = _flagvalues.FlagValues()
_defines.DEFINE_string('name', 'default', 'help', flag_values=fv)
with mock.patch.object(_flagvalues.logging, 'error') as mock_error:
self.assertFalse(hasattr(fv, 'name'))
mock_error.assert_called_once()
def test_unparsed_flag_access(self):
fv = _flagvalues.FlagValues()
_defines.DEFINE_string('name', 'default', 'help', flag_values=fv)
with self.assertRaises(_exceptions.UnparsedFlagAccessError):
_ = fv.name
