codemagic-cli-tools 0.53.4__tar.gz → 0.53.6__tar.gz

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: codemagic-cli-tools
-Version: 0.53.4
+Version: 0.53.6
 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.53.4 → codemagic_cli_tools-0.53.6}/pyproject.toml

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

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.6}/src/codemagic/__version__.py

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

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.6}/src/codemagic/__version__.py-e

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

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.6}/src/codemagic/apple/resources/enums.py

@@ -434,37 +434,47 @@ class ReviewSubmissionItemState(ResourceEnum):
 
 class Locale(ResourceEnum):
     """
-    Referenced in https://developer.apple.com/documentation/appstoreconnectapi/betaapplocalization/attributes#discussion
+    https://developer.apple.com/documentation/appstoreconnectapi/app_store/app_metadata/app_info_localizations/managing_metadata_in_your_app_by_using_locale_shortcodes
     """
 
-    DA = "da"
-    DE_DE = "de-DE"
-    EL = "el"
-    EN_AU = "en-AU"
-    EN_CA = "en-CA"
-    EN_GB = "en-GB"
-    EN_US = "en-US"
-    ES_ES = "es-ES"
-    ES_MX = "es-MX"
-    FI = "fi"
-    FR_CA = "fr-CA"
-    FR_FR = "fr-FR"
-    ID = "id"
-    IT = "it"
-    JA = "ja"
-    KO = "ko"
-    MS = "ms"
-    NL_NL = "nl-NL"
-    NO = "no"
-    PT_BR = "pt-BR"
-    PT_PT = "pt-PT"
-    RU = "ru"
-    SV = "sv"
-    TH = "th"
-    TR = "tr"
-    VI = "vi"
-    ZH_HANS = "zh-Hans"
-    ZH_HANT = "zh-Hant"
+    AR_SA = "ar-SA"  # Arabic
+    CA = "ca"  # Catalan
+    CS = "cs"  # Czech
+    DA = "da"  # Danish
+    DE_DE = "de-DE"  # German
+    EL = "el"  # Greek
+    EN_AU = "en-AU"  # English (Australia)
+    EN_CA = "en-CA"  # English (Canada)
+    EN_GB = "en-GB"  # English (U.K.)
+    EN_US = "en-US"  # English (U.S.)
+    ES_ES = "es-ES"  # Spanish (Spain)
+    ES_MX = "es-MX"  # Spanish (Mexico)
+    FI = "fi"  # Finnish
+    FR_CA = "fr-CA"  # French (Canada)
+    FR_FR = "fr-FR"  # French
+    HE = "he"  # Hebrew
+    HI = "hi"  # Hindi
+    HR = "hr"  # Croatian
+    HU = "hu"  # Hungarian
+    ID = "id"  # Indonesian
+    IT = "it"  # Italian
+    JA = "ja"  # Japanese
+    KO = "ko"  # Korean
+    MS = "ms"  # Malay
+    NL_NL = "nl-NL"  # Dutch
+    NO = "no"  # Norwegian
+    PL = "pl"  # Polish
+    PT_BR = "pt-BR"  # Portuguese (Brazil)
+    PT_PT = "pt-PT"  # Portuguese (Portugal)
+    RO = "ro"  # Romanian
+    RU = "ru"  # Russian
+    SK = "sk"  # Slovak
+    SV = "sv"  # Swedish
+    TH = "th"  # Thai
+    TR = "tr"  # Turkish
+    UK = "uk"  # Ukrainian
+    ZH_HANS = "zh-Hans"  # Chinese (Simplified)
+    ZH_HANT = "zh-Hant"  # Chinese (Traditional)
 
 
 class SubscriptionStatusUrlVersion(ResourceEnum):

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.6}/src/codemagic/cli/__init__.py

@@ -6,6 +6,7 @@ from .argument import Argument
 from .argument import ArgumentProperties
 from .argument import CommonArgumentTypes
 from .argument import EnvironmentArgumentValue
+from .argument import MutuallyExclusiveGroup
 from .argument import TypedCliArgument
 from .cli_app import CliApp
 from .cli_app import CliAppException

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.6}/src/codemagic/cli/argument/__init__.py

@@ -5,5 +5,6 @@ from .argument_formatter import ArgumentFormatter
 from .argument_parser_builder import ArgumentParserBuilder
 from .argument_properties import ArgumentProperties
 from .common_argument_types import CommonArgumentTypes
+from .mutually_exclusive_groups import MutuallyExclusiveGroup
 from .typed_cli_argument import EnvironmentArgumentValue
 from .typed_cli_argument import TypedCliArgument

codemagic_cli_tools-0.53.6/src/codemagic/cli/argument/argument_parser_builder.py

@@ -0,0 +1,220 @@
+from __future__ import annotations
+
+import argparse
+import dataclasses
+from typing import TYPE_CHECKING
+from typing import Dict
+from typing import Optional
+from typing import Sequence
+from typing import Tuple
+from typing import Type
+
+from codemagic.cli.cli_help_formatter import CliHelpFormatter
+from codemagic.cli.colors import Colors
+
+from .argument_formatter import ArgumentFormatter
+from .mutually_exclusive_groups import MutuallyExclusiveGroup
+from .mutually_exclusive_groups import MutuallyExclusiveGroups
+
+if TYPE_CHECKING:
+    from argparse import _ArgumentGroup as ArgumentGroup
+    from argparse import _SubParsersAction as SubParsersAction
+
+    from codemagic.cli import Argument
+    from codemagic.cli.argument import ActionCallable
+    from codemagic.cli.cli_app import CliApp
+
+
+@dataclasses.dataclass
+class _ArgumentGroups:
+    required: Optional[ArgumentGroup] = None
+    optionals: Optional[ArgumentGroup] = None
+    mutually_exclusive: Dict[MutuallyExclusiveGroup, ArgumentGroup] = dataclasses.field(default_factory=dict)
+    custom: Dict[str, ArgumentGroup] = dataclasses.field(default_factory=dict)
+
+    def register_arguments(self, arguments: Sequence[Argument]):
+        argument_group: Optional[ArgumentGroup]
+        for argument in arguments:
+            if argument.argument_group_name:
+                argument_group = self.custom[argument.argument_group_name]
+            elif argument.mutually_exclusive_group:
+                argument_group = self.mutually_exclusive[argument.mutually_exclusive_group]
+            elif argument.is_required():
+                argument_group = self.required
+            else:
+                argument_group = self.optionals
+
+            if argument_group:
+                argument.register(argument_group)
+
+
+class ArgumentParserBuilder:
+    def __init__(
+        self,
+        cli_app: Type[CliApp],
+        cli_action: ActionCallable,
+        parent_parser: SubParsersAction,
+        for_deprecated_alias: bool = False,
+    ):
+        self._cli_app = cli_app
+        self._cli_action = cli_action
+        self._action_parser = self._create_action_parser(parent_parser, for_deprecated_alias)
+
+    def _create_action_parser(self, parent_parser: SubParsersAction, for_deprecated_alias: bool):
+        if for_deprecated_alias:
+            if self._cli_action.deprecation_info is None:
+                raise RuntimeError(f"Deprecated alias requested for {self._cli_action.action_name} without alias")
+
+            deprecation_message = self._cli_action.deprecation_info.get_message(
+                self._full_action_name,
+                Colors.YELLOW,
+                Colors.BOLD,
+            )
+            return parent_parser.add_parser(
+                self._cli_action.deprecation_info.alias,
+                formatter_class=CliHelpFormatter,
+                description=f"{deprecation_message} {Colors.BOLD(self._cli_action.__doc__)}",
+            )
+        else:
+            return parent_parser.add_parser(
+                self._cli_action.action_name,
+                formatter_class=CliHelpFormatter,
+                description=Colors.BOLD(self._cli_action.__doc__),
+                help=self._cli_action.__doc__,
+            )
+
+    @property
+    def _full_action_name(self) -> str:
+        executable = self._cli_app.get_executable_name()
+        if self._cli_action.action_group:
+            return f"{executable} {self._cli_action.action_group.name} {self._cli_action.action_name}"
+        else:
+            return f"{executable} {self._cli_action.action_name}"
+
+    @classmethod
+    def set_default_cli_options(cls, cli_options_parser):
+        options_group = cli_options_parser.add_argument_group(Colors.UNDERLINE("Options"))
+        options_group.add_argument(
+            "--log-stream",
+            type=str,
+            default="stderr",
+            choices=["stderr", "stdout"],
+            help=f'Log output stream. {ArgumentFormatter.format_default_value("stderr")}',
+        )
+        options_group.add_argument(
+            "--no-color",
+            dest="no_color",
+            action="store_true",
+            help="Do not use ANSI colors to format terminal output",
+        )
+        options_group.add_argument(
+            "--version",
+            dest="show_version",
+            action="store_true",
+            help="Show tool version and exit",
+        )
+        options_group.add_argument(
+            "-s",
+            "--silent",
+            dest="enable_logging",
+            action="store_false",
+            help="Disable log output for commands",
+        )
+        options_group.add_argument(
+            "-v",
+            "--verbose",
+            dest="verbose",
+            action="store_true",
+            help="Enable verbose logging for commands",
+        )
+
+        options_group.set_defaults(
+            enable_logging=True,
+            no_color=False,
+            show_version=False,
+            verbose=False,
+        )
+
+    @staticmethod
+    def _get_mutually_exclusive_group_texts(group: MutuallyExclusiveGroup, executable: str) -> Tuple[str, str]:
+        if group.required:
+            title_prefix, description_prefix, description_verb = "Required", "Exactly", "must"
+        else:
+            title_prefix, description_prefix, description_verb = "Optional", "Only", "can"
+
+        title = f"{title_prefix} mutually exclusive arguments for {executable} to {Colors.BOLD(group.name)}"
+        description = f"{description_prefix} one of those options {description_verb} be selected"
+        return title, description
+
+    def _setup_custom_argument_groups(self, group_names: Sequence[str], executable) -> Dict[str, ArgumentGroup]:
+        argument_groups = {}
+        for group_name in group_names:
+            description = f"Optional arguments for {executable} to {Colors.BOLD(group_name)}"
+            argument_group = self._action_parser.add_argument_group(Colors.UNDERLINE(description))
+            argument_groups[group_name] = argument_group
+        return argument_groups
+
+    def _setup_mutually_exclusive_groups(
+        self,
+        mutually_exclusive_groups: Sequence[MutuallyExclusiveGroup],
+        executable: str,
+    ) -> Dict[MutuallyExclusiveGroup, ArgumentGroup]:
+        argument_groups = {}
+        for mutually_exclusive_group in mutually_exclusive_groups:
+            title, description = self._get_mutually_exclusive_group_texts(mutually_exclusive_group, executable)
+            argument_group = self._action_parser.add_argument_group(Colors.UNDERLINE(title), description)
+            mutually_exclusive_argument_group = argument_group.add_mutually_exclusive_group(
+                required=mutually_exclusive_group.required,
+            )
+            argument_groups[mutually_exclusive_group] = mutually_exclusive_argument_group
+        return argument_groups
+
+    def _setup_cli_app_options(self):
+        executable = self._action_parser.prog.split()[0]
+
+        mutually_exclusive_groups = MutuallyExclusiveGroups.from_argument_list(self._cli_app.CLASS_ARGUMENTS)
+
+        argument_groups = _ArgumentGroups()
+
+        required_args_title = Colors.UNDERLINE(f"Required arguments for {Colors.BOLD(executable)}")
+        argument_groups.required = self._action_parser.add_argument_group(required_args_title)
+        argument_groups.mutually_exclusive.update(
+            self._setup_mutually_exclusive_groups(mutually_exclusive_groups.required, executable),
+        )
+
+        optional_args_title = Colors.UNDERLINE(f"Optional arguments for {Colors.BOLD(executable)}")
+        argument_groups.optionals = self._action_parser.add_argument_group(optional_args_title)
+        argument_groups.mutually_exclusive.update(
+            self._setup_mutually_exclusive_groups(mutually_exclusive_groups.optional, executable),
+        )
+
+        argument_groups.register_arguments(self._cli_app.CLASS_ARGUMENTS)
+
+    def _setup_cli_action_options(self):
+        executable = f"command {self._cli_action.action_name}"
+        mutually_exclusive_groups = MutuallyExclusiveGroups.from_argument_list(self._cli_action.arguments)
+
+        argument_groups = _ArgumentGroups()
+
+        required_args_title = f"Required arguments for command {Colors.BOLD(self._cli_action.action_name)}"
+        argument_groups.required = self._action_parser.add_argument_group(Colors.UNDERLINE(required_args_title))
+        argument_groups.mutually_exclusive.update(
+            self._setup_mutually_exclusive_groups(mutually_exclusive_groups.required, executable),
+        )
+
+        optional_args_title = f"Optional arguments for command {Colors.BOLD(self._cli_action.action_name)}"
+        argument_groups.optionals = self._action_parser.add_argument_group(Colors.UNDERLINE(optional_args_title))
+        argument_groups.mutually_exclusive.update(
+            self._setup_mutually_exclusive_groups(mutually_exclusive_groups.optional, executable),
+        )
+
+        custom_group_names = {a.argument_group_name for a in self._cli_action.arguments if a.argument_group_name}
+        argument_groups.custom = self._setup_custom_argument_groups(sorted(custom_group_names), executable)
+
+        argument_groups.register_arguments(self._cli_action.arguments)
+
+    def build(self) -> argparse.ArgumentParser:
+        self._setup_cli_app_options()
+        self._setup_cli_action_options()
+        self.set_default_cli_options(self._action_parser)
+        return self._action_parser

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.6}/src/codemagic/cli/argument/argument_properties.py

@@ -2,6 +2,7 @@
 from __future__ import annotations
 
 import copy
+from typing import TYPE_CHECKING
 from typing import Any
 from typing import Callable
 from typing import Dict
@@ -11,6 +12,9 @@ from typing import Tuple
 from typing import Type
 from typing import Union
 
+if TYPE_CHECKING:
+    from codemagic.cli import MutuallyExclusiveGroup
+
 
 class ArgumentProperties(NamedTuple):
     key: str
@@ -19,6 +23,7 @@ class ArgumentProperties(NamedTuple):
     flags: Tuple[str, ...] = tuple()
     argparse_kwargs: Optional[Dict[str, Any]] = None
     argument_group_name: Optional[str] = None
+    mutually_exclusive_group: Optional[MutuallyExclusiveGroup] = None
 
     @classmethod
     def duplicate(cls, template: Union[Tuple, ArgumentProperties], **overwrites) -> ArgumentProperties:

codemagic_cli_tools-0.53.6/src/codemagic/cli/argument/mutually_exclusive_groups.py

@@ -0,0 +1,35 @@
+from __future__ import annotations
+
+import dataclasses
+from typing import NamedTuple
+from typing import Sequence
+
+from .argument import Argument
+
+
+class MutuallyExclusiveGroup(NamedTuple):
+    name: str
+    required: bool
+
+
+@dataclasses.dataclass(frozen=True)
+class MutuallyExclusiveGroups:
+    required: Sequence[MutuallyExclusiveGroup]
+    optional: Sequence[MutuallyExclusiveGroup]
+
+    @classmethod
+    def from_argument_list(cls, arguments: Sequence[Argument]) -> MutuallyExclusiveGroups:
+        required_groups, optional_groups = set(), set()
+
+        for argument in arguments:
+            if not argument.mutually_exclusive_group:
+                continue
+            elif argument.mutually_exclusive_group.required:
+                required_groups.add(argument.mutually_exclusive_group)
+            else:
+                optional_groups.add(argument.mutually_exclusive_group)
+
+        return MutuallyExclusiveGroups(
+            required=tuple(required_groups),
+            optional=tuple(optional_groups),
+        )

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.6}/src/codemagic/models/enums.py

@@ -1,6 +1,10 @@
+from __future__ import annotations
+
 import contextlib
 import enum
 import re
+from typing import Dict
+from typing import Tuple
 
 from codemagic.utilities import log
 
@@ -19,6 +23,8 @@ class ResourceEnumMeta(enum.EnumMeta):
     graceful_fallback = True
     enable_name_transformation = False
 
+    __graceful_fallback_cache: Dict[Tuple[str, str], str] = {}
+
     def __call__(cls, value, *args, **kwargs):  # noqa: N805
         try:
             return super().__call__(value, *args, **kwargs)
@@ -29,11 +35,21 @@ class ResourceEnumMeta(enum.EnumMeta):
             logger = log.get_logger(cls, log_to_stream=False)
             logger.warning("Undefined Resource enumeration: %s", ve)
             try:
-                enum_class = ResourceEnum(f"Graceful{cls.__name__}", {value: value})
-                return enum_class(value)
+                return cls._create_graceful_fallback_instance(value)
             except TypeError:
                 raise ve
 
+    def _create_graceful_fallback_instance(cls, value):  # noqa: N805
+        cache_key = (cls.__name__, value)
+
+        try:
+            enum_class = cls.__graceful_fallback_cache[cache_key]
+        except KeyError:
+            enum_class = ResourceEnum(f"Graceful{cls.__name__}", {value: value})
+            cls.__graceful_fallback_cache[cache_key] = enum_class
+
+        return enum_class(value)
+
     def _transform_class_name(cls):  # noqa: N805
         """
         If enabled, transform CamelCase class name 'ClassName' to more

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.6}/src/codemagic/tools/firebase_app_distribution/action_groups/releases_action_group.py

@@ -38,7 +38,7 @@ class ReleasesActionGroup(FirebaseAppDistributionAction, ABC):
         List releases for the Firebase application
         """
 
-        app_identifier = AppIdentifier(self.project_id, app_id)
+        app_identifier = AppIdentifier(self.project_number, app_id)
         try:
             releases = self.client.releases.list(app_identifier, order_by, limit)
         except GoogleError as e:

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.6}/src/codemagic/tools/firebase_app_distribution/actions/get_latest_build_version_action.py

@@ -18,7 +18,7 @@ class GetLatestBuildVersionAction(FirebaseAppDistributionAction, ABC):
         """
         Get latest build version from Firebase
         """
-        app_identifier = AppIdentifier(self.project_id, app_id)
+        app_identifier = AppIdentifier(self.project_number, app_id)
         try:
             releases = self.client.releases.list(app_identifier, limit=1)
         except GoogleError as e:

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.6}/src/codemagic/tools/firebase_app_distribution/arguments.py

@@ -4,13 +4,24 @@ from codemagic.google.resources import OrderBy
 
 from .argument_types import CredentialsArgument
 
+select_project_group = cli.MutuallyExclusiveGroup(
+    name="select project",
+    required=True,
+)
+
 
 class FirebaseArgument(cli.Argument):
     PROJECT_ID = cli.ArgumentProperties(
         key="project_id",
-        flags=("--project-id", "-p"),
-        description=f'Project ID in Firebase. For example `{Colors.WHITE("228333310124")}`',
-        argparse_kwargs={"required": True},
+        flags=("--project-id",),
+        description=f'Deprecated in version 0.53.5. Use `{Colors.BRIGHT_BLUE("--project-number")}` instead',
+        mutually_exclusive_group=select_project_group,
+    )
+    PROJECT_NUMBER = cli.ArgumentProperties(
+        key="project_number",
+        flags=("--project-number", "-p"),
+        description=f'Project number in Firebase. For example `{Colors.WHITE("228333310124")}`',
+        mutually_exclusive_group=select_project_group,
     )
     FIREBASE_SERVICE_ACCOUNT_CREDENTIALS = cli.ArgumentProperties(
         key="credentials",

codemagic_cli_tools-0.53.6/src/codemagic/tools/firebase_app_distribution/firebase_app_distribution.py

@@ -0,0 +1,88 @@
+#!/usr/bin/env python3
+
+from __future__ import annotations
+
+import argparse
+from typing import Dict
+from typing import Optional
+
+from codemagic import cli
+from codemagic.google.firebase_client import FirebaseClient
+from codemagic.utilities import log
+from codemagic.utilities.decorators import deprecated
+
+from .action_groups import ReleasesActionGroup
+from .actions import GetLatestBuildVersionAction
+from .arguments import FirebaseArgument
+
+
+@cli.common_arguments(
+    FirebaseArgument.PROJECT_ID,
+    FirebaseArgument.PROJECT_NUMBER,
+    FirebaseArgument.FIREBASE_SERVICE_ACCOUNT_CREDENTIALS,
+)
+class FirebaseAppDistribution(
+    cli.CliApp,
+    GetLatestBuildVersionAction,
+    ReleasesActionGroup,
+):
+    """
+    Utility to list releases and retrieve the latest release build version number from Firebase
+    """
+
+    def __init__(
+        self,
+        credentials: Dict,
+        project_number: Optional[str] = None,
+        project_id: Optional[str] = None,
+        **kwargs,
+    ):
+        if not project_id and not project_number:
+            raise ValueError("Missing project_number")
+        super().__init__(**kwargs)
+        self.client = FirebaseClient(credentials)
+        self._project_id = project_id
+        self._project_number = project_number
+        if project_id:
+            _ = self.project_id  # Just to trigger deprecation warning
+
+    @property
+    @deprecated("0.53.5", 'Use "FirebaseAppDistribution.project_number" instead.')
+    def project_id(self):
+        return self.project_number
+
+    @property
+    def project_number(self):
+        if not self._project_number:
+            return self._project_id
+        return self._project_number
+
+    @classmethod
+    def from_cli_args(cls, cli_args: argparse.Namespace) -> FirebaseAppDistribution:
+        credentials_argument = FirebaseArgument.FIREBASE_SERVICE_ACCOUNT_CREDENTIALS.from_args(cli_args)
+        if credentials_argument is None:
+            raise FirebaseArgument.FIREBASE_SERVICE_ACCOUNT_CREDENTIALS.raise_argument_error()
+        project_id = FirebaseArgument.PROJECT_ID.from_args(cli_args)
+        if project_id:
+            message = (
+                "Deprecation warning! "
+                f'Flag "{FirebaseArgument.get_flag(FirebaseArgument.PROJECT_ID)}" was deprecated in version 0.53.5 '
+                "and is subject for removal in future releases. "
+                f'Use "{FirebaseArgument.get_flag(FirebaseArgument.PROJECT_NUMBER)}" instead.'
+            )
+            log.get_logger(cls).warning(cli.Colors.YELLOW(message))
+
+        project_number = FirebaseArgument.PROJECT_NUMBER.from_args(cli_args)
+
+        if not project_id and not project_number:
+            raise FirebaseArgument.PROJECT_NUMBER.raise_argument_error()
+
+        return FirebaseAppDistribution(
+            credentials_argument.value,
+            project_number=project_id or project_number,
+            **cls._parent_class_kwargs(cli_args),
+        )
+
+
+if __name__ == "__main__":
+    FirebaseAppDistribution.invoke_cli()

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.6}/src/codemagic/tools/firebase_app_distribution/firebase_app_distribution_action.py

@@ -16,7 +16,7 @@ class FirebaseAppDistributionAction(ABC):
 
     @property
     @abstractmethod
-    def project_id(self):
+    def project_number(self):
         ...
 
     @classmethod

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.6}/tests/models/enums/test_resource_enum.py

@@ -44,3 +44,12 @@ def test_context_manager(is_graceful_before):
         with pytest.raises(ValueError):
             MockEnum("invalid value")
     assert ResourceEnumMeta.graceful_fallback is is_graceful_before
+
+
+def test_graceful_fallback_identity():
+    ResourceEnumMeta.graceful_fallback = True
+    e1 = MockEnum("undefined-value")
+    e2 = MockEnum("undefined-value")
+    assert e1 is e2  # Enumerations with the same value should persist identity
+    assert e1 == e2  # Enumerations with the same value should be equal
+    assert e1.value == e2.value  # And of course their values should also be equal

{codemagic_cli_tools-0.53.4 → codemagic_cli_tools-0.53.6}/tests/tools/test_firebase_app_distribution.py

@@ -21,6 +21,7 @@ from googleapiclient import discovery
 from oauth2client.service_account import ServiceAccountCredentials
 
 credentials_argument = FirebaseArgument.FIREBASE_SERVICE_ACCOUNT_CREDENTIALS
+project_number_argument = FirebaseArgument.PROJECT_NUMBER
 project_id_argument = FirebaseArgument.PROJECT_ID
 
 
@@ -41,7 +42,8 @@ def register_args(cli_argument_group):
 def namespace_kwargs():
     ns_kwargs = {
         credentials_argument.key: CredentialsArgument('{"type":"service_account"}'),
-        project_id_argument.key: "228333310124",
+        project_number_argument.key: "228333310124",
+        project_id_argument.key: None,
     }
     for arg in FirebaseAppDistribution.CLASS_ARGUMENTS:
         if not hasattr(arg.type, "environment_variable_key"):
@@ -158,7 +160,7 @@ def app_identifier():
 
 @pytest.fixture
 def firebase_app_distribution(app_identifier):
-    return FirebaseAppDistribution({"type": "service_account"}, app_identifier.project_id)
+    return FirebaseAppDistribution({"type": "service_account"}, app_identifier.project_id, None)
 
 
 def test_list_releases(firebase_app_distribution, mock_releases_list, releases, app_identifier):