def test_running_in_offline_mode():
"""
Tests the case in which a service.running state is executed on an offline environemnt
"""
name = "thisisnotarealservice"
with patch.object(service, "_offline", MagicMock(return_value=True)):
ret = service.running(name=name)
assert ret == {
"changes": {},
"comment": "Running in OFFLINE mode. Nothing to do",
"result": True,
"name": name,
}
def test_running(self):
'''
Test to verify that the service is running
'''
ret = [{'comment': '', 'changes': {}, 'name': 'salt', 'result': True},
{'changes': {},
'comment': 'The service salt is already running',
'name': 'salt', 'result': True},
{'changes': 'saltstack',
'comment': 'The service salt is already running',
'name': 'salt', 'result': True},
{'changes': {},
'comment': 'Service salt is set to start', 'name': 'salt',
'result': None},
{'changes': 'saltstack',
'comment': 'Started Service salt', 'name': 'salt',
'result': True}]
mock = MagicMock(return_value="salt")
with patch.object(service, '_enabled_used_error', mock):
self.assertEqual(service.running("salt", enabled=1), 'salt')
mock = MagicMock(side_effect=[False, True, True, True, True, True])
with patch.object(service, '_available', mock):
self.assertDictEqual(service.running("salt"), ret[0])
mock = MagicMock(side_effect=[True, True, True, False, False])
with patch.dict(service.__salt__, {'service.status': mock}):
self.assertDictEqual(service.running("salt"), ret[1])
mock = MagicMock(return_value={'changes': 'saltstack'})
with patch.object(service, '_enable', mock):
self.assertDictEqual(service.running("salt", True), ret[2])
mock = MagicMock(return_value={'changes': 'saltstack'})
with patch.object(service, '_disable', mock):
self.assertDictEqual(service.running("salt", False),
ret[2])
with patch.dict(service.__opts__, {'test': True}):
self.assertDictEqual(service.running("salt"), ret[3])
with patch.dict(service.__opts__, {'test': False}):
mock = MagicMock(return_value="stack")
with patch.dict(service.__salt__, {'service.start': mock}):
mock = MagicMock(return_value={'changes': 'saltstack'})
with patch.object(service, '_enable', mock):
self.assertDictEqual(service.running("salt", True),
ret[4])
def run_service(name, watch_list, state_id):
comment = ""
ret = service.running(name,enable=True)
if not ret.get("result"):
comment += "Unable to run service %s"%name
return False,comment
comment += "Service %s: %s\n"%(name,ret.get("comment","Available"))
if not watch_list: watch_list = []
for watch in watch_list:
cs = Checksum(watch,state_id,WATCH_PATH)
if cs.update(edit=False,tfirst=True):
ret = service.mod_watch(name,restart=True)
if not ret.get("result"):
comment += "Unable to restart service %s after change triggered on file %s"%(name,watch)
return False,comment
comment += "Service %s: %s\n"%(name,ret.get("comment","Restarted"))
cs.update(edit=True,tfirst=True)
return True,comment
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_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_running():
"""
Test to verify that the service is running
"""
ret = [
{
"comment": "",
"changes": {},
"name": "salt",
"result": True
},
{
"changes": {},
"comment": "The service salt is already running",
"name": "salt",
"result": True,
},
{
"changes": "saltstack",
"comment": "The service salt is already running",
"name": "salt",
"result": True,
},
{
"changes": {},
"comment": "Service salt is set to start",
"name": "salt",
"result": None,
},
{
"changes": "saltstack",
"comment": "Started service salt",
"name": "salt",
"result": True,
},
{
"changes": {},
"comment": "The service salt is already running",
"name": "salt",
"result": True,
},
{
"changes": "saltstack",
"comment": "Service salt failed to start",
"name": "salt",
"result": False,
},
{
"changes":
"saltstack",
"comment":
("Started service salt\nService masking not available on this minion"
),
"name":
"salt",
"result":
True,
},
{
"changes":
"saltstack",
"comment":
("Started service salt\nService masking not available on this minion"
),
"name":
"salt",
"result":
True,
},
{
"changes": {},
"comment":
("The service salt is disabled but enable is not True. Set enable to"
" True to successfully start the service."),
"name":
"salt",
"result":
False,
},
{
"changes": {},
"comment": "The service salt is set to restart",
"name": "salt",
"result": None,
},
]
tmock = MagicMock(return_value=True)
fmock = MagicMock(return_value=False)
vmock = MagicMock(return_value="salt")
with patch.object(service, "_enabled_used_error", vmock):
assert service.running("salt", enabled=1) == "salt"
with patch.object(service, "_available", fmock):
assert service.running("salt") == ret[0]
with patch.object(service, "_available", tmock):
with patch.dict(service.__opts__, {"test": False}):
with patch.dict(
service.__salt__,
{
"service.enabled": tmock,
"service.status": tmock
},
):
assert service.running("salt") == ret[1]
mock = MagicMock(return_value={"changes": "saltstack"})
with patch.dict(
service.__salt__,
{
"service.enabled": MagicMock(side_effect=[False, True]),
"service.status": tmock,
},
):
with patch.object(service, "_enable", mock):
assert service.running("salt", True) == ret[2]
with patch.dict(
service.__salt__,
{
"service.enabled": MagicMock(side_effect=[True, False]),
"service.status": tmock,
},
):
with patch.object(service, "_disable", mock):
assert service.running("salt", False) == ret[2]
with patch.dict(
service.__salt__,
{
"service.status": MagicMock(side_effect=[False, True]),
"service.enabled": MagicMock(side_effect=[False, True]),
"service.start": MagicMock(return_value="stack"),
},
):
with patch.object(
service,
"_enable",
MagicMock(return_value={"changes": "saltstack"}),
):
assert service.running("salt", True) == ret[4]
with patch.dict(
service.__salt__,
{
"service.status": MagicMock(side_effect=[False, True]),
"service.enabled": MagicMock(side_effect=[False, True]),
"service.unmask": MagicMock(side_effect=[False, True]),
"service.start": MagicMock(return_value="stack"),
},
):
with patch.object(
service,
"_enable",
MagicMock(return_value={"changes": "saltstack"}),
):
assert service.running("salt", True, unmask=True) == ret[7]
with patch.dict(service.__opts__, {"test": True}):
with patch.dict(service.__salt__, {"service.status": tmock}):
assert service.running("salt") == ret[10]
with patch.dict(service.__salt__, {"service.status": fmock}):
assert service.running("salt") == ret[3]
with patch.dict(service.__opts__, {"test": False}):
with patch.dict(
service.__salt__,
{
"service.status": MagicMock(side_effect=[False, False]),
"service.enabled": MagicMock(side_effect=[True, True]),
"service.start": MagicMock(return_value="stack"),
},
):
with patch.object(
service,
"_enable",
MagicMock(return_value={"changes": "saltstack"}),
):
assert service.running("salt", True) == ret[6]
# test some unique cases simulating Windows
with patch.object(salt.utils.platform, "is_windows", tmock):
# We should fail if a service is disabled on Windows and enable
# isn't set.
with patch.dict(
service.__salt__,
{
"service.status": fmock,
"service.enabled": fmock,
"service.start": tmock,
},
):
assert service.running("salt", None) == ret[9]
assert service.__context__ == {"service.state": "running"}
# test some unique cases simulating macOS
with patch.object(salt.utils.platform, "is_darwin", tmock):
# We should fail if a service is disabled on macOS and enable
# isn't set.
with patch.dict(
service.__salt__,
{
"service.status": fmock,
"service.enabled": fmock,
"service.start": tmock,
},
):
assert service.running("salt", None) == ret[9]
assert service.__context__ == {"service.state": "running"}
# test enabling a service prior starting it on macOS
with patch.dict(
service.__salt__,
{
"service.status":
MagicMock(side_effect=[False, "loaded"]),
"service.enabled":
MagicMock(side_effect=[False, True]),
"service.start": tmock,
},
):
with patch.object(
service,
"_enable",
MagicMock(return_value={"changes": "saltstack"}),
):
assert service.running("salt", True) == ret[4]
assert service.__context__ == {
"service.state": "running"
}
# if an enable attempt fails on macOS or windows then a
# disabled service will always fail to start.
with patch.dict(
service.__salt__,
{
"service.status": fmock,
"service.enabled": fmock,
"service.start": fmock,
},
):
with patch.object(
service,
"_enable",
MagicMock(return_value={
"changes": "saltstack",
"result": False
}),
):
assert service.running("salt", True) == ret[6]
assert service.__context__ == {
"service.state": "running"
}
def test_running(self):
'''
Test to verify that the service is running
'''
ret = [{'comment': '', 'changes': {}, 'name': 'salt', 'result': True},
{'changes': {},
'comment': 'The service salt is already running',
'name': 'salt', 'result': True},
{'changes': 'saltstack',
'comment': 'The service salt is already running',
'name': 'salt', 'result': True},
{'changes': {},
'comment': 'Service salt is set to start', 'name': 'salt',
'result': None},
{'changes': 'saltstack',
'comment': 'Started Service salt', 'name': 'salt',
'result': True},
{'changes': {},
'comment': 'The service salt is already running',
'name': 'salt', 'result': True},
{'changes': 'saltstack',
'comment': 'Service salt failed to start', 'name': 'salt',
'result': False}]
tmock = MagicMock(return_value=True)
fmock = MagicMock(return_value=False)
vmock = MagicMock(return_value="salt")
with patch.object(service, '_enabled_used_error', vmock):
self.assertEqual(service.running("salt", enabled=1), 'salt')
with patch.object(service, '_available', fmock):
self.assertDictEqual(service.running("salt"), ret[0])
with patch.object(service, '_available', tmock):
with patch.dict(service.__opts__, {'test': False}):
with patch.dict(service.__salt__, {'service.enabled': tmock,
'service.status': tmock}):
self.assertDictEqual(service.running("salt"), ret[1])
mock = MagicMock(return_value={'changes': 'saltstack'})
with patch.dict(service.__salt__, {'service.enabled': MagicMock(side_effect=[False, True]),
'service.status': tmock}):
with patch.object(service, '_enable', mock):
self.assertDictEqual(service.running("salt", True), ret[2])
with patch.dict(service.__salt__, {'service.enabled': MagicMock(side_effect=[True, False]),
'service.status': tmock}):
with patch.object(service, '_disable', mock):
self.assertDictEqual(service.running("salt", False), ret[2])
with patch.dict(service.__salt__, {'service.status': MagicMock(side_effect=[False, True]),
'service.enabled': MagicMock(side_effect=[False, True]),
'service.start': MagicMock(return_value="stack")}):
with patch.object(service, '_enable', MagicMock(return_value={'changes': 'saltstack'})):
self.assertDictEqual(service.running("salt", True), ret[4])
with patch.dict(service.__opts__, {'test': True}):
with patch.dict(service.__salt__, {'service.status': tmock}):
self.assertDictEqual(service.running("salt"), ret[5])
with patch.dict(service.__salt__, {'service.status': fmock}):
self.assertDictEqual(service.running("salt"), ret[3])
with patch.dict(service.__opts__, {'test': False}):
with patch.dict(service.__salt__, {'service.status': MagicMock(side_effect=[False, False]),
'service.enabled': MagicMock(side_effecct=[True, True]),
'service.start': MagicMock(return_value='stack')}):
with patch.object(service, '_enable', MagicMock(return_value={'changes': 'saltstack'})):
self.assertDictEqual(service.running('salt', True), ret[6])
def test_running(self):
"""
Test to verify that the service is running
"""
ret = [
{
"comment": "",
"changes": {},
"name": "salt",
"result": True
},
{
"changes": {},
"comment": "The service salt is already running",
"name": "salt",
"result": True,
},
{
"changes": "saltstack",
"comment": "The service salt is already running",
"name": "salt",
"result": True,
},
{
"changes": {},
"comment": "Service salt is set to start",
"name": "salt",
"result": None,
},
{
"changes": "saltstack",
"comment": "Started Service salt",
"name": "salt",
"result": True,
},
{
"changes": {},
"comment": "The service salt is already running",
"name": "salt",
"result": True,
},
{
"changes": "saltstack",
"comment": "Service salt failed to start",
"name": "salt",
"result": False,
},
{
"changes": "saltstack",
"comment":
"Started Service salt\nService masking not available on this minion",
"name": "salt",
"result": True,
},
{
"changes": "saltstack",
"comment":
"Started Service salt\nService masking not available on this minion",
"name": "salt",
"result": True,
},
]
tmock = MagicMock(return_value=True)
fmock = MagicMock(return_value=False)
vmock = MagicMock(return_value="salt")
with patch.object(service, "_enabled_used_error", vmock):
self.assertEqual(service.running("salt", enabled=1), "salt")
with patch.object(service, "_available", fmock):
self.assertDictEqual(service.running("salt"), ret[0])
with patch.object(service, "_available", tmock):
with patch.dict(service.__opts__, {"test": False}):
with patch.dict(
service.__salt__,
{
"service.enabled": tmock,
"service.status": tmock
},
):
self.assertDictEqual(service.running("salt"), ret[1])
mock = MagicMock(return_value={"changes": "saltstack"})
with patch.dict(
service.__salt__,
{
"service.enabled":
MagicMock(side_effect=[False, True]),
"service.status": tmock,
},
):
with patch.object(service, "_enable", mock):
self.assertDictEqual(service.running("salt", True),
ret[2])
with patch.dict(
service.__salt__,
{
"service.enabled":
MagicMock(side_effect=[True, False]),
"service.status": tmock,
},
):
with patch.object(service, "_disable", mock):
self.assertDictEqual(service.running("salt", False),
ret[2])
with patch.dict(
service.__salt__,
{
"service.status": MagicMock(side_effect=[False, True]),
"service.enabled":
MagicMock(side_effect=[False, True]),
"service.start": MagicMock(return_value="stack"),
},
):
with patch.object(
service,
"_enable",
MagicMock(return_value={"changes": "saltstack"}),
):
self.assertDictEqual(service.running("salt", True),
ret[4])
with patch.dict(
service.__salt__,
{
"service.status": MagicMock(side_effect=[False, True]),
"service.enabled":
MagicMock(side_effect=[False, True]),
"service.unmask": MagicMock(side_effect=[False, True]),
"service.start": MagicMock(return_value="stack"),
},
):
with patch.object(
service,
"_enable",
MagicMock(return_value={"changes": "saltstack"}),
):
self.assertDictEqual(
service.running("salt", True, unmask=True), ret[7])
with patch.dict(service.__opts__, {"test": True}):
with patch.dict(service.__salt__, {"service.status": tmock}):
self.assertDictEqual(service.running("salt"), ret[5])
with patch.dict(service.__salt__, {"service.status": fmock}):
self.assertDictEqual(service.running("salt"), ret[3])
with patch.dict(service.__opts__, {"test": False}):
with patch.dict(
service.__salt__,
{
"service.status":
MagicMock(side_effect=[False, False]),
"service.enabled":
MagicMock(side_effecct=[True, True]),
"service.start": MagicMock(return_value="stack"),
},
):
with patch.object(
service,
"_enable",
MagicMock(return_value={"changes": "saltstack"}),
):
self.assertDictEqual(service.running("salt", True),
ret[6])
def test_running(self):
'''
Test to verify that the service is running
'''
ret = [{'comment': '', 'changes': {}, 'name': 'salt', 'result': True},
{'changes': {},
'comment': 'The service salt is already running',
'name': 'salt', 'result': True},
{'changes': 'saltstack',
'comment': 'The service salt is already running',
'name': 'salt', 'result': True},
{'changes': {},
'comment': 'Service salt is set to start', 'name': 'salt',
'result': None},
{'changes': 'saltstack',
'comment': 'Started Service salt', 'name': 'salt',
'result': True},
{'changes': {},
'comment': 'The service salt is already running',
'name': 'salt', 'result': True}]
tmock = MagicMock(return_value=True)
fmock = MagicMock(return_value=False)
vmock = MagicMock(return_value="salt")
with patch.object(service, '_enabled_used_error', vmock):
self.assertEqual(service.running("salt", enabled=1), 'salt')
with patch.object(service, '_available', fmock):
self.assertDictEqual(service.running("salt"), ret[0])
with patch.object(service, '_available', tmock):
with contextlib.nested(
patch.dict(service.__opts__, {'test': False}),
patch.dict(
service.__salt__,
{'service.enabled': tmock, 'service.status': tmock}
)
):
self.assertDictEqual(service.running("salt"), ret[1])
# service was enabled and running, no changes
mock = MagicMock(return_value={'changes': 'saltstack'})
with contextlib.nested(
patch.dict(service.__opts__, {'test': False}),
patch.dict(
service.__salt__,
{'service.enabled':
MagicMock(side_effect=[False, True]),
'service.status': tmock}
),
patch.object(service, '_enable', mock)
):
self.assertDictEqual(service.running("salt", True), ret[2])
with contextlib.nested(
patch.dict(service.__opts__, {'test': False}),
patch.dict(
service.__salt__,
{'service.enabled':
MagicMock(side_effect=[True, False]),
'service.status': tmock}
),
patch.object(service, '_disable', mock)
):
self.assertDictEqual(service.running("salt", False),
ret[2])
with patch.dict(service.__opts__, {'test': True}):
self.assertDictEqual(service.running("salt"), ret[5])
with contextlib.nested(
patch.dict(
service.__salt__,
{'service.status': fmock}
),
patch.dict(service.__opts__, {'test': True})
):
self.assertDictEqual(service.running("salt"), ret[3])
with contextlib.nested(
patch.dict(service.__opts__, {'test': False}),
patch.dict(
service.__salt__, {
'service.status':
MagicMock(side_effect=[False, True]),
'service.enabled':
MagicMock(side_effect=[False, True]),
'service.start':
MagicMock(return_value="stack")}),
patch.object(
service, '_enable',
MagicMock(return_value={'changes': 'saltstack'}))
):
self.assertDictEqual(service.running("salt", True), ret[4])
