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_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_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_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_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_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_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_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_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_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_infrecursion(self):
v = 42
d = {'foo': 'bar'.join(PARAMETER_INTERPOLATION_SENTINELS),
'bar': 'foo'.join(PARAMETER_INTERPOLATION_SENTINELS)}
p = Parameters(d)
with self.assertRaises(InfiniteRecursionError):
p.interpolate()
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_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_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_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_interpolate_infrecursion(self):
v = 42
d = {'foo': 'bar'.join(REFERENCE_SENTINELS),
'bar': 'foo'.join(REFERENCE_SENTINELS)}
p = Parameters(d)
with self.assertRaises(InfiniteRecursionError):
p.interpolate()
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_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_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_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_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_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_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_merging_inv_queries(self):
e = {'node1': {'a': 1}, 'node2': {'a': 1}, 'node3': {'a': 2}}
p1 = Parameters({'exp': '$[ if exports:a == 1 ]'}, SETTINGS, '')
p2 = Parameters({'exp': '$[ if exports:a == 2 ]'}, SETTINGS, '')
r = {'exp': ['node1', 'node2', 'node3']}
p1.merge(p2)
p1.interpolate(e)
self.assertEqual(p1.as_dict(), r)
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_if_expr_exports_with_refs(self):
e = {'node1': {'a': 1, 'b': 2}, 'node2': {'a': 3, 'b': 4}}
p = Parameters({
'exp': '$[ exports:a if exports:b == self:test_value ]',
'test_value': 2
})
r = {'exp': {'node1': 1}, 'test_value': 2}
p.interpolate(e)
self.assertEqual(p.as_dict(), r)
def test_interpolate_infrecursion(self):
v = 42
d = {
'foo': 'bar'.join(SETTINGS.reference_sentinels),
'bar': 'foo'.join(SETTINGS.reference_sentinels)
}
p = Parameters(d, SETTINGS, '')
with self.assertRaises(InfiniteRecursionError):
p.interpolate()
def test_merge_none_over_dict(self):
p1 = Parameters(dict(key=SIMPLE), SETTINGS, '')
p2 = Parameters(dict(key=None), SETTINGS, '')
with self.assertRaises(TypeMergeError) as e:
p1.merge(p2)
p1.interpolate()
self.assertEqual(
e.exception.message,
"-> \n Cannot merge scalar over dictionary, at key, in ; ")
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_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)
