zcc-helper 3.4.dev1__tar.gz → 3.4.dev2__tar.gz

{zcc_helper-3.4.dev1 → zcc_helper-3.4.dev2}/PKG-INFO

@@ -1,16 +1,23 @@
-Metadata-Version: 2.1
+Metadata-Version: 2.4
 Name: zcc_helper
-Version: 3.4.dev1
+Version: 3.4.dev2
 Summary: ZIMI ZCC helper module
-Home-page: UNKNOWN
 Author: Mark Hannon
 Author-email: mark.hannon@gmail.com
 License: MIT
 Project-URL: Source, https://bitbucket.org/mark_hannon/zcc
-Platform: UNKNOWN
-Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: summary
 
 # ZCC-HELPER
 
@@ -274,5 +281,3 @@ python -m zcc --execute --device 'bddf0500-4d15-4457-b063-c12ed208a0b0_3' --acti
 ```
 
 This version of the command is relatively slow as it first of all discovers the ZCC on the local LAN, builds a device inventory and then executes the action.
-
-

{zcc_helper-3.4.dev1 → zcc_helper-3.4.dev2}/setup.py

@@ -19,7 +19,7 @@ setup(
     author_email="mark.hannon@gmail.com",
     license="MIT",
     classifiers=[
-        "Programming Language :: Python :: 3.9",
+        "Programming Language :: Python :: 3.12",
     ],
     packages=find_packages(exclude=["contrib", "docs", "tests"]),
     project_urls={"Source": "https://bitbucket.org/mark_hannon/zcc"},

zcc_helper-3.4.dev2/tests/test_controller.py

@@ -0,0 +1,59 @@
+'''Test Basic Controller functionality.'''
+import pytest
+
+from zcc.controller import ControlPoint, ControlPointError
+from zcc.device import ControlPointDevice
+
+from tests.test_server import test_server
+
+
+def test_controller_discover(test_server):
+    '''Test for connection to a Controller connected to the Test Server'''
+
+    controller = ControlPoint(timeout=1)
+
+    assert controller.ready is True
+    assert controller.host is not None
+    assert controller.port == 5003
+    assert controller.brand == 'zimi'
+    assert len(controller.devices) == 31
+    assert len(controller.doors) == 0
+    assert len(controller.fans) == 0
+    assert len(controller.lights) == 20
+    assert len(controller.outlets) == 0
+
+
+def test_controller_discover_timeout():
+    '''Test if a UDP discovery times out - goes out over wire'''
+
+    try:
+        ControlPoint(timeout=1)
+        assert False
+    except ControlPointError as error:
+        assert error.args[0] == '__init() failed - unable to discover and connect to ZCC'
+
+
+def test_controller_device(test_server):
+    '''Test turn_on works for valid devices'''
+
+    controller = ControlPoint(timeout=1)
+
+    light = controller.lights[0]
+
+    assert light.is_off() is not True
+    assert light.is_on() is True
+
+    assert light.is_opening is not True
+    assert light.is_open is not True
+    assert light.location == "lounge LED strip/Lounge"
+    assert light.name == "lounge LED strip"
+
+    with pytest.raises(ControlPointDeviceError):
+        light.open_door()
+
+    with pytest.raises(ControlPointDeviceError):
+        light.close_door()
+
+    light.turn_on()
+
+    light.turn_off()

zcc_helper-3.4.dev2/tests/test_device.py

@@ -0,0 +1,42 @@
+import unittest
+
+from zcc.device import ControlPointDevice
+
+
+class DeviceTest(unittest.TestCase):
+
+    identifier = 'test_device_id'
+
+    def test_init(self):
+        device = ControlPointDevice(None, DeviceTest.identifier)
+        self.assertEqual(device.controller, None)
+        self.assertEqual(device.identifier, DeviceTest.identifier)
+        self.assertEqual(device.actions, {})
+        self.assertEqual(device.properties, {})
+        self.assertEqual(device.states, {})
+
+    def test_add_action(self):
+        device = ControlPointDevice(None, DeviceTest.identifier)
+        device.actions = {'TurnOn': {'actionParams': {}},
+                          'TurnOff': {'actionParams': {}}}
+        print(device)
+        self.assertEqual(device.controller, None)
+        self.assertEqual(device.identifier, DeviceTest.identifier)
+
+    def test_add_properties(self):
+        device = ControlPointDevice(None, DeviceTest.identifier)
+        device.properties = {'name': 'Entry Pendant',
+                             'controlPointType': 'switch', 'roomId': 2, 'roomName': 'Front Door '}
+        self.assertEqual(device.controller, None)
+        self.assertEqual(device.identifier, DeviceTest.identifier)
+
+    def test_add_states(self):
+        device = ControlPointDevice(None, DeviceTest.identifier)
+        device.states = {'controlState': {
+            'switch': {...}}, 'isConnected': True}
+        self.assertEqual(device.controller, None)
+        self.assertEqual(device.identifier, DeviceTest.identifier)
+
+
+if __name__ == '__main__':
+    unittest.main()

zcc_helper-3.4.dev2/tests/test_server.py

@@ -0,0 +1,11 @@
+'''Setup Test Server.'''
+import pytest
+
+from zcc.controller import ControlPoint, ControlPointError
+from tests.server import TestServer
+
+
+@pytest.fixture
+def test_server():
+    '''Create (and delete) a Test Server'''
+    return TestServer()

zcc_helper-3.4.dev2/tests/test_socket.py

@@ -0,0 +1,52 @@
+import socket
+import pytest
+from unittest.mock import Mock
+from mockito import when, unstub
+
+from zcc.socket import ControlPointSocket
+
+TEST_HOST = '10.0.0.1'
+TEST_PORT = 4567
+TEST_TIMEOUT = 5
+
+
+@pytest.fixture
+def mock_tcp_socket():
+    mock_socket = Mock(spec=socket.socket)
+    return mock_socket
+
+
+def test_socket_create(mock_tcp_socket, when):
+
+    when(socket).socket(socket.AF_INET,
+                        socket.SOCK_STREAM)\
+        .thenReturn(mock_tcp_socket)
+
+    controller_socket = ControlPointSocket(TEST_HOST, TEST_PORT)
+
+    assert controller_socket.host == TEST_HOST
+    assert controller_socket.port == TEST_PORT
+    assert controller_socket.sock == mock_tcp_socket
+
+    controller_socket.close()
+    assert controller_socket.sock == None
+
+
+def test_socket_create_timeout(mock_tcp_socket, when):
+
+    when(socket).socket(socket.AF_INET,
+                        socket.SOCK_STREAM)\
+        .thenReturn(mock_tcp_socket)
+
+    controller_socket = ControlPointSocket(
+        TEST_HOST, TEST_PORT, timeout=TEST_TIMEOUT)
+
+    assert controller_socket.host == TEST_HOST
+    assert controller_socket.port == TEST_PORT
+    assert controller_socket.sock == mock_tcp_socket
+
+    assert mock_tcp_socket.settimeout.call_count == 1
+    assert mock_tcp_socket.settimeout.call_args.args == (TEST_TIMEOUT,)
+
+    controller_socket.close()
+    assert controller_socket.sock == None

{zcc_helper-3.4.dev1 → zcc_helper-3.4.dev2}/zcc/__main__.py

@@ -52,6 +52,9 @@ def __options(args):
     cxg.add_argument(
         "--execute", action="store_true", help="execute an action on a device"
     )
+    cxg.add_argument(
+        "--test-connection", action="store_true", help="test the connection to a device"
+    )
 
     host_group = parser.add_argument_group("host")
     host_group.add_argument("--host", action="store", help="zcc host name|address")
@@ -96,6 +99,12 @@ async def main(args):
         await ControlPointDiscoveryService(verbosity=options.verbosity).discover()
         return
 
+    if options.test_connection and options.host and options.port:
+        await ControlPointDiscoveryService(
+            verbosity=options.verbosity
+        ).validate_connection(host=options.host, port=options.port)
+        return
+
     if options.host and options.port:
         description = ControlPointDescription(host=options.host, port=options.port)
     else:

{zcc_helper-3.4.dev1 → zcc_helper-3.4.dev2}/zcc/constants.py

@@ -9,4 +9,4 @@ APP_ID = "ZvWqWJQB"
 APP_TOKEN = "3422ecbb-cf6a-404c-b3dc-2023dd213535"
 
 NAME = "zcc_helper"
-VERSION = "3.4-dev1"
+VERSION = "3.4-dev2"

{zcc_helper-3.4.dev1 → zcc_helper-3.4.dev2}/zcc/discovery.py

@@ -3,6 +3,7 @@
 from __future__ import annotations
 
 import asyncio
+from enum import StrEnum
 import json
 from json.decoder import JSONDecodeError
 import logging
@@ -10,11 +11,25 @@ import socket
 from typing import Tuple
 
 from zcc.constants import LEVEL_BY_VERBOSITY
+from zcc.controller import ControlPoint
 from zcc.description import ControlPointDescription
 from zcc.errors import ControlPointError
 from zcc.protocol import ControlPointProtocol
 
 
+class ControlPointDiscoveryErrors(StrEnum):
+    """Discovery errors."""
+
+    ALREADY_CONFIGURED = "already_configured"
+    CANNOT_CONNECT = "cannot_connect"
+    CONNECTION_REFUSED = "connection_refused"
+    DISCOVERY_FAILURE = "discovery_failure"
+    INVALID_HOST = "invalid_host"
+    INVALID_PORT = "invalid_port"
+    TIMEOUT = "timeout"
+    UNKNOWN = "unknown"
+
+
 class ControlPointDiscoveryProtocol(asyncio.DatagramProtocol):
     """Listens for ZCC announcements on the defined UDP port."""
 
@@ -76,6 +91,7 @@ class ControlPointDiscoveryService:
         self.discovery_complete = self.loop.create_future()
         self.discovery_result: list[ControlPointDescription] = []
         self.never_completes = self.loop.create_future()
+        self.validation_result: ControlPointDescription
 
     async def discover(
         self, wait_for_all: bool = False
@@ -135,3 +151,57 @@ class ControlPointDiscoveryService:
     async def discovers(self) -> list[ControlPointDescription]:
         """Discover all local zimi controllers."""
         return await self.discover(wait_for_all=True)
+
+    async def validate_connection(
+        self, host: str, port: int
+    ) -> ControlPointDescription | dict[str, str]:
+        """Validate ability to connect and close a connection.
+
+        Return a ControlPointDescription if OK or error dictionary if not.
+        """
+
+        error = None
+
+        try:
+            socket.gethostbyname(host)
+            s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+            s.settimeout(10)
+            try:
+                s.connect((host, port))
+                s.close()
+            except ConnectionRefusedError:
+                error = {"error": ControlPointDiscoveryErrors.CONNECTION_REFUSED}
+            except TimeoutError:
+                error = {"error": ControlPointDiscoveryErrors.TIMEOUT}
+            except socket.gaierror:
+                error = {"error": ControlPointDiscoveryErrors.CANNOT_CONNECT}
+        except socket.gaierror:
+            error = {"error": ControlPointDiscoveryErrors.INVALID_HOST}
+
+        if error:
+            self.logger.error(error)
+            return error
+
+        api = ControlPoint(ControlPointDescription(host=host, port=port))
+
+        try:
+            await api.connect(fast=True)
+        except ControlPointError:
+            return {"error": ControlPointDiscoveryErrors.CANNOT_CONNECT}
+
+        self.validation_result = ControlPointDescription(
+            brand=api.brand,
+            product=api.product,
+            host=host,
+            port=port,
+            mac=api.mac,
+            available_tcps=api.available_tcps,
+            api_version=api.api_version,
+            firmware_version=api.firmware_version
+        )
+
+        api.disconnect()
+        
+        self.logger.info(self.validation_result)
+
+        return self.validation_result

{zcc_helper-3.4.dev1 → zcc_helper-3.4.dev2}/zcc_helper.egg-info/PKG-INFO

@@ -1,16 +1,23 @@
-Metadata-Version: 2.1
-Name: zcc-helper
-Version: 3.4.dev1
+Metadata-Version: 2.4
+Name: zcc_helper
+Version: 3.4.dev2
 Summary: ZIMI ZCC helper module
-Home-page: UNKNOWN
 Author: Mark Hannon
 Author-email: mark.hannon@gmail.com
 License: MIT
 Project-URL: Source, https://bitbucket.org/mark_hannon/zcc
-Platform: UNKNOWN
-Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.12
 Description-Content-Type: text/markdown
 License-File: LICENSE.txt
+Dynamic: author
+Dynamic: author-email
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: license
+Dynamic: license-file
+Dynamic: project-url
+Dynamic: summary
 
 # ZCC-HELPER
 
@@ -274,5 +281,3 @@ python -m zcc --execute --device 'bddf0500-4d15-4457-b063-c12ed208a0b0_3' --acti
 ```
 
 This version of the command is relatively slow as it first of all discovers the ZCC on the local LAN, builds a device inventory and then executes the action.
-
-

{zcc_helper-3.4.dev1 → zcc_helper-3.4.dev2}/zcc_helper.egg-info/SOURCES.txt

@@ -2,6 +2,10 @@ LICENSE.txt
 README.md
 setup.py
 zcc.py
+tests/test_controller.py
+tests/test_device.py
+tests/test_server.py
+tests/test_socket.py
 zcc/__init__.py
 zcc/__main__.py
 zcc/constants.py