def test_append_nested_ok(self):
# Append to an existing list
grainsmod.__grains__ = {'a': {'a_list': ['a', 'b', 'c'], 'b': 'bval'}}
res = grainsmod.append('a:a_list', 'd')
# check the result
self.assertEqual(res, {'a': {'a_list': ['a', 'b', 'c', 'd'], 'b': 'bval'}})
# check the whole grains
self.assertEqual(grainsmod.__grains__, {'a': {'a_list': ['a', 'b', 'c', 'd'], 'b': 'bval'}})
# Append to an non existing list
grainsmod.__grains__ = {'a': {'b': 'bval'}}
res = grainsmod.append('a:a_list', 'd')
# check the result
self.assertEqual(res, {'a': {'a_list': ['d'], 'b': 'bval'}})
# check the whole grains
self.assertEqual(grainsmod.__grains__, {'a': {'a_list': ['d'], 'b': 'bval'}})
# Append to an existing string, with convert
grainsmod.__grains__ = {'a': {'b': 'bval'}}
res = grainsmod.append('a:b', 'd', convert=True)
# check the result
self.assertEqual(res, {'a': {'b': ['bval', 'd']}})
# check the whole grains
self.assertEqual(grainsmod.__grains__, {'a': {'b': ['bval', 'd']}})
# Append to an existing dict, with convert
grainsmod.__grains__ = {'a': {'b': {'b1': 'bval1'}}}
res = grainsmod.append('a:b', 'd', convert=True)
# check the result
self.assertEqual(res, {'a': {'b': [{'b1': 'bval1'}, 'd']}})
# check the whole grains
self.assertEqual(grainsmod.__grains__, {'a': {'b': [{'b1': 'bval1'}, 'd']}})
def test_append_nested_not_a_list(self):
# Failing append to an existing string, without convert
grainsmod.__grains__ = {'a': {'b': 'bval'}}
res = grainsmod.append('a:b', 'd')
self.assertEqual(res, 'The key a:b is not a valid list')
self.assertEqual(grainsmod.__grains__, {'a': {'b': 'bval'}})
# Failing append to an existing dict
grainsmod.__grains__ = {'a': {'b': {'b1': 'bval1'}}}
res = grainsmod.append('a:b', 'd')
self.assertEqual(res, 'The key a:b is not a valid list')
self.assertEqual(grainsmod.__grains__, {'a': {'b': {'b1': 'bval1'}}})
def test_append_not_a_list(self):
# Failing append to an existing string, without convert
grainsmod.__grains__ = {'b': 'bval'}
res = grainsmod.append('b', 'd')
# check the result
self.assertEqual(res, 'The key b is not a valid list')
# check the whole grains
self.assertEqual(grainsmod.__grains__, {'b': 'bval'})
# Failing append to an existing dict
grainsmod.__grains__ = {'b': {'b1': 'bval1'}}
res = grainsmod.append('b', 'd')
# check the result
self.assertEqual(res, 'The key b is not a valid list')
# check the whole grains
self.assertEqual(grainsmod.__grains__, {'b': {'b1': 'bval1'}})
def test_append_to_an_element_of_a_list(self):
# Append to an element in a list
# It currently fails silently
grainsmod.__grains__ = {'a': ['b', 'c']}
res = grainsmod.append('a:b', 'd')
self.assertEqual(res, {'a': ['b', 'c']})
self.assertEqual(grainsmod.__grains__, {'a': ['b', 'c']})
def test_append_to_an_element_of_a_list(self):
# Append to an element in a list
# It currently fails silently
grainsmod.__grains__ = {'a': ['b', 'c']}
res = grainsmod.append('a:b', 'd')
self.assertEqual(res, {'a': ['b', 'c']})
self.assertEqual(grainsmod.__grains__, {'a': ['b', 'c']})
def test_append_to_an_element_of_a_list(self):
# Append to an element in a list
# It currently fails silently
with patch.dict(grainsmod.__grains__, {"a": ["b", "c"]}):
res = grainsmod.append("a:b", "d")
self.assertEqual(res, {"a": ["b", "c"]})
self.assertEqual(grainsmod.__grains__, {"a": ["b", "c"]})
def test_append_nested_not_a_list(self):
# Failing append to an existing string, without convert
grainsmod.__grains__ = {'a': {'b': 'bval'}}
res = grainsmod.append('a:b', 'd')
# check the result
self.assertEqual(res, 'The key a:b is not a valid list')
# check the whole grains
self.assertEqual(grainsmod.__grains__, {'a': {'b': 'bval'}})
# Failing append to an existing dict
grainsmod.__grains__ = {'a': {'b': {'b1': 'bval1'}}}
res = grainsmod.append('a:b', 'd')
# check the result
self.assertEqual(res, 'The key a:b is not a valid list')
# check the whole grains
self.assertEqual(grainsmod.__grains__, {'a': {'b': {'b1': 'bval1'}}})
def test_append_nested_already_in_list():
with patch.dict(
grainsmod.__grains__, {"a": {"a_list": ["a", "b", "c"], "b": "bval"}}
):
res = grainsmod.append("a:a_list", "b")
assert res == "The val b was already in the list a:a_list"
assert grainsmod.__grains__ == {"a": {"a_list": ["a", "b", "c"], "b": "bval"}}
def test_append_nested_ok(self):
# Append to an existing list
with patch.dict(grainsmod.__grains__,
{"a": {
"a_list": ["a", "b", "c"],
"b": "bval"
}}):
res = grainsmod.append("a:a_list", "d")
self.assertEqual(
res, {"a": {
"a_list": ["a", "b", "c", "d"],
"b": "bval"
}})
self.assertEqual(
grainsmod.__grains__,
{"a": {
"a_list": ["a", "b", "c", "d"],
"b": "bval"
}},
)
# Append to an non existing list
with patch.dict(grainsmod.__grains__, {"a": {"b": "bval"}}):
res = grainsmod.append("a:a_list", "d")
self.assertEqual(res, {"a": {"a_list": ["d"], "b": "bval"}})
self.assertEqual(grainsmod.__grains__,
{"a": {
"a_list": ["d"],
"b": "bval"
}})
# Append to an existing string, with convert
with patch.dict(grainsmod.__grains__, {"a": {"b": "bval"}}):
res = grainsmod.append("a:b", "d", convert=True)
self.assertEqual(res, {"a": {"b": ["bval", "d"]}})
self.assertEqual(grainsmod.__grains__, {"a": {"b": ["bval", "d"]}})
# Append to an existing dict, with convert
with patch.dict(grainsmod.__grains__, {"a": {"b": {"b1": "bval1"}}}):
res = grainsmod.append("a:b", "d", convert=True)
self.assertEqual(res, {"a": {"b": [{"b1": "bval1"}, "d"]}})
self.assertEqual(grainsmod.__grains__,
{"a": {
"b": [{
"b1": "bval1"
}, "d"]
}})
def test_append_already_in_list(self):
# Append an existing value
with patch.dict(grainsmod.__grains__, {"a_list": ["a", "b", "c"], "b": "bval"}):
res = grainsmod.append("a_list", "b")
self.assertEqual(res, "The val b was already in the list a_list")
self.assertEqual(
grainsmod.__grains__, {"a_list": ["a", "b", "c"], "b": "bval"}
)
def test_append_nested_already_in_list(self):
# Append an existing value
grainsmod.__grains__ = {'a': {'a_list': ['a', 'b', 'c'], 'b': 'bval'}}
res = grainsmod.append('a:a_list', 'b')
# check the result
self.assertEqual(res, 'The val b was already in the list a:a_list')
# check the whole grains
self.assertEqual(grainsmod.__grains__, {'a': {'a_list': ['a', 'b', 'c'], 'b': 'bval'}})
def test_append_nested_not_a_list(self):
# Failing append to an existing string, without convert
with patch.dict(grainsmod.__grains__, {"a": {"b": "bval"}}):
res = grainsmod.append("a:b", "d")
self.assertEqual(res, "The key a:b is not a valid list")
self.assertEqual(grainsmod.__grains__, {"a": {"b": "bval"}})
# Failing append to an existing dict
with patch.dict(grainsmod.__grains__, {"a": {"b": {"b1": "bval1"}}}):
res = grainsmod.append("a:b", "d")
self.assertEqual(res, "The key a:b is not a valid list")
self.assertEqual(grainsmod.__grains__,
{"a": {
"b": {
"b1": "bval1"
}
}})
def test_append_nested_ok(self):
# Append to an existing list
with patch.dict(grainsmod.__grains__,
{'a': {
'a_list': ['a', 'b', 'c'],
'b': 'bval'
}}):
res = grainsmod.append('a:a_list', 'd')
self.assertEqual(
res, {'a': {
'a_list': ['a', 'b', 'c', 'd'],
'b': 'bval'
}})
self.assertEqual(
grainsmod.__grains__,
{'a': {
'a_list': ['a', 'b', 'c', 'd'],
'b': 'bval'
}})
# Append to an non existing list
with patch.dict(grainsmod.__grains__, {'a': {'b': 'bval'}}):
res = grainsmod.append('a:a_list', 'd')
self.assertEqual(res, {'a': {'a_list': ['d'], 'b': 'bval'}})
self.assertEqual(grainsmod.__grains__,
{'a': {
'a_list': ['d'],
'b': 'bval'
}})
# Append to an existing string, with convert
with patch.dict(grainsmod.__grains__, {'a': {'b': 'bval'}}):
res = grainsmod.append('a:b', 'd', convert=True)
self.assertEqual(res, {'a': {'b': ['bval', 'd']}})
self.assertEqual(grainsmod.__grains__, {'a': {'b': ['bval', 'd']}})
# Append to an existing dict, with convert
with patch.dict(grainsmod.__grains__, {'a': {'b': {'b1': 'bval1'}}}):
res = grainsmod.append('a:b', 'd', convert=True)
self.assertEqual(res, {'a': {'b': [{'b1': 'bval1'}, 'd']}})
self.assertEqual(grainsmod.__grains__,
{'a': {
'b': [{
'b1': 'bval1'
}, 'd']
}})
def test_append_nested_not_a_list(self):
# Failing append to an existing string, without convert
with patch.dict(grainsmod.__grains__, {'a': {'b': 'bval'}}):
res = grainsmod.append('a:b', 'd')
self.assertEqual(res, 'The key a:b is not a valid list')
self.assertEqual(grainsmod.__grains__, {'a': {'b': 'bval'}})
# Failing append to an existing dict
with patch.dict(grainsmod.__grains__, {'a': {'b': {'b1': 'bval1'}}}):
res = grainsmod.append('a:b', 'd')
self.assertEqual(res, 'The key a:b is not a valid list')
self.assertEqual(grainsmod.__grains__,
{'a': {
'b': {
'b1': 'bval1'
}
}})
def test_append_already_in_list(self):
# Append an existing value
grainsmod.__grains__ = {'a_list': ['a', 'b', 'c'], 'b': 'bval'}
res = grainsmod.append('a_list', 'b')
self.assertEqual(res, 'The val b was already in the list a_list')
self.assertEqual(grainsmod.__grains__, {
'a_list': ['a', 'b', 'c'],
'b': 'bval'
})
def test_append_ok():
with patch.dict(grainsmod.__grains__, {"a_list": ["a", "b", "c"], "b": "bval"}):
res = grainsmod.append("a_list", "d")
assert res == {"a_list": ["a", "b", "c", "d"]}
assert grainsmod.__grains__ == {"a_list": ["a", "b", "c", "d"], "b": "bval"}
with patch.dict(grainsmod.__grains__, {"b": "bval"}):
res = grainsmod.append("a_list", "d")
assert res == {"a_list": ["d"]}
assert grainsmod.__grains__ == {"a_list": ["d"], "b": "bval"}
with patch.dict(grainsmod.__grains__, {"b": "bval"}):
res = grainsmod.append("b", "d", convert=True)
assert res == {"b": ["bval", "d"]}
assert grainsmod.__grains__ == {"b": ["bval", "d"]}
with patch.dict(grainsmod.__grains__, {"b": {"b1": "bval1"}}):
res = grainsmod.append("b", "d", convert=True)
assert res == {"b": [{"b1": "bval1"}, "d"]}
assert grainsmod.__grains__ == {"b": [{"b1": "bval1"}, "d"]}
def test_append_nested_already_in_list(self):
# Append an existing value
grainsmod.__grains__ = {'a': {'a_list': ['a', 'b', 'c'], 'b': 'bval'}}
res = grainsmod.append('a:a_list', 'b')
# check the result
self.assertEqual(res, 'The val b was already in the list a:a_list')
# check the whole grains
self.assertEqual(grainsmod.__grains__,
{'a': {
'a_list': ['a', 'b', 'c'],
'b': 'bval'
}})
def test_append_nested_already_in_list(self):
# Append an existing value
with patch.dict(grainsmod.__grains__,
{'a': {
'a_list': ['a', 'b', 'c'],
'b': 'bval'
}}):
res = grainsmod.append('a:a_list', 'b')
self.assertEqual(res, 'The val b was already in the list a:a_list')
self.assertEqual(grainsmod.__grains__,
{'a': {
'a_list': ['a', 'b', 'c'],
'b': 'bval'
}})
def test_append_ok(self):
# Append to an existing list
grainsmod.__grains__ = {'a_list': ['a', 'b', 'c'], 'b': 'bval'}
res = grainsmod.append('a_list', 'd')
self.assertEqual(res, {'a_list': ['a', 'b', 'c', 'd']})
self.assertEqual(grainsmod.__grains__, {'a_list': ['a', 'b', 'c', 'd'], 'b': 'bval'})
# Append to an non existing list
grainsmod.__grains__ = {'b': 'bval'}
res = grainsmod.append('a_list', 'd')
self.assertEqual(res, {'a_list': ['d']})
self.assertEqual(grainsmod.__grains__, {'a_list': ['d'], 'b': 'bval'})
# Append to an existing string, with convert
grainsmod.__grains__ = {'b': 'bval'}
res = grainsmod.append('b', 'd', convert=True)
self.assertEqual(res, {'b': ['bval', 'd']})
self.assertEqual(grainsmod.__grains__, {'b': ['bval', 'd']})
# Append to an existing dict, with convert
grainsmod.__grains__ = {'b': {'b1': 'bval1'}}
res = grainsmod.append('b', 'd', convert=True)
self.assertEqual(res, {'b': [{'b1': 'bval1'}, 'd']})
self.assertEqual(grainsmod.__grains__, {'b': [{'b1': 'bval1'}, 'd']})
def test_append_already_in_list(self):
# Append an existing value
grainsmod.__grains__ = {'a_list': ['a', 'b', 'c'], 'b': 'bval'}
res = grainsmod.append('a_list', 'b')
self.assertEqual(res, 'The val b was already in the list a_list')
self.assertEqual(grainsmod.__grains__, {'a_list': ['a', 'b', 'c'], 'b': 'bval'})
def test_append_to_an_element_of_a_list():
with patch.dict(grainsmod.__grains__, {"a": ["b", "c"]}):
res = grainsmod.append("a:b", "d")
assert res == {"a": ["b", "c"]}
assert grainsmod.__grains__ == {"a": ["b", "c"]}
