def test__update_should_handle_dots_appropriately(self):
init = self.__class__.test_parameters
P = ConfigParserParameterSet(init)
P.update({"sectionA.a": 5, "sectionA.c": 4, "sectionC.e": 9})
self.assertEqual(P.as_dict(), {"sectionA": dict(a="5", b="3", c="4"),
"sectionB": dict(c="hello", d="world"),
"sectionC": dict(e="9")})
def test_diff(self):
P1 = ConfigParserParameterSet(self.__class__.test_parameters)
P2 = ConfigParserParameterSet(
dedent("""
# this is a comment
[sectionA]
a: 3
b: 3
[sectionB]
c: hello
d: universe
[sectionC]
e: zebra
"""))
self.assertEqual(P1.diff(P2), ({
'sectionA': {
'a': '2'
},
'sectionB': {
'd': 'world'
}
}, {
'sectionA': {
'a': '3'
},
'sectionB': {
'd': 'universe'
},
'sectionC': {
'e': 'zebra'
}
}))
def test__init__should_accept_a_filename_or_string(self):
init = self.__class__.test_parameters
P1 = ConfigParserParameterSet(init)
with open("test_file", "w") as f:
f.write(init)
P2 = ConfigParserParameterSet("test_file")
self.assertEqual(P1.as_dict(), P2.as_dict())
os.remove("test_file")
def test__update_should_handle_dots_appropriately(self):
init = self.__class__.test_parameters
P = ConfigParserParameterSet(init)
P.update({"sectionA.a": 5, "sectionA.c": 4, "sectionC.e": 9})
self.assertEqual(
P.as_dict(), {
"sectionA": dict(a="5", b="3", c="4"),
"sectionB": dict(c="hello", d="world"),
"sectionC": dict(e="9")
})
def setUp(self):
## setup parsets with legal params
self.PSETS = [SimpleParameterSet(""), JSONParameterSet("")]
try:
self.PSETS.append(YAMLParameterSet(""))
except ImportError:
pass
self.PConfigParser = ConfigParserParameterSet("")
for k in ('a', 'b', 'c', 'd', 'l', 'save'):
up_dict = {k: 1}
self.PConfigParser.update(up_dict)
for P in self.PSETS:
P.update(up_dict)
def test_diff(self):
P1 = ConfigParserParameterSet(self.__class__.test_parameters)
P2 = ConfigParserParameterSet(dedent("""
# this is a comment
[sectionA]
a: 3
b: 3
[sectionB]
c: hello
d: universe
[sectionC]
e: zebra
"""))
self.assertEqual(P1.diff(P2),
({'sectionA': {'a': '2'}, 'sectionB': {'d': 'world'}},
{'sectionA': {'a': '3'}, 'sectionB': {'d': 'universe'}, 'sectionC': {'e': 'zebra'}}))
def setUp(self):
## setup parsets with legal params
self.PSETS = (SimpleParameterSet(""), JSONParameterSet(""),
YAMLParameterSet(""))
self.PConfigParser = ConfigParserParameterSet("")
for k in ('a', 'b', 'c', 'd', 'l', 'save'):
up_dict = {k: 1}
self.PConfigParser.update(up_dict)
for P in self.PSETS:
P.update(up_dict)
def setUp(self):
## setup parsets with legal params
self.PSETS = [SimpleParameterSet(""), JSONParameterSet("")]
try:
self.PSETS.append(YAMLParameterSet(""))
except ImportError:
pass
self.PConfigParser = ConfigParserParameterSet("")
for k in ("a", "b", "c", "d", "l", "save"):
up_dict = {k: 1}
self.PConfigParser.update(up_dict)
for P in self.PSETS:
P.update(up_dict)
def test__init__should_accept_a_filename_or_string(self):
init = self.__class__.test_parameters
P1 = ConfigParserParameterSet(init)
with open("test_file", "w") as f:
f.write(init)
P2 = ConfigParserParameterSet("test_file")
self.assertEqual(P1.as_dict(), P2.as_dict())
os.remove("test_file")
class ArgumentParsingTests(unittest.TestCase):
def setUp(self):
## setup parsets with legal params
self.PSETS = [SimpleParameterSet(""), JSONParameterSet("")]
try:
self.PSETS.append(YAMLParameterSet(""))
except ImportError:
pass
self.PConfigParser = ConfigParserParameterSet("")
for k in ("a", "b", "c", "d", "l", "save"):
up_dict = {k: 1}
self.PConfigParser.update(up_dict)
for P in self.PSETS:
P.update(up_dict)
def test_parse_command_line_parameter_arg_must_contain_equals(self):
for P in self.PSETS:
self.assertRaises(Exception, P.parse_command_line_parameter, "foobar")
def test_parse_command_line_parameter_with_int(self):
for P in self.PSETS:
result = P.parse_command_line_parameter("a=2")
self.assertEqual(result, {"a": 2})
assert isinstance(result["a"], int)
def test_parse_command_line_parameter_with_float(self):
for P in self.PSETS:
result = P.parse_command_line_parameter("b=2.0")
self.assertEqual(result, {"b": 2.0})
assert isinstance(result["b"], float)
def test_parse_command_line_parameter_warns(self):
## but still returns name and value with ValueError
for P in self.PSETS:
self.assertRaises(ValueError, P.parse_command_line_parameter, "bt=2")
try:
P.parse_command_line_parameter("bt=2")
except ValueError as v:
message, name, value = v.args
self.assertEqual(message, "")
self.assertEqual(name, "bt")
self.assertEqual(value, 2)
assert isinstance(value, int)
self.assertRaises(ValueError, self.PConfigParser.parse_command_line_parameter, "l=False")
try:
self.PConfigParser.parse_command_line_parameter("l=False")
except ValueError as v:
# config parser coerce all to string
message, name, value = v.args
self.assertEqual(name, "l")
self.assertEqual(value, "False")
assert isinstance(value, str)
def test_parse_command_line_parameter_with_list(self):
for P in self.PSETS:
result = P.parse_command_line_parameter("c=[1,2,3,4,5]")
self.assertEqual(result, {"c": [1, 2, 3, 4, 5]})
def test_parse_command_line_parameter_with_bool(self):
if len(self.PSETS) == 3:
PS, PJSON, PYAML = self.PSETS
else:
PS, PJSON = self.PSETS
PYAML = None
result = PJSON.parse_command_line_parameter("l=false")
self.assertEqual(result, {"l": False})
result = PS.parse_command_line_parameter("l=false")
self.assertEqual(result, {"l": "false"})
if PYAML:
# yaml has language agnostic bool
result = PYAML.parse_command_line_parameter("l=False") # python-like
self.assertEqual(result, {"l": False})
result = PYAML.parse_command_line_parameter("l=false") # json-like
self.assertEqual(result, {"l": False})
result = PYAML.parse_command_line_parameter("l=FALSE") # r-like
self.assertEqual(result, {"l": False})
result = PYAML.parse_command_line_parameter("l=off") # possibly undesired
self.assertEqual(result, {"l": False})
result = PYAML.parse_command_line_parameter("l=On") # possibly undesired
self.assertEqual(result, {"l": True})
def test_parse_command_line_parameter_with_tuple(self):
for P in self.PSETS:
result = P.parse_command_line_parameter("d=('a','b','c')")
self.assertEqual(result, {"d": ("a", "b", "c")})
def test_parse_command_line_parameter_should_accept_equals_in_parameter(self):
# because the parameter value could be a string containing "="
for P in self.PSETS:
value = "save=Data/result.uwsize=48.setsize=1"
result = P.parse_command_line_parameter(value)
self.assertEqual(result, {"save": "Data/result.uwsize=48.setsize=1"})
class ArgumentParsingTests(unittest.TestCase):
def setUp(self):
## setup parsets with legal params
self.PSETS = [SimpleParameterSet(""), JSONParameterSet("")]
try:
self.PSETS.append(YAMLParameterSet(""))
except ImportError:
pass
self.PConfigParser = ConfigParserParameterSet("")
for k in ('a', 'b', 'c', 'd', 'l', 'save'):
up_dict = {k: 1}
self.PConfigParser.update(up_dict)
for P in self.PSETS:
P.update(up_dict)
def test_parse_command_line_parameter_arg_must_contain_equals(self):
for P in self.PSETS:
self.assertRaises(Exception, P.parse_command_line_parameter, "foobar")
def test_parse_command_line_parameter_with_int(self):
for P in self.PSETS:
result = P.parse_command_line_parameter("a=2")
self.assertEqual(result, {'a': 2})
assert isinstance(result['a'], int)
def test_parse_command_line_parameter_with_float(self):
for P in self.PSETS:
result = P.parse_command_line_parameter("b=2.0")
self.assertEqual(result, {'b': 2.0})
assert isinstance(result['b'], float)
def test_parse_command_line_parameter_warns(self):
## but still returns name and value with ValueError
for P in self.PSETS:
self.assertRaises(ValueError, P.parse_command_line_parameter, "bt=2")
try:
P.parse_command_line_parameter("bt=2")
except ValueError as v:
message, name, value = v.args
self.assertEqual(message, '')
self.assertEqual(name, 'bt')
self.assertEqual(value, 2)
assert isinstance(value, int)
self.assertRaises(ValueError, self.PConfigParser.parse_command_line_parameter, "l=False")
try:
self.PConfigParser.parse_command_line_parameter("l=False")
except ValueError as v:
#config parser coerce all to string
message, name, value = v.args
self.assertEqual(name, 'l')
self.assertEqual(value, 'False')
assert isinstance(value, str)
def test_parse_command_line_parameter_with_list(self):
for P in self.PSETS:
result = P.parse_command_line_parameter("c=[1,2,3,4,5]")
self.assertEqual(result, {'c': [1, 2, 3, 4, 5]})
def test_parse_command_line_parameter_with_bool(self):
if len(self.PSETS) == 3:
PS, PJSON, PYAML = self.PSETS
else:
PS, PJSON = self.PSETS
PYAML = None
result = PJSON.parse_command_line_parameter("l=false")
self.assertEqual(result, {'l': False})
result = PS.parse_command_line_parameter("l=false")
self.assertEqual(result, {'l': 'false'})
if PYAML:
# yaml has language agnostic bool
result = PYAML.parse_command_line_parameter("l=False") #python-like
self.assertEqual(result, {'l': False})
result = PYAML.parse_command_line_parameter("l=false") #json-like
self.assertEqual(result, {'l': False})
result = PYAML.parse_command_line_parameter("l=FALSE") #r-like
self.assertEqual(result, {'l': False})
result = PYAML.parse_command_line_parameter("l=off") # possibly undesired
self.assertEqual(result, {'l': False})
result = PYAML.parse_command_line_parameter("l=On") # possibly undesired
self.assertEqual(result, {'l': True})
def test_parse_command_line_parameter_with_tuple(self):
for P in self.PSETS:
result = P.parse_command_line_parameter("d=('a','b','c')")
self.assertEqual(result, {'d': ('a', 'b', 'c')})
def test_parse_command_line_parameter_should_accept_equals_in_parameter(self):
# because the parameter value could be a string containing "="
for P in self.PSETS:
value = "save=Data/result.uwsize=48.setsize=1"
result = P.parse_command_line_parameter(value)
self.assertEqual(result, {'save': 'Data/result.uwsize=48.setsize=1'})
def test__pop(self):
init = self.__class__.test_parameters
P = ConfigParserParameterSet(init)
self.assertEqual(P.pop('sectionA.b'), '3')
self.assertEqual(P.pop('sectionA.foo', 42), 42)
def test__init__should_accept_an_empty_initializer(self):
P = ConfigParserParameterSet("")
self.assertEqual(P.as_dict(), {})
def test__pretty__output_should_be_useable_to_create_an_identical_parameterset(self):
init = self.__class__.test_parameters
P1 = ConfigParserParameterSet(init)
P2 = ConfigParserParameterSet(P1.pretty())
self.assertEqual(P1.as_dict(), P2.as_dict())
def test__init__should_accept_an_empty_initializer(self):
P = ConfigParserParameterSet("")
self.assertEqual(P.as_dict(), {})
class ArgumentParsingTests(unittest.TestCase):
def setUp(self):
## setup parsets with legal params
self.PSETS = (SimpleParameterSet(""), JSONParameterSet(""),
YAMLParameterSet(""))
self.PConfigParser = ConfigParserParameterSet("")
for k in ('a', 'b', 'c', 'd', 'l', 'save'):
up_dict = {k: 1}
self.PConfigParser.update(up_dict)
for P in self.PSETS:
P.update(up_dict)
def test_parse_command_line_parameter_arg_must_contain_equals(self):
for P in self.PSETS:
self.assertRaises(Exception, P.parse_command_line_parameter, "foobar")
def test_parse_command_line_parameter_with_int(self):
for P in self.PSETS:
result = P.parse_command_line_parameter("a=2")
self.assertEqual(result, {'a': 2})
assert isinstance(result['a'], int)
def test_parse_command_line_parameter_with_float(self):
for P in self.PSETS:
result = P.parse_command_line_parameter("b=2.0")
self.assertEqual(result, {'b': 2.0})
assert isinstance(result['b'], float)
def test_parse_command_line_parameter_warns(self):
## but still returns name and value with ValueError
for P in self.PSETS:
self.assertRaises(ValueError, P.parse_command_line_parameter, "bt=2")
try:
P.parse_command_line_parameter("bt=2")
except ValueError as v:
message, name, value = v.args
self.assertEqual(message, '')
self.assertEqual(name, 'bt')
self.assertEqual(value, 2)
assert isinstance(value, int)
self.assertRaises(ValueError, self.PConfigParser.parse_command_line_parameter, "l=False")
try:
self.PConfigParser.parse_command_line_parameter("l=False")
except ValueError as v:
#config parser coerce all to string
message, name, value = v.args
self.assertEqual(name, 'l')
self.assertEqual(value, 'False')
assert isinstance(value, str)
def test_parse_command_line_parameter_with_list(self):
for P in self.PSETS:
result = P.parse_command_line_parameter("c=[1,2,3,4,5]")
self.assertEqual(result, {'c': [1, 2, 3, 4, 5]})
def test_parse_command_line_parameter_with_bool(self):
PS, PJSON, PYAML = self.PSETS
result = PJSON.parse_command_line_parameter("l=false")
self.assertEqual(result, {'l': False})
result = PS.parse_command_line_parameter("l=false")
self.assertEqual(result, {'l': 'false'})
# yaml has language agnostic bool
result = PYAML.parse_command_line_parameter("l=False") #python-like
self.assertEqual(result, {'l': False})
result = PYAML.parse_command_line_parameter("l=false") #json-like
self.assertEqual(result, {'l': False})
result = PYAML.parse_command_line_parameter("l=FALSE") #r-like
self.assertEqual(result, {'l': False})
result = PYAML.parse_command_line_parameter("l=off") # possibly undesired
self.assertEqual(result, {'l': False})
result = PYAML.parse_command_line_parameter("l=On") # possibly undesired
self.assertEqual(result, {'l': True})
def test_parse_command_line_parameter_with_tuple(self):
for P in self.PSETS:
result = P.parse_command_line_parameter("d=('a','b','c')")
self.assertEqual(result, {'d': ('a', 'b', 'c')})
def test_parse_command_line_parameter_should_accept_equals_in_parameter(self):
# because the parameter value could be a string containing "="
for P in self.PSETS:
value = "save=Data/result.uwsize=48.setsize=1"
result = P.parse_command_line_parameter(value)
self.assertEqual(result, {'save': 'Data/result.uwsize=48.setsize=1'})
def test__getitem(self):
init = self.__class__.test_parameters
P = ConfigParserParameterSet(init)
self.assertEqual(P['sectionA'], {'a': '2', 'b': '3'})
self.assertEqual(P['sectionB.c'], 'hello')
def test__pop(self):
init = self.__class__.test_parameters
P = ConfigParserParameterSet(init)
self.assertEqual(P.pop('sectionA.b'), '3')
self.assertEqual(P.pop('sectionA.foo', 42), 42)
def test__str(self):
init = self.__class__.test_parameters
P = ConfigParserParameterSet(str(init))
as_string = str(P)
self.assertIsInstance(as_string, str)
self.assertEqual(P, ConfigParserParameterSet(as_string))
def test__deepcopy(self):
# see ticket:93
init = self.__class__.test_parameters
P = ConfigParserParameterSet(init)
Q = deepcopy(P)
def test__pretty__output_should_be_useable_to_create_an_identical_parameterset(
self):
init = self.__class__.test_parameters
P1 = ConfigParserParameterSet(init)
P2 = ConfigParserParameterSet(P1.pretty())
self.assertEqual(P1.as_dict(), P2.as_dict())
