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])