def test_absent_force_nested_complex_grain(self):
# Unset a nested complex grain
with self.setGrains({
"a":
"aval",
"foo": ["order", {
"is": {
"nested": "bar"
}
}, "correct"]
}):
ret = grains.absent(name="foo:is", force=True)
self.assertEqual(ret["result"], True)
self.assertEqual(ret["comment"],
"Value for grain foo:is was set to None")
self.assertEqual(ret["changes"], {
"grain": "foo:is",
"value": None
})
self.assertEqual(
grains.__grains__,
{
"a": "aval",
"foo": ["order", {
"is": None
}, "correct"]
},
)
self.assertGrainFileContent("a: aval\n" + "foo:\n" + "- order\n" +
"- is: null\n" + "- correct\n")
def test_absent(self):
'''
Test to delete a grain from the grains config file
'''
ret = {'changes': {'grain': self.name, 'value': None},
'name': self.name, 'result': None,
'comment': 'Value for grain cheese is set to be deleted (None)'}
ret1 = {'changes': {}, 'name': self.name, 'result': True,
'comment': 'Grain cheese does not exist'}
with patch.dict(grains.__opts__, {'test': True}):
with patch.dict(grains.__grains__, {self.name: ['edam']}):
self.assertDictEqual(grains.absent(self.name), ret)
self.assertDictEqual(grains.absent(self.name), ret1)
def test_absent_fails_nested_complex_grain(self):
# Unset a nested complex grain
with self.setGrains({
"a":
"aval",
"foo": ["order", {
"is": {
"nested": "bar"
}
}, "correct"]
}):
ret = grains.absent(name="foo:is")
self.assertEqual(ret["result"], False)
self.assertEqual(
ret["comment"],
"The key 'foo:is' exists but is a dict or a list. Use 'force=True' to overwrite.",
)
self.assertEqual(ret["changes"], {})
self.assertEqual(
grains.__grains__,
{
"a": "aval",
"foo": ["order", {
"is": {
"nested": "bar"
}
}, "correct"]
},
)
self.assertGrainFileContent("a: aval\n" + "foo:\n" + "- order\n" +
"- is:\n" + " nested: bar\n" +
"- correct\n")
def test_absent_force_nested_complex_grain(self):
# Unset a nested complex grain
with self.setGrains({
'a':
'aval',
'foo': ['order', {
'is': {
'nested': 'bar'
}
}, 'correct']
}):
ret = grains.absent(name='foo:is', force=True)
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'],
'Value for grain foo:is was set to None')
self.assertEqual(ret['changes'], {
'grain': 'foo:is',
'value': None
})
self.assertEqual(grains.__grains__, {
'a': 'aval',
'foo': ['order', {
'is': None
}, 'correct']
})
self.assertGrainFileContent("a: aval\n" + "foo:\n" + "- order\n" +
"- is: null\n" + "- correct\n")
def test_absent_fails_nested_complex_grain(self):
# Unset a nested complex grain
with self.setGrains({
'a':
'aval',
'foo': ['order', {
'is': {
'nested': 'bar'
}
}, 'correct']
}):
ret = grains.absent(name='foo:is')
self.assertEqual(ret['result'], False)
self.assertEqual(
ret['comment'],
'The key \'foo:is\' exists but is a dict or a list. Use \'force=True\' to overwrite.'
)
self.assertEqual(ret['changes'], {})
self.assertEqual(
grains.__grains__, {
'a': 'aval',
'foo': ['order', {
'is': {
'nested': 'bar'
}
}, 'correct']
})
self.assertGrainFileContent("a: aval\n" + "foo:\n" + "- order\n" +
"- is:\n" + " nested: bar\n" +
"- correct\n")
def test_absent_delete(self):
# Delete a grain
with self.setGrains({'a': 'aval', 'foo': 'bar'}):
ret = grains.absent(name='foo', destructive=True)
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'], 'Grain foo was deleted')
self.assertEqual(ret['changes'], {'deleted': 'foo'})
self.assertEqual(grains.__grains__, {'a': 'aval'})
self.assertGrainFileContent("a: aval\n")
# Delete a previously unset grain
with self.setGrains({'a': 'aval', 'foo': None}):
ret = grains.absent(name='foo', destructive=True)
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'], 'Grain foo was deleted')
self.assertEqual(ret['changes'], {'deleted': 'foo'})
self.assertEqual(grains.__grains__, {'a': 'aval'})
self.assertGrainFileContent("a: aval\n")
# Delete a nested grain
with self.setGrains({
'a':
'aval',
'foo':
['order', {
'is': {
'nested': 'bar',
'other': 'value'
}
}, 'correct']
}):
ret = grains.absent(name='foo:is:nested', destructive=True)
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'], 'Grain foo:is:nested was deleted')
self.assertEqual(ret['changes'], {'deleted': 'foo:is:nested'})
self.assertEqual(
grains.__grains__, {
'a': 'aval',
'foo': ['order', {
'is': {
'other': 'value'
}
}, 'correct']
})
self.assertGrainFileContent("a: aval\n" + "foo:\n" + "- order\n" +
"- is:\n" + " other: value\n" +
"- correct\n")
def test_absent_delete(self):
# Delete a grain
grains.__grains__ = grainsmod.__grains__ = {"a": "aval", "foo": "bar"}
ret = grains.absent(name="foo", destructive=True)
self.assertEqual(ret["result"], True)
self.assertEqual(ret["comment"], "Grain foo was deleted")
self.assertEqual(ret["changes"], {"deleted": "foo"})
self.assertEqual(grains.__grains__, {"a": "aval"})
def test_absent_unset(self):
# Unset a grain
grains.__grains__ = grainsmod.__grains__ = {"a": "aval", "foo": "bar"}
ret = grains.absent(name="foo")
self.assertEqual(ret["result"], True)
self.assertEqual(ret["comment"], "Value for grain foo was set to None")
self.assertEqual(ret["changes"], {"grain": "foo", "value": None})
self.assertEqual(grains.__grains__, {"a": "aval", "foo": None})
def test_absent_already(self):
# Unset a non existent grain
grains.__grains__ = grainsmod.__grains__ = {"a": "aval"}
ret = grains.absent(name="foo")
self.assertEqual(ret["result"], True)
self.assertEqual(ret["comment"], "Grain foo does not exist")
self.assertEqual(ret["changes"], {})
self.assertEqual(grains.__grains__, {"a": "aval"})
def test_absent_delete(self):
# Delete a grain
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval', 'foo': 'bar'}
ret = grains.absent(name='foo', destructive=True)
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'], 'Grain foo was deleted')
self.assertEqual(ret['changes'], {'deleted': 'foo'})
self.assertEqual(grains.__grains__, {'a': 'aval'})
def test_absent_already(self):
# Unset a non existent grain
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval'}
ret = grains.absent(name='foo')
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'], 'Grain foo does not exist')
self.assertEqual(ret['changes'], {})
self.assertEqual(grains.__grains__, {'a': 'aval'})
def test_absent_unset(self):
# Unset a grain
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval', 'foo': 'bar'}
ret = grains.absent(name='foo')
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'], 'Value for grain foo was set to None')
self.assertEqual(ret['changes'], {'grain': 'foo', 'value': None})
self.assertEqual(grains.__grains__, {'a': 'aval', 'foo': None})
def test_absent_delete(self):
# Delete a grain
self.setGrains({'a': 'aval', 'foo': 'bar'})
ret = grains.absent(
name='foo',
destructive=True)
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'], 'Grain foo was deleted')
self.assertEqual(ret['changes'], {'deleted': 'foo'})
self.assertEqual(
grains.__grains__,
{'a': 'aval'})
self.assertGrainFileContent("a: aval\n")
# Delete a previously unset grain
self.setGrains({'a': 'aval', 'foo': None})
ret = grains.absent(
name='foo',
destructive=True)
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'], 'Grain foo was deleted')
self.assertEqual(ret['changes'], {'deleted': 'foo'})
self.assertEqual(
grains.__grains__,
{'a': 'aval'})
self.assertGrainFileContent("a: aval\n")
# Delete a nested grain
self.setGrains({'a': 'aval', 'foo': ['order', {'is': {'nested': 'bar', 'other': 'value'}}, 'correct']})
ret = grains.absent(
name='foo:is:nested',
destructive=True)
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'], 'Grain foo:is:nested was deleted')
self.assertEqual(ret['changes'], {'deleted': 'foo:is:nested'})
self.assertEqual(
grains.__grains__,
{'a': 'aval', 'foo': ['order', {'is': {'other': 'value'}}, 'correct']})
self.assertGrainFileContent("a: aval\n"
+ "foo:\n"
+ "- order\n"
+ "- is:\n"
+ " other: value\n"
+ "- correct\n"
)
def test_absent_unset_test(self):
grains.__opts__['test'] = True
self.setGrains({'a': 'aval', 'foo': 'bar'})
# Overwrite an existing grain
ret = grains.absent(name='foo')
self.assertEqual(ret['result'], None)
self.assertEqual(ret['changes'], {'grain': 'foo', 'value': None})
self.assertEqual(grains.__grains__, {'a': 'aval', 'foo': 'bar'})
self.assertGrainFileContent("a: aval\n" + "foo: bar\n")
def test_absent_already(self):
# Unset a non existent grain
self.setGrains({'a': 'aval'})
ret = grains.absent(name='foo')
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'], 'Grain foo does not exist')
self.assertEqual(ret['changes'], {})
self.assertEqual(grains.__grains__, {'a': 'aval'})
self.assertGrainFileContent("a: aval\n")
# Unset a non existent nested grain
self.setGrains({'a': 'aval'})
ret = grains.absent(name='foo:is:nested')
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'], 'Grain foo:is:nested does not exist')
self.assertEqual(ret['changes'], {})
self.assertEqual(grains.__grains__, {'a': 'aval'})
self.assertGrainFileContent("a: aval\n")
def test_absent_already(self):
# Unset a non existent grain
with self.setGrains({"a": "aval"}):
ret = grains.absent(name="foo")
self.assertEqual(ret["result"], True)
self.assertEqual(ret["comment"], "Grain foo does not exist")
self.assertEqual(ret["changes"], {})
self.assertEqual(grains.__grains__, {"a": "aval"})
self.assertGrainFileContent("a: aval\n")
# Unset a non existent nested grain
with self.setGrains({"a": "aval"}):
ret = grains.absent(name="foo:is:nested")
self.assertEqual(ret["result"], True)
self.assertEqual(ret["comment"],
"Grain foo:is:nested does not exist")
self.assertEqual(ret["changes"], {})
self.assertEqual(grains.__grains__, {"a": "aval"})
self.assertGrainFileContent("a: aval\n")
def test_absent_unset_test(self):
grains.__opts__['test'] = True
self.setGrains({'a': 'aval', 'foo': 'bar'})
# Overwrite an existing grain
ret = grains.absent(name='foo')
self.assertEqual(ret['result'], None)
self.assertEqual(ret['changes'], {'grain': 'foo', 'value': None})
self.assertEqual(
grains.__grains__,
{'a': 'aval', 'foo': 'bar'})
self.assertGrainFileContent("a: aval\n"
+ "foo: bar\n"
)
def test_absent_already(self):
# Unset a non existent grain
self.setGrains({'a': 'aval'})
ret = grains.absent(
name='foo')
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'], 'Grain foo does not exist')
self.assertEqual(ret['changes'], {})
self.assertEqual(
grains.__grains__,
{'a': 'aval'})
self.assertGrainFileContent("a: aval\n")
# Unset a non existent nested grain
self.setGrains({'a': 'aval'})
ret = grains.absent(
name='foo:is:nested')
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'], 'Grain foo:is:nested does not exist')
self.assertEqual(ret['changes'], {})
self.assertEqual(
grains.__grains__,
{'a': 'aval'})
self.assertGrainFileContent("a: aval\n")
def test_absent_unset_test(self):
with patch.dict(grains.__opts__, {"test": True}):
with self.setGrains({"a": "aval", "foo": "bar"}):
# Overwrite an existing grain
ret = grains.absent(name="foo")
self.assertEqual(ret["result"], None)
self.assertEqual(ret["changes"], {
"grain": "foo",
"value": None
})
self.assertEqual(grains.__grains__, {
"a": "aval",
"foo": "bar"
})
self.assertGrainFileContent("a: aval\n" + "foo: bar\n")
def test_absent_force_nested_complex_grain(self):
# Unset a nested complex grain
self.setGrains({'a': 'aval', 'foo': ['order', {'is': {'nested': 'bar'}}, 'correct']})
ret = grains.absent(
name='foo:is',
force=True)
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'], 'Value for grain foo:is was set to None')
self.assertEqual(ret['changes'], {'grain': 'foo:is', 'value': None})
self.assertEqual(
grains.__grains__,
{'a': 'aval', 'foo': ['order', {'is': None}, 'correct']})
self.assertGrainFileContent("a: aval\n"
+ "foo:\n"
+ "- order\n"
+ "- is: null\n"
+ "- correct\n"
)
def test_absent_fails_nested_complex_grain(self):
# Unset a nested complex grain
self.setGrains({'a': 'aval', 'foo': ['order', {'is': {'nested': 'bar'}}, 'correct']})
ret = grains.absent(
name='foo:is')
self.assertEqual(ret['result'], False)
self.assertEqual(ret['comment'], 'The key \'foo:is\' exists but is a dict or a list. Use \'force=True\' to overwrite.')
self.assertEqual(ret['changes'], {})
self.assertEqual(
grains.__grains__,
{'a': 'aval', 'foo': ['order', {'is': {'nested': 'bar'}}, 'correct']})
self.assertGrainFileContent("a: aval\n"
+ "foo:\n"
+ "- order\n"
+ "- is:\n"
+ " nested: bar\n"
+ "- correct\n"
)
def test_absent_unset(self):
# Unset a grain
self.setGrains({'a': 'aval', 'foo': 'bar'})
ret = grains.absent(
name='foo')
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'], 'Value for grain foo was set to None')
self.assertEqual(ret['changes'], {'grain': 'foo', 'value': None})
self.assertEqual(
grains.__grains__,
{'a': 'aval', 'foo': None})
self.assertGrainFileContent("a: aval\n"
+ "foo: null\n"
)
# Unset grain when its value is False
self.setGrains({'a': 'aval', 'foo': False})
ret = grains.absent(
name='foo')
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'], 'Value for grain foo was set to None')
self.assertEqual(ret['changes'], {'grain': 'foo', 'value': None})
self.assertEqual(
grains.__grains__,
{'a': 'aval', 'foo': None})
self.assertGrainFileContent("a: aval\n"
+ "foo: null\n"
)
# Unset a nested grain
self.setGrains({'a': 'aval', 'foo': ['order', {'is': {'nested': 'bar'}}, 'correct']})
ret = grains.absent(
name='foo,is,nested',
delimiter=',')
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'], 'Value for grain foo:is:nested was set to None')
self.assertEqual(ret['changes'], {'grain': 'foo:is:nested', 'value': None})
self.assertEqual(
grains.__grains__,
{'a': 'aval', 'foo': ['order', {'is': {'nested': None}}, 'correct']})
self.assertGrainFileContent("a: aval\n"
+ "foo:\n"
+ "- order\n"
+ "- is:\n"
+ " nested: null\n"
+ "- correct\n"
)
# Unset a nested value don't change anything
self.setGrains({'a': 'aval', 'foo': ['order', {'is': 'nested'}, 'correct']})
ret = grains.absent(
name='foo:is:nested')
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'], 'Grain foo:is:nested does not exist')
self.assertEqual(ret['changes'], {})
self.assertEqual(
grains.__grains__,
{'a': 'aval', 'foo': ['order', {'is': 'nested'}, 'correct']})
self.assertGrainFileContent("a: aval\n"
+ "foo:\n"
+ "- order\n"
+ "- is: nested\n"
+ "- correct\n"
)
def test_absent_unset(self):
# Unset a grain
with self.setGrains({"a": "aval", "foo": "bar"}):
ret = grains.absent(name="foo")
self.assertEqual(ret["result"], True)
self.assertEqual(ret["comment"],
"Value for grain foo was set to None")
self.assertEqual(ret["changes"], {"grain": "foo", "value": None})
self.assertEqual(grains.__grains__, {"a": "aval", "foo": None})
self.assertGrainFileContent("a: aval\n" + "foo: null\n")
# Unset grain when its value is False
with self.setGrains({"a": "aval", "foo": False}):
ret = grains.absent(name="foo")
self.assertEqual(ret["result"], True)
self.assertEqual(ret["comment"],
"Value for grain foo was set to None")
self.assertEqual(ret["changes"], {"grain": "foo", "value": None})
self.assertEqual(grains.__grains__, {"a": "aval", "foo": None})
self.assertGrainFileContent("a: aval\n" + "foo: null\n")
# Unset a nested grain
with self.setGrains({
"a":
"aval",
"foo": ["order", {
"is": {
"nested": "bar"
}
}, "correct"]
}):
ret = grains.absent(name="foo,is,nested", delimiter=",")
self.assertEqual(ret["result"], True)
self.assertEqual(ret["comment"],
"Value for grain foo:is:nested was set to None")
self.assertEqual(ret["changes"], {
"grain": "foo:is:nested",
"value": None
})
self.assertEqual(
grains.__grains__,
{
"a": "aval",
"foo": ["order", {
"is": {
"nested": None
}
}, "correct"]
},
)
self.assertGrainFileContent("a: aval\n" + "foo:\n" + "- order\n" +
"- is:\n" + " nested: null\n" +
"- correct\n")
# Unset a nested value don't change anything
with self.setGrains({
"a": "aval",
"foo": ["order", {
"is": "nested"
}, "correct"]
}):
ret = grains.absent(name="foo:is:nested")
self.assertEqual(ret["result"], True)
self.assertEqual(ret["comment"],
"Grain foo:is:nested does not exist")
self.assertEqual(ret["changes"], {})
self.assertEqual(
grains.__grains__,
{
"a": "aval",
"foo": ["order", {
"is": "nested"
}, "correct"]
},
)
self.assertGrainFileContent("a: aval\n" + "foo:\n" + "- order\n" +
"- is: nested\n" + "- correct\n")
def test_absent_unset(self):
# Unset a grain
with self.setGrains({'a': 'aval', 'foo': 'bar'}):
ret = grains.absent(name='foo')
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'],
'Value for grain foo was set to None')
self.assertEqual(ret['changes'], {'grain': 'foo', 'value': None})
self.assertEqual(grains.__grains__, {'a': 'aval', 'foo': None})
self.assertGrainFileContent("a: aval\n" + "foo: null\n")
# Unset grain when its value is False
with self.setGrains({'a': 'aval', 'foo': False}):
ret = grains.absent(name='foo')
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'],
'Value for grain foo was set to None')
self.assertEqual(ret['changes'], {'grain': 'foo', 'value': None})
self.assertEqual(grains.__grains__, {'a': 'aval', 'foo': None})
self.assertGrainFileContent("a: aval\n" + "foo: null\n")
# Unset a nested grain
with self.setGrains({
'a':
'aval',
'foo': ['order', {
'is': {
'nested': 'bar'
}
}, 'correct']
}):
ret = grains.absent(name='foo,is,nested', delimiter=',')
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'],
'Value for grain foo:is:nested was set to None')
self.assertEqual(ret['changes'], {
'grain': 'foo:is:nested',
'value': None
})
self.assertEqual(
grains.__grains__, {
'a': 'aval',
'foo': ['order', {
'is': {
'nested': None
}
}, 'correct']
})
self.assertGrainFileContent("a: aval\n" + "foo:\n" + "- order\n" +
"- is:\n" + " nested: null\n" +
"- correct\n")
# Unset a nested value don't change anything
with self.setGrains({
'a': 'aval',
'foo': ['order', {
'is': 'nested'
}, 'correct']
}):
ret = grains.absent(name='foo:is:nested')
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'],
'Grain foo:is:nested does not exist')
self.assertEqual(ret['changes'], {})
self.assertEqual(grains.__grains__, {
'a': 'aval',
'foo': ['order', {
'is': 'nested'
}, 'correct']
})
self.assertGrainFileContent("a: aval\n" + "foo:\n" + "- order\n" +
"- is: nested\n" + "- correct\n")
