def test_dead(self):
'''
Test to ensure that the named service is dead
'''
ret = [{
'changes': {},
'comment': '',
'name': 'salt',
'result': True
}, {
'changes': 'saltstack',
'comment': 'The service salt is already dead',
'name': 'salt',
'result': True
}, {
'changes': {},
'comment': 'Service salt is set to be killed',
'name': 'salt',
'result': None
}, {
'changes': 'saltstack',
'comment': 'Service salt was killed',
'name': 'salt',
'result': True
}]
mock = MagicMock(return_value="salt")
with patch.object(service, '_enabled_used_error', mock):
self.assertEqual(service.dead("salt", enabled=1), 'salt')
mock = MagicMock(side_effect=[False, True, True, True])
with patch.object(service, '_available', mock):
self.assertDictEqual(service.dead("salt"), ret[0])
mock = MagicMock(side_effect=[False, True, True])
with patch.dict(service.__salt__, {'service.status': mock}):
mock = MagicMock(return_value={'changes': 'saltstack'})
with patch.object(service, '_enable', mock):
self.assertDictEqual(service.dead("salt", True), ret[1])
with patch.dict(service.__opts__, {'test': True}):
self.assertDictEqual(service.dead("salt"), ret[2])
with patch.dict(service.__opts__, {'test': False}):
mock = MagicMock(return_value="stack")
with patch.dict(service.__salt__, {'service.stop': mock}):
mock = MagicMock(return_value={'changes': 'saltstack'})
with patch.object(service, '_enable', mock):
self.assertDictEqual(service.dead("salt", True),
ret[3])
def test_running_with_reload(self):
with patch.dict(service.__opts__, {"test": False}):
service.dead(self.service_name, enable=False)
result = service.running(name=self.service_name,
enable=True,
reload=False)
expected = {
"changes": {
self.service_name: True
},
"comment":
"Service {} has been enabled, and is "
"running".format(self.service_name),
"name":
self.service_name,
"result":
True,
}
self.assertDictEqual(result, expected)
def test_running_with_reload(self):
with patch.dict(service.__opts__, {'test': False}):
service.dead(self.service_name, enable=False)
result = service.running(name=self.service_name,
enable=True,
reload=False)
expected = {
'changes': {
self.service_name: True
},
'comment':
'Service {0} has been enabled, and is '
'running'.format(self.service_name),
'name':
self.service_name,
'result':
True
}
self.assertDictEqual(result, expected)
def test_running_with_reload(self):
with patch.dict(service.__opts__, {"test": False}):
service.dead(self.service_name, enable=False)
result = service.running(name=self.service_name,
enable=True,
reload=False)
if salt.utils.platform.is_windows():
comment = "Started Service {}".format(self.service_name)
else:
comment = "Service {} has been enabled, and is running".format(
self.service_name)
expected = {
"changes": {
self.service_name: True
},
"comment": comment,
"name": self.service_name,
"result": True,
}
self.assertDictEqual(result, expected)
def test_running_with_reload(self):
with patch.dict(service.__opts__, {"test": False}):
with patch("salt.utils.systemd.offline",
MagicMock(return_value=False)):
service.dead(self.service_name, enable=False)
result = service.running(name=self.service_name,
enable=True,
reload=False)
expected = {
'changes': {
self.service_name: True
},
'comment':
'Service {0} has been enabled, and is '
'running'.format(self.service_name),
'name':
self.service_name,
'result':
True
}
self.assertDictEqual(result, expected)
def test_dead(self):
'''
Test to ensure that the named service is dead
'''
ret = [{'changes': {}, 'comment': '', 'name': 'salt', 'result': True},
{'changes': 'saltstack',
'comment': 'The service salt is already dead', 'name': 'salt',
'result': True},
{'changes': {},
'comment': 'Service salt is set to be killed', 'name': 'salt',
'result': None},
{'changes': 'saltstack',
'comment': 'Service salt was killed', 'name': 'salt',
'result': True}]
mock = MagicMock(return_value="salt")
with patch.object(service, '_enabled_used_error', mock):
self.assertEqual(service.dead("salt", enabled=1), 'salt')
mock = MagicMock(side_effect=[False, True, True, True])
with patch.object(service, '_available', mock):
self.assertDictEqual(service.dead("salt"), ret[0])
mock = MagicMock(side_effect=[False, True, True])
with patch.dict(service.__salt__, {'service.status': mock}):
mock = MagicMock(return_value={'changes': 'saltstack'})
with patch.object(service, '_enable', mock):
self.assertDictEqual(service.dead("salt", True), ret[1])
with patch.dict(service.__opts__, {'test': True}):
self.assertDictEqual(service.dead("salt"), ret[2])
with patch.dict(service.__opts__, {'test': False}):
mock = MagicMock(return_value="stack")
with patch.dict(service.__salt__, {'service.stop': mock}):
mock = MagicMock(return_value={'changes': 'saltstack'})
with patch.object(service, '_enable', mock):
self.assertDictEqual(service.dead("salt", True),
ret[3])
def test_dead_in_offline_mode():
"""
Tests the case in which a service.dead state is executed on an offline environemnt
"""
name = "thisisnotarealservice"
with patch.object(service, "_offline", MagicMock(return_value=True)):
ret = service.dead(name=name)
assert ret == {
"changes": {},
"comment": "Running in OFFLINE mode. Nothing to do",
"result": True,
"name": name,
}
def test_dead_with_missing_service():
"""
Tests the case in which a service.dead state is executed on a state
which does not exist.
See https://github.com/saltstack/salt/issues/37511
"""
name = "thisisnotarealservice"
with patch.dict(service.__salt__,
{"service.available": MagicMock(return_value=False)}):
ret = service.dead(name=name)
assert ret == {
"changes": {},
"comment": "The named service {} is not available".format(name),
"result": True,
"name": name,
}
def test_dead_with_missing_service(self):
'''
Tests the case in which a service.dead state is executed on a state
which does not exist.
See https://github.com/saltstack/salt/issues/37511
'''
name = 'thisisnotarealservice'
with patch.dict(service.__salt__,
{'service.available': MagicMock(return_value=False)}):
ret = service.dead(name=name)
self.assertDictEqual(
ret,
{'changes': {},
'comment': 'The named service {0} is not available'.format(name),
'result': True,
'name': name}
)
def test_dead_with_missing_service(self):
'''
Tests the case in which a service.dead state is executed on a state
which does not exist.
See https://github.com/saltstack/salt/issues/37511
'''
name = 'thisisnotarealservice'
with patch.dict(service.__salt__,
{'service.available': MagicMock(return_value=False)}):
ret = service.dead(name=name)
self.assertDictEqual(
ret,
{'changes': {},
'comment': 'The named service {0} is not available'.format(name),
'result': True,
'name': name}
)
def test_running_with_reload():
"""
Test that a running service is properly reloaded
"""
opts = salt.config.DEFAULT_MINION_OPTS.copy()
opts["grains"] = salt.loader.grains(opts)
utils = salt.loader.utils(opts)
modules = salt.loader.minion_mods(opts, utils=utils)
service_name = "cron"
cmd_name = "crontab"
os_family = opts["grains"]["os_family"]
os_release = opts["grains"]["osrelease"]
if os_family == "RedHat":
service_name = "crond"
elif os_family == "Arch":
service_name = "sshd"
cmd_name = "systemctl"
elif os_family == "MacOS":
service_name = "org.ntp.ntpd"
if int(os_release.split(".")[1]) >= 13:
service_name = "com.openssh.sshd"
elif os_family == "Windows":
service_name = "Spooler"
if os_family != "Windows" and salt.utils.path.which(cmd_name) is None:
pytest.skip("{} is not installed".format(cmd_name))
pre_srv_enabled = (True if service_name in modules["service.get_enabled"]()
else False)
post_srv_disable = False
if not pre_srv_enabled:
modules["service.enable"](service_name)
post_srv_disable = True
try:
with patch.dict(service.__grains__, opts["grains"]), patch.dict(
service.__opts__,
opts), patch.dict(service.__salt__, modules), patch.dict(
service.__utils__, utils), patch.dict(
service.__opts__,
{"test": False}), patch("salt.utils.systemd.offline",
MagicMock(return_value=False)):
service.dead(service_name, enable=False)
result = service.running(name=service_name,
enable=True,
reload=False)
if salt.utils.platform.is_windows():
comment = "Started service {}".format(service_name)
else:
comment = "Service {} has been enabled, and is running".format(
service_name)
expected = {
"changes": {
service_name: True
},
"comment": comment,
"name": service_name,
"result": True,
}
assert result == expected
finally:
if post_srv_disable:
modules["service.disable"](service_name)
def test_dead():
"""
Test to ensure that the named service is dead
"""
ret = [
{
"changes": {},
"comment": "",
"name": "salt",
"result": True
},
{
"changes": "saltstack",
"comment": "The service salt is already dead",
"name": "salt",
"result": True,
},
{
"changes": {},
"comment": "Service salt is set to be killed",
"name": "salt",
"result": None,
},
{
"changes": "saltstack",
"comment": "Service salt was killed",
"name": "salt",
"result": True,
},
{
"changes": {},
"comment": "Service salt failed to die",
"name": "salt",
"result": False,
},
{
"changes": "saltstack",
"comment": "The service salt is already dead",
"name": "salt",
"result": True,
},
]
info_mock = MagicMock(return_value={"StartType": ""})
mock = MagicMock(return_value="salt")
with patch.object(service, "_enabled_used_error", mock):
assert service.dead("salt", enabled=1) == "salt"
tmock = MagicMock(return_value=True)
fmock = MagicMock(return_value=False)
with patch.object(service, "_available", fmock):
assert service.dead("salt") == ret[0]
with patch.object(service, "_available", tmock):
mock = MagicMock(return_value={"changes": "saltstack"})
with patch.dict(service.__opts__, {"test": True}):
with patch.dict(
service.__salt__,
{
"service.enabled": fmock,
"service.stop": tmock,
"service.status": fmock,
"service.info": info_mock,
},
):
with patch.object(service, "_enable", mock):
assert service.dead("salt", True) == ret[5]
with patch.dict(
service.__salt__,
{
"service.enabled": tmock,
"service.status": tmock,
"service.info": info_mock,
},
):
assert service.dead("salt") == ret[2]
with patch.dict(service.__opts__, {"test": False}):
with patch.dict(
service.__salt__,
{
"service.enabled": fmock,
"service.stop": tmock,
"service.status": fmock,
"service.info": info_mock,
},
):
with patch.object(service, "_enable", mock):
assert service.dead("salt", True) == ret[1]
with patch.dict(
service.__salt__,
{
"service.enabled":
MagicMock(side_effect=[True, True, False]),
"service.status":
MagicMock(side_effect=[True, False, False]),
"service.stop": MagicMock(return_value="stack"),
"service.info": info_mock,
},
):
with patch.object(
service,
"_enable",
MagicMock(return_value={"changes": "saltstack"}),
):
assert service.dead("salt", True) == ret[3]
# test an initd which a wrong status (True even if dead)
with patch.dict(
service.__salt__,
{
"service.enabled":
MagicMock(side_effect=[False, False, False]),
"service.status":
MagicMock(side_effect=[True, True, True]),
"service.stop": MagicMock(return_value="stack"),
"service.info": info_mock,
},
):
with patch.object(service, "_disable",
MagicMock(return_value={})):
assert service.dead("salt", False) == ret[4]
assert service.__context__ == {"service.state": "dead"}
def test_dead(self):
'''
Test to ensure that the named service is dead
'''
ret = [{'changes': {}, 'comment': '', 'name': 'salt', 'result': True},
{'changes': 'saltstack',
'comment': 'The service salt is already dead', 'name': 'salt',
'result': True},
{'changes': {},
'comment': 'Service salt is set to be killed', 'name': 'salt',
'result': None},
{'changes': 'saltstack',
'comment': 'Service salt was killed', 'name': 'salt',
'result': True},
{'changes': {},
'comment': 'Service salt failed to die', 'name': 'salt',
'result': False},
{'changes': 'saltstack',
'comment': 'The service salt is already dead', 'name': 'salt',
'result': True}]
info_mock = MagicMock(return_value={'StartType': ''})
mock = MagicMock(return_value="salt")
with patch.object(service, '_enabled_used_error', mock):
self.assertEqual(service.dead("salt", enabled=1), 'salt')
tmock = MagicMock(return_value=True)
fmock = MagicMock(return_value=False)
with patch.object(service, '_available', fmock):
self.assertDictEqual(service.dead("salt"), ret[0])
with patch.object(service, '_available', tmock):
mock = MagicMock(return_value={'changes': 'saltstack'})
with patch.dict(service.__opts__, {'test': True}):
with patch.dict(service.__salt__, {'service.enabled': fmock,
'service.stop': tmock,
'service.status': fmock,
'service.info': info_mock}):
with patch.object(service, '_enable', mock):
self.assertDictEqual(service.dead("salt", True), ret[5])
with patch.dict(service.__salt__, {'service.enabled': tmock,
'service.status': tmock,
'service.info': info_mock}):
self.assertDictEqual(service.dead("salt"), ret[2])
with patch.dict(service.__opts__, {'test': False}):
with patch.dict(service.__salt__, {'service.enabled': fmock,
'service.stop': tmock,
'service.status': fmock,
'service.info': info_mock}):
with patch.object(service, '_enable', mock):
self.assertDictEqual(service.dead("salt", True), ret[1])
with patch.dict(service.__salt__, {'service.enabled': MagicMock(side_effect=[True, True, False]),
'service.status': MagicMock(side_effect=[True, False, False]),
'service.stop': MagicMock(return_value="stack"),
'service.info': info_mock}):
with patch.object(service, '_enable', MagicMock(return_value={'changes': 'saltstack'})):
self.assertDictEqual(service.dead("salt", True), ret[3])
# test an initd which a wrong status (True even if dead)
with patch.dict(service.__salt__, {'service.enabled': MagicMock(side_effect=[False, False, False]),
'service.status': MagicMock(side_effect=[True, True, True]),
'service.stop': MagicMock(return_value="stack"),
'service.info': info_mock}):
with patch.object(service, '_disable', MagicMock(return_value={})):
self.assertDictEqual(service.dead("salt", False), ret[4])
def test_dead(self):
'''
Test to ensure that the named service is dead
'''
ret = [{'changes': {}, 'comment': '', 'name': 'salt', 'result': True},
{'changes': 'saltstack',
'comment': 'The service salt is already dead', 'name': 'salt',
'result': True},
{'changes': {},
'comment': 'Service salt is set to be killed', 'name': 'salt',
'result': None},
{'changes': 'saltstack',
'comment': 'Service salt was killed', 'name': 'salt',
'result': True},
{'changes': {},
'comment': 'Service salt was killed', 'name': 'salt',
'result': True},
{'changes': {},
'comment': 'The service salt is already dead', 'name': 'salt',
'result': True}]
mock = MagicMock(return_value="salt")
with patch.object(service, '_enabled_used_error', mock):
self.assertEqual(service.dead("salt", enabled=1), 'salt')
tmock = MagicMock(return_value=True)
fmock = MagicMock(return_value=False)
with patch.object(service, '_available', fmock):
self.assertDictEqual(service.dead("salt"), ret[0])
with patch.object(service, '_available', tmock):
mock = MagicMock(return_value={'changes': 'saltstack'})
with contextlib.nested(
patch.dict(service.__opts__, {'test': True}),
patch.dict(
service.__salt__,
{'service.enabled': MagicMock(return_value=False),
'service.stop': MagicMock(return_value=True),
'service.status': MagicMock(return_value=False)}),
patch.object(service, '_enable', mock)
):
self.assertDictEqual(service.dead("salt", True), ret[5])
with contextlib.nested(
patch.dict(service.__opts__, {'test': False}),
patch.dict(
service.__salt__,
{'service.enabled': MagicMock(return_value=False),
'service.stop': MagicMock(return_value=True),
'service.status': MagicMock(return_value=False)}),
patch.object(service, '_enable', mock)
):
self.assertDictEqual(service.dead("salt", True), ret[1])
with contextlib.nested(
patch.dict(service.__opts__, {'test': True}),
patch.dict(
service.__salt__,
{'service.enabled': MagicMock(return_value=True),
'service.status': MagicMock(return_value=True)}),
):
self.assertDictEqual(service.dead("salt"), ret[2])
with contextlib.nested(
patch.dict(service.__opts__, {'test': False}),
patch.dict(
service.__salt__,
{'service.enabled':
MagicMock(side_effect=[True, True, False]),
'service.status':
MagicMock(side_effect=[True, True, False]),
'service.stop': MagicMock(return_value="stack")}),
patch.object(
service, '_enable',
MagicMock(return_value={'changes': 'saltstack'}))
):
self.assertDictEqual(service.dead("salt", True), ret[3])
# test an initd which a wrong status (True even if dead)
with contextlib.nested(
patch.dict(service.__opts__, {'test': False}),
patch.dict(
service.__salt__,
{'service.enabled':
MagicMock(side_effect=[False, False, False]),
'service.status':
MagicMock(side_effect=[True, True, True]),
'service.stop': MagicMock(return_value="stack")}),
patch.object(
service, '_disable',
MagicMock(return_value={}))
):
self.assertDictEqual(service.dead("salt", False), ret[4])
