pytest-embedded 1.2.5__tar.gz → 1.3.0__tar.gz

{pytest-embedded-1.2.5 → pytest-embedded-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.2
 Name: pytest-embedded
-Version: 1.2.5
+Version: 1.3.0
 Summary: pytest embedded plugin
 Home-page: https://docs.espressif.com/projects/pytest-embedded/en/latest/
 Author: Fu Hanxi

{pytest-embedded-1.2.5 → pytest-embedded-1.3.0}/pytest_embedded/dut.py

@@ -9,10 +9,10 @@ import pexpect
 from .app import App
 from .log import PexpectProcess
 from .unity import UNITY_SUMMARY_LINE_REGEX, TestSuite
-from .utils import Meta, remove_asci_color_code, to_bytes, to_list
+from .utils import Meta, _InjectMixinCls, remove_asci_color_code, to_bytes, to_list
 
 
-class Dut:
+class Dut(_InjectMixinCls):
     """
     Device under test (DUT) base class
 
@@ -160,7 +160,7 @@ class Dut:
             - Would raise TIMEOUT exception at the end of the test if any unity test case execution took longer
                 than timeout value
 
-        Warnings:
+        Warning:
             - All unity test cases record would be missed if the final report block is uncaught.
         """
         self.expect(UNITY_SUMMARY_LINE_REGEX, timeout=timeout)
@@ -174,3 +174,25 @@ class Dut:
             log = remove_asci_color_code(log)
 
         self.testsuite.add_unity_test_cases(log)
+
+    @_InjectMixinCls.require_services('idf')
+    def run_all_single_board_cases(
+        self,
+        group: Optional[str] = None,
+        reset: bool = False,
+        timeout: float = 30,
+        run_ignore_cases: bool = False,
+    ):
+        """
+        Run all multi_stage cases
+
+        Args:
+            group: test case group
+            reset: whether to perform a hardware reset before running a case
+            timeout: timeout. (Default: 30 seconds)
+            run_ignore_cases: run ignored test cases or not
+
+        Warning:
+            requires enable service `idf`
+        """
+        pass

{pytest-embedded-1.2.5 → pytest-embedded-1.3.0}/pytest_embedded/plugin.py

@@ -216,7 +216,7 @@ def pytest_addoption(parser):
     )
     qemu_group.addoption(
         '--qemu-cli-args',
-        help='QEMU cli default arguments. (Default: "-nographic -no-reboot -machine esp32")',
+        help='QEMU cli default arguments. (Default: "-nographic -machine esp32")',
     )
     qemu_group.addoption(
         '--qemu-extra-args',
@@ -227,6 +227,15 @@ def pytest_addoption(parser):
         help='y/yes/true for True and n/no/false for False. '
         'Set to True to disable auto regenerate image. (Default: False)',
     )
+    qemu_group.addoption(
+        '--encrypt',
+        help='y/yes/true for True and n/no/false for False. '
+        'Set to True for pre-encryption workflow (Default: False)',
+    )
+    qemu_group.addoption(
+        '--keyfile',
+        help='Flash Encryption (pre-encrypted workflow) key path. (Default: None)',
+    )
 
 
 ###########
@@ -898,6 +907,20 @@ def skip_regenerate_image(request: FixtureRequest) -> t.Optional[str]:
     return _request_param_or_config_option_or_default(request, 'skip_regenerate_image', None)
 
 
+@pytest.fixture
+@multi_dut_argument
+def encrypt(request: FixtureRequest) -> t.Optional[str]:
+    """Enable parametrization for the same cli option"""
+    return _request_param_or_config_option_or_default(request, 'encrypt', None)
+
+
+@pytest.fixture
+@multi_dut_argument
+def keyfile(request: FixtureRequest) -> t.Optional[str]:
+    """Enable parametrization for the same cli option"""
+    return _request_param_or_config_option_or_default(request, 'keyfile', None)
+
+
 ####################
 # Private Fixtures #
 ####################
@@ -924,6 +947,7 @@ def _services(embedded_services: t.Optional[str]) -> t.List[str]:
 @dataclass
 class ClassCliOptions:
     classes: t.Dict[str, type]
+    mixins: t.Dict[str, t.List[type]]
     kwargs: t.Dict[str, t.Dict[str, t.Any]]
 
 
@@ -958,6 +982,8 @@ def _fixture_classes_and_options(
     qemu_cli_args,
     qemu_extra_args,
     skip_regenerate_image,
+    encrypt,
+    keyfile,
     # pre-initialized fixtures
     dut_index,
     _pexpect_logfile,
@@ -985,6 +1011,7 @@ def _fixture_classes_and_options(
     }
     """
     classes: t.Dict[str, type] = {}
+    mixins: t.Dict[str, t.List[type]] = defaultdict(list)
     kwargs: t.Dict[str, t.Dict[str, t.Any]] = defaultdict(dict)
 
     for fixture in FIXTURES_SERVICES.keys():
@@ -1001,6 +1028,8 @@ def _fixture_classes_and_options(
                             'part_tool': part_tool,
                             'qemu_image_path': qemu_image_path,
                             'skip_regenerate_image': skip_regenerate_image,
+                            'encrypt': encrypt,
+                            'keyfile': keyfile,
                         }
                     )
                 else:
@@ -1099,16 +1128,23 @@ def _fixture_classes_and_options(
                     }
         elif fixture == 'qemu':
             if 'qemu' in _services:
-                from pytest_embedded_qemu import DEFAULT_IMAGE_FN, Qemu
+                from pytest_embedded_qemu import (
+                    DEFAULT_IMAGE_FN,
+                    ENCRYPTED_IMAGE_FN,
+                    Qemu,
+                )
 
                 classes[fixture] = Qemu
                 kwargs[fixture] = {
                     'msg_queue': msg_queue,
                     'qemu_image_path': qemu_image_path
-                    or os.path.join(app_path or '', build_dir or 'build', DEFAULT_IMAGE_FN),
+                    or os.path.join(
+                        app_path or '', build_dir or 'build', ENCRYPTED_IMAGE_FN if encrypt else DEFAULT_IMAGE_FN
+                    ),
                     'qemu_prog_path': qemu_prog_path,
                     'qemu_cli_args': qemu_cli_args,
                     'qemu_extra_args': qemu_extra_args,
+                    'app': None,
                     'meta': _meta,
                 }
         elif fixture == 'dut':
@@ -1130,6 +1166,11 @@ def _fixture_classes_and_options(
                         'qemu': None,
                     }
                 )
+
+                if 'idf' in _services:
+                    from pytest_embedded_idf.unity_tester import IdfUnityDutMixin
+
+                    mixins[fixture].append(IdfUnityDutMixin)
             elif 'jtag' in _services:
                 if 'idf' in _services:
                     from pytest_embedded_idf import IdfDut
@@ -1169,7 +1210,7 @@ def _fixture_classes_and_options(
                     }
                 )
 
-    return ClassCliOptions(classes, kwargs)
+    return ClassCliOptions(classes, mixins, kwargs)
 
 
 ####################
@@ -1268,6 +1309,7 @@ def dut(
         return cls(**kwargs)
 
     cls = _fixture_classes_and_options.classes['dut']
+    mixins = _fixture_classes_and_options.mixins['dut']
     kwargs = _fixture_classes_and_options.kwargs['dut']
 
     for k, v in kwargs.items():
@@ -1283,7 +1325,7 @@ def dut(
             elif k == 'qemu':
                 kwargs[k] = qemu
 
-    return cls(**_drop_none_kwargs(kwargs))
+    return cls(**_drop_none_kwargs(kwargs), mixins=mixins)
 
 
 @pytest.fixture

{pytest-embedded-1.2.5 → pytest-embedded-1.3.0}/pytest_embedded/utils.py

@@ -33,6 +33,12 @@ FIXTURES_SERVICES = {
 
 _T = t.TypeVar('_T')
 
+_MIXIN_REQUIRED_SERVICES = {
+    'IdfUnityMixin': ['idf'],
+}
+
+_MIXIN_REQUIRED_SERVICES_KEY = '_based_on_services'
+
 
 #######################
 # Errors and Warnings #
@@ -54,6 +60,16 @@ class PackageNotInstalledError(SystemExit):
         )
 
 
+class RequireServiceError(SystemExit):
+    def __init__(self, func_name: str, services: t.Union[str, t.List[str]]) -> None:
+        services_str = ','.join(to_list(services))
+        super().__init__(
+            f'function {func_name} requires enabling one of the service(s) {services_str}. '
+            f'Please enable by passing CLI options "--embedded-services {services_str}". '
+            f'For more details, please refer to "pytest --help".'
+        )
+
+
 #####################
 # Utility Functions #
 #####################
@@ -245,3 +261,80 @@ def lazy_load(
             raise AttributeError('Attribute %s not found in module %s', object_name, base_module.__name__)
 
     return __getattr__
+
+
+class _InjectMixinMeta(type):
+    def __call__(cls, *args, **kwargs):
+        try:
+            mixins = kwargs.pop('mixins', None)
+            if mixins:
+                mixins = to_list(mixins)
+                name = cls.__name__ + 'With' + 'And'.join([m.__name__ for m in mixins])
+                cls = type(name, tuple([*mixins, cls]), {})
+
+                # users should only know concept "services", not mixins
+                _based_on_services = set()
+                for m in mixins:
+                    if m.__name__ not in _MIXIN_REQUIRED_SERVICES:
+                        continue
+
+                    _based_on_services.update(to_list(_MIXIN_REQUIRED_SERVICES[m.__name__]))
+                kwargs[_MIXIN_REQUIRED_SERVICES_KEY] = sorted(_based_on_services)
+        except KeyError:
+            pass
+        return type.__call__(cls, *args, **kwargs)
+
+
+class _InjectMixinCls(metaclass=_InjectMixinMeta):
+    """
+    This class provide a check function `require_services()` to check if the function is injected by
+    enabling one of the required services.
+
+    The benefits are:
+    - provide the autocompletion for the functions provided by the mixins
+    - check the requirement at runtime
+
+    Examples:
+
+        class IdfUnityMixin:
+            def foo(self):
+                print('foo from MixinOne')
+
+
+        class Test(_InjectMixinCls):
+            def __init__(self, **kwargs):
+                for k, v in kwargs.items():
+                    setattr(self, k, v)
+
+            @_InjectMixinCls.require_services('idf')
+            def foo(self):
+                pass
+
+
+        # mro(): TestWithIdfUnityMixin, IdfUnityMixin, Test, object
+        s1 = Test(mixins=IdfUnityMixin)
+        # mro(): Test, object
+        s2 = Test()
+        s1.foo()  # foo from IdfUnityMixin
+        s2.foo()  # function foo requires enabling one of the service(s) idf.
+    """
+
+    def require_services(*services):
+        def decorator(func):
+            def wrapped(self, *args, **kwargs):
+                based = False
+                for service in services:
+                    if hasattr(self, _MIXIN_REQUIRED_SERVICES_KEY) and service in getattr(
+                        self, _MIXIN_REQUIRED_SERVICES_KEY
+                    ):
+                        based = True
+                        break
+
+                if based:
+                    return func(self, *args, **kwargs)
+                else:
+                    raise RequireServiceError(func.__name__, services)
+
+            return wrapped
+
+        return decorator

{pytest-embedded-1.2.5 → pytest-embedded-1.3.0}/pytest_embedded.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 1.2
 Name: pytest-embedded
-Version: 1.2.5
+Version: 1.3.0
 Summary: pytest embedded plugin
 Home-page: https://docs.espressif.com/projects/pytest-embedded/en/latest/
 Author: Fu Hanxi