0.11.0 Release

Author: Adminiuga

.github/workflows/publish-to-pypi.yml

@@ -0,0 +1,26 @@
+name: Publish distributions to PyPI and TestPyPI
+on:
+  push:
+    tags:
+      - "*"
+
+jobs:
+  build-and-publish:
+    name: Build and publish distributions to PyPI and TestPyPI
+    runs-on: ubuntu-latest
+    steps:
+    - uses: actions/checkout@master
+    - name: Set up Python 3.7
+      uses: actions/setup-python@v1
+      with:
+        version: 3.7
+    - name: Install wheel
+      run: >-
+        pip install wheel
+    - name: Build
+      run: >-
+        python3 setup.py sdist bdist_wheel
+    - name: Publish distribution to PyPI
+      uses: pypa/gh-action-pypi-publish@master
+      with:
+        password: ${{ secrets.PYPI_TOKEN }}

.pre-commit-config.yaml

@@ -1,12 +1,24 @@
 repos:
--   repo: https://github.com/psf/black
-    rev: 19.3b0
+  - repo: https://github.com/psf/black
+    rev: 19.10b0
     hooks:
-    -   id: black
+      - id: black
         args:
           - --safe
           - --quiet
--   repo: https://gitlab.com/pycqa/flake8
-    rev: 3.7.8
+  - repo: https://gitlab.com/pycqa/flake8
+    rev: 3.7.9
     hooks:
-    -   id: flake8
+      - id: flake8
+  - repo: https://github.com/pre-commit/mirrors-isort
+    rev: v4.3.21
+    hooks:
+      - id: isort
+  - repo: https://github.com/pre-commit/pre-commit-hooks
+    rev: v2.4.0
+    hooks:
+      - id: no-commit-to-branch
+        args:
+          - --branch=dev
+          - --branch=master
+          - --branch=rc

.travis.yml

@@ -4,6 +4,8 @@ matrix:
   include:
     - python: "3.6"
       env: TOXENV=lint
+    - python: "3.6"
+      env: TOXENV=black
     - python: "3.6"
       env: TOXENV=py36
     - python: "3.7"

setup.py

@@ -13,6 +13,6 @@
     author_email="[email protected]",
     license="GPL-3.0",
     packages=find_packages(exclude=["*.tests"]),
-    install_requires=["pyserial-asyncio", "zigpy-homeassistant >= 0.10.0"],
+    install_requires=["pyserial-asyncio", "zigpy-homeassistant >= 0.17.0"],
     tests_require=["pytest"],
 )

tests/test_api.py

@@ -1,7 +1,10 @@
 import asyncio
-from unittest import mock
+import logging
 
+from asynctest import CoroutineMock, mock
 import pytest
+import serial
+import zigpy.exceptions
 
 from zigpy_xbee import api as xbee_api, types as t, uart
 from zigpy_xbee.zigbee.application import ControllerApplication
@@ -25,9 +28,10 @@ async def test_connect(monkeypatch):
 
 
 def test_close(api):
-    api._uart.close = mock.MagicMock()
+    uart = api._uart
     api.close()
-    assert api._uart.close.call_count == 1
+    assert api._uart is None
+    assert uart.close.call_count == 1
 
 
 def test_commands():
@@ -84,6 +88,22 @@ def mock_api_frame(name, *args):
         api._uart.send.reset_mock()
 
 
+@pytest.mark.asyncio
+async def test_command_not_connected(api):
+    api._uart = None
+
+    def mock_api_frame(name, *args):
+        return mock.sentinel.api_frame_data, api._seq
+
+    api._api_frame = mock.MagicMock(side_effect=mock_api_frame)
+
+    for cmd, cmd_opts in xbee_api.COMMAND_REQUESTS.items():
+        with pytest.raises(zigpy.exceptions.APIException):
+            await api._command(cmd, mock.sentinel.cmd_data)
+        assert api._api_frame.call_count == 0
+        api._api_frame.reset_mock()
+
+
 async def _test_at_or_queued_at_command(api, cmd, monkeypatch, do_reply=True):
     monkeypatch.setattr(
         t, "serialize", mock.MagicMock(return_value=mock.sentinel.serialize)
@@ -518,3 +538,131 @@ def test_handle_many_to_one_rri(api):
     ieee = t.EUI64([t.uint8_t(a) for a in range(0, 8)])
     nwk = 0x1234
     api._handle_many_to_one_rri(ieee, nwk, 0)
+
+
+@pytest.mark.asyncio
+async def test_reconnect_multiple_disconnects(monkeypatch, caplog):
+    api = xbee_api.XBee()
+    dev = mock.sentinel.uart
+    connect_mock = CoroutineMock()
+    connect_mock.return_value = asyncio.Future()
+    connect_mock.return_value.set_result(True)
+    monkeypatch.setattr(uart, "connect", connect_mock)
+
+    await api.connect(dev, 115200)
+
+    caplog.set_level(logging.DEBUG)
+    connected = asyncio.Future()
+    connected.set_result(mock.sentinel.uart_reconnect)
+    connect_mock.reset_mock()
+    connect_mock.side_effect = [asyncio.Future(), connected]
+    api.connection_lost("connection lost")
+    await asyncio.sleep(0.3)
+    api.connection_lost("connection lost 2")
+    await asyncio.sleep(0.3)
+
+    assert "Cancelling reconnection attempt" in caplog.messages
+    assert api._uart is mock.sentinel.uart_reconnect
+    assert connect_mock.call_count == 2
+
+
+@pytest.mark.asyncio
+async def test_reconnect_multiple_attempts(monkeypatch, caplog):
+    api = xbee_api.XBee()
+    dev = mock.sentinel.uart
+    connect_mock = CoroutineMock()
+    connect_mock.return_value = asyncio.Future()
+    connect_mock.return_value.set_result(True)
+    monkeypatch.setattr(uart, "connect", connect_mock)
+
+    await api.connect(dev, 115200)
+
+    caplog.set_level(logging.DEBUG)
+    connected = asyncio.Future()
+    connected.set_result(mock.sentinel.uart_reconnect)
+    connect_mock.reset_mock()
+    connect_mock.side_effect = [asyncio.TimeoutError, OSError, connected]
+
+    with mock.patch("asyncio.sleep"):
+        api.connection_lost("connection lost")
+        await api._conn_lost_task
+
+    assert api._uart is mock.sentinel.uart_reconnect
+    assert connect_mock.call_count == 3
+
+
+@pytest.mark.asyncio
+@mock.patch.object(xbee_api.XBee, "_at_command", new_callable=CoroutineMock)
+@mock.patch.object(uart, "connect")
+async def test_probe_success(mock_connect, mock_at_cmd):
+    """Test device probing."""
+
+    res = await xbee_api.XBee.probe(mock.sentinel.uart, mock.sentinel.baud)
+    assert res is True
+    assert mock_connect.call_count == 1
+    assert mock_connect.await_count == 1
+    assert mock_connect.call_args[0][0] is mock.sentinel.uart
+    assert mock_at_cmd.call_count == 1
+    assert mock_connect.return_value.close.call_count == 1
+
+
+@pytest.mark.asyncio
+@mock.patch.object(xbee_api.XBee, "init_api_mode", return_value=True)
+@mock.patch.object(xbee_api.XBee, "_at_command", side_effect=asyncio.TimeoutError)
+@mock.patch.object(uart, "connect")
+async def test_probe_success_api_mode(mock_connect, mock_at_cmd, mock_api_mode):
+    """Test device probing."""
+
+    res = await xbee_api.XBee.probe(mock.sentinel.uart, mock.sentinel.baud)
+    assert res is True
+    assert mock_connect.call_count == 1
+    assert mock_connect.await_count == 1
+    assert mock_connect.call_args[0][0] is mock.sentinel.uart
+    assert mock_at_cmd.call_count == 1
+    assert mock_api_mode.call_count == 1
+    assert mock_connect.return_value.close.call_count == 1
+
+
+@pytest.mark.asyncio
+@mock.patch.object(xbee_api.XBee, "init_api_mode")
+@mock.patch.object(xbee_api.XBee, "_at_command", side_effect=asyncio.TimeoutError)
+@mock.patch.object(uart, "connect")
+@pytest.mark.parametrize(
+    "exception",
+    (asyncio.TimeoutError, serial.SerialException, zigpy.exceptions.APIException),
+)
+async def test_probe_fail(mock_connect, mock_at_cmd, mock_api_mode, exception):
+    """Test device probing fails."""
+
+    mock_api_mode.side_effect = exception
+    mock_api_mode.reset_mock()
+    mock_at_cmd.reset_mock()
+    mock_connect.reset_mock()
+    res = await xbee_api.XBee.probe(mock.sentinel.uart, mock.sentinel.baud)
+    assert res is False
+    assert mock_connect.call_count == 1
+    assert mock_connect.await_count == 1
+    assert mock_connect.call_args[0][0] is mock.sentinel.uart
+    assert mock_at_cmd.call_count == 1
+    assert mock_api_mode.call_count == 1
+    assert mock_connect.return_value.close.call_count == 1
+
+
+@pytest.mark.asyncio
+@mock.patch.object(xbee_api.XBee, "init_api_mode", return_value=False)
+@mock.patch.object(xbee_api.XBee, "_at_command", side_effect=asyncio.TimeoutError)
+@mock.patch.object(uart, "connect")
+async def test_probe_fail_api_mode(mock_connect, mock_at_cmd, mock_api_mode):
+    """Test device probing fails."""
+
+    mock_api_mode.reset_mock()
+    mock_at_cmd.reset_mock()
+    mock_connect.reset_mock()
+    res = await xbee_api.XBee.probe(mock.sentinel.uart, mock.sentinel.baud)
+    assert res is False
+    assert mock_connect.call_count == 1
+    assert mock_connect.await_count == 1
+    assert mock_connect.call_args[0][0] is mock.sentinel.uart
+    assert mock_at_cmd.call_count == 1
+    assert mock_api_mode.call_count == 1
+    assert mock_connect.return_value.close.call_count == 1

tests/test_application.py

@@ -2,7 +2,6 @@
 from unittest import mock
 
 import pytest
-
 from zigpy import types as t
 from zigpy.zdo.types import ZDOCmd
 

tests/test_types.py

@@ -1,4 +1,5 @@
 import pytest
+
 from zigpy_xbee import types as t
 
 

tests/test_uart.py

@@ -1,3 +1,4 @@
+import asyncio
 from unittest import mock
 
 import pytest
@@ -47,13 +48,6 @@ def test_command_mode_rsp(gw):
     assert gw._api.handle_command_mode_rsp.call_args[0][0] == "OK"
 
 
-def test_command_mode_rsp_decode_exc(gw):
-    data = b"OK\x81"
-    with pytest.raises(UnicodeDecodeError):
-        gw.command_mode_rsp(data)
-    assert gw._api.handle_command_mode_rsp.call_count == 0
-
-
 def test_command_mode_send(gw):
     data = b"ATAP2\x0D"
     gw.command_mode_send(data)
@@ -202,3 +196,24 @@ def test_unescape_underflow(gw):
     unescaped, rest = gw._get_unescaped(escaped, 3)
     assert unescaped is None
     assert rest is None
+
+
+def test_connection_lost_exc(gw):
+    gw._connected_future = asyncio.Future()
+
+    gw.connection_lost(ValueError())
+
+    conn_lost = gw._api.connection_lost
+    assert conn_lost.call_count == 1
+    assert isinstance(conn_lost.call_args[0][0], Exception)
+    assert gw._connected_future.done()
+    assert gw._connected_future.exception()
+
+
+def test_connection_closed(gw):
+    gw._connected_future = asyncio.Future()
+    gw.connection_lost(None)
+
+    assert gw._api.connection_lost.call_count == 0
+    assert gw._connected_future.done()
+    assert gw._connected_future.result() is True

tox.ini

@@ -12,15 +12,20 @@ setenv = PYTHONPATH = {toxinidir}
 install_command = pip install {opts} {packages}
 commands = py.test --cov --cov-report=
 deps =
+    asynctest
     coveralls
     pytest
     pytest-cov
     pytest-asyncio
 
 [testenv:lint]
 basepython = python3
-deps = flake8
-commands = flake8
+deps =
+    flake8
+    isort
+commands =
+    flake8
+    isort --check -rc {toxinidir}/zigpy_xbee {toxinidir}/tests {toxinidir}/setup.py
 
 [testenv:black]
 deps=black

zigpy_xbee/__init__.py

@@ -1,5 +1,5 @@
 MAJOR_VERSION = 0
-MINOR_VERSION = 10
+MINOR_VERSION = 11
 PATCH_VERSION = "0"
 __short_version__ = "{}.{}".format(MAJOR_VERSION, MINOR_VERSION)
 __version__ = "{}.{}".format(__short_version__, PATCH_VERSION)