cumulusci-plus 5.0.21__py3-none-any.whl → 5.0.35__py3-none-any.whl

cumulusci/tests/test_integration_infrastructure.py

@@ -35,6 +35,7 @@ def capture_orgid_using_task(create_task: callable, tmp_path: str) -> str:
 
 class TestIntegrationInfrastructure:
     "Test our two plugins for doing integration testing"
+
     remembered_cli_specified_org_id = None
 
     @pytest.mark.vcr()
@@ -42,6 +43,7 @@ class TestIntegrationInfrastructure:
         self, create_task, run_code_without_recording
     ):
         "Delete a VCR Cassette to ensure next test creates it."
+
         # only delete the cassette if we can replace it
         def delete_cassette():
             if first_cassette.exists():
@@ -81,7 +83,7 @@ class TestIntegrationInfrastructure:
 
         run_code_without_recording(setup)
 
-    def test_file_was_not_created(self, capture_orgid_using_task):
+    def test_file_was_not_created(self):
         filename = (
             Path(__file__).parent
             / "cassettes/TestIntegrationInfrastructure.test_run_code_without_recording.yaml"

cumulusci/tests/test_utils.py

@@ -453,31 +453,95 @@ Options\n------------------------------------------\n\n
     def test_inject_namespace__managed(self):
         logger = mock.Mock()
         name = "___NAMESPACE___test"
-        content = "%%%NAMESPACE%%%|%%%NAMESPACE_DOT%%%|%%%NAMESPACED_ORG%%%|%%%NAMESPACE_OR_C%%%|%%%NAMESPACED_ORG_OR_C%%%"
+        content = "%%%NAMESPACE%%%|%%%NAMESPACE_DOT%%%|%%%NAMESPACED_ORG%%%|%%%NAMESPACE_OR_C%%%|%%%NAMESPACED_ORG_OR_C%%%|%%%NAMESPACE_COLON%%%|%%%NAMESPACED_ORG_COLON%%%"
 
         name, content = utils.inject_namespace(
             name, content, namespace="ns", managed=True, logger=logger
         )
         assert name == "ns__test"
-        assert content == "ns__|ns.||ns|c"
+        assert content == "ns__|ns.||ns|c|ns:|"
 
     def test_inject_namespace__unmanaged(self):
         name = "___NAMESPACE___test"
-        content = "%%%NAMESPACE%%%|%%%NAMESPACE_DOT%%%|%%%NAMESPACED_ORG%%%|%%%NAMESPACE_OR_C%%%|%%%NAMESPACED_ORG_OR_C%%%"
+        content = "%%%NAMESPACE%%%|%%%NAMESPACE_DOT%%%|%%%NAMESPACED_ORG%%%|%%%NAMESPACE_OR_C%%%|%%%NAMESPACED_ORG_OR_C%%%|%%%NAMESPACE_COLON%%%|%%%NAMESPACED_ORG_COLON%%%"
 
         name, content = utils.inject_namespace(name, content, namespace="ns")
         assert name == "test"
-        assert content == "|||c|c"
+        assert content == "|||c|c||"
 
     def test_inject_namespace__namespaced_org(self):
         name = "___NAMESPACE___test"
-        content = "%%%NAMESPACE%%%|%%%NAMESPACE_DOT%%%|%%%NAMESPACED_ORG%%%|%%%NAMESPACE_OR_C%%%|%%%NAMESPACED_ORG_OR_C%%%"
+        content = "%%%NAMESPACE%%%|%%%NAMESPACE_DOT%%%|%%%NAMESPACED_ORG%%%|%%%NAMESPACE_OR_C%%%|%%%NAMESPACED_ORG_OR_C%%%|%%%NAMESPACE_COLON%%%|%%%NAMESPACED_ORG_COLON%%%"
 
         name, content = utils.inject_namespace(
             name, content, namespace="ns", managed=True, namespaced_org=True
         )
         assert name == "ns__test"
-        assert content == "ns__|ns.|ns__|ns|ns"
+        assert content == "ns__|ns.|ns__|ns|ns|ns:|ns:"
+
+    def test_inject_namespace__namespace_colon_managed(self):
+        """Test %%%NAMESPACE_COLON%%% token with managed=True"""
+        logger = mock.Mock()
+        name = "test"
+        content = "%%%NAMESPACE_COLON%%%component"
+
+        name, content = utils.inject_namespace(
+            name, content, namespace="ns", managed=True, logger=logger
+        )
+        assert content == "ns:component"
+        logger.info.assert_called()
+
+    def test_inject_namespace__namespace_colon_unmanaged(self):
+        """Test %%%NAMESPACE_COLON%%% token with managed=False"""
+        name = "test"
+        content = "%%%NAMESPACE_COLON%%%component"
+
+        name, content = utils.inject_namespace(
+            name, content, namespace="ns", managed=False
+        )
+        assert content == "component"
+
+    def test_inject_namespace__namespace_colon_no_namespace(self):
+        """Test %%%NAMESPACE_COLON%%% token with no namespace"""
+        name = "test"
+        content = "%%%NAMESPACE_COLON%%%component"
+
+        name, content = utils.inject_namespace(
+            name, content, namespace=None, managed=True
+        )
+        assert content == "component"
+
+    def test_inject_namespace__namespaced_org_colon(self):
+        """Test %%%NAMESPACED_ORG_COLON%%% token with namespaced_org=True"""
+        logger = mock.Mock()
+        name = "test"
+        content = "%%%NAMESPACED_ORG_COLON%%%component"
+
+        name, content = utils.inject_namespace(
+            name, content, namespace="ns", namespaced_org=True, logger=logger
+        )
+        assert content == "ns:component"
+        logger.info.assert_called()
+
+    def test_inject_namespace__namespaced_org_colon_false(self):
+        """Test %%%NAMESPACED_ORG_COLON%%% token with namespaced_org=False"""
+        name = "test"
+        content = "%%%NAMESPACED_ORG_COLON%%%component"
+
+        name, content = utils.inject_namespace(
+            name, content, namespace="ns", namespaced_org=False
+        )
+        assert content == "component"
+
+    def test_inject_namespace__namespaced_org_colon_no_namespace(self):
+        """Test %%%NAMESPACED_ORG_COLON%%% token with no namespace"""
+        name = "test"
+        content = "%%%NAMESPACED_ORG_COLON%%%component"
+
+        name, content = utils.inject_namespace(
+            name, content, namespace=None, namespaced_org=True
+        )
+        assert content == "component"
 
     def test_inject_namespace__filename_token_in_package_xml(self):
         name, content = utils.inject_namespace(

cumulusci/utils/__init__.py

@@ -42,7 +42,7 @@ BREW_DEPRECATION_MSG = (
     "brew uninstall cumulusci-plus\nbrew install pipx\npipx ensurepath\npipx install cumulusci-plus"
 )
 PIP_UPDATE_CMD = "pip install --upgrade cumulusci-plus"
-PIPX_UPDATE_CMD = "pipx upgrade cumulusci-plus"
+PIPX_UPDATE_CMD = "pipx install cumulusci-plus-azure-devops --include-deps --force"
 
 
 def parse_api_datetime(value):
@@ -245,6 +245,10 @@ def inject_namespace(
 ):
     """Replaces %%%NAMESPACE%%% in file content and ___NAMESPACE___ in file name
     with either '' if no namespace is provided or 'namespace__' if provided.
+
+    Also handles:
+    - %%%MANAGED_OR_NAMESPACED_ORG%%% and ___MANAGED_OR_NAMESPACED_ORG___ tokens
+      which are replaced with 'namespace__' if managed=True OR namespaced_org=True
     """
 
     # Handle namespace and filename tokens
@@ -264,7 +268,15 @@ def inject_namespace(
     # Handle tokens %%%NAMESPACED_ORG%%% and ___NAMESPACED_ORG___
     namespaced_org_token = "%%%NAMESPACED_ORG%%%"
     namespaced_org_file_token = "___NAMESPACED_ORG___"
-    namespaced_org = namespace + "__" if namespaced_org else ""
+    namespaced_org = (namespace + "__") if namespaced_org and namespace else ""
+
+    # Handle tokens %%%NAMESPACED_ORG_COLON%%%
+    namespaced_org_colon_token = "%%%NAMESPACED_ORG_COLON%%%"
+    namespaced_org_colon = (namespace + ":") if namespaced_org and namespace else ""
+
+    # Handle tokens %%%NAMESPACE_COLON%%%
+    namespace_colon_token = "%%%NAMESPACE_COLON%%%"
+    namespace_colon = (namespace + ":") if managed and namespace else ""
 
     # Handle token %%%NAMESPACE_OR_C%%% for lightning components
     namespace_or_c_token = "%%%NAMESPACE_OR_C%%%"
@@ -274,6 +286,13 @@ def inject_namespace(
     namespaced_org_or_c_token = "%%%NAMESPACED_ORG_OR_C%%%"
     namespaced_org_or_c = namespace if namespaced_org else "c"
 
+    # Handle new tokens %%%MANAGED_OR_NAMESPACED_ORG%%% and ___MANAGED_OR_NAMESPACED_ORG___
+    managed_or_namespaced_org_token = "%%%MANAGED_OR_NAMESPACED_ORG%%%"
+    managed_or_namespaced_org_file_token = "___MANAGED_OR_NAMESPACED_ORG___"
+    managed_or_namespaced_org = (
+        (namespace + "__") if ((managed) or (namespaced_org)) and namespace else ""
+    )
+
     orig_name = name
     prev_content = content
     content = content.replace(namespace_token, namespace_prefix)
@@ -317,6 +336,20 @@ def inject_namespace(
             f'  {name}: Replaced {namespaced_org_token} with "{namespaced_org}"'
         )
 
+    prev_content = content
+    content = content.replace(namespaced_org_colon_token, namespaced_org_colon)
+    if logger and content != prev_content:
+        logger.info(
+            f'  {name}: Replaced {namespaced_org_colon_token} with "{namespaced_org_colon}"'
+        )
+
+    prev_content = content
+    content = content.replace(namespace_colon_token, namespace_colon)
+    if logger and content != prev_content:
+        logger.info(
+            f'  {name}: Replaced {namespace_colon_token} with "{namespace_colon}"'
+        )
+
     prev_content = content
     content = content.replace(namespaced_org_or_c_token, namespaced_org_or_c)
     if logger and content != prev_content:
@@ -324,9 +357,20 @@ def inject_namespace(
             f'  {name}: Replaced {namespaced_org_or_c_token} with "{namespaced_org_or_c}"'
         )
 
+    # Replace new managed_or_namespaced_org token in content
+    prev_content = content
+    content = content.replace(
+        managed_or_namespaced_org_token, managed_or_namespaced_org
+    )
+    if logger and content != prev_content:
+        logger.info(
+            f'  {name}: Replaced {managed_or_namespaced_org_token} with "{managed_or_namespaced_org}"'
+        )
+
     # Replace namespace token in file name
     name = name.replace(filename_token, namespace_prefix)
     name = name.replace(namespaced_org_file_token, namespaced_org)
+    name = name.replace(managed_or_namespaced_org_file_token, managed_or_namespaced_org)
     if logger and name != orig_name:
         logger.info(f"  {orig_name}: renamed to {name}")
 
@@ -737,11 +781,12 @@ def get_tasks_with_options(project_config, frozen_options: frozenset):
     coordinator_opts = {}
     options = dict(frozen_options)
     for task_config in project_config.list_tasks():
-        if any(
-            key in options.keys()
-            for key in project_config.get_task(task_config["name"])
-            .get_class()
-            .task_options.keys()
-        ):
-            coordinator_opts[task_config["name"]] = options
+        task_keys = (
+            project_config.get_task(task_config["name"]).get_class().task_options.keys()
+        )
+        if any(key in options.keys() for key in task_keys):
+            # only assign options that are actually used by the task. This is to avoid passing options that are not used by the task.
+            coordinator_opts[task_config["name"]] = {
+                key: options[key] for key in options.keys() if key in task_keys
+            }
     return coordinator_opts

cumulusci/utils/classutils.py

@@ -1,9 +1,12 @@
-def get_all_subclasses(cls):
+from typing import Any, Dict, Set, Type
+
+
+def get_all_subclasses(cls: Type[Any]) -> Set[Type[Any]]:
     """Return all subclasses of the given class"""
     return set(cls.__subclasses__()).union(
         [s for c in cls.__subclasses__() for s in get_all_subclasses(c)]
     )
 
 
-def namedtuple_as_simple_dict(self):
+def namedtuple_as_simple_dict(self: Any) -> Dict[str, Any]:
     return {name: getattr(self, name, None) for name in self.__class__._fields}

cumulusci/utils/http/tests/cassettes/ManualEditTestCompositeParallelSalesforce.test_http_headers.yaml

@@ -1,32 +1,33 @@
 interactions:
-- request:
-    body: '{"compositeRequest": [{"referenceId": "CCI__RefId__0__", "method": "GET",
-      "url": "/services/data/v49.0/sobjects", "httpHeaders": {"If-Modified-Since":
-      "Thu, 03 Sep 2020 21:35:07 GMT"}}, {"referenceId": "CCI__RefId__1__", "method":
-      "GET", "url": "/services/data/v49.0/sobjects", "httpHeaders": {"If-Modified-Since":
-      "Thu, 03 Sep 2020 21:35:07 GMT"}}, {"referenceId": "CCI__RefId__2__", "method":
-      "GET", "url": "/services/data/v49.0/sobjects", "httpHeaders": {"If-Modified-Since":
-      "Thu, 03 Sep 2020 21:35:07 GMT"}}]}'
-    headers:
-      Request-Headers:
-      - Elided
-    method: POST
-    uri: https://orgname.my.salesforce.com/services/data/v49.0/composite
-  response:
-    body:
-      string: "{\n  \"compositeResponse\" : [ {\n    \"body\" : null,\n    \"httpHeaders\"
-        : {\n      \"ETag\" : \"\\\"baf7f695\\\"\",\n      \"Last-Modified\" : \"Fri,
-        14 Aug 2020 20:53:02 GMT\"\n    },\n    \"httpStatusCode\" : 304,\n    \"referenceId\"
-        : \"CCI__RefId__0__\"\n  }, {\n    \"body\" : null,\n    \"httpHeaders\" :
-        {\n      \"ETag\" : \"\\\"baf7f695\\\"\",\n      \"Last-Modified\" : \"Fri,
-        14 Aug 2020 20:53:02 GMT\"\n    },\n    \"httpStatusCode\" : 304,\n    \"referenceId\"
-        : \"CCI__RefId__1__\"\n  }, {\n    \"body\" : null,\n    \"httpHeaders\" :
-        {\n      \"ETag\" : \"\\\"baf7f695\\\"\",\n      \"Last-Modified\" : \"Fri,
-        14 Aug 2020 20:53:02 GMT\"\n    },\n    \"httpStatusCode\" : 304,\n    \"referenceId\"
-        : \"CCI__RefId__2__\"\n  } ]\n}"
-    headers:
-      Response-Headers: Elided
-    status:
-      code: 200
-      message: OK
+    - request:
+          body: '{"compositeRequest": [{"referenceId": "CCI__RefId__0__", "method": "GET",
+              "url": "/services/data/v49.0/sobjects", "httpHeaders": {"If-Modified-Since":
+              "Thu, 03 Sep 2020 21:35:07 GMT"}}, {"referenceId": "CCI__RefId__1__", "method":
+              "GET", "url": "/services/data/v49.0/sobjects", "httpHeaders": {"If-Modified-Since":
+              "Thu, 03 Sep 2020 21:35:07 GMT"}}, {"referenceId": "CCI__RefId__2__", "method":
+              "GET", "url": "/services/data/v49.0/sobjects", "httpHeaders": {"If-Modified-Since":
+              "Thu, 03 Sep 2020 21:35:07 GMT"}}]}'
+          headers:
+              Request-Headers:
+                  - Elided
+          method: POST
+          uri: https://orgname.my.salesforce.com/services/data/v49.0/composite
+      response:
+          body:
+              string:
+                  "{\n  \"compositeResponse\" : [ {\n    \"body\" : null,\n    \"httpHeaders\"
+                  : {\n      \"ETag\" : \"\\\"baf7f695\\\"\",\n      \"Last-Modified\" : \"Fri,
+                  14 Aug 2020 20:53:02 GMT\"\n    },\n    \"httpStatusCode\" : 304,\n    \"referenceId\"
+                  : \"CCI__RefId__0__\"\n  }, {\n    \"body\" : null,\n    \"httpHeaders\" :
+                  {\n      \"ETag\" : \"\\\"baf7f695\\\"\",\n      \"Last-Modified\" : \"Fri,
+                  14 Aug 2020 20:53:02 GMT\"\n    },\n    \"httpStatusCode\" : 304,\n    \"referenceId\"
+                  : \"CCI__RefId__1__\"\n  }, {\n    \"body\" : null,\n    \"httpHeaders\" :
+                  {\n      \"ETag\" : \"\\\"baf7f695\\\"\",\n      \"Last-Modified\" : \"Fri,
+                  14 Aug 2020 20:53:02 GMT\"\n    },\n    \"httpStatusCode\" : 304,\n    \"referenceId\"
+                  : \"CCI__RefId__2__\"\n  } ]\n}"
+          headers:
+              Response-Headers: Elided
+          status:
+              code: 200
+              message: OK
 version: 1

cumulusci/utils/options.py

@@ -2,7 +2,7 @@ import json
 from inspect import signature
 from typing import Any, Dict, List
 
-from pydantic import DirectoryPath, Field, FilePath, create_model
+from pydantic.v1 import DirectoryPath, Field, FilePath, create_model
 
 from cumulusci.core.exceptions import TaskOptionsError
 from cumulusci.utils.yaml.model_parser import CCIDictModel
@@ -95,6 +95,8 @@ class ListOfStringsOption(CCIOptionType):
 
     @classmethod
     def from_str(cls, v) -> List[str]:
+        if v is None or v == "":
+            return []
         return [s.strip() for s in v.split(",")]
 
 
@@ -106,6 +108,26 @@ class MappingOption(CCIOptionType):
         return parse_list_of_pairs_dict_arg(v)
 
 
+class PercentageOption(CCIOptionType):
+    """Parses a percentage from a string in format X%"""
+
+    @classmethod
+    def validate(cls, v):
+        """Validate and convert a value.
+        If its a string, parse it, else, just validate it.
+        """
+        try:
+            return v if isinstance(v, int) else int(v.rstrip("%"))
+        except ValueError:
+            raise TaskOptionsError(
+                "Value should be a percentage or integer (e.g. 90% or 90)"
+            )
+
+    @classmethod
+    def from_str(cls, v) -> int:
+        return v
+
+
 def parse_list_of_pairs_dict_arg(arg):
     """Process an arg in the format "aa:bb,cc:dd" """
     if isinstance(arg, dict):

cumulusci/utils/parallel/task_worker_queues/parallel_worker.py

@@ -7,7 +7,7 @@ from multiprocessing import Queue
 from pathlib import Path
 from traceback import format_exc
 
-from pydantic import BaseModel
+from pydantic.v1 import BaseModel
 
 from cumulusci.core.config import (
     BaseConfig,

cumulusci/utils/yaml/cumulusci_yml.py

@@ -9,8 +9,8 @@ from logging import getLogger
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Sequence, Union
 
-from pydantic import Field, root_validator, validator
-from pydantic.types import DirectoryPath
+from pydantic.v1 import Field, root_validator, validator
+from pydantic.v1.types import DirectoryPath
 from typing_extensions import Literal, TypedDict
 
 from cumulusci.core.enums import StrEnum
@@ -84,6 +84,11 @@ class Package(CCIDictModel):
     uninstall_class: str = None
     api_version: str = None
     metadata_package_id: str = None
+    apex_test_access: Optional[dict[str, Union[str, list[str]]]] = None
+    package_metadata_access: Optional[dict[str, Union[str, list[str]]]] = None
+    unpackaged_metadata_path: Optional[
+        Union[str, List[str], Dict[str, Union[str, List[str]]]]
+    ] = None
 
 
 class Test(CCIDictModel):
@@ -321,7 +326,6 @@ class ErrorDict(TypedDict):
 
 def _log_yaml_errors(logger, errors: List[ErrorDict]):
     "Format and log a Pydantic-style error dictionary"
-    # global has_shown_yaml_error_message
     plural = "" if len(errors) <= 1 else "s"
     logger.warning(f"CumulusCI Configuration Warning{plural}:")
     for error in errors:

cumulusci/utils/yaml/model_parser.py

@@ -1,8 +1,8 @@
 from pathlib import Path
 from typing import IO, Sequence, Union
 
-from pydantic import BaseModel, ValidationError
-from pydantic.error_wrappers import ErrorWrapper
+from pydantic.v1 import BaseModel, ValidationError
+from pydantic.v1.error_wrappers import ErrorWrapper
 
 from cumulusci.utils.yaml.safer_loader import load_from_source, load_yaml_data
 

cumulusci/utils/yaml/tests/test_cumulusci_yml.py

@@ -4,7 +4,7 @@ from pathlib import Path
 from unittest.mock import MagicMock, Mock, patch
 
 import pytest
-from pydantic import ValidationError
+from pydantic.v1 import ValidationError
 
 from cumulusci.utils import temporary_dir
 from cumulusci.utils.yaml.cumulusci_yml import (

cumulusci/utils/yaml/tests/test_model_parser.py

@@ -2,7 +2,7 @@ from io import StringIO
 from unittest.mock import Mock
 
 import pytest
-from pydantic import Field
+from pydantic.v1 import Field
 
 from cumulusci.utils.yaml.model_parser import CCIDictModel, CCIModel, ValidationError
 
@@ -20,7 +20,7 @@ class TestCCIModel:
     def test_fields_property(self):
         # JSON is YAML. Strange but true.
         foo = Document.parse_from_yaml(StringIO("{bar: 'blah'}"))
-        assert type(foo) == Foo
+        assert isinstance(foo, Foo)
         assert foo.fields_ == []
         assert foo.fields == []
 
@@ -122,7 +122,7 @@ class TestCCIDictModel:
 
         # JSON is YAML. Strange but true.
         foo = Document.parse_from_yaml(StringIO("{bar: 'blah'}"))
-        assert type(foo) == Foo
+        assert isinstance(foo, Foo)
         assert foo["fields"] == []
 
         foo = Document.parse_from_yaml(StringIO("{bar: 'blah', fields: [1,2]}"))

cumulusci/vcs/base.py

@@ -1,15 +1,17 @@
 import logging
 from abc import ABC, abstractmethod
-from typing import List, Optional, Type
+from typing import TYPE_CHECKING, List, Optional, Set, Type
 
-from cumulusci.core.config import BaseProjectConfig, ServiceConfig
-from cumulusci.core.dependencies.base import DynamicDependency
 from cumulusci.core.keychain import BaseProjectKeychain
-from cumulusci.tasks.release_notes.generator import BaseReleaseNotesGenerator
 from cumulusci.utils.classutils import get_all_subclasses
 from cumulusci.vcs.models import AbstractRelease, AbstractRepo
 from cumulusci.vcs.utils import AbstractCommitDir
 
+if TYPE_CHECKING:
+    from cumulusci.core.config import BaseProjectConfig, ServiceConfig
+    from cumulusci.core.dependencies.base import DynamicDependency
+    from cumulusci.tasks.release_notes.generator import BaseReleaseNotesGenerator
+
 
 class VCSService(ABC):
     """This is an abstract base class for VCS services.
@@ -18,14 +20,14 @@ class VCSService(ABC):
     """
 
     logger: logging.Logger
-    config: BaseProjectConfig
-    service_config: ServiceConfig
+    config: "BaseProjectConfig"
+    service_config: "ServiceConfig"
     name: str
     keychain: Optional[BaseProjectKeychain]
     _service_registry: List["VCSService"] = []
 
     def __init__(
-        self, config: BaseProjectConfig, name: Optional[str] = None, **kwargs
+        self, config: "BaseProjectConfig", name: Optional[str] = None, **kwargs
     ) -> None:
         """Initializes the VCS service with the given configuration, service name, and keychain.
 
@@ -35,8 +37,11 @@ class VCSService(ABC):
             **kwargs: Additional keyword arguments.
         """
         self.config = config
-        self.service_config = config.keychain.get_service(self.service_type, name)
-        self.name = self.service_config.name or name
+        if config.keychain:
+            self.service_config = config.keychain.get_service(self.service_type, name)
+            self.name = self.service_config.name
+        else:
+            self.name = name or ""
         self.keychain = config.keychain
         self.logger = kwargs.get("logger") or logging.getLogger(__name__)
 
@@ -51,11 +56,11 @@ class VCSService(ABC):
             raise NotImplementedError(
                 "Subclasses should define the service_type property"
             )
-        return self.__class__.service_type
+        return str(self.__class__.service_type)
 
     @property
     @abstractmethod
-    def dynamic_dependency_class(self) -> Type[DynamicDependency]:
+    def dynamic_dependency_class(self) -> Type["DynamicDependency"]:
         """Returns the dynamic dependency class for the VCS service.
         This property should be overridden by subclasses to provide
         the specific dynamic dependency class. For example, it could
@@ -78,7 +83,10 @@ class VCSService(ABC):
     @classmethod
     @abstractmethod
     def get_service_for_url(
-        cls, project_config: BaseProjectConfig, url: str, service_alias: str = None
+        cls,
+        project_config: "BaseProjectConfig",
+        url: str,
+        service_alias: Optional[str] = None,
     ) -> Optional["VCSService"]:
         """Returns the service configuration for the given URL.
         This method should be overridden by subclasses to provide
@@ -87,7 +95,7 @@ class VCSService(ABC):
         raise NotImplementedError("Subclasses should provide their own implementation")
 
     @classmethod
-    def registered_services(cls) -> List[Type["VCSService"]]:
+    def registered_services(cls) -> Set[Type["VCSService"]]:
         """This method returns all subclasses of VCSService that have been registered.
         It can be used to dynamically discover available VCS services."""
         return get_all_subclasses(cls)
@@ -127,7 +135,7 @@ class VCSService(ABC):
         raise NotImplementedError("Subclasses should provide their own implementation")
 
     @abstractmethod
-    def release_notes_generator(self, options: dict) -> BaseReleaseNotesGenerator:
+    def release_notes_generator(self, options: dict) -> "BaseReleaseNotesGenerator":
         """Returns the release notes generator for the VCS service."""
         raise NotImplementedError(
             "Subclasses should define the release_notes_generator property"
@@ -136,7 +144,7 @@ class VCSService(ABC):
     @abstractmethod
     def parent_pr_notes_generator(
         self, repo: AbstractRepo
-    ) -> BaseReleaseNotesGenerator:
+    ) -> "BaseReleaseNotesGenerator":
         """Returns the parent PR notes generator for the VCS service."""
         raise NotImplementedError(
             "Subclasses should define the parent_pr_notes_generator property"

cumulusci/vcs/bootstrap.py

@@ -226,20 +226,21 @@ def get_repo_from_config(config: BaseProjectConfig, options: dict = {}) -> Abstr
 
 def get_latest_tag(repo: AbstractRepo, beta: bool = False) -> str:
     """Query Github Releases to find the latest production or beta tag"""
-    prefix = repo.project_config.project__git__prefix_release
+    prefix = repo.project_config.project__git__prefix_beta if beta else repo.project_config.project__git__prefix_release  # type: ignore
 
     try:
         if not beta:
             release: Optional[AbstractRelease] = repo.latest_release()
 
+            if release is None:
+                raise
+
             if not release.tag_name.startswith(prefix):
                 return _get_latest_tag_for_prefix(repo, prefix)
 
             return release.tag_name
         else:
-            return _get_latest_tag_for_prefix(
-                repo, repo.project_config.project__git__prefix_beta
-            )
+            return _get_latest_tag_for_prefix(repo, prefix)
     except Exception:
         raise VcsException(
             f"No release found for {repo.repo_url} with tag prefix {prefix}"