mirror of
https://github.com/valitydev/salt.git
synced 2024-11-08 01:18:58 +00:00
367 lines
13 KiB
Python
367 lines
13 KiB
Python
# -*- coding: utf-8 -*-
|
|
'''
|
|
unit tests for the grains state
|
|
'''
|
|
|
|
from __future__ import absolute_import
|
|
|
|
# Import Python libs
|
|
import os
|
|
|
|
# Import Salt Testing libs
|
|
from salttesting import TestCase, skipIf
|
|
from salttesting.helpers import ensure_in_syspath
|
|
from salttesting.mock import NO_MOCK, NO_MOCK_REASON, MagicMock
|
|
|
|
ensure_in_syspath('../../')
|
|
|
|
from salt.modules import grains as grainsmod
|
|
from salt.states import grains as grains
|
|
|
|
import integration
|
|
|
|
|
|
|
|
@skipIf(NO_MOCK, NO_MOCK_REASON)
|
|
class GrainsTestCase(TestCase):
|
|
|
|
# 'present' function tests: 4
|
|
|
|
def setUp(self):
|
|
grains_test_dir = '__salt_test_state_grains'
|
|
grainsmod.__opts__ = grains.__opts__ = {
|
|
'test': False,
|
|
'conf_file': os.path.join(integration.TMP, grains_test_dir, 'minion'),
|
|
'cachedir': os.path.join(integration.TMP, grains_test_dir),
|
|
'local': True,
|
|
}
|
|
|
|
grainsmod.__salt__ = grains.__salt__ = {
|
|
'cmd.run_all': MagicMock(return_value={
|
|
'pid': 5,
|
|
'retcode': 0,
|
|
'stderr': '',
|
|
'stdout': ''}),
|
|
'grains.setval': grainsmod.setval,
|
|
'grains.delval': grainsmod.delval,
|
|
'grains.append': grainsmod.append,
|
|
'grains.remove': grainsmod.remove,
|
|
'saltutil.sync_grains': MagicMock()
|
|
}
|
|
if not os.path.exists(os.path.join(integration.TMP, grains_test_dir)):
|
|
os.mkdir(os.path.join(integration.TMP, grains_test_dir))
|
|
|
|
def test_present_add(self):
|
|
# Set a non existing grain
|
|
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval'}
|
|
ret = grains.present(
|
|
name='foo',
|
|
value='bar')
|
|
self.assertEqual(ret['result'], True)
|
|
self.assertEqual(ret['changes'], {'foo': 'bar'})
|
|
self.assertEqual(
|
|
grains.__grains__,
|
|
{'a': 'aval', 'foo': 'bar'})
|
|
|
|
def test_present_already_set(self):
|
|
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval', 'foo': 'bar'}
|
|
# Grain already set
|
|
ret = grains.present(
|
|
name='foo',
|
|
value='bar')
|
|
self.assertEqual(ret['result'], True)
|
|
self.assertEqual(ret['comment'], 'Grain is already set')
|
|
self.assertEqual(ret['changes'], {})
|
|
self.assertEqual(
|
|
grains.__grains__,
|
|
{'a': 'aval', 'foo': 'bar'})
|
|
|
|
def test_present_overwrite(self):
|
|
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval', 'foo': 'bar'}
|
|
# Overwrite an existing grain
|
|
ret = grains.present(
|
|
name='foo',
|
|
value='newbar')
|
|
self.assertEqual(ret['result'], True)
|
|
self.assertEqual(ret['changes'], {'foo': 'newbar'})
|
|
self.assertEqual(
|
|
grains.__grains__,
|
|
{'a': 'aval', 'foo': 'newbar'})
|
|
|
|
# Overwrite a grain to a list
|
|
ret = grains.present(
|
|
name='foo',
|
|
value=['l1', 'l2'])
|
|
self.assertEqual(ret['result'], True)
|
|
self.assertEqual(ret['changes'], {'foo': ['l1', 'l2']})
|
|
self.assertEqual(
|
|
grains.__grains__,
|
|
{'a': 'aval', 'foo': ['l1', 'l2']})
|
|
|
|
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval', 'foo': 'bar'}
|
|
# Fails setting a grain to a dict
|
|
ret = grains.present(
|
|
name='foo',
|
|
value={'k1': 'v1'})
|
|
self.assertEqual(ret['result'], False)
|
|
self.assertEqual(ret['comment'], 'Grain value cannot be dict')
|
|
self.assertEqual(ret['changes'], {})
|
|
self.assertEqual(
|
|
grains.__grains__,
|
|
{'a': 'aval', 'foo': 'bar'})
|
|
|
|
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval', 'foo': 'bar'}
|
|
# Clear a grain (set to None)
|
|
ret = grains.present(
|
|
name='foo',
|
|
value=None)
|
|
self.assertEqual(ret['result'], True)
|
|
self.assertEqual(ret['changes'], {'foo': None})
|
|
self.assertEqual(
|
|
grains.__grains__,
|
|
{'a': 'aval', 'foo': None})
|
|
|
|
def test_present_unknown_failure(self):
|
|
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval', 'foo': 'bar'}
|
|
# Unknown reason failure
|
|
grainsmod.__salt__['grains.setval'] = MagicMock()
|
|
ret = grains.present(
|
|
name='foo',
|
|
value='baz')
|
|
self.assertEqual(ret['result'], False)
|
|
self.assertEqual(ret['comment'], 'Failed to set grain foo')
|
|
self.assertEqual(ret['changes'], {})
|
|
self.assertEqual(
|
|
grains.__grains__,
|
|
{'a': 'aval', 'foo': 'bar'})
|
|
|
|
# 'absent' function tests: 3
|
|
|
|
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
|
|
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'})
|
|
|
|
# 'append' function tests: 5
|
|
|
|
def test_append(self):
|
|
# Append to an existing list
|
|
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval', 'foo': ['bar']}
|
|
ret = grains.append(
|
|
name='foo',
|
|
value='baz')
|
|
self.assertEqual(ret['result'], True)
|
|
self.assertEqual(ret['comment'], 'Value baz was added to grain foo')
|
|
self.assertEqual(ret['changes'], {'added': 'baz'})
|
|
self.assertEqual(
|
|
grains.__grains__,
|
|
{'a': 'aval', 'foo': ['bar', 'baz']})
|
|
|
|
def test_append_already(self):
|
|
# Append to an existing list
|
|
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval', 'foo': ['bar']}
|
|
ret = grains.append(
|
|
name='foo',
|
|
value='bar')
|
|
self.assertEqual(ret['result'], True)
|
|
self.assertEqual(ret['comment'], 'Value bar is already in the list '
|
|
+ 'for grain foo')
|
|
self.assertEqual(ret['changes'], {})
|
|
self.assertEqual(
|
|
grains.__grains__,
|
|
{'a': 'aval', 'foo': ['bar']})
|
|
|
|
def test_append_fails_not_a_list(self):
|
|
# Fail to append to an existing grain, not a list
|
|
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval', 'foo': {'bar': 'val'}}
|
|
ret = grains.append(
|
|
name='foo',
|
|
value='baz')
|
|
# Note from dr4Ke: should be false, IMO
|
|
self.assertEqual(ret['result'], False)
|
|
self.assertEqual(ret['comment'], 'Grain foo is not a valid list')
|
|
self.assertEqual(ret['changes'], {})
|
|
self.assertEqual(
|
|
grains.__grains__,
|
|
{'a': 'aval', 'foo': {'bar': 'val'}})
|
|
|
|
def test_append_convert_to_list(self):
|
|
# Append to an existing grain, converting to a list
|
|
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval', 'foo': {'bar': 'val'}}
|
|
ret = grains.append(
|
|
name='foo',
|
|
value='baz',
|
|
convert=True)
|
|
self.assertEqual(ret['result'], True)
|
|
self.assertEqual(ret['comment'], 'Value baz was added to grain foo')
|
|
self.assertEqual(ret['changes'], {'added': 'baz'})
|
|
self.assertEqual(
|
|
grains.__grains__,
|
|
{'a': 'aval', 'foo': [{'bar': 'val'}, 'baz']})
|
|
|
|
def test_append_fails_inexistent(self):
|
|
# Append to a non existing grain
|
|
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval'}
|
|
ret = grains.append(
|
|
name='foo',
|
|
value='bar')
|
|
# Note from dr4Ke: should be false, IMO
|
|
self.assertEqual(ret['result'], False)
|
|
self.assertEqual(ret['comment'], 'Grain foo does not exist')
|
|
self.assertEqual(ret['changes'], {})
|
|
self.assertEqual(
|
|
grains.__grains__,
|
|
{'a': 'aval'})
|
|
|
|
# 'list_present' function tests: 5
|
|
|
|
def test_list_present(self):
|
|
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval', 'foo': ['bar']}
|
|
ret = grains.list_present(
|
|
name='foo',
|
|
value='baz')
|
|
self.assertEqual(ret['result'], True)
|
|
self.assertEqual(ret['comment'], 'Append value baz to grain foo')
|
|
self.assertEqual(ret['changes'], {'new': {'foo': ['bar', 'baz']}})
|
|
self.assertEqual(
|
|
grains.__grains__,
|
|
{'a': 'aval', 'foo': ['bar', 'baz']})
|
|
|
|
def test_list_present_inexistent(self):
|
|
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval'}
|
|
ret = grains.list_present(
|
|
name='foo',
|
|
value='baz')
|
|
self.assertEqual(ret['result'], True)
|
|
self.assertEqual(ret['comment'], 'Append value baz to grain foo')
|
|
self.assertEqual(ret['changes'], {'new': {'foo': ['baz']}})
|
|
self.assertEqual(
|
|
grains.__grains__,
|
|
{'a': 'aval', 'foo': ['baz']})
|
|
|
|
def test_list_present_not_a_list(self):
|
|
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval', 'foo': 'bar'}
|
|
ret = grains.list_present(
|
|
name='foo',
|
|
value='baz')
|
|
self.assertEqual(ret['result'], False)
|
|
self.assertEqual(ret['comment'], 'Grain foo is not a valid list')
|
|
self.assertEqual(ret['changes'], {})
|
|
self.assertEqual(
|
|
grains.__grains__,
|
|
{'a': 'aval', 'foo': 'bar'})
|
|
|
|
def test_list_present_already(self):
|
|
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval', 'foo': ['bar']}
|
|
ret = grains.list_present(
|
|
name='foo',
|
|
value='bar')
|
|
self.assertEqual(ret['result'], True)
|
|
self.assertEqual(ret['comment'], 'Value bar is already in grain foo')
|
|
self.assertEqual(ret['changes'], {})
|
|
self.assertEqual(
|
|
grains.__grains__,
|
|
{'a': 'aval', 'foo': ['bar']})
|
|
|
|
def test_list_present_unknown_failure(self):
|
|
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval', 'foo': ['bar']}
|
|
# Unknown reason failure
|
|
grainsmod.__salt__['grains.append'] = MagicMock()
|
|
ret = grains.list_present(
|
|
name='foo',
|
|
value='baz')
|
|
self.assertEqual(ret['result'], False)
|
|
self.assertEqual(ret['comment'], 'Failed append value baz to grain foo')
|
|
self.assertEqual(ret['changes'], {})
|
|
self.assertEqual(
|
|
grains.__grains__,
|
|
{'a': 'aval', 'foo': ['bar']})
|
|
|
|
# 'list_absent' function tests: 4
|
|
|
|
def test_list_absent(self):
|
|
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval', 'foo': ['bar']}
|
|
ret = grains.list_absent(
|
|
name='foo',
|
|
value='bar')
|
|
self.assertEqual(ret['result'], True)
|
|
self.assertEqual(ret['comment'], 'Value bar was deleted from grain foo')
|
|
self.assertEqual(ret['changes'], {'deleted': 'bar'})
|
|
self.assertEqual(
|
|
grains.__grains__,
|
|
{'a': 'aval', 'foo': []})
|
|
|
|
def test_list_absent_inexistent(self):
|
|
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval'}
|
|
ret = grains.list_absent(
|
|
name='foo',
|
|
value='baz')
|
|
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_list_absent_not_a_list(self):
|
|
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval', 'foo': 'bar'}
|
|
ret = grains.list_absent(
|
|
name='foo',
|
|
value='bar')
|
|
# Note from dr4Ke: should be false, IMO
|
|
self.assertEqual(ret['result'], False)
|
|
self.assertEqual(ret['comment'], 'Grain foo is not a valid list')
|
|
self.assertEqual(ret['changes'], {})
|
|
self.assertEqual(
|
|
grains.__grains__,
|
|
{'a': 'aval', 'foo': 'bar'})
|
|
|
|
def test_list_absent_already(self):
|
|
grains.__grains__ = grainsmod.__grains__ = {'a': 'aval', 'foo': ['bar']}
|
|
ret = grains.list_absent(
|
|
name='foo',
|
|
value='baz')
|
|
self.assertEqual(ret['result'], True)
|
|
self.assertEqual(ret['comment'], 'Value baz is absent from grain foo')
|
|
self.assertEqual(ret['changes'], {})
|
|
self.assertEqual(
|
|
grains.__grains__,
|
|
{'a': 'aval', 'foo': ['bar']})
|
|
|
|
|
|
if __name__ == '__main__':
|
|
from integration import run_tests
|
|
run_tests(GrainsTestCase, needs_daemon=False)
|