def test_merge_lists(self):
l1 = [1,2,3]
l2 = [2,3,4]
p1 = Parameters(dict(list=l1[:]))
p2 = Parameters(dict(list=l2))
p1.merge(p2)
self.assertListEqual(p1.as_dict()['list'], l1+l2)
def test_overwrite_none(self):
p1 = Parameters({'A': None, 'B': None, 'C': None, 'D': None, 'E': None, 'F': None})
p2 = Parameters({'A': 'abc', 'B': [1, 2, 3], 'C': {'a': 'aaa', 'b': 'bbb'}, 'D': '${A}', 'E': '${B}', 'F': '${C}'})
r = {'A': 'abc', 'B': [1, 2, 3], 'C': {'a': 'aaa', 'b': 'bbb'}, 'D': 'abc', 'E': [1, 2, 3], 'F': {'a': 'aaa', 'b': 'bbb'}}
p1.merge(p2)
p1.interpolate()
self.assertEqual(p1.as_dict(), r)
def test_escaped_string_in_ref_dict_overwrite(self):
p1 = Parameters(
{
'a': {
'one': '\${not_a_ref}'
},
'b': {
'two': '\${also_not_a_ref}'
}
}, SETTINGS, '')
p2 = Parameters({'c': '${a}'}, SETTINGS, '')
p3 = Parameters({'c': '${b}'}, SETTINGS, '')
p4 = Parameters({'c': {'one': '\${again_not_a_ref}'}}, SETTINGS, '')
r = {
'a': {
'one': '${not_a_ref}'
},
'b': {
'two': '${also_not_a_ref}'
},
'c': {
'one': '${again_not_a_ref}',
'two': '${also_not_a_ref}'
}
}
p1.merge(p2)
p1.merge(p3)
p1.merge(p4)
p1.interpolate()
self.assertEqual(p1.as_dict(), r)
def test_merged_interpolated_dict_type(self):
p1 = Parameters({'a': {
'one': 1,
'two': 2,
'three': 3
}}, SETTINGS, 'first')
p2 = Parameters({'a': {
'four': 4,
'five': 5,
'six': 6
}}, SETTINGS, 'second')
r = {
'a': {
'one': 1,
'two': 2,
'three': 3,
'four': 4,
'five': 5,
'six': 6
}
}
self.assertIs(type(p1.as_dict()['a']), ParameterDict)
self.assertIs(type(p2.as_dict()['a']), ParameterDict)
p1.merge(p2)
self.assertIs(type(p1.as_dict()['a']), ParameterDict)
p1.interpolate()
self.assertIs(type(p1.as_dict()['a']), dict)
self.assertEqual(p1.as_dict(), r)
def test_escaped_string_overwrites(self):
p1 = Parameters({'test': '\${not_a_ref}'}, SETTINGS, '')
p2 = Parameters({'test': '\${also_not_a_ref}'}, SETTINGS, '')
r = {'test': '${also_not_a_ref}'}
p1.merge(p2)
p1.interpolate()
self.assertEqual(p1.as_dict(), r)
def test_overwrite_list(self):
p1 = Parameters({'a': [1, 2]}, SETTINGS, '')
p2 = Parameters({'~a': [3, 4]}, SETTINGS, '')
r = {'a': [3, 4]}
p1.merge(p2)
p1.interpolate()
self.assertEqual(p1.as_dict(), r)
def test_merge_scalars_overwrite(self):
p = Parameters(SIMPLE)
mergee = {'two': 5, 'four': 4, 'three': None, 'one': (1, 2, 3)}
p.merge(mergee)
goal = SIMPLE.copy()
goal.update(mergee)
self.assertDictEqual(p.as_dict(), goal)
def test_merge_referenced_dicts(self):
p1 = Parameters({'one': {'a': 1, 'b': 2}, 'two': {'c': 3, 'd': 4}, 'three': '${one}'})
p2 = Parameters({'three': '${two}'})
r = {'one': {'a': 1, 'b': 2}, 'two': {'c': 3, 'd': 4}, 'three': {'a': 1, 'b': 2, 'c': 3, 'd': 4}}
p1.merge(p2)
p1.interpolate()
self.assertEqual(p1.as_dict(), r)
def test_merge_dicts_overwrite(self):
mergee = {'two': 5, 'four': 4, 'three': None, 'one': (1, 2, 3)}
p = Parameters(dict(dict=SIMPLE))
p.merge(Parameters(dict(dict=mergee)))
goal = SIMPLE.copy()
goal.update(mergee)
self.assertDictEqual(p.as_dict(), dict(dict=goal))
def test_merge_referenced_lists(self):
p1 = Parameters({'one': [ 1, 2, 3 ], 'two': [ 4, 5, 6 ], 'three': '${one}'})
p2 = Parameters({'three': '${two}'})
r = {'one': [ 1, 2, 3 ], 'two': [ 4, 5, 6], 'three': [ 1, 2, 3, 4, 5, 6 ]}
p1.merge(p2)
p1.interpolate()
self.assertEqual(p1.as_dict(), r)
def test_complex_reference_overwriting(self):
p1 = Parameters({'one': 'abc_123_${two}_${three}', 'two': 'XYZ', 'four': 4})
p2 = Parameters({'one': 'QWERTY_${three}_${four}', 'three': '999'})
r = {'one': 'QWERTY_999_4', 'two': 'XYZ', 'three': '999', 'four': 4}
p1.merge(p2)
p1.interpolate()
self.assertEqual(p1.as_dict(), r)
def test_merge_dicts_overwrite(self):
mergee = {'two':5,'four':4,'three':None,'one':(1,2,3)}
p = Parameters(dict(dict=SIMPLE))
p.merge(Parameters(dict(dict=mergee)))
goal = SIMPLE.copy()
goal.update(mergee)
self.assertDictEqual(p.as_dict(), dict(dict=goal))
def test_merge_none_over_dict_negative(self):
settings = Settings({'allow_none_override': False})
p1 = Parameters(dict(key=SIMPLE), settings, '')
p2 = Parameters(dict(key=None), settings, '')
with self.assertRaises(TypeError):
p1.merge(p2)
p1.initialise_interpolation()
def test_exports_with_refs(self):
inventory = {'node1': {'a': 1, 'b': 2}, 'node2': {'a': 3, 'b': 4}}
node3_exports = Exports({'a': '${a}', 'b': '${b}'}, SETTINGS, '')
node3_parameters = Parameters({
'name': 'node3',
'a': '${c}',
'b': 5
}, SETTINGS, '')
node3_parameters.merge({'c': 3})
node3_entity = Entity(SETTINGS,
classes=None,
applications=None,
parameters=node3_parameters,
exports=node3_exports)
node3_entity.interpolate_exports()
inventory['node3'] = node3_entity.exports.as_dict()
r = {
'node1': {
'a': 1,
'b': 2
},
'node2': {
'a': 3,
'b': 4
},
'node3': {
'a': 3,
'b': 5
}
}
self.assertDictEqual(inventory, r)
def test_merge_scalars(self):
p = Parameters(SIMPLE)
mergee = {'five':5,'four':4,'None':None,'tuple':(1,2,3)}
p.merge(mergee)
goal = SIMPLE.copy()
goal.update(mergee)
self.assertDictEqual(p.as_dict(), goal)
def test_merge_scalars_overwrite(self):
p = Parameters(SIMPLE)
mergee = {'two':5,'four':4,'three':None,'one':(1,2,3)}
p.merge(mergee)
goal = SIMPLE.copy()
goal.update(mergee)
self.assertDictEqual(p.as_dict(), goal)
def test_merge_lists(self):
l1 = [1, 2, 3]
l2 = [2, 3, 4]
p1 = Parameters(dict(list=l1[:]))
p2 = Parameters(dict(list=l2))
p1.merge(p2)
self.assertListEqual(p1.as_dict()['list'], l1 + l2)
def test_merge_scalars(self):
p = Parameters(SIMPLE)
mergee = {'five': 5, 'four': 4, 'None': None, 'tuple': (1, 2, 3)}
p.merge(mergee)
goal = SIMPLE.copy()
goal.update(mergee)
self.assertDictEqual(p.as_dict(), goal)
def test_escaped_string_in_ref_dict_1(self):
# test with escaped string in first dict to be merged
p1 = Parameters(
{
'a': {
'one': '${a_ref}'
},
'b': {
'two': '\${not_a_ref}'
},
'c': '${b}',
'a_ref': 123
}, SETTINGS, '')
p2 = Parameters({'c': '${a}'}, SETTINGS, '')
r = {
'a': {
'one': 123
},
'b': {
'two': '${not_a_ref}'
},
'c': {
'one': 123,
'two': '${not_a_ref}'
},
'a_ref': 123
}
p1.merge(p2)
p1.interpolate()
self.assertEqual(p1.as_dict(), r)
def test_overwrite_dict(self):
p1 = Parameters({'a': {'one': 1, 'two': 2}}, SETTINGS, '')
p2 = Parameters({'~a': {'three': 3, 'four': 4}}, SETTINGS, '')
r = {'a': {'three': 3, 'four': 4}}
p1.merge(p2)
p1.interpolate()
self.assertEqual(p1.as_dict(), r)
def test_merge_none_over_dict_allow(self):
settings = Settings({'allow_none_override': True})
p1 = Parameters(dict(key=SIMPLE), settings, '')
p2 = Parameters(dict(key=None), settings, '')
p1.merge(p2)
p1.interpolate()
self.assertEqual(p1.as_dict()['key'], None)
def test_merge_lists(self):
l1 = [1, 2, 3]
l2 = [2, 3, 4]
p1 = Parameters(dict(list=l1[:]), SETTINGS, '')
p2 = Parameters(dict(list=l2), SETTINGS, '')
p1.merge(p2)
p1.initialise_interpolation()
self.assertListEqual(p1.as_dict()['list'], l1 + l2)
def test_merge_scalar_over_dict_allow(self):
d = {'one': 1, 'two': 2}
settings = Settings({'allow_scalar_over_dict': True})
p1 = Parameters({'a': d}, settings, '')
p2 = Parameters({'a': 1}, settings, '')
p1.merge(p2)
p1.interpolate()
self.assertEqual(p1.as_dict(), {'a': 1})
def test_merge_scalar_over_list_allow(self):
l = ['foo', 1, 2]
settings = Settings({'allow_scalar_over_list': True})
p1 = Parameters(dict(key=l[:2]), settings, '')
p2 = Parameters(dict(key=l[2]), settings, '')
p1.merge(p2)
p1.interpolate()
self.assertEqual(p1.as_dict()['key'], l[2])
def test_merge_list_into_scalar_allow(self):
settings = Settings({'allow_list_over_scalar': True})
l = ['foo', 1, 2]
p1 = Parameters(dict(key=l[0]), settings, '')
p2 = Parameters(dict(key=l[1:]), settings, '')
p1.merge(p2)
p1.interpolate()
self.assertListEqual(p1.as_dict()['key'], l)
def test_merge_none_over_list(self):
l = ['foo', 1, 2]
settings = Settings({'allow_none_override': True})
p1 = Parameters(dict(key=l[:2]), settings, '')
p2 = Parameters(dict(key=None), settings, '')
p1.merge(p2)
p1.initialise_interpolation()
self.assertEqual(p1.as_dict()['key'], None)
def test_merge_scalars_overwrite(self):
p = Parameters(SIMPLE, SETTINGS, '')
mergee = {'two': 5, 'four': 4, 'three': None, 'one': (1, 2, 3)}
p.merge(mergee)
p.initialise_interpolation()
goal = SIMPLE.copy()
goal.update(mergee)
self.assertDictEqual(p.as_dict(), goal)
def test_merge_scalar_over_dict(self):
settings = Settings({'allow_scalar_over_dict': True})
p = Parameters(dict(base=SIMPLE), settings, '')
mergee = {'base': 'foo'}
p2 = Parameters(mergee, settings, '')
p.merge(p2)
p.initialise_interpolation()
self.assertDictEqual(p.as_dict(), mergee)
def test_nested_reference_with_overwriting(self):
p1 = Parameters({'one': {'a': 1, 'b': 2, 'z': 'a'},
'two': '${one:${one:z}}' })
p2 = Parameters({'one': {'z': 'b'} })
r = {'one': {'a': 1, 'b':2, 'z': 'b'}, 'two': 2}
p1.merge(p2)
p1.interpolate()
self.assertEqual(p1.as_dict(), r)
def test_merge_scalar_over_dict(self):
options = MergeOptions()
options.allow_scalar_over_dict = True
p = Parameters(dict(base=SIMPLE), options=options)
mergee = {'base':'foo'}
p.merge(Parameters(mergee))
p.initialise_interpolation()
self.assertDictEqual(p.as_dict(), mergee)
def test_merge_scalar_over_list(self):
l = ['foo', 1, 2]
options = MergeOptions()
options.allow_scalar_over_list = True
p1 = Parameters(dict(key=l[:2]), options=options)
p1.merge(Parameters(dict(key=l[2])))
p1.initialise_interpolation()
self.assertEqual(p1.as_dict()['key'], l[2])
def test_merge_dicts(self):
mergee = {'five':5,'four':4,'None':None,'tuple':(1,2,3)}
p = Parameters(dict(dict=SIMPLE))
p.merge(Parameters(dict(dict=mergee)))
p.initialise_interpolation()
goal = SIMPLE.copy()
goal.update(mergee)
self.assertDictEqual(p.as_dict(), dict(dict=goal))
def test_merge_list_into_scalar(self):
l = ['foo', 1, 2]
options = MergeOptions()
options.allow_list_over_scalar = True
p1 = Parameters(dict(key=l[0]), options=options)
p1.merge(Parameters(dict(key=l[1:])))
p1.initialise_interpolation()
self.assertListEqual(p1.as_dict()['key'], l)
def test_merge_dicts_override(self):
"""Validate that tilde merge overrides function properly."""
mergee = {'~one': {'a': 'alpha'}, '~two': ['gamma']}
base = {'one': {'b': 'beta'}, 'two': ['delta']}
goal = {'one': {'a': 'alpha'}, 'two': ['gamma']}
p = Parameters(dict(dict=base))
p.merge(Parameters(dict(dict=mergee)))
self.assertDictEqual(p.as_dict(), dict(dict=goal))
def _merge(a, b):
'''
merge the contents of dictionary ``b`` into dictionary ``a``, using reclass'
sensible form of deep-dictionary merging and interpolation.
'''
m = Parameters(a)
m.merge(b)
m.interpolate()
return m.as_dict()
def test_merge_dicts_override(self):
"""Validate that tilde merge overrides function properly."""
mergee = {'~one': {'a': 'alpha'},
'~two': ['gamma']}
base = {'one': {'b': 'beta'},
'two': ['delta']}
goal = {'one': {'a': 'alpha'},
'two': ['gamma']}
p = Parameters(dict(dict=base))
p.merge(Parameters(dict(dict=mergee)))
self.assertDictEqual(p.as_dict(), dict(dict=goal))
def test_merge_list_into_scalar(self):
l = ['foo', 1, 2]
p1 = Parameters(dict(key=l[0]))
p1.merge(Parameters(dict(key=l[1:])))
self.assertListEqual(p1.as_dict()['key'], l)
def test_stray_occurrence_overwrites_during_interpolation(self):
p1 = Parameters({'r' : mock.sentinel.ref, 'b': '${r}'})
p2 = Parameters({'b' : mock.sentinel.goal})
p1.merge(p2)
p1.interpolate()
self.assertEqual(p1.as_dict()['b'], mock.sentinel.goal)
def test_merge_scalar_over_list(self):
l = ['foo', 1, 2]
p1 = Parameters(dict(key=l[:2]))
p1.merge(Parameters(dict(key=l[2])))
self.assertEqual(p1.as_dict()['key'], l[2])
def test_merge_dict_into_scalar(self):
p = Parameters(dict(base='foo'))
with self.assertRaises(TypeError):
p.merge(Parameters(dict(base=SIMPLE)))
def test_merge_scalar_over_dict(self):
p = Parameters(dict(base=SIMPLE))
mergee = {'base':'foo'}
p.merge(Parameters(mergee))
self.assertDictEqual(p.as_dict(), mergee)
