def test_set_fail_replacing_existing_complex_key(self):
# Fails to set a complex value without 'force'
grainsmod.__grains__ = {'a': 'aval', 'c': 8}
res = grainsmod.set('a', ['item', 12])
self.assertFalse(res['result'])
self.assertEqual(res['comment'], 'The key \'a\' exists and the given value is a '
+ 'dict or a list. Use \'force=True\' to overwrite.')
self.assertEqual(grainsmod.__grains__, {'a': 'aval', 'c': 8})
# Fails to overwrite a complex value without 'force'
grainsmod.__grains__ = {'a': ['item', 12], 'c': 8}
res = grainsmod.set('a', ['item', 14])
self.assertFalse(res['result'])
self.assertEqual(res['comment'], 'The key \'a\' exists but is a dict or a list. '
+ 'Use \'force=True\' to overwrite.')
self.assertEqual(grainsmod.__grains__, {'a': ['item', 12], 'c': 8})
# Fails to overwrite a complex value without 'force' in a nested grain
grainsmod.__grains__ = {'a': 'aval',
'b': ['l1', {'l2': ['val1']}],
'c': 8}
res = grainsmod.set('b,l2', 'val2', delimiter=',')
self.assertFalse(res['result'])
self.assertEqual(res['comment'], 'The key \'b,l2\' exists but is a dict or a '
+ 'list. Use \'force=True\' to overwrite.')
self.assertEqual(grainsmod.__grains__, {'a': 'aval',
'b': ['l1', {'l2': ['val1']}],
'c': 8})
def test_set_value_already_set(self):
# Set a grain to the same simple value
grainsmod.__grains__ = {'a': 12, 'c': 8}
res = grainsmod.set('a', 12)
self.assertTrue(res['result'])
self.assertEqual(res['comment'], 'The value \'12\' was already set for key \'a\'')
self.assertEqual(grainsmod.__grains__, {'a': 12, 'c': 8})
# Set a grain to the same complex value
grainsmod.__grains__ = {'a': ['item', 12], 'c': 8}
res = grainsmod.set('a', ['item', 12])
self.assertTrue(res['result'])
self.assertEqual(res['comment'], 'The value \'[\'item\', 12]\' was already set '
+ 'for key \'a\'')
self.assertEqual(grainsmod.__grains__, {'a': ['item', 12], 'c': 8})
# Set a key to the same simple value in a nested grain
grainsmod.__grains__ = {'a': 'aval', 'b': {'nested': 'val'}, 'c': 8}
res = grainsmod.set('b,nested', 'val', delimiter=',')
self.assertTrue(res['result'])
self.assertEqual(res['comment'], 'The value \'val\' was already set for key '
+ '\'b,nested\'')
self.assertEqual(grainsmod.__grains__, {'a': 'aval',
'b': {'nested': 'val'},
'c': 8})
def test_set_nested_update_dict(self):
grainsmod.__grains__ = {'a': 'aval', 'b': {'nested': 'val'}, 'c': 8}
res = grainsmod.set('b,nested', 'val2', delimiter=',')
self.assertTrue(res['result'])
self.assertEqual(res['changes'], {'b': {'nested': 'val2'}})
self.assertEqual(grainsmod.__grains__, {'a': 'aval',
'b': {'nested': 'val2'},
'c': 8})
def test_set_nested_list_update_dict_key(self):
grainsmod.__grains__ = {'a': 'aval', 'b': ['l1', {'l2': 'val1'}], 'c': 8}
res = grainsmod.set('b,l2', 'val2', delimiter=',')
self.assertTrue(res['result'])
self.assertEqual(res['changes'], {'b': ['l1', {'l2': 'val2'}]})
self.assertEqual(grainsmod.__grains__, {'a': 'aval',
'b': ['l1', {'l2': 'val2'}],
'c': 8})
def test_set_nested_existing_value_overwrite(self):
grainsmod.__grains__ = {'a': 'aval', 'b': 'l1', 'c': 8}
res = grainsmod.set('b,l3', 'val3', delimiter=',', force=True)
self.assertTrue(res['result'])
self.assertEqual(res['changes'], {'b': {'l3': 'val3'}})
self.assertEqual(grainsmod.__grains__, {'a': 'aval',
'b': {'l3': 'val3'},
'c': 8})
def test_set_simple_value(self):
grainsmod.__grains__ = {'a': ['b', 'c'], 'c': 8}
res = grainsmod.set('b', 'bval')
self.assertTrue(res['result'])
self.assertEqual(res['changes'], {'b': 'bval'})
self.assertEqual(grainsmod.__grains__, {'a': ['b', 'c'],
'b': 'bval',
'c': 8})
def test_set_nested_fails_replace_simple_value(self):
# Fails to replace a simple value with a new dictionnary consisting
# of the specified key and value
grainsmod.__grains__ = {'a': 'aval', 'b': 'l1', 'c': 8}
res = grainsmod.set('b,l3', 'val3', delimiter=',')
self.assertFalse(res['result'])
self.assertEqual(res['comment'], 'The key \'b\' value is \'l1\', which is '
+ 'different from the provided key \'l3\'. '
+ 'Use \'force=True\' to overwrite.')
self.assertEqual(grainsmod.__grains__, {'a': 'aval', 'b': 'l1', 'c': 8})
def test_set_nested_list_append_dict_key():
with patch.dict(
grainsmod.__grains__, {"a": "aval", "b": ["l1", {"l2": "val2"}], "c": 8}
):
res = grainsmod.set("b,l3", "val3", delimiter=",")
assert res["result"]
assert res["changes"] == {"b": ["l1", {"l2": "val2"}, {"l3": "val3"}]}
assert grainsmod.__grains__ == {
"a": "aval",
"b": ["l1", {"l2": "val2"}, {"l3": "val3"}],
"c": 8,
}
def test_set_nested_update_dict_new_key():
with patch.dict(
grainsmod.__grains__, {"a": "aval", "b": {"nested": "val"}, "c": 8}
):
res = grainsmod.set("b,b2", "val2", delimiter=",")
assert res["result"]
assert res["changes"] == {"b": {"b2": "val2", "nested": "val"}}
assert grainsmod.__grains__ == {
"a": "aval",
"b": {"b2": "val2", "nested": "val"},
"c": 8,
}
def test_set_nested_create(self):
with patch.dict(grainsmod.__grains__, {"a": "aval", "c": 8}):
res = grainsmod.set("b,nested", "val", delimiter=",")
self.assertTrue(res["result"])
self.assertEqual(res["changes"], {"b": {"nested": "val"}})
self.assertEqual(grainsmod.__grains__, {
"a": "aval",
"b": {
"nested": "val"
},
"c": 8
})
def test_set_deeply_nested_update(self):
grainsmod.__grains__ = {'a': 'aval',
'b': {'l1': ['l21', 'l22', {'l23': 'l23val'}]},
'c': 8}
res = grainsmod.set('b,l1,l23', 'val', delimiter=',')
self.assertTrue(res['result'])
self.assertEqual(res['changes'], {'b': {'l1': ['l21', 'l22', {'l23': 'val'}]}})
self.assertEqual(grainsmod.__grains__, {'a': 'aval',
'b': {'l1': ['l21',
'l22',
{'l23': 'val'}]},
'c': 8})
def test_set_nested_list_append_dict_key(self):
with patch.dict(grainsmod.__grains__, {'a': 'aval',
'b': ['l1', {'l2': 'val2'}],
'c': 8}):
res = grainsmod.set('b,l3', 'val3', delimiter=',')
self.assertTrue(res['result'])
self.assertEqual(res['changes'], {'b': ['l1', {'l2': 'val2'}, {'l3': 'val3'}]})
self.assertEqual(grainsmod.__grains__, {'a': 'aval',
'b': ['l1',
{'l2': 'val2'},
{'l3': 'val3'}],
'c': 8})
def test_set_nested_list_update_dict_key_overwrite():
with patch.dict(
grainsmod.__grains__, {"a": "aval", "b": ["l1", {"l2": ["val1"]}], "c": 8}
):
res = grainsmod.set("b,l2", "val2", delimiter=",", force=True)
assert res["result"]
assert res["changes"] == {"b": ["l1", {"l2": "val2"}]}
assert grainsmod.__grains__ == {
"a": "aval",
"b": ["l1", {"l2": "val2"}],
"c": 8,
}
def test_set_deeply_nested_update(self):
grainsmod.__grains__ = {'a': 'aval',
'b': {'l1': ['l21', 'l22', {'l23': 'l23val'}]},
'c': 8}
res = grainsmod.set('b,l1,l23', 'val', delimiter=',')
self.assertTrue(res['result'])
self.assertEqual(res['changes'], {'b': {'l1': ['l21', 'l22', {'l23': 'val'}]}})
self.assertEqual(grainsmod.__grains__, {'a': 'aval',
'b': {'l1': ['l21',
'l22',
{'l23': 'val'}]},
'c': 8})
def test_set_nested_create(self):
grainsmod.__grains__ = {'a': 'aval', 'c': 8}
res = grainsmod.set('b,nested', 'val', delimiter=',')
self.assertTrue(res['result'])
self.assertEqual(res['changes'], {'b': {'nested': 'val'}})
self.assertEqual(grainsmod.__grains__, {
'a': 'aval',
'b': {
'nested': 'val'
},
'c': 8
})
def test_set_nested_existing_value_overwrite(self):
grainsmod.__grains__ = {'a': 'aval', 'b': 'l1', 'c': 8}
res = grainsmod.set('b,l3', 'val3', delimiter=',', force=True)
self.assertTrue(res['result'])
self.assertEqual(res['changes'], {'b': {'l3': 'val3'}})
self.assertEqual(grainsmod.__grains__, {
'a': 'aval',
'b': {
'l3': 'val3'
},
'c': 8
})
def test_set_nested_list_replace_key(self):
grainsmod.__grains__ = {'a': 'aval', 'b': ['l1', 'l2', 'l3'], 'c': 8}
res = grainsmod.set('b,l2', 'val2', delimiter=',')
self.assertTrue(res['result'])
self.assertEqual(res['changes'], {'b': ['l1', {'l2': 'val2'}, 'l3']})
self.assertEqual(grainsmod.__grains__, {
'a': 'aval',
'b': ['l1', {
'l2': 'val2'
}, 'l3'],
'c': 8
})
def test_set_fail_replacing_existing_complex_key(self):
# Fails to set a complex value without 'force'
grainsmod.__grains__ = {'a': 'aval', 'c': 8}
res = grainsmod.set('a', ['item', 12])
self.assertFalse(res['result'])
self.assertEqual(
res['comment'], 'The key \'a\' exists and the given value is a ' +
'dict or a list. Use \'force=True\' to overwrite.')
self.assertEqual(grainsmod.__grains__, {'a': 'aval', 'c': 8})
# Fails to overwrite a complex value without 'force'
grainsmod.__grains__ = {'a': ['item', 12], 'c': 8}
res = grainsmod.set('a', ['item', 14])
self.assertFalse(res['result'])
self.assertEqual(
res['comment'], 'The key \'a\' exists but is a dict or a list. ' +
'Use \'force=True\' to overwrite.')
self.assertEqual(grainsmod.__grains__, {'a': ['item', 12], 'c': 8})
# Fails to overwrite a complex value without 'force' in a nested grain
grainsmod.__grains__ = {
'a': 'aval',
'b': ['l1', {
'l2': ['val1']
}],
'c': 8
}
res = grainsmod.set('b,l2', 'val2', delimiter=',')
self.assertFalse(res['result'])
self.assertEqual(
res['comment'], 'The key \'b,l2\' exists but is a dict or a ' +
'list. Use \'force=True\' to overwrite.')
self.assertEqual(grainsmod.__grains__, {
'a': 'aval',
'b': ['l1', {
'l2': ['val1']
}],
'c': 8
})
def test_set_nested_list_append_dict_key(self):
with patch.dict(
grainsmod.__grains__, {"a": "aval", "b": ["l1", {"l2": "val2"}], "c": 8}
):
res = grainsmod.set("b,l3", "val3", delimiter=",")
self.assertTrue(res["result"])
self.assertEqual(
res["changes"], {"b": ["l1", {"l2": "val2"}, {"l3": "val3"}]}
)
self.assertEqual(
grainsmod.__grains__,
{"a": "aval", "b": ["l1", {"l2": "val2"}, {"l3": "val3"}], "c": 8},
)
def test_set_nested_fails_replace_simple_value(self):
# Fails to replace a simple value with a new dictionary consisting
# of the specified key and value
with patch.dict(grainsmod.__grains__, {"a": "aval", "b": "l1", "c": 8}):
res = grainsmod.set("b,l3", "val3", delimiter=",")
self.assertFalse(res["result"])
self.assertEqual(
res["comment"],
"The key 'b' value is 'l1', which is "
+ "different from the provided key 'l3'. "
+ "Use 'force=True' to overwrite.",
)
self.assertEqual(grainsmod.__grains__, {"a": "aval", "b": "l1", "c": 8})
def test_set_deeply_nested_update():
with patch.dict(
grainsmod.__grains__,
{"a": "aval", "b": {"l1": ["l21", "l22", {"l23": "l23val"}]}, "c": 8},
):
res = grainsmod.set("b,l1,l23", "val", delimiter=",")
assert res["result"]
assert res["changes"] == {"b": {"l1": ["l21", "l22", {"l23": "val"}]}}
assert grainsmod.__grains__ == {
"a": "aval",
"b": {"l1": ["l21", "l22", {"l23": "val"}]},
"c": 8,
}
def test_set_fail_replacing_existing_complex_key(self):
# Fails to set a complex value without 'force'
with patch.dict(grainsmod.__grains__, {"a": "aval", "c": 8}):
res = grainsmod.set("a", ["item", 12])
self.assertFalse(res["result"])
self.assertEqual(
res["comment"],
"The key 'a' exists and the given value is a "
"dict or a list. Use 'force=True' to overwrite.",
)
self.assertEqual(grainsmod.__grains__, {"a": "aval", "c": 8})
# Fails to overwrite a complex value without 'force'
with patch.dict(grainsmod.__grains__, {"a": ["item", 12], "c": 8}):
res = grainsmod.set("a", ["item", 14])
self.assertFalse(res["result"])
self.assertEqual(
res["comment"],
"The key 'a' exists but is a dict or a list. "
+ "Use 'force=True' to overwrite.",
)
self.assertEqual(grainsmod.__grains__, {"a": ["item", 12], "c": 8})
# Fails to overwrite a complex value without 'force' in a nested grain
with patch.dict(
grainsmod.__grains__, {"a": "aval", "b": ["l1", {"l2": ["val1"]}], "c": 8}
):
res = grainsmod.set("b,l2", "val2", delimiter=",")
self.assertFalse(res["result"])
self.assertEqual(
res["comment"],
"The key 'b,l2' exists but is a dict or a "
+ "list. Use 'force=True' to overwrite.",
)
self.assertEqual(
grainsmod.__grains__,
{"a": "aval", "b": ["l1", {"l2": ["val1"]}], "c": 8},
)
def test_set_value_already_set(self):
# Set a grain to the same simple value
grainsmod.__grains__ = {'a': 12, 'c': 8}
res = grainsmod.set('a', 12)
self.assertTrue(res['result'])
self.assertEqual(res['comment'], 'Grain is already set')
self.assertEqual(grainsmod.__grains__, {'a': 12, 'c': 8})
# Set a grain to the same complex value
grainsmod.__grains__ = {'a': ['item', 12], 'c': 8}
res = grainsmod.set('a', ['item', 12])
self.assertTrue(res['result'])
self.assertEqual(res['comment'], 'Grain is already set')
self.assertEqual(grainsmod.__grains__, {'a': ['item', 12], 'c': 8})
# Set a key to the same simple value in a nested grain
grainsmod.__grains__ = {'a': 'aval', 'b': {'nested': 'val'}, 'c': 8}
res = grainsmod.set('b,nested', 'val', delimiter=',')
self.assertTrue(res['result'])
self.assertEqual(res['comment'], 'Grain is already set')
self.assertEqual(grainsmod.__grains__, {'a': 'aval',
'b': {'nested': 'val'},
'c': 8})
def test_set_deeply_nested_update(self):
with patch.dict(
grainsmod.__grains__,
{"a": "aval", "b": {"l1": ["l21", "l22", {"l23": "l23val"}]}, "c": 8},
):
res = grainsmod.set("b,l1,l23", "val", delimiter=",")
self.assertTrue(res["result"])
self.assertEqual(
res["changes"], {"b": {"l1": ["l21", "l22", {"l23": "val"}]}}
)
self.assertEqual(
grainsmod.__grains__,
{"a": "aval", "b": {"l1": ["l21", "l22", {"l23": "val"}]}, "c": 8},
)
def test_set_nested_fails_replace_simple_value(self):
# Fails to replace a simple value with a new dictionary consisting
# of the specified key and value
grainsmod.__grains__ = {'a': 'aval', 'b': 'l1', 'c': 8}
res = grainsmod.set('b,l3', 'val3', delimiter=',')
self.assertFalse(res['result'])
self.assertEqual(
res['comment'], 'The key \'b\' value is \'l1\', which is ' +
'different from the provided key \'l3\'. ' +
'Use \'force=True\' to overwrite.')
self.assertEqual(grainsmod.__grains__, {
'a': 'aval',
'b': 'l1',
'c': 8
})
def test_set_nested_existing_value_is_the_key(self):
with patch.dict(grainsmod.__grains__, {
'a': 'aval',
'b': 'l3',
'c': 8
}):
res = grainsmod.set('b,l3', 'val3', delimiter=',')
self.assertTrue(res['result'])
self.assertEqual(res['changes'], {'b': {'l3': 'val3'}})
self.assertEqual(grainsmod.__grains__, {
'a': 'aval',
'b': {
'l3': 'val3'
},
'c': 8
})
def test_set_nested_existing_value_overwrite(self):
with patch.dict(grainsmod.__grains__, {
"a": "aval",
"b": "l1",
"c": 8
}):
res = grainsmod.set("b,l3", "val3", delimiter=",", force=True)
self.assertTrue(res["result"])
self.assertEqual(res["changes"], {"b": {"l3": "val3"}})
self.assertEqual(grainsmod.__grains__, {
"a": "aval",
"b": {
"l3": "val3"
},
"c": 8
})
def test_set_deeply_nested_create(self):
with patch.dict(grainsmod.__grains__, {'a': 'aval',
'b': {'l1': ['l21', 'l22', {'l23': 'l23val'}]},
'c': 8}):
res = grainsmod.set('b,l1,l24,l241', 'val', delimiter=',')
self.assertTrue(res['result'])
self.assertEqual(res['changes'], {'b': {'l1': ['l21',
'l22',
{'l23': 'l23val'},
{'l24': {'l241': 'val'}}]}})
self.assertEqual(grainsmod.__grains__, {'a': 'aval',
'b': {'l1': [
'l21',
'l22',
{'l23': 'l23val'},
{'l24': {'l241': 'val'}}]},
'c': 8})
def test_set_nested_list_update_dict_key_overwrite(self):
with patch.dict(grainsmod.__grains__, {
"a": "aval",
"b": ["l1", {
"l2": ["val1"]
}],
"c": 8
}):
res = grainsmod.set("b,l2", "val2", delimiter=",", force=True)
self.assertTrue(res["result"])
self.assertEqual(res["changes"], {"b": ["l1", {"l2": "val2"}]})
self.assertEqual(grainsmod.__grains__, {
"a": "aval",
"b": ["l1", {
"l2": "val2"
}],
"c": 8
})
def test_set_nested_update_dict(self):
with patch.dict(grainsmod.__grains__, {
'a': 'aval',
'b': {
'nested': 'val'
},
'c': 8
}):
res = grainsmod.set('b,nested', 'val2', delimiter=',')
self.assertTrue(res['result'])
self.assertEqual(res['changes'], {'b': {'nested': 'val2'}})
self.assertEqual(grainsmod.__grains__, {
'a': 'aval',
'b': {
'nested': 'val2'
},
'c': 8
})
def test_set_nested_list_update_dict_key_overwrite(self):
grainsmod.__grains__ = {
'a': 'aval',
'b': ['l1', {
'l2': ['val1']
}],
'c': 8
}
res = grainsmod.set('b,l2', 'val2', delimiter=',', force=True)
self.assertTrue(res['result'])
self.assertEqual(res['changes'], {'b': ['l1', {'l2': 'val2'}]})
self.assertEqual(grainsmod.__grains__, {
'a': 'aval',
'b': ['l1', {
'l2': 'val2'
}],
'c': 8
})
def test_set_nested_update_dict_remove_key(self):
with patch.dict(grainsmod.__grains__, {
"a": "aval",
"b": {
"nested": "val"
},
"c": 8
}):
res = grainsmod.set("b,nested",
None,
delimiter=",",
destructive=True)
self.assertTrue(res["result"])
self.assertEqual(res["changes"], {"b": {}})
self.assertEqual(grainsmod.__grains__, {
"a": "aval",
"b": {},
"c": 8
})
def test_set_nested_update_dict_remove_key(self):
with patch.dict(grainsmod.__grains__, {
'a': 'aval',
'b': {
'nested': 'val'
},
'c': 8
}):
res = grainsmod.set('b,nested',
None,
delimiter=',',
destructive=True)
self.assertTrue(res['result'])
self.assertEqual(res['changes'], {'b': {}})
self.assertEqual(grainsmod.__grains__, {
'a': 'aval',
'b': {},
'c': 8
})
def test_set_complex_value_force(self):
grainsmod.__grains__ = {'a': 'aval', 'c': 8}
res = grainsmod.set('a', ['item', 12], force=True)
self.assertTrue(res['result'])
self.assertEqual(res['changes'], {'a': ['item', 12]})
self.assertEqual(grainsmod.__grains__, {'a': ['item', 12], 'c': 8})
def test_set_None_force_destructive(self):
with patch.dict(grainsmod.__grains__, {"a": "aval", "c": 8}):
res = grainsmod.set("a", None, force=True, destructive=True)
self.assertTrue(res["result"])
self.assertEqual(res["changes"], {"a": None})
self.assertEqual(grainsmod.__grains__, {"c": 8})
def test_set_None_replace_ok(self):
with patch.dict(grainsmod.__grains__, {"a": "aval", "c": 8}):
res = grainsmod.set("a", None)
self.assertTrue(res["result"])
self.assertEqual(res["changes"], {"a": None})
self.assertEqual(grainsmod.__grains__, {"a": None, "c": 8})
def test_set_complex_value_force(self):
with patch.dict(grainsmod.__grains__, {"a": "aval", "c": 8}):
res = grainsmod.set("a", ["item", 12], force=True)
self.assertTrue(res["result"])
self.assertEqual(res["changes"], {"a": ["item", 12]})
self.assertEqual(grainsmod.__grains__, {"a": ["item", 12], "c": 8})
def test_set_nested_update_dict_remove_key(self):
grainsmod.__grains__ = {'a': 'aval', 'b': {'nested': 'val'}, 'c': 8}
res = grainsmod.set('b,nested', None, delimiter=',', destructive=True)
self.assertTrue(res['result'])
self.assertEqual(res['changes'], {'b': {}})
self.assertEqual(grainsmod.__grains__, {'a': 'aval', 'b': {}, 'c': 8})
def test_set_complex_value_force(self):
grainsmod.__grains__ = {'a': 'aval', 'c': 8}
res = grainsmod.set('a', ['item', 12], force=True)
self.assertTrue(res['result'])
self.assertEqual(res['changes'], {'a': ['item', 12]})
self.assertEqual(grainsmod.__grains__, {'a': ['item', 12], 'c': 8})
def test_set_None_force_destructive(self):
grainsmod.__grains__ = {'a': 'aval', 'c': 8}
res = grainsmod.set('a', None, force=True, destructive=True)
self.assertTrue(res['result'])
self.assertEqual(res['changes'], {'a': None})
self.assertEqual(grainsmod.__grains__, {'c': 8})
def test_set_None_replace_ok(self):
grainsmod.__grains__ = {'a': 'aval', 'c': 8}
res = grainsmod.set('a', None)
self.assertTrue(res['result'])
self.assertEqual(res['changes'], {'a': None})
self.assertEqual(grainsmod.__grains__, {'a': None, 'c': 8})
def test_set_replace_value(self):
grainsmod.__grains__ = {'a': 'aval', 'c': 8}
res = grainsmod.set('a', 12)
self.assertTrue(res['result'])
self.assertEqual(res['changes'], {'a': 12})
self.assertEqual(grainsmod.__grains__, {'a': 12, 'c': 8})
def test_set_replace_value(self):
with patch.dict(grainsmod.__grains__, {"a": "aval", "c": 8}):
res = grainsmod.set("a", 12)
self.assertTrue(res["result"])
self.assertEqual(res["changes"], {"a": 12})
self.assertEqual(grainsmod.__grains__, {"a": 12, "c": 8})
