def test_list_merging_for_multiple_nodes(self): p1 = Parameters({'alpha': {'one': [1, 2]}}, SETTINGS, '') p2 = Parameters({'beta': {'two': '${alpha:one}'}}, SETTINGS, '') p3 = Parameters({'beta': {'two': [3]}}, SETTINGS, '') n1 = Parameters({'name': 'node1'}, SETTINGS, '') r1 = { 'alpha': { 'one': [1, 2] }, 'beta': { 'two': [1, 2] }, 'name': 'node1' } r2 = { 'alpha': { 'one': [1, 2] }, 'beta': { 'two': [1, 2, 3] }, 'name': 'node2' } n1.merge(p1) n1.merge(p2) n1.interpolate() n2 = Parameters({'name': 'node2'}, SETTINGS, '') n2.merge(p1) n2.merge(p2) n2.merge(p3) n2.interpolate() self.assertEqual(n1.as_dict(), r1) self.assertEqual(n2.as_dict(), r2)
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_interpolated_list_type(self): p1 = Parameters({'a': [1, 2, 3]}, SETTINGS, 'first') r = {'a': [1, 2, 3]} self.assertIs(type(p1.as_dict()['a']), ParameterList) p1.interpolate() self.assertIs(type(p1.as_dict()['a']), list) self.assertEqual(p1.as_dict(), r)
def test_merged_interpolated_list_type(self): p1 = Parameters({'a': [1, 2, 3]}, SETTINGS, 'first') p2 = Parameters({'a': [4, 5, 6]}, SETTINGS, 'second') r = {'a': [1, 2, 3, 4, 5, 6]} self.assertIs(type(p1.as_dict()['a']), ParameterList) self.assertIs(type(p2.as_dict()['a']), ParameterList) p1.merge(p2) self.assertIs(type(p1.as_dict()['a']), ValueList) p1.interpolate() self.assertIs(type(p1.as_dict()['a']), list) self.assertEqual(p1.as_dict(), r)
def test_interpolated_dict_type(self): p1 = Parameters({'a': { 'one': 1, 'two': 2, 'three': 3 }}, SETTINGS, 'first') r = {'a': {'one': 1, 'two': 2, 'three': 3}} 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_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_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_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_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_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_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_if_expr_invquery(self): e = {'node1': {'a': 1, 'b': 2}, 'node2': {'a': 3, 'b': 4}} p = Parameters({'exp': '$[ exports:a if exports:b == 4 ]'}, SETTINGS, '') r = {'exp': {'node2': 3}} p.interpolate(e) self.assertEqual(p.as_dict(), r)
def test_exports_failed_render_ignore(self): node1_exports = Exports({'a': '${a}'}, SETTINGS, '') node1_parameters = Parameters( { 'name': 'node1', 'a': 1, 'exp': '$[ +IgnoreErrors exports:a ]' }, SETTINGS, '') node1_entity = Entity(SETTINGS, classes=None, applications=None, parameters=node1_parameters, exports=node1_exports) node2_exports = Exports({'a': '${b}'}, SETTINGS, '') node2_parameters = Parameters({'name': 'node1', 'a': 2}, SETTINGS, '') node2_entity = Entity(SETTINGS, classes=None, applications=None, parameters=node2_parameters, exports=node2_exports) node1_entity.initialise_interpolation() node2_entity.initialise_interpolation() queries = node1_entity.parameters.get_inv_queries() for p, q in queries: node1_entity.interpolate_single_export(q) node2_entity.interpolate_single_export(q) res_inv = {'node1': {'a': 1}, 'node2': {}} res_params = {'a': 1, 'name': 'node1', 'exp': {'node1': 1}} inventory = {} inventory['node1'] = node1_entity.exports.as_dict() inventory['node2'] = node2_entity.exports.as_dict() node1_entity.interpolate(inventory) self.assertDictEqual(node1_parameters.as_dict(), res_params) self.assertDictEqual(inventory, res_inv)
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_interpolate_double_escaping(self): v = ESCAPE_CHARACTER + 'meep' d = {'foo': ESCAPE_CHARACTER + ESCAPE_CHARACTER + 'bar'.join(REFERENCE_SENTINELS), 'bar': 'meep'} p = Parameters(d) p.interpolate() self.assertEqual(p.as_dict()['foo'], v)
def test_interpolate_escaping(self): v = 'bar'.join(REFERENCE_SENTINELS) d = {'foo': ESCAPE_CHARACTER + 'bar'.join(REFERENCE_SENTINELS), 'bar': 'unused'} p = Parameters(d) p.initialise_interpolation() self.assertEqual(p.as_dict()['foo'], v)
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_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_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_interpolate_single(self): v = 42 d = {'foo': 'bar'.join(PARAMETER_INTERPOLATION_SENTINELS), 'bar': v} p = Parameters(d) p.interpolate() self.assertEqual(p.as_dict()['foo'], v)
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_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_interpolate_list(self): l = [41,42,43] d = {'foo': 'bar'.join(REFERENCE_SENTINELS), 'bar': l} p = Parameters(d) p.interpolate() self.assertEqual(p.as_dict()['foo'], l)
def test_interpolate_single(self): v = 42 d = {'foo': 'bar'.join(REFERENCE_SENTINELS), 'bar': v} p = Parameters(d) p.interpolate() self.assertEqual(p.as_dict()['foo'], v)
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_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_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_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_interpolate_list(self): l = [41,42,43] d = {'foo': 'bar'.join(PARAMETER_INTERPOLATION_SENTINELS), 'bar': l} p = Parameters(d) p.interpolate() self.assertEqual(p.as_dict()['foo'], l)
def test_interpolate_multiple(self): v = '42' d = {'foo': 'bar'.join(PARAMETER_INTERPOLATION_SENTINELS) + 'meep'.join(PARAMETER_INTERPOLATION_SENTINELS), 'bar': v[0], 'meep': v[1]} p = Parameters(d) p.interpolate() self.assertEqual(p.as_dict()['foo'], v)
def test_interpolate_multiple(self): v = '42' d = {'foo': 'bar'.join(REFERENCE_SENTINELS) + 'meep'.join(REFERENCE_SENTINELS), 'bar': v[0], 'meep': v[1]} p = Parameters(d) p.interpolate() self.assertEqual(p.as_dict()['foo'], v)
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_dict_merging_for_multiple_nodes(self): p1 = Parameters({ 'alpha': { 'one': { 'a': 'aa', 'b': 'bb' }}}) p2 = Parameters({ 'beta': {'two': '${alpha:one}' }}) p3 = Parameters({ 'beta': {'two': {'c': 'cc' }}}) n1 = Parameters({ 'name': 'node1'}) r1 = { 'alpha': { 'one': {'a': 'aa', 'b': 'bb'} }, 'beta': { 'two': {'a': 'aa', 'b': 'bb'} }, 'name': 'node1' } r2 = { 'alpha': { 'one': {'a': 'aa', 'b': 'bb'} }, 'beta': { 'two': {'a': 'aa', 'b': 'bb', 'c': 'cc'} }, 'name': 'node2' } n1.merge(p1) n1.merge(p2) n1.interpolate() n2 = Parameters({'name': 'node2'}) n2.merge(p1) n2.merge(p2) n2.merge(p3) n2.interpolate() self.assertEqual(n1.as_dict(), r1) self.assertEqual(n2.as_dict(), r2)
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_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_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_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_scalar_over_dict(self): p = Parameters(dict(base=SIMPLE)) mergee = {'base':'foo'} p.merge(Parameters(mergee)) self.assertDictEqual(p.as_dict(), mergee)