def test_reboot_with_delay(self): ''' Test to reboot the system using shutdown -r with a delay ''' cmd_mock = MagicMock(return_value='A') with patch.dict(system.__salt__, {'cmd.run': cmd_mock}): self.assertEqual(system.reboot(at_time=5), 'A') cmd_mock.assert_called_with(['shutdown', '-r', '5'], python_shell=False)
def test_saltify_reboot(self): mm_cmd = MagicMock(return_value=True) lcl = salt.client.LocalClient() lcl.cmd = mm_cmd with patch('salt.client.LocalClient', return_value=lcl): result = saltify.reboot('nodeS1', 'action') mm_cmd.assert_called_with('nodeS1', 'system.reboot') self.assertTrue(result)
def test_reboot(self): ''' Test to reboot the system with shutdown -r ''' cmd_mock = MagicMock(return_value='A') with patch.dict(system.__salt__, {'cmd.run': cmd_mock}): self.assertEqual(system.reboot(), 'A') cmd_mock.assert_called_with(['shutdown', '-r', 'now'], python_shell=False)
def test_reboot_with_delay(self): """ Test to reboot the system using shutdown -r with a delay """ cmd_mock = MagicMock(return_value="A") with patch.dict(system.__salt__, {"cmd.run": cmd_mock}): self.assertEqual(system.reboot(at_time=5), "A") cmd_mock.assert_called_with(["shutdown", "-r", "5"], python_shell=False)
def test_reboot(self): """ Test to reboot the system with shutdown -r """ cmd_mock = MagicMock(return_value="A") with patch.dict(system.__salt__, {"cmd.run": cmd_mock}): self.assertEqual(system.reboot(), "A") cmd_mock.assert_called_with(["shutdown", "-r", "now"], python_shell=False)
def test_saltify_reboot(self): mm_cmd = MagicMock(return_value=True) lcl = salt.client.LocalClient() lcl.cmd = mm_cmd with patch("salt.client.LocalClient", return_value=lcl): result = saltify.reboot("nodeS1", "action") mm_cmd.assert_called_with("nodeS1", "system.reboot") self.assertTrue(result)
def test_get_saved_rules(self): """ Test if it return a data structure of the rules in the conf file """ mock = MagicMock(return_value=False) with patch.object(iptables, "_parse_conf", mock): self.assertFalse(iptables.get_saved_rules()) mock.assert_called_with(conf_file=None, family="ipv4")
def test_get_rules(self): """ Test if it return a data structure of the current, in-memory rules """ mock = MagicMock(return_value=False) with patch.object(iptables, "_parse_conf", mock): self.assertFalse(iptables.get_rules()) mock.assert_called_with(in_mem=True, family="ipv4")
def test_extracted_tar(self): ''' archive.extracted tar options ''' source = '/tmp/foo.tar.gz' tmp_dir = '/tmp/test_extracted_tar' test_tar_opts = [ '--no-anchored foo', 'v -p --opt', '-v -p', '--long-opt -z', 'z -v -weird-long-opt arg', ] ret_tar_opts = [ ['tar', 'x', '--no-anchored', 'foo', '-f'], ['tar', 'xv', '-p', '--opt', '-f'], ['tar', 'x', '-v', '-p', '-f'], ['tar', 'x', '--long-opt', '-z', '-f'], ['tar', 'xz', '-v', '-weird-long-opt', 'arg', '-f'], ] mock_true = MagicMock(return_value=True) mock_false = MagicMock(return_value=False) ret = {'stdout': ['cheese', 'ham', 'saltines'], 'stderr': 'biscuits', 'retcode': '31337', 'pid': '1337'} mock_run = MagicMock(return_value=ret) mock_source_list = MagicMock(return_value=(source, None)) state_single_mock = MagicMock(return_value={'local': {'result': True}}) list_mock = MagicMock(return_value={ 'dirs': [], 'files': ['cheese', 'saltines'], 'links': ['ham'], 'top_level_dirs': [], 'top_level_files': ['cheese', 'saltines'], 'top_level_links': ['ham'], }) isfile_mock = MagicMock(side_effect=_isfile_side_effect) with patch.dict(archive.__opts__, {'test': False, 'cachedir': tmp_dir, 'hash_type': 'sha256'}): with patch.dict(archive.__salt__, {'file.directory_exists': mock_false, 'file.file_exists': mock_false, 'state.single': state_single_mock, 'file.makedirs': mock_true, 'cmd.run_all': mock_run, 'archive.list': list_mock, 'file.source_list': mock_source_list}): with patch.object(os.path, 'isfile', isfile_mock): for test_opts, ret_opts in zip(test_tar_opts, ret_tar_opts): ret = archive.extracted(tmp_dir, source, options=test_opts, enforce_toplevel=False) ret_opts.append(source) mock_run.assert_called_with(ret_opts, cwd=tmp_dir + os.sep, python_shell=False)
def test_list_upgrades_present(): """ Test pkgng.list_upgrades with upgrades available """ pkg_cmd = MagicMock( return_value=textwrap.dedent( """ The following 6 package(s) will be affected (of 0 checked): Installed packages to be UPGRADED: pkga: 1.0 -> 1.1 pkgb: 2.0 -> 2.1 [FreeBSD] pkgc: 3.0 -> 3.1 [FreeBSD] (dependency changed) pkgd: 4.0 -> 4.1 (dependency changed) New packages to be INSTALLED: pkge: 1.0 pkgf: 2.0 [FreeBSD] pkgg: 3.0 [FreeBSD] (dependency changed) pkgh: 4.0 (dependency changed) Installed packages to be REINSTALLED: pkgi-1.0 pkgj-2.0 [FreeBSD] pkgk-3.0 [FreeBSD] (direct dependency changed: pkga) pkgl-4.0 (direct dependency changed: pkgb) Installed packages to be DOWNGRADED: pkgm: 1.1 -> 1.0 pkgn: 2.1 -> 2.0 [FreeBSD] pkgo: 3.1 -> 3.0 [FreeBSD] (dependency changed) pkgp: 4.1 -> 4.0 (dependency changed) Installed packages to be REMOVED: pkgq-1.0 pkgr-2.0 [FreeBSD] pkgs-3.0 [FreeBSD] (direct dependency changed: pkga) pkgt-4.0 (direct dependency changed: pkgb) Number of packages to be upgraded: 2 Number of packages to be reinstalled: 2 The process will require 14 MiB more space. 22 MiB to be downloaded. """ ) ) with patch.dict(pkgng.__salt__, {"cmd.run_stdout": pkg_cmd}): result = pkgng.list_upgrades(refresh=False) assert result == {"pkga": "1.1", "pkgb": "2.1", "pkgc": "3.1", "pkgd": "4.1"} pkg_cmd.assert_called_with( ["pkg", "upgrade", "--dry-run", "--quiet", "--no-repo-update"], output_loglevel="trace", python_shell=False, ignore_retcode=True, )
def test_list_upgrades_present(self): ''' Test pkgng.list_upgrades with upgrades available ''' pkg_cmd = MagicMock(return_value=textwrap.dedent(""" The following 6 package(s) will be affected (of 0 checked): Installed packages to be UPGRADED: pkga: 1.0 -> 1.1 pkgb: 2.0 -> 2.1 [FreeBSD] pkgc: 3.0 -> 3.1 [FreeBSD] (dependency changed) pkgd: 4.0 -> 4.1 (dependency changed) New packages to be INSTALLED: pkge: 1.0 pkgf: 2.0 [FreeBSD] pkgg: 3.0 [FreeBSD] (dependency changed) pkgh: 4.0 (dependency changed) Installed packages to be REINSTALLED: pkgi-1.0 pkgj-2.0 [FreeBSD] pkgk-3.0 [FreeBSD] (direct dependency changed: pkga) pkgl-4.0 (direct dependency changed: pkgb) Installed packages to be DOWNGRADED: pkgm: 1.1 -> 1.0 pkgn: 2.1 -> 2.0 [FreeBSD] pkgo: 3.1 -> 3.0 [FreeBSD] (dependency changed) pkgp: 4.1 -> 4.0 (dependency changed) Installed packages to be REMOVED: pkgq-1.0 pkgr-2.0 [FreeBSD] pkgs-3.0 [FreeBSD] (direct dependency changed: pkga) pkgt-4.0 (direct dependency changed: pkgb) Number of packages to be upgraded: 2 Number of packages to be reinstalled: 2 The process will require 14 MiB more space. 22 MiB to be downloaded. """)) with patch.dict(pkgng.__salt__, {'cmd.run_stdout': pkg_cmd}): result = pkgng.list_upgrades(refresh=False) self.assertDictEqual(result, { 'pkga': '1.1', 'pkgb': '2.1', 'pkgc': '3.1', 'pkgd': '4.1' }) pkg_cmd.assert_called_with( ['pkg', 'upgrade', '--dry-run', '--quiet', '--no-repo-update'], output_loglevel='trace', python_shell=False, ignore_retcode=True)
def test_examine_quiet(self): ''' Test for mdadm_raid.examine ''' mock = MagicMock(return_value='') with patch.dict(mdadm.__salt__, {'cmd.run_stdout': mock}): self.assertEqual(mdadm.examine('/dev/md0', quiet=True), {}) mock.assert_called_with('mdadm -Y -E /dev/md0', ignore_retcode=True, python_shell=False)
def test_get_virtualenv_version_from_shell(self): with ForceImportErrorOn('virtualenv'): # ----- virtualenv binary not available -------------------------> mock = MagicMock(return_value={'retcode': 0, 'stdout': ''}) with patch.dict(virtualenv_mod.__salt__, {'cmd.run_all': mock}): self.assertRaises( CommandExecutionError, virtualenv_mod.create, '/tmp/foo', ) # <---- virtualenv binary not available -------------------------- # ----- virtualenv binary present but > 0 exit code -------------> mock = MagicMock(side_effect=[ {'retcode': 1, 'stdout': '', 'stderr': 'This is an error'}, {'retcode': 0, 'stdout': ''} ]) with patch.dict(virtualenv_mod.__salt__, {'cmd.run_all': mock}): self.assertRaises( CommandExecutionError, virtualenv_mod.create, '/tmp/foo', venv_bin='virtualenv', ) # <---- virtualenv binary present but > 0 exit code -------------- # ----- virtualenv binary returns 1.9.1 as its version ---------> mock = MagicMock(side_effect=[ {'retcode': 0, 'stdout': '1.9.1'}, {'retcode': 0, 'stdout': ''} ]) with patch.dict(virtualenv_mod.__salt__, {'cmd.run_all': mock}): virtualenv_mod.create( '/tmp/foo', never_download=True ) mock.assert_called_with( ['virtualenv', '--never-download', '/tmp/foo'], runas=None, python_shell=False ) # <---- virtualenv binary returns 1.9.1 as its version ---------- # ----- virtualenv binary returns 1.10rc1 as its version -------> mock = MagicMock(side_effect=[ {'retcode': 0, 'stdout': '1.10rc1'}, {'retcode': 0, 'stdout': ''} ]) with patch.dict(virtualenv_mod.__salt__, {'cmd.run_all': mock}): virtualenv_mod.create( '/tmp/foo', never_download=True ) mock.assert_called_with( ['virtualenv', '/tmp/foo'], runas=None, python_shell=False )
def test_pvdisplay(self): """ Tests information about the physical volume(s) """ mock = MagicMock(return_value={"retcode": 1}) with patch.dict(linux_lvm.__salt__, {"cmd.run_all": mock}): self.assertDictEqual(linux_lvm.pvdisplay(), {}) mock = MagicMock(return_value={"retcode": 1}) with patch.dict(linux_lvm.__salt__, {"cmd.run_all": mock}): self.assertDictEqual(linux_lvm.pvdisplay(quiet=True), {}) mock.assert_called_with( ["pvdisplay", "-c"], ignore_retcode=True, python_shell=False ) mock = MagicMock(return_value={"retcode": 0, "stdout": "A:B:C:D:E:F:G:H:I:J:K"}) with patch.dict(linux_lvm.__salt__, {"cmd.run_all": mock}): self.assertDictEqual( linux_lvm.pvdisplay(), { "A": { "Allocated Physical Extents": "K", "Current Logical Volumes Here": "G", "Free Physical Extents": "J", "Internal Physical Volume Number": "D", "Physical Extent Size (kB)": "H", "Physical Volume (not) Allocatable": "F", "Physical Volume Device": "A", "Physical Volume Size (kB)": "C", "Physical Volume Status": "E", "Total Physical Extents": "I", "Volume Group Name": "B", } }, ) mockpath = MagicMock(return_value="Z") with patch.object(os.path, "realpath", mockpath): self.assertDictEqual( linux_lvm.pvdisplay(real=True), { "Z": { "Allocated Physical Extents": "K", "Current Logical Volumes Here": "G", "Free Physical Extents": "J", "Internal Physical Volume Number": "D", "Physical Extent Size (kB)": "H", "Physical Volume (not) Allocatable": "F", "Physical Volume Device": "A", "Physical Volume Size (kB)": "C", "Physical Volume Status": "E", "Real Physical Volume Device": "Z", "Total Physical Extents": "I", "Volume Group Name": "B", } }, )
def test_defined_update_error(test): """ defined state test, with error during the update. """ with patch.dict(virt.__opts__, {"test": test}): init_mock = MagicMock(return_value=True) update_mock = MagicMock(return_value={ "definition": True, "cpu": False, "errors": ["some error"] }) with patch.dict( virt.__salt__, { "virt.list_domains": MagicMock(return_value=["myvm"]), "virt.update": update_mock, "virt.init": init_mock, }, ): assert virt.defined("myvm", cpu=2, boot_dev="cdrom hd") == { "name": "myvm", "changes": { "myvm": { "definition": True, "cpu": False, "errors": ["some error"], } }, "result": True if not test else None, "comment": "Domain myvm updated with live update(s) failures", } init_mock.assert_not_called() update_mock.assert_called_with( "myvm", cpu=2, boot_dev="cdrom hd", mem=None, disk_profile=None, disks=None, nic_profile=None, interfaces=None, graphics=None, live=True, connection=None, username=None, password=None, boot=None, numatune=None, test=test, hypervisor_features=None, clock=None, serials=None, consoles=None, stop_on_reboot=False, host_devices=None, )
def test_update_an_existent_host_proxy(basic_host_configuration, existing_host_responses): """ Tests if the proxy of a host is updated to a new one. This also tests if a proxy can be added, as a host without a proxy have the proxy_hostid property equals zero. """ host, groups, interfaces, kwargs, _ = basic_host_configuration ( host_get_output, hostgroup_get_output, hostinterface_get_output, host_inventory_get_output, ) = existing_host_responses kwargs["proxy_host"] = 10356 host_exists_output = True host_update_output = "31337" run_query_output = [{"proxyid": "10356"}] ret = { "changes": { "proxy_hostid": "10356" }, "comment": "Host new_host updated.", "name": "new_host", "result": True, } mock_hostgroup_get = MagicMock(return_value=hostgroup_get_output) mock_host_exists = MagicMock(return_value=host_exists_output) mock_host_get = MagicMock(return_value=host_get_output) mock_hostinterface_get = MagicMock(return_value=hostinterface_get_output) mock_host_inventory_get = MagicMock(return_value=host_inventory_get_output) mock_host_update = MagicMock(return_value=host_update_output) mock_run_query = MagicMock(return_value=run_query_output) with patch.dict( zabbix_host.__salt__, { "zabbix.hostgroup_get": mock_hostgroup_get, "zabbix.host_exists": mock_host_exists, "zabbix.host_get": mock_host_get, "zabbix.hostinterface_get": mock_hostinterface_get, "zabbix.host_inventory_get": mock_host_inventory_get, "zabbix.host_update": mock_host_update, "zabbix.run_query": mock_run_query, }, ): assert zabbix_host.present(host, groups, interfaces, **kwargs) == ret mock_host_update.assert_called_with( "31337", proxy_hostid="10356", _connection_password="******", _connection_url="http://XXXXXXXXX/zabbix/api_jsonrpc.php", _connection_user="******", )
def test_pvdisplay(self): ''' Tests information about the physical volume(s) ''' mock = MagicMock(return_value={'retcode': 1}) with patch.dict(linux_lvm.__salt__, {'cmd.run_all': mock}): self.assertDictEqual(linux_lvm.pvdisplay(), {}) mock = MagicMock(return_value={'retcode': 1}) with patch.dict(linux_lvm.__salt__, {'cmd.run_all': mock}): self.assertDictEqual(linux_lvm.pvdisplay(quiet=True), {}) mock.assert_called_with(['pvdisplay', '-c'], ignore_retcode=True, python_shell=False) mock = MagicMock(return_value={ 'retcode': 0, 'stdout': 'A:B:C:D:E:F:G:H:I:J:K' }) with patch.dict(linux_lvm.__salt__, {'cmd.run_all': mock}): self.assertDictEqual( linux_lvm.pvdisplay(), { 'A': { 'Allocated Physical Extents': 'K', 'Current Logical Volumes Here': 'G', 'Free Physical Extents': 'J', 'Internal Physical Volume Number': 'D', 'Physical Extent Size (kB)': 'H', 'Physical Volume (not) Allocatable': 'F', 'Physical Volume Device': 'A', 'Physical Volume Size (kB)': 'C', 'Physical Volume Status': 'E', 'Total Physical Extents': 'I', 'Volume Group Name': 'B' } }) mockpath = MagicMock(return_value='Z') with patch.object(os.path, 'realpath', mockpath): self.assertDictEqual( linux_lvm.pvdisplay(real=True), { 'Z': { 'Allocated Physical Extents': 'K', 'Current Logical Volumes Here': 'G', 'Free Physical Extents': 'J', 'Internal Physical Volume Number': 'D', 'Physical Extent Size (kB)': 'H', 'Physical Volume (not) Allocatable': 'F', 'Physical Volume Device': 'A', 'Physical Volume Size (kB)': 'C', 'Physical Volume Status': 'E', 'Real Physical Volume Device': 'Z', 'Total Physical Extents': 'I', 'Volume Group Name': 'B' } })
def test_examine_quiet(self): """ Test for mdadm_raid.examine """ mock = MagicMock(return_value="") with patch.dict(mdadm.__salt__, {"cmd.run_stdout": mock}): self.assertEqual(mdadm.examine("/dev/md0", quiet=True), {}) mock.assert_called_with("mdadm -Y -E /dev/md0", ignore_retcode=True, python_shell=False)
def test_create_a_new_host_with_multiple_groups(basic_host_configuration): """ This test creates a host with multiple groups, mixing names and IDs. """ host, _, interfaces, kwargs, ret = basic_host_configuration groups = ["Testing Group", 15, "Tested Group"] hostgroup_get_output = [ [{ "groupid": "16", "name": "Testing Group", "internal": "0", "flags": "0" }], [{ "groupid": "17", "name": "Tested Group", "internal": "0", "flags": "0" }], ] host_exists_output = False host_create_output = "31337" mock_hostgroup_get = MagicMock(side_effect=hostgroup_get_output) mock_host_exists = MagicMock(return_value=host_exists_output) mock_host_create = MagicMock(return_value=host_create_output) with patch.dict( zabbix_host.__salt__, { "zabbix.hostgroup_get": mock_hostgroup_get, "zabbix.host_exists": mock_host_exists, "zabbix.host_create": mock_host_create, }, ): assert zabbix_host.present(host, groups, interfaces, **kwargs) == ret mock_host_create.assert_called_with( "new_host", [16, 15, 17], [{ "type": "1", "main": "1", "useip": "1", "ip": "127.0.0.1", "dns": "basic_interface", "port": "10050", "details": [], }], _connection_password="******", _connection_url="http://XXXXXXXXX/zabbix/api_jsonrpc.php", _connection_user="******", inventory={}, proxy_hostid="0", visible_name=None, )
def test_create_a_new_host_with_additional_parameters( basic_host_configuration): """ Tests if additional parameters, like "description" or "inventory_mode" are being properly passed to host_create. Also, checks if invalid parameters are filtered out. """ host, groups, interfaces, kwargs, ret = basic_host_configuration kwargs["visible_name"] = "Visible Name" kwargs["description"] = "An amazing test host entry" kwargs["not_valid_property"] = "This should be removed" kwargs["inventory_mode"] = "0" hostgroup_get_output = [{ "groupid": "16", "name": "Testing Group", "internal": "0", "flags": "0" }] host_exists_output = False host_create_output = "31337" mock_hostgroup_get = MagicMock(return_value=hostgroup_get_output) mock_host_exists = MagicMock(return_value=host_exists_output) mock_host_create = MagicMock(return_value=host_create_output) with patch.dict( zabbix_host.__salt__, { "zabbix.hostgroup_get": mock_hostgroup_get, "zabbix.host_exists": mock_host_exists, "zabbix.host_create": mock_host_create, }, ): assert zabbix_host.present(host, groups, interfaces, **kwargs) == ret mock_host_create.assert_called_with( "new_host", [16], [{ "type": "1", "main": "1", "useip": "1", "ip": "127.0.0.1", "dns": "basic_interface", "port": "10050", "details": [], }], _connection_password="******", _connection_url="http://XXXXXXXXX/zabbix/api_jsonrpc.php", _connection_user="******", description="An amazing test host entry", inventory={}, inventory_mode="0", proxy_hostid="0", visible_name="Visible Name", )
def test_network_running_stopped(test): """ network_running state test cases, network stopped case. """ with patch.dict(virt.__opts__, {"test": test}): define_mock = MagicMock(return_value=True) start_mock = MagicMock(return_value=True) update_mock = MagicMock(return_value=False) with patch.dict( virt.__salt__, { # pylint: disable=no-member "virt.network_info": MagicMock( return_value={"mynet": {"active": False, "autostart": True}} ), "virt.network_start": start_mock, "virt.network_define": define_mock, "virt.network_update": update_mock, }, ): assert virt.network_running( "mynet", "br2", "bridge", connection="myconnection", username="******", password="******", ) == { "name": "mynet", "changes": { "mynet": "Network started" }, "comment": "Network mynet unchanged and started", "result": None if test else True, } assert update_mock.call_args_list == [ network_update_call( "mynet", "br2", "bridge", connection="myconnection", username="******", password="******", test=True, ) ] if not test: start_mock.assert_called_with( "mynet", connection="myconnection", username="******", password="******", ) else: start_mock.assert_not_called()
def test_running_update_error(): """ running state test, update an existing guest raising an error """ with patch.dict(virt.__opts__, {"test": False}): update_mock = MagicMock(return_value={ "definition": True, "cpu": False, "errors": ["some error"] }) with patch.dict( virt.__salt__, { "virt.vm_state": MagicMock(return_value={"myvm": "running"}), "virt.update": update_mock, "virt.list_domains": MagicMock(return_value=["myvm"]), }, ): assert virt.running("myvm", cpu=2) == { "name": "myvm", "changes": { "myvm": { "definition": True, "cpu": False, "errors": ["some error"], } }, "result": True, "comment": "Domain myvm updated with live update(s) failures", } update_mock.assert_called_with( "myvm", cpu=2, mem=None, disk_profile=None, disks=None, nic_profile=None, interfaces=None, graphics=None, live=True, connection=None, username=None, password=None, boot=None, numatune=None, test=False, boot_dev=None, hypervisor_features=None, clock=None, serials=None, consoles=None, stop_on_reboot=False, host_devices=None, )
def test_to_add_new_groups_to_a_host(basic_host_configuration, existing_host_responses): """ Tests if new groups are added to a host """ host, _, interfaces, kwargs, _ = basic_host_configuration ( host_get_output, hostgroup_get_output_up, hostinterface_get_output, host_inventory_get_output, ) = existing_host_responses groups = ["Testing Group", 15, "Tested Group"] hostgroup_get_output = [ hostgroup_get_output_up, [{"groupid": "17", "name": "Actual Group", "internal": "0", "flags": "0"}], hostgroup_get_output_up, ] host_exists_output = True host_update_output = "31337" ret = { "changes": {"groups": "[16, 15, 17]"}, "comment": "Host new_host updated.", "name": "new_host", "result": True, } mock_hostgroup_get = MagicMock(side_effect=hostgroup_get_output) mock_host_exists = MagicMock(return_value=host_exists_output) mock_host_get = MagicMock(return_value=host_get_output) mock_hostinterface_get = MagicMock(return_value=hostinterface_get_output) mock_host_inventory_get = MagicMock(return_value=host_inventory_get_output) mock_host_update = MagicMock(return_value=host_update_output) with patch.dict( zabbix_host.__salt__, { "zabbix.hostgroup_get": mock_hostgroup_get, "zabbix.host_exists": mock_host_exists, "zabbix.host_get": mock_host_get, "zabbix.hostinterface_get": mock_hostinterface_get, "zabbix.host_inventory_get": mock_host_inventory_get, "zabbix.host_update": mock_host_update, }, ): assert zabbix_host.present(host, groups, interfaces, **kwargs) == ret mock_host_update.assert_called_with( "31337", groups=[16, 15, 17], _connection_password="******", _connection_url="http://XXXXXXXXX/zabbix/api_jsonrpc.php", _connection_user="******", )
def test_shutdown_openbsd(self): """ Test to shutdown a running OpenBSD system """ cmd_mock = MagicMock(return_value="A") with patch.dict(system.__salt__, {"cmd.run": cmd_mock}), patch( "salt.utils.platform.is_freebsd", MagicMock(return_value=False) ), patch("salt.utils.platform.is_netbsd", MagicMock(return_value=False)), patch( "salt.utils.platform.is_openbsd", MagicMock(return_value=True) ): self.assertEqual(system.shutdown(), "A") cmd_mock.assert_called_with(["shutdown", "-p", "now"], python_shell=False)
def test_check_checklibs(): """ Test pkgng.check to regenerate the library dependency metadata """ pkg_cmd = MagicMock(return_value="") with patch.dict(pkgng.__salt__, {"cmd.run": pkg_cmd}): result = pkgng.check(checklibs=True) assert result == "" pkg_cmd.assert_called_with( ["pkg", "check", "-B"], output_loglevel="trace", python_shell=False, )
def test_autoremove_with_dryrun(): """ Test pkgng.autoremove with dryrun argument """ pkg_cmd = MagicMock(return_value="") with patch.dict(pkgng.__salt__, {"cmd.run": pkg_cmd}): result = pkgng.autoremove(dryrun=True) assert result == "" pkg_cmd.assert_called_with( ["pkg", "autoremove", "-n"], output_loglevel="trace", python_shell=False, )
def test_show_current(): mock = MagicMock(return_value="/etc/alternatives/salt") with patch("salt.utils.path.readlink", mock): ret = alternatives.show_current("better-world") assert "/etc/alternatives/salt" == ret mock.assert_called_once_with("/etc/alternatives/better-world") with TstSuiteLoggingHandler() as handler: mock.side_effect = OSError("Hell was not found!!!") assert not alternatives.show_current("hell") mock.assert_called_with("/etc/alternatives/hell") assert "ERROR:alternative: hell does not exist" in handler.messages
def test_get_tok_with_expire_before_current_time_should_remove_token(self): fake_get_token = MagicMock(return_value={"expire": time.time() - 1}) patch_opts = patch.dict(self.lauth.opts, {"eauth_tokens": "testfs"}) patch_get_token = patch.dict( self.lauth.tokens, {"testfs.get_token": fake_get_token}, ) mock_rm_token = MagicMock() patch_rm_token = patch.object(self.lauth, "rm_token", mock_rm_token) with patch_opts, patch_get_token, patch_rm_token: expected_token = "fnord" self.lauth.get_tok(expected_token) mock_rm_token.assert_called_with(expected_token)
def test_get_tok_with_no_expiration_should_remove_bad_token(self): fake_get_token = MagicMock(return_value={"no_expire_here": "Nope"}) patch_opts = patch.dict(self.lauth.opts, {"eauth_tokens": "testfs"}) patch_get_token = patch.dict( self.lauth.tokens, {"testfs.get_token": fake_get_token}, ) mock_rm_token = MagicMock() patch_rm_token = patch.object(self.lauth, "rm_token", mock_rm_token) with patch_opts, patch_get_token, patch_rm_token: expected_token = "fnord" self.lauth.get_tok(expected_token) mock_rm_token.assert_called_with(expected_token)
def test_get_tok_with_broken_file_will_remove_bad_token(self): fake_get_token = MagicMock(side_effect=SaltDeserializationError("hi")) patch_opts = patch.dict(self.lauth.opts, {"eauth_tokens": "testfs"}) patch_get_token = patch.dict( self.lauth.tokens, {"testfs.get_token": fake_get_token}, ) mock_rm_token = MagicMock() patch_rm_token = patch.object(self.lauth, "rm_token", mock_rm_token) with patch_opts, patch_get_token, patch_rm_token: expected_token = "fnord" self.lauth.get_tok(expected_token) mock_rm_token.assert_called_with(expected_token)