cumulusci-plus 5.0.0__py3-none-any.whl

cumulusci/core/dependencies/dependencies.py

@@ -0,0 +1,273 @@
+import itertools
+import logging
+import os
+from typing import List, Optional, Type
+
+from pydantic import AnyUrl, ValidationError
+
+import cumulusci.core.dependencies.base as base_dependency
+from cumulusci.core.config import OrgConfig
+from cumulusci.core.config.project_config import BaseProjectConfig
+from cumulusci.core.exceptions import DependencyParseError
+from cumulusci.salesforce_api.package_install import (
+    DEFAULT_PACKAGE_RETRY_OPTIONS,
+    PackageInstallOptions,
+    install_package_by_namespace_version,
+    install_package_by_version_id,
+)
+from cumulusci.utils import download_extract_zip
+
+logger = logging.getLogger(__name__)
+
+
+class PackageNamespaceVersionDependency(base_dependency.StaticDependency):
+    """Static dependency on a package identified by namespace and version number."""
+
+    namespace: str
+    version: str
+    package_name: Optional[str] = None
+    version_id: Optional[str] = None
+
+    password_env_name: Optional[str] = None
+
+    @property
+    def package(self):
+        return self.package_name or self.namespace or "Unknown Package"
+
+    def install(
+        self,
+        context: BaseProjectConfig,
+        org: OrgConfig,
+        options: Optional[PackageInstallOptions] = None,
+        retry_options=None,
+    ):
+        if not options:
+            options = PackageInstallOptions()
+        if self.password_env_name:
+            options.password = os.environ.get(self.password_env_name)
+        if not retry_options:
+            retry_options = DEFAULT_PACKAGE_RETRY_OPTIONS
+
+        if "Beta" in self.version:
+            version_string = self.version.split(" ")[0]
+            beta = self.version.split(" ")[-1].strip(")")
+            version = f"{version_string}b{beta}"
+        else:
+            version = self.version
+
+        if org.has_minimum_package_version(
+            self.namespace,
+            version,
+        ):
+            context.logger.info(
+                f"{self} or a newer version is already installed; skipping."
+            )
+            return
+
+        context.logger.info(f"Installing {self.description}")
+        install_package_by_namespace_version(
+            context,
+            org,
+            self.namespace,
+            self.version,
+            options,
+            retry_options=retry_options,
+        )
+
+    @property
+    def name(self):
+        return f"Install {self.package} {self.version}"
+
+    @property
+    def description(self):
+        return f"{self.package} {self.version}"
+
+
+class PackageVersionIdDependency(base_dependency.StaticDependency):
+    """Static dependency on a package identified by 04t version id."""
+
+    version_id: str
+    package_name: Optional[str] = None
+    version_number: Optional[str] = None
+
+    password_env_name: Optional[str] = None
+
+    @property
+    def package(self):
+        return self.package_name or "Unknown Package"
+
+    def install(
+        self,
+        context: BaseProjectConfig,
+        org: OrgConfig,
+        options: Optional[PackageInstallOptions] = None,
+        retry_options=None,
+    ):
+        if not options:
+            options = PackageInstallOptions()
+        if self.password_env_name:
+            options.password = os.environ.get(self.password_env_name)
+        if not retry_options:
+            retry_options = DEFAULT_PACKAGE_RETRY_OPTIONS
+
+        if any(
+            self.version_id == v.id
+            for v in itertools.chain(*org.installed_packages.values())
+        ):
+            context.logger.info(
+                f"{self} or a newer version is already installed; skipping."
+            )
+            return
+
+        context.logger.info(f"Installing {self.description}")
+        install_package_by_version_id(
+            context,
+            org,
+            self.version_id,
+            options,
+            retry_options=retry_options,
+        )
+
+    @property
+    def name(self):
+        return f"Install {self.description}"
+
+    @property
+    def description(self):
+        return f"{self.package} {self.version_number or self.version_id}"
+
+
+class UnmanagedZipURLDependency(base_dependency.UnmanagedDependency):
+    """Static dependency on unmanaged metadata downloaded as a zip file from a URL."""
+
+    zip_url: AnyUrl
+
+    def _get_zip_src(self, context: BaseProjectConfig):
+        # We don't pass `subfolder` to download_extract_github_from_repo()
+        # because we need to get the whole ref in order to
+        # correctly handle any permutation of MDAPI/SFDX format,
+        # with or without a subfolder specified.
+
+        # install() will take care of that for us.
+
+        return download_extract_zip(self.zip_url)
+
+    @property
+    def name(self):
+        subfolder = f"/{self.subfolder}" if self.subfolder else ""
+        return f"Deploy {self.zip_url} {subfolder}"
+
+    @property
+    def description(self):
+        subfolder = f"/{self.subfolder}" if self.subfolder else ""
+        return f"{self.zip_url} {subfolder}"
+
+
+#### Definition of dependency classes ####
+
+AVAILABLE_DEPENDENCY_CLASSES = [
+    PackageVersionIdDependency,
+    PackageNamespaceVersionDependency,
+    UnmanagedZipURLDependency,
+]
+
+
+def add_dependency_class(new_class: Type[base_dependency.Dependency]) -> None:
+    """
+    Adds a new dependency class to the global list if it's not already present.
+    Args:
+        new_class: The dependency class to add.
+    """
+    if new_class not in AVAILABLE_DEPENDENCY_CLASSES:
+        AVAILABLE_DEPENDENCY_CLASSES.append(new_class)
+        logger.debug(f"dependency_config: Added '{new_class}'.")
+    else:
+        logger.debug(f"dependency_config: '{new_class}' already exists.")
+
+
+def parse_dependency(dep_dict: dict[str, str]) -> Optional[base_dependency.Dependency]:
+    """Parse a single dependency specification in the form of a dict
+    into a concrete Dependency subclass.
+
+    Returns None if the given dict cannot be parsed."""
+
+    # The order in which we attempt parsing is significant.
+    # GitHubDynamicDependency has an optional `ref` field, but we want
+    # any dependencies with a populated `ref` to be parsed as static deps.
+
+    # We also want PackageVersionIdDependency to match before
+    # PackageNamespaceVersionDependency, which can also accept a `version_id`.
+
+    for dependency_class in AVAILABLE_DEPENDENCY_CLASSES:
+        try:
+            dep = dependency_class.parse_obj(dep_dict)
+            if dep:
+                return dep
+        except ValidationError:
+            pass
+
+
+def parse_dependencies(
+    deps: Optional[List[dict[str, str]]]
+) -> List[base_dependency.Dependency]:
+    """Convert a list of dependency specifications in the form of dicts
+    (as defined in `cumulusci.yml`) and parse each into a concrete Dependency subclass.
+
+    Throws DependencyParseError if a dict cannot be parsed."""
+    parsed_deps = []
+    for dep in deps or []:
+        parsed = parse_dependency(dep)
+        if parsed is None:
+            raise DependencyParseError(f"Unable to parse dependency: {dep}")
+        parsed_deps.append(parsed)
+    return parsed_deps
+
+
+#### Definition of dependency pins classes ####
+
+AVAILABLE_DEPENDENCY_PIN_CLASSES = []
+
+
+def parse_pins(pins: Optional[List[dict]]) -> List[base_dependency.DependencyPin]:
+    """Convert a list of dependency pin specifications in the form of dicts
+    (as defined in `cumulusci.yml`) and parse each into a concrete DependencyPin subclass.
+
+    Throws DependencyParseError if a dict cannot be parsed."""
+    parsed_pins = []
+    for pin in pins or []:
+        parsed = parse_dependency_pin(pin)
+        if parsed is None:
+            raise DependencyParseError(f"Unable to parse dependency pin: {pin}")
+        parsed_pins.append(parsed)
+
+    return parsed_pins
+
+
+def add_dependency_pin_class(new_class: Type[base_dependency.DependencyPin]) -> None:
+    """
+    Adds a new dependency pin class to the global list if it's not already present.
+    Args:
+        new_class: The dependency pin class to add.
+    """
+    if new_class not in AVAILABLE_DEPENDENCY_PIN_CLASSES:
+        AVAILABLE_DEPENDENCY_PIN_CLASSES.append(new_class)
+        logger.info(f"dependency_pin_config: Added '{new_class}'.")
+    else:
+        logger.warning(f"dependency_pin_config: '{new_class}' already exists.")
+
+
+def parse_dependency_pin(
+    pin_dict: dict[str, str]
+) -> Optional[base_dependency.DependencyPin]:
+    """Parse a single dependency pin specification in the form of a dict
+    into a concrete DependencyPin subclass.
+
+    Returns None if the given dict cannot be parsed."""
+
+    for dependency_pin_class in AVAILABLE_DEPENDENCY_PIN_CLASSES:
+        try:
+            pin = dependency_pin_class.parse_obj(pin_dict)
+            if pin:
+                return pin
+        except ValidationError:
+            pass

cumulusci/core/dependencies/github.py

@@ -0,0 +1,177 @@
+import logging
+from abc import ABC
+from functools import lru_cache
+from typing import Optional, Type
+
+from pydantic import root_validator
+from pydantic.networks import AnyUrl
+
+import cumulusci.core.dependencies.base as base_dependency
+from cumulusci.core.exceptions import DependencyResolutionError, GithubApiNotFoundError
+from cumulusci.utils.git import split_repo_url
+from cumulusci.vcs.github.adapter import GitHubRepository
+
+logger = logging.getLogger(__name__)
+
+VCS_GITHUB = "github"
+
+
+@lru_cache(50)
+def get_github_repo(project_config, url) -> GitHubRepository:
+    from cumulusci.vcs.github.service import VCSService, get_github_service_for_url
+
+    vcs_service: Optional[VCSService] = get_github_service_for_url(project_config, url)
+
+    if vcs_service is None:
+        raise DependencyResolutionError(
+            f"Could not find a GitHub service for URL: {url}"
+        )
+
+    try:
+        repo = vcs_service.get_repository(options={"repository_url": url})
+        if repo is None:
+            raise GithubApiNotFoundError(f"Get GitHub Repository found None. {url}")
+        return repo
+    except GithubApiNotFoundError as e:
+        raise DependencyResolutionError(
+            f"Could not find a GitHub repository at {url}: {e}"
+        )
+
+
+def _validate_github_parameters(values):
+    if values.get("repo_owner") or values.get("repo_name"):
+        logger.warning(
+            "The repo_name and repo_owner keys are deprecated. Please use the github key."
+        )
+
+    assert (
+        values.get("url")
+        or values.get("github")
+        or (values.get("repo_owner") and values.get("repo_name"))
+    ), "Must specify `github` or `repo_owner` and `repo_name`"
+
+    # Populate the `github` property if not already populated.
+    if not values.get("github") and values.get("repo_name"):
+        values["github"] = values[
+            "url"
+        ] = f"https://github.com/{values['repo_owner']}/{values['repo_name']}"
+        values.pop("repo_owner")
+        values.pop("repo_name")
+
+    return values
+
+
+def _sync_github_and_url(values):
+    # If only github is provided, set url to github
+    if values.get("github") and not values.get("url"):
+        values["url"] = values["github"]
+    # If only url is provided, set github to url
+    elif values.get("url") and not values.get("github"):
+        values["github"] = values["url"]
+    return values
+
+
+class GitHubDependencyPin(base_dependency.VcsDependencyPin):
+    """Model representing a request to pin a GitHub dependency to a specific tag"""
+
+    github: str
+
+    @property
+    def vcsTagResolver(self):  # -> Type["AbstractTagResolver"]:
+        from cumulusci.core.dependencies.github_resolvers import (  # Circular imports
+            GitHubTagResolver,
+        )
+
+        return GitHubTagResolver
+
+    @root_validator(pre=True)
+    def sync_vcs_and_url(cls, values):
+        """Defined vcs should be assigned to url"""
+        return _sync_github_and_url(values)
+
+
+GitHubDependencyPin.update_forward_refs()
+
+
+class BaseGitHubDependency(base_dependency.BaseVcsDynamicDependency, ABC):
+    """Base class for dynamic dependencies that reference a GitHub repo."""
+
+    github: Optional[AnyUrl] = None
+    vcs: str = VCS_GITHUB
+    pin_class = GitHubDependencyPin
+
+    repo_owner: Optional[str] = None  # Deprecated - use full URL
+    repo_name: Optional[str] = None  # Deprecated - use full URL
+
+    @root_validator
+    def check_deprecated_fields(cls, values):
+        if values.get("repo_owner") or values.get("repo_name"):
+            logger.warning(
+                "The dependency keys `repo_owner` and `repo_name` are deprecated. Use the full repo URL with the `github` key instead."
+            )
+        return values
+
+    @root_validator
+    def validate_github_parameters(cls, values):
+        return _validate_github_parameters(values)
+
+    @root_validator(pre=True)
+    def sync_vcs_and_url(cls, values):
+        """Defined vcs should be assigned to url"""
+        return _sync_github_and_url(values)
+
+
+class GitHubDynamicSubfolderDependency(
+    BaseGitHubDependency, base_dependency.VcsDynamicSubfolderDependency
+):
+    """A dependency expressed by a reference to a subfolder of a GitHub repo, which needs
+    to be resolved to a specific ref. This is always an unmanaged dependency."""
+
+    @property
+    def unmanagedVcsDependency(self) -> Type["UnmanagedGitHubRefDependency"]:
+        """A human-readable description of the dependency."""
+        return UnmanagedGitHubRefDependency
+
+
+class GitHubDynamicDependency(
+    BaseGitHubDependency, base_dependency.VcsDynamicDependency
+):
+    """A dependency expressed by a reference to a GitHub repo, which needs
+    to be resolved to a specific ref and/or package version."""
+
+    @property
+    def unmanagedVcsDependency(self) -> Type["UnmanagedGitHubRefDependency"]:
+        """A human-readable description of the dependency."""
+        return UnmanagedGitHubRefDependency
+
+    def get_repo(self, context, url) -> "GitHubRepository":
+        return get_github_repo(context, url)
+
+
+class UnmanagedGitHubRefDependency(base_dependency.UnmanagedVcsDependency):
+    """Static dependency on unmanaged metadata in a specific GitHub ref and subfolder."""
+
+    repo_owner: Optional[str] = None
+    repo_name: Optional[str] = None
+
+    # or
+    github: Optional[AnyUrl] = None
+
+    def get_repo(self, context, url) -> "GitHubRepository":
+        return get_github_repo(context, url)
+
+    @property
+    def package_name(self) -> str:
+        repo_owner, repo_name = split_repo_url((str(self.github)))
+        package_name = f"{repo_owner}/{repo_name} {self.subfolder}"
+        return package_name
+
+    @root_validator
+    def validate(cls, values):
+        return _validate_github_parameters(values)
+
+    @root_validator(pre=True)
+    def sync_vcs_and_url(cls, values):
+        """Defined vcs should be assigned to url"""
+
+        return _sync_github_and_url(values)

cumulusci/core/dependencies/github_resolvers.py

@@ -0,0 +1,244 @@
+import abc
+from typing import Any, List, Optional
+
+from cumulusci.core.config.project_config import BaseProjectConfig
+from cumulusci.core.dependencies.github import (
+    VCS_GITHUB,
+    BaseGitHubDependency,
+    get_github_repo,
+)
+from cumulusci.core.dependencies.resolvers import (
+    AbstractReleaseTagResolver,
+    AbstractTagResolver,
+    AbstractUnmanagedHeadResolver,
+    AbstractVcsCommitStatusPackageResolver,
+    AbstractVcsReleaseBranchResolver,
+    DependencyResolutionStrategy,
+)
+from cumulusci.core.exceptions import DependencyResolutionError
+from cumulusci.utils.git import get_feature_branch_name
+from cumulusci.vcs.bootstrap import find_repo_feature_prefix
+from cumulusci.vcs.github.adapter import GitHubBranch, GitHubRepository
+
+
+class GitHubTagResolver(AbstractTagResolver):
+    """Resolver that identifies a ref by a specific GitHub tag."""
+
+    name = "GitHub Tag Resolver"
+    vcs = VCS_GITHUB
+
+    def get_repo(
+        self, context: BaseProjectConfig, url: Optional[str]
+    ) -> GitHubRepository:
+        return get_github_repo(context, url)
+
+
+class GitHubReleaseTagResolver(AbstractReleaseTagResolver):
+    """Resolver that identifies a ref by finding the latest GitHub release."""
+
+    name = "GitHub Release Resolver"
+    vcs = VCS_GITHUB
+
+    def get_repo(
+        self, context: BaseProjectConfig, url: Optional[str]
+    ) -> GitHubRepository:
+        return get_github_repo(context, url)
+
+
+class GitHubBetaReleaseTagResolver(GitHubReleaseTagResolver):
+    """Resolver that identifies a ref by finding the latest GitHub release, including betas."""
+
+    name = "GitHub Release Resolver (Betas)"
+    include_beta = True
+
+
+class GitHubUnmanagedHeadResolver(AbstractUnmanagedHeadResolver):
+    """Resolver that identifies a ref by finding the latest commit on the main branch."""
+
+    name = "GitHub Unmanaged Resolver"
+    vcs = VCS_GITHUB
+
+    def get_repo(
+        self, context: BaseProjectConfig, url: Optional[str]
+    ) -> GitHubRepository:
+        return get_github_repo(context, url)
+
+
+class GitHubReleaseBranchCommitStatusResolver(AbstractVcsReleaseBranchResolver):
+    """Resolver that identifies a ref by finding a beta 2GP package version
+    in a commit status on a `feature/NNN` release branch."""
+
+    name = "GitHub Release Branch Commit Status Resolver"
+    commit_status_context = "2gp_context"
+    commit_status_default = "Build Feature Test Package"
+    branch_offset_start = 0
+    branch_offset_end = 1
+
+    def get_repo(
+        self, context: BaseProjectConfig, url: Optional[str]
+    ) -> GitHubRepository:
+        return get_github_repo(context, url)
+
+
+class GitHubReleaseBranchUnlockedResolver(AbstractVcsReleaseBranchResolver):
+    """Resolver that identifies a ref by finding an unlocked package version
+    in a commit status on a `feature/NNN` release branch."""
+
+    name = "GitHub Release Branch Unlocked Commit Status Resolver"
+    commit_status_context = "unlocked_context"
+    commit_status_default = "Build Unlocked Test Package"
+    branch_offset_start = 0
+    branch_offset_end = 1
+
+    def get_repo(
+        self, context: BaseProjectConfig, url: Optional[str]
+    ) -> GitHubRepository:
+        return get_github_repo(context, url)
+
+
+class GitHubPreviousReleaseBranchCommitStatusResolver(AbstractVcsReleaseBranchResolver):
+    """Resolver that identifies a ref by finding a beta 2GP package version
+    in a commit status on a `feature/NNN` release branch that is earlier
+    than the matching local release branch."""
+
+    name = "GitHub Previous Release Branch Commit Status Resolver"
+    commit_status_context = "2gp_context"
+    commit_status_default = "Build Feature Test Package"
+    branch_offset_start = 1
+    branch_offset_end = 3
+
+    def get_repo(
+        self, context: BaseProjectConfig, url: Optional[str]
+    ) -> GitHubRepository:
+        return get_github_repo(context, url)
+
+
+class GitHubPreviousReleaseBranchUnlockedResolver(AbstractVcsReleaseBranchResolver):
+    """Resolver that identifies a ref by finding an unlocked package version
+    in a commit status on a `feature/NNN` release branch that is earlier
+    than the matching local release branch."""
+
+    name = "GitHub Previous Release Branch Unlocked Commit Status Resolver"
+    commit_status_context = "unlocked_context"
+    commit_status_default = "Build Unlocked Test Package"
+    branch_offset_start = 1
+    branch_offset_end = 3
+
+    def get_repo(
+        self, context: BaseProjectConfig, url: Optional[str]
+    ) -> GitHubRepository:
+        return get_github_repo(context, url)
+
+
+class AbstractGitHubExactMatchCommitStatusResolver(
+    AbstractVcsCommitStatusPackageResolver, abc.ABC
+):
+    """Abstract base class for resolvers that identify a ref by finding a package version
+    in a commit status on a branch whose name matches the local branch."""
+
+    def get_repo(
+        self, context: BaseProjectConfig, url: Optional[str]
+    ) -> GitHubRepository:
+        return get_github_repo(context, url)
+
+    def get_branches(
+        self,
+        dep: BaseGitHubDependency,
+        context: BaseProjectConfig,
+    ) -> List[GitHubBranch]:
+        repo = self.get_repo(context, dep.url)
+        if not repo:
+            raise DependencyResolutionError(
+                f"Unable to access GitHub repository for {dep.url}"
+            )
+
+        try:
+            remote_branch_prefix = find_repo_feature_prefix(repo)
+        except Exception:
+            context.logger.info(
+                f"Could not find feature branch prefix or commit-status context for {repo.clone_url}. Unable to resolve package."
+            )
+            return []
+
+        # Attempt exact match
+        try:
+            branch = get_feature_branch_name(
+                context.repo_branch, context.project__git__prefix_feature
+            )
+            release_branch = repo.branch(f"{remote_branch_prefix}{branch}")
+        except Exception:
+            context.logger.info(f"Exact-match branch not found for {repo.clone_url}.")
+            return []
+
+        return [release_branch]
+
+
+class GitHubExactMatch2GPResolver(AbstractGitHubExactMatchCommitStatusResolver):
+    """Resolver that identifies a ref by finding a 2GP package version
+    in a commit status on a branch whose name matches the local branch."""
+
+    name = "GitHub Exact-Match Commit Status Resolver"
+    commit_status_context = "2gp_context"
+    commit_status_default = "Build Feature Test Package"
+
+
+class GitHubExactMatchUnlockedCommitStatusResolver(
+    AbstractGitHubExactMatchCommitStatusResolver
+):
+    """Resolver that identifies a ref by finding an unlocked package version
+    in a commit status on a branch whose name matches the local branch."""
+
+    name = "GitHub Exact-Match Unlocked Commit Status Resolver"
+    commit_status_context = "unlocked_context"
+    commit_status_default = "Build Unlocked Test Package"
+
+
+class AbstractGitHubDefaultBranchCommitStatusResolver(
+    AbstractVcsCommitStatusPackageResolver, abc.ABC
+):
+    """Abstract base class for resolvers that identify a ref by finding a beta package version
+    in a commit status on the repo's default branch."""
+
+    def get_repo(
+        self, context: BaseProjectConfig, url: Optional[str]
+    ) -> GitHubRepository:
+        return get_github_repo(context, url)
+
+    def get_branches(
+        self,
+        dep: BaseGitHubDependency,
+        context: BaseProjectConfig,
+    ) -> List[GitHubBranch]:
+        repo = self.get_repo(context, dep.url)
+
+        return [repo.branch(repo.default_branch)]
+
+
+class GitHubDefaultBranch2GPResolver(AbstractGitHubDefaultBranchCommitStatusResolver):
+    name = "GitHub Default Branch Commit Status Resolver"
+    commit_status_context = "2gp_context"
+    commit_status_default = "Build Feature Test Package"
+
+
+class GitHubDefaultBranchUnlockedCommitStatusResolver(
+    AbstractGitHubDefaultBranchCommitStatusResolver
+):
+    name = "GitHub Default Branch Unlocked Commit Status Resolver"
+    commit_status_context = "unlocked_context"
+    commit_status_default = "Build Unlocked Test Package"
+
+
+GITHUB_RESOLVER_CLASSES: dict[str, type[Any]] = {
+    DependencyResolutionStrategy.STATIC_TAG_REFERENCE: GitHubTagResolver,
+    DependencyResolutionStrategy.COMMIT_STATUS_EXACT_BRANCH: GitHubExactMatch2GPResolver,
+    DependencyResolutionStrategy.COMMIT_STATUS_RELEASE_BRANCH: GitHubReleaseBranchCommitStatusResolver,
+    DependencyResolutionStrategy.COMMIT_STATUS_PREVIOUS_RELEASE_BRANCH: GitHubPreviousReleaseBranchCommitStatusResolver,
+    DependencyResolutionStrategy.COMMIT_STATUS_DEFAULT_BRANCH: GitHubDefaultBranch2GPResolver,
+    DependencyResolutionStrategy.BETA_RELEASE_TAG: GitHubBetaReleaseTagResolver,
+    DependencyResolutionStrategy.RELEASE_TAG: GitHubReleaseTagResolver,
+    DependencyResolutionStrategy.UNMANAGED_HEAD: GitHubUnmanagedHeadResolver,
+    DependencyResolutionStrategy.UNLOCKED_EXACT_BRANCH: GitHubExactMatchUnlockedCommitStatusResolver,
+    DependencyResolutionStrategy.UNLOCKED_RELEASE_BRANCH: GitHubReleaseBranchUnlockedResolver,
+    DependencyResolutionStrategy.UNLOCKED_PREVIOUS_RELEASE_BRANCH: GitHubPreviousReleaseBranchUnlockedResolver,
+    DependencyResolutionStrategy.UNLOCKED_DEFAULT_BRANCH: GitHubDefaultBranchUnlockedCommitStatusResolver,
+}