from pcs_test.tools.misc import create_patcher from pcs_test.tools.xml import etree_to_str from pcs.common import report_codes from pcs.common.fencing_topology import ( TARGET_TYPE_NODE, TARGET_TYPE_REGEXP, TARGET_TYPE_ATTRIBUTE, ) from pcs.lib import reports from pcs.lib.errors import LibraryError, ReportItemSeverity as severity from pcs.lib.pacemaker.state import ClusterState from pcs.lib.cib import fencing_topology as lib patch_lib = create_patcher("pcs.lib.cib.fencing_topology") # pylint: disable=too-few-public-methods, anomalous-backslash-in-string # pylint: disable=protected-access, no-self-use class CibMixin: @staticmethod def get_cib(): return etree.fromstring(""" <cib><configuration> <fencing-topology> <fencing-level id="fl1" index="1" devices="d1,d2" target="nodeA" /> <fencing-level
from pcs_test.tools.misc import create_patcher from pcs.common.reports import ReportItemSeverity as severity from pcs.common.reports import codes as report_codes from pcs.lib.cib.tools import IdProvider from pcs.lib.env import LibraryEnvironment from pcs.lib.errors import LibraryError from pcs.lib.commands import node as lib # pylint: disable=protected-access mocked_cib = etree.fromstring("<cib />") patch_env = partial(mock.patch.object, LibraryEnvironment) patch_command = create_patcher("pcs.lib.commands.node") create_env = partial( LibraryEnvironment, mock.MagicMock(logging.Logger), MockLibraryReportProcessor(), ) def fixture_node(order_num): node = mock.MagicMock(attrs=mock.MagicMock()) node.attrs.name = "node-{0}".format(order_num) return node class StandbyMaintenancePassParameters(TestCase):
from pcs_test.tools import fixture from pcs_test.tools.assertions import assert_raise_library_error from pcs_test.tools.command_env import get_env_tools from pcs_test.tools.custom_mock import MockLibraryReportProcessor from pcs_test.tools.misc import ( create_patcher, get_test_resource as rc, ) from pcs.common import report_codes from pcs.lib.corosync.config_facade import ConfigFacade as CorosyncConfigFacade from pcs.lib.env import LibraryEnvironment from pcs.lib.errors import ReportItemSeverity as severity patch_env = create_patcher("pcs.lib.env") patch_env_object = partial(mock.patch.object, LibraryEnvironment) class LibraryEnvironmentTest(TestCase): def setUp(self): self.mock_logger = mock.MagicMock(logging.Logger) self.mock_reporter = MockLibraryReportProcessor() def test_logger(self): env = LibraryEnvironment(self.mock_logger, self.mock_reporter) self.assertEqual(self.mock_logger, env.logger) def test_report_processor(self): env = LibraryEnvironment(self.mock_logger, self.mock_reporter) self.assertEqual(self.mock_reporter, env.report_processor)
FileAlreadyExists, FileMetadata, RawFile, RawFileError, ) from pcs_test.tools.misc import create_patcher FILE_TYPE_CODE = "file type code" FILE_PATH = "file path" FILE_OWNER = "owner name" FILE_GROUP = "group name" FILE_PERMISSIONS = "file permissions" FILE_IS_BINARY = False patch_file = create_patcher("pcs.common.file") def fixture_metadata( owner=FILE_OWNER, group=FILE_GROUP, permissions=FILE_PERMISSIONS, binary=FILE_IS_BINARY, ): return FileMetadata( FILE_TYPE_CODE, FILE_PATH, owner, group, permissions, binary ) class RawFileExists(TestCase): @patch_file("os.path.exists")
from unittest import mock, TestCase from pcs_test.tools.assertions import assert_raise_library_error from pcs_test.tools.command_env import get_env_tools from pcs_test.tools.misc import create_patcher from pcs_test.tools.misc import get_test_resource as rc from pcs_test.tools.xml import get_xml_manipulation_creator_from_file from pcs_test.tier0.lib.misc import get_mocked_env from pcs.common import report_codes from pcs.lib.commands.constraint import ticket as ticket_command from pcs.lib.errors import ReportItemSeverity as severities patch_commands = create_patcher("pcs.lib.commands.constraint.ticket") class CreateTest(TestCase): def setUp(self): self.create_cib = get_xml_manipulation_creator_from_file( rc("cib-empty.xml") ) def test_sucess_create(self): env_assist, config = get_env_tools(test_case=self) (config .runner.cib.load( resources=""" <resources> <primitive id="resourceA" class="service" type="exim"/> </resources> """ )
from unittest import mock, TestCase from pcs_test.tools.misc import create_patcher from pcs_test.tools.assertions import (assert_raise_library_error, assert_report_item_list_equal) from pcs_test.tools.custom_mock import MockLibraryReportProcessor from pcs.common import report_codes from pcs.lib import env_file from pcs.lib.errors import ReportItemSeverity as severities # pylint: disable=no-self-use patch_env_file = create_patcher(env_file) FILE_PATH = "/path/to.file" MISSING_PATH = "/no/existing/file.path" CONF_PATH = "/etc/booth/some-name.conf" class GhostFileInit(TestCase): def test_is_not_binary_default(self): ghost_file = env_file.GhostFile("some role", content=None) self.assertFalse(ghost_file.export()["is_binary"]) def test_accepts_is_binary_attribute(self): ghost_file = env_file.GhostFile("some role", content=None, is_binary=True) self.assertTrue(ghost_file.export()["is_binary"])
from unittest import mock, TestCase from lxml import etree from pcs_test.tools import fixture from pcs_test.tools.assertions import assert_report_item_list_equal from pcs_test.tools.custom_mock import MockLibraryReportProcessor from pcs_test.tools.misc import create_patcher from pcs.common import report_codes from pcs.lib.cib.resource import operations from pcs.common.reports import ReportItemSeverity as severities from pcs.lib.validate import ValuePair # pylint: disable=no-self-use patch_operations = create_patcher("pcs.lib.cib.resource.operations") @patch_operations("get_remaining_defaults") @patch_operations("complete_all_intervals") @patch_operations("validate_different_intervals") @patch_operations("validate_operation_list") @patch_operations("normalized_to_operations") @patch_operations("operations_to_normalized") class Prepare(TestCase): def test_prepare(self, operations_to_normalized, normalized_to_operations, validate_operation_list, validate_different_intervals, complete_all_intervals, get_remaining_defaults): validate_operation_list.return_value = ["options_report"] validate_different_intervals.return_value = [ "different_interval_report"
TARGET_TYPE_REGEXP, ) from pcs.common.tools import Version from pcs.lib.env import LibraryEnvironment from pcs.lib.commands import fencing_topology as lib # pylint: disable=no-self-use create_lib_env = partial( LibraryEnvironment, mock.MagicMock(logging.Logger), MockLibraryReportProcessor() ) patch_env = partial(mock.patch.object, LibraryEnvironment) patch_command = create_patcher("pcs.lib.commands.fencing_topology") @patch_command("cib_fencing_topology.add_level") @patch_command("get_resources") @patch_command("get_fencing_topology") @patch_env("push_cib") @patch_command("ClusterState") @patch_command("get_cluster_status_xml") @patch_env("get_cib") @patch_env("cmd_runner", lambda self: "mocked cmd_runner") class AddLevel(TestCase): def prepare_mocks( self, mock_get_cib, mock_status_xml, mock_status, mock_get_topology, mock_get_resources ):
from pcs_test.tools.xml import etree_to_str from pcs.common import report_codes from pcs.common.fencing_topology import ( TARGET_TYPE_NODE, TARGET_TYPE_REGEXP, TARGET_TYPE_ATTRIBUTE, ) from pcs.lib import reports from pcs.lib.errors import LibraryError, ReportItemSeverity as severity from pcs.lib.pacemaker.state import ClusterState from pcs.lib.cib import fencing_topology as lib patch_lib = create_patcher("pcs.lib.cib.fencing_topology") # pylint: disable=too-few-public-methods, anomalous-backslash-in-string # pylint: disable=protected-access, no-self-use class CibMixin: @staticmethod def get_cib(): return etree.fromstring(""" <cib><configuration> <fencing-topology> <fencing-level id="fl1" index="1" devices="d1,d2" target="nodeA" /> <fencing-level
import os.path from unittest import mock, TestCase from pcs_test.tools.assertions import ( assert_raise_library_error, assert_report_item_list_equal, ) from pcs_test.tools.custom_mock import MockLibraryReportProcessor from pcs_test.tools.misc import create_patcher from pcs.common import report_codes, env_file_role_codes as file_roles from pcs.lib.booth import config_files from pcs.lib.errors import ReportItemSeverity as severities from pcs.settings import booth_config_dir as BOOTH_CONFIG_DIR patch_config_files = create_patcher("pcs.lib.booth.config_files") @mock.patch("os.path.isdir") @mock.patch("os.listdir") @mock.patch("os.path.isfile") class GetAllConfigsFileNamesTest(TestCase): def test_booth_config_dir_is_no_dir(self, mock_is_file, mock_listdir, mock_isdir): mock_isdir.return_value = False self.assertEqual([], config_files.get_all_configs_file_names()) mock_isdir.assert_called_once_with(BOOTH_CONFIG_DIR) self.assertEqual(0, mock_is_file.call_count) self.assertEqual(0, mock_listdir.call_count) def test_success(self, mock_is_file, mock_listdir, mock_isdir):
from unittest import mock, TestCase from pcs_test.tools.misc import create_patcher, create_setup_patch_mixin from pcs.cli.common import env_file from pcs.common import report_codes from pcs.lib.errors import ReportItem patch_env_file = create_patcher(env_file) SetupPatchMixin = create_setup_patch_mixin(patch_env_file) FILE_PATH = "/path/to/local/file" class Write(TestCase, SetupPatchMixin): def setUp(self): self.mock_open = mock.mock_open() self.mock_error = self.setup_patch("console_report.error") def assert_params_causes_calls(self, env_file_dict, calls, path=FILE_PATH): with patch_env_file("open", self.mock_open, create=True): env_file.write(env_file_dict, path) self.assertEqual(self.mock_open.mock_calls, calls) def test_sucessfully_write(self): self.assert_params_causes_calls( {"content": "filecontent"}, [ mock.call(FILE_PATH, "w"), mock.call().write("filecontent"), mock.call().close(), ]
import os.path from unittest import mock, TestCase from pcs_test.tools.assertions import ( assert_raise_library_error, assert_report_item_list_equal, ) from pcs_test.tools.custom_mock import MockLibraryReportProcessor from pcs_test.tools.misc import create_patcher from pcs.common import report_codes, env_file_role_codes as file_roles from pcs.lib.booth import config_files from pcs.lib.errors import ReportItemSeverity as severities from pcs.settings import booth_config_dir as BOOTH_CONFIG_DIR patch_config_files = create_patcher("pcs.lib.booth.config_files") @mock.patch("os.path.isdir") @mock.patch("os.listdir") @mock.patch("os.path.isfile") class GetAllConfigsFileNamesTest(TestCase): def test_booth_config_dir_is_no_dir( self, mock_is_file, mock_listdir, mock_isdir ): mock_isdir.return_value = False self.assertEqual([], config_files.get_all_configs_file_names()) mock_isdir.assert_called_once_with(BOOTH_CONFIG_DIR) self.assertEqual(0, mock_is_file.call_count) self.assertEqual(0, mock_listdir.call_count) def test_success(self, mock_is_file, mock_listdir, mock_isdir):
) # pylint: disable=no-self-use, unused-argument, protected-access def _booth_env_fixture(name): booth_env = mock.MagicMock() booth_env.name = name return booth_env def _env_fixture(booth_name): env = mock.MagicMock(spec_set=LibraryEnvironment) env.booth = _booth_env_fixture(booth_name) return env patch_commands = create_patcher("pcs.lib.commands.booth") @mock.patch("pcs.lib.tools.generate_binary_key", return_value=b"key value") @mock.patch("pcs.lib.commands.booth.build", return_value="config content") @mock.patch("pcs.lib.booth.config_structure.validate_peers") class ConfigSetupTest(TestCase): def test_successfuly_build_and_write_to_std_path( self, mock_validate_peers, mock_build, mock_generate_binary_key ): env = _env_fixture("booth_name") commands.config_setup( env, booth_configuration=[ {"key": "site", "value": "1.1.1.1", "details": []}, {"key": "arbitrator", "value": "2.2.2.2", "details": []}, ],
'REMOTE_ADDR': None, # It requires complicated request args 'REMOTE_HOST': 'pcsd-host:2224', 'REQUEST_METHOD': 'POST', 'REQUEST_PATH': '/pcsd/uri', 'REQUEST_URI': 'http://pcsd-host:2224/pcsd/uri', 'SCRIPT_NAME': '', 'SERVER_NAME': 'pcsd-host', 'SERVER_PORT': 2224, 'SERVER_PROTOCOL': 'HTTP/1.0', 'rack.input': 'post-key=post-value' } }) patch_ruby_pcsd = create_patcher(ruby_pcsd) class RunRuby(AsyncTestCase): def setUp(self): self.stdout = "" self.stderr = "" self.exit_status = 0 self.request = self.create_request() self.wrapper = create_wrapper() patcher = mock.patch.object(self.wrapper, "send_to_ruby", self.send_to_ruby) self.addCleanup(patcher.stop) patcher.start() super().setUp()
'QUERY_STRING': '', 'REMOTE_ADDR': None, # It requires complicated request args 'REMOTE_HOST': 'pcsd-host:2224', 'REQUEST_METHOD': 'POST', 'REQUEST_PATH': '/pcsd/uri', 'REQUEST_URI': 'http://pcsd-host:2224/pcsd/uri', 'SCRIPT_NAME': '', 'SERVER_NAME': 'pcsd-host', 'SERVER_PORT': 2224, 'SERVER_PROTOCOL': 'HTTP/1.0', 'rack.input': 'post-key=post-value' } } ) patch_ruby_pcsd = create_patcher(ruby_pcsd) class RunRuby(AsyncTestCase): def setUp(self): self.stdout = "" self.stderr = "" self.exit_status = 0 self.request = self.create_request() self.wrapper = create_wrapper() patcher = mock.patch.object( self.wrapper, "send_to_ruby", self.send_to_ruby ) self.addCleanup(patcher.stop) patcher.start()
from unittest import mock, TestCase from pcs_test.tools.command_env import get_env_tools from pcs_test.tools.misc import create_patcher from pcs.common.reports import ReportItemSeverity as severities from pcs.common.reports import codes as report_codes from pcs.lib.commands.constraint import ticket as ticket_command patch_commands = create_patcher("pcs.lib.commands.constraint.ticket") class CreateTest(TestCase): def test_sucess_create(self): env_assist, config = get_env_tools(test_case=self) (config.runner.cib.load(resources=""" <resources> <primitive id="resourceA" class="service" type="exim"/> </resources> """).env.push_cib(optional_in_conf=""" <constraints> <rsc_ticket id="ticket-ticketA-resourceA-Master" rsc="resourceA" rsc-role="Master" ticket="ticketA" loss-policy="fence" /> </constraints> """))
TARGET_TYPE_ATTRIBUTE, ) from pcs.common.tools import Version from pcs.lib.env import LibraryEnvironment from pcs.lib.commands import fencing_topology as lib # pylint: disable=no-self-use create_lib_env = partial( LibraryEnvironment, mock.MagicMock(logging.Logger), MockLibraryReportProcessor() ) patch_env = partial(mock.patch.object, LibraryEnvironment) patch_command = create_patcher("pcs.lib.commands.fencing_topology") @patch_command("cib_fencing_topology.add_level") @patch_command("get_resources") @patch_command("get_fencing_topology") @patch_env("push_cib") @patch_command("ClusterState") @patch_command("get_cluster_status_xml") @patch_env("get_cib") @patch_env("cmd_runner", lambda self: "mocked cmd_runner") class AddLevel(TestCase): def prepare_mocks( self, mock_get_cib, mock_status_xml, mock_status, mock_get_topology, mock_get_resources ):
from unittest import mock, TestCase from pcs_test.tools.assertions import assert_raise_library_error from pcs_test.tools.custom_mock import MockLibraryReportProcessor from pcs_test.tools.misc import ( create_patcher, get_test_resource as rc, ) from pcs.common import file_type_codes from pcs.common.reports import ReportItemSeverity as severity from pcs.common.reports import codes as report_codes from pcs.lib.env import LibraryEnvironment patch_env = create_patcher("pcs.lib.env") patch_env_object = partial(mock.patch.object, LibraryEnvironment) class LibraryEnvironmentTest(TestCase): def setUp(self): self.mock_logger = mock.MagicMock(logging.Logger) self.mock_reporter = MockLibraryReportProcessor() def test_logger(self): env = LibraryEnvironment(self.mock_logger, self.mock_reporter) self.assertEqual(self.mock_logger, env.logger) def test_report_processor(self): env = LibraryEnvironment(self.mock_logger, self.mock_reporter) self.assertEqual(self.mock_reporter, env.report_processor)
from functools import partial from unittest import mock, TestCase from lxml import etree from pcs_test.tools.assertions import assert_report_item_list_equal from pcs_test.tools.custom_mock import MockLibraryReportProcessor from pcs_test.tools.misc import create_patcher from pcs.common import report_codes from pcs.lib.cib.resource import operations from pcs.lib.errors import ReportItemSeverity as severities from pcs.lib.validate import ValuePair # pylint: disable=no-self-use patch_operations = create_patcher("pcs.lib.cib.resource.operations") @patch_operations("get_remaining_defaults") @patch_operations("complete_all_intervals") @patch_operations("validate_different_intervals") @patch_operations("validate_operation_list") @patch_operations("normalized_to_operations") @patch_operations("operations_to_normalized") class Prepare(TestCase): def test_prepare( self, operations_to_normalized, normalized_to_operations, validate_operation_list, validate_different_intervals, complete_all_intervals, get_remaining_defaults ): validate_operation_list.return_value = ["options_report"] validate_different_intervals.return_value = [