qontract-reconcile 0.9.1rc298__py3-none-any.whl → 0.10.1.dev1203__py3-none-any.whl

reconcile/change_owners/decision.py

@@ -7,11 +7,13 @@ from dataclasses import dataclass
 from enum import Enum
 from typing import Any
 
-from reconcile.change_owners.bundle import FileRef
-from reconcile.change_owners.change_types import (
-    BundleFileChange,
-    ChangeTypeContext,
+from reconcile.change_owners.approver import (
+    Approver,
+    ApproverReachability,
 )
+from reconcile.change_owners.bundle import FileRef
+from reconcile.change_owners.change_types import ChangeTypeContext, DiffCoverage
+from reconcile.change_owners.changes import BundleFileChange
 from reconcile.change_owners.diff import Diff
 
 
@@ -20,17 +22,17 @@ class DecisionCommand(Enum):
     CANCEL_APPROVED = "/lgtm cancel"
     HOLD = "/hold"
     CANCEL_HOLD = "/hold cancel"
+    GOOD_TO_TEST = "/good-to-test"
 
 
 @dataclass
 class Decision:
-
     approver_name: str
     command: DecisionCommand
 
 
 def get_approver_decisions_from_mr_comments(
-    comments: Iterable[Mapping[str, Any]]
+    comments: Iterable[Mapping[str, Any]],
 ) -> list[Decision]:
     decisions: list[Decision] = []
     for c in sorted(comments, key=lambda k: k["created_at"]):
@@ -62,40 +64,74 @@ def get_approver_decisions_from_mr_comments(
 
 
 @dataclass
-class ChangeDecision:
+class ChangeResponsibles:
+    context: str
+    approvers: list[Approver]
+    approver_reachability: list[ApproverReachability] | None = None
+
 
+@dataclass
+class ChangeDecision:
     file: FileRef
     diff: Diff
     coverage: list[ChangeTypeContext]
+    coverable_by_fragment_decisions: bool = False
 
     def __post_init__(self) -> None:
         self.approve: dict[str, bool] = defaultdict(bool)
         self.hold: dict[str, bool] = defaultdict(bool)
+        self.context_auto_approval: dict[str, bool] = defaultdict(bool)
 
     def apply_decision(
         self, ctx: ChangeTypeContext, decision_cmd: DecisionCommand
-    ) -> None:
+    ) -> "ChangeDecision":
+        return self.apply_context_decision(ctx.context, decision_cmd)
+
+    def apply_context_decision(
+        self, context: str, decision_cmd: DecisionCommand
+    ) -> "ChangeDecision":
         if decision_cmd == DecisionCommand.APPROVED:
-            self.approve[ctx.context] = True
+            self.approve[context] = True
         elif decision_cmd == DecisionCommand.CANCEL_APPROVED:
-            self.approve[ctx.context] = False
+            self.approve[context] = False
         elif decision_cmd == DecisionCommand.HOLD:
-            self.hold[ctx.context] = True
+            self.hold[context] = True
         elif decision_cmd == DecisionCommand.CANCEL_HOLD:
-            self.hold[ctx.context] = False
+            self.hold[context] = False
+        return self
+
+    def auto_approve(self, ctx: ChangeTypeContext, decision: bool) -> None:
+        self.context_auto_approval[ctx.context] = decision
 
     def is_approved(self) -> bool:
-        return any(self.approve.values())
+        """
+        A diff is considered approved if
+        * at least one eligible approver party (context) approved it
+          OR
+        * ALL eligible approver parties (contexts) have issued an auto-approval
+
+        An approved diff does not imply that the MR is approved. There might still be holds.
+        """
+        return any(self.approve.values()) or (
+            len(self.context_auto_approval) > 0
+            and all(self.context_auto_approval.values())
+        )
 
     def is_held(self) -> bool:
         return any(self.hold.values())
 
-    def deduped_coverage(self) -> list[ChangeTypeContext]:
-        unique_coverage = {}
+    @property
+    def change_responsibles(self) -> list[ChangeResponsibles]:
+        unique_contexts: dict[str, ChangeResponsibles] = {}
         for ctx in self.coverage:
-            key = f"{ctx.change_type_processor.name}:{ctx.context}"
-            unique_coverage[key] = ctx
-        return list(unique_coverage.values())
+            if ctx.context in unique_contexts:
+                continue
+            unique_contexts[ctx.context] = ChangeResponsibles(
+                context=ctx.context,
+                approvers=ctx.approvers,
+                approver_reachability=ctx.approver_reachability,
+            )
+        return list(unique_contexts.values())
 
 
 def apply_decisions_to_changes(
@@ -110,32 +146,75 @@ def apply_decisions_to_changes(
     to generate the coverage report and to reason about the approval
     state of the MR.
     """
+
     diff_decisions = []
     for c in changes:
         for d in c.diff_coverage:
-            change_decision = ChangeDecision(
-                file=c.fileref, diff=d.diff, coverage=d.coverage
+            diff_decisions.append(
+                _apply_decision_to_diff(
+                    c,
+                    d,
+                    approver_decisions,
+                    auto_approver_usernames,
+                )
             )
-            diff_decisions.append(change_decision)
-            for change_type_context in change_decision.coverage:
-                # approvers of a disabled change-type are ignored
-                if change_type_context.disabled:
-                    continue
-
-                # autoapproval authors
-                if (
-                    len(change_type_context.approvers) == 1
-                    and change_type_context.approvers[0].org_username
-                    in auto_approver_usernames
-                ):
-                    change_decision.apply_decision(
-                        change_type_context, DecisionCommand.APPROVED
-                    )
-                    continue
 
-                for decision in approver_decisions:
-                    if change_type_context.includes_approver(decision.approver_name):
-                        change_decision.apply_decision(
-                            change_type_context, decision.command
-                        )
     return diff_decisions
+
+
+def _apply_decision_to_diff(
+    c: BundleFileChange,
+    diff: DiffCoverage,
+    approver_decisions: Iterable[Decision],
+    auto_approver_usernames: set[str],
+) -> ChangeDecision:
+    approvers_decisions_by_name = {
+        d.approver_name: d.command for d in approver_decisions
+    }
+    change_decision = ChangeDecision(
+        file=c.fileref, diff=diff.diff, coverage=diff.coverage
+    )
+
+    # if the diff is splittable in parts, and each of these parts is covered by
+    # a change-type, then we consider the diff approved if all parts have
+    # been approved by their respective change-type approvers
+    if diff.diff_fragments and diff.is_covered_by_splits():
+        change_decision.coverable_by_fragment_decisions = True
+        fragment_decisions = [
+            _apply_decision_to_diff(
+                c, fragment, approver_decisions, auto_approver_usernames
+            )
+            for fragment in diff.diff_fragments
+        ]
+        if all(
+            fragment.is_approved() and not fragment.is_held()
+            for fragment in fragment_decisions
+        ):
+            change_decision.apply_context_decision(
+                "fragments", DecisionCommand.APPROVED
+            )
+
+    for change_type_context in diff.coverage:
+        # approvers of a disabled change-type are ignored
+        if change_type_context.disabled:
+            continue
+
+        # a context is auto-approved if
+        #  * it has only one approver
+        #  * the approver is an auto-approver
+        #  * the approver has not issued an explicit hold decision
+        context_auto_approved = (
+            len(change_type_context.approvers) == 1
+            and change_type_context.approvers[0].org_username in auto_approver_usernames
+            and approvers_decisions_by_name.get(
+                change_type_context.approvers[0].org_username
+            )
+            != DecisionCommand.HOLD
+        )
+        change_decision.auto_approve(change_type_context, context_auto_approved)
+
+        for decision in approver_decisions:
+            if change_type_context.includes_approver(decision.approver_name):
+                change_decision.apply_decision(change_type_context, decision.command)
+
+    return change_decision

reconcile/change_owners/diff.py

@@ -1,19 +1,15 @@
 import copy
 import json
-import re
-from collections.abc import MutableMapping
 from dataclasses import dataclass
 from enum import Enum
 from functools import reduce
-from typing import (
-    Any,
-    Optional,
-)
+from typing import Any
 
 import jsonpath_ng
 from deepdiff import DeepDiff
 from deepdiff.helper import CannotCompare
 from deepdiff.model import DiffLevel
+from deepdiff.path import parse_path
 
 from reconcile.utils.jsonpath import parse_jsonpath
 
@@ -32,8 +28,8 @@ class Diff:
 
     path: jsonpath_ng.JSONPath
     diff_type: DiffType
-    old: Optional[Any]
-    new: Optional[Any]
+    old: Any | None
+    new: Any | None
 
     def create_subdiff(self, sub_path: jsonpath_ng.JSONPath) -> "Diff":
         if sub_path == self.path:
@@ -45,7 +41,7 @@ class Diff:
             absolute_sub_path = sub_path
         elif sub_path_str.startswith(self.path_str()):
             absolute_sub_path = parse_jsonpath(
-                f"${sub_path_str[len(self.path_str()):]}"
+                f"${sub_path_str[len(self.path_str()) :]}"
             )
         else:
             raise Exception(
@@ -60,40 +56,25 @@ class Diff:
             new=sub_new[0].value if len(sub_new) > 0 else None,
         )
 
-    def get_context_data_copy(self) -> Optional[Any]:
-        if self.diff_type in [DiffType.ADDED, DiffType.CHANGED]:
-            data_copy = copy.deepcopy(self.new)
-        elif self.diff_type == DiffType.REMOVED:
-            data_copy = copy.deepcopy(self.old)
-        else:
-            raise Exception(f"Unknown diff type {self.diff_type}")
-
-        # remove file metadata
-        if (
-            data_copy
-            and isinstance(data_copy, MutableMapping)
-            and self.path == jsonpath_ng.Root()
-        ):
-            if SCHEMA_FIELD in data_copy:
-                del data_copy[SCHEMA_FIELD]
-            if PATH_FIELD in data_copy:
-                del data_copy[PATH_FIELD]
-            if SHA256SUM_FIELD_NAME in data_copy:
-                del data_copy[SHA256SUM_FIELD_NAME]
-        return data_copy
+    def get_context_data_copy(self) -> Any | None:
+        if self.diff_type in {DiffType.ADDED, DiffType.CHANGED}:
+            return copy.deepcopy(self.new)
+        if self.diff_type == DiffType.REMOVED:
+            return copy.deepcopy(self.old)
+        raise Exception(f"Unknown diff type {self.diff_type}")
 
     def path_str(self) -> str:
         return str(self.path)
 
-    def old_value_repr(self) -> Optional[str]:
+    def old_value_repr(self) -> str | None:
         return self._value_repr(self.old)
 
-    def new_value_repr(self) -> Optional[str]:
+    def new_value_repr(self) -> str | None:
         return self._value_repr(self.new)
 
-    def _value_repr(self, value: Optional[Any]) -> Optional[str]:
+    def _value_repr(self, value: Any | None) -> str | None:
         if value:
-            if isinstance(value, (dict, list)):
+            if isinstance(value, dict | list):
                 return json.dumps(value, indent=2)
             return str(value)
         return value
@@ -103,7 +84,7 @@ IDENTIFIER_FIELD_NAME = "__identifier"
 REF_FIELD_NAME = "$ref"
 
 
-def _extract_identifier_from_object(obj: Any) -> Optional[str]:
+def _extract_identifier_from_object(obj: Any) -> str | None:
     if isinstance(obj, dict):
         if IDENTIFIER_FIELD_NAME in obj:
             return obj.get(IDENTIFIER_FIELD_NAME)
@@ -113,7 +94,7 @@ def _extract_identifier_from_object(obj: Any) -> Optional[str]:
 
 
 def compare_object_ctx_identifier(
-    x: Any, y: Any, level: Optional[DiffLevel] = None
+    x: Any, y: Any, level: DiffLevel | None = None
 ) -> bool:
     """
     this function helps the deepdiff library to decide if two objects are
@@ -150,12 +131,6 @@ def compare_object_ctx_identifier(
     raise CannotCompare() from None
 
 
-SCHEMA_FIELD = "$schema"
-PATH_FIELD = "path"
-SHA256SUM_FIELD_NAME = "$file_sha256sum"
-SHA256SUM_PATH = jsonpath_ng.parse(f"'{SHA256SUM_FIELD_NAME}'")
-
-
 def extract_diffs(old_file_content: Any, new_file_content: Any) -> list[Diff]:
     diffs: list[Diff] = []
     if old_file_content and new_file_content:
@@ -168,17 +143,15 @@ def extract_diffs(old_file_content: Any, new_file_content: Any) -> list[Diff]:
         )
 
         # handle changed values
-        diffs.extend(
-            [
-                Diff(
-                    path=deepdiff_path_to_jsonpath(path),
-                    diff_type=DiffType.CHANGED,
-                    old=change.get("old_value"),
-                    new=change.get("new_value"),
-                )
-                for path, change in deep_diff.get("values_changed", {}).items()
-            ]
-        )
+        diffs.extend([
+            Diff(
+                path=deepdiff_path_to_jsonpath(path),
+                diff_type=DiffType.CHANGED,
+                old=change.get("old_value"),
+                new=change.get("new_value"),
+            )
+            for path, change in deep_diff.get("values_changed", {}).items()
+        ])
         # handle property added
         for path in deep_diff.get("dictionary_item_added", []):
             jpath = deepdiff_path_to_jsonpath(path)
@@ -206,34 +179,36 @@ def extract_diffs(old_file_content: Any, new_file_content: Any) -> list[Diff]:
                 )
             )
         # handle added items
-        diffs.extend(
-            [
-                Diff(
-                    path=deepdiff_path_to_jsonpath(path),
-                    diff_type=DiffType.ADDED,
-                    old=None,
-                    new=change,
-                )
-                for path, change in deep_diff.get("iterable_item_added", {}).items()
-            ]
-        )
+        diffs.extend([
+            Diff(
+                path=deepdiff_path_to_jsonpath(path),
+                diff_type=DiffType.ADDED,
+                old=None,
+                new=change,
+            )
+            for path, change in deep_diff.get("iterable_item_added", {}).items()
+        ])
         # handle removed items
-        diffs.extend(
-            [
-                Diff(
-                    path=deepdiff_path_to_jsonpath(path),
-                    diff_type=DiffType.REMOVED,
-                    old=change,
-                    new=None,
-                )
-                for path, change in deep_diff.get("iterable_item_removed", {}).items()
-            ]
-        )
+        diffs.extend([
+            Diff(
+                path=deepdiff_path_to_jsonpath(path),
+                diff_type=DiffType.REMOVED,
+                old=change,
+                new=None,
+            )
+            for path, change in deep_diff.get("iterable_item_removed", {}).items()
+        ])
 
-        # if real changes have been detected, we are going to delete the
-        # diff for the checksum field
-        if len(diffs) > 1:
-            diffs = [d for d in diffs if str(d.path) != SHA256SUM_FIELD_NAME]
+        # handle type changes
+        diffs.extend([
+            Diff(
+                path=deepdiff_path_to_jsonpath(path),
+                diff_type=DiffType.CHANGED,
+                old=change.get("old_value"),
+                new=change.get("new_value"),
+            )
+            for path, change in deep_diff.get("type_changes", {}).items()
+        ])
 
     elif old_file_content:
         # file was deleted
@@ -259,9 +234,6 @@ def extract_diffs(old_file_content: Any, new_file_content: Any) -> list[Diff]:
     return diffs
 
 
-DEEP_DIFF_RE = re.compile(r"\['?(.*?)'?\]")
-
-
 def deepdiff_path_to_jsonpath(deep_diff_path: str) -> jsonpath_ng.JSONPath:
     """
     deepdiff's way to describe a path within a data structure differs from jsonpath.
@@ -274,17 +246,16 @@ def deepdiff_path_to_jsonpath(deep_diff_path: str) -> jsonpath_ng.JSONPath:
     if not deep_diff_path.startswith("root"):
         raise ValueError("a deepdiff path must start with 'root'")
 
-    def build_jsonpath_part(element: str) -> jsonpath_ng.JSONPath:
-        if element.isdigit():
-            return jsonpath_ng.Index(int(element))
-
-        if "." in element:
-            return jsonpath_ng.Fields(f"'{element}'")
-        return jsonpath_ng.Fields(element)
+    def build_jsonpath_part(element: str | int) -> jsonpath_ng.JSONPath:
+        match element:
+            case int():
+                return jsonpath_ng.Index(element)
+            case str():
+                if "." in element:
+                    return jsonpath_ng.Fields(f"'{element}'")
+                return jsonpath_ng.Fields(element)
 
-    path_parts = [
-        build_jsonpath_part(p) for p in DEEP_DIFF_RE.findall(deep_diff_path[4:])
-    ]
+    path_parts = [build_jsonpath_part(p) for p in parse_path(deep_diff_path)]
     if path_parts:
         return reduce(lambda a, b: a.child(b), path_parts)
     return jsonpath_ng.Root()

reconcile/change_owners/implicit_ownership.py

@@ -2,10 +2,11 @@ import logging
 
 from reconcile.change_owners.approver import ApproverResolver
 from reconcile.change_owners.change_types import (
-    BundleFileChange,
     ChangeTypeContext,
     ChangeTypeProcessor,
+    FileChange,
 )
+from reconcile.change_owners.changes import BundleFileChange
 from reconcile.gql_definitions.change_owners.queries.change_types import (
     ChangeTypeImplicitOwnershipJsonPathProviderV1,
 )
@@ -37,7 +38,12 @@ def change_type_contexts_for_implicit_ownership(
     for ctp in processors_with_implicit_ownership:
         for bc in bundle_changes:
             for ownership in ctp.find_context_file_refs(
-                bc.fileref, bc.old, bc.new, set()
+                change=FileChange(
+                    file_ref=bc.fileref,
+                    old=bc.old,
+                    new=bc.new,
+                ),
+                expansion_trail=set(),
             ):
                 for io in ctp.implicit_ownership:
                     if isinstance(io, ChangeTypeImplicitOwnershipJsonPathProviderV1):
@@ -66,18 +72,16 @@ def change_type_contexts_for_implicit_ownership(
                         )
                     )
                     if implicit_approvers:
-                        change_type_contexts.append(
-                            (
-                                bc,
-                                ChangeTypeContext(
-                                    change_type_processor=ctp,
-                                    context=f"implicit ownership - (via {ownership.change_type.name})",
-                                    origin=ownership.change_type.name,
-                                    approvers=implicit_approvers,
-                                    context_file=ownership.context_file_ref,
-                                ),
-                            )
-                        )
+                        change_type_contexts.append((
+                            bc,
+                            ChangeTypeContext(
+                                change_type_processor=ctp,
+                                context=f"implicit ownership - (via {ownership.change_type.name})",
+                                origin=ownership.change_type.name,
+                                approvers=implicit_approvers,
+                                context_file=ownership.context_file_ref,
+                            ),
+                        ))
 
     return change_type_contexts
 
@@ -86,8 +90,7 @@ def find_approvers_with_implicit_ownership_jsonpath_selector(
     bc: BundleFileChange,
     implicit_ownership: ChangeTypeImplicitOwnershipJsonPathProviderV1,
 ) -> set[str]:
-
-    context_file_content = bc.old or bc.new
+    context_file_content = bc.old_content_with_metadata or bc.new_content_with_metadata
     if context_file_content is None:
         # this can't happen. either bc.old or bc.new is set
         # but to make mypy happy, we need to check for None