codemagic-cli-tools 0.53.3__tar.gz → 0.53.5__tar.gz

{codemagic_cli_tools-0.53.3 → codemagic_cli_tools-0.53.5}/PKG-INFO

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

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

{codemagic_cli_tools-0.53.3 → codemagic_cli_tools-0.53.5}/src/codemagic/__version__.py

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

{codemagic_cli_tools-0.53.3 → codemagic_cli_tools-0.53.5}/src/codemagic/__version__.py-e

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

{codemagic_cli_tools-0.53.3 → codemagic_cli_tools-0.53.5}/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.3 → codemagic_cli_tools-0.53.5}/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.5/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.3 → codemagic_cli_tools-0.53.5}/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.5/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.3 → codemagic_cli_tools-0.53.5}/src/codemagic/models/xctests/xcresulttool.py

@@ -2,7 +2,9 @@ from __future__ import annotations
 
 import json
 import pathlib
+import re
 import subprocess
+from functools import lru_cache
 from tempfile import NamedTemporaryFile
 from typing import TYPE_CHECKING
 from typing import Any
@@ -11,9 +13,12 @@ from typing import List
 from typing import Optional
 from typing import Sequence
 
+from packaging.version import Version
+
 from codemagic.cli import CommandArg
 from codemagic.mixins import RunningCliAppMixin
 from codemagic.mixins import StringConverterMixin
+from codemagic.utilities import log
 
 if TYPE_CHECKING:
     from codemagic.cli import CliApp
@@ -26,6 +31,42 @@ class XcResultToolError(IOError):
 
 
 class XcResultTool(RunningCliAppMixin, StringConverterMixin):
+    @classmethod
+    @lru_cache(1)
+    def get_tool_version(cls) -> Optional[Version]:
+        # Cache xcresulttool version to avoid repeated checks.
+        # Assumes Xcode (and thus xcresulttool) version remains constant during execution.
+
+        cmd_args = ["xcrun", "xcresulttool", "version"]
+        try:
+            stdout = cls._run_command(cmd_args, "Failed to obtain xcresulttool version")
+        except XcResultToolError as e:
+            log.get_file_logger(cls).exception(str(e))
+            return None
+
+        version_output = cls._str(stdout.strip())
+        # Expected version output of xcresulttool (bundled with Xcode 16.0 beta 3) is as follows:
+        # xcresulttool version 23024, format version 3.53 (current)
+        match = re.match(r"^xcresulttool version (?P<version>\d+(\.\d+)?)", version_output)
+
+        if not match:
+            log.get_file_logger(cls).error("Failed to capture xcresulttool version from %r", version_output)
+            return None
+
+        return Version(match.group("version"))
+
+    @classmethod
+    def _requires_legacy_flag(cls) -> bool:
+        """
+        Starting from Xcode 16 beta 3 'xcresulttool get --format json' has been deprecated and
+        cannot be used without '--legacy' flag.
+        """
+
+        version = cls.get_tool_version()
+        if not version:
+            return False
+        return version >= Version("23021")
+
     @classmethod
     def get_bundle(cls, xcresult: pathlib.Path) -> Dict[str, Any]:
         cmd_args: List[CommandArg] = [
@@ -37,6 +78,10 @@ class XcResultTool(RunningCliAppMixin, StringConverterMixin):
             "--path",
             xcresult.expanduser(),
         ]
+
+        if cls._requires_legacy_flag():
+            cmd_args.append("--legacy")
+
         stdout = cls._run_command(cmd_args, f"Failed to get result bundle object from {xcresult}")
         return json.loads(stdout)
 
@@ -53,6 +98,10 @@ class XcResultTool(RunningCliAppMixin, StringConverterMixin):
             "--id",
             object_id,
         ]
+
+        if cls._requires_legacy_flag():
+            cmd_args.append("--legacy")
+
         stdout = cls._run_command(cmd_args, f"Failed to get result bundle object {object_id} from {xcresult}")
         return json.loads(stdout)
 
@@ -82,8 +131,8 @@ class XcResultTool(RunningCliAppMixin, StringConverterMixin):
         Replace default stdout stream with direct file handle to bypass stream
         processing in Python which can be very slow. For example
         `xcrun xcresulttool get --format json --path results.xcresult --id 'object-id'`
-        can output 500K+ lines at 30+ MB. Processing it in small chunks in Python is very time
-        consuming whereas using file handles is almost instantaneous.
+        can output 500K+ lines at 30+ MB. Processing it in small chunks in Python is very
+        time-consuming whereas using file handles is almost instantaneous.
         """
         with NamedTemporaryFile(mode="w+b") as stdout_fd:
             process = cli_app.execute(command_args, suppress_output=True, stdout=stdout_fd)

{codemagic_cli_tools-0.53.3 → codemagic_cli_tools-0.53.5}/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.3 → codemagic_cli_tools-0.53.5}/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.3 → codemagic_cli_tools-0.53.5}/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.5/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.3 → codemagic_cli_tools-0.53.5}/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.5/tests/models/xctests/test_xcresulttool.py

@@ -0,0 +1,24 @@
+from typing import Optional
+from unittest import mock
+
+import pytest
+from codemagic.models.xctests import XcResultTool
+from packaging.version import Version
+
+
+@pytest.mark.parametrize(
+    ("xcresulttool_version", "expected_result"),
+    (
+        (None, False),
+        (Version("0"), False),
+        (Version("1"), False),
+        (Version("23020.9"), False),
+        (Version("23021"), True),
+        (Version("23021.1"), True),
+        (Version("23022"), True),
+        (Version("33022"), True),
+    ),
+)
+def test_requires_legacy_flag(xcresulttool_version: Optional[Version], expected_result: bool):
+    with mock.patch.object(XcResultTool, "get_tool_version", new=mock.MagicMock(return_value=xcresulttool_version)):
+        assert expected_result is XcResultTool._requires_legacy_flag()

{codemagic_cli_tools-0.53.3 → codemagic_cli_tools-0.53.5}/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):