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