Ejemplo n.º 1
0
    def test_skip_failed(self, mock_get_configs, mock_read):
        def _mock_read_cfg(file):
            if file in ["name1.conf", "name3.conf"]:
                raise EnvironmentError()
            elif file == "name2.conf":
                return "config2"
            else:
                raise AssertionError("unexpected input: {0}".format(file))

        mock_get_configs.return_value = [
            "name1.conf", "name2.conf", "name3.conf"
        ]
        mock_read.side_effect = _mock_read_cfg

        self.assertEqual({"name2.conf": "config2"},
                         config_files.read_configs(self.mock_reporter, True))
        mock_get_configs.assert_called_once_with()
        self.assertEqual(3, mock_read.call_count)
        mock_read.assert_has_calls([
            mock.call("name1.conf"),
            mock.call("name2.conf"),
            mock.call("name3.conf")
        ])
        assert_report_item_list_equal(
            self.mock_reporter.report_item_list,
            [(severities.WARNING, report_codes.BOOTH_CONFIG_READ_ERROR, {
                "name": "name1.conf"
            }),
             (severities.WARNING, report_codes.BOOTH_CONFIG_READ_ERROR, {
                 "name": "name3.conf"
             })])
Ejemplo n.º 2
0
    def test_error_cleanup(self):
        expected_stdout = "some info"
        expected_stderr = "some error"
        expected_retval = 1
        mock_runner = mock.MagicMock(spec_set=CommandRunner)
        call_list = [
            mock.call(self.crm_mon_cmd()),
            mock.call([self.path("crm_resource"), "--cleanup"]),
        ]
        return_value_list = [
            (self.fixture_status_xml(1, 1), "", 0),
            (expected_stdout, expected_stderr, expected_retval),
        ]
        mock_runner.run.side_effect = return_value_list

        assert_raise_library_error(
            lambda: lib.resource_cleanup(mock_runner),
            (
                Severity.ERROR,
                report_codes.RESOURCE_CLEANUP_ERROR,
                {
                    "reason": expected_stderr + "\n" + expected_stdout,
                }
            )
        )

        self.assertEqual(len(return_value_list), len(call_list))
        self.assertEqual(len(return_value_list), mock_runner.run.call_count)
        mock_runner.run.assert_has_calls(call_list)
Ejemplo n.º 3
0
    def test_success(self):
        node_id = "id_1"
        node_name = "name_1"
        node_status = self.fixture_get_node_status(node_name, node_id)
        expected_status = dict(node_status, offline=False)
        self.fixture_add_node_status(
            self.fixture_get_node_status("name_2", "id_2")
        )
        self.fixture_add_node_status(node_status)
        self.fixture_add_node_status(
            self.fixture_get_node_status("name_3", "id_3")
        )

        mock_runner = mock.MagicMock(spec_set=CommandRunner)
        call_list = [
            mock.call(self.crm_mon_cmd()),
            mock.call([self.path("crm_node"), "--cluster-id"]),
            mock.call(
                [self.path("crm_node"), "--name-for-id={0}".format(node_id)]
            ),
        ]
        return_value_list = [
            (str(self.status), "", 0),
            (node_id, "", 0),
            (node_name, "", 0)
        ]
        mock_runner.run.side_effect = return_value_list

        real_status = lib.get_local_node_status(mock_runner)

        self.assertEqual(len(return_value_list), len(call_list))
        self.assertEqual(len(return_value_list), mock_runner.run.call_count)
        mock_runner.run.assert_has_calls(call_list)
        self.assertEqual(expected_status, real_status)
Ejemplo n.º 4
0
    def test_error_3(self):
        node_id = "id_1"
        node_name = "name_1"
        node_status = self.fixture_get_node_status(node_name, node_id)
        self.fixture_add_node_status(node_status)

        mock_runner = mock.MagicMock(spec_set=CommandRunner)
        call_list = [
            mock.call(self.crm_mon_cmd()),
            mock.call([self.path("crm_node"), "--cluster-id"]),
            mock.call(
                [self.path("crm_node"), "--name-for-id={0}".format(node_id)]
            ),
        ]
        return_value_list = [
            (str(self.status), "", 0),
            (node_id, "", 0),
            ("(null)", "", 0),
        ]
        mock_runner.run.side_effect = return_value_list

        assert_raise_library_error(
            lambda: lib.get_local_node_status(mock_runner),
            (
                Severity.ERROR,
                report_codes.PACEMAKER_LOCAL_NODE_NAME_NOT_FOUND,
                {"reason": "node name is null"}
            )
        )

        self.assertEqual(len(return_value_list), len(call_list))
        self.assertEqual(len(return_value_list), mock_runner.run.call_count)
        mock_runner.run.assert_has_calls(call_list)
Ejemplo n.º 5
0
    def test_success(self, mock_get_configs, mock_read):
        def _mock_read_cfg(file):
            if file == "name1.conf":
                return "config1"
            elif file == "name2.conf":
                return "config2"
            elif file == "name3.conf":
                return "config3"
            else:
                raise AssertionError("unexpected input: {0}".format(file))
        mock_get_configs.return_value = [
            "name1.conf", "name2.conf", "name3.conf"
        ]
        mock_read.side_effect = _mock_read_cfg

        self.assertEqual(
            {
                "name1.conf": "config1",
                "name2.conf": "config2",
                "name3.conf": "config3"
            },
            config_files.read_configs(self.mock_reporter)
        )

        mock_get_configs.assert_called_once_with()
        self.assertEqual(3, mock_read.call_count)
        mock_read.assert_has_calls([
            mock.call("name1.conf"),
            mock.call("name2.conf"),
            mock.call("name3.conf")
        ])
        self.assertEqual(0, len(self.mock_reporter.report_item_list))
Ejemplo n.º 6
0
    def test_error_cleanup(self):
        expected_stdout = "some info"
        expected_stderr = "some error"
        expected_retval = 1
        mock_runner = mock.MagicMock(spec_set=CommandRunner)
        call_list = [
            mock.call(self.crm_mon_cmd()),
            mock.call([self.path("crm_resource"), "--cleanup"]),
        ]
        return_value_list = [
            (self.fixture_status_xml(1, 1), "", 0),
            (expected_stdout, expected_stderr, expected_retval),
        ]
        mock_runner.run.side_effect = return_value_list

        assert_raise_library_error(
            lambda: lib.resource_cleanup(mock_runner),
            (
                Severity.ERROR,
                report_codes.RESOURCE_CLEANUP_ERROR,
                {
                    "reason": expected_stderr + "\n" + expected_stdout,
                }
            )
        )

        self.assertEqual(len(return_value_list), len(call_list))
        self.assertEqual(len(return_value_list), mock_runner.run.call_count)
        mock_runner.run.assert_has_calls(call_list)
Ejemplo n.º 7
0
    def test_standard_not_specified(self, mock_list_agents,
                                    mock_list_standards):
        agents_ocf = [
            "Delay",
            "Dummy",
            "Stateful",
        ]
        agents_service = [
            "corosync",
            "pacemaker",
            "pcsd",
        ]
        mock_list_standards.return_value = ["ocf:test", "service"]
        mock_list_agents.side_effect = [agents_ocf, agents_service]

        self.assertEqual(
            lib.list_agents_for_standard_and_provider(self.lib_env),
            sorted(agents_ocf + agents_service, key=lambda x: x.lower()))

        mock_list_standards.assert_called_once_with("mock_runner")
        self.assertEqual(2, len(mock_list_agents.mock_calls))
        mock_list_agents.assert_has_calls([
            mock.call("mock_runner", "ocf:test"),
            mock.call("mock_runner", "service"),
        ])
Ejemplo n.º 8
0
    def test_configs_without_authfiles(self, mock_read_authfile,
                                       mock_read_configs, mock_parse,
                                       mock_authfile, mock_run_com):
        def mock_authfile_fn(parsed_config):
            if parsed_config == "config1":
                return None
            elif parsed_config == "config2":
                return "/path/to/file2.key"
            else:
                raise AssertionError(
                    "unexpected input: {0}".format(parsed_config))

        mock_parse.side_effect = self.mock_parse_fn
        mock_authfile.side_effect = mock_authfile_fn
        mock_read_authfile.return_value = "another key".encode("utf-8")
        mock_read_configs.return_value = {
            "name1.conf": "config1",
            "name2.conf": "config2"
        }
        mock_run_com.return_value = [(self.node, {
            "existing": [],
            "failed": {},
            "saved": ["name1.conf", "name2.conf", "file2.key"]
        })]
        lib.send_all_config_to_node(self.mock_com, self.mock_reporter,
                                    self.node)
        self.assertEqual(2, mock_parse.call_count)
        mock_parse.assert_has_calls(
            [mock.call("config1"), mock.call("config2")])
        self.assertEqual(2, mock_authfile.call_count)
        mock_authfile.assert_has_calls(
            [mock.call("config1"), mock.call("config2")])
        mock_read_authfile.assert_called_once_with(self.mock_reporter,
                                                   "/path/to/file2.key")
        mock_read_configs.assert_called_once_with(self.mock_reporter, False)
        expected_file_list = [{
            "name": "name1.conf",
            "data": "config1",
            "is_authfile": False
        }, {
            "name": "name2.conf",
            "data": "config2",
            "is_authfile": False
        }, {
            "name": "file2.key",
            "data": to_b64("another key"),
            "is_authfile": True
        }]
        communicator, com_cmd = mock_run_com.call_args[0]
        self.assertEqual(self.mock_com, communicator)
        self.assertEqual(expected_file_list, com_cmd._file_list)
        self.assertFalse(com_cmd._rewrite_existing)
        assert_report_item_list_equal(
            self.mock_reporter.report_item_list,
            [(Severities.INFO, report_codes.BOOTH_CONFIG_DISTRIBUTION_STARTED,
              {}),
             (Severities.INFO, report_codes.BOOTH_CONFIG_ACCEPTED_BY_NODE, {
                 "node": self.node.label,
                 "name_list": ["name1.conf", "name2.conf", "file2.key"]
             })])
Ejemplo n.º 9
0
    def test_success(self, mock_get_configs, mock_read):
        def _mock_read_cfg(file):
            if file == "name1.conf":
                return "config1"
            elif file == "name2.conf":
                return "config2"
            elif file == "name3.conf":
                return "config3"
            else:
                raise AssertionError("unexpected input: {0}".format(file))

        mock_get_configs.return_value = [
            "name1.conf", "name2.conf", "name3.conf"
        ]
        mock_read.side_effect = _mock_read_cfg

        self.assertEqual(
            {
                "name1.conf": "config1",
                "name2.conf": "config2",
                "name3.conf": "config3"
            }, config_files.read_configs(self.mock_reporter))

        mock_get_configs.assert_called_once_with()
        self.assertEqual(3, mock_read.call_count)
        mock_read.assert_has_calls([
            mock.call("name1.conf"),
            mock.call("name2.conf"),
            mock.call("name3.conf")
        ])
        self.assertEqual(0, len(self.mock_reporter.report_item_list))
Ejemplo n.º 10
0
    def test_do_not_skip_failed(self, mock_get_configs, mock_read):
        def _mock_read_cfg(file):
            if file in ["name1.conf", "name3.conf"]:
                raise EnvironmentError()
            elif file == "name2.conf":
                return "config2"
            else:
                raise AssertionError("unexpected input: {0}".format(file))

        mock_get_configs.return_value = [
            "name1.conf", "name2.conf", "name3.conf"
        ]
        mock_read.side_effect = _mock_read_cfg

        assert_raise_library_error(
            lambda: config_files.read_configs(self.mock_reporter),
            (severities.ERROR, report_codes.BOOTH_CONFIG_READ_ERROR, {
                "name": "name1.conf"
            }, report_codes.SKIP_UNREADABLE_CONFIG),
            (severities.ERROR, report_codes.BOOTH_CONFIG_READ_ERROR, {
                "name": "name3.conf"
            }, report_codes.SKIP_UNREADABLE_CONFIG))
        mock_get_configs.assert_called_once_with()
        self.assertEqual(3, mock_read.call_count)
        mock_read.assert_has_calls([
            mock.call("name1.conf"),
            mock.call("name2.conf"),
            mock.call("name3.conf")
        ])
        self.assertEqual(2, len(self.mock_reporter.report_item_list))
Ejemplo n.º 11
0
    def test_failure(self, mock_role, mock_assign):
        def _mock_role(_, el_id):
            if el_id in ["role1", "role3"]:
                raise acl_lib.AclRoleNotFound(el_id)
            elif el_id == "role2":
                return "role2_el"
            else:
                raise AssertionError("unexpected input")

        mock_role.side_effect = _mock_role
        assert_raise_library_error(
            lambda: cmd_acl._assign_roles_to_element(
                self.cib, "el", ["role1", "role2", "role3"]),
            (Severities.ERROR, report_codes.ID_NOT_FOUND, {
                "id": "role1",
                "id_description": "role",
            }), (Severities.ERROR, report_codes.ID_NOT_FOUND, {
                "id": "role3",
                "id_description": "role",
            }))
        mock_role.assert_has_calls([
            mock.call(self.cib, "role1"),
            mock.call(self.cib, "role2"),
            mock.call(self.cib, "role3")
        ])
        mock_assign.assert_called_once_with("el", "role2_el")
Ejemplo n.º 12
0
    def test_error_some_nodes(self):
        nodes = ("node1", "node2", "node3", "node4")
        for i, n in enumerate(nodes, 1):
            self.fixture_add_node_status(self.fixture_get_node_status(n, i))
        mock_runner = mock.MagicMock(spec_set=CommandRunner)
        call_list = [mock.call(self.crm_mon_cmd())]
        call_list += [
            mock.call([self.path("crm_standby"), "-v", "on", "-N", n])
            for n in nodes
        ]
        return_value_list = [
            (str(self.status), "", 0),
            ("dummy1", "", 0),
            ("dummy2", "error2", 1),
            ("dummy3", "", 0),
            ("dummy4", "error4", 1),
        ]
        mock_runner.run.side_effect = return_value_list

        assert_raise_library_error(
            lambda: lib.nodes_standby(mock_runner, all_nodes=True),
            (Severity.ERROR, report_codes.COMMON_ERROR, {
                "text": "error2\ndummy2",
            }), (Severity.ERROR, report_codes.COMMON_ERROR, {
                "text": "error4\ndummy4",
            }))

        self.assertEqual(len(return_value_list), len(call_list))
        self.assertEqual(len(return_value_list), mock_runner.run.call_count)
        mock_runner.run.assert_has_calls(call_list)
Ejemplo n.º 13
0
    def test_success(self, mock_remote_start, mock_remote_stop):
        nodes = ["node1", "node2"]
        node_addrs_list = NodeAddressesList(
            [NodeAddresses(addr) for addr in nodes]
        )

        lib.qdevice_reload_on_nodes(
            self.mock_communicator,
            self.mock_reporter,
            node_addrs_list
        )

        node_calls = [
            mock.call(
                self.mock_reporter, self.mock_communicator, node_addrs_list[0]
            ),
            mock.call(
                self.mock_reporter, self.mock_communicator, node_addrs_list[1]
            ),
        ]
        self.assertEqual(len(node_calls), len(mock_remote_stop.mock_calls))
        self.assertEqual(len(node_calls), len(mock_remote_start.mock_calls))
        mock_remote_stop.assert_has_calls(node_calls, any_order=True)
        mock_remote_start.assert_has_calls(node_calls, any_order=True)

        assert_report_item_list_equal(
            self.mock_reporter.report_item_list,
            [
                (
                    severity.INFO,
                    report_codes.QDEVICE_CLIENT_RELOAD_STARTED,
                    {}
                ),
            ]
        )
Ejemplo n.º 14
0
    def test_success(self, mock_remote_start, mock_remote_stop):
        nodes = ["node1", "node2"]
        node_addrs_list = NodeAddressesList(
            [NodeAddresses(addr) for addr in nodes]
        )

        lib.qdevice_reload_on_nodes(
            self.mock_communicator,
            self.mock_reporter,
            node_addrs_list
        )

        node_calls = [
            mock.call(
                self.mock_reporter, self.mock_communicator, node_addrs_list[0]
            ),
            mock.call(
                self.mock_reporter, self.mock_communicator, node_addrs_list[1]
            ),
        ]
        self.assertEqual(len(node_calls), len(mock_remote_stop.mock_calls))
        self.assertEqual(len(node_calls), len(mock_remote_start.mock_calls))
        mock_remote_stop.assert_has_calls(node_calls, any_order=True)
        mock_remote_start.assert_has_calls(node_calls, any_order=True)

        assert_report_item_list_equal(
            self.mock_reporter.report_item_list,
            [
                (
                    severity.INFO,
                    report_codes.QDEVICE_CLIENT_RELOAD_STARTED,
                    {}
                ),
            ]
        )
Ejemplo n.º 15
0
    def test_standard_not_specified(
        self, mock_list_agents, mock_list_standards
    ):
        agents_ocf = [
            "Delay",
            "Dummy",
            "Stateful",
        ]
        agents_service = [
            "corosync",
            "pacemaker",
            "pcsd",
        ]
        mock_list_standards.return_value = ["ocf:test", "service"]
        mock_list_agents.side_effect = [agents_ocf, agents_service]

        self.assertEqual(
            lib.list_agents_for_standard_and_provider(self.lib_env),
            sorted(agents_ocf + agents_service, key=lambda x: x.lower())
        )

        mock_list_standards.assert_called_once_with("mock_runner")
        self.assertEqual(2, len(mock_list_agents.mock_calls))
        mock_list_agents.assert_has_calls([
            mock.call("mock_runner", "ocf:test"),
            mock.call("mock_runner", "service"),
        ])
Ejemplo n.º 16
0
    def test_error_3(self):
        node_id = "id_1"
        node_name = "name_1"
        node_status = self.fixture_get_node_status(node_name, node_id)
        self.fixture_add_node_status(node_status)

        mock_runner = mock.MagicMock(spec_set=CommandRunner)
        call_list = [
            mock.call(self.crm_mon_cmd()),
            mock.call([self.path("crm_node"), "--cluster-id"]),
            mock.call(
                [self.path("crm_node"), "--name-for-id={0}".format(node_id)]),
        ]
        return_value_list = [
            (str(self.status), "", 0),
            (node_id, "", 0),
            ("(null)", "", 0),
        ]
        mock_runner.run.side_effect = return_value_list

        assert_raise_library_error(
            lambda: lib.get_local_node_status(mock_runner),
            (Severity.ERROR, report_codes.PACEMAKER_LOCAL_NODE_NAME_NOT_FOUND,
             {
                 "reason": "node name is null"
             }))

        self.assertEqual(len(return_value_list), len(call_list))
        self.assertEqual(len(return_value_list), mock_runner.run.call_count)
        mock_runner.run.assert_has_calls(call_list)
Ejemplo n.º 17
0
    def test_success(self):
        node_id = "id_1"
        node_name = "name_1"
        node_status = self.fixture_get_node_status(node_name, node_id)
        expected_status = dict(node_status, offline=False)
        self.fixture_add_node_status(
            self.fixture_get_node_status("name_2", "id_2"))
        self.fixture_add_node_status(node_status)
        self.fixture_add_node_status(
            self.fixture_get_node_status("name_3", "id_3"))

        mock_runner = mock.MagicMock(spec_set=CommandRunner)
        call_list = [
            mock.call(self.crm_mon_cmd()),
            mock.call([self.path("crm_node"), "--cluster-id"]),
            mock.call(
                [self.path("crm_node"), "--name-for-id={0}".format(node_id)]),
        ]
        return_value_list = [(str(self.status), "", 0), (node_id, "", 0),
                             (node_name, "", 0)]
        mock_runner.run.side_effect = return_value_list

        real_status = lib.get_local_node_status(mock_runner)

        self.assertEqual(len(return_value_list), len(call_list))
        self.assertEqual(len(return_value_list), mock_runner.run.call_count)
        mock_runner.run.assert_has_calls(call_list)
        self.assertEqual(expected_status, real_status)
Ejemplo n.º 18
0
    def test_fail_doesnt_prevent_start(self, mock_remote_start,
                                       mock_remote_stop):
        nodes = ["node1", "node2"]
        node_addrs_list = NodeAddressesList(
            [NodeAddresses(addr) for addr in nodes])

        def raiser(reporter, communicator, node):
            if node.ring0 == nodes[1]:
                raise NodeAuthenticationException(node.label, "command",
                                                  "HTTP error: 401")

        mock_remote_stop.side_effect = raiser

        assert_raise_library_error(
            lambda: lib.qdevice_reload_on_nodes(
                self.mock_communicator, self.mock_reporter, node_addrs_list),
            (severity.ERROR,
             report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED, {
                 "node": nodes[1],
                 "command": "command",
                 "reason": "HTTP error: 401",
             }, report_codes.SKIP_OFFLINE_NODES))

        node_calls = [
            mock.call(self.mock_reporter, self.mock_communicator,
                      node_addrs_list[0]),
            mock.call(self.mock_reporter, self.mock_communicator,
                      node_addrs_list[1]),
        ]
        self.assertEqual(len(node_calls), len(mock_remote_stop.mock_calls))
        self.assertEqual(len(node_calls), len(mock_remote_start.mock_calls))
        mock_remote_stop.assert_has_calls(node_calls, any_order=True)
        mock_remote_start.assert_has_calls(node_calls, any_order=True)

        assert_report_item_list_equal(
            self.mock_reporter.report_item_list,
            [
                (severity.INFO, report_codes.QDEVICE_CLIENT_RELOAD_STARTED,
                 {}),
                # why the same error twice?
                # 1. Tested piece of code calls a function which puts an error
                # into the reporter. The reporter raises an exception. The
                # exception is caught in the tested piece of code, stored, and
                # later put to reporter again.
                # 2. Mock reporter remembers everything that goes through it
                # and by the machanism described in 1 the error goes througt it
                # twice.
                (severity.ERROR,
                 report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED, {
                     "node": nodes[1],
                     "command": "command",
                     "reason": "HTTP error: 401",
                 }, report_codes.SKIP_OFFLINE_NODES),
                (severity.ERROR,
                 report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED, {
                     "node": nodes[1],
                     "command": "command",
                     "reason": "HTTP error: 401",
                 }, report_codes.SKIP_OFFLINE_NODES),
            ])
Ejemplo n.º 19
0
    def test_remove_ip_when_booth_resource_add_failed(self):
        mock_resource_create = mock.Mock(side_effect=[None, SystemExit(1)])
        mock_resource_remove = mock.Mock()
        mock_create_id = mock.Mock(side_effect=["ip_id","booth_id","group_id"])
        ip = "1.2.3.4"
        booth_config_file_path = rc("/path/to/booth.conf")

        booth_resource.get_creator(mock_resource_create, mock_resource_remove)(
            ip,
            booth_config_file_path,
            mock_create_id
        )
        self.assertEqual(mock_resource_create.mock_calls, [
            mock.call(
                clone_opts=[],
                group=u'group_id',
                meta_values=[],
                op_values=[],
                ra_id=u'ip_id',
                ra_type=u'ocf:heartbeat:IPaddr2',
                ra_values=[u'ip=1.2.3.4'],
            ),
            mock.call(
                clone_opts=[],
                group='group_id',
                meta_values=[],
                op_values=[],
                ra_id='booth_id',
                ra_type='ocf:pacemaker:booth-site',
                ra_values=['config=/path/to/booth.conf'],
            )
        ])
        mock_resource_remove.assert_called_once_with("ip_id")
Ejemplo n.º 20
0
    def test_catch_exactly_his_exception(self):
        report_missing = self.setup_patch("env_file.report_missing")
        next_in_line = mock.Mock(side_effect=LibraryEnvError(
            ReportItem.error(report_codes.FILE_DOES_NOT_EXIST, info={
                "file_role": env_file_role_codes.BOOTH_CONFIG,
            }),
            ReportItem.error(report_codes.FILE_DOES_NOT_EXIST, info={
                "file_role": env_file_role_codes.BOOTH_KEY,
            }),
            ReportItem.error("OTHER ERROR", info={}),
        ))
        mock_env = mock.MagicMock()
        self.read.return_value = {"content": None}

        booth_conf_middleware = env.middleware_config(
            "booth-name",
            "/local/file/path.conf",
            "/local/file/path.key",
        )
        raised_exception = []
        def run_middleware():
            try:
                booth_conf_middleware(next_in_line, mock_env)
            except Exception as e:
                raised_exception.append(e)
                raise e
        self.assertRaises(LibraryEnvError, run_middleware)
        self.assertEqual(1, len(raised_exception[0].unprocessed))
        self.assertEqual("OTHER ERROR", raised_exception[0].unprocessed[0].code)
        self.assertEqual(report_missing.mock_calls, [
            mock.call('Booth config file', '/local/file/path.conf'),
            mock.call('Booth key file', '/local/file/path.key'),
        ])
Ejemplo n.º 21
0
    def test_success(self, mock_attrs):
        lib._set_instance_attrs_all_nodes(create_env(), "attrs", False)

        self.assertEqual(2, len(mock_attrs.mock_calls))
        mock_attrs.assert_has_calls([
            mock.call("cib", "node-0", "attrs", self.cluster_nodes),
            mock.call("cib", "node-1", "attrs", self.cluster_nodes),
        ])
Ejemplo n.º 22
0
    def test_success(self, mock_attrs):
        lib._set_instance_attrs_all_nodes(create_env(), "attrs", False)

        self.assertEqual(2, len(mock_attrs.mock_calls))
        mock_attrs.assert_has_calls([
            mock.call("cib", "node-0", "attrs", self.cluster_nodes),
            mock.call("cib", "node-1", "attrs", self.cluster_nodes),
        ])
Ejemplo n.º 23
0
 def test_success(self, assign_role):
     assign_role.return_value = []
     lib.assign_all_roles("acl_section", ["1", "2", "3"], "element")
     assign_role.assert_has_calls([
         mock.call("acl_section", "1", "element"),
         mock.call("acl_section", "2", "element"),
         mock.call("acl_section", "3", "element"),
     ], any_order=True)
Ejemplo n.º 24
0
 def test_success(self, assign_role):
     assign_role.return_value = []
     lib.assign_all_roles("acl_section", ["1", "2", "3"], "element")
     assign_role.assert_has_calls([
         mock.call("acl_section", "1", "element"),
         mock.call("acl_section", "2", "element"),
         mock.call("acl_section", "3", "element"),
     ], any_order=True)
Ejemplo n.º 25
0
    def test_prepare(
        self, validate_operation, validate_value_in,
        validate_different_intervals, complete_all_intervals,
        get_remaining_defaults
    ):
        validate_operation.side_effect = lambda operation, validator_list: [
            operation["name"].normalized #values comes here in ValuePairs
        ]
        validate_value_in.return_value = "value_in"
        validate_different_intervals.return_value = ["different_interval"]


        report_processor = mock.MagicMock()
        raw_operation_list = [
            {"name": "start"},
            {"name": "monitor"},
        ]
        default_operation_list = [
            {"name": "stop"},
        ]
        allowed_operation_name_list = ["start", "stop", "monitor"]
        allow_invalid = True

        operations.prepare(
            report_processor,
            raw_operation_list,
            default_operation_list,
            allowed_operation_name_list,
            allow_invalid,
        )

        validate_value_in.assert_called_once_with(
            "name",
            allowed_operation_name_list,
            option_name_for_report="operation name",
            code_to_allow_extra_values=report_codes.FORCE_OPTIONS,
            allow_extra_values=allow_invalid,
        )

        validate_different_intervals.assert_called_once_with(raw_operation_list)
        report_processor.process_list.assert_called_once_with([
            "start",
            "monitor",
            "different_interval",
        ])
        validate_operation.assert_has_calls(
            [
                mock.call(
                    {"name": ValuePair("monitor", "monitor")},
                    ["value_in"]
                ),
                mock.call({"name": ValuePair("start", "start")}, ["value_in"]),
            ],
            any_order=True
        )

        complete_all_intervals.assert_called_once_with(raw_operation_list)
Ejemplo n.º 26
0
 def test_sucessfully_write_binary(self):
     self.assert_params_causes_calls(
         {
             "content": "filecontent",
             "is_binary": True
         }, [
             mock.call(FILE_PATH, "wb"),
             mock.call().write("filecontent"),
             mock.call().close(),
         ])
Ejemplo n.º 27
0
    def test_success(self, mock_attrs):
        lib._set_instance_attrs_node_list(create_env(), "attrs",
                                          ["node-1", "node-2"], False)

        self.assert_context_manager_launched(pre=True, post=True)
        self.assertEqual(2, len(mock_attrs.mock_calls))
        mock_attrs.assert_has_calls([
            mock.call("cib", "node-1", "attrs", self.cluster_nodes),
            mock.call("cib", "node-2", "attrs", self.cluster_nodes),
        ])
Ejemplo n.º 28
0
    def test_fail_doesnt_prevent_start(self, mock_remote_start, mock_remote_stop):
        nodes = ["node1", "node2"]
        node_addrs_list = NodeAddressesList([NodeAddresses(addr) for addr in nodes])

        def raiser(reporter, communicator, node):
            if node.ring0 == nodes[1]:
                raise NodeAuthenticationException(node.label, "command", "HTTP error: 401")

        mock_remote_stop.side_effect = raiser

        assert_raise_library_error(
            lambda: lib.qdevice_reload_on_nodes(self.mock_communicator, self.mock_reporter, node_addrs_list),
            (
                severity.ERROR,
                report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED,
                {"node": nodes[1], "command": "command", "reason": "HTTP error: 401"},
                report_codes.SKIP_OFFLINE_NODES,
            ),
        )

        node_calls = [
            mock.call(self.mock_reporter, self.mock_communicator, node_addrs_list[0]),
            mock.call(self.mock_reporter, self.mock_communicator, node_addrs_list[1]),
        ]
        self.assertEqual(len(node_calls), len(mock_remote_stop.mock_calls))
        self.assertEqual(len(node_calls), len(mock_remote_start.mock_calls))
        mock_remote_stop.assert_has_calls(node_calls, any_order=True)
        mock_remote_start.assert_has_calls(node_calls, any_order=True)

        assert_report_item_list_equal(
            self.mock_reporter.report_item_list,
            [
                (severity.INFO, report_codes.QDEVICE_CLIENT_RELOAD_STARTED, {}),
                # why the same error twice?
                # 1. Tested piece of code calls a function which puts an error
                # into the reporter. The reporter raises an exception. The
                # exception is caught in the tested piece of code, stored, and
                # later put to reporter again.
                # 2. Mock reporter remembers everything that goes through it
                # and by the machanism described in 1 the error goes througt it
                # twice.
                (
                    severity.ERROR,
                    report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED,
                    {"node": nodes[1], "command": "command", "reason": "HTTP error: 401"},
                    report_codes.SKIP_OFFLINE_NODES,
                ),
                (
                    severity.ERROR,
                    report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED,
                    {"node": nodes[1], "command": "command", "reason": "HTTP error: 401"},
                    report_codes.SKIP_OFFLINE_NODES,
                ),
            ],
        )
Ejemplo n.º 29
0
    def test_success(self, mock_attrs):
        lib._set_instance_attrs_node_list(
            create_env(), "attrs", ["node-1", "node-2"], False
        )

        self.assert_context_manager_launched(pre=True, post=True)
        self.assertEqual(2, len(mock_attrs.mock_calls))
        mock_attrs.assert_has_calls([
            mock.call("cib", "node-1", "attrs", self.cluster_nodes),
            mock.call("cib", "node-2", "attrs", self.cluster_nodes),
        ])
Ejemplo n.º 30
0
    def test_one_node_down_forced(self, mock_corosync_live):
        conf_text = "test conf text"
        nodes = ["node1", "node2"]
        node_addrs_list = NodeAddressesList(
            [NodeAddresses(addr) for addr in nodes])
        mock_corosync_live.set_remote_corosync_conf = mock.MagicMock()

        def raiser(comm, node, conf):
            if node.ring0 == nodes[1]:
                raise NodeAuthenticationException(nodes[1], "command",
                                                  "HTTP error: 401")

        mock_corosync_live.set_remote_corosync_conf.side_effect = raiser

        lib.distribute_corosync_conf(self.mock_communicator,
                                     self.mock_reporter,
                                     node_addrs_list,
                                     conf_text,
                                     skip_offline_nodes=True)

        corosync_live_calls = [
            mock.call.set_remote_corosync_conf("mock node communicator",
                                               nodes[0], conf_text),
            mock.call.set_remote_corosync_conf("mock node communicator",
                                               nodes[1], conf_text),
        ]
        self.assertEqual(len(corosync_live_calls),
                         len(mock_corosync_live.mock_calls))
        mock_corosync_live.set_remote_corosync_conf.assert_has_calls(
            [
                mock.call("mock node communicator", node_addrs_list[0],
                          conf_text),
                mock.call("mock node communicator", node_addrs_list[1],
                          conf_text),
            ],
            any_order=True)

        assert_report_item_list_equal(self.mock_reporter.report_item_list, [
            (severity.INFO, report_codes.COROSYNC_CONFIG_DISTRIBUTION_STARTED,
             {}),
            (severity.INFO, report_codes.COROSYNC_CONFIG_ACCEPTED_BY_NODE, {
                "node": nodes[0]
            }),
            (severity.WARNING,
             report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED, {
                 "node": nodes[1],
                 "command": "command",
                 "reason": "HTTP error: 401",
             }),
            (severity.WARNING,
             report_codes.COROSYNC_CONFIG_DISTRIBUTION_NODE_ERROR, {
                 "node": nodes[1],
             }),
        ])
Ejemplo n.º 31
0
    def test_success(self):
        self.maxDiff = None
        mock_open = mock.mock_open(read_data="config content")
        with patch_config_files("open", mock_open, create=True):
            self.assertEqual("config content",
                             config_files._read_config("my-file.conf"))

        self.assertEqual([
            mock.call(os.path.join(BOOTH_CONFIG_DIR, "my-file.conf"), "r"),
            mock.call().__enter__(),
            mock.call().read(),
            mock.call().__exit__(None, None, None)
        ], mock_open.mock_calls)
Ejemplo n.º 32
0
    def test_success(self):
        path = os.path.join(BOOTH_CONFIG_DIR, "file.key")
        mock_open = mock.mock_open(read_data="key")

        with patch_config_files("open", mock_open, create=True):
            self.assertEqual(
                "key", config_files.read_authfile(self.mock_reporter, path))

        self.assertEqual([
            mock.call(path, "rb"),
            mock.call().__enter__(),
            mock.call().read(),
            mock.call().__exit__(None, None, None)
        ], mock_open.mock_calls)
        self.assertEqual(0, len(self.mock_reporter.report_item_list))
Ejemplo n.º 33
0
    def test_success(self):
        mock_runner = mock.MagicMock(spec_set=CommandRunner)
        mock_runner.run.side_effect = [
            (
                "\n".join([
                    "ocf",
                    "lsb",
                    "service",
                    "systemd",
                    "nagios",
                    "stonith",
                    "",
                ]),
                "",
                0
            ),
            (
                "\n".join([
                    "heartbeat",
                    "openstack",
                    "pacemaker",
                    "booth",
                    "",
                ]),
                "",
                0
            ),
        ]

        self.assertEqual(
            lib_ra.list_resource_agents_standards_and_providers(mock_runner),
            [
                "lsb",
                "nagios",
                "ocf:booth",
                "ocf:heartbeat",
                "ocf:openstack",
                "ocf:pacemaker",
                "service",
                "systemd",
            ]
        )

        self.assertEqual(2, len(mock_runner.run.mock_calls))
        mock_runner.run.assert_has_calls([
            mock.call(["/usr/sbin/crm_resource", "--list-standards"]),
            mock.call(["/usr/sbin/crm_resource", "--list-ocf-providers"]),
        ])
Ejemplo n.º 34
0
 def test_success(self, mock_func):
     lib_sbd.remove_stonith_watchdog_timeout_on_all_nodes(
         self.mock_com, self.node_list
     )
     func_calls = [mock.call(self.mock_com, node) for node in self.node_list]
     self.assertEqual(mock_func.call_count, len(func_calls))
     mock_func.assert_has_calls(func_calls)
Ejemplo n.º 35
0
    def test_create_config(self, mock_real_file, mock_set_keyfile_access):
        mock_file = mock.MagicMock(
            assert_no_conflict_with_existing=mock.MagicMock(),
            write=mock.MagicMock(),
        )
        mock_real_file.return_value = mock_file

        env.BoothEnv("report processor", env_data={
            "name": "booth"
        }).create_config("a", can_overwrite_existing=True)

        self.assertEqual(mock_file.assert_no_conflict_with_existing.mock_calls,
                         [
                             mock.call('report processor', True),
                         ])
        self.assertEqual(mock_file.write.mock_calls, [mock.call('a')])
Ejemplo n.º 36
0
    def test_communication_error(self, mock_func):
        def raiser(_, node):
            if node == self.node_list[1]:
                raise NodeConnectionException(self.node_list[1], "command",
                                              "reason")
            elif node == self.node_list[4]:
                raise NodeCommunicationException(self.node_list[4], "command",
                                                 "reason")

        mock_func.side_effect = raiser
        assert_raise_library_error(
            lambda: lib_sbd.remove_stonith_watchdog_timeout_on_all_nodes(
                self.mock_com, self.node_list),
            (Severities.ERROR,
             report_codes.NODE_COMMUNICATION_ERROR_UNABLE_TO_CONNECT, {
                 "node": self.node_list[1],
                 "command": "command",
                 "reason": "reason"
             }), (Severities.ERROR, report_codes.NODE_COMMUNICATION_ERROR, {
                 "node": self.node_list[4],
                 "command": "command",
                 "reason": "reason"
             }))
        func_calls = [
            mock.call(self.mock_com, node) for node in self.node_list
        ]
        self.assertEqual(mock_func.call_count, len(func_calls))
        mock_func.assert_has_calls(func_calls)
Ejemplo n.º 37
0
 def test_success(self, mock_func):
     lib_sbd.remove_stonith_watchdog_timeout_on_all_nodes(
         self.mock_com, self.node_list
     )
     func_calls = [mock.call(self.mock_com, node) for node in self.node_list]
     self.assertEqual(mock_func.call_count, len(func_calls))
     mock_func.assert_has_calls(func_calls)
Ejemplo n.º 38
0
    def test_create_config(self, mock_real_file, mock_set_keyfile_access):
        mock_file = mock.MagicMock(
            assert_no_conflict_with_existing=mock.MagicMock(),
            write=mock.MagicMock(),
        )
        mock_real_file.return_value = mock_file


        env.BoothEnv(
            "report processor",
            env_data={"name": "booth"}
        ).create_config("a", can_overwrite_existing=True)

        self.assertEqual(mock_file.assert_no_conflict_with_existing.mock_calls,[
            mock.call('report processor', True),
        ])
        self.assertEqual(mock_file.write.mock_calls, [mock.call('a')])
Ejemplo n.º 39
0
    def test_remove_ip_when_is_only_booth_sibling_in_group(self):
        group = etree.fromstring('''
            <group>
                <primitive id="ip" type="IPaddr2"/>
                <primitive id="booth" type="booth-site">
                    <instance_attributes>
                        <nvpair name="config" value="/PATH/TO/CONF"/>
                    </instance_attributes>
                </primitive>
            </group>
        ''')

        mock_resource_remove = self.call(self.find_booth_resources(group))
        self.assertEqual(mock_resource_remove.mock_calls, [
            mock.call('ip'),
            mock.call('booth'),
        ])
Ejemplo n.º 40
0
    def test_success(self):
        self.maxDiff = None
        mock_open = mock.mock_open(read_data="config content")
        with patch_config_files("open", mock_open, create=True):
            self.assertEqual(
                "config content",
                config_files._read_config("my-file.conf")
            )

        self.assertEqual(
            [
                mock.call(os.path.join(BOOTH_CONFIG_DIR, "my-file.conf"), "r"),
                mock.call().__enter__(),
                mock.call().read(),
                mock.call().__exit__(None, None, None)
            ],
            mock_open.mock_calls
        )
Ejemplo n.º 41
0
    def test_unstandby_all(self):
        nodes = ("node1", "node2", "node3")
        for i, n in enumerate(nodes, 1):
            self.fixture_add_node_status(self.fixture_get_node_status(n, i))
        mock_runner = mock.MagicMock(spec_set=CommandRunner)
        call_list = [mock.call(self.crm_mon_cmd())]
        call_list += [
            mock.call([self.path("crm_standby"), "-D", "-N", n]) for n in nodes
        ]
        return_value_list = [(str(self.status), "", 0)]
        return_value_list += [("dummy", "", 0) for n in nodes]
        mock_runner.run.side_effect = return_value_list

        output = lib.nodes_unstandby(mock_runner, all_nodes=True)

        self.assertEqual(len(return_value_list), len(call_list))
        self.assertEqual(len(return_value_list), mock_runner.run.call_count)
        mock_runner.run.assert_has_calls(call_list)
        self.assertEqual(None, output)
Ejemplo n.º 42
0
    def test_failure(self, mock_role, mock_assign):
        def _mock_role(_, el_id):
            if el_id in ["role1", "role3"]:
                raise acl_lib.AclRoleNotFound(el_id)
            elif el_id == "role2":
                return "role2_el"
            else:
                raise AssertionError("unexpected input")

        mock_role.side_effect = _mock_role
        assert_raise_library_error(
            lambda: cmd_acl._assign_roles_to_element(self.cib, "el", ["role1", "role2", "role3"]),
            (Severities.ERROR, report_codes.ID_NOT_FOUND, {"id": "role1", "id_description": "role"}),
            (Severities.ERROR, report_codes.ID_NOT_FOUND, {"id": "role3", "id_description": "role"}),
        )
        mock_role.assert_has_calls(
            [mock.call(self.cib, "role1"), mock.call(self.cib, "role2"), mock.call(self.cib, "role3")]
        )
        mock_assign.assert_called_once_with("el", "role2_el")
Ejemplo n.º 43
0
    def test_success(self):
        path = os.path.join(BOOTH_CONFIG_DIR, "file.key")
        mock_open = mock.mock_open(read_data="key")

        with patch_config_files("open", mock_open, create=True):
            self.assertEqual(
                "key", config_files.read_authfile(self.mock_reporter, path)
            )

        self.assertEqual(
            [
                mock.call(path, "rb"),
                mock.call().__enter__(),
                mock.call().read(),
                mock.call().__exit__(None, None, None)
            ],
            mock_open.mock_calls
        )
        self.assertEqual(0, len(self.mock_reporter.report_item_list))
Ejemplo n.º 44
0
    def test_remove_ip_when_is_only_booth_sibling_in_group(self):
        group = etree.fromstring('''
            <group>
                <primitive id="ip" type="IPaddr2"/>
                <primitive id="booth" type="booth-site">
                    <instance_attributes>
                        <nvpair name="config" value="/PATH/TO/CONF"/>
                    </instance_attributes>
                </primitive>
            </group>
        ''')

        mock_resource_remove = self.call(group.getchildren()[1:])
        self.assertEqual(
            mock_resource_remove.mock_calls, [
                mock.call('ip'),
                mock.call('booth'),
            ]
        )
Ejemplo n.º 45
0
    def test_error_some_nodes(self):
        nodes = ("node1", "node2", "node3", "node4")
        for i, n in enumerate(nodes, 1):
            self.fixture_add_node_status(
                self.fixture_get_node_status(n, i)
            )
        mock_runner = mock.MagicMock(spec_set=CommandRunner)
        call_list = [mock.call(self.crm_mon_cmd())]
        call_list += [
            mock.call([self.path("crm_standby"), "-v", "on", "-N", n])
            for n in nodes
        ]
        return_value_list = [
            (str(self.status), "", 0),
            ("dummy1", "", 0),
            ("dummy2", "error2", 1),
            ("dummy3", "", 0),
            ("dummy4", "error4", 1),
        ]
        mock_runner.run.side_effect = return_value_list

        assert_raise_library_error(
            lambda: lib.nodes_standby(mock_runner, all_nodes=True),
            (
                Severity.ERROR,
                report_codes.COMMON_ERROR,
                {
                    "text": "error2\ndummy2",
                }
            ),
            (
                Severity.ERROR,
                report_codes.COMMON_ERROR,
                {
                    "text": "error4\ndummy4",
                }
            )
        )

        self.assertEqual(len(return_value_list), len(call_list))
        self.assertEqual(len(return_value_list), mock_runner.run.call_count)
        mock_runner.run.assert_has_calls(call_list)
Ejemplo n.º 46
0
    def test_one_node_down_forced(self, mock_corosync_live):
        conf_text = "test conf text"
        nodes = ["node1", "node2"]
        node_addrs_list = NodeAddressesList([NodeAddresses(addr) for addr in nodes])
        mock_corosync_live.set_remote_corosync_conf = mock.MagicMock()

        def raiser(comm, node, conf):
            if node.ring0 == nodes[1]:
                raise NodeAuthenticationException(nodes[1], "command", "HTTP error: 401")

        mock_corosync_live.set_remote_corosync_conf.side_effect = raiser

        lib.distribute_corosync_conf(
            self.mock_communicator, self.mock_reporter, node_addrs_list, conf_text, skip_offline_nodes=True
        )

        corosync_live_calls = [
            mock.call.set_remote_corosync_conf("mock node communicator", nodes[0], conf_text),
            mock.call.set_remote_corosync_conf("mock node communicator", nodes[1], conf_text),
        ]
        self.assertEqual(len(corosync_live_calls), len(mock_corosync_live.mock_calls))
        mock_corosync_live.set_remote_corosync_conf.assert_has_calls(
            [
                mock.call("mock node communicator", node_addrs_list[0], conf_text),
                mock.call("mock node communicator", node_addrs_list[1], conf_text),
            ],
            any_order=True,
        )

        assert_report_item_list_equal(
            self.mock_reporter.report_item_list,
            [
                (severity.INFO, report_codes.COROSYNC_CONFIG_DISTRIBUTION_STARTED, {}),
                (severity.INFO, report_codes.COROSYNC_CONFIG_ACCEPTED_BY_NODE, {"node": nodes[0]}),
                (
                    severity.WARNING,
                    report_codes.NODE_COMMUNICATION_ERROR_NOT_AUTHORIZED,
                    {"node": nodes[1], "command": "command", "reason": "HTTP error: 401"},
                ),
                (severity.WARNING, report_codes.COROSYNC_CONFIG_DISTRIBUTION_NODE_ERROR, {"node": nodes[1]}),
            ],
        )
Ejemplo n.º 47
0
    def test_success(self, mock_create_handle, _, mock_con_successful,
                     mock_con_failure):
        com = self.get_multiaddress_communicator()
        counter = {"counter": 0}
        expected_response_list = []

        def _con_successful(handle):
            response = lib.Response(handle, True)
            expected_response_list.append(response)
            return response

        def _con_failure(handle, errno, err_msg):
            response = lib.Response(handle, False, errno, err_msg)
            expected_response_list.append(response)
            return response

        def _mock_create_request_handle(request, _, __):
            counter["counter"] += 1
            return (MockCurl(
                request=request) if counter["counter"] > 2 else MockCurl(
                    error=(pycurl.E_SEND_ERROR, "reason"),
                    request=request,
                ))

        mock_con_successful.side_effect = _con_successful
        mock_con_failure.side_effect = _con_failure
        mock_create_handle.side_effect = _mock_create_request_handle
        request = lib.Request(
            lib.RequestTarget("label",
                              ["host{0}".format(i) for i in range(4)]),
            lib.RequestData("action"))
        com.add_requests([request])
        response_list = list(com.start_loop())
        self.assertEqual(1, len(response_list))
        response = response_list[0]
        self.assertIs(response, expected_response_list[-1])
        self.assertTrue(response.was_connected)
        self.assertIs(request, response.request)
        self.assertEqual("host2", request.host)
        self.assertEqual(3, mock_create_handle.call_count)
        self.assertEqual(3, len(expected_response_list))
        mock_create_handle.assert_has_calls([
            mock.call(request, {}, settings.default_request_timeout)
            for _ in range(3)
        ])
        logger_calls = (fixture_logger_request_retry_calls(
            expected_response_list[0], "host0") +
                        fixture_logger_request_retry_calls(
                            expected_response_list[1], "host1") + [
                                mock.call.log_request_start(request),
                                mock.call.log_response(response),
                            ])
        self.assertEqual(logger_calls, self.mock_com_log.mock_calls)
        com._multi_handle.assert_no_handle_left()
Ejemplo n.º 48
0
    def test_basic(self):
        expected_stdout = "expected output"
        expected_stderr = "expected stderr"
        mock_runner = mock.MagicMock(spec_set=CommandRunner)
        call_list = [
            mock.call(self.crm_mon_cmd()),
            mock.call([self.path("crm_resource"), "--cleanup"]),
        ]
        return_value_list = [
            (self.fixture_status_xml(1, 1), "", 0),
            (expected_stdout, expected_stderr, 0),
        ]
        mock_runner.run.side_effect = return_value_list

        real_output = lib.resource_cleanup(mock_runner)

        self.assertEqual(len(return_value_list), len(call_list))
        self.assertEqual(len(return_value_list), mock_runner.run.call_count)
        mock_runner.run.assert_has_calls(call_list)
        self.assertEqual(expected_stdout + "\n" + expected_stderr, real_output)
Ejemplo n.º 49
0
    def test_catch_exactly_his_exception(self, mock_is_file,
                                         mock_console_report):
        next_in_line = mock.Mock(side_effect=LibraryEnvError(
            ReportItem.error(report_codes.FILE_DOES_NOT_EXIST,
                             info={
                                 "file_role": env_file_role_codes.BOOTH_CONFIG,
                             }),
            ReportItem.error(report_codes.FILE_DOES_NOT_EXIST,
                             info={
                                 "file_role": env_file_role_codes.BOOTH_KEY,
                             }),
            ReportItem.error("OTHER ERROR", info={}),
        ))
        mock_is_file.return_value = False
        mock_env = mock.MagicMock()

        #run tested code
        booth_conf_middleware = middleware_config(
            "booth-name",
            "/local/file/path.conf",
            "/local/file/path.key",
        )
        raised_exception = []

        def run_middleware():
            try:
                booth_conf_middleware(next_in_line, mock_env)
            except Exception as e:
                raised_exception.append(e)
                raise e

        self.assertRaises(LibraryEnvError, run_middleware)
        self.assertEqual(1, len(raised_exception[0].unprocessed))
        self.assertEqual("OTHER ERROR",
                         raised_exception[0].unprocessed[0].code)

        self.assertEqual(mock_console_report.error.mock_calls, [
            mock.call(
                "Booth config file '/local/file/path.conf' does not exist"),
            mock.call("Booth key file '/local/file/path.key' does not exist"),
        ])
Ejemplo n.º 50
0
    def test_catch_exactly_his_exception(
        self, mock_is_file, mock_console_report
    ):
        next_in_line = mock.Mock(side_effect=LibraryEnvError(
            ReportItem.error(report_codes.FILE_DOES_NOT_EXIST, "", info={
                "file_role": env_file_role_codes.BOOTH_CONFIG,
            }),
            ReportItem.error(report_codes.FILE_DOES_NOT_EXIST, "", info={
                "file_role": env_file_role_codes.BOOTH_KEY,
            }),
            ReportItem.error("OTHER ERROR", "", info={}),
        ))
        mock_is_file.return_value = False
        mock_env = mock.MagicMock()

        #run tested code
        booth_conf_middleware = middleware_config(
            "booth-name",
            "/local/file/path.conf",
            "/local/file/path.key",
        )
        raised_exception = []
        def run_middleware():
            try:
                booth_conf_middleware(next_in_line, mock_env)
            except Exception as e:
                raised_exception.append(e)
                raise e

        self.assertRaises(LibraryEnvError, run_middleware)
        self.assertEqual(1, len(raised_exception[0].unprocessed))
        self.assertEqual("OTHER ERROR", raised_exception[0].unprocessed[0].code)

        self.assertEqual(mock_console_report.error.mock_calls, [
            mock.call(
                "Booth config file '/local/file/path.conf' does not exist"
            ),
            mock.call(
                "Booth key file '/local/file/path.key' does not exist"
            ),
        ])
Ejemplo n.º 51
0
    def test_skip_failed(self, mock_get_configs, mock_read):
        def _mock_read_cfg(file):
            if file in ["name1.conf", "name3.conf"]:
                raise EnvironmentError()
            elif file == "name2.conf":
                return "config2"
            else:
                raise AssertionError("unexpected input: {0}".format(file))

        mock_get_configs.return_value = [
            "name1.conf", "name2.conf", "name3.conf"
        ]
        mock_read.side_effect = _mock_read_cfg

        self.assertEqual(
            {"name2.conf": "config2"},
            config_files.read_configs(self.mock_reporter, True)
        )
        mock_get_configs.assert_called_once_with()
        self.assertEqual(3, mock_read.call_count)
        mock_read.assert_has_calls([
            mock.call("name1.conf"),
            mock.call("name2.conf"),
            mock.call("name3.conf")
        ])
        assert_report_item_list_equal(
            self.mock_reporter.report_item_list,
            [
                (
                    severities.WARNING,
                    report_codes.BOOTH_CONFIG_READ_ERROR,
                    {"name": "name1.conf"}
                ),
                (
                    severities.WARNING,
                    report_codes.BOOTH_CONFIG_READ_ERROR,
                    {"name": "name3.conf"}
                )
            ]
        )
Ejemplo n.º 52
0
    def test_unstandby_nodes(self):
        nodes = ("node1", "node2", "node3")
        for i, n in enumerate(nodes, 1):
            self.fixture_add_node_status(
                self.fixture_get_node_status(n, i)
            )
        mock_runner = mock.MagicMock(spec_set=CommandRunner)
        call_list = [mock.call(self.crm_mon_cmd())]
        call_list += [
            mock.call([self.path("crm_standby"), "-D", "-N", n])
            for n in nodes[:2]
        ]
        return_value_list = [(str(self.status), "", 0)]
        return_value_list += [("dummy", "", 0) for n in nodes[:2]]
        mock_runner.run.side_effect = return_value_list

        output = lib.nodes_unstandby(mock_runner, node_list=nodes[:2])

        self.assertEqual(len(return_value_list), len(call_list))
        self.assertEqual(len(return_value_list), mock_runner.run.call_count)
        mock_runner.run.assert_has_calls(call_list)
        self.assertEqual(None, output)
Ejemplo n.º 53
0
    def test_remove_ip_when_group_is_disabled(self):
        group = etree.fromstring('''
            <group>
                <primitive id="ip" type="IPaddr2"/>
                <primitive id="booth" type="booth-site">
                    <instance_attributes>
                        <nvpair name="config" value="/PATH/TO/CONF"/>
                    </instance_attributes>
                </primitive>
                <meta_attributes>
                    <nvpair name="target-role" value="Stopped"/>
                </meta_attributes>
            </group>
        ''')

        mock_resource_remove = self.call(self.find_booth_resources(group))
        self.assertEqual(
            mock_resource_remove.mock_calls, [
                mock.call('ip'),
                mock.call('booth'),
            ]
        )
Ejemplo n.º 54
0
    def test_put_duplicate_constraint_when_duplication_allowed(self):
        self.create()
        self.create(duplication_alowed=True)
        expected_calls = [
            mock.call(self.cib),
            mock.call(self.cib),
        ]
        self.assertEqual(self.env.push_cib.call_count, len(expected_calls))
        self.env.push_cib.assert_has_calls(expected_calls)

        constraint_section = self.independent_cib.find(".//constraints")
        constraint_section.append(etree.XML("""
            <rsc_some id="some_id" symmetrical="true">
                <resource_set id="pcs_rsc_set_A_B" role="Master">
                    <resource_ref id="A"></resource_ref>
                    <resource_ref id="B"></resource_ref>
                </resource_set>
                <resource_set action="start" id="pcs_rsc_set_E_F">
                    <resource_ref id="E"></resource_ref>
                    <resource_ref id="F"></resource_ref>
                </resource_set>
            </rsc_some>
        """))
        constraint_section.append(etree.XML("""
            <rsc_some id="some_id" symmetrical="true">
                <resource_set id="pcs_rsc_set_A_B-1" role="Master">
                    <resource_ref id="A"></resource_ref>
                    <resource_ref id="B"></resource_ref>
                </resource_set>
                <resource_set action="start" id="pcs_rsc_set_E_F-1">
                    <resource_ref id="E"></resource_ref>
                    <resource_ref id="F"></resource_ref>
                </resource_set>
            </rsc_some>
        """))
        assert_xml_equal(
            etree.tostring(self.independent_cib).decode(),
            etree.tostring(self.cib).decode()
        )
Ejemplo n.º 55
0
    def test_basic(self):
        expected_stdout = "expected output"
        expected_stderr = "expected stderr"
        mock_runner = mock.MagicMock(spec_set=CommandRunner)
        call_list = [
            mock.call(self.crm_mon_cmd()),
            mock.call([self.path("crm_resource"), "--cleanup"]),
        ]
        return_value_list = [
            (self.fixture_status_xml(1, 1), "", 0),
            (expected_stdout, expected_stderr, 0),
        ]
        mock_runner.run.side_effect = return_value_list

        real_output = lib.resource_cleanup(mock_runner)

        self.assertEqual(len(return_value_list), len(call_list))
        self.assertEqual(len(return_value_list), mock_runner.run.call_count)
        mock_runner.run.assert_has_calls(call_list)
        self.assertEqual(
            expected_stdout + "\n" + expected_stderr,
            real_output
        )
Ejemplo n.º 56
0
    def test_do_not_skip_failed(self, mock_get_configs, mock_read):
        def _mock_read_cfg(file):
            if file in ["name1.conf", "name3.conf"]:
                raise EnvironmentError()
            elif file == "name2.conf":
                return "config2"
            else:
                raise AssertionError("unexpected input: {0}".format(file))

        mock_get_configs.return_value = [
            "name1.conf", "name2.conf", "name3.conf"
        ]
        mock_read.side_effect = _mock_read_cfg

        assert_raise_library_error(
            lambda: config_files.read_configs(self.mock_reporter),
            (
                severities.ERROR,
                report_codes.BOOTH_CONFIG_READ_ERROR,
                {"name": "name1.conf"},
                report_codes.SKIP_UNREADABLE_CONFIG
            ),
            (
                severities.ERROR,
                report_codes.BOOTH_CONFIG_READ_ERROR,
                {"name": "name3.conf"},
                report_codes.SKIP_UNREADABLE_CONFIG
            )
        )
        mock_get_configs.assert_called_once_with()
        self.assertEqual(3, mock_read.call_count)
        mock_read.assert_has_calls([
            mock.call("name1.conf"),
            mock.call("name2.conf"),
            mock.call("name3.conf")
        ])
        self.assertEqual(2, len(self.mock_reporter.report_item_list))
Ejemplo n.º 57
0
 def test_success(self, mock_role, mock_assign):
     mock_role.side_effect = lambda _, el_id: "{0}_el".format(el_id)
     cmd_acl._assign_roles_to_element(self.cib, "el", ["role1", "role2", "role3"])
     mock_role.assert_has_calls(
         [mock.call(self.cib, "role1"), mock.call(self.cib, "role2"), mock.call(self.cib, "role3")]
     )
     mock_assign.assert_has_calls(
         [mock.call("el", "role1_el"), mock.call("el", "role2_el"), mock.call("el", "role3_el")]
     )
Ejemplo n.º 58
0
    def test_dont_remove_ip_when_group_has_other_resources(self):
        group = etree.fromstring('''
            <group>
                <primitive id="ip" type="IPaddr2"/>
                <primitive id="booth" type="booth-site">
                    <instance_attributes>
                        <nvpair name="config" value="/PATH/TO/CONF"/>
                    </instance_attributes>
                </primitive>
                <primitive id="dummy" type="Dummy"/>
            </group>
        ''')

        mock_resource_remove = self.call(self.find_booth_resources(group))
        self.assertEqual(
            mock_resource_remove.mock_calls, [
                mock.call('booth'),
            ]
        )