From e3f9823283517bafa8d309fb6148539e0e8ecdb2 Mon Sep 17 00:00:00 2001

From: Miroslav Lisik <mlisik@redhat.com>

Date: Fri, 10 Sep 2021 11:40:03 +0200

Subject: [PATCH] add missing file test_stonith_update_scsi_devices.py

---

 .../test_stonith_update_scsi_devices.py       | 1153 +++++++++++++++++

 1 file changed, 1153 insertions(+)

 create mode 100644 pcs_test/tier0/lib/commands/test_stonith_update_scsi_devices.py

diff --git a/pcs_test/tier0/lib/commands/test_stonith_update_scsi_devices.py b/pcs_test/tier0/lib/commands/test_stonith_update_scsi_devices.py

new file mode 100644

index 0000000..3bc5132

--- /dev/null

+++ b/pcs_test/tier0/lib/commands/test_stonith_update_scsi_devices.py

@@ -0,0 +1,1153 @@

+import json

+from unittest import mock, TestCase

+

+

+from pcs_test.tools import fixture

+from pcs_test.tools.command_env import get_env_tools

+from pcs_test.tools.misc import get_test_resource as rc

+

+from pcs import settings

+from pcs.lib.commands import stonith

+from pcs.common import (

+    communication,

+    reports,

+)

+from pcs.common.interface import dto

+from pcs.common.tools import timeout_to_seconds

+

+from .cluster.common import (

+    corosync_conf_fixture,

+    get_two_node,

+    node_fixture,

+)

+

+SCSI_STONITH_ID = "scsi-fence-device"

+SCSI_NODE = "node1"

+_DIGEST = "0" * 31

+DEFAULT_DIGEST = _DIGEST + "0"

+ALL_DIGEST = _DIGEST + "1"

+NONPRIVATE_DIGEST = _DIGEST + "2"

+NONRELOADABLE_DIGEST = _DIGEST + "3"

+DEVICES_1 = ("/dev/sda",)

+DEVICES_2 = ("/dev/sda", "/dev/sdb")

+DEVICES_3 = ("/dev/sda", "/dev/sdb", "/dev/sdc")

+

+DEFAULT_MONITOR = ("monitor", "60s", None, None)

+DEFAULT_OPS = (DEFAULT_MONITOR,)

+DEFAULT_LRM_START_OPS = (("0", DEFAULT_DIGEST, None, None),)

+DEFAULT_LRM_MONITOR_OPS = (("60000", DEFAULT_DIGEST, None, None),)

+DEFAULT_LRM_START_OPS_UPDATED = (("0", ALL_DIGEST, None, None),)

+DEFAULT_LRM_MONITOR_OPS_UPDATED = (("60000", ALL_DIGEST, None, None),)

+

+

+def _fixture_ops(resource_id, ops):

+    return "\n".join(

+        [

+            (

+                '

+                ' interval="{interval}" {timeout} name="{name}"/>'

+            ).format(

+                resource_id=resource_id,

+                name=name,

+                _interval=_interval if _interval else interval,

+                interval=interval,

+                timeout=f'timeout="{timeout}"' if timeout else "",

+            )

+            for name, interval, timeout, _interval in ops

+        ]

+    )

+

+

+def _fixture_devices_nvpair(resource_id, devices):

+    if devices is None:

+        return ""

+    return (

+        '

+        ' value="{devices}"/>'

+    ).format(resource_id=resource_id, devices=",".join(sorted(devices)))

+

+

+def fixture_scsi(

+    stonith_id=SCSI_STONITH_ID, devices=DEVICES_1, resource_ops=DEFAULT_OPS

+):

+    return """

+        <resources>

+            <primitive class="stonith" id="{stonith_id}" type="fence_scsi">

+                <instance_attributes id="{stonith_id}-instance_attributes">

+                    {devices}

+                    <nvpair id="{stonith_id}-instance_attributes-pcmk_host_check" name="pcmk_host_check" value="static-list"/>

+                    <nvpair id="{stonith_id}-instance_attributes-pcmk_host_list" name="pcmk_host_list" value="node1 node2 node3"/>

+                    <nvpair id="{stonith_id}-instance_attributes-pcmk_reboot_action" name="pcmk_reboot_action" value="off"/>

+                </instance_attributes>

+                <meta_attributes id="{stonith_id}-meta_attributes">

+                    <nvpair id="{stonith_id}-meta_attributes-provides" name="provides" value="unfencing"/>

+                </meta_attributes>

+                <operations>

+                    {operations}

+                </operations>

+            </primitive>

+            <primitive class="ocf" id="dummy" provider="pacemaker" type="Dummy"/>

+        </resources>

+    """.format(

+        stonith_id=stonith_id,

+        devices=_fixture_devices_nvpair(stonith_id, devices),

+        operations=_fixture_ops(stonith_id, resource_ops),

+    )

+

+

+def _fixture_lrm_rsc_ops(op_type, resource_id, lrm_ops):

+    return [

+        (

+            '

+            'interval="{ms}" {_all} {secure} {restart}/>'

+        ).format(

+            op_type_id="last" if op_type == "start" else op_type,

+            op_type=op_type,

+            resource_id=resource_id,

+            ms=ms,

+            _all=f'op-digest="{_all}"' if _all else "",

+            secure=f'op-secure-digest="{secure}"' if secure else "",

+            restart=f'op-restart-digest="{restart}"' if restart else "",

+        )

+        for ms, _all, secure, restart in lrm_ops

+    ]

+

+

+def _fixture_lrm_rsc_monitor_ops(resource_id, lrm_monitor_ops):

+    return _fixture_lrm_rsc_ops("monitor", resource_id, lrm_monitor_ops)

+

+

+def _fixture_lrm_rsc_start_ops(resource_id, lrm_start_ops):

+    return _fixture_lrm_rsc_ops("start", resource_id, lrm_start_ops)

+

+

+def _fixture_status_lrm_ops_base(

+    resource_id,

+    lrm_ops,

+):

+    return f"""

+        <status>

+            <node_state id="1" uname="node1">

+                <lrm id="1">

+                    <lrm_resources>

+                        <lrm_resource id="{resource_id}" type="fence_scsi" class="stonith">

+                            {lrm_ops}

+                        </lrm_resource>

+                    </lrm_resources>

+                </lrm>

+            </node_state>

+        </status>

+    """

+

+

+def _fixture_status_lrm_ops(

+    resource_id,

+    lrm_start_ops=DEFAULT_LRM_START_OPS,

+    lrm_monitor_ops=DEFAULT_LRM_MONITOR_OPS,

+):

+    return _fixture_status_lrm_ops_base(

+        resource_id,

+        "\n".join(

+            _fixture_lrm_rsc_start_ops(resource_id, lrm_start_ops)

+            + _fixture_lrm_rsc_monitor_ops(resource_id, lrm_monitor_ops)

+        ),

+    )

+

+

+def fixture_digests_xml(resource_id, node_name, devices=""):

+    return f"""

+        <pacemaker-result api-version="2.9" request="crm_resource --digests --resource {resource_id} --node {node_name} --output-as xml devices={devices}">

+            <digests resource="{resource_id}" node="{node_name}" task="stop" interval="0ms">

+                <digest type="all" hash="{ALL_DIGEST}">

+                    <parameters devices="{devices}" pcmk_host_check="static-list" pcmk_host_list="node1 node2 node3" pcmk_reboot_action="off"/>

+                </digest>

+                <digest type="nonprivate" hash="{NONPRIVATE_DIGEST}">

+                    <parameters devices="{devices}"/>

+                </digest>

+            </digests>

+            <status code="0" message="OK"/>

+        </pacemaker-result>

+    """

+

+

+FIXTURE_CRM_MON_RES_RUNNING_1 = f""" <resources> <resource id="{SCSI_STONITH_ID}" resource_agent="stonith:fence_scsi" role="Started" nodes_running_on="1">

+            <node name="{SCSI_NODE}" id="1" cached="true"/>

+        </resource>

+    </resources>

+"""

+

+FIXTURE_CRM_MON_RES_RUNNING_2 = f"""

+    <resources>

+        <resource id="{SCSI_STONITH_ID}" resource_agent="stonith:fence_scsi" role="Started" nodes_running_on="1">

+            <node name="node1" id="1" cached="true"/>

+            <node name="node2" id="2" cached="true"/>

+        </resource>

+    </resources>

+"""

+FIXTURE_CRM_MON_NODES = """

+    <nodes>

+        <node name="node1" id="1" is_dc="true" resources_running="1"/>

+        <node name="node2" id="2"/>

+        <node name="node3" id="3"/>

+    </nodes>

+"""

+

+FIXTURE_CRM_MON_RES_STOPPED = f"""

+    <resource id="{SCSI_STONITH_ID}" resource_agent="stonith:fence_scsi" role="Stopped" nodes_running_on="0"/>

+"""

+

+

+@mock.patch.object(

+    settings,

+    "pacemaker_api_result_schema",

+    rc("pcmk_api_rng/api-result.rng"),

+)

+class UpdateScsiDevices(TestCase):

+    def setUp(self):

+        self.env_assist, self.config = get_env_tools(self)

+

+        self.existing_nodes = ["node1", "node2", "node3"]

+        self.existing_corosync_nodes = [

+            node_fixture(node, node_id)

+            for node_id, node in enumerate(self.existing_nodes, 1)

+        ]

+        self.config.env.set_known_nodes(self.existing_nodes)

+

+    def assert_command_success(

+        self,

+        devices_before=DEVICES_1,

+        devices_updated=DEVICES_2,

+        resource_ops=DEFAULT_OPS,

+        lrm_monitor_ops=DEFAULT_LRM_MONITOR_OPS,

+        lrm_start_ops=DEFAULT_LRM_START_OPS,

+        lrm_monitor_ops_updated=DEFAULT_LRM_MONITOR_OPS_UPDATED,

+        lrm_start_ops_updated=DEFAULT_LRM_START_OPS_UPDATED,

+    ):

+        # pylint: disable=too-many-locals

+        self.config.runner.pcmk.is_resource_digests_supported()

+        self.config.runner.cib.load(

+            resources=fixture_scsi(

+                devices=devices_before, resource_ops=resource_ops

+            ),

+            status=_fixture_status_lrm_ops(

+                SCSI_STONITH_ID,

+                lrm_start_ops=lrm_start_ops,

+                lrm_monitor_ops=lrm_monitor_ops,

+            ),

+        )

+        self.config.runner.pcmk.load_state(

+            resources=FIXTURE_CRM_MON_RES_RUNNING_1, nodes=FIXTURE_CRM_MON_NODES

+        )

+        devices_opt = "devices={}".format(",".join(devices_updated))

+        self.config.runner.pcmk.resource_digests(

+            SCSI_STONITH_ID,

+            SCSI_NODE,

+            name="start.op.digests",

+            stdout=fixture_digests_xml(

+                SCSI_STONITH_ID, SCSI_NODE, devices=",".join(devices_updated)

+            ),

+            args=[devices_opt],

+        )

+

+        for num, op in enumerate(resource_ops, 1):

+            name, interval, timeout, _ = op

+            if name != "monitor":

+                continue

+            args = [devices_opt]

+            args.append(

+                "CRM_meta_interval={}".format(

+                    1000 * timeout_to_seconds(interval)

+                )

+            )

+            if timeout:

+                args.append(

+                    "CRM_meta_timeout={}".format(

+                        1000 * timeout_to_seconds(timeout)

+                    )

+                )

+            self.config.runner.pcmk.resource_digests(

+                SCSI_STONITH_ID,

+                SCSI_NODE,

+                name=f"{name}-{num}.op.digests",

+                stdout=fixture_digests_xml(

+                    SCSI_STONITH_ID,

+                    SCSI_NODE,

+                    devices=",".join(devices_updated),

+                ),

+                args=args,

+            )

+        self.config.corosync_conf.load_content(

+            corosync_conf_fixture(

+                self.existing_corosync_nodes,

+                get_two_node(len(self.existing_corosync_nodes)),

+            )

+        )

+        self.config.http.corosync.get_corosync_online_targets(

+            node_labels=self.existing_nodes

+        )

+        self.config.http.scsi.unfence_node(

+            devices_updated, node_labels=self.existing_nodes

+        )

+        self.config.env.push_cib(

+            resources=fixture_scsi(

+                devices=devices_updated, resource_ops=resource_ops

+            ),

+            status=_fixture_status_lrm_ops(

+                SCSI_STONITH_ID,

+                lrm_start_ops=lrm_start_ops_updated,

+                lrm_monitor_ops=lrm_monitor_ops_updated,

+            ),

+        )

+        stonith.update_scsi_devices(

+            self.env_assist.get_env(), SCSI_STONITH_ID, devices_updated

+        )

+        self.env_assist.assert_reports([])

+

+    def test_update_1_to_1_devices(self):

+        self.assert_command_success(

+            devices_before=DEVICES_1, devices_updated=DEVICES_1

+        )

+

+    def test_update_2_to_2_devices(self):

+        self.assert_command_success(

+            devices_before=DEVICES_1, devices_updated=DEVICES_1

+        )

+

+    def test_update_1_to_2_devices(self):

+        self.assert_command_success()

+

+    def test_update_1_to_3_devices(self):

+        self.assert_command_success(

+            devices_before=DEVICES_1, devices_updated=DEVICES_3

+        )

+

+    def test_update_3_to_1_devices(self):

+        self.assert_command_success(

+            devices_before=DEVICES_3, devices_updated=DEVICES_1

+        )

+

+    def test_update_3_to_2_devices(self):

+        self.assert_command_success(

+            devices_before=DEVICES_3, devices_updated=DEVICES_2

+        )

+

+    def test_default_monitor(self):

+        self.assert_command_success()

+

+    def test_no_monitor_ops(self):

+        self.assert_command_success(

+            resource_ops=(), lrm_monitor_ops=(), lrm_monitor_ops_updated=()

+        )

+

+    def test_1_monitor_with_timeout(self):

+        self.assert_command_success(

+            resource_ops=(("monitor", "30s", "10s", None),),

+            lrm_monitor_ops=(("30000", DEFAULT_DIGEST, None, None),),

+            lrm_monitor_ops_updated=(("30000", ALL_DIGEST, None, None),),

+        )

+

+    def test_2_monitor_ops_with_timeouts(self):

+        self.assert_command_success(

+            resource_ops=(

+                ("monitor", "30s", "10s", None),

+                ("monitor", "40s", "20s", None),

+            ),

+            lrm_monitor_ops=(

+                ("30000", DEFAULT_DIGEST, None, None),

+                ("40000", DEFAULT_DIGEST, None, None),

+            ),

+            lrm_monitor_ops_updated=(

+                ("30000", ALL_DIGEST, None, None),

+                ("40000", ALL_DIGEST, None, None),

+            ),

+        )

+

+    def test_2_monitor_ops_with_one_timeout(self):

+        self.assert_command_success(

+            resource_ops=(

+                ("monitor", "30s", "10s", None),

+                ("monitor", "60s", None, None),

+            ),

+            lrm_monitor_ops=(

+                ("30000", DEFAULT_DIGEST, None, None),

+                ("60000", DEFAULT_DIGEST, None, None),

+            ),

+            lrm_monitor_ops_updated=(

+                ("30000", ALL_DIGEST, None, None),

+                ("60000", ALL_DIGEST, None, None),

+            ),

+        )

+

+    def test_various_start_ops_one_lrm_start_op(self):

+        self.assert_command_success(

+            resource_ops=(

+                ("monitor", "60s", None, None),

+                ("start", "0s", "40s", None),

+                ("start", "0s", "30s", "1"),

+                ("start", "10s", "5s", None),

+                ("start", "20s", None, None),

+            ),

+        )

+

+    def test_1_nonrecurring_start_op_with_timeout(self):

+        self.assert_command_success(

+            resource_ops=(

+                ("monitor", "60s", None, None),

+                ("start", "0s", "40s", None),

+            ),

+        )

+

+

+@mock.patch.object(

+    settings,

+    "pacemaker_api_result_schema",

+    rc("pcmk_api_rng/api-result.rng"),

+)

+class TestUpdateScsiDevicesFailures(TestCase):

+    # pylint: disable=too-many-public-methods

+    def setUp(self):

+        self.env_assist, self.config = get_env_tools(self)

+

+        self.existing_nodes = ["node1", "node2", "node3"]

+        self.existing_corosync_nodes = [

+            node_fixture(node, node_id)

+            for node_id, node in enumerate(self.existing_nodes, 1)

+        ]

+        self.config.env.set_known_nodes(self.existing_nodes)

+

+    def test_pcmk_doesnt_support_digests(self):

+        self.config.runner.pcmk.is_resource_digests_supported(

+            is_supported=False

+        )

+        self.env_assist.assert_raise_library_error(

+            lambda: stonith.update_scsi_devices(

+                self.env_assist.get_env(), SCSI_STONITH_ID, ()

+            ),

+            [

+                fixture.error(

+                    reports.codes.STONITH_RESTARTLESS_UPDATE_OF_SCSI_DEVICES_NOT_SUPPORTED,

+                )

+            ],

+            expected_in_processor=False,

+        )

+

+    def test_devices_cannot_be_empty(self):

+        self.config.runner.pcmk.is_resource_digests_supported()

+        self.config.runner.cib.load(resources=fixture_scsi())

+        self.env_assist.assert_raise_library_error(

+            lambda: stonith.update_scsi_devices(

+                self.env_assist.get_env(), SCSI_STONITH_ID, ()

+            )

+        )

+        self.env_assist.assert_reports(

+            [

+                fixture.error(

+                    reports.codes.INVALID_OPTION_VALUE,

+                    option_name="devices",

+                    option_value="",

+                    allowed_values=None,

+                    cannot_be_empty=True,

+                    forbidden_characters=None,

+                )

+            ]

+        )

+

+    def test_nonexistant_id(self):

+        self.config.runner.pcmk.is_resource_digests_supported()

+        self.config.runner.cib.load(resources=fixture_scsi())

+        self.env_assist.assert_raise_library_error(

+            lambda: stonith.update_scsi_devices(

+                self.env_assist.get_env(), "non-existent-id", DEVICES_2

+            )

+        )

+        self.env_assist.assert_reports(

+            [

+                fixture.error(

+                    reports.codes.ID_NOT_FOUND,

+                    id="non-existent-id",

+                    expected_types=["primitive"],

+                    context_type="cib",

+                    context_id="",

+                )

+            ]

+        )

+

+    def test_not_a_resource_id(self):

+        self.config.runner.pcmk.is_resource_digests_supported()

+        self.config.runner.cib.load(resources=fixture_scsi())

+        self.env_assist.assert_raise_library_error(

+            lambda: stonith.update_scsi_devices(

+                self.env_assist.get_env(),

+                f"{SCSI_STONITH_ID}-instance_attributes-devices",

+                DEVICES_2,

+            )

+        )

+        self.env_assist.assert_reports(

+            [

+                fixture.error(

+                    reports.codes.ID_BELONGS_TO_UNEXPECTED_TYPE,

+                    id=f"{SCSI_STONITH_ID}-instance_attributes-devices",

+                    expected_types=["primitive"],

+                    current_type="nvpair",

+                )

+            ]

+        )

+

+    def test_not_supported_resource_type(self):

+        self.config.runner.pcmk.is_resource_digests_supported()

+        self.config.runner.cib.load(resources=fixture_scsi())

+        self.env_assist.assert_raise_library_error(

+            lambda: stonith.update_scsi_devices(

+                self.env_assist.get_env(), "dummy", DEVICES_2

+            )

+        )

+        self.env_assist.assert_reports(

+            [

+                fixture.error(

+                    reports.codes.STONITH_RESTARTLESS_UPDATE_UNSUPPORTED_AGENT,

+                    resource_id="dummy",

+                    resource_type="Dummy",

+                    supported_stonith_types=["fence_scsi"],

+                )

+            ]

+        )

+

+    def test_devices_option_missing(self):

+        self.config.runner.pcmk.is_resource_digests_supported()

+        self.config.runner.cib.load(resources=fixture_scsi(devices=None))

+        self.env_assist.assert_raise_library_error(

+            lambda: stonith.update_scsi_devices(

+                self.env_assist.get_env(), SCSI_STONITH_ID, DEVICES_2

+            )

+        )

+        self.env_assist.assert_reports(

+            [

+                fixture.error(

+                    reports.codes.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM,

+                    reason=(

+                        "no devices option configured for stonith device "

+                        f"'{SCSI_STONITH_ID}'"

+                    ),

+                    reason_type=reports.const.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM_REASON_OTHER,

+                )

+            ]

+        )

+

+    def test_devices_option_empty(self):

+        self.config.runner.pcmk.is_resource_digests_supported()

+        self.config.runner.cib.load(resources=fixture_scsi(devices=""))

+        self.env_assist.assert_raise_library_error(

+            lambda: stonith.update_scsi_devices(

+                self.env_assist.get_env(), SCSI_STONITH_ID, DEVICES_2

+            )

+        )

+        self.env_assist.assert_reports(

+            [

+                fixture.error(

+                    reports.codes.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM,

+                    reason=(

+                        "no devices option configured for stonith device "

+                        f"'{SCSI_STONITH_ID}'"

+                    ),

+                    reason_type=reports.const.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM_REASON_OTHER,

+                )

+            ]

+        )

+

+    def test_stonith_resource_is_not_running(self):

+        self.config.runner.pcmk.is_resource_digests_supported()

+        self.config.runner.cib.load(resources=fixture_scsi())

+        self.config.runner.pcmk.load_state(

+            resources=FIXTURE_CRM_MON_RES_STOPPED, nodes=FIXTURE_CRM_MON_NODES

+        )

+        self.env_assist.assert_raise_library_error(

+            lambda: stonith.update_scsi_devices(

+                self.env_assist.get_env(), SCSI_STONITH_ID, DEVICES_2

+            ),

+            [

+                fixture.error(

+                    reports.codes.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM,

+                    reason=f"resource '{SCSI_STONITH_ID}' is not running on any node",

+                    reason_type=reports.const.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM_REASON_NOT_RUNNING,

+                )

+            ],

+            expected_in_processor=False,

+        )

+

+    def test_stonith_resource_is_running_on_more_than_one_node(self):

+        self.config.runner.pcmk.is_resource_digests_supported()

+        self.config.runner.cib.load(resources=fixture_scsi())

+        self.config.runner.pcmk.load_state(

+            resources=FIXTURE_CRM_MON_RES_RUNNING_2, nodes=FIXTURE_CRM_MON_NODES

+        )

+        self.env_assist.assert_raise_library_error(

+            lambda: stonith.update_scsi_devices(

+                self.env_assist.get_env(), SCSI_STONITH_ID, DEVICES_2

+            ),

+            [

+                fixture.error(

+                    reports.codes.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM,

+                    reason=(

+                        f"resource '{SCSI_STONITH_ID}' is running on more than "

+                        "1 node"

+                    ),

+                    reason_type=reports.const.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM_REASON_OTHER,

+                )

+            ],

+            expected_in_processor=False,

+        )

+

+    def test_lrm_op_missing_digest_attributes(self):

+        devices = ",".join(DEVICES_2)

+        self.config.runner.pcmk.is_resource_digests_supported()

+        self.config.runner.cib.load(

+            resources=fixture_scsi(),

+            status=_fixture_status_lrm_ops_base(

+                SCSI_STONITH_ID,

+                f'<lrm_rsc_op id="{SCSI_STONITH_ID}_last" operation="start"/>',

+            ),

+        )

+        self.config.runner.pcmk.load_state(

+            resources=FIXTURE_CRM_MON_RES_RUNNING_1, nodes=FIXTURE_CRM_MON_NODES

+        )

+        self.config.runner.pcmk.resource_digests(

+            SCSI_STONITH_ID,

+            SCSI_NODE,

+            name="start.op.digests",

+            stdout=fixture_digests_xml(

+                SCSI_STONITH_ID,

+                SCSI_NODE,

+                devices=devices,

+            ),

+            args=[f"devices={devices}"],

+        )

+        self.env_assist.assert_raise_library_error(

+            lambda: stonith.update_scsi_devices(

+                self.env_assist.get_env(), SCSI_STONITH_ID, DEVICES_2

+            ),

+            [

+                fixture.error(

+                    reports.codes.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM,

+                    reason="no digests attributes in lrm_rsc_op element",

+                    reason_type=reports.const.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM_REASON_OTHER,

+                )

+            ],

+            expected_in_processor=False,

+        )

+

+    def test_crm_resource_digests_missing(self):

+        devices = ",".join(DEVICES_2)

+        self.config.runner.pcmk.is_resource_digests_supported()

+        self.config.runner.cib.load(

+            resources=fixture_scsi(),

+            status=_fixture_status_lrm_ops_base(

+                SCSI_STONITH_ID,

+                (

+                    f'

+                    'operation="start" op-restart-digest="somedigest" />'

+                ),

+            ),

+        )

+        self.config.runner.pcmk.load_state(

+            resources=FIXTURE_CRM_MON_RES_RUNNING_1, nodes=FIXTURE_CRM_MON_NODES

+        )

+        self.config.runner.pcmk.resource_digests(

+            SCSI_STONITH_ID,

+            SCSI_NODE,

+            name="start.op.digests",

+            stdout=fixture_digests_xml(

+                SCSI_STONITH_ID,

+                SCSI_NODE,

+                devices=devices,

+            ),

+            args=[f"devices={devices}"],

+        )

+        self.env_assist.assert_raise_library_error(

+            lambda: stonith.update_scsi_devices(

+                self.env_assist.get_env(), SCSI_STONITH_ID, DEVICES_2

+            ),

+            [

+                fixture.error(

+                    reports.codes.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM,

+                    reason=(

+                        "necessary digest for 'op-restart-digest' attribute is "

+                        "missing"

+                    ),

+                    reason_type=reports.const.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM_REASON_OTHER,

+                )

+            ],

+            expected_in_processor=False,

+        )

+

+    def test_no_lrm_start_op(self):

+        self.config.runner.pcmk.is_resource_digests_supported()

+        self.config.runner.cib.load(

+            resources=fixture_scsi(),

+            status=_fixture_status_lrm_ops(SCSI_STONITH_ID, lrm_start_ops=()),

+        )

+        self.config.runner.pcmk.load_state(

+            resources=FIXTURE_CRM_MON_RES_RUNNING_1, nodes=FIXTURE_CRM_MON_NODES

+        )

+        self.env_assist.assert_raise_library_error(

+            lambda: stonith.update_scsi_devices(

+                self.env_assist.get_env(), SCSI_STONITH_ID, DEVICES_2

+            ),

+            [

+                fixture.error(

+                    reports.codes.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM,

+                    reason=(

+                        "lrm_rsc_op element for start operation was not found"

+                    ),

+                    reason_type=reports.const.STONITH_RESTARTLESS_UPDATE_UNABLE_TO_PERFORM_REASON_OTHER,

+                )

+            ],