def test_is_valid_shell_none(self): """ Tests return of when os.path.exists(/etc/shells) isn't available """ with patch("os.path.exists", MagicMock(return_value=False)): self.assertIsNone(cmdmod._is_valid_shell("foo"))
def test_pbm_si(self): mock_get_pbm_si = MagicMock() with patch('salt.utils.pbm.pbm.ServiceInstance', mock_get_pbm_si): salt.utils.pbm.get_placement_solver(self.mock_si) mock_get_pbm_si.assert_called_once_with('ServiceInstance', self.mock_stub)
def test_retrieve_policy_ids(self): mock_retrieve_policy_ids = MagicMock(return_value=self.mock_policy_ids) self.mock_prof_mgr.QueryProfile = mock_retrieve_policy_ids salt.utils.pbm.get_storage_policies(self.mock_prof_mgr) mock_retrieve_policy_ids.assert_called_once_with(self.mock_res_type)
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])
class JBoss7TestCase(TestCase, LoaderModuleMockMixin): jboss_config = {} org_run_operation = None def setup_loader_modules(self): self.org_run_operation = MagicMock() self.addCleanup(delattr, self, "org_run_operation") return { jboss7: {"__salt__": {"jboss7_cli.run_operation": self.org_run_operation}} } def test_create_simple_binding(self): jboss7.create_simple_binding(self.jboss_config, "java:global/env", "DEV") self.org_run_operation.assert_called_with( self.jboss_config, '/subsystem=naming/binding="java:global/env":add(binding-type=simple, value="DEV")', ) def test_create_simple_binding_with_backslash(self): jboss7.create_simple_binding(self.jboss_config, "java:global/env", r"DEV\2") self.org_run_operation.assert_called_with( self.jboss_config, r'/subsystem=naming/binding="java:global/env":add(binding-type=simple, value="DEV\\\\2")', ) def test_update_binding(self): jboss7.update_simple_binding(self.jboss_config, "java:global/env", "INT") self.org_run_operation.assert_called_with( self.jboss_config, '/subsystem=naming/binding="java:global/env":write-attribute(name=value, value="INT")', ) def test_update_binding_with_backslash(self): jboss7.update_simple_binding(self.jboss_config, "java:global/env", r"INT\2") self.org_run_operation.assert_called_with( self.jboss_config, r'/subsystem=naming/binding="java:global/env":write-attribute(name=value, value="INT\\\\2")', ) def test_read_binding(self): def cli_command_response(jboss_config, cli_command): if ( cli_command == '/subsystem=naming/binding="java:global/env":read-resource' ): return { "outcome": "success", "result": {"binding-type": "simple", "value": "DEV"}, } self.org_run_operation.side_effect = cli_command_response result = jboss7.read_simple_binding(self.jboss_config, "java:global/env") self.assertEqual(result["outcome"], "success") self.assertEqual(result["result"]["value"], "DEV") def test_create_datasource_all_properties_included(self): def cli_command_response(jboss_config, cli_command, fail_on_error=False): if ( cli_command == '/subsystem=datasources/data-source="appDS":read-resource-description' ): return { "outcome": "success", "result": { "attributes": { "driver-name": {"type": "STRING"}, "connection-url": {"type": "STRING"}, "jndi-name": {"type": "STRING"}, "user-name": {"type": "STRING"}, "password": {"type": "STRING"}, } }, } self.org_run_operation.side_effect = cli_command_response datasource_properties = OrderedDict() datasource_properties["driver-name"] = "mysql" datasource_properties["connection-url"] = "jdbc:mysql://localhost:3306/app" datasource_properties["jndi-name"] = "java:jboss/datasources/appDS" datasource_properties["user-name"] = "app" datasource_properties["password"] = "******" jboss7.create_datasource(self.jboss_config, "appDS", datasource_properties) self.org_run_operation.assert_called_with( self.jboss_config, '/subsystem=datasources/data-source="appDS":add(driver-name="mysql",connection-url="jdbc:mysql://localhost:3306/app",jndi-name="java:jboss/datasources/appDS",user-name="app",password="******")', fail_on_error=False, ) def test_create_datasource_format_boolean_value_when_string(self): def cli_command_response(jboss_config, cli_command, fail_on_error=False): if ( cli_command == '/subsystem=datasources/data-source="appDS":read-resource-description' ): return { "outcome": "success", "result": {"attributes": {"use-ccm": {"type": "BOOLEAN"}}}, } self.org_run_operation.side_effect = cli_command_response datasource_properties = OrderedDict() datasource_properties["use-ccm"] = "true" jboss7.create_datasource(self.jboss_config, "appDS", datasource_properties) self.org_run_operation.assert_called_with( self.jboss_config, '/subsystem=datasources/data-source="appDS":add(use-ccm=true)', fail_on_error=False, ) def test_create_datasource_format_boolean_value_when_boolean(self): def cli_command_response(jboss_config, cli_command, fail_on_error=False): if ( cli_command == '/subsystem=datasources/data-source="appDS":read-resource-description' ): return { "outcome": "success", "result": {"attributes": {"use-ccm": {"type": "BOOLEAN"}}}, } self.org_run_operation.side_effect = cli_command_response datasource_properties = OrderedDict() datasource_properties["use-ccm"] = True jboss7.create_datasource(self.jboss_config, "appDS", datasource_properties) self.org_run_operation.assert_called_with( self.jboss_config, '/subsystem=datasources/data-source="appDS":add(use-ccm=true)', fail_on_error=False, ) def test_create_datasource_format_int_value_when_int(self): def cli_command_response(jboss_config, cli_command, fail_on_error=False): if ( cli_command == '/subsystem=datasources/data-source="appDS":read-resource-description' ): return { "outcome": "success", "result": {"attributes": {"min-pool-size": {"type": "INT"}}}, } self.org_run_operation.side_effect = cli_command_response datasource_properties = OrderedDict() datasource_properties["min-pool-size"] = 15 jboss7.create_datasource(self.jboss_config, "appDS", datasource_properties) self.org_run_operation.assert_called_with( self.jboss_config, '/subsystem=datasources/data-source="appDS":add(min-pool-size=15)', fail_on_error=False, ) def test_create_datasource_format_int_value_when_string(self): def cli_command_response(jboss_config, cli_command, fail_on_error=False): if ( cli_command == '/subsystem=datasources/data-source="appDS":read-resource-description' ): return { "outcome": "success", "result": {"attributes": {"min-pool-size": {"type": "INT"}}}, } self.org_run_operation.side_effect = cli_command_response datasource_properties = OrderedDict() datasource_properties["min-pool-size"] = "15" jboss7.create_datasource(self.jboss_config, "appDS", datasource_properties) self.org_run_operation.assert_called_with( self.jboss_config, '/subsystem=datasources/data-source="appDS":add(min-pool-size=15)', fail_on_error=False, ) def test_read_datasource(self): def cli_command_response(jboss_config, cli_command): if ( cli_command == '/subsystem=datasources/data-source="appDS":read-resource' ): return { "outcome": "success", "result": { "driver-name": "mysql", "connection-url": "jdbc:mysql://localhost:3306/app", "jndi-name": "java:jboss/datasources/appDS", "user-name": "app", "password": "******", }, } self.org_run_operation.side_effect = cli_command_response ds_result = jboss7.read_datasource(self.jboss_config, "appDS") ds_properties = ds_result["result"] self.assertEqual(ds_properties["driver-name"], "mysql") self.assertEqual( ds_properties["connection-url"], "jdbc:mysql://localhost:3306/app" ) self.assertEqual(ds_properties["jndi-name"], "java:jboss/datasources/appDS") self.assertEqual(ds_properties["user-name"], "app") self.assertEqual(ds_properties["password"], "app_password") def test_update_datasource(self): datasource_properties = { "driver-name": "mysql", "connection-url": "jdbc:mysql://localhost:3306/app", "jndi-name": "java:jboss/datasources/appDS", "user-name": "newuser", "password": "******", } def cli_command_response(jboss_config, cli_command, fail_on_error=False): if ( cli_command == '/subsystem=datasources/data-source="appDS":read-resource-description' ): return { "outcome": "success", "result": { "attributes": { "driver-name": {"type": "STRING"}, "connection-url": {"type": "STRING"}, "jndi-name": {"type": "STRING"}, "user-name": {"type": "STRING"}, "password": {"type": "STRING"}, } }, } elif ( cli_command == '/subsystem=datasources/data-source="appDS":read-resource' ): return { "outcome": "success", "result": { "driver-name": "mysql", "connection-url": "jdbc:mysql://localhost:3306/app", "jndi-name": "java:jboss/datasources/appDS", "user-name": "app", "password": "******", }, } elif ( cli_command == '/subsystem=datasources/data-source="appDS":write-attribute(name="user-name",value="newuser")' ): return {"outcome": "success", "success": True} self.org_run_operation.side_effect = cli_command_response jboss7.update_datasource(self.jboss_config, "appDS", datasource_properties) self.org_run_operation.assert_any_call( self.jboss_config, '/subsystem=datasources/data-source="appDS":write-attribute(name="user-name",value="newuser")', fail_on_error=False, )
def setUp(self): # setup the service instance self.si_mock = MagicMock() # RootFolder self.root_folder_mock = MagicMock() self.get_root_folder_mock = \ MagicMock(return_value=self.root_folder_mock) # CreateContainerView() self.container_view_mock = MagicMock() self.create_container_view_mock = \ MagicMock(return_value=self.container_view_mock) self.si_mock.content.viewManager.CreateContainerView = \ self.create_container_view_mock # RetrieveContents() self.result_mock = MagicMock() self.retrieve_contents_mock = MagicMock(return_value=self.result_mock) self.si_mock.content.propertyCollector.RetrieveContents = \ self.retrieve_contents_mock # Destroy() self.destroy_mock = MagicMock() self.container_view_mock.Destroy = self.destroy_mock # override mocks self.obj_type_mock = MagicMock() self.traversal_spec_ret_mock = MagicMock() self.traversal_spec_mock = \ MagicMock(return_value=self.traversal_spec_ret_mock) self.property_spec_ret_mock = MagicMock() self.property_spec_mock = \ MagicMock(return_value=self.property_spec_ret_mock) self.obj_spec_ret_mock = MagicMock() self.obj_spec_mock = \ MagicMock(return_value=self.obj_spec_ret_mock) self.filter_spec_ret_mock = MagicMock() self.filter_spec_mock = \ MagicMock(return_value=self.filter_spec_ret_mock)
def test_get_details(self): mock_get_details = MagicMock() with patch.dict(esxdatacenter.__proxy__, {"esxdatacenter.get_details": mock_get_details}): esxdatacenter.get_details() mock_get_details.assert_called_once_with()
class AptUtilsTestCase(TestCase, LoaderModuleMockMixin): """ apt utils test case """ def setup_loader_modules(self): return {aptpkg: {}} def test_call_apt_default(self): """ Call default apt. :return: """ with patch.dict( aptpkg.__salt__, { "cmd.run_all": MagicMock(), "config.get": MagicMock(return_value=False) }, ): aptpkg._call_apt(["apt-get", "install", "emacs"]) # pylint: disable=W0106 aptpkg.__salt__["cmd.run_all"].assert_called_once_with( ["apt-get", "install", "emacs"], env={}, output_loglevel="trace", python_shell=False, ) @patch("salt.utils.systemd.has_scope", MagicMock(return_value=True)) def test_call_apt_in_scope(self): """ Call apt within the scope. :return: """ with patch.dict( aptpkg.__salt__, { "cmd.run_all": MagicMock(), "config.get": MagicMock(return_value=True) }, ): aptpkg._call_apt(["apt-get", "purge", "vim"]) # pylint: disable=W0106 aptpkg.__salt__["cmd.run_all"].assert_called_once_with( [ "systemd-run", "--scope", "--description", '"salt.modules.aptpkg"', "apt-get", "purge", "vim", ], env={}, output_loglevel="trace", python_shell=False, ) def test_call_apt_with_kwargs(self): """ Call apt with the optinal keyword arguments. :return: """ with patch.dict( aptpkg.__salt__, { "cmd.run_all": MagicMock(), "config.get": MagicMock(return_value=False) }, ): aptpkg._call_apt( ["dpkg", "-l", "python"], python_shell=True, output_loglevel="quiet", ignore_retcode=False, username="******", ) # pylint: disable=W0106 aptpkg.__salt__["cmd.run_all"].assert_called_once_with( ["dpkg", "-l", "python"], env={}, ignore_retcode=False, output_loglevel="quiet", python_shell=True, username="******", ) def test_call_apt_dpkg_lock(self): """ Call apt and ensure the dpkg locking is handled :return: """ cmd_side_effect = [ { "stderr": "Could not get lock" }, { "stderr": "Could not get lock" }, { "stderr": "Could not get lock" }, { "stderr": "Could not get lock" }, { "stderr": "", "stdout": "" }, ] cmd_mock = MagicMock(side_effect=cmd_side_effect) cmd_call = (call( ["dpkg", "-l", "python"], env={}, ignore_retcode=False, output_loglevel="quiet", python_shell=True, username="******", ), ) expected_calls = [cmd_call * 5] with patch.dict( aptpkg.__salt__, { "cmd.run_all": cmd_mock, "config.get": MagicMock(return_value=False) }, ): with patch("time.sleep", MagicMock()) as sleep_mock: aptpkg._call_apt( ["dpkg", "-l", "python"], python_shell=True, output_loglevel="quiet", ignore_retcode=False, username="******", ) # pylint: disable=W0106 # We should have sleept at least 4 times assert sleep_mock.call_count >= 4 # We should attempt to call the cmd 5 times self.assertEqual(cmd_mock.call_count, 5) cmd_mock.has_calls(expected_calls)
def test_uptime_macos(self): ''' Test modules.status.uptime function for macOS ''' m = self._set_up_test_uptime() kern_boottime = ('{{ sec = {0}, usec = {1:0<6} }} Mon Oct 03 03:09:18.23 2016' ''.format(*six.text_type(m.now - m.ut).split('.'))) with patch.multiple(salt.utils.platform, is_linux=MagicMock(return_value=False), is_sunos=MagicMock(return_value=False), is_darwin=MagicMock(return_value=True), is_freebsd=MagicMock(return_value=False), is_openbsd=MagicMock(return_value=False), is_netbsd=MagicMock(return_value=False)), \ patch('salt.utils.path.which', MagicMock(return_value=True)), \ patch.dict(status.__salt__, {'cmd.run': MagicMock(return_value=os.linesep.join(['1', '2', '3'])), 'sysctl.get': MagicMock(return_value=kern_boottime)}), \ patch('time.time', MagicMock(return_value=m.now)): ret = status.uptime() self.assertDictEqual(ret, m.ret) with patch.dict(status.__salt__, {'sysctl.get': MagicMock(return_value='')}): with self.assertRaises(CommandExecutionError): status.uptime()
class AptPkgTestCase(TestCase, LoaderModuleMockMixin): """ Test cases for salt.modules.aptpkg """ def setup_loader_modules(self): return {aptpkg: {"__grains__": {}}} def test_version(self): """ Test - Returns a string representing the package version or an empty string if not installed. """ version = LOWPKG_INFO["wget"]["version"] mock = MagicMock(return_value=version) with patch.dict(aptpkg.__salt__, {"pkg_resource.version": mock}): self.assertEqual(aptpkg.version(*["wget"]), version) def test_upgrade_available(self): """ Test - Check whether or not an upgrade is available for a given package. """ with patch("salt.modules.aptpkg.latest_version", MagicMock(return_value="")): self.assertFalse(aptpkg.upgrade_available("wget")) def test_add_repo_key(self): """ Test - Add a repo key. """ with patch("salt.modules.aptpkg.get_repo_keys", MagicMock(return_value=REPO_KEYS)): mock = MagicMock(return_value={"retcode": 0, "stdout": "OK"}) with patch.dict(aptpkg.__salt__, {"cmd.run_all": mock}): self.assertTrue( aptpkg.add_repo_key(keyserver="keyserver.ubuntu.com", keyid="FBB75451")) def test_add_repo_key_failed(self): """ Test - Add a repo key using incomplete input data. """ with patch("salt.modules.aptpkg.get_repo_keys", MagicMock(return_value=REPO_KEYS)): kwargs = {"keyserver": "keyserver.ubuntu.com"} mock = MagicMock(return_value={"retcode": 0, "stdout": "OK"}) with patch.dict(aptpkg.__salt__, {"cmd.run_all": mock}): self.assertRaises(SaltInvocationError, aptpkg.add_repo_key, **kwargs) def test_get_repo_keys(self): """ Test - List known repo key details. """ mock = MagicMock(return_value={"retcode": 0, "stdout": APT_KEY_LIST}) with patch.dict(aptpkg.__salt__, {"cmd.run_all": mock}): self.assertEqual(aptpkg.get_repo_keys(), REPO_KEYS) def test_file_dict(self): """ Test - List the files that belong to a package, grouped by package. """ mock = MagicMock(return_value=LOWPKG_FILES) with patch.dict(aptpkg.__salt__, {"lowpkg.file_dict": mock}): self.assertEqual(aptpkg.file_dict("wget"), LOWPKG_FILES) def test_file_list(self): """ Test - List the files that belong to a package. """ files = { "errors": LOWPKG_FILES["errors"], "files": LOWPKG_FILES["packages"]["wget"], } mock = MagicMock(return_value=files) with patch.dict(aptpkg.__salt__, {"lowpkg.file_list": mock}): self.assertEqual(aptpkg.file_list("wget"), files) def test_get_selections(self): """ Test - View package state from the dpkg database. """ selections = {"install": ["wget"]} mock = MagicMock(return_value="wget\t\t\t\t\t\tinstall") with patch.dict(aptpkg.__salt__, {"cmd.run_stdout": mock}): self.assertEqual(aptpkg.get_selections("wget"), selections) def test_info_installed(self): """ Test - Return the information of the named package(s) installed on the system. """ names = { "group": "section", "packager": "maintainer", "url": "homepage" } installed = copy.deepcopy({"wget": LOWPKG_INFO["wget"]}) for name in names: if installed["wget"].get(names[name], False): installed["wget"][name] = installed["wget"].pop(names[name]) mock = MagicMock(return_value=LOWPKG_INFO) with patch.dict(aptpkg.__salt__, {"lowpkg.info": mock}): del installed["wget"]["status"] self.assertEqual(aptpkg.info_installed("wget"), installed) self.assertEqual(len(aptpkg.info_installed()), 1) def test_owner(self): """ Test - Return the name of the package that owns the file. """ paths = ["/usr/bin/wget"] mock = MagicMock(return_value="wget: /usr/bin/wget") with patch.dict(aptpkg.__salt__, {"cmd.run_stdout": mock}): self.assertEqual(aptpkg.owner(*paths), "wget") def test_refresh_db(self): """ Test - Updates the APT database to latest packages based upon repositories. """ refresh_db = { "http://security.ubuntu.com trusty-security InRelease": True, "http://security.ubuntu.com trusty-security/main Sources": True, "http://security.ubuntu.com trusty-security/main Translation-en": None, "http://security.ubuntu.com trusty-security/main amd64 Packages": True, "http://security.ubuntu.com trusty-security/main i386 Packages": True, } mock = MagicMock(return_value={"retcode": 0, "stdout": APT_Q_UPDATE}) with patch("salt.utils.pkg.clear_rtag", MagicMock()): with patch.dict( aptpkg.__salt__, { "cmd.run_all": mock, "config.get": MagicMock(return_value=False) }, ): self.assertEqual(aptpkg.refresh_db(), refresh_db) def test_refresh_db_failed(self): """ Test - Update the APT database using unreachable repositories. """ kwargs = {"failhard": True} mock = MagicMock(return_value={ "retcode": 0, "stdout": APT_Q_UPDATE_ERROR }) with patch("salt.utils.pkg.clear_rtag", MagicMock()): with patch.dict( aptpkg.__salt__, { "cmd.run_all": mock, "config.get": MagicMock(return_value=False) }, ): self.assertRaises(CommandExecutionError, aptpkg.refresh_db, **kwargs) def test_autoremove(self): """ Test - Remove packages not required by another package. """ with patch("salt.modules.aptpkg.list_pkgs", MagicMock(return_value=PACKAGES)): patch_kwargs = { "__salt__": { "config.get": MagicMock(return_value=True), "cmd.run_all": MagicMock(return_value=MagicMock(return_value=AUTOREMOVE)), } } with patch.multiple(aptpkg, **patch_kwargs): assert aptpkg.autoremove() == {} assert aptpkg.autoremove(purge=True) == {} assert aptpkg.autoremove(list_only=True) == [] assert aptpkg.autoremove(list_only=True, purge=True) == [] def test_install(self): """ Test - Install packages. """ with patch("salt.modules.aptpkg.install", MagicMock(return_value=INSTALL)): self.assertEqual(aptpkg.install(name="tmux"), INSTALL) kwargs = {"force_conf_new": True} self.assertEqual(aptpkg.install(name="tmux", **kwargs), INSTALL) def test_remove(self): """ Test - Remove packages. """ with patch("salt.modules.aptpkg._uninstall", MagicMock(return_value=UNINSTALL)): self.assertEqual(aptpkg.remove(name="tmux"), UNINSTALL) def test_purge(self): """ Test - Remove packages along with all configuration files. """ with patch("salt.modules.aptpkg._uninstall", MagicMock(return_value=UNINSTALL)): self.assertEqual(aptpkg.purge(name="tmux"), UNINSTALL) def test_upgrade(self): """ Test - Upgrades all packages. """ with patch("salt.utils.pkg.clear_rtag", MagicMock()): with patch("salt.modules.aptpkg.list_pkgs", MagicMock(return_value=UNINSTALL)): mock_cmd = MagicMock(return_value={ "retcode": 0, "stdout": UPGRADE }) patch_kwargs = { "__salt__": { "config.get": MagicMock(return_value=True), "cmd.run_all": mock_cmd, } } with patch.multiple(aptpkg, **patch_kwargs): self.assertEqual(aptpkg.upgrade(), dict()) kwargs = {"force_conf_new": True} self.assertEqual(aptpkg.upgrade(**kwargs), dict()) def test_upgrade_downloadonly(self): """ Tests the download-only options for upgrade. """ with patch("salt.utils.pkg.clear_rtag", MagicMock()): with patch("salt.modules.aptpkg.list_pkgs", MagicMock(return_value=UNINSTALL)): mock_cmd = MagicMock(return_value={ "retcode": 0, "stdout": UPGRADE }) patch_kwargs = { "__salt__": { "config.get": MagicMock(return_value=True), "cmd.run_all": mock_cmd, }, } with patch.multiple(aptpkg, **patch_kwargs): aptpkg.upgrade() args_matching = [ True for args in patch_kwargs["__salt__"] ["cmd.run_all"].call_args[0] if "--download-only" in args ] # Here we shouldn't see the parameter and args_matching should be empty. self.assertFalse(any(args_matching)) aptpkg.upgrade(downloadonly=True) args_matching = [ True for args in patch_kwargs["__salt__"] ["cmd.run_all"].call_args[0] if "--download-only" in args ] # --download-only should be in the args list and we should have at least on True in the list. self.assertTrue(any(args_matching)) aptpkg.upgrade(download_only=True) args_matching = [ True for args in patch_kwargs["__salt__"] ["cmd.run_all"].call_args[0] if "--download-only" in args ] # --download-only should be in the args list and we should have at least on True in the list. self.assertTrue(any(args_matching)) def test_show(self): """ Test that the pkg.show function properly parses apt-cache show output. This test uses an abridged output per package, for simplicity. """ show_mock_success = MagicMock( return_value={ "retcode": 0, "pid": 12345, "stderr": "", "stdout": textwrap.dedent("""\ Package: foo1.0 Architecture: amd64 Version: 1.0.5-3ubuntu4 Description: A silly package (1.0 release cycle) Provides: foo Suggests: foo-doc Package: foo1.0 Architecture: amd64 Version: 1.0.4-2ubuntu1 Description: A silly package (1.0 release cycle) Provides: foo Suggests: foo-doc Package: foo-doc Architecture: all Version: 1.0.5-3ubuntu4 Description: Silly documentation for a silly package (1.0 release cycle) Package: foo-doc Architecture: all Version: 1.0.4-2ubuntu1 Description: Silly documentation for a silly package (1.0 release cycle) """), }) show_mock_failure = MagicMock( return_value={ "retcode": 1, "pid": 12345, "stderr": textwrap.dedent("""\ N: Unable to locate package foo* N: Couldn't find any package by glob 'foo*' N: Couldn't find any package by regex 'foo*' E: No packages found """), "stdout": "", }) refresh_mock = Mock() expected = { "foo1.0": { "1.0.5-3ubuntu4": { "Architecture": "amd64", "Description": "A silly package (1.0 release cycle)", "Provides": "foo", "Suggests": "foo-doc", }, "1.0.4-2ubuntu1": { "Architecture": "amd64", "Description": "A silly package (1.0 release cycle)", "Provides": "foo", "Suggests": "foo-doc", }, }, "foo-doc": { "1.0.5-3ubuntu4": { "Architecture": "all", "Description": "Silly documentation for a silly package (1.0 release cycle)", }, "1.0.4-2ubuntu1": { "Architecture": "all", "Description": "Silly documentation for a silly package (1.0 release cycle)", }, }, } # Make a copy of the above dict and strip out some keys to produce the # expected filtered result. filtered = copy.deepcopy(expected) for k1 in filtered: for k2 in filtered[k1]: # Using list() because we will modify the dict during iteration for k3 in list(filtered[k1][k2]): if k3 not in ("Description", "Provides"): filtered[k1][k2].pop(k3) with patch.dict(aptpkg.__salt__, {"cmd.run_all": show_mock_success}), patch.object( aptpkg, "refresh_db", refresh_mock): # Test success (no refresh) self.assertEqual(aptpkg.show("foo*"), expected) refresh_mock.assert_not_called() refresh_mock.reset_mock() # Test success (with refresh) self.assertEqual(aptpkg.show("foo*", refresh=True), expected) self.assert_called_once(refresh_mock) refresh_mock.reset_mock() # Test filtered return self.assertEqual( aptpkg.show("foo*", filter="description,provides"), filtered) refresh_mock.assert_not_called() refresh_mock.reset_mock() with patch.dict(aptpkg.__salt__, {"cmd.run_all": show_mock_failure}), patch.object( aptpkg, "refresh_db", refresh_mock): # Test failure (no refresh) self.assertEqual(aptpkg.show("foo*"), {}) refresh_mock.assert_not_called() refresh_mock.reset_mock() # Test failure (with refresh) self.assertEqual(aptpkg.show("foo*", refresh=True), {}) self.assert_called_once(refresh_mock) refresh_mock.reset_mock() def test_mod_repo_enabled(self): """ Checks if a repo is enabled or disabled depending on the passed kwargs. """ with patch.dict( aptpkg.__salt__, { "config.option": MagicMock(), "no_proxy": MagicMock(return_value=False) }, ): with patch("salt.modules.aptpkg._check_apt", MagicMock(return_value=True)): with patch("salt.modules.aptpkg.refresh_db", MagicMock(return_value={})): with patch("salt.utils.data.is_true", MagicMock(return_value=True)) as data_is_true: with patch("salt.modules.aptpkg.sourceslist", MagicMock(), create=True): repo = aptpkg.mod_repo("foo", enabled=False) data_is_true.assert_called_with(False) # with disabled=True; should call salt.utils.data.is_true True data_is_true.reset_mock() repo = aptpkg.mod_repo("foo", disabled=True) data_is_true.assert_called_with(True) # with enabled=True; should call salt.utils.data.is_true with False data_is_true.reset_mock() repo = aptpkg.mod_repo("foo", enabled=True) data_is_true.assert_called_with(True) # with disabled=True; should call salt.utils.data.is_true False data_is_true.reset_mock() repo = aptpkg.mod_repo("foo", disabled=False) data_is_true.assert_called_with(False) @patch("salt.utils.path.os_walk", MagicMock(return_value=[("test", "test", "test")])) @patch("os.path.getsize", MagicMock(return_value=123456)) @patch("os.path.getctime", MagicMock(return_value=1234567890.123456)) @patch( "fnmatch.filter", MagicMock(return_value=["/var/cache/apt/archive/test_package.rpm"]), ) def test_list_downloaded(self): """ Test downloaded packages listing. :return: """ DOWNLOADED_RET = { "test-package": { "1.0": { "path": "/var/cache/apt/archive/test_package.rpm", "size": 123456, "creation_date_time_t": 1234567890, "creation_date_time": "2009-02-13T23:31:30", } } } with patch.dict( aptpkg.__salt__, { "lowpkg.bin_pkg_info": MagicMock(return_value={ "name": "test-package", "version": "1.0" }) }, ): list_downloaded = aptpkg.list_downloaded() self.assertEqual(len(list_downloaded), 1) self.assertDictEqual(list_downloaded, DOWNLOADED_RET) def test__skip_source(self): """ Test __skip_source. :return: """ # Valid source source_type = "deb" source_uri = "http://cdn-aws.deb.debian.org/debian" source_line = "deb http://cdn-aws.deb.debian.org/debian stretch main\n" mock_source = MockSourceEntry(source_uri, source_type, source_line, False) ret = aptpkg._skip_source(mock_source) self.assertFalse(ret) # Invalid source type source_type = "ded" source_uri = "http://cdn-aws.deb.debian.org/debian" source_line = "deb http://cdn-aws.deb.debian.org/debian stretch main\n" mock_source = MockSourceEntry(source_uri, source_type, source_line, True) ret = aptpkg._skip_source(mock_source) self.assertTrue(ret) # Invalid source type , not skipped source_type = "deb" source_uri = "http://cdn-aws.deb.debian.org/debian" source_line = "deb [http://cdn-aws.deb.debian.org/debian] stretch main\n" mock_source = MockSourceEntry(source_uri, source_type, source_line, True) ret = aptpkg._skip_source(mock_source) self.assertFalse(ret) def test_normalize_name(self): """ Test that package is normalized only when it should be """ with patch.dict(aptpkg.__grains__, {"osarch": "amd64"}): result = aptpkg.normalize_name("foo") assert result == "foo", result result = aptpkg.normalize_name("foo:amd64") assert result == "foo", result result = aptpkg.normalize_name("foo:any") assert result == "foo", result result = aptpkg.normalize_name("foo:i386") assert result == "foo:i386", result def test_list_repos(self): """ Checks results from list_repos """ # Valid source source_type = "deb" source_uri = "http://cdn-aws.deb.debian.org/debian/" source_line = "deb http://cdn-aws.deb.debian.org/debian/ stretch main\n" mock_source = MockSourceEntry(source_uri, source_type, source_line, False) mock_source_list = MockSourceList() mock_source_list.list = [mock_source] with patch("salt.modules.aptpkg._check_apt", MagicMock(return_value=True)): with patch("salt.modules.aptpkg.sourceslist", MagicMock(), create=True): with patch( "salt.modules.aptpkg.sourceslist.SourcesList", MagicMock(return_value=mock_source_list), create=True, ): repos = aptpkg.list_repos() self.assertIn(source_uri, repos) assert isinstance(repos[source_uri], list) assert len(repos[source_uri]) == 1 # Make sure last character in of the URI in line is still a / self.assertIn("line", repos[source_uri][0]) _uri = _get_uri(repos[source_uri][0]["line"]) self.assertEqual(_uri[-1], "/") # Make sure last character in URI is still a / self.assertIn("uri", repos[source_uri][0]) self.assertEqual(repos[source_uri][0]["uri"][-1], "/") def test_expand_repo_def(self): """ Checks results from expand_repo_def """ source_type = "deb" source_uri = "http://cdn-aws.deb.debian.org/debian/" source_line = "deb http://cdn-aws.deb.debian.org/debian/ stretch main\n" source_file = "/etc/apt/sources.list" mock_source = MockSourceEntry(source_uri, source_type, source_line, False, file=source_file) # Valid source with patch("salt.modules.aptpkg._check_apt", MagicMock(return_value=True)): with patch("salt.modules.aptpkg.sourceslist", MagicMock(), create=True): with patch( "salt.modules.aptpkg.sourceslist.SourceEntry", MagicMock(return_value=mock_source), create=True, ): repo = "deb http://cdn-aws.deb.debian.org/debian/ stretch main\n" sanitized = aptpkg.expand_repo_def(repo=repo, file=source_file) assert isinstance(sanitized, dict) self.assertIn("uri", sanitized) # Make sure last character in of the URI is still a / self.assertEqual(sanitized["uri"][-1], "/")
def test_show(self): """ Test that the pkg.show function properly parses apt-cache show output. This test uses an abridged output per package, for simplicity. """ show_mock_success = MagicMock( return_value={ "retcode": 0, "pid": 12345, "stderr": "", "stdout": textwrap.dedent("""\ Package: foo1.0 Architecture: amd64 Version: 1.0.5-3ubuntu4 Description: A silly package (1.0 release cycle) Provides: foo Suggests: foo-doc Package: foo1.0 Architecture: amd64 Version: 1.0.4-2ubuntu1 Description: A silly package (1.0 release cycle) Provides: foo Suggests: foo-doc Package: foo-doc Architecture: all Version: 1.0.5-3ubuntu4 Description: Silly documentation for a silly package (1.0 release cycle) Package: foo-doc Architecture: all Version: 1.0.4-2ubuntu1 Description: Silly documentation for a silly package (1.0 release cycle) """), }) show_mock_failure = MagicMock( return_value={ "retcode": 1, "pid": 12345, "stderr": textwrap.dedent("""\ N: Unable to locate package foo* N: Couldn't find any package by glob 'foo*' N: Couldn't find any package by regex 'foo*' E: No packages found """), "stdout": "", }) refresh_mock = Mock() expected = { "foo1.0": { "1.0.5-3ubuntu4": { "Architecture": "amd64", "Description": "A silly package (1.0 release cycle)", "Provides": "foo", "Suggests": "foo-doc", }, "1.0.4-2ubuntu1": { "Architecture": "amd64", "Description": "A silly package (1.0 release cycle)", "Provides": "foo", "Suggests": "foo-doc", }, }, "foo-doc": { "1.0.5-3ubuntu4": { "Architecture": "all", "Description": "Silly documentation for a silly package (1.0 release cycle)", }, "1.0.4-2ubuntu1": { "Architecture": "all", "Description": "Silly documentation for a silly package (1.0 release cycle)", }, }, } # Make a copy of the above dict and strip out some keys to produce the # expected filtered result. filtered = copy.deepcopy(expected) for k1 in filtered: for k2 in filtered[k1]: # Using list() because we will modify the dict during iteration for k3 in list(filtered[k1][k2]): if k3 not in ("Description", "Provides"): filtered[k1][k2].pop(k3) with patch.dict(aptpkg.__salt__, {"cmd.run_all": show_mock_success}), patch.object( aptpkg, "refresh_db", refresh_mock): # Test success (no refresh) self.assertEqual(aptpkg.show("foo*"), expected) refresh_mock.assert_not_called() refresh_mock.reset_mock() # Test success (with refresh) self.assertEqual(aptpkg.show("foo*", refresh=True), expected) self.assert_called_once(refresh_mock) refresh_mock.reset_mock() # Test filtered return self.assertEqual( aptpkg.show("foo*", filter="description,provides"), filtered) refresh_mock.assert_not_called() refresh_mock.reset_mock() with patch.dict(aptpkg.__salt__, {"cmd.run_all": show_mock_failure}), patch.object( aptpkg, "refresh_db", refresh_mock): # Test failure (no refresh) self.assertEqual(aptpkg.show("foo*"), {}) refresh_mock.assert_not_called() refresh_mock.reset_mock() # Test failure (with refresh) self.assertEqual(aptpkg.show("foo*", refresh=True), {}) self.assert_called_once(refresh_mock) refresh_mock.reset_mock()
class MacGroupTestCase(TestCase): ''' TestCase for the salt.modules.mac_group module ''' mac_group.__context__ = {} mac_group.__salt__ = {} mock_group = {'passwd': '*', 'gid': 0, 'name': 'test', 'members': ['root']} mock_getgrall = [grp.struct_group(('foo', '*', 20, ['test']))] # 'add' function tests: 6 @patch('salt.modules.mac_group.info', MagicMock(return_value=mock_group)) def test_add_group_exists(self): ''' Tests if the group already exists or not ''' self.assertRaises(CommandExecutionError, mac_group.add, 'test') @patch('salt.modules.mac_group.info', MagicMock(return_value={})) def test_add_whitespace(self): ''' Tests if there is whitespace in the group name ''' self.assertRaises(SaltInvocationError, mac_group.add, 'white space') @patch('salt.modules.mac_group.info', MagicMock(return_value={})) def test_add_underscore(self): ''' Tests if the group name starts with an underscore or not ''' self.assertRaises(SaltInvocationError, mac_group.add, '_Test') @patch('salt.modules.mac_group.info', MagicMock(return_value={})) def test_add_gid_int(self): ''' Tests if the gid is an int or not ''' self.assertRaises(SaltInvocationError, mac_group.add, 'foo', 'foo') @patch('salt.modules.mac_group.info', MagicMock(return_value={})) @patch('salt.modules.mac_group._list_gids', MagicMock(return_value=['3456'])) def test_add_gid_exists(self): ''' Tests if the gid is already in use or not ''' self.assertRaises(CommandExecutionError, mac_group.add, 'foo', 3456) @patch('salt.modules.mac_group.info', MagicMock(return_value={})) @patch('salt.modules.mac_group._list_gids', MagicMock(return_value=[])) def test_add(self): ''' Tests if specified group was added ''' mock_ret = MagicMock(return_value=0) with patch.dict(mac_group.__salt__, {'cmd.retcode': mock_ret}): self.assertTrue(mac_group.add('test', 500)) # 'delete' function tests: 4 def test_delete_whitespace(self): ''' Tests if there is whitespace in the group name ''' self.assertRaises(SaltInvocationError, mac_group.delete, 'white space') def test_delete_underscore(self): ''' Tests if the group name starts with an underscore or not ''' self.assertRaises(SaltInvocationError, mac_group.delete, '_Test') @patch('salt.modules.mac_group.info', MagicMock(return_value={})) def test_delete_group_exists(self): ''' Tests if the group to be deleted exists or not ''' self.assertTrue(mac_group.delete('test')) @patch('salt.modules.mac_group.info', MagicMock(return_value=mock_group)) def test_delete(self): ''' Tests if the specified group was deleted ''' mock_ret = MagicMock(return_value=0) with patch.dict(mac_group.__salt__, {'cmd.retcode': mock_ret}): self.assertTrue(mac_group.delete('test')) # 'info' function tests: 2 def test_info_whitespace(self): ''' Tests if there is whitespace in the group name ''' self.assertRaises(SaltInvocationError, mac_group.info, 'white space') @patch('grp.getgrall', MagicMock(return_value=mock_getgrall)) def test_info(self): ''' Tests the return of group information ''' ret = {'passwd': '*', 'gid': 20, 'name': 'foo', 'members': ['test']} self.assertEqual(mac_group.info('foo'), ret) # '_format_info' function tests: 1 def test_format_info(self): ''' Tests the formatting of returned group information ''' data = grp.struct_group(('wheel', '*', 0, ['root'])) ret = {'passwd': '*', 'gid': 0, 'name': 'wheel', 'members': ['root']} self.assertEqual(mac_group._format_info(data), ret) # 'getent' function tests: 1 @patch('grp.getgrall', MagicMock(return_value=mock_getgrall)) def test_getent(self): ''' Tests the return of information on all groups ''' ret = [{'passwd': '*', 'gid': 20, 'name': 'foo', 'members': ['test']}] self.assertEqual(mac_group.getent(), ret) # 'chgid' function tests: 4 def test_chgid_gid_int(self): ''' Tests if gid is an integer or not ''' self.assertRaises(SaltInvocationError, mac_group.chgid, 'foo', 'foo') @patch('salt.modules.mac_group.info', MagicMock(return_value={})) def test_chgid_group_exists(self): ''' Tests if the group id exists or not ''' mock_pre_gid = MagicMock(return_value='') with patch.dict(mac_group.__salt__, {'file.group_to_gid': mock_pre_gid}): self.assertRaises(CommandExecutionError, mac_group.chgid, 'foo', 4376) @patch('salt.modules.mac_group.info', MagicMock(return_value=mock_group)) def test_chgid_gid_same(self): ''' Tests if the group id is the same as argument ''' mock_pre_gid = MagicMock(return_value=0) with patch.dict(mac_group.__salt__, {'file.group_to_gid': mock_pre_gid}): self.assertTrue(mac_group.chgid('test', 0)) @patch('salt.modules.mac_group.info', MagicMock(return_value=mock_group)) def test_chgid(self): ''' Tests the gid for a named group was changed ''' mock_pre_gid = MagicMock(return_value=0) mock_ret = MagicMock(return_value=0) with patch.dict(mac_group.__salt__, {'file.group_to_gid': mock_pre_gid}): with patch.dict(mac_group.__salt__, {'cmd.retcode': mock_ret}): self.assertTrue(mac_group.chgid('test', 500))
def mock_proc(__cmd__, **kwargs): cmd_handler.cmd = " ".join(__cmd__) return MagicMock(return_value=MockTimedProc(stdout=None, stderr=None))
def test_shell_properly_handled_on_macOS(self): """ cmd.run should invoke a new bash login only when bash is the default shell for the selected user """ class _CommandHandler(object): """ Class for capturing cmd """ def __init__(self): self.cmd = None def clear(self): self.cmd = None cmd_handler = _CommandHandler() def mock_proc(__cmd__, **kwargs): cmd_handler.cmd = " ".join(__cmd__) return MagicMock(return_value=MockTimedProc(stdout=None, stderr=None)) with patch("pwd.getpwnam") as getpwnam_mock: with patch("salt.utils.timed_subprocess.TimedProc", mock_proc): # User default shell is '/usr/local/bin/bash' user_default_shell = "/usr/local/bin/bash" with patch.dict( cmdmod.__salt__, { "user.info": MagicMock( return_value={"shell": user_default_shell} ) }, ): cmd_handler.clear() cmdmod._run( "ls", cwd=tempfile.gettempdir(), runas="foobar", use_vt=False ) self.assertRegex( cmd_handler.cmd, "{} -l -c".format(user_default_shell), "cmd invokes right bash session on macOS", ) # User default shell is '/bin/zsh' user_default_shell = "/bin/zsh" with patch.dict( cmdmod.__salt__, { "user.info": MagicMock( return_value={"shell": user_default_shell} ) }, ): cmd_handler.clear() cmdmod._run( "ls", cwd=tempfile.gettempdir(), runas="foobar", use_vt=False ) self.assertNotRegex( cmd_handler.cmd, "bash -l -c", "cmd does not invoke user shell on macOS", )
def test_return_managed_object_name(self): mock_get_properties_of_managed_object = MagicMock() with patch('salt.utils.vmware.get_properties_of_managed_object', MagicMock(return_value={'name': 'fake_name'})): ret = salt.utils.vmware.get_managed_object_name(self.mock_mo_ref) self.assertEqual(ret, 'fake_name')
def test_uptime_linux(self): ''' Test modules.status.uptime function for Linux ''' m = self._set_up_test_uptime() with patch.multiple(salt.utils.platform, is_linux=MagicMock(return_value=True), is_sunos=MagicMock(return_value=False), is_darwin=MagicMock(return_value=False), is_freebsd=MagicMock(return_value=False), is_openbsd=MagicMock(return_value=False), is_netbsd=MagicMock(return_value=False)), \ patch('salt.utils.path.which', MagicMock(return_value=True)), \ patch.dict(status.__salt__, {'cmd.run': MagicMock(return_value=os.linesep.join(['1', '2', '3']))}), \ patch('time.time', MagicMock(return_value=m.now)), \ patch('os.path.exists', MagicMock(return_value=True)): proc_uptime = salt.utils.stringutils.to_str('{0} {1}'.format(m.ut, m.idle)) with patch('salt.utils.files.fopen', mock_open(read_data=proc_uptime)): ret = status.uptime() self.assertDictEqual(ret, m.ret) with patch('os.path.exists', MagicMock(return_value=False)): with self.assertRaises(CommandExecutionError): status.uptime()
class GetContentTestCase(TestCase): '''Tests for salt.utils.get_content''' # Method names to be patched traversal_spec_method_name = \ 'salt.utils.vmware.vmodl.query.PropertyCollector.TraversalSpec' property_spec_method_name = \ 'salt.utils.vmware.vmodl.query.PropertyCollector.PropertySpec' obj_spec_method_name = \ 'salt.utils.vmware.vmodl.query.PropertyCollector.ObjectSpec' filter_spec_method_name = \ 'salt.utils.vmware.vmodl.query.PropertyCollector.FilterSpec' # Class variables si_mock = None root_folder_mock = None root_folder_prop = None container_view_mock = None create_container_view_mock = None result_mock = None retrieve_contents_mock = None destroy_mock = None obj_type_mock = None traversal_spec_ret_mock = None traversal_spec_mock = None property_spec_ret_mock = None property_spec_mock = None obj_spec_ret_mock = None obj_spec_mock = None filter_spec_ret_mock = None filter_spec_mock = None def setUp(self): # setup the service instance self.si_mock = MagicMock() # RootFolder self.root_folder_mock = MagicMock() self.get_root_folder_mock = \ MagicMock(return_value=self.root_folder_mock) # CreateContainerView() self.container_view_mock = MagicMock() self.create_container_view_mock = \ MagicMock(return_value=self.container_view_mock) self.si_mock.content.viewManager.CreateContainerView = \ self.create_container_view_mock # RetrieveContents() self.result_mock = MagicMock() self.retrieve_contents_mock = MagicMock(return_value=self.result_mock) self.si_mock.content.propertyCollector.RetrieveContents = \ self.retrieve_contents_mock # Destroy() self.destroy_mock = MagicMock() self.container_view_mock.Destroy = self.destroy_mock # override mocks self.obj_type_mock = MagicMock() self.traversal_spec_ret_mock = MagicMock() self.traversal_spec_mock = \ MagicMock(return_value=self.traversal_spec_ret_mock) self.property_spec_ret_mock = MagicMock() self.property_spec_mock = \ MagicMock(return_value=self.property_spec_ret_mock) self.obj_spec_ret_mock = MagicMock() self.obj_spec_mock = \ MagicMock(return_value=self.obj_spec_ret_mock) self.filter_spec_ret_mock = MagicMock() self.filter_spec_mock = \ MagicMock(return_value=self.filter_spec_ret_mock) def test_empty_container_ref(self): with patch('salt.utils.vmware.get_root_folder', self.get_root_folder_mock): salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock) self.get_root_folder_mock.assert_called_once_with(self.si_mock) self.create_container_view_mock.assert_called_once_with( self.root_folder_mock, [self.obj_type_mock], True) def test_defined_container_ref(self): container_ref_mock = MagicMock() with patch('salt.utils.vmware.get_root_folder', self.get_root_folder_mock): with patch(self.obj_spec_method_name, self.obj_type_mock): salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock, container_ref=container_ref_mock) self.assertEqual(self.get_root_folder_mock.call_count, 0) self.create_container_view_mock.assert_called_once_with( container_ref_mock, [self.obj_type_mock], True) # Also checks destroy is called def test_local_traversal_spec(self): with patch('salt.utils.vmware.get_root_folder', self.get_root_folder_mock): with patch(self.traversal_spec_method_name, self.traversal_spec_mock): with patch(self.obj_spec_method_name, self.obj_spec_mock): ret = salt.utils.vmware.get_content( self.si_mock, self.obj_type_mock) self.create_container_view_mock.assert_called_once_with( self.root_folder_mock, [self.obj_type_mock], True) self.traversal_spec_mock.assert_called_once_with( name='traverseEntities', path='view', skip=False, type=vim.view.ContainerView) self.obj_spec_mock.assert_called_once_with( obj=self.container_view_mock, skip=True, selectSet=[self.traversal_spec_ret_mock]) # check destroy is called self.assertEqual(self.destroy_mock.call_count, 1) def test_create_container_view_raise_vim_fault(self): exc = vim.fault.VimFault() exc.msg = 'VimFault msg' self.si_mock.content.viewManager.CreateContainerView = \ MagicMock(side_effect=exc) with patch('salt.utils.vmware.get_root_folder', self.get_root_folder_mock): with self.assertRaises(excs.VMwareApiError) as excinfo: salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock) self.assertEqual(excinfo.exception.strerror, 'VimFault msg') def test_create_container_view_raise_runtime_fault(self): exc = vmodl.RuntimeFault() exc.msg = 'RuntimeFault msg' self.si_mock.content.viewManager.CreateContainerView = \ MagicMock(side_effect=exc) with patch('salt.utils.vmware.get_root_folder', self.get_root_folder_mock): with self.assertRaises(excs.VMwareRuntimeError) as excinfo: salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock) self.assertEqual(excinfo.exception.strerror, 'RuntimeFault msg') def test_destroy_raise_vim_fault(self): exc = vim.fault.VimFault() exc.msg = 'VimFault msg' self.si_mock.content.viewManager.CreateContainerView = MagicMock( return_value=MagicMock(Destroy=MagicMock(side_effect=exc))) with patch('salt.utils.vmware.get_root_folder', self.get_root_folder_mock): with self.assertRaises(excs.VMwareApiError) as excinfo: salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock) self.assertEqual(excinfo.exception.strerror, 'VimFault msg') def test_destroy_raise_runtime_fault(self): exc = vmodl.RuntimeFault() exc.msg = 'RuntimeFault msg' self.si_mock.content.viewManager.CreateContainerView = MagicMock( return_value=MagicMock(Destroy=MagicMock(side_effect=exc))) with patch('salt.utils.vmware.get_root_folder', self.get_root_folder_mock): with self.assertRaises(excs.VMwareRuntimeError) as excinfo: salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock) self.assertEqual(excinfo.exception.strerror, 'RuntimeFault msg') # Also checks destroy is not called def test_external_traversal_spec(self): traversal_spec_obj_mock = MagicMock() with patch('salt.utils.vmware.get_root_folder', self.get_root_folder_mock): with patch(self.traversal_spec_method_name, self.traversal_spec_mock): with patch(self.obj_spec_method_name, self.obj_spec_mock): salt.utils.vmware.get_content( self.si_mock, self.obj_type_mock, traversal_spec=traversal_spec_obj_mock) self.obj_spec_mock.assert_called_once_with( obj=self.root_folder_mock, skip=True, selectSet=[traversal_spec_obj_mock]) # Check local traversal methods are not called self.assertEqual(self.create_container_view_mock.call_count, 0) self.assertEqual(self.traversal_spec_mock.call_count, 0) # check destroy is not called self.assertEqual(self.destroy_mock.call_count, 0) def test_property_obj_filter_specs_and_contents(self): with patch(self.traversal_spec_method_name, self.traversal_spec_mock): with patch(self.property_spec_method_name, self.property_spec_mock): with patch(self.obj_spec_method_name, self.obj_spec_mock): with patch(self.filter_spec_method_name, self.filter_spec_mock): ret = salt.utils.vmware.get_content( self.si_mock, self.obj_type_mock) self.traversal_spec_mock.assert_called_once_with( name='traverseEntities', path='view', skip=False, type=vim.view.ContainerView) self.property_spec_mock.assert_called_once_with( type=self.obj_type_mock, all=True, pathSet=None) self.obj_spec_mock.assert_called_once_with( obj=self.container_view_mock, skip=True, selectSet=[self.traversal_spec_ret_mock]) self.retrieve_contents_mock.assert_called_once_with( [self.filter_spec_ret_mock]) self.assertEqual(ret, self.result_mock) def test_retrieve_contents_raise_vim_fault(self): exc = vim.fault.VimFault() exc.msg = 'VimFault msg' self.si_mock.content.propertyCollector.RetrieveContents = \ MagicMock(side_effect=exc) with self.assertRaises(excs.VMwareApiError) as excinfo: salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock) self.assertEqual(excinfo.exception.strerror, 'VimFault msg') def test_retrieve_contents_raise_runtime_fault(self): exc = vmodl.RuntimeFault() exc.msg = 'RuntimeFault msg' self.si_mock.content.propertyCollector.RetrieveContents = \ MagicMock(side_effect=exc) with self.assertRaises(excs.VMwareRuntimeError) as excinfo: salt.utils.vmware.get_content(self.si_mock, self.obj_type_mock) self.assertEqual(excinfo.exception.strerror, 'RuntimeFault msg') def test_local_properties_set(self): container_ref_mock = MagicMock() with patch(self.traversal_spec_method_name, self.traversal_spec_mock): with patch(self.property_spec_method_name, self.property_spec_mock): with patch(self.obj_spec_method_name, self.obj_spec_mock): salt.utils.vmware.get_content( self.si_mock, self.obj_type_mock, container_ref=container_ref_mock, local_properties=True) self.assertEqual(self.traversal_spec_mock.call_count, 0) self.obj_spec_mock.assert_called_once_with(obj=container_ref_mock, skip=False, selectSet=None)
class M2CryptTestCase(TestCase): @patch('os.umask', MagicMock()) @patch('os.chmod', MagicMock()) @patch('os.access', MagicMock(return_value=True)) def test_gen_keys(self): with patch('M2Crypto.RSA.RSA.save_pem', MagicMock()) as save_pem: with patch('M2Crypto.RSA.RSA.save_pub_key', MagicMock()) as save_pub: with patch('os.path.isfile', return_value=True): self.assertEqual(crypt.gen_keys('/keydir', 'keyname', 2048), '/keydir{0}keyname.pem'.format(os.sep)) save_pem.assert_not_called() save_pub.assert_not_called() with patch('os.path.isfile', return_value=False): self.assertEqual(crypt.gen_keys('/keydir', 'keyname', 2048), '/keydir{0}keyname.pem'.format(os.sep)) save_pem.assert_called_once_with('/keydir{0}keyname.pem'.format(os.sep), cipher=None) save_pub.assert_called_once_with('/keydir{0}keyname.pub'.format(os.sep)) @patch('os.umask', MagicMock()) @patch('os.chmod', MagicMock()) @patch('os.chown', MagicMock()) @patch('os.access', MagicMock(return_value=True)) def test_gen_keys_with_passphrase(self): with patch('M2Crypto.RSA.RSA.save_pem', MagicMock()) as save_pem: with patch('M2Crypto.RSA.RSA.save_pub_key', MagicMock()) as save_pub: with patch('os.path.isfile', return_value=True): self.assertEqual(crypt.gen_keys('/keydir', 'keyname', 2048, passphrase='password'), '/keydir{0}keyname.pem'.format(os.sep)) save_pem.assert_not_called() save_pub.assert_not_called() with patch('os.path.isfile', return_value=False): self.assertEqual(crypt.gen_keys('/keydir', 'keyname', 2048, passphrase='password'), '/keydir{0}keyname.pem'.format(os.sep)) callback = save_pem.call_args[1]['callback'] save_pem.assert_called_once_with('/keydir{0}keyname.pem'.format(os.sep), cipher='des_ede3_cbc', callback=callback) self.assertEqual(callback(None), b'password') save_pub.assert_called_once_with('/keydir{0}keyname.pub'.format(os.sep)) def test_sign_message(self): key = M2Crypto.RSA.load_key_string(six.b(PRIVKEY_DATA)) with patch('salt.crypt.get_rsa_key', return_value=key): self.assertEqual(SIG, salt.crypt.sign_message('/keydir/keyname.pem', MSG)) def test_sign_message_with_passphrase(self): key = M2Crypto.RSA.load_key_string(six.b(PRIVKEY_DATA)) with patch('salt.crypt.get_rsa_key', return_value=key): self.assertEqual(SIG, crypt.sign_message('/keydir/keyname.pem', MSG, passphrase='password')) def test_verify_signature(self): key = M2Crypto.RSA.load_pub_key_bio(M2Crypto.BIO.MemoryBuffer(six.b(PUBKEY_DATA))) with patch('M2Crypto.RSA.load_pub_key', return_value=key): self.assertTrue(crypt.verify_signature('/keydir/keyname.pub', MSG, SIG)) def test_encrypt_decrypt_bin(self): priv_key = M2Crypto.RSA.load_key_string(six.b(PRIVKEY_DATA)) pub_key = M2Crypto.RSA.load_pub_key_bio(M2Crypto.BIO.MemoryBuffer(six.b(PUBKEY_DATA))) encrypted = salt.crypt.private_encrypt(priv_key, b'salt') decrypted = salt.crypt.public_decrypt(pub_key, encrypted) self.assertEqual(b'salt', decrypted)
def setUp(self): self.mock_root_folder = MagicMock() self.mock_content = MagicMock(rootFolder=self.mock_root_folder) self.mock_si = MagicMock(RetrieveContent=MagicMock( return_value=self.mock_content))
class PoudriereTestCase(TestCase): ''' Test cases for salt.modules.poudriere ''' # 'is_jail' function tests: 1 @patch('salt.modules.poudriere._check_config_exists', MagicMock(return_value=True)) def test_is_jail(self): ''' Test if it return True if jail exists False if not. ''' mock = MagicMock(return_value='salt stack') with patch.dict(poudriere.__salt__, {'cmd.run': mock}): self.assertTrue(poudriere.is_jail('salt')) self.assertFalse(poudriere.is_jail('SALT')) # 'make_pkgng_aware' function tests: 1 def test_make_pkgng_aware(self): ''' Test if it make jail ``jname`` pkgng aware. ''' ret1 = 'Could not create or find required directory /tmp/salt' ret2 = 'Looks like file /tmp/salt/salt-make.conf could not be created' ret3 = {'changes': 'Created /tmp/salt/salt-make.conf'} mock = MagicMock(return_value='/tmp/salt') mock_true = MagicMock(return_value=True) with patch.dict(poudriere.__salt__, { 'config.option': mock, 'file.write': mock_true }): with patch.object(os.path, 'isdir', MagicMock(return_value=False)): with patch.object(os, 'makedirs', mock_true): self.assertEqual(poudriere.make_pkgng_aware('salt'), ret1) with patch.object(os.path, 'isdir', mock_true): self.assertEqual(poudriere.make_pkgng_aware('salt'), ret2) with patch.object(os.path, 'isfile', mock_true): self.assertDictEqual(poudriere.make_pkgng_aware('salt'), ret3) # 'parse_config' function tests: 1 @patch('salt.utils.fopen', mock_open()) def test_parse_config(self): ''' Test if it returns a dict of poudriere main configuration definitions. ''' mock = MagicMock(return_value='/tmp/salt') with patch.dict(poudriere.__salt__, {'config.option': mock}): with patch.object(poudriere, '_check_config_exists', MagicMock(side_effect=[True, False])): self.assertDictEqual(poudriere.parse_config(), {}) self.assertEqual(poudriere.parse_config(), 'Could not find /tmp/salt on file system') # 'version' function tests: 1 def test_version(self): ''' Test if it return poudriere version. ''' mock = MagicMock(return_value='9.0-RELEASE') with patch.dict(poudriere.__salt__, {'cmd.run': mock}): self.assertEqual(poudriere.version(), '9.0-RELEASE') # 'list_jails' function tests: 1 @patch('salt.modules.poudriere._check_config_exists', MagicMock(return_value=True)) def test_list_jails(self): ''' Test if it return a list of current jails managed by poudriere. ''' mock = MagicMock(return_value='salt stack') with patch.dict(poudriere.__salt__, {'cmd.run': mock}): self.assertListEqual(poudriere.list_jails(), ['salt stack']) # 'list_ports' function tests: 1 @patch('salt.modules.poudriere._check_config_exists', MagicMock(return_value=True)) def test_list_ports(self): ''' Test if it return a list of current port trees managed by poudriere. ''' mock = MagicMock(return_value='salt stack') with patch.dict(poudriere.__salt__, {'cmd.run': mock}): self.assertListEqual(poudriere.list_ports(), ['salt stack']) # 'create_jail' function tests: 1 @patch('salt.modules.poudriere._check_config_exists', MagicMock(return_value=True)) def test_create_jail(self): ''' Test if it creates a new poudriere jail if one does not exist. ''' mock_stack = MagicMock(return_value='90amd64 stack') mock_true = MagicMock(return_value=True) with patch.dict(poudriere.__salt__, {'cmd.run': mock_stack}): self.assertEqual(poudriere.create_jail('90amd64', 'amd64'), '90amd64 already exists') with patch.object(poudriere, 'make_pkgng_aware', mock_true): self.assertEqual(poudriere.create_jail('80amd64', 'amd64'), 'Issue creating jail 80amd64') with patch.object(poudriere, 'make_pkgng_aware', mock_true): with patch.object(poudriere, 'is_jail', MagicMock(side_effect=[False, True])): with patch.dict(poudriere.__salt__, {'cmd.run': mock_stack}): self.assertEqual(poudriere.create_jail('80amd64', 'amd64'), 'Created jail 80amd64') # 'update_jail' function tests: 1 @patch('salt.modules.poudriere._check_config_exists', MagicMock(return_value=True)) def test_update_jail(self): ''' Test if it run freebsd-update on `name` poudriere jail. ''' mock = MagicMock(return_value='90amd64 stack') with patch.dict(poudriere.__salt__, {'cmd.run': mock}): self.assertEqual(poudriere.update_jail('90amd64'), '90amd64 stack') self.assertEqual(poudriere.update_jail('80amd64'), 'Could not find jail 80amd64') # 'delete_jail' function tests: 1 @patch('salt.modules.poudriere._check_config_exists', MagicMock(return_value=True)) def test_delete_jail(self): ''' Test if it deletes poudriere jail with `name`. ''' ret = 'Looks like there was an issue deleteing jail 90amd64' mock_stack = MagicMock(return_value='90amd64 stack') with patch.dict(poudriere.__salt__, {'cmd.run': mock_stack}): self.assertEqual(poudriere.delete_jail('90amd64'), ret) self.assertEqual(poudriere.delete_jail('80amd64'), 'Looks like jail 80amd64 has not been created') ret1 = 'Deleted jail "80amd64" but was unable to remove jail make file' with patch.object(poudriere, 'is_jail', MagicMock(side_effect=[True, False, True, False])): with patch.dict(poudriere.__salt__, {'cmd.run': mock_stack}): with patch.object(poudriere, '_config_dir', MagicMock(return_value='/tmp/salt')): self.assertEqual(poudriere.delete_jail('80amd64'), 'Deleted jail 80amd64') with patch.object(os.path, 'isfile', MagicMock(return_value=True)): self.assertEqual(poudriere.delete_jail('80amd64'), ret1) # 'create_ports_tree' function tests: 1 @patch('salt.modules.poudriere._check_config_exists', MagicMock(return_value=True)) def test_create_ports_tree(self): ''' Test if it not working need to run portfetch non interactive. ''' mock = MagicMock(return_value='salt stack') with patch.dict(poudriere.__salt__, {'cmd.run': mock}): self.assertEqual(poudriere.create_ports_tree(), 'salt stack') # 'update_ports_tree' function tests: 1 @patch('salt.modules.poudriere._check_config_exists', MagicMock(return_value=True)) def test_update_ports_tree(self): ''' Test if it updates the ports tree, either the default or the `ports_tree` specified. ''' mock = MagicMock(return_value='salt stack') with patch.dict(poudriere.__salt__, {'cmd.run': mock}): self.assertEqual(poudriere.update_ports_tree('staging'), 'salt stack') # 'bulk_build' function tests: 1 @patch('salt.modules.poudriere._check_config_exists', MagicMock(return_value=True)) def test_bulk_build(self): ''' Test if it run bulk build on poudriere server. ''' ret = 'Could not find file /root/pkg_list on filesystem' mock = MagicMock(return_value='salt stack') with patch.dict(poudriere.__salt__, {'cmd.run': mock}): self.assertEqual(poudriere.bulk_build('90amd64', '/root/pkg_list'), ret) with patch.object(os.path, 'isfile', MagicMock(return_value=True)): self.assertEqual( poudriere.bulk_build('90amd64', '/root/pkg_list'), 'Could not find jail 90amd64') ret = ('There may have been an issue building ' 'packages dumping output: 90amd64 stack') with patch.object(os.path, 'isfile', MagicMock(return_value=True)): mock = MagicMock(return_value='90amd64 stack packages built') with patch.dict(poudriere.__salt__, {'cmd.run': mock}): self.assertEqual( poudriere.bulk_build('90amd64', '/root/pkg_list'), '90amd64 stack packages built') mock = MagicMock(return_value='90amd64 stack') with patch.dict(poudriere.__salt__, {'cmd.run': mock}): self.assertEqual( poudriere.bulk_build('90amd64', '/root/pkg_list'), ret)
class DnsmasqTestCase(TestCase): ''' TestCase for the salt.modules.at module ''' def test_version(self): ''' test to show installed version of dnsmasq. ''' mock = MagicMock(return_value='A B C') with patch.dict(dnsmasq.__salt__, {'cmd.run': mock}): self.assertEqual(dnsmasq.version(), "C") def test_fullversion(self): ''' Test to Show installed version of dnsmasq and compile options. ''' mock = MagicMock(return_value='A B C\nD E F G H I') with patch.dict(dnsmasq.__salt__, {'cmd.run': mock}): self.assertDictEqual(dnsmasq.fullversion(), {'version': 'C', 'compile options': ['G', 'H', 'I']}) def test_set_config(self): ''' test to show installed version of dnsmasq. ''' mock = MagicMock(return_value={'conf-dir': 'A'}) with patch.object(dnsmasq, 'get_config', mock): mock = MagicMock(return_value=['.', '~', 'bak', '#']) with patch.object(os, 'listdir', mock): self.assertDictEqual(dnsmasq.set_config(), {}) @patch('salt.modules.dnsmasq.get_config', MagicMock(return_value={'conf-dir': 'A'})) def test_set_config_filter_pub_kwargs(self): ''' Test that the kwargs returned from running the set_config function do not contain the __pub that may have been passed through in **kwargs. ''' mock_domain = 'local' mock_address = '/some-test-address.local/8.8.4.4' with patch.dict(dnsmasq.__salt__, {'file.append': MagicMock()}): ret = dnsmasq.set_config(follow=False, domain=mock_domain, address=mock_address, __pub_pid=8184, __pub_jid=20161101194639387946, __pub_tgt='salt-call') self.assertEqual(ret, {'domain': mock_domain, 'address': mock_address}) def test_get_config(self): ''' test to dumps all options from the config file. ''' mock = MagicMock(return_value={'conf-dir': 'A'}) with patch.object(dnsmasq, 'get_config', mock): mock = MagicMock(return_value=['.', '~', 'bak', '#']) with patch.object(os, 'listdir', mock): self.assertDictEqual(dnsmasq.get_config(), {'conf-dir': 'A'}) def test_parse_dnsmasq_no_file(self): ''' Tests that a CommandExecutionError is when a filename that doesn't exist is passed in. ''' self.assertRaises(CommandExecutionError, dnsmasq._parse_dnamasq, 'filename') @patch('os.path.isfile', MagicMock(return_value=True)) def test_parse_dnamasq(self): ''' test for generic function for parsing dnsmasq files including includes. ''' text_file_data = '\n'.join(["line here", "second line", "A=B", "#"]) with patch('salt.utils.fopen', mock_open(read_data=text_file_data), create=True) as m: m.return_value.__iter__.return_value = text_file_data.splitlines() self.assertDictEqual(dnsmasq._parse_dnamasq('filename'), {'A': 'B', 'unparsed': ['line here', 'second line']})
import salt.exceptions as excs import salt.utils.vmware # Import Third Party Libs try: from pyVmomi import vim, vmodl HAS_PYVMOMI = True except ImportError: HAS_PYVMOMI = False # Get Logging Started log = logging.getLogger(__name__) @skipIf(NO_MOCK, NO_MOCK_REASON) @skipIf(not HAS_PYVMOMI, 'The \'pyvmomi\' library is missing') @patch('salt.utils.vmware.time.time', MagicMock(return_value=1)) @patch('salt.utils.vmware.time.sleep', MagicMock(return_value=None)) class WaitForTaskTestCase(TestCase): '''Tests for salt.utils.vmware.wait_for_task''' def test_first_task_info_raise_vim_fault(self): exc = vim.fault.VimFault() exc.msg = 'VimFault msg' mock_task = MagicMock() type(mock_task).info = PropertyMock(side_effect=exc) with self.assertRaises(excs.VMwareApiError) as excinfo: salt.utils.vmware.wait_for_task(mock_task, 'fake_instance_name', 'task_type') self.assertEqual(excinfo.exception.strerror, 'VimFault msg') def test_first_task_info_raise_runtime_fault(self): exc = vmodl.RuntimeFault()
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, 'warnings': ["The 'unmask' argument is not supported by this platform/action"]}] 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 setUp(self): self.si = MagicMock() self.obj_type = MagicMock() self.prop_list = MagicMock() self.container_ref = MagicMock() self.traversal_spec = MagicMock()
def setup_loader_modules(self): self.org_run_operation = MagicMock() self.addCleanup(delattr, self, "org_run_operation") return { jboss7: {"__salt__": {"jboss7_cli.run_operation": self.org_run_operation}} }
def setUp(self): self.mock_si = MagicMock() self.fake_mo_ref = vim.ManagedEntity('Fake') self.mock_props = MagicMock() self.mock_item_name = {'name': 'fake_name'} self.mock_item = MagicMock()
def setUp(self): self.policy_ids = MagicMock() self.mock_policies = MagicMock() self.mock_prof_mgr = MagicMock(RetrieveContent=MagicMock( return_value=self.mock_policies))
def setUp(self): self.mock_mo_ref = MagicMock()
def setUp(self): self.mock_policy_spec = MagicMock() self.mock_policy = MagicMock() self.mock_prof_mgr = MagicMock()
def test_is_valid_shell_windows(self): """ Tests return if running on windows """ with patch("salt.utils.platform.is_windows", MagicMock(return_value=True)): self.assertTrue(cmdmod._is_valid_shell("foo"))