0.9.0 Release

Author: Adminiuga

LICENSE

@@ -1,18 +1,26 @@
 """Setup module for zigpy-deconz"""
 
+import os
+
 from setuptools import find_packages, setup
 
 import zigpy_deconz
 
+this_directory = os.path.join(os.path.abspath(os.path.dirname(__file__)))
+with open(os.path.join(this_directory, "README.md"), encoding="utf-8") as f:
+    long_description = f.read()
+
 setup(
     name="zigpy-deconz",
     version=zigpy_deconz.__version__,
     description="A library which communicates with Deconz radios for zigpy",
+    long_description=long_description,
+    long_description_content_type="text/markdown",
     url="http://github.com/zigpy/zigpy-deconz",
     author="Daniel Schmidt",
     author_email="[email protected]",
     license="GPL-3.0",
     packages=find_packages(exclude=["*.tests"]),
-    install_requires=["pyserial-asyncio", "zigpy-homeassistant>=0.17.0"],
+    install_requires=["pyserial-asyncio", "zigpy>=0.20.a1"],
     tests_require=["pytest", "pytest-asyncio", "asynctest"],
 )

setup.py

@@ -4,31 +4,37 @@
 from asynctest import CoroutineMock, mock
 import pytest
 import serial
+import zigpy.config
 
 from zigpy_deconz import api as deconz_api, types as t, uart
 import zigpy_deconz.exception
+import zigpy_deconz.zigbee.application
+
+DEVICE_CONFIG = {zigpy.config.CONF_DEVICE_PATH: "/dev/null"}
 
 
 @pytest.fixture
 def api():
-    api = deconz_api.Deconz()
+    controller = mock.MagicMock(
+        spec_set=zigpy_deconz.zigbee.application.ControllerApplication
+    )
+    api = deconz_api.Deconz(controller, {zigpy.config.CONF_DEVICE_PATH: "/dev/null"})
     api._uart = mock.MagicMock()
     return api
 
 
-def test_set_application(api):
-    api.set_application(mock.sentinel.app)
-    assert api._app == mock.sentinel.app
-
-
 @pytest.mark.asyncio
-async def test_connect(monkeypatch):
-    api = deconz_api.Deconz()
-    dev = mock.MagicMock()
-    monkeypatch.setattr(
-        uart, "connect", mock.MagicMock(side_effect=asyncio.coroutine(mock.MagicMock()))
+async def test_connect():
+    controller = mock.MagicMock(
+        spec_set=zigpy_deconz.zigbee.application.ControllerApplication
     )
-    await api.connect(dev, 115200)
+    api = deconz_api.Deconz(controller, {zigpy.config.CONF_DEVICE_PATH: "/dev/null"})
+
+    with mock.patch.object(uart, "connect", new=CoroutineMock()) as conn_mck:
+        await api.connect()
+        assert conn_mck.call_count == 1
+        assert conn_mck.await_count == 1
+        assert api._uart == conn_mck.return_value
 
 
 def test_close(api):
@@ -437,14 +443,13 @@ def test_device_state_network_state(data, network_state):
 
 @pytest.mark.asyncio
 async def test_reconnect_multiple_disconnects(monkeypatch, caplog):
-    api = deconz_api.Deconz()
-    dev = mock.sentinel.uart
+    api = deconz_api.Deconz(None, DEVICE_CONFIG)
     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)
+    await api.connect()
 
     caplog.set_level(logging.DEBUG)
     connected = asyncio.Future()
@@ -463,14 +468,13 @@ async def test_reconnect_multiple_disconnects(monkeypatch, caplog):
 
 @pytest.mark.asyncio
 async def test_reconnect_multiple_attempts(monkeypatch, caplog):
-    api = deconz_api.Deconz()
-    dev = mock.sentinel.uart
+    api = deconz_api.Deconz(None, DEVICE_CONFIG)
     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)
+    await api.connect()
 
     caplog.set_level(logging.DEBUG)
     connected = asyncio.Future()
@@ -492,22 +496,22 @@ async def test_reconnect_multiple_attempts(monkeypatch, caplog):
 async def test_probe_success(mock_connect, mock_device_state):
     """Test device probing."""
 
-    res = await deconz_api.Deconz.probe(mock.sentinel.uart, mock.sentinel.baud)
+    res = await deconz_api.Deconz.probe(DEVICE_CONFIG)
     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_connect.call_args[0][0] is DEVICE_CONFIG
     assert mock_device_state.call_count == 1
     assert mock_connect.return_value.close.call_count == 1
 
     mock_connect.reset_mock()
     mock_device_state.reset_mock()
     mock_connect.reset_mock()
-    res = await deconz_api.Deconz.probe(mock.sentinel.uart, mock.sentinel.baud)
+    res = await deconz_api.Deconz.probe(DEVICE_CONFIG)
     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_connect.call_args[0][0] is DEVICE_CONFIG
     assert mock_device_state.call_count == 1
     assert mock_connect.return_value.close.call_count == 1
 
@@ -525,10 +529,37 @@ async def test_probe_fail(mock_connect, mock_device_state, exception):
     mock_device_state.side_effect = exception
     mock_device_state.reset_mock()
     mock_connect.reset_mock()
-    res = await deconz_api.Deconz.probe(mock.sentinel.uart, mock.sentinel.baud)
+    res = await deconz_api.Deconz.probe(DEVICE_CONFIG)
     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_connect.call_args[0][0] is DEVICE_CONFIG
     assert mock_device_state.call_count == 1
     assert mock_connect.return_value.close.call_count == 1
+
+
+@pytest.mark.parametrize(
+    "value, name",
+    (
+        (0x00, "SUCCESS"),
+        (0xA0, "APS_ASDU_TOO_LONG"),
+        (0x01, "MAC_PAN_AT_CAPACITY"),
+        (0xC9, "NWK_UNSUPPORTED_ATTRIBUTE"),
+        (0xFE, "undefined_0xfe"),
+    ),
+)
+def test_tx_status(value, name):
+    """Test tx status undefined values."""
+    i = deconz_api.TXStatus(value)
+    assert i == value
+    assert i.value == value
+    assert i.name == name
+
+    extra = b"\xaa\55"
+    data = t.uint8_t(value).serialize()
+    status, rest = deconz_api.TXStatus.deserialize(data + extra)
+    assert rest == extra
+    assert isinstance(status, deconz_api.TXStatus)
+    assert status == value
+    assert status.value == value
+    assert status.name == name

tests/test_api.py

@@ -1,9 +1,9 @@
 import asyncio
 import logging
-from unittest import mock
 
-import asynctest
+from asynctest import CoroutineMock, mock
 import pytest
+import zigpy.config
 import zigpy.device
 from zigpy.types import EUI64
 import zigpy.zdo.types as zdo_t
@@ -15,10 +15,16 @@
 
 
 @pytest.fixture
-def app(monkeypatch, database_file=None):
-    app = application.ControllerApplication(
-        deconz_api.Deconz(), database_file=database_file
+def app(database_file=None):
+    config = application.ControllerApplication.SCHEMA(
+        {
+            zigpy.config.CONF_DEVICE: {zigpy.config.CONF_DEVICE_PATH: "/dev/null"},
+            zigpy.config.CONF_DATABASE: database_file,
+        }
     )
+
+    app = application.ControllerApplication(config)
+    app._api = deconz_api.Deconz(app, config[zigpy.config.CONF_DEVICE])
     return app
 
 
@@ -168,21 +174,24 @@ def test_rx_unknown_device(app, addr_ieee, addr_nwk, caplog):
 
 @pytest.mark.asyncio
 async def test_form_network(app):
-    app._api.change_network_state = mock.MagicMock(
-        side_effect=asyncio.coroutine(mock.MagicMock())
-    )
-    app._api.device_state = mock.MagicMock(
-        side_effect=asyncio.coroutine(mock.MagicMock())
+    app._api.change_network_state = CoroutineMock()
+    app._api.device_state = CoroutineMock(
+        return_value=deconz_api.NetworkState.CONNECTED
     )
 
-    app._api._device_state = deconz_api.DeviceState(2)
+    app._api._device_state = deconz_api.DeviceState(deconz_api.NetworkState.CONNECTED)
     await app.form_network()
-    assert app._api.device_state.call_count == 0
+    assert app._api.change_network_state.call_count == 0
+    assert app._api.change_network_state.await_count == 0
+    assert app._api.device_state.await_count == 0
 
-    app._api._device_state = deconz_api.DeviceState(0)
+    app._api._device_state = deconz_api.DeviceState(deconz_api.NetworkState.OFFLINE)
     application.CHANGE_NETWORK_WAIT = 0.001
     with pytest.raises(Exception):
         await app.form_network()
+    assert app._api.change_network_state.call_count == 1
+    assert app._api.change_network_state.await_count == 1
+    assert app._api.device_state.await_count == 10
     assert app._api.device_state.call_count == 10
 
 
@@ -195,26 +204,24 @@ async def _version():
         app._api._proto_ver = protocol_ver
         return [version]
 
-    app._reset_watchdog = mock.MagicMock(
-        side_effect=asyncio.coroutine(mock.MagicMock())
-    )
-    app.form_network = mock.MagicMock(side_effect=asyncio.coroutine(mock.MagicMock()))
-    app._api._command = mock.MagicMock(side_effect=asyncio.coroutine(mock.MagicMock()))
-    app._api.read_parameter = mock.MagicMock(
-        side_effect=asyncio.coroutine(mock.MagicMock(return_value=[[0]]))
-    )
-    app._api.version = mock.MagicMock(side_effect=_version)
-    app._api.write_parameter = mock.MagicMock(
-        side_effect=asyncio.coroutine(mock.MagicMock())
-    )
+    app._reset_watchdog = CoroutineMock()
+    app.form_network = CoroutineMock()
+
+    app._api._command = CoroutineMock()
+    api = deconz_api.Deconz(app, app._config[zigpy.config.CONF_DEVICE])
+    api.connect = CoroutineMock()
+    api._command = CoroutineMock()
+    api.read_parameter = CoroutineMock(return_value=[[0]])
+    api.version = mock.MagicMock(side_effect=_version)
+    api.write_parameter = CoroutineMock()
 
-    new_mock = mock.MagicMock(side_effect=asyncio.coroutine(mock.MagicMock()))
-    monkeypatch.setattr(application.ConBeeDevice, "new", new_mock)
-    await app.startup(auto_form=False)
-    assert app.form_network.call_count == 0
-    assert app._reset_watchdog.call_count == watchdog_cc
-    await app.startup(auto_form=True)
-    assert app.form_network.call_count == 1
+    monkeypatch.setattr(application.ConBeeDevice, "new", CoroutineMock())
+    with mock.patch.object(application, "Deconz", return_value=api):
+        await app.startup(auto_form=False)
+        assert app.form_network.call_count == 0
+        assert app._reset_watchdog.call_count == watchdog_cc
+        await app.startup(auto_form=True)
+        assert app.form_network.call_count == 1
 
 
 @pytest.mark.asyncio
@@ -514,16 +521,15 @@ async def test_mrequest_send_aps_data_error(app):
 
 
 @pytest.mark.asyncio
-@mock.patch.object(application, "WATCHDOG_TTL", new=1)
 async def test_reset_watchdog(app):
     """Test watchdog."""
-    with asynctest.patch.object(app._api, "write_parameter") as mock_api:
+    with mock.patch.object(app._api, "write_parameter") as mock_api:
         dog = asyncio.ensure_future(app._reset_watchdog())
         await asyncio.sleep(0.3)
         dog.cancel()
         assert mock_api.call_count == 1
 
-    with asynctest.patch.object(app._api, "write_parameter") as mock_api:
+    with mock.patch.object(app._api, "write_parameter") as mock_api:
         mock_api.side_effect = zigpy_deconz.exception.CommandError
         dog = asyncio.ensure_future(app._reset_watchdog())
         await asyncio.sleep(0.3)

tests/test_application.py

@@ -2,6 +2,7 @@
 
 import pytest
 import serial_asyncio
+from zigpy.config import CONF_DEVICE_PATH
 
 from zigpy_deconz import uart
 
@@ -16,7 +17,6 @@ def gw():
 @pytest.mark.asyncio
 async def test_connect(monkeypatch):
     api = mock.MagicMock()
-    portmock = mock.MagicMock()
 
     async def mock_conn(loop, protocol_factory, **kwargs):
         protocol = protocol_factory()
@@ -25,7 +25,7 @@ async def mock_conn(loop, protocol_factory, **kwargs):
 
     monkeypatch.setattr(serial_asyncio, "create_serial_connection", mock_conn)
 
-    await uart.connect(portmock, 57600, api)
+    await uart.connect({CONF_DEVICE_PATH: "/dev/null"}, api)
 
 
 def test_send(gw):

tests/test_uart.py

@@ -1,6 +1,6 @@
 # coding: utf-8
 MAJOR_VERSION = 0
-MINOR_VERSION = 8
+MINOR_VERSION = 9
 PATCH_VERSION = "0"
 __short_version__ = "{}.{}".format(MAJOR_VERSION, MINOR_VERSION)
 __version__ = "{}.{}".format(__short_version__, PATCH_VERSION)