Refactor rainforest_raven coordinator tests (home-assistant#128591)

* Refactor rainforest_raven tests

* Remove assert

* Cleanup freezer

* Drop un-needed coordinator properties

* Cleanup remaining coordinator tests

* Improve

* Revert _DEVICE_TIMEOUT

* Ensure 100% coverage

* Use async_fire_time_changed

tests/components/rainforest_raven/test_init.py

@@ -3,6 +3,7 @@
 from unittest.mock import AsyncMock
 
 from aioraven.data import DeviceInfo as RAVenDeviceInfo
+from aioraven.device import RAVEnConnectionError
 import pytest
 from syrupy.assertion import SnapshotAssertion
 
@@ -55,3 +56,28 @@ async def test_device_registry(
     entries = dr.async_entries_for_config_entry(device_registry, entry.entry_id)
     assert len(entries) == device_count
     assert entries == snapshot
+
+
+async def test_synchronize_error(hass: HomeAssistant, mock_device: AsyncMock) -> None:
+    """Test handling of an error parsing or reading raw device data."""
+    entry = create_mock_entry()
+    entry.add_to_hass(hass)
+
+    mock_device.synchronize.side_effect = RAVEnConnectionError
+
+    await hass.config_entries.async_setup(entry.entry_id)
+
+    assert entry.state is ConfigEntryState.SETUP_RETRY
+
+
+async def test_get_network_info_error(
+    hass: HomeAssistant, mock_device: AsyncMock
+) -> None:
+    """Test handling of a device error during initialization."""
+    entry = create_mock_entry()
+    entry.add_to_hass(hass)
+
+    mock_device.get_network_info.side_effect = RAVEnConnectionError
+    await hass.config_entries.async_setup(entry.entry_id)
+
+    assert entry.state is ConfigEntryState.SETUP_RETRY

tests/components/rainforest_raven/test_sensor.py

@@ -1,12 +1,20 @@
 """Tests for the Rainforest RAVEn sensors."""
 
+from datetime import timedelta
+from unittest.mock import AsyncMock
+
+from aioraven.device import RAVEnConnectionError
+from freezegun.api import FrozenDateTimeFactory
 import pytest
 from syrupy.assertion import SnapshotAssertion
 
+from homeassistant.const import STATE_UNAVAILABLE
 from homeassistant.core import HomeAssistant
 from homeassistant.helpers import entity_registry as er
 
-from tests.common import MockConfigEntry, snapshot_platform
+from .const import NETWORK_INFO
+
+from tests.common import MockConfigEntry, async_fire_time_changed, snapshot_platform
 
 
 @pytest.mark.usefixtures("mock_entry")
@@ -20,3 +28,75 @@ async def test_sensors(
     assert len(hass.states.async_all()) == 5
 
     await snapshot_platform(hass, entity_registry, snapshot, mock_entry.entry_id)
+
+
+@pytest.mark.usefixtures("mock_entry")
+async def test_device_update_error(
+    hass: HomeAssistant,
+    mock_device: AsyncMock,
+    freezer: FrozenDateTimeFactory,
+) -> None:
+    """Test handling of a device error during an update."""
+    mock_device.get_network_info.side_effect = (RAVEnConnectionError, NETWORK_INFO)
+
+    states = hass.states.async_all()
+    assert len(states) == 5
+    assert all(state.state != STATE_UNAVAILABLE for state in states)
+
+    freezer.tick(timedelta(seconds=60))
+    async_fire_time_changed(hass)
+    await hass.async_block_till_done()
+
+    states = hass.states.async_all()
+    assert len(states) == 5
+    assert all(state.state == STATE_UNAVAILABLE for state in states)
+
+    freezer.tick(timedelta(seconds=60))
+    async_fire_time_changed(hass)
+
+    states = hass.states.async_all()
+    assert len(states) == 5
+    assert all(state.state != STATE_UNAVAILABLE for state in states)
+
+
+@pytest.mark.usefixtures("mock_entry")
+async def test_device_update_timeout(
+    hass: HomeAssistant, mock_device: AsyncMock, freezer: FrozenDateTimeFactory
+) -> None:
+    """Test handling of a device timeout during an update."""
+    mock_device.get_network_info.side_effect = (TimeoutError, NETWORK_INFO)
+
+    states = hass.states.async_all()
+    assert len(states) == 5
+    assert all(state.state != STATE_UNAVAILABLE for state in states)
+
+    freezer.tick(timedelta(seconds=60))
+    async_fire_time_changed(hass)
+    await hass.async_block_till_done()
+
+    states = hass.states.async_all()
+    assert len(states) == 5
+    assert all(state.state == STATE_UNAVAILABLE for state in states)
+
+    freezer.tick(timedelta(seconds=60))
+    async_fire_time_changed(hass)
+
+    states = hass.states.async_all()
+    assert len(states) == 5
+    assert all(state.state != STATE_UNAVAILABLE for state in states)
+
+
+@pytest.mark.usefixtures("mock_entry")
+async def test_device_cache(
+    hass: HomeAssistant, mock_device: AsyncMock, freezer: FrozenDateTimeFactory
+) -> None:
+    """Test that the device isn't re-opened for subsequent refreshes."""
+    assert mock_device.get_network_info.call_count == 1
+    assert mock_device.open.call_count == 1
+
+    freezer.tick(timedelta(seconds=60))
+    async_fire_time_changed(hass)
+    await hass.async_block_till_done()
+
+    assert mock_device.get_network_info.call_count == 2
+    assert mock_device.open.call_count == 1