Fix status priority for suspended-ev and suspended-evse (#56)

* Update `Pod.connected` to correctly support `suspended-evse`

* 55: Fix status priorities for suspended-ev and suspended-evse

In order to address #55 I have re-worked how 'new' statuses are
handled. Also adds additional tests for the integration.

* Rev version

Author: mattrayner

custom_components/pod_point/coordinator.py

@@ -340,8 +340,8 @@ async def __async_group_pods(
         return (new_pods, new_pods_by_id)
 
     async def __async_refresh_firmware(
-        self, new_pods: List[Pod], new_pods_by_id: Dict[str, List[Pod]]
-    ) -> Dict[str, List[Pod]]:
+        self, new_pods: List[Pod], new_pods_by_id: Dict[str, Pod]
+    ) -> Dict[str, Pod]:
         _LOGGER.debug("=== FIRMWARE STATUS UPDATE ===")
 
         for pod in new_pods:
@@ -367,8 +367,8 @@ async def __async_refresh_firmware(
         return new_pods_by_id
 
     async def __async_update_pod_connection_status(
-        self, new_pods_by_id: Dict[str, List[Pod]]
-    ) -> Dict[str, List[Pod]]:
+        self, new_pods_by_id: Dict[str, Pod]
+    ) -> Dict[str, Pod]:
         _LOGGER.debug("=== POD CONNECTION STATUS UPDATE ===")
 
         # flat_pods = [item for row in new_pods_by_id.values() for item in row]
@@ -381,16 +381,8 @@ async def __async_update_pod_connection_status(
                 pod.last_message_at = connectivity_status.last_message_at
                 pod.charging_state = connectivity_status.charging_state
 
-                pod.statuses.append(
-                    Pod.Status(
-                        99,
-                        connectivity_status.charging_state,
-                        connectivity_status.charging_state,
-                        connectivity_status.charging_state,
-                        "A",
-                        1,
-                    )
-                )
+                if pod.charging_state is not None:
+                    pod.charging_state = pod.charging_state.lower().replace("_", "-")
 
                 new_pods_by_id[pod.unit_id] = pod
 

custom_components/pod_point/entity.py

@@ -85,6 +85,14 @@ def __update_attrs(self):
         should_be_charging = is_charging_state and (
             is_override_charge_mode or is_manual_charge_mode
         )
+        should_be_suspended_ev = (
+                is_charging_state
+                and (pod.charging_state == ATTR_STATE_SUSPENDED_EV)
+        )
+        should_be_suspended_evse = (
+                is_charging_state
+                and (pod.charging_state == ATTR_STATE_SUSPENDED_EVSE)
+        )
         should_be_pending = (
             self.coordinator.last_message_at is not None
             and self.pod.last_message_at is not None
@@ -105,6 +113,14 @@ def __update_attrs(self):
         if should_be_charging:
             state = ATTR_STATE_CHARGING
 
+        # Pod should be suspended evse if pod is charging and connectivity status is suspended evse
+        if should_be_suspended_evse:
+            state = ATTR_STATE_SUSPENDED_EVSE
+
+        # Pod should be suspended ev if pod is charging and connectivity status is suspended ev
+        if should_be_suspended_ev:
+            state = ATTR_STATE_SUSPENDED_EV
+
         # Should this pod be pending?
         if should_be_pending:
             state = ATTR_STATE_PENDING

custom_components/pod_point/manifest.json

@@ -570,5 +570,5 @@
     "aiodiscover",
     "scapy"
   ],
-  "version": "2.0.0"
+  "version": "2.0.2"
 }

custom_components/pod_point/version.py

@@ -1,3 +1,3 @@
 """Version of the Pod Point integration"""
 
-__version__ = "2.0.0"
+__version__ = "2.0.2"

tests/test_binary_sensor.py

@@ -0,0 +1,111 @@
+"""Test pod_point binary sensors."""
+
+from typing import List, Union
+from unittest.mock import Mock, call, patch
+
+from homeassistant.components.binary_sensor import (
+    BinarySensorDeviceClass,
+    BinarySensorEntity,
+)
+from homeassistant.helpers.entity import EntityCategory
+import pytest
+from pytest_homeassistant_custom_component.common import MockConfigEntry
+
+from custom_components.pod_point import async_setup_entry
+from custom_components.pod_point.const import (
+    ATTR_CONNECTION_STATE_ONLINE,
+    DOMAIN, ATTR_STATE,
+)
+from custom_components.pod_point.binary_sensor import (
+    PodPointCableConnectionSensor,
+    PodPointCloudConnectionSensor,
+    async_setup_entry,
+)
+from podpointclient.connectivity_status import ConnectivityStatus, Evse
+
+from .const import MOCK_CONFIG
+from .fixtures import CONNECTIVITY_STATUS_COMPLETE_FIXTURE
+from .test_coordinator import subject_with_data as coordinator_with_data
+
+
+async def setup_sensors(hass) -> List[BinarySensorEntity]:
+    """Setup sensors within the test environment"""
+    coordinator = await coordinator_with_data(hass)
+
+    # Create a mock entry so we don't have to go through config flow
+    config_entry = MockConfigEntry(domain=DOMAIN, data=MOCK_CONFIG, entry_id="test")
+
+    hass.data[DOMAIN] = {}
+    hass.data[DOMAIN][config_entry.entry_id] = coordinator
+
+    mock = Mock()
+
+    await async_setup_entry(hass, config_entry, mock)
+
+    print(mock.call_args_list)
+    sensors: List[Union(PodPointCableConnectionSensor, PodPointCloudConnectionSensor)] = (
+        mock.call_args_list[0][0][0]
+    )
+
+    return (config_entry, sensors)
+
+
+@pytest.mark.asyncio
+async def test_sensor_creation(hass, bypass_get_data):
+    """Test that the expected number of sensors is created"""
+
+    (_, sensors) = await setup_sensors(hass)
+
+    assert 2 == len(sensors)
+
+
+@pytest.mark.asyncio
+async def test_cloud_connection_sensor(hass, bypass_get_data):
+    """Tests for pod status sensor."""
+    (_, sensors) = await setup_sensors(hass)
+
+    [_, status] = sensors
+
+    assert BinarySensorDeviceClass.CONNECTIVITY == status.device_class
+    assert EntityCategory.DIAGNOSTIC == status.entity_category
+    assert "pod_point_12234_PSL-123456_cloud_connection" == status.unique_id
+    assert "Cloud Connection" == status.name
+
+    status.pod.connectivity_status = ConnectivityStatus(CONNECTIVITY_STATUS_COMPLETE_FIXTURE)
+    assert status.is_on is True
+    assert "mdi:cloud-check-variant" == status.icon
+
+    status.pod.connectivity_status.evses[0].connectivity_state.connectivity_status = "FOO"
+    assert status.is_on is False
+    assert "mdi:cloud-off" == status.icon
+
+
+@pytest.mark.asyncio
+async def test_cable_connection_sensor(hass, bypass_get_data):
+    """Tests for pod status sensor."""
+    (_, sensors) = await setup_sensors(hass)
+
+    [status, _] = sensors
+
+    assert BinarySensorDeviceClass.PLUG == status.device_class
+    assert "pod_point_12234_PSL-123456_cable_status" == status.unique_id
+    assert "Cable Status" == status.name
+
+    status.extra_attrs[ATTR_STATE] = "charging"
+    assert status.is_on is True
+
+    status.extra_attrs[ATTR_STATE] = "available"
+    assert status.is_on is False
+
+    status.extra_attrs[ATTR_STATE] = "connected-waiting-for-schedule"
+    assert status.is_on is True
+
+    status.extra_attrs[ATTR_STATE] = "suspended-evse"
+    assert status.is_on is True
+
+    status.extra_attrs[ATTR_STATE] = "suspended-ev"
+    assert status.is_on is True
+
+    status.extra_attrs[ATTR_STATE] = "foo"
+    assert status.is_on is False
+

tests/test_entity.py

@@ -1,10 +1,11 @@
 """Test pod_point switch."""
 
 # import asyncio
-from datetime import datetime
+from datetime import datetime, timedelta
 from email.utils import encode_rfc2231
 from typing import List
 from unittest.mock import Mock, call, patch
+import pytz
 
 # import aiohttp
 from homeassistant.components import switch
@@ -318,6 +319,32 @@ async def test_pod_point_entity(hass, bypass_get_data):
     entity.pod.model.name = None
     assert None == entity.image
 
+    # Test states for ev and evse suspended
+    assert "charging" == entity.state
+    entity.pod.charging_state = "suspended-ev"
+    entity._PodPointEntity__update_attrs()
+    assert entity.state == "suspended-ev"
+
+    entity.pod.charging_state = "suspended-evse"
+    entity._PodPointEntity__update_attrs()
+    assert entity.state == "suspended-evse"
+
+    entity.pod.statuses[0].key_name = 'available'
+    entity.pod.charging_state = "suspended-evse"
+    entity._PodPointEntity__update_attrs()
+    assert entity.state == "available"
+
+    entity.pod.statuses[0].key_name = 'out-of-service'
+    entity.pod.charging_state = "suspended-evse"
+    entity._PodPointEntity__update_attrs()
+    assert entity.state == "out-of-service"
+
+    # Test pending status
+    entity.coordinator.last_message_at = datetime.now(tz=pytz.utc)
+    entity.pod.last_message_at = datetime.now(tz=pytz.utc) - timedelta(minutes=5)
+    entity._PodPointEntity__update_attrs()
+    assert entity.state == "pending"
+
 
 @pytest.mark.asyncio
 async def test_compare_state(hass, bypass_get_data):