qontract-reconcile 0.10.1rc513__py3-none-any.whl → 0.10.1rc515__py3-none-any.whl

reconcile/saas_auto_promotions_manager/merge_request_manager/reconciler.py

@@ -0,0 +1,207 @@
+from collections.abc import Iterable
+from dataclasses import dataclass
+from typing import Optional
+
+from reconcile.saas_auto_promotions_manager.merge_request_manager.mr_parser import (
+    OpenMergeRequest,
+)
+
+MSG_MISSING_UNBATCHING = (
+    "Closing this MR because it failed MR check and isn't marked as un-batchable yet."
+)
+MSG_OUTDATED_CONTENT = "Closing this MR because it has out-dated content."
+MSG_NEW_BATCH = "Closing this MR in favor of a new batch MR."
+
+
+@dataclass
+class Promotion:
+    content_hashes: set[str]
+    channels: set[str]
+
+
+@dataclass
+class Deletion:
+    mr: OpenMergeRequest
+    reason: str
+
+
+@dataclass
+class Addition:
+    content_hashes: set[str]
+    channels: set[str]
+    batchable: bool
+
+
+@dataclass
+class Diff:
+    deletions: list[Deletion]
+    additions: list[Addition]
+
+
+class Reconciler:
+    """
+    The reconciler calculates a Diff. I.e., which MRs need to be opened (Addition)
+    and which MRs need to be closed (Deletion). The reconciler has no external
+    dependencies and does not interact with VCS. The reconciler expects to be
+    given the desired state (which promotions do we want) and the current state
+    (the currently open MRs) in order to calculate the Diff.
+    """
+
+    def __init__(self) -> None:
+        self._desired_promotions: Iterable[Promotion] = []
+        self._open_mrs: Iterable[OpenMergeRequest] = []
+
+    def _unbatch(self, diff: Diff) -> None:
+        """
+        We optimistically batch MRs together that didnt run through MR check yet.
+        Vast majority of auto-promotion MRs are succeeding checks, so we can stay optimistic.
+        In the rare case of an MR failing the check, we want to unbatch it.
+        I.e., we open a dedicated MR for each channel in the batched MR, mark the new MRs as non-batchable
+        and close the old batched MR. By doing so, we ensure that unrelated MRs are not blocking each other.
+        Unbatched MRs are marked and will never be batched again.
+        """
+        open_mrs_after_unbatching: list[OpenMergeRequest] = []
+        unbatchable_hashes: set[str] = set()
+        falsely_marked_batchable_hashes: set[str] = set()
+        for mr in self._open_mrs:
+            if not mr.is_batchable:
+                unbatchable_hashes.update(mr.content_hashes)
+                open_mrs_after_unbatching.append(mr)
+            elif mr.failed_mr_check:
+                falsely_marked_batchable_hashes.update(mr.content_hashes)
+                diff.deletions.append(
+                    Deletion(
+                        mr=mr,
+                        reason=MSG_MISSING_UNBATCHING,
+                    )
+                )
+            else:
+                open_mrs_after_unbatching.append(mr)
+        self._open_mrs = open_mrs_after_unbatching
+
+        desired_promotions_after_unbatching: list[Promotion] = []
+        for promotion in self._desired_promotions:
+            if promotion.content_hashes.issubset(unbatchable_hashes):
+                continue
+            elif promotion.content_hashes.issubset(falsely_marked_batchable_hashes):
+                diff.additions.append(
+                    Addition(
+                        content_hashes=promotion.content_hashes,
+                        channels=promotion.channels,
+                        batchable=False,
+                    )
+                )
+                continue
+            else:
+                desired_promotions_after_unbatching.append(promotion)
+        self._desired_promotions = desired_promotions_after_unbatching
+
+    def _remove_outdated(self, diff: Diff) -> None:
+        """
+        We want to be sure that the open MRs are still addressing desired content.
+        We close MRs that are not addressing any content hash in a desired promotion.
+        """
+        all_desired_content_hashes: set[str] = set()
+        for promotion in self._desired_promotions:
+            all_desired_content_hashes.update(promotion.content_hashes)
+
+        open_mrs_after_deletion: list[OpenMergeRequest] = []
+        for mr in self._open_mrs:
+            if mr.content_hashes.issubset(all_desired_content_hashes):
+                open_mrs_after_deletion.append(mr)
+                continue
+            diff.deletions.append(
+                Deletion(
+                    mr=mr,
+                    reason=MSG_OUTDATED_CONTENT,
+                )
+            )
+        self._open_mrs = open_mrs_after_deletion
+
+    def _batch_remaining_mrs(self, diff: Diff, batch_limit: int) -> None:
+        """
+        Remaining desired promotions should be batched together
+        if they are not addressed yet by a valid open MR.
+
+        We do not want to let MR batches grow infinitely,
+        as constant change of a batch might starve MRs that
+        are already part of the batch.
+        In order for MRs to not grow infinitely, we apply a
+        BATCH_LIMIT per MR, i.e., a maximum number of hashes
+        that can be batched together.
+        """
+        submitted_content_hashes: set[str] = set()
+        for open_mr in self._open_mrs:
+            submitted_content_hashes.update(open_mr.content_hashes)
+
+        unsubmitted_promotions = [
+            prom
+            for prom in self._desired_promotions
+            if not prom.content_hashes.issubset(submitted_content_hashes)
+        ]
+
+        if not unsubmitted_promotions:
+            return
+
+        batch_with_capacity: Optional[OpenMergeRequest] = None
+        for mr in self._open_mrs:
+            if len(mr.content_hashes) < batch_limit:
+                batch_with_capacity = mr
+                # Note, there should always only be maximum one batch with capacity available
+                break
+
+        if batch_with_capacity:
+            # We disassemble the batch to its promotions
+            # can be added to new batch(es)
+            unsubmitted_promotions.append(
+                Promotion(
+                    content_hashes=batch_with_capacity.content_hashes,
+                    channels=batch_with_capacity.channels,
+                )
+            )
+            # Lets close the current batch so remaining promotions can
+            # be aggregated in new batch(es)
+            diff.deletions.append(
+                Deletion(
+                    mr=batch_with_capacity,
+                    reason=MSG_NEW_BATCH,
+                )
+            )
+
+        batched_mr = Addition(
+            content_hashes=set(),
+            channels=set(),
+            batchable=True,
+        )
+
+        for promotion in unsubmitted_promotions:
+            batched_mr.content_hashes.update(promotion.content_hashes)
+            batched_mr.channels.update(promotion.channels)
+            if len(batched_mr.content_hashes) >= batch_limit:
+                # Note, we might also be above the batch limit, but thats ok.
+                # We only ensure that we create a new batch now and dont grow further.
+                diff.additions.append(batched_mr)
+                batched_mr = Addition(
+                    content_hashes=set(),
+                    channels=set(),
+                    batchable=True,
+                )
+        if batched_mr.content_hashes:
+            diff.additions.append(batched_mr)
+
+    def reconcile(
+        self,
+        desired_promotions: Iterable[Promotion],
+        open_mrs: Iterable[OpenMergeRequest],
+        batch_limit: int,
+    ) -> Diff:
+        self._open_mrs = open_mrs
+        self._desired_promotions = desired_promotions
+        diff = Diff(
+            deletions=[],
+            additions=[],
+        )
+        self._unbatch(diff=diff)
+        self._remove_outdated(diff=diff)
+        self._batch_remaining_mrs(diff=diff, batch_limit=batch_limit)
+        return diff

reconcile/saas_auto_promotions_manager/merge_request_manager/renderer.py

@@ -1,3 +1,4 @@
+import hashlib
 from collections.abc import Mapping
 from copy import deepcopy
 from typing import Any
@@ -18,18 +19,17 @@ from reconcile.saas_auto_promotions_manager.subscriber import Subscriber
 PROMOTION_DATA_SEPARATOR = (
     "**SAPM Data - DO NOT MANUALLY CHANGE ANYTHING BELOW THIS LINE**"
 )
-SAPM_VERSION = "1.1.0"
-SAPM_LABEL = "SAPM"
+SAPM_VERSION = "2.0.0"
 CONTENT_HASHES = "content_hashes"
 CHANNELS_REF = "channels"
 IS_BATCHABLE = "is_batchable"
 VERSION_REF = "sapm_version"
-SAPM_DESC = f"""
+SAPM_DESC = """
 This is an auto-promotion triggered by app-interface's [saas-auto-promotions-manager](https://github.com/app-sre/qontract-reconcile/tree/master/reconcile/saas_auto_promotions_manager) (SAPM).
 The channel(s) mentioned in the MR title had an event.
 This MR promotes all subscribers with auto-promotions for these channel(s).
 
-Please **do not remove the {SAPM_LABEL} label** from this MR.
+Please **do not remove or change any label** from this MR.
 
 Parts of this description are used by SAPM to manage auto-promotions.
 """
@@ -152,8 +152,11 @@ class Renderer:
 {VERSION_REF}: {SAPM_VERSION}
         """
 
-    def render_title(self, channels: str) -> str:
-        return f"[SAPM] auto-promotion for {channels}"
+    def render_title(self, is_draft: bool, channels: str) -> str:
+        content = f"[SAPM] auto-promotion ID {int(hashlib.sha256(channels.encode('utf-8')).hexdigest(), 16) % 10**8}"
+        if is_draft:
+            return f"Draft: {content}"
+        return content
 
 
 def _parse_expression(expression: str) -> Any:

reconcile/test/saas_auto_promotions_manager/merge_request_manager/merge_request_manager/conftest.py

@@ -11,16 +11,22 @@ from gitlab.v4.objects import ProjectMergeRequest
 from reconcile.gql_definitions.fragments.saas_target_namespace import (
     SaasTargetNamespace,
 )
+from reconcile.saas_auto_promotions_manager.merge_request_manager.merge_request_manager_v2 import (
+    SAPM_LABEL,
+)
 from reconcile.saas_auto_promotions_manager.merge_request_manager.mr_parser import (
     MRParser,
     OpenMergeRequest,
 )
+from reconcile.saas_auto_promotions_manager.merge_request_manager.reconciler import (
+    Diff,
+    Reconciler,
+)
 from reconcile.saas_auto_promotions_manager.merge_request_manager.renderer import (
     CHANNELS_REF,
     CONTENT_HASHES,
     IS_BATCHABLE,
     PROMOTION_DATA_SEPARATOR,
-    SAPM_LABEL,
     SAPM_VERSION,
     VERSION_REF,
     Renderer,
@@ -32,17 +38,16 @@ from reconcile.saas_auto_promotions_manager.subscriber import (
 from reconcile.utils.vcs import VCS, MRCheckStatus
 
 from .data_keys import (
+    CHANNEL,
     DESCRIPTION,
     HAS_CONFLICTS,
     LABELS,
     OPEN_MERGE_REQUESTS,
     PIPELINE_RESULTS,
+    REF,
     SUBSCRIBER_BATCHABLE,
     SUBSCRIBER_CHANNELS,
     SUBSCRIBER_CONTENT_HASH,
-    SUBSCRIBER_DESIRED_CONFIG_HASHES,
-    SUBSCRIBER_DESIRED_REF,
-    SUBSCRIBER_TARGET_NAMESPACE,
     SUBSCRIBER_TARGET_PATH,
 )
 
@@ -96,7 +101,7 @@ def vcs_builder(
 
 
 @pytest.fixture
-def mr_parser_builder() -> Callable[[Mapping], MRParser]:
+def mr_parser_builder() -> Callable[[Iterable[OpenMergeRequest]], MRParser]:
     def builder(data: Iterable[OpenMergeRequest]) -> MRParser:
         mr_parser = create_autospec(spec=MRParser)
         mr_parser.retrieve_open_mrs.side_effect = [data]
@@ -105,24 +110,32 @@ def mr_parser_builder() -> Callable[[Mapping], MRParser]:
     return builder
 
 
+@pytest.fixture
+def reconciler_builder() -> Callable[[Diff], Reconciler]:
+    def builder(data: Diff) -> Reconciler:
+        reconciler = create_autospec(spec=Reconciler)
+        reconciler.reconcile.side_effect = [data]
+        return reconciler
+
+    return builder
+
+
 @pytest.fixture
 def subscriber_builder(
     saas_target_namespace_builder: Callable[..., SaasTargetNamespace],
-):
+) -> Callable[..., Subscriber]:
     def builder(data: Mapping) -> Subscriber:
         subscriber = Subscriber(
             saas_name="",
             template_name="",
-            target_namespace=saas_target_namespace_builder(
-                data.get(SUBSCRIBER_TARGET_NAMESPACE, {})
-            ),
+            target_namespace=saas_target_namespace_builder({}),
             ref="",
             target_file_path=data.get(SUBSCRIBER_TARGET_PATH, ""),
             use_target_config_hash=True,
         )
-        subscriber.desired_hashes = data.get(SUBSCRIBER_DESIRED_CONFIG_HASHES, [])
-        subscriber.desired_ref = data.get(SUBSCRIBER_DESIRED_REF, "")
-        for channel in data.get(SUBSCRIBER_CHANNELS, []):
+        subscriber.desired_hashes = []
+        subscriber.desired_ref = data.get(REF, "")
+        for channel in data.get(CHANNEL, []):
             subscriber.channels.append(
                 Channel(
                     name=channel,

reconcile/test/saas_auto_promotions_manager/merge_request_manager/merge_request_manager/data_keys.py

@@ -14,3 +14,6 @@ SUBSCRIBER_BATCHABLE = "sub_batchable"
 HAS_CONFLICTS = "has_conflicts"
 SUBSCRIBER_TARGET_NAMESPACE = "subscriber_target_namespace"
 PIPELINE_RESULTS = "pipeline_results"
+
+CHANNEL = "channel"
+REF = "ref"

reconcile/test/saas_auto_promotions_manager/merge_request_manager/merge_request_manager/test_merge_request_manager.py

@@ -1,185 +1,83 @@
-from collections.abc import (
-    Callable,
-    Iterable,
-    Mapping,
-)
-from unittest.mock import create_autospec
+from collections.abc import Callable
+from unittest.mock import call, create_autospec
 
-import pytest
 from gitlab.v4.objects import ProjectMergeRequest
 
-from reconcile.saas_auto_promotions_manager.merge_request_manager.merge_request_manager import (
-    MergeRequestManager,
+from reconcile.saas_auto_promotions_manager.merge_request_manager.merge_request_manager_v2 import (
+    MergeRequestManagerV2,
 )
 from reconcile.saas_auto_promotions_manager.merge_request_manager.mr_parser import (
     MRParser,
     OpenMergeRequest,
 )
+from reconcile.saas_auto_promotions_manager.merge_request_manager.reconciler import (
+    Addition,
+    Deletion,
+    Diff,
+    Reconciler,
+)
 from reconcile.saas_auto_promotions_manager.merge_request_manager.renderer import (
     Renderer,
 )
 from reconcile.saas_auto_promotions_manager.subscriber import Subscriber
-from reconcile.utils.vcs import VCS
-
-from .data_keys import (
-    SUBSCRIBER_CHANNELS,
-    SUBSCRIBER_DESIRED_CONFIG_HASHES,
-    SUBSCRIBER_DESIRED_REF,
-    SUBSCRIBER_TARGET_NAMESPACE,
-    SUBSCRIBER_TARGET_PATH,
+from reconcile.test.saas_auto_promotions_manager.merge_request_manager.merge_request_manager.data_keys import (
+    CHANNEL,
+    REF,
 )
+from reconcile.utils.vcs import VCS
 
 
-def test_close_old_content(
-    mr_parser_builder: Callable[[Iterable], MRParser],
-    renderer: Renderer,
-    subscriber_builder: Callable[[Mapping], Subscriber],
-):
-    subscribers = [
-        subscriber_builder({
-            SUBSCRIBER_TARGET_NAMESPACE: {"path": "namespace1"},
-            SUBSCRIBER_TARGET_PATH: "target1",
-            SUBSCRIBER_DESIRED_REF: "new_sha",
-            SUBSCRIBER_DESIRED_CONFIG_HASHES: [],
-            SUBSCRIBER_CHANNELS: ["channel-a", "channel-b"],
-        })
-    ]
-
-    open_mrs = [
-        OpenMergeRequest(
-            raw=create_autospec(ProjectMergeRequest),
-            content_hashes="oldcontent",
-            channels="channel-a,channel-b",
-            failed_mr_check=False,
-            is_batchable=True,
-        )
-    ]
-    mr_parser = mr_parser_builder(open_mrs)
+def test_reconcile(
+    reconciler_builder: Callable[[Diff], Reconciler],
+    subscriber_builder: Callable[..., Subscriber],
+) -> None:
     vcs = create_autospec(spec=VCS)
-    merge_request_manager = MergeRequestManager(
-        vcs=vcs,
-        mr_parser=mr_parser,
-        renderer=renderer,
-    )
-    merge_request_manager.housekeeping()
-    merge_request_manager.create_promotion_merge_requests(subscribers=subscribers)
-
-    # There is an open MR with old content for that subscriber
-    # Close old content and open new MR with new content
-    vcs.close_app_interface_mr.assert_called_once()
-    vcs.open_app_interface_merge_request.assert_called_once()
-
-
-@pytest.mark.parametrize(
-    "hash_prefix, hash_suffix, channel_prefix, channel_suffix",
-    [
-        ("", "", "", ""),
-        ("hashprefix,", "", "", ""),
-        ("", ",hashsuffix", "", ""),
-        ("", "", "channelprefix,", ""),
-        ("", "", "", ",channelsuffix"),
-        ("a,", ",b", "c,", ",d"),
-    ],
-)
-def test_merge_request_already_opened(
-    mr_parser_builder: Callable[[Iterable], MRParser],
-    renderer: Renderer,
-    subscriber_builder: Callable[[Mapping], Subscriber],
-    hash_prefix: str,
-    hash_suffix: str,
-    channel_prefix: str,
-    channel_suffix: str,
-):
-    subscriber_channel = "channel-a"
+    mr_parser = create_autospec(spec=MRParser)
+    renderer = create_autospec(spec=Renderer)
     subscribers = [
         subscriber_builder({
-            SUBSCRIBER_TARGET_NAMESPACE: {"path": "namespace1"},
-            SUBSCRIBER_TARGET_PATH: "target1",
-            SUBSCRIBER_DESIRED_REF: "new_sha",
-            SUBSCRIBER_DESIRED_CONFIG_HASHES: [],
-            SUBSCRIBER_CHANNELS: [subscriber_channel],
+            CHANNEL: ["chan1,chan2"],
+            REF: "hash1",
         })
     ]
-    content_hash = Subscriber.combined_content_hash(subscribers=subscribers)
-
-    open_mrs = [
-        OpenMergeRequest(
+    deletion = Deletion(
+        mr=OpenMergeRequest(
             raw=create_autospec(spec=ProjectMergeRequest),
-            content_hashes=f"{hash_prefix}{content_hash}{hash_suffix}",
-            channels=f"{channel_prefix}{subscriber_channel}{channel_suffix}",
-            is_batchable=True,
+            channels=set(),
+            content_hashes=set(),
             failed_mr_check=False,
-        )
-    ]
-    mr_parser = mr_parser_builder(open_mrs)
-
-    vcs = create_autospec(spec=VCS)
-    merge_request_manager = MergeRequestManager(
-        vcs=vcs,
-        mr_parser=mr_parser,
-        renderer=renderer,
+            is_batchable=True,
+        ),
+        reason="some reason.",
     )
-    merge_request_manager.housekeeping()
-    merge_request_manager.create_promotion_merge_requests(subscribers=subscribers)
-
-    # There is already an open merge request for this subscriber content
-    # Do not open another one
-    vcs.close_app_interface_mr.assert_not_called()
-    vcs.open_app_interface_merge_request.assert_not_called()
 
-
-@pytest.mark.parametrize(
-    "hash_prefix, hash_suffix, channel_prefix, channel_suffix",
-    [
-        ("", "", "", ""),
-        ("hashprefix,", "", "", ""),
-        ("", ",hashsuffix", "", ""),
-        ("", "", "channelprefix,", ""),
-        ("", "", "", ",channelsuffix"),
-        ("a,", ",b", "c,", ",d"),
-    ],
-)
-def test_ignore_unrelated_channels(
-    mr_parser_builder: Callable[[Iterable], MRParser],
-    renderer: Renderer,
-    subscriber_builder: Callable[[Mapping], Subscriber],
-    hash_prefix: str,
-    hash_suffix: str,
-    channel_prefix: str,
-    channel_suffix: str,
-):
-    subscribers = [
-        subscriber_builder({
-            SUBSCRIBER_TARGET_NAMESPACE: {"path": "namespace1"},
-            SUBSCRIBER_TARGET_PATH: "target1",
-            SUBSCRIBER_DESIRED_REF: "new_sha",
-            SUBSCRIBER_DESIRED_CONFIG_HASHES: [],
-            SUBSCRIBER_CHANNELS: ["channel-a"],
-        })
-    ]
-    content_hash = Subscriber.combined_content_hash(subscribers=subscribers)
-
-    open_mrs = [
-        OpenMergeRequest(
-            raw=create_autospec(spec=ProjectMergeRequest),
-            content_hashes=f"{hash_prefix}{content_hash}{hash_suffix}",
-            channels=f"{channel_prefix}other-channel{channel_suffix}",
-            is_batchable=True,
-            failed_mr_check=False,
+    additions = [
+        Addition(
+            content_hashes={Subscriber.combined_content_hash(subscribers=subscribers)},
+            channels={"chan1,chan2"},
+            batchable=True,
         )
     ]
-    mr_parser = mr_parser_builder(open_mrs)
 
-    vcs = create_autospec(spec=VCS)
-    merge_request_manager = MergeRequestManager(
+    reconciler = reconciler_builder(
+        Diff(
+            deletions=[deletion],
+            additions=additions,
+        )
+    )
+    manager = MergeRequestManagerV2(
         vcs=vcs,
         mr_parser=mr_parser,
+        reconciler=reconciler,
         renderer=renderer,
     )
-    merge_request_manager.housekeeping()
-    merge_request_manager.create_promotion_merge_requests(subscribers=subscribers)
 
-    # There is already an open merge request for this subscriber content
-    # Do not open another one, because the channels do not match
-    vcs.close_app_interface_mr.assert_not_called()
-    vcs.open_app_interface_merge_request.assert_called_once()
+    manager.reconcile(subscribers=subscribers)
+
+    assert len(manager._sapm_mrs) == len(additions)
+    vcs.close_app_interface_mr.assert_has_calls([
+        call(deletion.mr.raw, deletion.reason),
+    ])
+    vcs.open_app_interface_merge_request.assert_has_calls([
+        call(mr) for mr in manager._sapm_mrs
+    ])

reconcile/test/saas_auto_promotions_manager/merge_request_manager/merge_request_manager/test_mr_parser.py

@@ -6,6 +6,9 @@ from unittest.mock import call
 
 from gitlab.v4.objects import ProjectMergeRequest
 
+from reconcile.saas_auto_promotions_manager.merge_request_manager.merge_request_manager_v2 import (
+    SAPM_LABEL,
+)
 from reconcile.saas_auto_promotions_manager.merge_request_manager.mr_parser import (
     MRParser,
 )
@@ -14,7 +17,6 @@ from reconcile.saas_auto_promotions_manager.merge_request_manager.renderer impor
     CONTENT_HASHES,
     IS_BATCHABLE,
     PROMOTION_DATA_SEPARATOR,
-    SAPM_LABEL,
     SAPM_VERSION,
     VERSION_REF,
 )
@@ -60,17 +62,17 @@ def test_valid_parsing(
     mr_parser = MRParser(
         vcs=vcs,
     )
-    open_mrs = mr_parser.retrieve_open_mrs()
+    open_mrs = mr_parser.retrieve_open_mrs(label=SAPM_LABEL)
     assert len(open_mrs) == 2
 
     assert open_mrs[0].raw == expectd_mrs[0]
-    assert open_mrs[0].channels == "channel0"
-    assert open_mrs[0].content_hashes == "hash0"
+    assert open_mrs[0].channels == {"channel0"}
+    assert open_mrs[0].content_hashes == {"hash0"}
     assert open_mrs[0].is_batchable
 
     assert open_mrs[1].raw == expectd_mrs[1]
-    assert open_mrs[1].channels == "channel1"
-    assert open_mrs[1].content_hashes == "hash1"
+    assert open_mrs[1].channels == {"channel1"}
+    assert open_mrs[1].content_hashes == {"hash1"}
     assert not open_mrs[1].is_batchable
 
 
@@ -107,7 +109,7 @@ def test_labels_filter(
     mr_parser = MRParser(
         vcs=vcs,
     )
-    open_mrs = mr_parser.retrieve_open_mrs()
+    open_mrs = mr_parser.retrieve_open_mrs(label=SAPM_LABEL)
     assert len(open_mrs) == 1
     assert open_mrs[0].raw == expectd_mrs[0]
 
@@ -261,7 +263,7 @@ def test_bad_mrs(
         ),
     ]
 
-    open_mrs = mr_parser.retrieve_open_mrs()
+    open_mrs = mr_parser.retrieve_open_mrs(label=SAPM_LABEL)
     assert len(open_mrs) == 0
     vcs.close_app_interface_mr.assert_has_calls(expected_calls)  # type: ignore[attr-defined]
     assert vcs.close_app_interface_mr.call_count == len(expected_calls)  # type: ignore[attr-defined]
@@ -299,7 +301,7 @@ def test_remove_duplicates(
     mr_parser = MRParser(
         vcs=vcs,
     )
-    open_mrs = mr_parser.retrieve_open_mrs()
+    open_mrs = mr_parser.retrieve_open_mrs(label=SAPM_LABEL)
     vcs.close_app_interface_mr.assert_has_calls([  # type: ignore[attr-defined]
         call(
             expected_mrs[1],