codemagic-cli-tools 0.50.0__tar.gz → 0.50.2__tar.gz

{codemagic_cli_tools-0.50.0 → codemagic_cli_tools-0.50.2}/PKG-INFO

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

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

{codemagic_cli_tools-0.50.0 → codemagic_cli_tools-0.50.2}/src/codemagic/__version__.py

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

{codemagic_cli_tools-0.50.0 → codemagic_cli_tools-0.50.2}/src/codemagic/__version__.py-e

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

{codemagic_cli_tools-0.50.0 → codemagic_cli_tools-0.50.2}/src/codemagic/models/export_options.py

@@ -107,6 +107,12 @@ ExportOptionValue = Union[
 
 @dataclass
 class ExportOptions(StringConverterMixin):
+    """
+    Definition for Xcode export options. Available keys and their allowed types
+    can be seen from `xcodebuild -help` output under section
+    "Available keys for -exportOptionsPlist"
+    """
+
     compileBitcode: Optional[bool] = None
     destination: Optional[Destination] = None
     distributionBundleIdentifier: Optional[str] = None
@@ -114,8 +120,8 @@ class ExportOptions(StringConverterMixin):
     generateAppStoreInformation: Optional[bool] = None
     iCloudContainerEnvironment: Optional[str] = None
     installerSigningCertificate: Optional[str] = None
-    manifest: Optional[Manifest] = None
     manageAppVersionAndBuildNumber: Optional[bool] = None
+    manifest: Optional[Manifest] = None
     method: Optional[ArchiveMethod] = None
     onDemandResourcesAssetPacksBaseURL: Optional[str] = None
     provisioningProfiles: Optional[List[ProvisioningProfileInfo]] = None
@@ -123,6 +129,7 @@ class ExportOptions(StringConverterMixin):
     signingStyle: Optional[SigningStyle] = None
     stripSwiftSymbols: Optional[bool] = None
     teamID: Optional[str] = None
+    testFlightInternalTestingOnly: Optional[bool] = None
     thinning: Optional[str] = None
     uploadBitcode: Optional[bool] = None
     uploadSymbols: Optional[bool] = None
@@ -132,8 +139,12 @@ class ExportOptions(StringConverterMixin):
             self.set_value(field_name, getattr(self, field_name))
 
     @classmethod
-    def _get_field_type(cls, field_name: str) -> type:
-        type_hint = get_type_hints(cls)[field_name]
+    def _get_field_type(cls, field_name: str) -> Optional[type]:
+        try:
+            type_hint = get_type_hints(cls)[field_name]
+        except KeyError:
+            # Type info is missing for unknown fields
+            return None
         if hasattr(type_hint, "__origin__") and type_hint.__origin__ is Union:
             # Optionals are unions of actual type and NoneType
             actual_type = type_hint.__args__[0]
@@ -183,7 +194,8 @@ class ExportOptions(StringConverterMixin):
 
     def set_value(self, field_name: str, value: ExportOptionValue):
         if field_name not in self.__dict__:
-            raise ValueError(f"Invalid filed {field_name}")
+            logger = log.get_logger(self.__class__)
+            logger.warning(Colors.YELLOW(f'Warning: Using unknown export option "{field_name}"'))
 
         field_type = self._get_field_type(field_name)
         if value is None:
@@ -192,9 +204,12 @@ class ExportOptions(StringConverterMixin):
             self._set_manifest(value)
         elif field_name == "provisioningProfiles":
             self._set_provisioning_profiles(value)
-        elif not isinstance(value, field_type):
-            with ResourceEnumMeta.without_graceful_fallback():
-                setattr(self, field_name, field_type(value))
+        elif field_type and not isinstance(value, field_type):
+            if issubclass(field_type, enum.Enum):
+                with ResourceEnumMeta.without_graceful_fallback():
+                    setattr(self, field_name, field_type(value))
+            else:
+                raise ValueError(f"Invalid value for {field_name!r}")
         else:
             setattr(self, field_name, value)
 
@@ -213,7 +228,11 @@ class ExportOptions(StringConverterMixin):
                 data = plistlib.load(fd)  # type: ignore
             except plistlib.InvalidFileException:
                 raise ValueError("Invalid plist")
-        return ExportOptions(**data)
+
+        export_options = ExportOptions()
+        for key_name, value in data.items():
+            export_options.set_value(field_name=key_name, value=value)
+        return export_options
 
     @classmethod
     def from_profile_assignments(cls, profile_assignments: Sequence[ProvisioningProfileAssignment]) -> ExportOptions:

{codemagic_cli_tools-0.50.0 → codemagic_cli_tools-0.50.2}/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.50.0 → codemagic_cli_tools-0.50.2}/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.0 → codemagic_cli_tools-0.50.2}/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.0 → codemagic_cli_tools-0.50.2}/tests/models/test_export_options.py

@@ -1,10 +1,17 @@
+import logging
+import plistlib
+import tempfile
 from tempfile import NamedTemporaryFile
 from tempfile import TemporaryDirectory
+from unittest import mock
 
 import pytest
+from codemagic.cli import Colors
 from codemagic.models import ExportOptions
 from codemagic.models.export_options import ProvisioningProfileInfo
 
+mock_logger = mock.Mock(spec=logging.Logger)
+
 
 def test_export_options_initialize_from_path(export_options_list_path, export_options_dict):
     export_options = ExportOptions.from_path(export_options_list_path)
@@ -74,14 +81,55 @@ def test_export_options_set_valid_values(field_name, value, export_options_dict)
         ("manifest", 1),
         ("manifest", 3.4),
         ("manifest", {"invalid_key": 1}),
-        ("invalid_field", -1),
         ("provisioningProfiles", [1]),
         ("provisioningProfiles", [ProvisioningProfileInfo("bundle_id", "name"), {"k": "v"}]),
         ("method", "invalid method"),
         ("destination", "invalid destination"),
+        ("teamID", -1),
+        ("teamID", True),
+        ("stripSwiftSymbols", "false"),
+        ("stripSwiftSymbols", "YES"),
     ],
 )
 def test_export_options_set_invalid_values(field_name, value, export_options_dict):
     export_options = ExportOptions(**export_options_dict)
     with pytest.raises(ValueError):
         export_options.set_value(field_name=field_name, value=value)
+
+
+@mock.patch("codemagic.models.export_options.log.get_logger", new=mock.Mock(return_value=mock_logger))
+def test_export_options_set_unknown_fields():
+    export_options = ExportOptions()
+    export_options.set_value(field_name="unknownExportOption", value=False)
+
+    expected_warning = 'Warning: Using unknown export option "unknownExportOption"'
+    mock_logger.warning.assert_called_once_with(Colors.YELLOW(expected_warning))
+    assert export_options.dict() == {"unknownExportOption": False}
+
+
+@mock.patch("codemagic.models.export_options.log.get_logger", new=mock.Mock(return_value=mock_logger))
+def test_export_options_unknown_fields_notify():
+    export_options = ExportOptions()
+    export_options.set_value(field_name="unknownExportOption", value=False)
+    export_options.notify("Title")
+
+    mock_logger.info.assert_has_calls(
+        [
+            mock.call("Title"),
+            mock.call(Colors.BLUE(" - Unknown Export Option: False")),
+        ],
+    )
+
+
+def test_export_options_unknown_fields_from_path():
+    expected_export_options = {
+        "signingStyle": "manual",  # Known field
+        "unknownExportOption": False,  # Unknown field
+    }
+
+    with tempfile.NamedTemporaryFile(mode="wb") as tf:
+        tf.write(plistlib.dumps(expected_export_options))
+        tf.flush()
+        export_options = ExportOptions.from_path(tf.name)
+
+    assert export_options.dict() == expected_export_options