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_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)