Improve handling of availability (#106)

Author: drc38

custom_components/ocpp/api.py

@@ -7,7 +7,7 @@
 from typing import Dict
 
 from homeassistant.config_entries import ConfigEntry
-from homeassistant.const import TIME_MINUTES
+from homeassistant.const import STATE_OK, STATE_UNAVAILABLE, TIME_MINUTES
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import device_registry, entity_component, entity_registry
 import voluptuous as vol
@@ -164,6 +164,7 @@ async def on_connect(self, websocket, path: str):
         except Exception as e:
             _LOGGER.info(f"Exception occurred:\n{e}")
         finally:
+            self.charge_points[self.cpid].status = STATE_UNAVAILABLE
             _LOGGER.info(f"Charger {cp_id} disconnected from {self.host}:{self.port}.")
 
     def get_metric(self, cp_id: str, measurand: str):
@@ -184,6 +185,12 @@ def get_extra_attr(self, cp_id: str, measurand: str):
             return self.charge_points[cp_id].get_extra_attr(measurand)
         return None
 
+    def get_available(self, cp_id: str):
+        """Return whether the charger is available."""
+        if cp_id in self.charge_points:
+            return self.charge_points[cp_id].status == STATE_OK
+        return False
+
     async def set_charger_state(
         self, cp_id: str, service_name: str, state: bool = True
     ):
@@ -261,10 +268,14 @@ async def post_connect(self):
         # Define custom service handles for charge point
         async def handle_clear_profile(call):
             """Handle the clear profile service call."""
+            if self.status == STATE_UNAVAILABLE:
+                return
             await self.clear_profile()
 
         async def handle_set_charge_rate(call):
             """Handle the set charge rate service call."""
+            if self.status == STATE_UNAVAILABLE:
+                return
             lim_A = call.data.get("limit_amps")
             lim_W = call.data.get("limit_watts")
             if lim_A is not None and lim_W is not None:
@@ -278,24 +289,29 @@ async def handle_set_charge_rate(call):
 
         async def handle_update_firmware(call):
             """Handle the firmware update service call."""
+            if self.status == STATE_UNAVAILABLE:
+                return
             url = call.data.get("firmware_url")
             delay = int(call.data.get("delay_hours", 0))
             await self.update_firmware(url, delay)
 
         async def handle_configure(call):
             """Handle the configure service call."""
+            if self.status == STATE_UNAVAILABLE:
+                return
             key = call.data.get("ocpp_key")
             value = call.data.get("value")
             await self.configure(key, value)
-            return
 
         async def handle_get_configuration(call):
             """Handle the get configuration service call."""
+            if self.status == STATE_UNAVAILABLE:
+                return
             key = call.data.get("ocpp_key")
             await self.get_configuration(key)
-            return
 
         try:
+            self.status = STATE_OK
             await self.get_supported_features()
             if om.feature_profile_remote.value in self._features_supported:
                 await self.trigger_boot_notification()
@@ -650,7 +666,11 @@ async def start(self):
     async def reconnect(self, connection):
         """Reconnect charge point."""
         self._connection = connection
-        await self.start()
+        try:
+            self.status = STATE_OK
+            await super().start()
+        except websockets.exceptions.ConnectionClosed as e:
+            _LOGGER.debug(e)
 
     async def async_update_device_info(self, boot_info: dict):
         """Update device info asynchronuously."""

custom_components/ocpp/enums.py

@@ -5,7 +5,7 @@
 class HAChargerServices(str, Enum):
     """Charger status conditions to report in home assistant."""
 
-    """For HA service reference use .name for function to call use .value"""
+    """For HA service reference and for function to call use .value"""
 
     service_charge_start = "start_transaction"
     service_charge_stop = "stop_transaction"

custom_components/ocpp/sensor.py

@@ -67,6 +67,11 @@ def state(self):
         """Return the state of the sensor."""
         return self.central_system.get_metric(self.cp_id, self.metric)
 
+    @property
+    def available(self) -> bool:
+        """Return if switch is available."""
+        return self.central_system.get_available(self.cp_id)
+
     @property
     def unit_of_measurement(self):
         """Return the unit the value is expressed in."""

custom_components/ocpp/switch.py

@@ -45,7 +45,7 @@ def unique_id(self):
     @property
     def available(self) -> bool:
         """Return if switch is available."""
-        return True  # type: ignore [no-any-return]
+        return self.central_system.get_available(self.cp_id)  # type: ignore [no-any-return]
 
     @property
     def is_on(self) -> bool:

setup.cfg

@@ -41,5 +41,6 @@ branch = False
 
 [coverage:report]
 show_missing = true
-fail_under = 85
+fail_under = 90
+
 

tests/test_charge_point.py

@@ -9,7 +9,7 @@
 
 from custom_components.ocpp import async_setup_entry, async_unload_entry
 from custom_components.ocpp.const import DOMAIN, SWITCH, SWITCHES
-from custom_components.ocpp.enums import ConfigurationKey
+from custom_components.ocpp.enums import ConfigurationKey, HAChargerServices as csvcs
 from ocpp.routing import on
 from ocpp.v16 import ChargePoint as cpclass, call, call_result
 from ocpp.v16.enums import (
@@ -38,7 +38,6 @@ async def test_cms_responses(hass):
 
     async def test_switches(hass):
         """Test switch operations."""
-
         for switch in SWITCHES:
             result = await hass.services.async_call(
                 SWITCH,
@@ -60,6 +59,31 @@ async def test_switches(hass):
             )
             assert result
 
+    async def test_services(hass):
+        """Test service operations."""
+        SERVICES = [
+            csvcs.service_update_firmware,
+            csvcs.service_configure,
+            csvcs.service_get_configuration,
+            csvcs.service_clear_profile,
+            csvcs.service_set_charge_rate,
+        ]
+        for service in SERVICES:
+            data = {}
+            if service == csvcs.service_update_firmware:
+                data = {"firmware_url": "http://www.charger.com/firmware.bin"}
+            if service == csvcs.service_configure:
+                data = {"ocpp_key": "WebSocketPingInterval", "value": "60"}
+            if service == csvcs.service_get_configuration:
+                data = {"ocpp_key": "WebSocketPingInterval"}
+            result = await hass.services.async_call(
+                DOMAIN,
+                service.value,
+                service_data=data,
+                blocking=True,
+            )
+            assert result
+
     # Create a mock entry so we don't have to go through config flow
     config_entry = MockConfigEntry(
         domain=DOMAIN, data=MOCK_CONFIG_DATA, entry_id="test_cms"
@@ -69,6 +93,7 @@ async def test_switches(hass):
 
     cs = hass.data[DOMAIN][config_entry.entry_id]
 
+    # test ocpp messages sent from charger to cms
     async with websockets.connect(
         "ws://localhost:9000/CP_1",
         subprotocols=["ocpp1.6"],
@@ -85,27 +110,36 @@ async def test_switches(hass):
                     cp.send_status_notification(),
                     cp.send_firmware_status(),
                     cp.send_data_transfer(),
-                    cp.send_start_transaction(),
                     cp.send_meter_data(),
+                    cp.send_start_transaction(),
                     cp.send_stop_transaction(),
-                    cs.charge_points["test_cpid"].start_transaction(),
-                    cs.charge_points["test_cpid"].reset(),
-                    cs.charge_points["test_cpid"].set_charge_rate(),
-                    cs.charge_points["test_cpid"].clear_profile(),
-                    cs.charge_points["test_cpid"].update_firmware(
-                        "http://www.charger.com/file.bin"
-                    ),
-                    cs.charge_points["test_cpid"].unlock(),
+                ),
+                timeout=4,
+            )
+        except asyncio.TimeoutError:
+            pass
+    assert int(cs.get_metric("test_cpid", "Energy.Active.Import.Register")) == int(
+        1305570 / 1000
+    )
+    assert cs.get_unit("test_cpid", "Energy.Active.Import.Register") == "kWh"
+
+    # test ocpp messages sent from cms to charger, through HA switches/services
+    async with websockets.connect(
+        "ws://localhost:9000/CP_1",
+        subprotocols=["ocpp1.6"],
+    ) as ws:
+        cp = ChargePoint("CP_1_test", ws)
+        try:
+            await asyncio.wait_for(
+                asyncio.gather(
+                    cp.start(),
                     test_switches(hass),
+                    test_services(hass),
                 ),
-                timeout=5,
+                timeout=4,
             )
         except asyncio.TimeoutError:
             pass
-        assert int(cs.get_metric("test_cpid", "Energy.Active.Import.Register")) == int(
-            1305570 / 1000
-        )
-        assert cs.get_unit("test_cpid", "Energy.Active.Import.Register") == "kWh"
     await async_unload_entry(hass, config_entry)
     await hass.async_block_till_done()
 
@@ -282,6 +316,16 @@ async def send_start_transaction(self):
 
     async def send_status_notification(self):
         """Send a status notification."""
+        request = call.StatusNotificationPayload(
+            connector_id=1,
+            error_code=ChargePointErrorCode.no_error,
+            status=ChargePointStatus.suspended_ev,
+            timestamp=datetime.now(tz=timezone.utc).isoformat(),
+            info="Test info",
+            vendor_id="The Mobility House",
+            vendor_error_code="Test error",
+        )
+        resp = await self.call(request)
         request = call.StatusNotificationPayload(
             connector_id=1,
             error_code=ChargePointErrorCode.no_error,
@@ -352,7 +396,7 @@ async def send_meter_data(self):
                             "context": "Sample.Periodic",
                             "measurand": "Power.Active.Import",
                             "location": "Outlet",
-                            "unit": "W",
+                            "unit": "kW",
                         },
                         {
                             "value": "0.000",
@@ -450,6 +494,9 @@ async def send_meter_data(self):
                             "context": "Transaction.Begin",
                             "unit": "kWh",
                         },
+                        {
+                            "value": "1305570.000",
+                        },
                     ],
                 }
             ],