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 setUp(self):
super(MultiFlagsValidatorTest, self).setUp()
self.flag_values = _flagvalues.FlagValues()
self.call_args = []
_defines.DEFINE_integer('foo',
1,
'Usual integer flag',
flag_values=self.flag_values)
_defines.DEFINE_integer('bar',
2,
'Usual integer flag',
flag_values=self.flag_values)
def test_allow_override(self):
first = _defines.DEFINE_integer('int_flag',
1,
'help',
flag_values=self.fv,
allow_override=1)
second = _defines.DEFINE_integer('int_flag',
2,
'help',
flag_values=self.fv,
allow_override=1)
self.parse_flags('--int_flag=3')
self.assertEqual(3, first.value)
self.assertEqual(3, second.value)
def test_set_default(self):
fv = _flagvalues.FlagValues()
fv.mark_as_parsed()
with self.assertRaises(_exceptions.UnrecognizedFlagError):
fv.set_default('changelist', 1)
_defines.DEFINE_integer('changelist', 0, 'help', flag_values=fv)
self.assertEqual(0, fv.changelist)
fv.set_default('changelist', 2)
self.assertEqual(2, fv.changelist)
def test_validator_not_called_when_other_flag_is_changed(self):
def checker(x):
self.call_args.append(x)
return True
_defines.DEFINE_integer('test_flag',
1,
'Usual integer flag',
flag_values=self.flag_values)
_defines.DEFINE_integer('other_flag',
2,
'Other integer flag',
flag_values=self.flag_values)
_validators.register_validator('test_flag',
checker,
message='Errors happen',
flag_values=self.flag_values)
argv = ('./program', )
self.flag_values(argv)
self.assertEqual(1, self.flag_values.test_flag)
self.flag_values.other_flag = 3
self.assertEqual([1], self.call_args)
def test_copy(self):
fv = _flagvalues.FlagValues()
_defines.DEFINE_integer('answer', 0, 'help', flag_values=fv)
fv(['', '--answer=1'])
with self.assertRaisesRegexp(
TypeError, 'FlagValues does not support shallow copies'):
copy.copy(fv)
fv2 = copy.deepcopy(fv)
self.assertEqual(fv2.answer, 1)
fv2.answer = 42
self.assertEqual(fv2.answer, 42)
self.assertEqual(fv.answer, 1)
def _define_flag_and_validators(self, first_validator, second_validator):
local_flags = _flagvalues.FlagValues()
_defines.DEFINE_integer('test_flag',
2,
'test flag',
flag_values=local_flags)
_validators.register_validator('test_flag',
first_validator,
message='',
flag_values=local_flags)
_validators.register_validator('test_flag',
second_validator,
message='',
flag_values=local_flags)
argv = ('./program', )
local_flags(argv)
def test_validator_not_called_when_other_flag_is_changed(self):
def checker(flags_dict):
self.call_args.append(flags_dict)
return True
_defines.DEFINE_integer('other_flag',
3,
'Other integer flag',
flag_values=self.flag_values)
_validators.register_multi_flags_validator(
['foo', 'bar'], checker, flag_values=self.flag_values)
argv = ('./program', )
self.flag_values(argv)
self.flag_values.other_flag = 3
self.assertEqual([{'foo': 1, 'bar': 2}], self.call_args)
def test_default_value_not_used_success(self):
def checker(x):
self.call_args.append(x)
return True
_defines.DEFINE_integer('test_flag',
None,
'Usual integer flag',
flag_values=self.flag_values)
_validators.register_validator('test_flag',
checker,
message='Errors happen',
flag_values=self.flag_values)
argv = ('./program', '--test_flag=1')
self.flag_values(argv)
self.assertEqual(1, self.flag_values.test_flag)
self.assertEqual([1], self.call_args)
def test_error_message_when_checker_raises_exception_on_start(self):
def checker(x):
self.call_args.append(x)
raise _exceptions.ValidationError('Specific message')
_defines.DEFINE_integer('test_flag',
None,
'Usual integer flag',
flag_values=self.flag_values)
_validators.register_validator('test_flag',
checker,
message='Errors happen',
flag_values=self.flag_values)
argv = ('./program', '--test_flag=1')
with self.assertRaises(_exceptions.IllegalFlagValueError) as cm:
self.flag_values(argv)
self.assertEqual('flag --test_flag=1: Specific message',
str(cm.exception))
self.assertEqual([1], self.call_args)
def test_validator_as_decorator(self):
_defines.DEFINE_integer('test_flag',
None,
'Simple integer flag',
flag_values=self.flag_values)
@_validators.validator('test_flag', flag_values=self.flag_values)
def checker(x):
self.call_args.append(x)
return True
argv = ('./program', )
self.flag_values(argv)
self.assertIsNone(self.flag_values.test_flag)
self.flag_values.test_flag = 2
self.assertEqual(2, self.flag_values.test_flag)
self.assertEqual([None, 2], self.call_args)
# Check that 'Checker' is still a function and has not been replaced.
self.assertTrue(checker(3))
self.assertEqual([None, 2, 3], self.call_args)
def setUp(self):
super(MarkBoolFlagsAsMutualExclusiveTest, self).setUp()
self.flag_values = _flagvalues.FlagValues()
_defines.DEFINE_boolean('false_1',
False,
'default false 1',
flag_values=self.flag_values)
_defines.DEFINE_boolean('false_2',
False,
'default false 2',
flag_values=self.flag_values)
_defines.DEFINE_boolean('true_1',
True,
'default true 1',
flag_values=self.flag_values)
_defines.DEFINE_integer('non_bool',
None,
'non bool',
flag_values=self.flag_values)
def test_exception_raised_if_checker_fails(self):
def checker(x):
self.call_args.append(x)
return x == 1
_defines.DEFINE_integer('test_flag',
None,
'Usual integer flag',
flag_values=self.flag_values)
_validators.register_validator('test_flag',
checker,
message='Errors happen',
flag_values=self.flag_values)
argv = ('./program', '--test_flag=1')
self.flag_values(argv)
with self.assertRaises(_exceptions.IllegalFlagValueError) as cm:
self.flag_values.test_flag = 2
self.assertEqual('flag --test_flag=2: Errors happen',
str(cm.exception))
self.assertEqual([1, 2], self.call_args)
def test_error_message_when_checker_returns_false_on_start(self):
def checker(x):
self.call_args.append(x)
return False
_defines.DEFINE_integer('test_flag',
None,
'Usual integer flag',
flag_values=self.flag_values)
_validators.register_validator('test_flag',
checker,
message='Errors happen',
flag_values=self.flag_values)
argv = ('./program', '--test_flag=1')
try:
self.flag_values(argv)
raise AssertionError('IllegalFlagValueError expected')
except _exceptions.IllegalFlagValueError as e:
self.assertEqual('flag --test_flag=1: Errors happen', str(e))
self.assertEqual([1], self.call_args)
def test_exception_raised_if_checker_raises_exception(self):
def checker(x):
self.call_args.append(x)
if x == 1:
return True
raise _exceptions.ValidationError('Specific message')
_defines.DEFINE_integer('test_flag',
None,
'Usual integer flag',
flag_values=self.flag_values)
_validators.register_validator('test_flag',
checker,
message='Errors happen',
flag_values=self.flag_values)
argv = ('./program', '--test_flag=1')
self.flag_values(argv)
try:
self.flag_values.test_flag = 2
raise AssertionError('IllegalFlagValueError expected')
except _exceptions.IllegalFlagValueError as e:
self.assertEqual('flag --test_flag=2: Specific message', str(e))
self.assertEqual([1, 2], self.call_args)
def test_unregistered_flags_are_cleaned_up(self):
fv = _flagvalues.FlagValues()
module, module_name = _helpers.get_calling_module_object_and_name()
# Define first flag.
_defines.DEFINE_integer('cores', 4, '', flag_values=fv, short_name='c')
old_cores_flag = fv['cores']
fv.register_key_flag_for_module(module_name, old_cores_flag)
self.assertEqual(fv.flags_by_module_dict(),
{module_name: [old_cores_flag]})
self.assertEqual(fv.flags_by_module_id_dict(),
{id(module): [old_cores_flag]})
self.assertEqual(fv.key_flags_by_module_dict(),
{module_name: [old_cores_flag]})
# Redefine the same flag.
_defines.DEFINE_integer('cores',
4,
'',
flag_values=fv,
short_name='c',
allow_override=True)
new_cores_flag = fv['cores']
self.assertNotEqual(old_cores_flag, new_cores_flag)
self.assertEqual(fv.flags_by_module_dict(),
{module_name: [new_cores_flag]})
self.assertEqual(fv.flags_by_module_id_dict(),
{id(module): [new_cores_flag]})
# old_cores_flag is removed from key flags, and the new_cores_flag is
# not automatically added because it must be registered explicitly.
self.assertEqual(fv.key_flags_by_module_dict(), {module_name: []})
# Define a new flag but with the same short_name.
_defines.DEFINE_integer('changelist',
0,
'',
flag_values=fv,
short_name='c',
allow_override=True)
old_changelist_flag = fv['changelist']
fv.register_key_flag_for_module(module_name, old_changelist_flag)
# The short named flag -c is overridden to be the old_changelist_flag.
self.assertEqual(fv['c'], old_changelist_flag)
self.assertNotEqual(fv['c'], new_cores_flag)
self.assertEqual(fv.flags_by_module_dict(),
{module_name: [new_cores_flag, old_changelist_flag]})
self.assertEqual(fv.flags_by_module_id_dict(),
{id(module): [new_cores_flag, old_changelist_flag]})
self.assertEqual(fv.key_flags_by_module_dict(),
{module_name: [old_changelist_flag]})
# Define a flag only with the same long name.
_defines.DEFINE_integer('changelist',
0,
'',
flag_values=fv,
short_name='l',
allow_override=True)
new_changelist_flag = fv['changelist']
self.assertNotEqual(old_changelist_flag, new_changelist_flag)
self.assertEqual(
fv.flags_by_module_dict(), {
module_name:
[new_cores_flag, old_changelist_flag, new_changelist_flag]
})
self.assertEqual(fv.flags_by_module_id_dict(), {
id(module):
[new_cores_flag, old_changelist_flag, new_changelist_flag]
})
self.assertEqual(fv.key_flags_by_module_dict(),
{module_name: [old_changelist_flag]})
# Delete the new changelist's long name, it should still be registered
# because of its short name.
del fv.changelist
self.assertNotIn('changelist', fv)
self.assertEqual(
fv.flags_by_module_dict(), {
module_name:
[new_cores_flag, old_changelist_flag, new_changelist_flag]
})
self.assertEqual(fv.flags_by_module_id_dict(), {
id(module):
[new_cores_flag, old_changelist_flag, new_changelist_flag]
})
self.assertEqual(fv.key_flags_by_module_dict(),
{module_name: [old_changelist_flag]})
# Delete the new changelist's short name, it should be removed.
del fv.l
self.assertNotIn('l', fv)
self.assertEqual(fv.flags_by_module_dict(),
{module_name: [new_cores_flag, old_changelist_flag]})
self.assertEqual(fv.flags_by_module_id_dict(),
{id(module): [new_cores_flag, old_changelist_flag]})
self.assertEqual(fv.key_flags_by_module_dict(),
{module_name: [old_changelist_flag]})
def _test_find_module_or_id_defining_flag(self, test_id):
"""Tests for find_module_defining_flag and find_module_id_defining_flag.
Args:
test_id: True to test find_module_id_defining_flag, False to test
find_module_defining_flag.
"""
fv = _flagvalues.FlagValues()
current_module, current_module_name = (
_helpers.get_calling_module_object_and_name())
alt_module_name = _flagvalues.__name__
if test_id:
current_module_or_id = id(current_module)
alt_module_or_id = id(_flagvalues)
testing_fn = fv.find_module_id_defining_flag
else:
current_module_or_id = current_module_name
alt_module_or_id = alt_module_name
testing_fn = fv.find_module_defining_flag
# Define first flag.
_defines.DEFINE_integer('cores', 4, '', flag_values=fv, short_name='c')
module_or_id_cores = testing_fn('cores')
self.assertEqual(module_or_id_cores, current_module_or_id)
module_or_id_c = testing_fn('c')
self.assertEqual(module_or_id_c, current_module_or_id)
# Redefine the same flag in another module.
_defines.DEFINE_integer('cores',
4,
'',
flag_values=fv,
module_name=alt_module_name,
short_name='c',
allow_override=True)
module_or_id_cores = testing_fn('cores')
self.assertEqual(module_or_id_cores, alt_module_or_id)
module_or_id_c = testing_fn('c')
self.assertEqual(module_or_id_c, alt_module_or_id)
# Define a new flag but with the same short_name.
_defines.DEFINE_integer('changelist',
0,
'',
flag_values=fv,
short_name='c',
allow_override=True)
module_or_id_cores = testing_fn('cores')
self.assertEqual(module_or_id_cores, alt_module_or_id)
module_or_id_changelist = testing_fn('changelist')
self.assertEqual(module_or_id_changelist, current_module_or_id)
module_or_id_c = testing_fn('c')
self.assertEqual(module_or_id_c, current_module_or_id)
# Define a flag in another module only with the same long name.
_defines.DEFINE_integer('changelist',
0,
'',
flag_values=fv,
module_name=alt_module_name,
short_name='l',
allow_override=True)
module_or_id_cores = testing_fn('cores')
self.assertEqual(module_or_id_cores, alt_module_or_id)
module_or_id_changelist = testing_fn('changelist')
self.assertEqual(module_or_id_changelist, alt_module_or_id)
module_or_id_c = testing_fn('c')
self.assertEqual(module_or_id_c, current_module_or_id)
module_or_id_l = testing_fn('l')
self.assertEqual(module_or_id_l, alt_module_or_id)
# Delete the changelist flag, its short name should still be registered.
del fv.changelist
module_or_id_changelist = testing_fn('changelist')
self.assertEqual(module_or_id_changelist, None)
module_or_id_c = testing_fn('c')
self.assertEqual(module_or_id_c, current_module_or_id)
module_or_id_l = testing_fn('l')
self.assertEqual(module_or_id_l, alt_module_or_id)
