codemagic-cli-tools 0.49.0__tar.gz → 0.50.1__tar.gz

{codemagic_cli_tools-0.49.0 → codemagic_cli_tools-0.50.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codemagic-cli-tools
-Version: 0.49.0
+Version: 0.50.1
 Summary: CLI tools used in Codemagic builds
 Home-page: https://github.com/codemagic-ci-cd/cli-tools
 License: GPL-3.0-or-later

{codemagic_cli_tools-0.49.0 → codemagic_cli_tools-0.50.1}/pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "codemagic-cli-tools"
-version = "0.49.0"
+version = "0.50.1"
 description = "CLI tools used in Codemagic builds"
 readme = "README.md"
 authors = [

{codemagic_cli_tools-0.49.0 → codemagic_cli_tools-0.50.1}/src/codemagic/__version__.py

@@ -1,5 +1,5 @@
 __title__ = "codemagic-cli-tools"
 __description__ = "CLI tools used in Codemagic builds"
-__version__ = '0.49.0'
+__version__ = '0.50.1'
 __url__ = "https://github.com/codemagic-ci-cd/cli-tools"
 __licence__ = "GNU General Public License v3.0"

{codemagic_cli_tools-0.49.0 → codemagic_cli_tools-0.50.1}/src/codemagic/__version__.py-e

@@ -1,5 +1,5 @@
 __title__ = "codemagic-cli-tools"
 __description__ = "CLI tools used in Codemagic builds"
-__version__ = "0.49.0.dev"
+__version__ = "0.50.1.dev"
 __url__ = "https://github.com/codemagic-ci-cd/cli-tools"
 __licence__ = "GNU General Public License v3.0"

{codemagic_cli_tools-0.49.0 → codemagic_cli_tools-0.50.1}/src/codemagic/apple/resources/bundle_id_capability.py

@@ -1,6 +1,7 @@
 from __future__ import annotations
 
 from dataclasses import dataclass
+from typing import Any
 from typing import Optional
 
 from .enums import CapabilityOptionKey
@@ -66,3 +67,13 @@ class BundleIdCapability(Resource):
     @dataclass
     class Relationships(Resource.Relationships):
         bundleId: Relationship
+
+    def _format_attribute_value(self, attribute_name: str, value: Any) -> Any:
+        if attribute_name == "capabilityType":
+            # In case we get an unknown capability type from API response, then this is stored as
+            # a runtime-created fallback enumeration `GracefulCapabilityType` which does not have
+            # the properties and methods that `CapabilityType` has.
+            if isinstance(self.attributes.capabilityType, CapabilityType):
+                return self.attributes.capabilityType.display_name
+            return CapabilityType.get_default_display_name(self.attributes.capabilityType.value)
+        return super()._format_attribute_value(attribute_name, value)

{codemagic_cli_tools-0.49.0 → codemagic_cli_tools-0.50.1}/src/codemagic/apple/resources/enums.py

@@ -1,5 +1,6 @@
 from __future__ import annotations
 
+import re
 from typing import Tuple
 
 from codemagic.models.enums import ResourceEnum
@@ -78,30 +79,73 @@ class CapabilitySettingKey(ResourceEnum):
 
 
 class CapabilityType(ResourceEnum):
+    """
+    https://developer.apple.com/documentation/appstoreconnectapi/capabilitytype
+    """
+
     ACCESS_WIFI_INFORMATION = "ACCESS_WIFI_INFORMATION"
-    APP_GROUPS = "APP_GROUPS"
+    APPLE_ID_AUTH = "APPLE_ID_AUTH"
     APPLE_PAY = "APPLE_PAY"
+    APP_GROUPS = "APP_GROUPS"
     ASSOCIATED_DOMAINS = "ASSOCIATED_DOMAINS"
     AUTOFILL_CREDENTIAL_PROVIDER = "AUTOFILL_CREDENTIAL_PROVIDER"
     CLASSKIT = "CLASSKIT"
+    COREMEDIA_HLS_LOW_LATENCY = "COREMEDIA_HLS_LOW_LATENCY"
     DATA_PROTECTION = "DATA_PROTECTION"
     GAME_CENTER = "GAME_CENTER"
     HEALTHKIT = "HEALTHKIT"
     HOMEKIT = "HOMEKIT"
     HOT_SPOT = "HOT_SPOT"
     ICLOUD = "ICLOUD"
-    IN_APP_PURCHASE = "IN_APP_PURCHASE"
     INTER_APP_AUDIO = "INTER_APP_AUDIO"
+    IN_APP_PURCHASE = "IN_APP_PURCHASE"
     MAPS = "MAPS"
     MULTIPATH = "MULTIPATH"
+    NETWORK_CUSTOM_PROTOCOL = "NETWORK_CUSTOM_PROTOCOL"
     NETWORK_EXTENSIONS = "NETWORK_EXTENSIONS"
+    NETWORK_SLICING = "NETWORK_SLICING"
     NFC_TAG_READING = "NFC_TAG_READING"
     PERSONAL_VPN = "PERSONAL_VPN"
     PUSH_NOTIFICATIONS = "PUSH_NOTIFICATIONS"
     SIRIKIT = "SIRIKIT"
+    SYSTEM_EXTENSION_INSTALL = "SYSTEM_EXTENSION_INSTALL"
+    USER_MANAGEMENT = "USER_MANAGEMENT"
     WALLET = "WALLET"
     WIRELESS_ACCESSORY_CONFIGURATION = "WIRELESS_ACCESSORY_CONFIGURATION"
 
+    @classmethod
+    def from_display_name(cls, display_name: str) -> CapabilityType:
+        for capability_type in cls:
+            if capability_type.display_name == display_name:
+                return capability_type
+        raise ValueError("Unknown capability type", display_name)
+
+    @property
+    def display_name(self) -> str:
+        try:
+            return {
+                CapabilityType.ACCESS_WIFI_INFORMATION: "Access Wi-Fi Information",
+                CapabilityType.APPLE_ID_AUTH: "Sign In with Apple",
+                CapabilityType.COREMEDIA_HLS_LOW_LATENCY: "Low Latency HLS",
+                CapabilityType.HOT_SPOT: "Hotspot",
+                CapabilityType.ICLOUD: "iCloud",
+                CapabilityType.INTER_APP_AUDIO: "Inter-App Audio",
+                CapabilityType.IN_APP_PURCHASE: "In-App Purchase",
+                CapabilityType.NETWORK_CUSTOM_PROTOCOL: "Custom Network Protocol",
+                CapabilityType.NETWORK_SLICING: "5G Network Slicing",
+                CapabilityType.NFC_TAG_READING: "NFC Tag Reading",
+                CapabilityType.PERSONAL_VPN: "Personal VPN",
+                CapabilityType.SYSTEM_EXTENSION_INSTALL: "System Extension",
+            }[self]
+        except KeyError:
+            return self.get_default_display_name(self.value)
+
+    @classmethod
+    def get_default_display_name(cls, capability_type_value: str) -> str:
+        parts = capability_type_value.split("_")
+        title = " ".join(parts).title()
+        return re.sub(r"(kit)$", "Kit", title)
+
 
 class CertificateType(ResourceEnum):
     DEVELOPER_ID_APPLICATION = "DEVELOPER_ID_APPLICATION"

{codemagic_cli_tools-0.49.0 → codemagic_cli_tools-0.50.1}/src/codemagic/models/xctests/__init__.py

@@ -2,3 +2,4 @@ from .collector import XcResultCollector
 from .converter import XcResultConverter
 from .xcresult import ActionsInvocationRecord
 from .xcresulttool import XcResultTool
+from .xcresulttool import XcResultToolError

{codemagic_cli_tools-0.49.0 → codemagic_cli_tools-0.50.1}/src/codemagic/models/xctests/xcresulttool.py

@@ -13,12 +13,19 @@ from typing import Sequence
 
 from codemagic.cli import CommandArg
 from codemagic.mixins import RunningCliAppMixin
+from codemagic.mixins import StringConverterMixin
 
 if TYPE_CHECKING:
     from codemagic.cli import CliApp
 
 
-class XcResultTool(RunningCliAppMixin):
+class XcResultToolError(IOError):
+    def __init__(self, message: str, stderr: str):
+        super().__init__(message)
+        self.stderr = stderr
+
+
+class XcResultTool(RunningCliAppMixin, StringConverterMixin):
     @classmethod
     def get_bundle(cls, xcresult: pathlib.Path) -> Dict[str, Any]:
         cmd_args: List[CommandArg] = [
@@ -66,8 +73,8 @@ class XcResultTool(RunningCliAppMixin):
                 return cls._run_command_with_cli_app(cli_app, command_args)
             else:
                 return subprocess.check_output(command_args)
-        except subprocess.CalledProcessError:
-            raise IOError(error_message)
+        except subprocess.CalledProcessError as cpe:
+            raise XcResultToolError(error_message, cls._str(cpe.stderr)) from cpe
 
     @classmethod
     def _run_command_with_cli_app(cls, cli_app: CliApp, command_args: Sequence[CommandArg]) -> bytes:

codemagic_cli_tools-0.50.1/src/codemagic/tools/app_store_connect/action_groups/bundle_ids_action_group.py

@@ -0,0 +1,317 @@
+from __future__ import annotations
+
+from abc import ABCMeta
+from typing import List
+from typing import Optional
+from typing import Sequence
+from typing import Union
+
+from codemagic import cli
+from codemagic.apple import AppStoreConnectApiError
+from codemagic.apple.resources import BundleId
+from codemagic.apple.resources import BundleIdCapability
+from codemagic.apple.resources import BundleIdPlatform
+from codemagic.apple.resources import CapabilityType
+from codemagic.apple.resources import Profile
+from codemagic.apple.resources import ProfileState
+from codemagic.apple.resources import ProfileType
+from codemagic.apple.resources import ResourceId
+from codemagic.cli import Colors
+
+from ..abstract_base_action import AbstractBaseAction
+from ..action_group import AppStoreConnectActionGroup
+from ..arguments import BundleIdArgument
+from ..arguments import CommonArgument
+from ..arguments import ProfileArgument
+from ..errors import AppStoreConnectError
+
+
+class BundleIdsActionGroup(AbstractBaseAction, metaclass=ABCMeta):
+    @cli.action(
+        "create",
+        BundleIdArgument.BUNDLE_ID_IDENTIFIER,
+        BundleIdArgument.BUNDLE_ID_NAME,
+        BundleIdArgument.PLATFORM,
+        action_group=AppStoreConnectActionGroup.BUNDLE_IDS,
+        deprecation_info=cli.ActionDeprecationInfo("create-bundle-id", "0.49.0"),
+    )
+    def create_bundle_id(
+        self,
+        bundle_id_identifier: str,
+        bundle_id_name: Optional[str] = None,
+        platform: BundleIdPlatform = BundleIdPlatform.IOS,
+        should_print: bool = True,
+    ) -> BundleId:
+        """
+        Create Bundle ID in Apple Developer portal for specifier identifier
+        """
+
+        if bundle_id_name is None:
+            bundle_id_name = bundle_id_identifier.replace(".", " ")
+
+        create_params = dict(identifier=bundle_id_identifier, name=bundle_id_name, platform=platform)
+        return self._create_resource(self.api_client.bundle_ids, should_print, **create_params)
+
+    @cli.action(
+        "get",
+        BundleIdArgument.BUNDLE_ID_RESOURCE_ID,
+        action_group=AppStoreConnectActionGroup.BUNDLE_IDS,
+        deprecation_info=cli.ActionDeprecationInfo("get-bundle-id", "0.49.0"),
+    )
+    def get_bundle_id(
+        self,
+        bundle_id_resource_id: ResourceId,
+        should_print: bool = True,
+    ) -> BundleId:
+        """
+        Get specified Bundle ID from Apple Developer portal
+        """
+
+        return self._get_resource(bundle_id_resource_id, self.api_client.bundle_ids, should_print)
+
+    @cli.action(
+        "list",
+        BundleIdArgument.BUNDLE_ID_IDENTIFIER_OPTIONAL,
+        BundleIdArgument.BUNDLE_ID_NAME,
+        BundleIdArgument.PLATFORM_OPTIONAL,
+        BundleIdArgument.IDENTIFIER_STRICT_MATCH,
+        action_group=AppStoreConnectActionGroup.BUNDLE_IDS,
+        deprecation_info=cli.ActionDeprecationInfo("list-bundle-ids", "0.49.0"),
+    )
+    def list_bundle_ids(
+        self,
+        bundle_id_identifier: Optional[str] = None,
+        bundle_id_name: Optional[str] = None,
+        platform: Optional[BundleIdPlatform] = None,
+        bundle_id_identifier_strict_match: bool = False,
+        should_print: bool = True,
+    ) -> List[BundleId]:
+        """
+        List Bundle IDs from Apple Developer portal matching given constraints
+        """
+
+        def predicate(bundle_id):
+            return bundle_id.attributes.identifier == bundle_id_identifier
+
+        bundle_id_filter = self.api_client.bundle_ids.Filter(
+            identifier=bundle_id_identifier,
+            name=bundle_id_name,
+            platform=platform,
+        )
+        bundle_ids = self._list_resources(
+            bundle_id_filter,
+            self.api_client.bundle_ids,
+            should_print,
+            filter_predicate=predicate if bundle_id_identifier_strict_match else None,
+        )
+
+        return bundle_ids
+
+    @cli.action(
+        "delete",
+        BundleIdArgument.BUNDLE_ID_RESOURCE_ID,
+        CommonArgument.IGNORE_NOT_FOUND,
+        action_group=AppStoreConnectActionGroup.BUNDLE_IDS,
+        deprecation_info=cli.ActionDeprecationInfo("delete-bundle-id", "0.49.0"),
+    )
+    def delete_bundle_id(
+        self,
+        bundle_id_resource_id: ResourceId,
+        ignore_not_found: bool = False,
+    ) -> None:
+        """
+        Delete specified Bundle ID from Apple Developer portal
+        """
+
+        self._delete_resource(self.api_client.bundle_ids, bundle_id_resource_id, ignore_not_found)
+
+    @cli.action(
+        "profiles",
+        BundleIdArgument.BUNDLE_ID_RESOURCE_IDS,
+        ProfileArgument.PROFILE_TYPE_OPTIONAL,
+        ProfileArgument.PROFILE_STATE_OPTIONAL,
+        ProfileArgument.PROFILE_NAME,
+        CommonArgument.SAVE,
+        action_group=AppStoreConnectActionGroup.BUNDLE_IDS,
+        deprecation_info=cli.ActionDeprecationInfo("list-bundle-id-profiles", "0.49.0"),
+    )
+    def list_bundle_id_profiles(
+        self,
+        bundle_id_resource_ids: Sequence[ResourceId],
+        profile_type: Optional[ProfileType] = None,
+        profile_state: Optional[ProfileState] = None,
+        profile_name: Optional[str] = None,
+        save: bool = False,
+        should_print: bool = True,
+    ) -> List[Profile]:
+        """
+        List provisioning profiles from Apple Developer Portal for specified Bundle IDs
+        """
+
+        profiles_filter = self.api_client.profiles.Filter(
+            profile_type=profile_type,
+            profile_state=profile_state,
+            name=profile_name,
+        )
+
+        profiles = []
+        for resource_id in set(bundle_id_resource_ids):
+            bundle_id_profiles = self._list_related_resources(
+                resource_id,
+                BundleId,
+                Profile,
+                self.api_client.bundle_ids.list_profiles,
+                profiles_filter,
+                should_print,
+            )
+            profiles.extend(bundle_id_profiles)
+
+        if save:
+            self._save_profiles(profiles)
+        return profiles
+
+    @cli.action(
+        "capabilities",
+        BundleIdArgument.BUNDLE_ID_RESOURCE_ID,
+        action_group=AppStoreConnectActionGroup.BUNDLE_IDS,
+    )
+    def list_bundle_id_capabilities(
+        self,
+        bundle_id_resource_id: ResourceId,
+        should_print: bool = True,
+    ) -> List[BundleIdCapability]:
+        """
+        Check the capabilities that are enabled for identifier
+        """
+        return self._list_related_resources(
+            bundle_id_resource_id,
+            BundleId,
+            BundleIdCapability,
+            self.api_client.bundle_ids.list_capabilities,
+            None,
+            should_print,
+        )
+
+    @cli.action(
+        "enable-capabilities",
+        BundleIdArgument.BUNDLE_ID_RESOURCE_ID,
+        BundleIdArgument.CAPABILITY_TYPES,
+        action_group=AppStoreConnectActionGroup.BUNDLE_IDS,
+    )
+    def enable_bundle_id_capabilities(
+        self,
+        bundle_id_resource_id: ResourceId,
+        capabilities: Sequence[Union[CapabilityType, str]],
+    ):
+        """
+        Enable capabilities for identifier
+        """
+        capability_types = self._resolve_capability_types(capabilities)
+        bundle_id = self._get_bundle_id(bundle_id_resource_id)
+        self.logger.info(Colors.BLUE(f'Enable {BundleIdCapability.s} for identifier "{bundle_id.attributes.name}"'))
+
+        for capability_type in capability_types:
+            self._enable_capability(bundle_id, capability_type)
+
+        success_message = f'Successfully enabled {BundleIdCapability.s} for identifier "{bundle_id.attributes.name}"'
+        self.logger.info(Colors.GREEN(success_message))
+
+    @cli.action(
+        "disable-capabilities",
+        BundleIdArgument.BUNDLE_ID_RESOURCE_ID,
+        BundleIdArgument.CAPABILITY_TYPES,
+        action_group=AppStoreConnectActionGroup.BUNDLE_IDS,
+    )
+    def disable_bundle_id_capabilities(
+        self,
+        bundle_id_resource_id: ResourceId,
+        capabilities: Sequence[Union[CapabilityType, str]],
+    ):
+        """
+        Disable identifier capabilities
+        """
+        capability_types = self._resolve_capability_types(capabilities)
+        bundle_id = self._get_bundle_id(bundle_id_resource_id)
+        self.logger.info(Colors.BLUE(f'Disable {BundleIdCapability.s} for identifier "{bundle_id.attributes.name}"'))
+
+        enabled_capabilities = self._get_capabilities(bundle_id, capability_types)
+        if not enabled_capabilities:
+            skip_message = (
+                f"None of the specified {BundleIdCapability.s} are enabled for identifier "
+                f'"{bundle_id.attributes.name}". Skip disabling.'
+            )
+            self.logger.info(Colors.YELLOW(skip_message))
+            return
+
+        for capability in enabled_capabilities:
+            self._disable_capability(bundle_id, capability)
+
+        success_message = f'Successfully disabled {BundleIdCapability.s} for identifier "{bundle_id.attributes.name}"'
+        self.logger.info(Colors.GREEN(success_message))
+
+    def _get_bundle_id(self, bundle_id_resource_id: ResourceId) -> BundleId:
+        try:
+            return self.api_client.bundle_ids.read(bundle_id_resource_id)
+        except AppStoreConnectApiError as api_error:
+            raise AppStoreConnectError(
+                str(api_error),
+                api_error_response=api_error.error_response,
+            ) from api_error
+
+    @classmethod
+    def _resolve_capability_types(
+        cls,
+        capabilities: Optional[Sequence[Union[CapabilityType, str]]],
+    ) -> List[CapabilityType]:
+        if not capabilities:
+            return []
+        return [c if isinstance(c, CapabilityType) else CapabilityType.from_display_name(c) for c in capabilities]
+
+    def _get_capabilities(
+        self,
+        bundle_id: BundleId,
+        capability_types: Sequence[CapabilityType],
+    ) -> List[BundleIdCapability]:
+        try:
+            capabilities = self.api_client.bundle_ids.list_capabilities(bundle_id)
+        except AppStoreConnectApiError as api_error:
+            raise AppStoreConnectError(
+                str(api_error),
+                api_error_response=api_error.error_response,
+            ) from api_error
+        return [c for c in capabilities if c.attributes.capabilityType in capability_types]
+
+    def _enable_capability(self, bundle_id: BundleId, capability_type: CapabilityType) -> BundleIdCapability:
+        try:
+            capability = self.api_client.bundle_id_capabilities.enable(
+                capability_type,
+                bundle_id=bundle_id.id,
+            )
+        except AppStoreConnectApiError as api_error:
+            raise AppStoreConnectError(
+                (
+                    f"Failed to enable capability {capability_type.value} for bundle identifier "
+                    f'"{bundle_id.attributes.name}" ({bundle_id.id}): {api_error}'
+                ),
+                api_error_response=api_error.error_response,
+            ) from api_error
+
+        self.echo(Colors.BLUE(f"-- Enabled {capability.__class__} --"))
+        self.echo(f"{capability}")
+        return capability
+
+    def _disable_capability(self, bundle_id: BundleId, capability: BundleIdCapability):
+        try:
+            self.api_client.bundle_id_capabilities.disable(capability)
+        except AppStoreConnectApiError as api_error:
+            raise AppStoreConnectError(
+                (
+                    f"Failed to disable capability {capability.attributes.capabilityType.value} "
+                    f"for bundle identifier "
+                    f'"{bundle_id.attributes.name}" ({bundle_id.id}): {api_error}'
+                ),
+                api_error_response=api_error.error_response,
+            ) from api_error
+
+        self.echo(Colors.BLUE(f"-- Disabled {capability.__class__} --"))
+        self.echo(f"{capability}")

{codemagic_cli_tools-0.49.0 → codemagic_cli_tools-0.50.1}/src/codemagic/tools/app_store_connect/arguments.py

@@ -23,6 +23,7 @@ from codemagic.apple.resources import AppStoreState
 from codemagic.apple.resources import BetaReviewState
 from codemagic.apple.resources import BuildProcessingState
 from codemagic.apple.resources import BundleIdPlatform
+from codemagic.apple.resources import CapabilityType
 from codemagic.apple.resources import CertificateType
 from codemagic.apple.resources import DeviceStatus
 from codemagic.apple.resources import Locale
@@ -1229,6 +1230,17 @@ class BundleIdArgument(cli.Argument):
             "metavar": "bundle-identifier-id",
         },
     )
+    CAPABILITY_TYPES = cli.ArgumentProperties(
+        key="capabilities",
+        flags=("--capability",),
+        type=str,
+        description="Name of the identifier capability",
+        argparse_kwargs={
+            "required": True,
+            "choices": [ct.display_name for ct in CapabilityType],
+            "nargs": "+",
+        },
+    )
     PLATFORM = cli.ArgumentProperties(
         key="platform",
         flags=("--platform",),

{codemagic_cli_tools-0.49.0 → codemagic_cli_tools-0.50.1}/src/codemagic/tools/xcode_project.py

@@ -36,6 +36,7 @@ from codemagic.models.simulator import Runtime
 from codemagic.models.simulator import Simulator
 from codemagic.models.xctests import XcResultCollector
 from codemagic.models.xctests import XcResultConverter
+from codemagic.models.xctests import XcResultToolError
 
 from ._xcode_project.arguments import CustomExportOptions
 from ._xcode_project.arguments import ExportIpaArgument
@@ -501,21 +502,25 @@ class XcodeProject(cli.CliApp, PathFinderMixin):
         if not xcresult_collector.get_collected_results():
             raise XcodeProjectException("Did not find any test results")
 
-        test_suites, xcresult = self._get_test_suites(
-            xcresult_collector,
-            show_found_result=True,
-            save_xcresult_dir=output_dir,
-        )
-
-        message = (
-            f"Executed {test_suites.tests} tests with "
-            f"{test_suites.failures} failures and "
-            f"{test_suites.errors} errors in "
-            f"{test_suites.time:.2f} seconds.\n"
-        )
-        self.echo(Colors.BLUE(message))
-        TestSuitePrinter(self.echo).print_test_suites(test_suites)
-        self._save_test_suite(xcresult, test_suites, output_dir, output_extension)
+        try:
+            test_suites, xcresult = self._get_test_suites(
+                xcresult_collector,
+                show_found_result=True,
+                save_xcresult_dir=output_dir,
+            )
+        except XcResultToolError as e:
+            test_suites = None
+            self.logger.error(Colors.RED(f"Parsing test results failed\n{e}\n{e.stderr}"))
+        else:
+            message = (
+                f"Executed {test_suites.tests} tests with "
+                f"{test_suites.failures} failures and "
+                f"{test_suites.errors} errors in "
+                f"{test_suites.time:.2f} seconds.\n"
+            )
+            self.echo(Colors.BLUE(message))
+            TestSuitePrinter(self.echo).print_test_suites(test_suites)
+            self._save_test_suite(xcresult, test_suites, output_dir, output_extension)
 
         if not graceful_exit:
             if testing_failed or (test_suites and test_suites.has_failed_tests()):
@@ -539,7 +544,12 @@ class XcodeProject(cli.CliApp, PathFinderMixin):
         if not xcresults:
             raise XcodeProjectException("Did not find any Xcode test results for given patterns")
 
-        test_suites, xcresult = self._get_test_suites(xcresult_collector, show_found_result=True)
+        try:
+            test_suites, xcresult = self._get_test_suites(xcresult_collector, show_found_result=True)
+        except XcResultToolError as e:
+            self.logger.error(Colors.RED(f"{e}\n{e.stderr}"))
+            raise XcodeProjectException("Parsing test results failed") from e
+
         TestSuitePrinter(self.echo).print_test_suites(test_suites)
 
     @cli.action(
@@ -564,7 +574,12 @@ class XcodeProject(cli.CliApp, PathFinderMixin):
         if not xcresults:
             raise XcodeProjectException("Did not find any Xcode test results for given patterns")
 
-        test_suites, xcresult = self._get_test_suites(xcresult_collector, show_found_result=True)
+        try:
+            test_suites, xcresult = self._get_test_suites(xcresult_collector, show_found_result=True)
+        except XcResultToolError as e:
+            self.logger.error(Colors.RED(f"{e}\n{e.stderr}"))
+            raise XcodeProjectException("Parsing test results failed") from e
+
         output_dir.mkdir(parents=True, exist_ok=True)
         self._save_test_suite(xcresult, test_suites, output_dir, output_extension)
 

codemagic_cli_tools-0.50.1/tests/apple/resources/enums/test_capability_type.py

@@ -0,0 +1,77 @@
+import pytest
+from codemagic.apple.resources import CapabilityType
+
+
+@pytest.mark.parametrize(
+    ("capability_type", "expected_display_name"),
+    (
+        (CapabilityType.ACCESS_WIFI_INFORMATION, "Access Wi-Fi Information"),
+        (CapabilityType.APPLE_ID_AUTH, "Sign In with Apple"),
+        (CapabilityType.APPLE_PAY, "Apple Pay"),
+        (CapabilityType.APP_GROUPS, "App Groups"),
+        (CapabilityType.ASSOCIATED_DOMAINS, "Associated Domains"),
+        (CapabilityType.AUTOFILL_CREDENTIAL_PROVIDER, "Autofill Credential Provider"),
+        (CapabilityType.CLASSKIT, "ClassKit"),
+        (CapabilityType.COREMEDIA_HLS_LOW_LATENCY, "Low Latency HLS"),
+        (CapabilityType.DATA_PROTECTION, "Data Protection"),
+        (CapabilityType.GAME_CENTER, "Game Center"),
+        (CapabilityType.HEALTHKIT, "HealthKit"),
+        (CapabilityType.HOMEKIT, "HomeKit"),
+        (CapabilityType.HOT_SPOT, "Hotspot"),
+        (CapabilityType.ICLOUD, "iCloud"),
+        (CapabilityType.INTER_APP_AUDIO, "Inter-App Audio"),
+        (CapabilityType.IN_APP_PURCHASE, "In-App Purchase"),
+        (CapabilityType.MAPS, "Maps"),
+        (CapabilityType.MULTIPATH, "Multipath"),
+        (CapabilityType.NETWORK_CUSTOM_PROTOCOL, "Custom Network Protocol"),
+        (CapabilityType.NETWORK_EXTENSIONS, "Network Extensions"),
+        (CapabilityType.NFC_TAG_READING, "NFC Tag Reading"),
+        (CapabilityType.PERSONAL_VPN, "Personal VPN"),
+        (CapabilityType.PUSH_NOTIFICATIONS, "Push Notifications"),
+        (CapabilityType.SIRIKIT, "SiriKit"),
+        (CapabilityType.SYSTEM_EXTENSION_INSTALL, "System Extension"),
+        (CapabilityType.USER_MANAGEMENT, "User Management"),
+        (CapabilityType.WALLET, "Wallet"),
+        (CapabilityType.WIRELESS_ACCESSORY_CONFIGURATION, "Wireless Accessory Configuration"),
+    ),
+)
+def test_display_name(capability_type: CapabilityType, expected_display_name: str):
+    assert capability_type.display_name == expected_display_name
+
+
+@pytest.mark.parametrize(
+    ("display_name", "expected_capability_type"),
+    (
+        ("Access Wi-Fi Information", CapabilityType.ACCESS_WIFI_INFORMATION),
+        ("Sign In with Apple", CapabilityType.APPLE_ID_AUTH),
+        ("Apple Pay", CapabilityType.APPLE_PAY),
+        ("App Groups", CapabilityType.APP_GROUPS),
+        ("Associated Domains", CapabilityType.ASSOCIATED_DOMAINS),
+        ("Autofill Credential Provider", CapabilityType.AUTOFILL_CREDENTIAL_PROVIDER),
+        ("ClassKit", CapabilityType.CLASSKIT),
+        ("Low Latency HLS", CapabilityType.COREMEDIA_HLS_LOW_LATENCY),
+        ("Data Protection", CapabilityType.DATA_PROTECTION),
+        ("Game Center", CapabilityType.GAME_CENTER),
+        ("HealthKit", CapabilityType.HEALTHKIT),
+        ("HomeKit", CapabilityType.HOMEKIT),
+        ("Hotspot", CapabilityType.HOT_SPOT),
+        ("iCloud", CapabilityType.ICLOUD),
+        ("Inter-App Audio", CapabilityType.INTER_APP_AUDIO),
+        ("In-App Purchase", CapabilityType.IN_APP_PURCHASE),
+        ("Maps", CapabilityType.MAPS),
+        ("Multipath", CapabilityType.MULTIPATH),
+        ("Custom Network Protocol", CapabilityType.NETWORK_CUSTOM_PROTOCOL),
+        ("Network Extensions", CapabilityType.NETWORK_EXTENSIONS),
+        ("NFC Tag Reading", CapabilityType.NFC_TAG_READING),
+        ("Personal VPN", CapabilityType.PERSONAL_VPN),
+        ("Push Notifications", CapabilityType.PUSH_NOTIFICATIONS),
+        ("SiriKit", CapabilityType.SIRIKIT),
+        ("System Extension", CapabilityType.SYSTEM_EXTENSION_INSTALL),
+        ("User Management", CapabilityType.USER_MANAGEMENT),
+        ("Wallet", CapabilityType.WALLET),
+        ("Wireless Accessory Configuration", CapabilityType.WIRELESS_ACCESSORY_CONFIGURATION),
+    ),
+)
+def test_from_display_name(display_name: str, expected_capability_type: CapabilityType):
+    capability_type = CapabilityType.from_display_name(display_name)
+    assert capability_type is expected_capability_type