pyg90alarm 2.3.0__tar.gz → 2.3.1__tar.gz

{pyg90alarm-2.3.0 → pyg90alarm-2.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyg90alarm
-Version: 2.3.0
+Version: 2.3.1
 Summary: G90 Alarm system protocol
 Home-page: https://github.com/hostcc/pyg90alarm
 Author: Ilia Sotnikov

{pyg90alarm-2.3.0 → pyg90alarm-2.3.1}/pyproject.toml

@@ -11,6 +11,7 @@ local_scheme = "no-local-version"
 log_cli = 1
 log_cli_level = "error"
 asyncio_mode = "auto"
+asyncio_default_fixture_loop_scope = "function"
 pythonpath = "src/"
 
 [tool.coverage.run]

{pyg90alarm-2.3.0 → pyg90alarm-2.3.1}/src/pyg90alarm/entities/base_list.py

@@ -68,7 +68,7 @@ class G90BaseList(Generic[T], ABC):
 
         :return: Async generator of entities
         """
-        yield cast(T, None)
+        yield cast(T, None)  # pragma: no cover
 
     @property
     async def entities(self) -> List[T]:
@@ -231,25 +231,30 @@ class G90BaseList(Generic[T], ABC):
         # Collect indexes in use by the existing entities
         occupied_indexes = set(x.index for x in entities)
         # Generate a set of possible indexes from 0 to the maximum index in
-        # use
-        possible_indexes = set(range(0, max(occupied_indexes)))
+        # use, or provide an empty set if there are no existing entities
+        if occupied_indexes:
+            possible_indexes = set(range(0, max(occupied_indexes)))
+        else:
+            # No occupied indexes, so possible_indexes is empty
+            possible_indexes = set()
 
         try:
             # Find the first free index by taking difference between
             # possible indexes and occupied ones, and then taking the minimum
             # value off the difference
             free_idx = min(
-                set(possible_indexes).difference(occupied_indexes)
+                possible_indexes.difference(occupied_indexes)
             )
-            _LOGGER.debug(
-                'Found free index: %s out of occupied indexes: %s',
-                free_idx, occupied_indexes
-            )
-            return free_idx
         except ValueError:
             # If no gaps in existing indexes, then return the index next to
             # the last existing entity
-            return len(entities)
+            free_idx = len(entities)
+
+        _LOGGER.debug(
+            'Found free index=%s out of occupied indexes: %s',
+            free_idx, occupied_indexes
+        )
+        return free_idx
 
     @property
     def list_change_callback(self) -> Optional[ListChangeCallback[T]]:

{pyg90alarm-2.3.0 → pyg90alarm-2.3.1}/src/pyg90alarm.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: pyg90alarm
-Version: 2.3.0
+Version: 2.3.1
 Summary: G90 Alarm system protocol
 Home-page: https://github.com/hostcc/pyg90alarm
 Author: Ilia Sotnikov

{pyg90alarm-2.3.0 → pyg90alarm-2.3.1}/src/pyg90alarm.egg-info/SOURCES.txt

@@ -74,4 +74,5 @@ tests/test_discovery.py
 tests/test_history.py
 tests/test_local_notifications.py
 tests/test_paginated_commands.py
-tests/test_sensor.py
+tests/test_sensor.py
+tests/unit/entities/test_base_list.py

pyg90alarm-2.3.1/tests/unit/entities/test_base_list.py

@@ -0,0 +1,192 @@
+"""
+Tests for G90BaseList class
+"""
+from __future__ import annotations
+from typing import AsyncGenerator
+from unittest.mock import MagicMock
+
+from pyg90alarm.entities.base_list import G90BaseList
+
+
+class TestBaseList(G90BaseList[MagicMock]):
+    """
+    Mock subclass for testing G90BaseList.
+    """
+
+    # Prevent pytest from collecting this class as a test case
+    __test__ = False
+
+    async def _fetch(self) -> AsyncGenerator[MagicMock, None]:
+        """Mock _fetch method."""
+        if False:  # pragma: no cover
+            yield MagicMock()
+
+
+async def test_find_free_idx_empty_list() -> None:
+    """
+    Tests find_free_idx with empty entities list.
+    """
+
+    parent = MagicMock()
+    base_list = TestBaseList(parent)
+    base_list._entities = []
+
+    result = await base_list.find_free_idx()
+
+    assert result == 0
+
+
+async def test_find_free_idx_one_entity_at_zero() -> None:
+    """
+    Tests find_free_idx with one entity at index 0.
+    """
+
+    base_list = TestBaseList(parent=MagicMock())
+    base_list._entities = [MagicMock(index=0)]
+
+    result = await base_list.find_free_idx()
+
+    assert result == 1
+
+
+async def test_find_free_idx_returns_lowest_available_index() -> None:
+    """
+    Tests find_free_idx with two entities at indexes 10 and 11.
+    """
+
+    base_list = TestBaseList(parent=MagicMock())
+    base_list._entities = [MagicMock(index=10), MagicMock(index=11)]
+
+    result = await base_list.find_free_idx()
+
+    assert result == 0
+
+
+async def test_find_free_idx_returns_lowest_available_index_over_gap() -> None:
+    """
+    Tests find_free_idx with two entities at indexes 10 and 11.
+    """
+
+    base_list = TestBaseList(parent=MagicMock())
+    base_list._entities = [
+        MagicMock(index=0), MagicMock(index=10), MagicMock(index=11)
+    ]
+
+    result = await base_list.find_free_idx()
+
+    assert result == 1
+
+
+async def test_find_entity_by_idx_and_name() -> None:
+    """
+    Tests find with matching index, subindex, and name.
+    """
+
+    base_list = TestBaseList(parent=MagicMock())
+    entity = MagicMock()
+    entity.index = 0
+    entity.subindex = 0
+    entity.name = "Test Entity"
+    entity.is_unavailable = False
+    base_list._entities = [entity]
+
+    result = await base_list.find(
+        idx=0, name="Test Entity", exclude_unavailable=False
+    )
+
+    assert result == entity
+
+
+async def test_find_entity_name_mismatch() -> None:
+    """
+    Tests find with matching index but mismatched name.
+    """
+
+    base_list = TestBaseList(parent=MagicMock())
+    entity = MagicMock()
+    entity.index = 0
+    entity.subindex = 0
+    entity.name = "Test Entity"
+    entity.is_unavailable = False
+    base_list._entities = [entity]
+
+    result = await base_list.find(
+        idx=0, name="Wrong Name", exclude_unavailable=False
+    )
+
+    assert result is None
+
+
+async def test_find_entity_not_found() -> None:
+    """
+    Tests find with non-existing index.
+    """
+
+    base_list = TestBaseList(parent=MagicMock())
+    base_list._entities = []
+
+    result = await base_list.find(
+        idx=0, name="Test Entity", exclude_unavailable=False
+    )
+
+    assert result is None
+
+
+async def test_find_entity_unavailable_excluded() -> None:
+    """
+    Tests find with unavailable entity and exclude_unavailable=True.
+    """
+
+    base_list = TestBaseList(parent=MagicMock())
+    entity = MagicMock()
+    entity.index = 0
+    entity.subindex = 0
+    entity.name = "Test Entity"
+    entity.is_unavailable = True
+    base_list._entities = [entity]
+
+    result = await base_list.find(
+        idx=0, name="Test Entity", exclude_unavailable=True
+    )
+
+    assert result is None
+
+
+async def test_find_entity_unavailable_not_excluded() -> None:
+    """
+    Tests find with unavailable entity and exclude_unavailable=False.
+    """
+
+    base_list = TestBaseList(parent=MagicMock())
+    entity = MagicMock()
+    entity.index = 0
+    entity.subindex = 0
+    entity.name = "Test Entity"
+    entity.is_unavailable = True
+    base_list._entities = [entity]
+
+    result = await base_list.find(
+        idx=0, name="Test Entity", exclude_unavailable=False
+    )
+
+    assert result == entity
+
+
+async def test_find_entity_with_subindex() -> None:
+    """
+    Tests find with specific subindex.
+    """
+
+    base_list = TestBaseList(parent=MagicMock())
+    entity = MagicMock()
+    entity.index = 0
+    entity.subindex = 1
+    entity.name = "Test Entity"
+    entity.is_unavailable = False
+    base_list._entities = [entity]
+
+    result = await base_list.find(
+        idx=0, name="Test Entity", exclude_unavailable=False, subindex=1
+    )
+
+    assert result == entity