pytest-embedded 2.7.0__tar.gz → 2.8.1__tar.gz

{pytest_embedded-2.7.0 → pytest_embedded-2.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pytest-embedded
-Version: 2.7.0
+Version: 2.8.1
 Summary: A pytest plugin that designed for embedded testing.
 Author-email: Fu Hanxi <fuhanxi@espressif.com>
 Requires-Python: >=3.10

{pytest_embedded-2.7.0 → pytest_embedded-2.8.1}/pytest_embedded/__init__.py

@@ -6,4 +6,4 @@ from .dut_factory import DutFactory
 
 __all__ = ['App', 'Dut', 'DutFactory']
 
-__version__ = '2.7.0'
+__version__ = '2.8.1'

{pytest_embedded-2.7.0 → pytest_embedded-2.8.1}/pytest_embedded/dut_factory.py

@@ -1,3 +1,4 @@
+import contextlib
 import datetime
 import gc
 import io
@@ -42,8 +43,19 @@ DUT_GLOBAL_INDEX = 0
 PARAMETRIZED_FIXTURES_CACHE = {}
 
 
-def _listen(q: MessageQueue, filepath: str, with_timestamp: bool = True, count: int = 1, total: int = 1) -> None:
+_STDOUT_LOCK = None
+
+
+def set_stdout_lock(lock) -> None:
+    global _STDOUT_LOCK
+    _STDOUT_LOCK = lock
+
+
+def _listen(
+    q: MessageQueue, filepath: str, with_timestamp: bool = True, count: int = 1, total: int = 1, _stdout_lock=None
+) -> None:
     shall_add_prefix = True
+    _pending = ''
     while True:
         msg = q.get()
         if not msg:
@@ -71,20 +83,25 @@ def _listen(q: MessageQueue, filepath: str, with_timestamp: bool = True, count:
         if _s.endswith('\n'):  # complete line
             shall_add_prefix = True
             _s = _s[:-1].replace('\n', '\n' + prefix) + '\n'
+            with _stdout_lock if _stdout_lock else contextlib.nullcontext():
+                _stdout.write(_pending + _s)
+                _stdout.flush()
+            _pending = ''
         else:
             shall_add_prefix = False
             _s = _s.replace('\n', '\n' + prefix)
-
-        _stdout.write(_s)
-        _stdout.flush()
+            _pending += _s
 
 
-def _listener_gn(msg_queue, _pexpect_logfile, with_timestamp, dut_index, dut_total) -> multiprocessing.Process:
+def _listener_gn(
+    msg_queue, _pexpect_logfile, with_timestamp, dut_index, dut_total, _stdout_lock=None
+) -> multiprocessing.Process:
     os.makedirs(os.path.dirname(_pexpect_logfile), exist_ok=True)
     kwargs = {
         'with_timestamp': with_timestamp,
         'count': dut_index,
         'total': dut_total,
+        '_stdout_lock': _stdout_lock,
     }
 
     return _ctx.Process(
@@ -124,6 +141,7 @@ def _fixture_classes_and_options_fn(
     erase_all,
     esptool_baud,
     esp_flash_force,
+    no_fast_flash,
     part_tool,
     confirm_target_elf_sha256,
     erase_nvs,
@@ -140,6 +158,7 @@ def _fixture_classes_and_options_fn(
     qemu_extra_args,
     qemu_efuse_path,
     wokwi_diagram,
+    wokwi_usb_serial_jtag,
     skip_regenerate_image,
     encrypt,
     keyfile,
@@ -236,6 +255,7 @@ def _fixture_classes_and_options_fn(
                     kwargs[fixture].update(
                         {
                             'app': None,
+                            'fast_flash': not no_fast_flash if no_fast_flash is not None else True,
                         }
                     )
                 elif 'nuttx' in _services:
@@ -318,6 +338,7 @@ def _fixture_classes_and_options_fn(
                 kwargs[fixture].update(
                     {
                         'wokwi_diagram': wokwi_diagram,
+                        'wokwi_usb_serial_jtag': wokwi_usb_serial_jtag,
                         'msg_queue': msg_queue,
                         'app': None,
                         'meta': _meta,
@@ -663,6 +684,7 @@ class DutFactory:
         erase_all: bool | None = None,
         esptool_baud: int | None = None,
         esp_flash_force: bool | None = False,
+        no_fast_flash: bool | None = None,
         part_tool: str | None = None,
         confirm_target_elf_sha256: bool | None = None,
         erase_nvs: bool | None = None,
@@ -679,6 +701,7 @@ class DutFactory:
         qemu_extra_args: str | None = None,
         qemu_efuse_path: str | None = None,
         wokwi_diagram: str | None = None,
+        wokwi_usb_serial_jtag: bool | None = None,
         skip_regenerate_image: bool | None = None,
         encrypt: bool | None = None,
         keyfile: str | None = None,
@@ -726,6 +749,7 @@ class DutFactory:
             qemu_extra_args: Additional QEMU arguments.
             qemu_efuse_path: Efuse binary path.
             wokwi_diagram: Wokwi diagram path.
+            wokwi_usb_serial_jtag: Use USB Serial JTAG instead of UART for Wokwi serial communication.
             skip_regenerate_image: Skip image regeneration flag.
             encrypt: Encryption flag.
             keyfile: Keyfile for encryption.
@@ -753,7 +777,9 @@ class DutFactory:
             )
             logging.debug('You can get your custom DUT log file at the following path: %s.', _pexpect_logfile)
 
-            _listener = _listener_gn(msg_queue, _pexpect_logfile, True, DUT_GLOBAL_INDEX, DUT_GLOBAL_INDEX + 1)
+            _listener = _listener_gn(
+                msg_queue, _pexpect_logfile, True, DUT_GLOBAL_INDEX, DUT_GLOBAL_INDEX + 1, _stdout_lock=_STDOUT_LOCK
+            )
             layout.append(_listener)
 
             _pexpect_fr = _pexpect_fr_gn(_pexpect_logfile, _listener)
@@ -778,6 +804,7 @@ class DutFactory:
                 'erase_all': erase_all,
                 'esptool_baud': esptool_baud,
                 'esp_flash_force': esp_flash_force,
+                'no_fast_flash': no_fast_flash,
                 'part_tool': part_tool,
                 'confirm_target_elf_sha256': confirm_target_elf_sha256,
                 'erase_nvs': erase_nvs,
@@ -794,6 +821,7 @@ class DutFactory:
                 'qemu_extra_args': qemu_extra_args,
                 'qemu_efuse_path': qemu_efuse_path,
                 'wokwi_diagram': wokwi_diagram,
+                'wokwi_usb_serial_jtag': wokwi_usb_serial_jtag,
                 'skip_regenerate_image': skip_regenerate_image,
                 'encrypt': encrypt,
                 'keyfile': keyfile,

{pytest_embedded-2.7.0 → pytest_embedded-2.8.1}/pytest_embedded/plugin.py

@@ -30,6 +30,7 @@ from .app import App
 from .dut import Dut
 from .dut_factory import (
     DutFactory,
+    _ctx,
     _fixture_classes_and_options_fn,
     _listener_gn,
     _pexpect_fr_gn,
@@ -41,6 +42,7 @@ from .dut_factory import (
     qemu_gn,
     serial_gn,
     set_parametrized_fixtures_cache,
+    set_stdout_lock,
     wokwi_gn,
 )
 from .log import MessageQueue, MessageQueueManager, PexpectProcess
@@ -207,6 +209,17 @@ def pytest_addoption(parser):
         action='store_true',
         help='force mode for esptool',
     )
+    arduino_group = parser.getgroup('embedded-arduino')
+    arduino_group.addoption(
+        '--no-fast-flash',
+        help=(
+            'y/yes/true for True and n/no/false for False. '
+            'Set to True to disable fast reflashing (--diff-with) for Arduino. '
+            'Useful when flash state is unknown, e.g. after OTA updates. '
+            '(Default: False)'
+        ),
+    )
+
     idf_group = parser.getgroup('embedded-idf')
     idf_group.addoption(
         '--supported-targets', help='Comma-separated list of supported targets for the test case. (Default: None)'
@@ -296,6 +309,13 @@ def pytest_addoption(parser):
         '--wokwi-diagram',
         help='Path to the wokwi diagram file (Default: None)',
     )
+    wokwi_group.addoption(
+        '--wokwi-usb-serial-jtag',
+        help='y/yes/true for True and n/no/false for False. '
+        'Use USB Serial JTAG instead of UART for serial communication in the Wokwi diagram. '
+        'When enabled, the diagram will use the USB_SERIAL_JTAG interface and remove $serialMonitor connections. '
+        '(Default: False)',
+    )
 
 
 ###########
@@ -695,6 +715,23 @@ def _mp_manager():
     manager.shutdown()
 
 
+@pytest.fixture(scope='session', autouse=True)
+def _stdout_lock():
+    """
+    A session-scoped multiprocessing lock used to serialize stdout writes across
+    all DUT listener processes, preventing garbled output when multiple DUTs
+    print to stdout simultaneously.
+
+    It is marked ``autouse=True`` so that the lock is created and registered
+    globally (via ``set_stdout_lock``) before any DUT fixture is instantiated,
+    ensuring every listener process receives a valid lock reference regardless
+    of test ordering.
+    """
+    lock = _ctx.Lock()
+    set_stdout_lock(lock)
+    yield lock
+
+
 @pytest.fixture
 def test_case_tempdir(test_case_name: str, session_tempdir: str) -> str:
     """Function scoped temp dir for pytest-embedded"""
@@ -746,13 +783,17 @@ def with_timestamp(request: FixtureRequest) -> bool:
 
 @pytest.fixture
 @multi_dut_generator_fixture
-def _listener(msg_queue, _pexpect_logfile, with_timestamp, dut_index, dut_total) -> multiprocessing.Process:
+def _listener(
+    msg_queue, _pexpect_logfile, with_timestamp, dut_index, dut_total, _stdout_lock
+) -> multiprocessing.Process:
     """
     The listener would create a `_listen` process. The `_listen` process would get the string from the message queue,
     and do two things together:
 
     1. print the string to `sys.stdout`
     2. write the string to `_pexpect_logfile`
+
+    A shared lock (_stdout_lock) is used to prevent interleaved output when multiple DUTs print simultaneously.
     """
     return _listener_gn(**locals())
 
@@ -819,6 +860,13 @@ def esp_flash_force(request: FixtureRequest) -> str | None:
     return _request_param_or_config_option_or_default(request, 'esp_flash_force', False)
 
 
+@pytest.fixture
+@multi_dut_argument
+def no_fast_flash(request: FixtureRequest) -> bool | None:
+    """Enable parametrization for the same cli option"""
+    return _request_param_or_config_option_or_default(request, 'no_fast_flash', None)
+
+
 @pytest.fixture
 @multi_dut_argument
 def build_dir(request: FixtureRequest) -> str | None:
@@ -1053,6 +1101,13 @@ def wokwi_diagram(request: FixtureRequest) -> str | None:
     return _request_param_or_config_option_or_default(request, 'wokwi_diagram', None)
 
 
+@pytest.fixture
+@multi_dut_argument
+def wokwi_usb_serial_jtag(request: FixtureRequest) -> bool | None:
+    """Enable parametrization for the same cli option"""
+    return _request_param_or_config_option_or_default(request, 'wokwi_usb_serial_jtag', None)
+
+
 ####################
 # Private Fixtures #
 ####################
@@ -1095,6 +1150,7 @@ def parametrize_fixtures(
     erase_all,
     esptool_baud,
     esp_flash_force,
+    no_fast_flash,
     part_tool,
     confirm_target_elf_sha256,
     erase_nvs,
@@ -1111,6 +1167,7 @@ def parametrize_fixtures(
     qemu_extra_args,
     qemu_efuse_path,
     wokwi_diagram,
+    wokwi_usb_serial_jtag,
     skip_regenerate_image,
     encrypt,
     keyfile,

{pytest_embedded-2.7.0 → pytest_embedded-2.8.1}/tests/test_base.py

@@ -821,3 +821,192 @@ def test_log_metric_without_path(pytester):
 
     result = pytester.runpytest()
     result.assert_outcomes(passed=1)
+
+
+# ---------------------------------------------------------------------------
+# Tests for the stdout-lock feature (_stdout_lock / set_stdout_lock / _listen)
+# ---------------------------------------------------------------------------
+
+
+def test_set_stdout_lock():
+    """set_stdout_lock updates the module-level _STDOUT_LOCK variable."""
+    import pytest_embedded.dut_factory as m
+    from pytest_embedded.dut_factory import set_stdout_lock
+
+    original = m._STDOUT_LOCK
+    try:
+        sentinel = object()
+        set_stdout_lock(sentinel)
+        assert m._STDOUT_LOCK is sentinel
+
+        set_stdout_lock(None)
+        assert m._STDOUT_LOCK is None
+    finally:
+        set_stdout_lock(original)
+
+
+def test_listen_no_data_loss_without_lock(tmp_path):
+    """_listen writes every queued message to the logfile when no lock is used."""
+    import time
+
+    from pytest_embedded.dut_factory import _ctx, _listen
+    from pytest_embedded.log import MessageQueue
+
+    logfile = str(tmp_path / 'test.log')
+    q = MessageQueue()
+    messages = [f'line_{i}\n'.encode() for i in range(20)]
+
+    p = _ctx.Process(target=_listen, args=(q, logfile), kwargs={'with_timestamp': False})
+    p.start()
+    try:
+        for msg in messages:
+            q.put(msg)
+
+        deadline = time.monotonic() + 10
+        while time.monotonic() < deadline:
+            try:
+                content = open(logfile, 'rb').read()
+                if all(msg in content for msg in messages):
+                    break
+            except OSError:
+                pass
+            time.sleep(0.05)
+    finally:
+        p.terminate()
+        p.join(timeout=5)
+        assert p.exitcode is not None, 'listener process did not terminate'
+
+    content = open(logfile, 'rb').read()
+    for msg in messages:
+        assert msg in content, f'{msg!r} missing from logfile'
+
+
+def test_listen_no_data_loss_with_lock(tmp_path):
+    """_listen writes every queued message to the logfile when a Manager lock is used."""
+    import multiprocessing
+    import time
+
+    from pytest_embedded.dut_factory import _ctx, _listen
+    from pytest_embedded.log import MessageQueue
+
+    logfile = str(tmp_path / 'test.log')
+    q = MessageQueue()
+    messages = [f'line_{i}\n'.encode() for i in range(20)]
+
+    manager = multiprocessing.Manager()
+    try:
+        lock = manager.Lock()
+        p = _ctx.Process(
+            target=_listen,
+            args=(q, logfile),
+            kwargs={'with_timestamp': False, '_stdout_lock': lock},
+        )
+        p.start()
+        try:
+            for msg in messages:
+                q.put(msg)
+
+            deadline = time.monotonic() + 10
+            while time.monotonic() < deadline:
+                try:
+                    content = open(logfile, 'rb').read()
+                    if all(msg in content for msg in messages):
+                        break
+                except OSError:
+                    pass
+                time.sleep(0.05)
+        finally:
+            p.terminate()
+            p.join(timeout=5)
+            assert p.exitcode is not None, 'listener process did not terminate'
+    finally:
+        manager.shutdown()
+
+    content = open(logfile, 'rb').read()
+    for msg in messages:
+        assert msg in content, f'{msg!r} missing from logfile'
+
+
+def test_stdout_lock_concurrent_no_data_loss(tmp_path):
+    """Two concurrent _listen processes sharing a Manager lock both preserve all data."""
+    import multiprocessing
+    import time
+
+    from pytest_embedded.dut_factory import _ctx, _listen
+    from pytest_embedded.log import MessageQueue
+
+    logfile0 = str(tmp_path / 'dut0.log')
+    logfile1 = str(tmp_path / 'dut1.log')
+    q0 = MessageQueue()
+    q1 = MessageQueue()
+    messages0 = [f'dut0_line_{i}\n'.encode() for i in range(20)]
+    messages1 = [f'dut1_line_{i}\n'.encode() for i in range(20)]
+
+    manager = multiprocessing.Manager()
+    try:
+        lock = manager.Lock()
+        p0 = _ctx.Process(
+            target=_listen,
+            args=(q0, logfile0),
+            kwargs={'with_timestamp': False, 'count': 1, 'total': 2, '_stdout_lock': lock},
+        )
+        p1 = _ctx.Process(
+            target=_listen,
+            args=(q1, logfile1),
+            kwargs={'with_timestamp': False, 'count': 2, 'total': 2, '_stdout_lock': lock},
+        )
+        p0.start()
+        p1.start()
+        try:
+            # interleave writes from both DUTs to maximize lock contention
+            for msg0, msg1 in zip(messages0, messages1):
+                q0.put(msg0)
+                q1.put(msg1)
+
+            deadline = time.monotonic() + 15
+            while time.monotonic() < deadline:
+                try:
+                    c0 = open(logfile0, 'rb').read()
+                    c1 = open(logfile1, 'rb').read()
+                    if all(m in c0 for m in messages0) and all(m in c1 for m in messages1):
+                        break
+                except OSError:
+                    pass
+                time.sleep(0.05)
+        finally:
+            p0.terminate()
+            p1.terminate()
+            p0.join(timeout=5)
+            p1.join(timeout=5)
+            assert p0.exitcode is not None, 'dut0 listener process did not terminate'
+            assert p1.exitcode is not None, 'dut1 listener process did not terminate'
+    finally:
+        manager.shutdown()
+
+    c0 = open(logfile0, 'rb').read()
+    c1 = open(logfile1, 'rb').read()
+    for msg in messages0:
+        assert msg in c0, f'{msg!r} missing from dut0 logfile'
+    for msg in messages1:
+        assert msg in c1, f'{msg!r} missing from dut1 logfile'
+
+
+def test_multi_dut_no_data_loss(testdir):
+    """In a 2-DUT test, all messages written by each DUT can be expected - nothing is dropped."""
+    testdir.makepyfile(r"""
+        import pytest
+
+        @pytest.mark.parametrize('count', [2], indirect=True)
+        def test_concurrent_dut_writes(dut):
+            n = 15
+            for i in range(n):
+                dut[0].write(f'dut0_msg_{i}')
+                dut[1].write(f'dut1_msg_{i}')
+
+            for i in range(n):
+                dut[0].expect_exact(f'dut0_msg_{i}')
+                dut[1].expect_exact(f'dut1_msg_{i}')
+    """)
+
+    result = testdir.runpytest()
+    result.assert_outcomes(passed=1)