nano-dev-utils 0.4.4__tar.gz → 0.5.2__tar.gz

nano_dev_utils-0.5.2/.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.10 (datagov-mcp)" project-jdk-type="Python SDK" />
+</project>

nano_dev_utils-0.5.2/.idea/workspace.xml

@@ -0,0 +1,47 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ChangeListManager">
+    <list default="true" id="1859e23b-7665-4b92-98cc-65e07a208923" name="Changes" comment="" />
+    <option name="SHOW_DIALOG" value="false" />
+    <option name="HIGHLIGHT_CONFLICTS" value="true" />
+    <option name="HIGHLIGHT_NON_ACTIVE_CHANGELIST" value="false" />
+    <option name="LAST_RESOLUTION" value="IGNORE" />
+  </component>
+  <component name="Git.Settings">
+    <option name="RECENT_GIT_ROOT_PATH" value="$PROJECT_DIR$" />
+  </component>
+  <component name="ProjectColorInfo"><![CDATA[{
+  "customColor": "",
+  "associatedIndex": 5
+}]]></component>
+  <component name="ProjectId" id="2wVV0HQbcggEgX5PEayC1Mcx9Gd" />
+  <component name="ProjectViewState">
+    <option name="hideEmptyMiddlePackages" value="true" />
+    <option name="showLibraryContents" value="true" />
+    <option name="showMembers" value="true" />
+  </component>
+  <component name="PropertiesComponent"><![CDATA[{
+  "keyToString": {
+    "RunOnceActivity.ShowReadmeOnStart": "true",
+    "git-widget-placeholder": "master"
+  }
+}]]></component>
+  <component name="SharedIndexes">
+    <attachedChunks>
+      <set>
+        <option value="bundled-python-sdk-5b207ade9991-746f403e7f0c-com.jetbrains.pycharm.community.sharedIndexes.bundled-PC-241.17890.14" />
+      </set>
+    </attachedChunks>
+  </component>
+  <component name="SpellCheckerSettings" RuntimeDictionaries="0" Folders="0" CustomDictionaries="0" DefaultDictionary="application-level" UseSingleDictionary="true" transferred="true" />
+  <component name="TaskManager">
+    <task active="true" id="Default" summary="Default task">
+      <changelist id="1859e23b-7665-4b92-98cc-65e07a208923" name="Changes" comment="" />
+      <created>1746126505743</created>
+      <option name="number" value="Default" />
+      <option name="presentableId" value="Default" />
+      <updated>1746126505743</updated>
+    </task>
+    <servers />
+  </component>
+</project>

{nano_dev_utils-0.4.4 → nano_dev_utils-0.5.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nano_dev_utils
-Version: 0.4.4
+Version: 0.5.2
 Summary: A collection of small Python utilities for developers.
 Project-URL: Homepage, https://github.com/yaronday/nano_utils
 Project-URL: Issues, https://github.com/yaronday/nano_utils/issues
@@ -10,6 +10,9 @@ License-File: LICENSE.md
 Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Requires-Python: >=3.10
+Provides-Extra: test
+Requires-Dist: pytest-mock>=3.14.0; extra == 'test'
+Requires-Dist: pytest>=8.2.0; extra == 'test'
 Description-Content-Type: text/markdown
 
 # nano_dev_utils

{nano_dev_utils-0.4.4 → nano_dev_utils-0.5.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "nano_dev_utils"
-version = "0.4.4"
+version = "0.5.2"
 
 authors = [
   { name="Yaron Dayan", email="yaronday77@gmail.com" },
@@ -13,12 +13,19 @@ classifiers = [
     "Operating System :: OS Independent",
 ]
 license = { text = "MIT" }
-license-files = ["LICENSE.md"]
+
+[project.optional-dependencies]
+test = [
+    "pytest>=8.2.0",
+    "pytest-mock>=3.14.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/yaronday/nano_utils"
+Issues = "https://github.com/yaronday/nano_utils/issues"
 
 [build-system]
 requires = ["hatchling >= 1.26"]
 build-backend = "hatchling.build"
 
-[project.urls]
-Homepage = "https://github.com/yaronday/nano_utils"  # PyPI
-Issues = "https://github.com/yaronday/nano_utils/issues"
+

{nano_dev_utils-0.4.4 → nano_dev_utils-0.5.2}/src/nano_dev_utils/__init__.py

@@ -5,11 +5,14 @@ Copyright (c) 2025 Yaron Dayan
 from .dynamic_importer import Importer
 from .timers import Timer
 from .release_ports import PortsRelease, PROXY_SERVER, INSPECTOR_CLIENT
+from importlib.metadata import version
+
+__version__ = version('nano-dev-utils')
 
 __all__ = [
-    "Importer",
-    "Timer",
-    "PortsRelease",
-    "PROXY_SERVER",
-    "INSPECTOR_CLIENT",
+    'Importer',
+    'Timer',
+    'PortsRelease',
+    'PROXY_SERVER',
+    'INSPECTOR_CLIENT',
 ]

{nano_dev_utils-0.4.4 → nano_dev_utils-0.5.2}/src/nano_dev_utils/dynamic_importer.py

@@ -25,6 +25,3 @@ class Importer:
             return module
         except ModuleNotFoundError as e:
             raise ImportError(f'Could not import {lib_mod}') from e
-
-
-

{nano_dev_utils-0.4.4 → nano_dev_utils-0.5.2}/src/nano_dev_utils/release_ports.py

@@ -11,8 +11,11 @@ INSPECTOR_CLIENT = 6274
 
 class PortsRelease:
     def __init__(self, default_ports: list[int] | None = None):
-        self.default_ports: list[int] = default_ports \
-            if default_ports is not None else [PROXY_SERVER, INSPECTOR_CLIENT]
+        self.default_ports: list[int] = (
+            default_ports
+            if default_ports is not None
+            else [PROXY_SERVER, INSPECTOR_CLIENT]
+        )
 
     @staticmethod
     def _log_process_found(port: int, pid: int) -> str:
@@ -31,8 +34,9 @@ class PortsRelease:
         return f'Invalid port number: {port}. Skipping.'
 
     @staticmethod
-    def _log_terminate_failed(pid: int, port: int | None = None,
-                              error: str | None = None) -> str:
+    def _log_terminate_failed(
+        pid: int, port: int | None = None, error: str | None = None
+    ) -> str:
         base_msg = f'Failed to terminate process {pid}'
         if port:
             base_msg += f' (on port {port})'
@@ -61,17 +65,17 @@ class PortsRelease:
         system = platform.system()
         try:
             cmd: str = {
-                "Windows": f"netstat -ano | findstr :{port}",
-                "Linux": f"ss -lntp | grep :{port}",
-                "Darwin": f"lsof -i :{port}",
-            }.get(system, "")
+                'Windows': f'netstat -ano | findstr :{port}',
+                'Linux': f'ss -lntp | grep :{port}',
+                'Darwin': f'lsof -i :{port}',
+            }.get(system, '')
             if not cmd:
                 lgr.error(self._log_unsupported_os())
                 return None
 
-            process = subprocess.Popen(cmd, shell=True,
-                                       stdout=subprocess.PIPE,
-                                       stderr=subprocess.PIPE)
+            process = subprocess.Popen(
+                cmd, shell=True, stdout=subprocess.PIPE, stderr=subprocess.PIPE
+            )
             output, error = process.communicate()
             if error:
                 lgr.error(self._log_cmd_error(error))
@@ -81,21 +85,21 @@ class PortsRelease:
             for line in lines:
                 if str(port) in line:
                     parts: list[str] = line.split()
-                    if system == "Windows" and len(parts) > 4:
+                    if system == 'Windows' and len(parts) > 4:
                         try:
                             return int(parts[4])
                         except ValueError:
                             lgr.error(self._log_line_parse_failed(line))
                             return None
-                    elif system == "Linux":
+                    elif system == 'Linux':
                         for part in parts:
-                            if "pid=" in part:
+                            if 'pid=' in part:
                                 try:
-                                    return int(part.split("=")[1])
+                                    return int(part.split('=')[1])
                                 except ValueError:
                                     lgr.error(self._log_line_parse_failed(line))
                                     return None
-                    elif system == "Darwin" and len(parts) > 1:
+                    elif system == 'Darwin' and len(parts) > 1:
                         try:
                             return int(parts[1])
                         except ValueError:
@@ -113,7 +117,7 @@ class PortsRelease:
                 'Windows': f'taskkill /F /PID {pid}',
                 'Linux': f'kill -9 {pid}',
                 'Darwin': f'kill -9 {pid}',
-            }.get(platform.system(), "")  # fallback to empty string
+            }.get(platform.system(), '')  # fallback to empty string
             if not cmd:
                 lgr.error(self._log_unsupported_os())
                 return False
@@ -148,4 +152,4 @@ class PortsRelease:
                 else:
                     lgr.error(self._log_terminate_failed(pid=pid, port=port))
         except Exception as e:
-            lgr.error(self._log_unexpected_error(e))
+            lgr.error(self._log_unexpected_error(e))

{nano_dev_utils-0.4.4 → nano_dev_utils-0.5.2}/src/nano_dev_utils/timers.py

@@ -1,6 +1,7 @@
 from functools import wraps
 import time
 from typing import Callable, ParamSpec, TypeVar
+
 P = ParamSpec('P')
 R = TypeVar('R')
 
@@ -9,15 +10,11 @@ class Timer:
     def __init__(self, precision=4, verbose=False):
         self.precision = precision
         self.verbose = verbose
-        self.units = [
-            (1e9, 's'),
-            (1e6, 'ms'),
-            (1e3, 'μs'),
-            (1.0, 'ns')
-        ]
+        self.units = [(1e9, 's'), (1e6, 'ms'), (1e3, 'μs'), (1.0, 'ns')]
 
     def timeit(self, func: Callable[P, R]) -> Callable[P, R]:
         """Decorator that times function execution with automatic unit scaling."""
+
         @wraps(func)
         def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
             start = time.perf_counter_ns()
@@ -33,7 +30,9 @@ class Timer:
                     break
 
             extra_info = f'{args} {kwargs} ' if self.verbose else ''
-            print(f'{func.__name__} {extra_info}took {value:.{self.precision}f} [{unit}]')
+            print(
+                f'{func.__name__} {extra_info}took {value:.{self.precision}f} [{unit}]'
+            )
             return result
 
         return wrapper

nano_dev_utils-0.5.2/tests/__init__.py

@@ -0,0 +1,10 @@
+"""nano-dev-utils - A collection of small Python utilities for developers.
+Copyright (c) 2025 Yaron Dayan
+"""
+
+from .test_release_ports import PROXY_SERVER, CLIENT_PORT
+
+__all__ = [
+    'PROXY_SERVER',
+    'CLIENT_PORT',
+]

nano_dev_utils-0.5.2/tests/test_dynamic_importer.py

@@ -0,0 +1,62 @@
+import pytest
+from types import ModuleType
+from src.nano_dev_utils.dynamic_importer import Importer
+
+
+@pytest.fixture
+def importer():
+    return Importer()
+
+
+@pytest.fixture
+def mock_module():
+    module = ModuleType('mock_module')
+    setattr(module, 'attribute', 'test_value')
+    return module
+
+
+def test_import_mod_from_lib_success_new_import(importer, mock_module, mocker):
+    mock_import = mocker.patch('importlib.import_module', return_value=mock_module)
+    module = importer.import_mod_from_lib('test_library', 'test_module')
+
+    assert module == mock_module
+    assert 'test_module' in importer.imported_modules
+    assert importer.imported_modules['test_module'] == mock_module
+    mock_import.assert_called_once_with('test_library.test_module')
+
+
+def test_import_mod_from_lib_success_cached_import(importer, mock_module, mocker):
+    importer.imported_modules['cached_module'] = mock_module
+    mock_import = mocker.patch('importlib.import_module')
+
+    module = importer.import_mod_from_lib('another_library', 'cached_module')
+
+    assert module == mock_module
+    mock_import.assert_not_called()
+
+
+def test_import_mod_from_lib_failure(importer, mocker):
+    mocker.patch(
+        'importlib.import_module',
+        side_effect=ModuleNotFoundError(
+            "No module named 'nonexistent_library.missing_module'"
+        ),
+    )
+
+    with pytest.raises(
+        ImportError, match='Could not import nonexistent_library.missing_module'
+    ):
+        importer.import_mod_from_lib('nonexistent_library', 'missing_module')
+
+    assert 'missing_module' not in importer.imported_modules
+
+
+def test_import_mod_from_lib_returns_any(importer, mocker):
+    mock_object = 'not a module'
+    mocker.patch.dict('sys.modules', {'yet_another_library.some_object': mock_object})
+
+    result = importer.import_mod_from_lib('yet_another_library', 'some_object')
+
+    assert result == mock_object
+    assert 'some_object' in importer.imported_modules
+    assert importer.imported_modules['some_object'] == mock_object

nano_dev_utils-0.5.2/tests/test_release_ports.py

@@ -0,0 +1,307 @@
+import logging
+import pytest
+from src.nano_dev_utils import release_ports as rp
+
+PROXY_SERVER = rp.PROXY_SERVER
+CLIENT_PORT = rp.INSPECTOR_CLIENT
+
+
+@pytest.fixture
+def ports_release():
+    return rp.PortsRelease()
+
+
+@pytest.fixture
+def mock_logger(mocker):
+    logger = mocker.MagicMock(spec=logging.Logger)
+    mocker.patch.object(rp, 'lgr', logger)
+    return logger
+
+
+def encode_dict(input_dict: dict) -> bytes:
+    return b' '.join(str(v).encode() for v in input_dict.values())
+
+
+def remove_file_handlers():
+    """Temporarily remove any file handlers from the root logger"""
+    root_logger = logging.getLogger()
+    existing_file_handlers = [
+        handler
+        for handler in root_logger.handlers
+        if isinstance(handler, logging.FileHandler)
+    ]
+    for handler in existing_file_handlers:
+        root_logger.removeHandler(handler)
+        handler.close()
+
+
+@pytest.fixture(autouse=True)
+def cleanup():
+    remove_file_handlers()
+    yield
+
+
+def mock_pid_retrieval(ports_release, mocker, entry, port):
+    mock_process = mocker.MagicMock()
+    encoded_entry = encode_dict(entry)
+    mock_process.communicate.return_value = (encoded_entry, '')
+    mocker.patch('subprocess.Popen', return_value=mock_process)
+    pid = ports_release.get_pid_by_port(port)
+    return pid, encoded_entry
+
+
+def test_get_pid_by_port_linux_success(ports_release, mock_logger, mocker):
+    mock_popen = mocker.patch('subprocess.Popen')
+    mocker.patch('platform.system', return_value='Linux')
+    # ss - lntp command response structure
+    port = 8080  # local port
+    peer_port = '*'
+    local_addr = '::'  # :: - listening to all available interfaces
+    peer_addr = '::'
+    _pid = 1234
+    fd = 4  # file descriptor
+    ss_entry = {
+        'netid': 'tcp6',
+        'rx_q': 0,
+        'tx_q': 0,
+        'local_addr_port': f'{local_addr}:{port}',
+        'peer_addr_port': f'{peer_addr}:{peer_port}',
+        'process_name': 'users:python3',
+        'pid': f'pid={_pid}',
+        'fd': f'fd={fd}',
+    }
+
+    mock_process = mocker.MagicMock()
+    mock_process.communicate.return_value = (encode_dict(ss_entry), '')
+    mock_popen.return_value = mock_process
+
+    pid = ports_release.get_pid_by_port(port)
+    assert pid == 1234
+    mock_popen.assert_called_once_with(
+        f'ss -lntp | grep :{port}',
+        shell=True,
+        stdout=-1,
+        stderr=-1,
+    )
+
+
+def test_get_pid_by_port_windows_success(ports_release, mock_logger, mocker):
+    mock_popen = mocker.patch('subprocess.Popen')
+    mocker.patch('platform.system', return_value='Windows')
+
+    # netstat -ano command response structure (Windows)
+    port = 9000
+    _pid = 5678
+    netstat_entry = {
+        'protocol': 'TCP',
+        'local_addr_and_port ': f'0.0.0.0:{port}',
+        'remote_addr_and_port': '0.0.0.0:0',
+        'state_and_pid': f'LISTENING {_pid}\n',
+    }
+
+    mock_process = mocker.MagicMock()
+    mock_process.communicate.return_value = (encode_dict(netstat_entry), '')
+    mock_popen.return_value = mock_process
+
+    pid = ports_release.get_pid_by_port(port)
+    assert pid == 5678
+    mock_popen.assert_called_once_with(
+        f'netstat -ano | findstr :{port}',
+        shell=True,
+        stdout=-1,
+        stderr=-1,
+    )
+
+
+def test_get_pid_by_port_darwin_success(ports_release, mock_logger, mocker):
+    mock_popen = mocker.patch('subprocess.Popen')
+    mocker.patch('platform.system', return_value='Darwin')
+    # lsof -i command response structure (MacOS)
+    port = 7000
+    _pid = 1111
+    lsof_entry = {
+        'command': 'python3',  # Process name
+        'pid': f'{_pid}',  # Process ID (integer)
+        'user': 'user',  # User running the process
+        'fd': '10u',  # File descriptor (read/write)
+        'type': 'IPv4',  # Network connection type (IPv4/IPv6)
+        'device': '0xabcdef0123456789',  # Kernel device identifier
+        'size_off': '0t0',  # Size/offset (0 for sockets)
+        'protocol': 'TCP',  # Protocol (TCP/UDP)
+        'name': f'*:{port} (LISTEN)',  # Combined address & state (optional)
+    }
+
+    mock_process = mocker.MagicMock()
+    mock_process.communicate.return_value = (encode_dict(lsof_entry), '')
+    mock_popen.return_value = mock_process
+
+    pid = ports_release.get_pid_by_port(port)
+    assert pid == 1111
+    mock_popen.assert_called_once_with(
+        f'lsof -i :{port}',
+        shell=True,
+        stdout=-1,
+        stderr=-1,
+    )
+
+
+def test_get_pid_by_port_unsupported_os(ports_release, mock_logger, mocker):
+    mocker.patch('platform.system', return_value='UnsupportedOS')
+    pid = ports_release.get_pid_by_port(1234)
+    assert pid is None
+    mock_logger.error.assert_called_once_with(ports_release._log_unsupported_os())
+
+
+def test_get_pid_by_port_no_process(ports_release, mock_logger, mocker):
+    port = 9999
+    mocker.patch('platform.system', return_value='Linux')
+    mock_process = mocker.MagicMock()
+    mock_process.communicate.return_value = (b'', b'')
+    mocker.patch('subprocess.Popen', return_value=mock_process)
+
+    pid = ports_release.get_pid_by_port(port)
+    assert pid is None
+    mock_logger.error.assert_not_called()
+
+
+def test_get_pid_by_port_command_error(ports_release, mock_logger, mocker):
+    mock_popen = mocker.patch('subprocess.Popen')
+    mocker.patch('platform.system', return_value='Linux')
+    port = 80
+    err = 'Error occurred'
+    mock_process = mocker.MagicMock()
+    mock_process.communicate.return_value = (b'', err.encode())
+    mock_popen.return_value = mock_process
+    pid = ports_release.get_pid_by_port(port)
+    assert pid is None
+    mock_logger.error.assert_called_once_with(f'Error running command: {err}')
+
+
+def test_get_pid_by_port_parse_error(ports_release, mock_logger, mocker):
+    mocker.patch('platform.system', return_value='Linux')
+    port = 8080
+    peer_port = '*'
+    local_addr = '::'
+    peer_addr = '::'
+    _pid = 'invalid'
+    fd = 4
+    ss_entry = {
+        'netid': 'tcp6',
+        'rx_q': 0,
+        'tx_q': 0,
+        'local_addr_port': f'{local_addr}:{port}',
+        'peer_addr_port': f'{peer_addr}:{peer_port}',
+        'process_name': 'users:python3',
+        'pid': f'pid={_pid}',
+        'fd': f'fd={fd}',
+    }
+
+    pid, enc_entry = mock_pid_retrieval(ports_release, mocker, ss_entry, port)
+    assert pid is None
+    mock_logger.error.assert_called_once_with(
+        f'Could not parse PID from line: {enc_entry.decode()}'
+    )
+
+
+def test_get_pid_by_port_unexpected_exception(ports_release, mock_logger, mocker):
+    mocker.patch('platform.system', return_value='Linux')
+    err = Exception('Unexpected')
+    port = 1234
+    mocker.patch('subprocess.Popen', side_effect=err)
+    pid = ports_release.get_pid_by_port(port)
+    assert pid is None
+    mock_logger.error.assert_called_once_with(f'An unexpected error occurred: {err}')
+
+
+def test_kill_process_success(ports_release, mock_logger, mocker):
+    mocker.patch('platform.system', return_value='Linux')
+    mock_popen = mocker.patch('subprocess.Popen')
+
+    port = 5678
+    mock_process = mocker.MagicMock()
+    mock_process.returncode = 0
+    mock_process.communicate.return_value = (b'', b'')
+    mock_popen.return_value = mock_process
+    result = ports_release.kill_process(port)
+    assert result is True
+    mock_popen.assert_called_once_with(f'kill -9 {port}', shell=True, stderr=-1)
+
+
+def test_kill_process_fail(ports_release, mock_logger, mocker):
+    pid = 1234
+    err = 'Access denied'
+    mocker.patch('platform.system', return_value='Windows')
+    mock_popen = mocker.patch('subprocess.Popen')
+    mock_process = mocker.MagicMock()
+    mock_process.returncode = 1
+    mock_process.communicate.return_value = (b'', err.encode())
+    mock_popen.return_value = mock_process
+    result = ports_release.kill_process(pid)
+    assert result is False
+    mock_logger.error.assert_called_once_with(
+        ports_release._log_terminate_failed(pid=pid, error=err)
+    )
+
+
+def test_kill_process_unsupported_os(ports_release, mock_logger, mocker):
+    mocker.patch('platform.system', return_value='UnsupportedOS')
+    pid = 9999
+    result = ports_release.kill_process(pid)
+    assert result is False
+    mock_logger.error.assert_called_once_with(ports_release._log_unsupported_os())
+
+
+def test_kill_process_unexpected_exception(ports_release, mock_logger, mocker):
+    err = Exception('Another error')
+    mocker.patch('platform.system', return_value='Linux')
+    mocker.patch('subprocess.Popen', side_effect=err)
+
+    pid = 4321
+    result = ports_release.kill_process(pid)
+    assert result is False
+    mock_logger.error.assert_called_once_with(ports_release._log_unexpected_error(err))
+
+
+def test_release_all_default_ports_success(ports_release, mock_logger, mocker):
+    mock_get_pid = mocker.patch.object(ports_release, 'get_pid_by_port')
+    mock_kill = mocker.patch.object(ports_release, 'kill_process')
+
+    pid1, pid2 = 1111, 2222
+    mock_get_pid.side_effect = [pid1, pid2]
+    mock_kill.side_effect = [True, True]
+    ports_release.release_all()
+
+    assert mock_get_pid.call_args_list == [
+        mocker.call(PROXY_SERVER),
+        mocker.call(CLIENT_PORT),
+    ]
+    assert mock_kill.call_args_list == [mocker.call(pid1), mocker.call(pid2)]
+    mock_logger.info.assert_has_calls(
+        [
+            mocker.call(ports_release._log_process_found(PROXY_SERVER, pid1)),
+            mocker.call(ports_release._log_process_terminated(pid1, PROXY_SERVER)),
+            mocker.call(ports_release._log_process_found(CLIENT_PORT, pid2)),
+            mocker.call(ports_release._log_process_terminated(pid2, CLIENT_PORT)),
+        ]
+    )
+
+
+def test_release_all_invalid_port(ports_release, mock_logger, mocker):
+    mock_get_pid = mocker.patch.object(ports_release, 'get_pid_by_port')
+    mock_kill = mocker.patch.object(ports_release, 'kill_process')
+    ports = ['invalid', 1234, 5678]
+    mock_get_pid.side_effect = [None, None]
+    ports_release.release_all(ports=ports)
+    assert mock_get_pid.call_args_list == [mocker.call(ports[1]), mocker.call(ports[2])]
+
+    mock_kill.assert_not_called()
+    mock_logger.error.assert_called_once_with(ports_release._log_invalid_port(ports[0]))
+
+
+def test_release_all_unexpected_exception(ports_release, mock_logger, mocker):
+    err = Exception('Release all error')
+    mocker.patch.object(ports_release, 'get_pid_by_port', side_effect=err)
+    port = 9010
+    ports_release.release_all(ports=[port])
+    mock_logger.error.assert_called_once_with(ports_release._log_unexpected_error(err))
+    ports_release.get_pid_by_port.assert_called_once_with(port)