# Globals
defaults.__grains__ = {}
defaults.__salt__ = {}
defaults.__opts__ = {}
@skipIf(NO_MOCK, NO_MOCK_REASON)
class DefaultsTestCase(TestCase):
'''
Test cases for salt.modules.defaults
'''
@patch('salt.modules.defaults.get',
MagicMock(return_value={'users': {
'root': [0]
}}))
def test_get_mock(self):
'''
Test if it execute a defaults client run and return a dict
'''
with patch.object(inspect, 'stack', MagicMock(return_value=[])):
self.assertEqual(defaults.get('core:users:root'),
{'users': {
'root': [0]
}})
if __name__ == '__main__':
from integration import run_tests
run_tests(DefaultsTestCase, needs_daemon=False)
raise AssertionError(
'No exception should have been raised: {0}'.format(err)
)
# Remove the testing handler
log.removeHandler(handler)
# Test for a format which does not include digits in name formatting.
log_format = '[%(name)s] %(message)s'
handler = TestsLoggingHandler(format=log_format)
log.addHandler(handler)
# Trigger TestsLoggingHandler.__enter__
with handler:
# Let's create another log instance to trigger salt's logging class
# calculations.
try:
saltlog.SaltLoggingClass('{0}.without_digits'.format(__name__))
except Exception as err:
raise AssertionError(
'No exception should have been raised: {0}'.format(err)
)
# Remove the testing handler
log.removeHandler(handler)
if __name__ == '__main__':
from integration import run_tests
run_tests(TestLog, needs_daemon=False)
fd.write("foo")
fd.close()
finder = salt.utils.find.Finder({'name': 'test_name'})
self.assertEqual(list(finder.find('')), [])
finder = salt.utils.find.Finder({'name': 'hello.txt'})
self.assertEqual(list(finder.find(self.tmpdir)), [hello_file])
finder = salt.utils.find.Finder({'type': 'f', 'print': 'path'})
self.assertEqual(list(finder.find(self.tmpdir)),
[os.path.join(self.tmpdir, 'hello.txt')])
finder = salt.utils.find.Finder({'size': '+1G', 'print': 'path'})
self.assertEqual(list(finder.find(self.tmpdir)), [])
finder = salt.utils.find.Finder(
{'name': 'hello.txt', 'print': 'path name'}
)
self.assertEqual(
list(finder.find(self.tmpdir)), [[hello_file, 'hello.txt']]
)
if __name__ == '__main__':
from integration import run_tests
run_tests(
[TestFind, TestGrepOption, TestPrintOption, TestFinder],
needs_daemon=False
)
self.proc = self.result[pid]
def test_cmd_is_empty_string(self):
self.assertEqual(self.proc['cmd'], '')
#class TestProcsComInitialization(TestProcsBase):
# def setUp(self):
# call_count = 5
# for _ in range(call_count):
# self.call_procs()
# self.expected_calls = [call()] * call_count
#
# def test_initialize_and_uninitialize_called(self):
# pythoncom.CoInitialize.assert_has_calls(self.expected_calls)
# pythoncom.CoUninitialize.assert_has_calls(self.expected_calls)
if __name__ == '__main__':
from integration import run_tests
run_tests(
[
TestProcsCount,
TestProcsAttributes,
TestProcsUnicodeAttributes,
TestProcsWMIGetOwnerErrorsAreLogged,
TestProcsWMIGetOwnerAccessDeniedWorkaround,
],
needs_daemon=False
)
mock = MagicMock(side_effect=[['rahulha@salt'], [''], ['']])
with patch.dict(rabbitmq_cluster.__salt__,
{"rabbitmq.cluster_status": mock}):
ret.update({'comment': 'Already in cluster'})
self.assertDictEqual(rabbitmq_cluster.joined('salt', 'salt',
'rahulha'), ret)
with patch.dict(rabbitmq_cluster.__opts__, {"test": True}):
ret.update({'result': None,
'comment': 'Node is set to join '
'cluster rahulha@salt'})
self.assertDictEqual(rabbitmq_cluster.joined('salt', 'salt',
'rahulha'), ret)
with patch.dict(rabbitmq_cluster.__opts__, {"test": False}):
mock = MagicMock(return_value={'Error': 'ERR'})
with patch.dict(rabbitmq_cluster.__salt__,
{"rabbitmq.join_cluster": mock}):
ret.update({'result': False,
'comment': 'ERR'})
self.assertDictEqual(rabbitmq_cluster.joined('salt',
'salt',
'rahulha'),
ret)
if __name__ == '__main__':
from integration import run_tests
run_tests(RabbitmqClusterTestCase, needs_daemon=False)
with patch.dict(__opts__, {'ipv6': False, 'master': float('127.0'), 'master_port': '4555', 'retry_dns': False}):
self.assertRaises(SaltSystemExit, minion.resolve_dns, __opts__)
@skipIf(os.geteuid() != 0, 'You must be logged in as root to run this test')
def test_sock_path_len(self):
'''
This tests whether or not a larger hash causes the sock path to exceed
the system's max sock path length. See the below link for more
information.
https://github.com/saltstack/salt/issues/12172#issuecomment-43903643
'''
opts = {
'id': 'salt-testing',
'hash_type': 'sha512',
'sock_dir': os.path.join(salt.syspaths.SOCK_DIR, 'minion')
}
with patch.dict(__opts__, opts):
testminion = minion.MinionBase(__opts__)
try:
testminion._prepare_minion_event_system()
result = True
except SaltSystemExit:
result = False
self.assertTrue(result)
if __name__ == '__main__':
from integration import run_tests
run_tests(MinionTestCase, needs_daemon=False)
signer = RSAX931Signer('bogus key data')
with self.assertRaises(ValueError):
signer = RSAX931Signer(RSAX931Test.pubkey_data)
signer = RSAX931Signer(RSAX931Test.privkey_data)
with self.assertRaises(ValueError):
signer.sign('x'*255) # message too long
sig = signer.sign(RSAX931Test.hello_world)
self.assertEqual(RSAX931Test.hello_world_sig, sig)
def test_verifier(self):
with self.assertRaises(ValueError):
verifier = RSAX931Verifier('bogus key data')
with self.assertRaises(ValueError):
verifier = RSAX931Verifier(RSAX931Test.privkey_data)
verifier = RSAX931Verifier(RSAX931Test.pubkey_data)
with self.assertRaises(ValueError):
verifier.verify('')
with self.assertRaises(ValueError):
verifier.verify(RSAX931Test.hello_world_sig + b'junk')
msg = verifier.verify(RSAX931Test.hello_world_sig)
self.assertEqual(RSAX931Test.hello_world, msg)
if __name__ == '__main__':
from integration import run_tests
run_tests(RSAX931Test, needs_daemon=False)
with salt.utils.fopen(conf_file, 'r') as f_in:
for line in f_in:
if to_find in line:
return True
return False
@destructiveTest
@skipIf(os.geteuid() != 0,
'You must be logged in as root to run this test')
@requires_system_grains
def tearDown(self, grains=None):
'''
Clean up after tests
'''
ret = self.run_function('sysctl.get', [ASSIGN_CMD])
if ret != self.val:
self.run_function('sysctl.assign', [ASSIGN_CMD, self.val])
if self.has_conf is True:
# restore original sysctl file
self.__restore_sysctl()
if self.has_conf is False and os.path.isfile(CONFIG):
# remove sysctl.conf created by tests
os.remove(CONFIG)
if __name__ == '__main__':
from integration import run_tests
run_tests(DarwinSysctlModuleTest)
method='POST',
body=urlencode(self.auth_creds),
headers={'Content-Type': self.content_type_map['form']})
token = json.loads(response.body)['return'][0]['token']
url = 'ws://127.0.0.1:{0}/hook/{1}'.format(self.get_http_port(), token)
# Example.com should works
request = HTTPRequest(url,
headers={
'Origin': 'http://example.com',
'Host': 'example.com'
})
ws = yield websocket_connect(request)
ws.write_message('websocket client ready')
ws.close()
# Foo.bar too
request = HTTPRequest(url,
headers={
'Origin': 'http://foo.bar',
'Host': 'example.com'
})
ws = yield websocket_connect(request)
ws.write_message('websocket client ready')
ws.close()
if __name__ == '__main__':
from integration import run_tests # pylint: disable=import-error
run_tests(TestBaseSaltAPIHandler, TestSaltAuthHandler, needs_daemon=False)
'retcode': 0,
'stdout': 'stdout'
})
}):
with patch.object(rbenv, 'rehash', return_value=None):
self.assertEqual(rbenv.do(), 'stdout')
with patch.dict(
rbenv.__salt__, {
'cmd.run_all':
MagicMock(return_value={
'retcode': 1,
'stdout': 'stdout'
})
}):
with patch.object(rbenv, 'rehash', return_value=None):
self.assertFalse(rbenv.do(), 'stdout')
def test_do_with_ruby(self):
'''
Test for execute a ruby command with rbenv's shims using a
specific ruby version.
'''
with patch.object(rbenv, 'do', return_value='A'):
self.assertEqual(rbenv.do_with_ruby('ruby', 'cmdline'), 'A')
if __name__ == '__main__':
from integration import run_tests
run_tests(RbenvTestCase, needs_daemon=False)
self.assertIn('Gromit', data)
self.assertNotIn('Comte', data)
finally:
os.unlink(tgt)
def test_get_file_from_env_in_url(self):
tgt = os.path.join(integration.TMP, 'cheese')
try:
self.run_function('cp.get_file', ['salt://cheese?env=prod', tgt])
with salt.utils.fopen(tgt, 'r') as cheese:
data = cheese.read()
self.assertIn('Gromit', data)
self.assertIn('Comte', data)
finally:
os.unlink(tgt)
try:
self.run_function('cp.get_file',
['salt://cheese?saltenv=prod', tgt])
with salt.utils.fopen(tgt, 'r') as cheese:
data = cheese.read()
self.assertIn('Gromit', data)
self.assertIn('Comte', data)
finally:
os.unlink(tgt)
if __name__ == '__main__':
from integration import run_tests
run_tests(CPModuleTest)
'''
sys.list_moduels
'''
mods = self.run_function('sys.list_modules')
self.assertTrue('hosts' in mods)
self.assertTrue('pkg' in mods)
def test_valid_docs(self):
'''
Make sure no functions are exposed that don't have valid docstrings
'''
docs = self.run_function('sys.doc')
bad = set()
for fun in docs:
if fun.startswith('runtests_helpers'):
continue
if not isinstance(docs[fun], basestring):
bad.add(fun)
elif not 'Example::' in docs[fun]:
if not 'Examples::' in docs[fun]:
bad.add(fun)
if bad:
import pprint
pprint.pprint(sorted(bad))
self.assertFalse(bool(bad))
if __name__ == '__main__':
from integration import run_tests
run_tests(SysModuleTest)
Test get_slave_status in the mysql execution module
'''
self._test_call(mysql.get_slave_status, 'SHOW SLAVE STATUS')
@skipIf(True,
'MySQL module claims this function is not ready for production')
def test_free_slave(self):
pass
def test_query(self):
self._test_call(mysql.query, 'SELECT * FROM testdb', 'testdb',
'SELECT * FROM testdb')
def _test_call(self, function, expected_sql, *args, **kwargs):
connect_mock = MagicMock()
mysql._connect = connect_mock
with patch.dict(mysql.__salt__, {'config.option': MagicMock()}):
function(*args, **kwargs)
if isinstance(expected_sql, dict):
calls = call().cursor().execute(
'{0}'.format(expected_sql['sql']),
expected_sql['sql_args'])
else:
calls = call().cursor().execute('{0}'.format(expected_sql))
connect_mock.assert_has_calls((calls, ), True)
if __name__ == '__main__':
from integration import run_tests
run_tests(MySQLTestCase, needs_daemon=False)
# Only run the state once and keep the return data
state_run = self.run_function('state.sls', mods='requisites.listen_simple')
# Both listeners are expected to trigger
listener_state = 'cmd_|-listener_test_listening_resolution_one_|-echo "Successful listen resolution"_|-mod_watch'
self.assertIn(listener_state, state_run)
listener_state = 'cmd_|-listener_test_listening_resolution_two_|-echo "Successful listen resolution"_|-mod_watch'
self.assertIn(listener_state, state_run)
def test_issue_30820_requisite_in_match_by_name(self):
'''
This tests the case where a requisite_in matches by name instead of ID
See https://github.com/saltstack/salt/issues/30820 for more info
'''
state_run = self.run_function(
'state.sls',
mods='requisites.requisite_in_match_by_name'
)
bar_state = 'cmd_|-bar state_|-echo bar_|-wait'
self.assertIn(bar_state, state_run)
self.assertEqual(state_run[bar_state]['comment'],
'Command "echo bar" run')
if __name__ == '__main__':
from integration import run_tests
run_tests(StateModuleTest)
def test_ssh_custom_module(self):
'''
Test custom module work using SSHCase environment
'''
expected = 'hello'[::-1]
cmd = self.run_function('test.recho', arg=['hello'])
self.assertEqual(expected, cmd)
def test_ssh_sls_with_custom_module(self):
'''
Test sls with custom module work using SSHCase environment
'''
expected = {
"module_|-regular-module_|-test.echo_|-run": 'hello',
"module_|-custom-module_|-test.recho_|-run": 'olleh'}
cmd = self.run_function('state.sls', arg=['custom_module'])
for key in cmd:
if not isinstance(cmd, dict) or not isinstance(cmd[key], dict):
raise AssertionError('{0} is not a proper state return'
.format(cmd))
elif not cmd[key]['result']:
raise AssertionError(cmd[key]['comment'])
cmd_ret = cmd[key]['changes'].get('ret', None)
self.assertEqual(cmd_ret, expected[key])
if __name__ == '__main__':
from integration import run_tests
run_tests(SSHCustomModuleTest)
@skipIf(NO_MOCK, NO_MOCK_REASON)
class KeyTestCase(TestCase):
'''
Test cases for salt.modules.key
'''
def test_finger(self):
'''
Test for finger
'''
with patch.object(os.path, 'join', return_value='A'):
with patch.object(salt.utils, 'pem_finger', return_value='A'):
with patch.dict(key.__opts__,
{'pki_dir': MagicMock(return_value='A')}):
self.assertEqual(key.finger(), 'A')
def test_finger_master(self):
'''
Test for finger
'''
with patch.object(os.path, 'join', return_value='A'):
with patch.object(salt.utils, 'pem_finger', return_value='A'):
with patch.dict(key.__opts__, {'pki_dir': 'A'}):
self.assertEqual(key.finger_master(), 'A')
if __name__ == '__main__':
from integration import run_tests
run_tests(KeyTestCase, needs_daemon=False)
def test_build_network_settings(self):
'''
Test to build the global network script.
'''
with patch.object(rh_ip, '_parse_rh_config', MagicMock()):
with patch.object(rh_ip, '_parse_network_settings', MagicMock()):
mock = jinja2.exceptions.TemplateNotFound('foo')
with patch.object(jinja2.Environment,
'get_template', MagicMock(side_effect=mock)):
self.assertEqual(rh_ip.build_network_settings(), '')
with patch.object(jinja2.Environment,
'get_template', MagicMock()):
with patch.object(rh_ip, '_read_temp', return_value='A'):
self.assertEqual(rh_ip.build_network_settings
(test='t'), 'A')
with patch.object(rh_ip, '_write_file_network',
return_value=None):
with patch.object(rh_ip, '_read_file',
return_value='A'):
self.assertEqual(rh_ip.build_network_settings
(test=None), 'A')
if __name__ == '__main__':
from integration import run_tests
run_tests(RhipTestCase, needs_daemon=False)
ret = self.run_call('test.ping --out=yaml')
self.assertEqual(ret, expected)
def test_output_unicodebad(self):
'''
Tests outputter reliability with utf8
'''
opts = copy.deepcopy(self.minion_opts)
opts['output_file'] = os.path.join(self.minion_opts['root_dir'],
'outputtest')
data = {
'foo': {
'result': False,
'aaa': 'azerzaeréééé',
'comment': u'ééééàààà'
}
}
try:
# this should not raises UnicodeEncodeError
display_output(data, opts=self.minion_opts)
self.assertTrue(True)
except Exception:
# display trace in error message for debugging on jenkins
trace = traceback.format_exc()
self.assertEqual(trace, '')
if __name__ == '__main__':
from integration import run_tests
run_tests(OutputReturnTest)
# Import Salt libs
from salt import template
class TemplateTestCase(TestCase):
render_dict = {'jinja': 'fake_jinja_func',
'json': 'fake_json_func',
'mako': 'fake_make_func'}
def test_compile_template_bad_type(self):
'''
Test to ensure that unsupported types cannot be passed to the template compiler
'''
ret = template.compile_template(['1', '2', '3'], None, None)
self.assertDictEqual(ret, {})
def test_check_render_pipe_str(self):
'''
Check that all renderers specified in the pipe string are available.
'''
ret = template.check_render_pipe_str('jinja|json', self.render_dict)
self.assertIn(('fake_jinja_func', ''), ret)
self.assertIn(('fake_json_func', ''), ret)
self.assertNotIn(('OBVIOUSLY_NOT_HERE', ''), ret)
if __name__ == '__main__':
from integration import run_tests
run_tests(TemplateTestCase, needs_daemon=False)
@requires_network()
@destructiveTest
def test_refresh_db(self):
'''
test refreshing the package database
'''
func = 'pkg.refresh_db'
os_family = self.run_function('grains.item',
['os_family'])['os_family']
if os_family == 'RedHat':
ret = self.run_function(func)
self.assertIn(ret, (True, None))
elif os_family == 'Debian':
ret = self.run_function(func)
self.assertNotEqual(ret, {})
if not isinstance(ret, dict):
self.skipTest(
'Upstream repo did not return coherent results. Skipping test.'
)
for source, state in ret.items():
self.assertIn(state, (True, False, None))
else:
os_grain = self.run_function('grains.item', ['os'])['os']
self.skipTest('{0} is unavailable on {1}'.format(func, os_grain))
if __name__ == '__main__':
from integration import run_tests
run_tests(PkgModuleTest)
else:
os_grain = self.run_function('grains.item', ['os'])['os']
self.skipTest('{0} is unavailable on {1}'.format('pkg.hold', os_grain))
@requires_network()
@destructiveTest
def test_refresh_db(self):
'''
test refreshing the package database
'''
func = 'pkg.refresh_db'
os_family = self.run_function('grains.item', ['os_family'])['os_family']
if os_family == 'RedHat':
ret = self.run_function(func)
self.assertIn(ret, (True, None))
elif os_family == 'Debian':
ret = self.run_function(func)
self.assertNotEqual(ret, {})
for source, state in ret.items():
self.assertIn(state, (True, False, None))
else:
os_grain = self.run_function('grains.item', ['os'])['os']
self.skipTest('{0} is unavailable on {1}'.format(func, os_grain))
if __name__ == '__main__':
from integration import run_tests
run_tests(PkgModuleTest)
'''
supervisord.dead
When service needs to be added.
'''
self.start_supervisord(autostart=False)
self.run_function(
'supervisord.remove',
['sleep_service', None, self.supervisor_conf, self.venv_dir])
ret = self.run_state('supervisord.dead',
name='sleep_service',
bin_env=self.venv_dir,
conf_file=self.supervisor_conf)
self.assertSaltTrueReturn(ret)
def test_dead_notexists(self):
'''
supervisord.dead
When service does not exist.
'''
self.start_supervisord(autostart=True)
ret = self.run_state('supervisord.dead',
name='does_not_exist',
bin_env=self.venv_dir,
conf_file=self.supervisor_conf)
self.assertSaltTrueReturn(ret)
if __name__ == '__main__':
from integration import run_tests
run_tests(SupervisordTest)
hostname_cmd = salt.utils.which('hostnamectl')
if hostname_cmd:
desc = self.run_function('cmd.run', ["hostnamectl status --pretty"])
self.assertEqual(res, desc)
else:
if not os.path.isfile('/etc/machine-info'):
self.assertFalse(res)
else:
with salt.utils.fopen('/etc/machine-info', 'r') as mach_info:
data = mach_info.read()
self.assertIn(res, data.decode('string_escape'))
@destructiveTest
@skipIf(os.geteuid() != 0, 'you must be root to run this test')
def test_set_computer_desc(self):
'''
Test setting the system hostname
'''
self._save_machine_info()
desc = "test"
ret = self.run_function('system.set_computer_desc', [desc])
computer_desc = self.run_function('system.get_computer_desc')
self.assertTrue(ret)
self.assertIn(desc, computer_desc)
if __name__ == '__main__':
from integration import run_tests
run_tests(SystemModuleTest)
'stderr': ''
}
run_all_mock = MagicMock(return_value=cmd_out)
patches = {
'cmd.run_all': run_all_mock,
'pkg_resource.parse_targets': MagicMock(return_value=parsed_targets),
'pkg_resource.stringify': MagicMock(),
'pkg_resource.sort_pkglist': MagicMock(),
}
with patch.dict(openbsdpkg.__salt__, patches):
with patch('salt.modules.openbsdpkg.list_pkgs', ListPackages()):
added = openbsdpkg.install()
expected = {
'png': {'new': '1.6.23', 'old': ''},
'ruby': {'new': '2.3.1p1', 'old': ''}
}
self.assertDictEqual(added, expected)
expected_calls = [
call('pkg_add -x -I png--%', output_loglevel='trace', python_shell=False),
call('pkg_add -x -I ruby--%2.3', output_loglevel='trace', python_shell=False),
call('pkg_add -x -I vim--gtk2%', output_loglevel='trace', python_shell=False),
]
run_all_mock.assert_has_calls(expected_calls, any_order=True)
self.assertEqual(run_all_mock.call_count, 3)
if __name__ == '__main__':
from integration import run_tests
run_tests(OpenbsdpkgTestCase, needs_daemon=False)
'''
# check if instance with salt installed returned
try:
self.assertIn(
INSTANCE_NAME,
[i.strip() for i in self.run_cloud('-p digitalocean-test {0}'.format(INSTANCE_NAME))]
)
except AssertionError:
self.run_cloud('-d {0} --assume-yes'.format(INSTANCE_NAME))
raise
# delete the instance
try:
self.assertIn(
'True',
[i.strip() for i in self.run_cloud('-d {0} --assume-yes'.format(INSTANCE_NAME))]
)
except AssertionError:
raise
# Final clean-up of created instance, in case something went wrong.
# This was originally in a tearDown function, but that didn't make sense
# To run this for each test when not all tests create instances.
if INSTANCE_NAME in [i.strip() for i in self.run_cloud('--query')]:
self.run_cloud('-d {0} --assume-yes'.format(INSTANCE_NAME))
if __name__ == '__main__':
from integration import run_tests
run_tests(DigitalOceanTest)
def test_handle_decoded_payload_jid_queue_reduced_minion_jid_queue_hwm(
self):
'''
Tests that the _handle_decoded_payload function removes a jid from the minion's jid_queue when the
minion's jid_queue high water mark (minion_jid_queue_hwm) is hit.
'''
mock_opts = {
'cachedir': '',
'extension_modules': '',
'minion_jid_queue_hwm': 2
}
mock_data = {'fun': 'foo.bar', 'jid': 789}
mock_jid_queue = [123, 456]
minion = salt.minion.Minion(mock_opts,
jid_queue=copy.copy(mock_jid_queue))
# Assert that the minion's jid_queue attribute matches the mock_jid_queue as a baseline
# This can help debug any test failures if the _handle_decoded_payload call fails.
self.assertEqual(minion.jid_queue, mock_jid_queue)
# Call the _handle_decoded_payload function and check that the queue is smaller by one item
# and contains the new jid
minion._handle_decoded_payload(mock_data)
self.assertEqual(len(minion.jid_queue), 2)
self.assertEqual(minion.jid_queue, [456, 789])
if __name__ == '__main__':
from integration import run_tests
run_tests(MinionTestCase, needs_daemon=False)
# returns X, the second Y, the third Z, etc...
osaccess.side_effect = [
# The first os.access should return False(the abspath one)
False,
# The second, iterating through $PATH, should also return False,
# still checking for Linux
False,
# We will now also return False 3 times so we get a .CMD back from
# the function, see PATHEXT below.
# Lastly return True, this is the windows check.
False, False, False,
True
]
# Let's patch os.environ to provide a custom PATH variable
with patch.dict(os.environ, {'PATH': '/bin',
'PATHEXT': '.COM;.EXE;.BAT;.CMD;.VBS;'
'.VBE;.JS;.JSE;.WSF;.WSH;.MSC;.PY'}):
# Let's also patch is_windows to return True
with patch('salt.utils.is_windows', lambda: True):
with patch('os.path.isfile', lambda x: True):
self.assertEqual(
salt.utils.which('this-binary-exists-under-windows'),
# The returned path should return the .exe suffix
'/bin/this-binary-exists-under-windows.CMD'
)
if __name__ == '__main__':
from integration import run_tests
run_tests(TestWhich, needs_daemon=False)
_HASHES = dict(
md5=dict(pw_salt='TgIp9OTu', pw_hash='$1$TgIp9OTu$.d0FFP6jVi5ANoQmk6GpM1'),
sha256=dict(
pw_salt='3vINbSrC',
pw_hash='$5$3vINbSrC$hH8A04jAY3bG123yU4FQ0wvP678QDTvWBhHHFbz6j0D'),
sha512=dict(
pw_salt='PiGA3V2o',
pw_hash=
'$6$PiGA3V2o$/PrntRYufz49bRV/V5Eb1V6DdHaS65LB0fu73Tp/xxmDFr6HWJKptY2TvHRDViXZugWpnAcOnrbORpOgZUGTn.'
),
)
@skipIf(not is_linux(), 'minion is not Linux')
class LinuxShadowTest(TestCase):
def test_gen_password(self):
'''
Test shadow.gen_password
'''
self.assertTrue(HAS_SHADOW)
for algorithm, hash_info in _HASHES.iteritems():
self.assertEqual(
shadow.gen_password(_PASSWORD,
crypt_salt=hash_info['pw_salt'],
algorithm=algorithm), hash_info['pw_hash'])
if __name__ == '__main__':
from integration import run_tests
run_tests(LinuxShadowTest, needs_daemon=False)
if not os.path.isfile(KNOWN_HOSTS):
self.skipTest(
'Unable to copy {0} to {1}'.format(
known_hosts, KNOWN_HOSTS
)
)
kwargs = {'name': 'github.com', 'user': '******', 'config': KNOWN_HOSTS}
# test first
ret = self.run_state('ssh_known_hosts.absent', test=True, **kwargs)
self.assertSaltNoneReturn(ret)
# remove once, the key is gone
ret = self.run_state('ssh_known_hosts.absent', **kwargs)
self.assertSaltStateChangesEqual(
ret, GITHUB_FINGERPRINT, keys=('old', 'fingerprint')
)
# remove twice, nothing has changed
ret = self.run_state('ssh_known_hosts.absent', **kwargs)
self.assertSaltStateChangesEqual(ret, {})
# test again
ret = self.run_state('ssh_known_hosts.absent', test=True, **kwargs)
self.assertSaltNoneReturn(ret)
if __name__ == '__main__':
from integration import run_tests
run_tests(SSHKnownHostsStateTest)
state_filename = state_name + '.sls'
state_file = os.path.join(STATE_DIR, state_filename)
# the result of running self.cmd not in a shell
disabled_ret = (
'first second third | wc -l ; export SALTY_VARIABLE=saltines '
'&& echo $SALTY_VARIABLE ; echo duh &> /dev/null')
ret_key = 'test_|-shell_enabled_|-{0}_|-configurable_test_state'.format(
disabled_ret)
try:
with salt.utils.fopen(state_file, 'w') as fp_:
fp_.write(
textwrap.dedent('''\
{{% set shell_disabled = salt['cmd.run']("{0}") %}}
shell_enabled:
test.configurable_test_state:
- name: '{{{{ shell_disabled }}}}'
'''.format(self.cmd)))
ret = self.run_function('state.sls', [state_name])
self.assertEqual(ret[ret_key]['name'], disabled_ret)
finally:
os.remove(state_file)
if __name__ == '__main__':
from integration import run_tests
run_tests(EnabledTest)
# set user password
set_pw_cmd = "shadow.set_password {0} '{1}'".format(
self.userB,
password if salt.utils.is_darwin() else hashed_pwd
)
self.run_call(set_pw_cmd)
# test group auth against pam: saltadm is not configured in
# external_auth, but saltops is and saldadm is a member of saltops
cmd = ('-a pam "*" test.ping '
'--username {0} --password {1}'.format(self.userB, password))
resp = self.run_salt(cmd)
self.assertTrue(
'minion:' in resp
)
@destructiveTest
@skipIf(is_not_root, 'You must be logged in as root to run this test')
def test_zzzz_tearDown(self):
for user in (self.userA, self.userB):
if pwd.getpwnam(user):
self.run_call('user.delete {0}'.format(user))
if grp.getgrnam(self.group):
self.run_call('group.delete {0}'.format(self.group))
if __name__ == '__main__':
from integration import run_tests
run_tests(AuthTest)
shutil.rmtree(dir)
def test_archive_extracted_skip_verify(self):
'''
test archive.extracted with skip_verify
'''
ret = self.run_state('archive.extracted', name=ARCHIVE_DIR,
source=ARCHIVE_TAR_SOURCE, archive_format='tar',
skip_verify=True)
self.assertSaltTrueReturn(ret)
self._check_ext_remove(ARCHIVE_DIR, UNTAR_FILE)
def test_archive_extracted_with_source_hash(self):
'''
test archive.extracted without skip_verify
only external resources work to check to
ensure source_hash is verified correctly
'''
ret = self.run_state('archive.extracted', name=ARCHIVE_DIR,
source=ARCHIVE_TAR_SOURCE, archive_format='tar',
source_hash=ARCHIVE_TAR_HASH)
self.assertSaltTrueReturn(ret)
self._check_ext_remove(ARCHIVE_DIR, UNTAR_FILE)
if __name__ == '__main__':
from integration import run_tests
run_tests(ArchiveTest)
gateway = '10.225.108.1'
ret = {'name': ip_,
'result': None,
'comment': '',
'changes': {}}
net_info = {'IPv4 settings': {'IP Address': ip_, 'Subnet Mask': netmask,
'Gateway': gateway}}
mock_info = MagicMock(return_value=net_info)
mock_bool = MagicMock(side_effect=[True, False])
with patch.dict(drac.__salt__, {'drac.network_info': mock_info,
'drac.set_network': mock_bool}):
with patch.dict(drac.__opts__, {'test': True}):
self.assertDictEqual(drac.network(ip_, netmask, gateway), ret)
with patch.dict(drac.__opts__, {'test': False}):
comt = ('Network is in the desired state')
ret.update({'comment': comt, 'result': True})
self.assertDictEqual(drac.network(ip_, netmask, gateway), ret)
comt = ('unable to configure network')
ret.update({'comment': comt, 'result': False})
self.assertDictEqual(drac.network(ip_, netmask, gateway), ret)
if __name__ == '__main__':
from integration import run_tests
run_tests(DracTestCase, needs_daemon=False)
'fun': 'key.list_keys',
}
low.update(self.eauth_creds)
self.wheel.cmd_async(low)
def test_cmd_sync_w_arg(self):
low = {
'fun': 'key.finger',
'match': '*',
}
low.update(self.eauth_creds)
ret = self.wheel.cmd_sync(low)
self.assertIn('return', ret.get('data', {}))
def test_wildcard_auth(self):
low = {
'username': '******',
'password': '******',
'eauth': 'auto',
'fun': 'key.list_all',
}
self.wheel.cmd_sync(low)
if __name__ == '__main__':
from integration import run_tests
run_tests(WheelModuleTest, needs_daemon=True)
class PillarModuleTest(integration.ModuleCase):
'''
Validate the pillar module
'''
def test_data(self):
'''
pillar.data
'''
grains = self.run_function('grains.items')
pillar = self.run_function('pillar.data')
self.assertEqual(pillar['os'], grains['os'])
self.assertEqual(pillar['monty'], 'python')
if grains['os'] == 'Fedora':
self.assertEqual(pillar['class'], 'redhat')
else:
self.assertEqual(pillar['class'], 'other')
def test_ext_cmd_yaml(self):
'''
pillar.data for ext_pillar cmd.yaml
'''
self.assertEqual(
self.run_function('pillar.data')['ext_spam'], 'eggs'
)
if __name__ == '__main__':
from integration import run_tests
run_tests(PillarModuleTest)
@skipIf(NO_MOCK, NO_MOCK_REASON)
class ChefTestCase(TestCase):
'''
Test cases for salt.modules.chef
'''
# 'client' function tests: 1
@patch('salt.modules.chef._exec_cmd', MagicMock(return_value={}))
@patch('salt.utils.which', MagicMock(return_value=True))
def test_client(self):
'''
Test if it execute a chef client run and return a dict
'''
self.assertDictEqual(chef.client(), {})
# 'solo' function tests: 1
@patch('salt.modules.chef._exec_cmd', MagicMock(return_value={}))
@patch('salt.utils.which', MagicMock(return_value=True))
def test_solo(self):
'''
Test if it execute a chef solo run and return a dict
'''
self.assertDictEqual(chef.solo('/dev/sda1'), {})
if __name__ == '__main__':
from integration import run_tests
run_tests(ChefTestCase, needs_daemon=False)
uinfo = self.run_function('user.info', [uname])
self.assertIn(uname, uinfo['groups'])
# This uid is available, store it
uid = uinfo['uid']
self.run_function('user.delete', [uname, True, True])
# Now, a weird group id
gname = self.__random_string()
if self.run_function('group.add', [gname]) is not True:
self.skipTest('Failed to create group')
ginfo = self.run_function('group.info', [gname])
# And create the user with that gid
if self.run_function('user.add', [uname, uid, ginfo['gid']]) is False:
# Skip because creating is not what we're testing here
self.skipTest('Failed to create user')
uinfo = self.run_function('user.info', [uname])
self.assertIn(gname, uinfo['groups'])
self.run_function('user.delete', [uname, True, True])
if __name__ == '__main__':
from integration import run_tests
run_tests(UseraddModuleTest)
Test that serializers have: []
'''
self._verify_globals(salt.loader.serializers(self.master_opts))
def test_states(self):
'''
Test that states:
- __pillar__
- __salt__
- __opts__
- __grains__
- __context__
'''
self._verify_globals(salt.loader.states(self.master_opts, {}, {}, {}))
def test_renderers(self):
'''
Test that renderers have:
- __salt__ # Execution functions (i.e. __salt__['test.echo']('foo'))
- __grains__ # Grains (i.e. __grains__['os'])
- __pillar__ # Pillar data (i.e. __pillar__['foo'])
- __opts__ # Minion configuration options
- __context__ # Context dict shared amongst all modules of the same type
'''
self._verify_globals(salt.loader.render(self.master_opts, {}))
if __name__ == '__main__':
from integration import run_tests
run_tests(LoaderGlobalsTest, needs_daemon=False)
rendered = env.from_string('{{ data }}').render(data=data)
self.assertEqual(rendered, u"{'foo': {'bar': 'baz', 'qux': 42}}")
rendered = env.from_string('{{ data }}').render(data=[
OrderedDict(
foo='bar',
),
OrderedDict(
baz=42,
)
])
self.assertEqual(rendered, u"[{'foo': 'bar'}, {'baz': 42}]")
# def test_print(self):
# env = Environment(extensions=[SerializerExtension])
# source = '{% import_yaml "toto.foo" as docu %}'
# name, filename = None, '<filename>'
# parsed = env._parse(source, name, filename)
# print parsed
# print
# compiled = env._generate(parsed, name, filename)
# print compiled
# return
if __name__ == '__main__':
from integration import run_tests
run_tests(TestSaltCacheLoader, TestGetTemplate, TestCustomExtensions,
needs_daemon=False)
self.assertDictEqual(
{
'hash_type': 'blob_sha1',
'hsum': '0d234303e6451128d756c5c259175de37d767742'
}, ret)
def test_serve_file(self):
with patch.dict(
gitfs.__opts__, {
'cachedir': self.master_opts['cachedir'],
'gitfs_remotes': ['file://' + self.tmp_repo_git],
'sock_dir': self.master_opts['sock_dir'],
'file_buffer_size': 262144
}):
fnd = {'rel': 'testfile', 'path': 'testfile'}
tmp_load = load
tmp_load['loc'] = 0
ret = gitfs.serve_file(load, fnd)
self.assertDictEqual(
{
'data':
'Scene 24\n\n \n OLD MAN: Ah, hee he he ha!\n ARTHUR: And this enchanter of whom you speak, he has seen the grail?\n OLD MAN: Ha ha he he he he!\n ARTHUR: Where does he live? Old man, where does he live?\n OLD MAN: He knows of a cave, a cave which no man has entered.\n ARTHUR: And the Grail... The Grail is there?\n OLD MAN: Very much danger, for beyond the cave lies the Gorge\n of Eternal Peril, which no man has ever crossed.\n ARTHUR: But the Grail! Where is the Grail!?\n OLD MAN: Seek you the Bridge of Death.\n ARTHUR: The Bridge of Death, which leads to the Grail?\n OLD MAN: Hee hee ha ha!\n\n',
'dest': 'testfile'
}, ret)
if __name__ == '__main__':
integration.run_tests(GitFSTest)
self.assertEqual(
sconfig.get_id(cache=False), ('foo.bar.org', False)
)
@patch('salt.utils.network.get_fqhostname', MagicMock(return_value='localhost'))
def test_get_id_etc_hostname(self):
'''
Test calling salt.config.get_id() and falling back to looking at
/etc/hostname.
'''
with patch('salt.utils.fopen', _fopen_side_effect_etc_hostname):
self.assertEqual(
sconfig.get_id(cache=False), ('foo.bar.com', False)
)
@patch('salt.utils.network.get_fqhostname', MagicMock(return_value='localhost'))
def test_get_id_etc_hosts(self):
'''
Test calling salt.config.get_id() and falling back all the way to
looking up data from /etc/hosts.
'''
with patch('salt.utils.fopen', _fopen_side_effect_etc_hosts):
self.assertEqual(
sconfig.get_id(cache=False), ('foo.bar.net', False)
)
if __name__ == '__main__':
from integration import run_tests
run_tests(ConfigTestCase, needs_daemon=False)
name='Setup Keys',
source='salt://{0}?saltenv=prod'.format(key_fname),
enc='ssh-rsa',
user=username,
comment=username)
self.assertSaltTrueReturn(ret)
with salt.utils.fopen(authorized_keys_file, 'r') as fhr:
self.assertEqual(
fhr.read(),
'ssh-rsa AAAAB3NzaC1kcQ9J5bYTEyZ== {0}\n'.format(username))
os.unlink(authorized_keys_file)
ret = self.run_state('ssh_auth.present',
name='Setup Keys',
source='salt://{0}'.format(key_fname),
enc='ssh-rsa',
user=username,
comment=username,
saltenv='prod')
self.assertSaltTrueReturn(ret)
with salt.utils.fopen(authorized_keys_file, 'r') as fhr:
self.assertEqual(
fhr.read(),
'ssh-rsa AAAAB3NzaC1kcQ9J5bYTEyZ== {0}\n'.format(username))
if __name__ == '__main__':
from integration import run_tests
run_tests([SSHKnownHostsStateTest, SSHAuthStateTests])
events.put_nowait(
me.get_event(wait=10, tag='salttest', full=False)
)
threading.Thread(target=get_event, args=(events,)).start()
time.sleep(1) # Allow multiprocessing.Process to start
ret = self.run_function(
'event.fire', ['event.fire: just test it!!!!', 'salttest'],
minion_tgt='sub_minion'
)
self.assertTrue(ret)
eventfired = events.get(block=True, timeout=10)
self.assertIsNotNone(eventfired)
self.assertIn('event.fire: just test it!!!!', eventfired)
ret = self.run_function(
'event.fire', ['event.fire: just test it!!!!', 'salttest-miss'],
minion_tgt='sub_minion'
)
self.assertTrue(ret)
with self.assertRaises(Empty):
eventfired = events.get(block=True, timeout=10)
if __name__ == '__main__':
from integration import run_tests
run_tests(EventModuleTest)
'''
ret = self.run_state('npm.installed',
name='git://github.com/request/request')
self.assertSaltTrueReturn(ret)
ret = self.run_state('npm.removed',
name='git://github.com/request/request')
self.assertSaltTrueReturn(ret)
@requires_network()
@destructiveTest
def test_npm_installed_pkgs(self):
'''
Basic test to determine if NPM module successfully installs multiple
packages.
'''
ret = self.run_state('npm.installed', name=None, pkgs=['pm2', 'grunt'])
self.assertSaltTrueReturn(ret)
@destructiveTest
def test_npm_cache_clean(self):
'''
Basic test to determine if NPM successfully cleans its cached packages.
'''
ret = self.run_state('npm.cache_cleaned', name=None)
self.assertSaltTrueReturn(ret)
if __name__ == '__main__':
from integration import run_tests
run_tests(NpmStateTest)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.set('myzpool/mydataset', compression='lz4'), res)
@patch('salt.modules.zfs._check_zfs', MagicMock(return_value='/sbin/zfs'))
def test_set_failure(self):
'''
Tests zfs set failure
'''
res = {'myzpool/mydataset': {'canmount': "'canmount' must be one of 'on | off | noauto'"}}
ret = {'pid': 79887, 'retcode': 1, 'stderr': "cannot set property for 'myzpool/mydataset': 'canmount' must be one of 'on | off | noauto'", 'stdout': ''}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.set('myzpool/mydataset', canmount='lz4'), res)
@patch('salt.modules.zfs._check_zfs', MagicMock(return_value='/sbin/zfs'))
def test_get_success(self):
'''
Tests zfs get success
'''
res = OrderedDict([('myzpool', {'compression': {'value': 'off'}})])
ret = {'pid': 562, 'retcode': 0, 'stderr': '', 'stdout': 'myzpool\tcompression\toff'}
mock_cmd = MagicMock(return_value=ret)
with patch.dict(zfs.__salt__, {'cmd.run_all': mock_cmd}):
self.assertEqual(zfs.get('myzpool', properties='compression', fields='value'), res)
if __name__ == '__main__':
from integration import run_tests
run_tests(ZfsTestCase, needs_daemon=False)
# vim: tabstop=4 expandtab shiftwidth=4 softtabstop=4
# check if instance installed salt and returned correctly
try:
self.assertIn(ret_str, instance)
except AssertionError:
self.run_cloud('-d {0} --assume-yes'.format(INSTANCE_NAME))
raise
# delete the instance
delete = self.run_cloud('-d {0} --assume-yes'.format(INSTANCE_NAME))
not_deleted = 'No machines were found to be destroyed'
try:
self.assertNotEqual(not_deleted, delete)
except AssertionError:
raise
def tearDown(self):
'''
Clean up after tests
'''
query = self.run_cloud('--query')
ret_str = ' {0}:'.format(INSTANCE_NAME)
# if test instance is still present, delete it
if ret_str in query:
self.run_cloud('-d {0} --assume-yes'.format(INSTANCE_NAME))
if __name__ == '__main__':
from integration import run_tests # pylint: disable=import-error
run_tests(AzureTest)
@patch('salt.modules.snapper._get_num_interval', MagicMock(return_value=(55, 0)))
@patch('salt.modules.snapper.snapper.MountSnapshot', MagicMock(
side_effect=["/.snapshots/55/snapshot", "", "/.snapshots/55/snapshot", ""]))
@patch('salt.modules.snapper.snapper.UmountSnapshot', MagicMock(return_value=""))
@patch('salt.modules.snapper.changed_files', MagicMock(return_value=["/tmp/foo3"]))
@patch('salt.modules.snapper._is_text_file', MagicMock(return_value=False))
@patch('os.path.isfile', MagicMock(side_effect=[True, True]))
@patch('os.path.isdir', MagicMock(return_value=False))
@patch.dict(snapper.__salt__, {
'hashutil.sha256_digest': MagicMock(side_effect=[
"e61f8b762d83f3b4aeb3689564b0ffbe54fa731a69a1e208dc9440ce0f69d19b",
"f18f971f1517449208a66589085ddd3723f7f6cefb56c141e3d97ae49e1d87fa",
])
})
def test_diff_binary_files(self):
fopen_effect = [
mock_open(read_data="dummy binary").return_value,
mock_open(read_data="dummy binary").return_value,
]
with patch('salt.utils.fopen') as fopen_mock:
fopen_mock.side_effect = fopen_effect
module_ret = {
"/tmp/foo3": MODULE_RET['DIFF']["/tmp/foo3"],
}
self.assertEqual(snapper.diff(), module_ret)
if __name__ == '__main__':
from integration import run_tests
run_tests(SnapperTestCase, needs_daemon=False)
comt = ('Boolean is in the correct state')
ret.update({'comment': comt, 'result': True})
self.assertDictEqual(selinux.boolean(name, value), ret)
mock_bools = MagicMock(return_value={name: {'State': 'off',
'Default': 'on'}})
mock = MagicMock(side_effect=[True, False])
with patch.dict(selinux.__salt__,
{'selinux.list_sebool': mock_bools,
'selinux.setsebool': mock}):
with patch.dict(selinux.__opts__, {'test': True}):
comt = ('Boolean samba_create_home_dirs'
' is set to be changed to on')
ret.update({'comment': comt, 'result': None})
self.assertDictEqual(selinux.boolean(name, value), ret)
with patch.dict(selinux.__opts__, {'test': False}):
comt = ('Boolean samba_create_home_dirs has been set to on')
ret.update({'comment': comt, 'result': True})
self.assertDictEqual(selinux.boolean(name, value), ret)
comt = ('Failed to set the boolean '
'samba_create_home_dirs to on')
ret.update({'comment': comt, 'result': True})
self.assertDictEqual(selinux.boolean(name, value), ret)
if __name__ == '__main__':
from integration import run_tests
run_tests(SelinuxTestCase, needs_daemon=False)
class TestAsyncEventPublisher(AsyncTestCase):
def get_new_ioloop(self):
return zmq.eventloop.ioloop.ZMQIOLoop()
def setUp(self):
super(TestAsyncEventPublisher, self).setUp()
self.publisher = event.AsyncEventPublisher(
{'sock_dir': SOCK_DIR},
self._handle_publish,
self.io_loop,
)
def _handle_publish(self, raw):
self.tag, self.data = event.SaltEvent.unpack(raw)
self.stop()
def test_event_subscription(self):
'''Test a single event is received'''
me = event.MinionEvent({'sock_dir': SOCK_DIR}, listen=True)
me.fire_event({'data': 'foo1'}, 'evt1')
self.wait()
evt1 = me.get_event(tag='evt1')
self.assertEqual(self.tag, 'evt1')
self.data.pop('_stamp') # drop the stamp
self.assertEqual(self.data, {'data': 'foo1'})
if __name__ == '__main__':
from integration import run_tests
run_tests(TestSaltEvent, needs_daemon=False)
'''
tmpl_str = '''Hello, {{ salt['mocktest.ping']() }}.'''
ret = self.render(tmpl_str)
self.assertEqual(ret, 'Hello, True.')
def test_dotlookup(self):
'''
Check calling a stub function using awesome dot-notation
'''
tmpl_str = '''Hello, {{ salt.mocktest.ping() }}.'''
ret = self.render(tmpl_str)
self.assertEqual(ret, 'Hello, True.')
def test_shadowed_dict_method(self):
'''
Check calling a stub function with a name that shadows a ``dict``
method name
'''
tmpl_str = '''Hello, {{ salt.mockgrains.get('id') }}.'''
ret = self.render(tmpl_str)
self.assertEqual(ret, 'Hello, jerry.')
if __name__ == '__main__':
from integration import run_tests
run_tests(TestSaltCacheLoader, TestGetTemplate, TestCustomExtensions,
TestDotNotationLookup,
needs_daemon=False)
'job': 101,
'queue': 'A',
'tag': '',
'time': '19:48:47',
'user': '******'}]})
with patch.dict(at.__grains__, {'os_family': ''}):
mock = MagicMock(return_value=None)
with patch.dict(at.__salt__, {'cmd.run': mock}):
self.assertEqual(at.at('12:05am', '/sbin/reboot',
tag='reboot'),
"'at.at' is not available.")
def test_atc(self):
"""
Tests for atc
"""
with patch.object(at, '_cmd', return_value=None):
self.assertEqual(at.atc(101), '\'at.atc\' is not available.')
with patch.object(at, '_cmd', return_value=''):
self.assertDictEqual(at.atc(101), {'error': 'invalid job id 101'})
with patch.object(at, '_cmd',
return_value='101\tThu Dec 11 19:48:47 2014 A B'):
self.assertEqual(at.atc(101), '101\tThu Dec 11 19:48:47 2014 A B')
if __name__ == '__main__':
from integration import run_tests
run_tests(AtTestCase, needs_daemon=False)
if version is None:
version = strip_initial_non_numbers_regex.search(vs).group('vs')
self.assertEqual(saltstack_version.string, version)
def test_version_comparison(self):
examples = (
('debian/0.11.1+ds-1-3-ga0afcbd', '0.11.1+ds-2'),
('v0.12.0-85-g2880105', 'v0.12.0-19-g767d4f9'),
('v0.17.0rc1-1-g52ebdfd', '0.17.0rc1'),
('v0.17.0', 'v0.17.0rc1'),
('Hydrogen', '0.17.0'),
('Helium', 'Hydrogen'),
('v2014.1.4.1-n/a-abcdefgh', 'v2014.1.4.1rc3-n/a-abcdefgh'),
('v2014.1.4.1-1-abcdefgh', 'v2014.1.4.1-n/a-abcdefgh')
)
for higher_version, lower_version in examples:
self.assertTrue(SaltStackVersion.parse(higher_version) > lower_version)
self.assertTrue(SaltStackVersion.parse(lower_version) < higher_version)
def test_unparsable_version(self):
with self.assertRaises(ValueError):
SaltStackVersion.from_name('Drunk')
with self.assertRaises(ValueError):
SaltStackVersion.parse('Drunk')
if __name__ == '__main__':
from integration import run_tests
run_tests(VersionTestCase, needs_daemon=False)
def test_omits(self):
with patch.dict(config.DEFAULTS, DEFAULTS):
with patch.dict(config.__pillar__, __pillar__):
with patch.dict(config.__opts__, __opts__):
opt_name = 'test.option.all'
opt = config.option(opt_name,
omit_opts=False,
omit_master=True,
omit_pillar=True)
self.assertEqual(opt, config.__opts__[opt_name])
opt = config.option(opt_name,
omit_opts=True,
omit_master=True,
omit_pillar=False)
self.assertEqual(opt, config.__pillar__[opt_name])
opt = config.option(opt_name,
omit_opts=True,
omit_master=False,
omit_pillar=True)
self.assertEqual(
opt, config.__pillar__['master'][opt_name])
if __name__ == '__main__':
from integration import run_tests
run_tests(TestModulesConfig, needs_daemon=False)
self.setGrains({'a': 'aval'})
ret = grains.list_absent(name='foo:list', value='baz')
self.assertEqual(ret['result'], True)
self.assertEqual(ret['comment'], 'Grain foo:list does not exist')
self.assertEqual(ret['changes'], {})
self.assertEqual(grains.__grains__, {'a': 'aval'})
self.assertGrainFileContent("a: aval\n")
def test_list_absent_not_a_list(self):
self.setGrains({'a': 'aval', 'foo': 'bar'})
ret = grains.list_absent(name='foo', value='bar')
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'})
self.assertGrainFileContent("a: aval\n" + "foo: bar\n")
def test_list_absent_already(self):
self.setGrains({'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']})
self.assertGrainFileContent("a: aval\n" + "foo:\n" + "- bar\n")
if __name__ == '__main__':
from integration import run_tests
run_tests(GrainsTestCase, needs_daemon=False)
name=name,
bare=True
)
self.assertSaltFalseReturn(ret)
self.assertFalse(os.path.isfile(os.path.join(name, 'HEAD')))
finally:
shutil.rmtree(name, ignore_errors=True)
def test_present_empty_dir(self):
'''
git.present
'''
name = os.path.join(integration.TMP, 'salt_repo')
if not os.path.isdir(name):
os.mkdir(name)
try:
ret = self.run_state(
'git.present',
name=name,
bare=True
)
self.assertSaltTrueReturn(ret)
self.assertTrue(os.path.isfile(os.path.join(name, 'HEAD')))
finally:
shutil.rmtree(name, ignore_errors=True)
if __name__ == '__main__':
from integration import run_tests
run_tests(GitTest)
mock_l = MagicMock(return_value=[{'key': 'salt'}])
with patch.dict(powerpath.__salt__,
{'powerpath.has_powerpath': mock,
'powerpath.list_licenses': mock_l,
'powerpath.remove_license': mock_t}):
comt = ('PowerPath is not installed.')
ret.update({'comment': comt, 'result': False})
self.assertDictEqual(powerpath.license_absent(name), ret)
comt = ('License key {0} not present'.format(name))
ret.update({'comment': comt, 'result': True})
self.assertDictEqual(powerpath.license_absent(name), ret)
with patch.dict(powerpath.__opts__, {'test': True}):
comt = ('License key salt is set to be removed')
ret.update({'comment': comt, 'result': None, 'name': 'salt'})
self.assertDictEqual(powerpath.license_absent('salt'), ret)
with patch.dict(powerpath.__opts__, {'test': False}):
ret.update({'comment': name, 'result': True,
'changes': {'salt': 'removed'}})
self.assertDictEqual(powerpath.license_absent('salt'), ret)
ret.update({'result': False, 'changes': {}})
self.assertDictEqual(powerpath.license_absent('salt'), ret)
if __name__ == '__main__':
from integration import run_tests
run_tests(PowerpathTestCase, needs_daemon=False)
contain a schedule key and neither does self.schedule.opts
'''
saved = {'foo': 'bar'}
ret = {'schedule': {'foo': 'bar'}}
Schedule.reload(self.schedule, saved)
self.assertEqual(self.schedule.opts, ret)
def test_reload_schedule_in_saved_but_not_opts(self):
'''
Tests reloading the schedule from saved schedule that contains
a schedule key, but self.schedule.opts does not
'''
saved = {'schedule': {'foo': 'bar'}}
ret = {'schedule': {'schedule': {'foo': 'bar'}}}
Schedule.reload(self.schedule, saved)
self.assertEqual(self.schedule.opts, ret)
# eval tests
def test_eval_schedule_is_not_dict(self):
'''
Tests if the schedule is a dictionary
'''
self.schedule.opts = {'schedule': ''}
self.assertRaises(ValueError, Schedule.eval, self.schedule)
if __name__ == '__main__':
from integration import run_tests
run_tests(ScheduleTestCase, needs_daemon=False)
self.start_supervisord(autostart=False)
ret = self.run_function(
'supervisord.stop', ['sleep_service'],
conf_file=self.supervisor_conf, bin_env=self.venv_dir)
self.assertEqual(ret, 'sleep_service: ERROR (not running)')
def test_status_all(self):
'''
Status for all services
'''
self.start_supervisord(autostart=True)
ret = self.run_function(
'supervisord.status', [], conf_file=self.supervisor_conf,
bin_env=self.venv_dir)
self.assertEqual(ret.keys(), ['sleep_service', 'sleep_service2'])
def test_status_one(self):
'''
Status for a specific service.
'''
self.start_supervisord(autostart=True)
ret = self.run_function(
'supervisord.status', ['sleep_service'],
conf_file=self.supervisor_conf, bin_env=self.venv_dir)
self.assertTrue(ret)
if __name__ == '__main__':
from integration import run_tests
run_tests(SupervisordModuleTest)
{'iptables.flush': mock}):
ret.update({'changes': {'locale': 'salt'},
'comment': 'Flush iptables rules in'
' table chain ipv4 family',
'result': True})
self.assertDictEqual(iptables.flush('salt',
table='', chain=''),
ret)
ret.update({'changes': {},
'comment': 'Failed to flush iptables rules',
'result': False})
self.assertDictEqual(iptables.flush('salt',
table='', chain=''),
ret)
def test_mod_aggregate(self):
'''
Test to mod_aggregate function
'''
self.assertDictEqual(iptables.mod_aggregate({'fun': 'salt'}, [], []),
{'fun': 'salt'})
self.assertDictEqual(iptables.mod_aggregate({'fun': 'append'}, [], []),
{'fun': 'append'})
if __name__ == '__main__':
from integration import run_tests
run_tests(IptablesTestCase, needs_daemon=False)
with patch.dict(module.__salt__, {}):
cmd = 'hello.world'
ret = module.run(cmd)
comment = 'Module function {0} is not available'.format(cmd)
self.assertEqual(ret['comment'], comment)
self.assertFalse(ret['result'])
def test_module_run_test_true(self):
'''
Tests the return of module.run state when test=True is passed in
'''
with patch.dict(module.__opts__, {'test': True}):
ret = module.run(CMD)
comment = 'Module function {0} is set to execute'.format(CMD)
self.assertEqual(ret['comment'], comment)
@patch('salt.utils.args.get_function_argspec',
MagicMock(return_value=aspec))
def test_module_run_missing_arg(self):
'''
Tests the return of module.run state when arguments are missing
'''
ret = module.run(CMD)
comment = 'The following arguments are missing: world hello'
self.assertEqual(ret['comment'], comment)
if __name__ == '__main__':
from integration import run_tests
run_tests(ModuleStateTest, needs_daemon=False)
