def test_exports_failed_render(self): node1_exports = Exports({'a': '${a}'}, SETTINGS, '') node1_parameters = Parameters( { 'name': 'node1', 'a': 1, 'exp': '$[ 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': 'node2', '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() with self.assertRaises(ResolveError): for p, q in queries: node1_entity.interpolate_single_export(q) node2_entity.interpolate_single_export(q)
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_interpolate_list_types(self): node1_exports = Exports({'exps': ['${one}']}, SETTINGS, 'first') node1_parameters = Parameters( { 'alpha': ['${two}', '${three}'], 'one': 1, 'two': 2, 'three': 3 }, SETTINGS, 'first') node1_entity = Entity(SETTINGS, classes=None, applications=None, parameters=node1_parameters, exports=node1_exports) node2_exports = Exports({'exps': '${alpha}'}, SETTINGS, 'second') node2_parameters = Parameters({}, SETTINGS, 'second') node2_entity = Entity(SETTINGS, classes=None, applications=None, parameters=node2_parameters, exports=node2_exports) result = {'exps': [1, 2, 3]} node1_entity.merge(node2_entity) node1_entity.interpolate(None) self.assertIs(type(node1_entity.exports.as_dict()['exps']), list) self.assertDictEqual(node1_entity.exports.as_dict(), result)
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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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_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 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_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_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_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 _get_scalar_parameters(self, node_parameters): if self._settings.scalar_parameters: scalars = node_parameters.as_dict().get( self._settings.scalar_parameters, {}) return Parameters({self._settings.scalar_parameters: scalars}, self._settings, '__scalar__') else: return Parameters({}, self._settings, '')
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)