Use explicit assertions following Python idioms (#2013)

Apply feedback from #1916

Author: iMicknl

tests/conftest.py

@@ -0,0 +1,31 @@
+"""Shared pytest fixtures for the test suite."""
+
+from __future__ import annotations
+
+import pytest_asyncio
+
+from pyoverkiz.auth.credentials import (
+    LocalTokenCredentials,
+    UsernamePasswordCredentials,
+)
+from pyoverkiz.client import OverkizClient
+from pyoverkiz.enums import Server
+from pyoverkiz.utils import create_local_server_config
+
+
+@pytest_asyncio.fixture
+async def client() -> OverkizClient:
+    """Fixture providing an OverkizClient configured for the cloud server."""
+    return OverkizClient(
+        server=Server.SOMFY_EUROPE,
+        credentials=UsernamePasswordCredentials("username", "password"),
+    )
+
+
+@pytest_asyncio.fixture
+async def local_client() -> OverkizClient:
+    """Fixture providing an OverkizClient configured for a local (developer) server."""
+    return OverkizClient(
+        server=create_local_server_config(host="gateway-1234-5678-1243.local:8443"),
+        credentials=LocalTokenCredentials(token="token"),  # noqa: S106
+    )

tests/helpers.py

@@ -0,0 +1,31 @@
+"""Shared test helpers for the test suite."""
+
+from __future__ import annotations
+
+import json
+from typing import Any, Self
+
+
+class MockResponse:
+    """Simple stand-in for aiohttp responses used in tests."""
+
+    def __init__(self, text: str, status: int = 200, url: str = "") -> None:
+        """Create a mock response with text payload and optional status/url."""
+        self._text = text
+        self.status = status
+        self.url = url
+
+    async def text(self) -> str:
+        """Return text payload asynchronously."""
+        return self._text
+
+    async def json(self, content_type: str | None = None) -> Any:
+        """Return parsed JSON payload asynchronously."""
+        return json.loads(self._text)
+
+    async def __aexit__(self, exc_type, exc, tb) -> None:
+        """Context manager exit (noop)."""
+
+    async def __aenter__(self) -> Self:
+        """Context manager enter returning self."""
+        return self

tests/test_client.py

@@ -1,8 +1,5 @@
 """Unit tests for the high-level OverkizClient behaviour and responses."""
 
-# ruff: noqa: S106
-# S106: Test credentials use dummy values.
-
 from __future__ import annotations
 
 import json
@@ -11,21 +8,15 @@
 
 import aiohttp
 import pytest
-from pytest_asyncio import fixture
 
 from pyoverkiz import exceptions
-from pyoverkiz.auth.credentials import (
-    LocalTokenCredentials,
-    UsernamePasswordCredentials,
-)
 from pyoverkiz.client import OverkizClient
 from pyoverkiz.enums import (
     APIType,
     DataType,
     ExecutionState,
     ExecutionSubType,
     ExecutionType,
-    Server,
 )
 from pyoverkiz.models import (
     Action,
@@ -37,30 +28,14 @@
     State,
 )
 from pyoverkiz.response_handler import check_response
-from pyoverkiz.utils import create_local_server_config
+from tests.helpers import MockResponse
 
 CURRENT_DIR = Path(__file__).resolve().parent
 
 
 class TestOverkizClient:
     """Tests for the public OverkizClient behaviour (API type, devices, events, setup and diagnostics)."""
 
-    @fixture
-    async def client(self):
-        """Fixture providing an OverkizClient configured for the cloud server."""
-        return OverkizClient(
-            server=Server.SOMFY_EUROPE,
-            credentials=UsernamePasswordCredentials("username", "password"),
-        )
-
-    @fixture
-    async def local_client(self):
-        """Fixture providing an OverkizClient configured for a local (developer) server."""
-        return OverkizClient(
-            server=create_local_server_config(host="gateway-1234-5678-1243.local:8443"),
-            credentials=LocalTokenCredentials(token="token"),
-        )
-
     @pytest.mark.asyncio
     async def test_get_api_type_cloud(self, client: OverkizClient):
         """Verify that a cloud-configured client reports APIType.CLOUD."""
@@ -289,9 +264,9 @@ async def test_get_setup(
                 assert setup.id is None
 
             for device in setup.devices:
-                assert device.identifier.gateway_id
-                assert device.identifier.device_address
-                assert device.identifier.protocol
+                assert device.identifier.gateway_id is not None
+                assert device.identifier.device_address is not None
+                assert device.identifier.protocol is not None
 
     @pytest.mark.parametrize(
         "fixture_name",
@@ -765,16 +740,16 @@ async def test_get_action_groups(
             assert len(action_groups) == scenario_count
 
             for action_group in action_groups:
-                assert action_group.oid
+                assert action_group.oid is not None
                 assert action_group.label is not None
                 assert action_group.actions
 
                 for action in action_group.actions:
-                    assert action.device_url
+                    assert action.device_url is not None
                     assert action.commands
 
                     for command in action.commands:
-                        assert command.name
+                        assert command.name is not None
 
     @pytest.mark.asyncio
     async def test_get_current_execution_returns_execution(self, client: OverkizClient):
@@ -1141,29 +1116,3 @@ async def test_local_schedule_persisted_action_group_unknown_object(
             await local_client.schedule_persisted_action_group(
                 "00000000-0000-0000-0000-000000000000", 9999999999
             )
-
-
-class MockResponse:
-    """Simple stand-in for aiohttp responses used in tests."""
-
-    def __init__(self, text, status=200, url=""):
-        """Create a mock response with text payload and optional status/url."""
-        self._text = text
-        self.status = status
-        self.url = url
-
-    async def text(self):
-        """Return text payload asynchronously."""
-        return self._text
-
-    # pylint: disable=unused-argument
-    async def json(self, content_type=None):
-        """Return parsed JSON payload asynchronously."""
-        return json.loads(self._text)
-
-    async def __aexit__(self, exc_type, exc, tb):
-        """Context manager exit (noop)."""
-
-    async def __aenter__(self):
-        """Context manager enter returning self."""
-        return self

tests/test_models.py

@@ -249,7 +249,7 @@ def test_none_states(self):
         raw = dict(RAW_DEVICES)
         del raw["states"]
         device = _make_device(raw)
-        assert not device.states.get(STATE)
+        assert device.states.get(STATE) is None
 
     def test_select_first_command(self):
         """Device.select_first_command() returns first supported command from list."""
@@ -379,19 +379,19 @@ def test_empty_states(self):
         """An empty list yields an empty States object with no state found."""
         states = self._make_states([])
         assert not states
-        assert not states.get(STATE)
+        assert states.get(STATE) is None
 
     def test_none_states(self):
         """A None value for states should behave as empty."""
         states = self._make_states(None)
         assert not states
-        assert not states.get(STATE)
+        assert states.get(STATE) is None
 
     def test_getter(self):
         """Retrieve a known state and validate its properties."""
         states = self._make_states(RAW_STATES)
         state = states.get(STATE)
-        assert state
+        assert state is not None
         assert state.name == STATE
         assert state.type == DataType.STRING
         assert state.value == "alarm name"
@@ -400,7 +400,7 @@ def test_getter_missing(self):
         """Requesting a missing state returns falsy (None)."""
         states = self._make_states(RAW_STATES)
         state = states.get("FooState")
-        assert not state
+        assert state is None
 
     def test_select_returns_first_match(self):
         """select() returns the first state with a non-None value."""
@@ -627,7 +627,7 @@ def test_bad_int_value(self):
         """Accessor raises TypeError if the state type mismatches expected int."""
         state = State(name="state", type=DataType.BOOLEAN, value=False)
         with pytest.raises(TypeError):
-            assert state.value_as_int
+            _ = state.value_as_int
 
     def test_float_value(self):
         """Float typed state returns proper float accessor."""
@@ -638,7 +638,7 @@ def test_bad_float_value(self):
         """Accessor raises TypeError if the state type mismatches expected float."""
         state = State(name="state", type=DataType.BOOLEAN, value=False)
         with pytest.raises(TypeError):
-            assert state.value_as_float
+            _ = state.value_as_float
 
     def test_bool_value(self):
         """Boolean typed state returns proper boolean accessor."""
@@ -649,7 +649,7 @@ def test_bad_bool_value(self):
         """Accessor raises TypeError if the state type mismatches expected bool."""
         state = State(name="state", type=DataType.INTEGER, value=1)
         with pytest.raises(TypeError):
-            assert state.value_as_bool
+            _ = state.value_as_bool
 
     def test_str_value(self):
         """String typed state returns proper string accessor."""
@@ -660,7 +660,7 @@ def test_bad_str_value(self):
         """Accessor raises TypeError if the state type mismatches expected string."""
         state = State(name="state", type=DataType.BOOLEAN, value=False)
         with pytest.raises(TypeError):
-            assert state.value_as_str
+            _ = state.value_as_str
 
     def test_dict_value(self):
         """JSON object typed state returns proper dict accessor."""
@@ -671,7 +671,7 @@ def test_bad_dict_value(self):
         """Accessor raises TypeError if the state type mismatches expected dict."""
         state = State(name="state", type=DataType.BOOLEAN, value=False)
         with pytest.raises(TypeError):
-            assert state.value_as_dict
+            _ = state.value_as_dict
 
     def test_list_value(self):
         """JSON array typed state returns proper list accessor."""
@@ -682,7 +682,7 @@ def test_bad_list_value(self):
         """Accessor raises TypeError if the state type mismatches expected list."""
         state = State(name="state", type=DataType.BOOLEAN, value=False)
         with pytest.raises(TypeError):
-            assert state.value_as_list
+            _ = state.value_as_list
 
 
 class TestEventState:

tests/test_utils.py

@@ -15,7 +15,7 @@ def test_create_local_server_config(self):
         """Create a local server descriptor using the host and default values."""
         local_server = create_local_server_config(host=LOCAL_HOST)
 
-        assert local_server
+        assert local_server is not None
         assert (
             local_server.endpoint
             == "https://gateway-1234-5678-1243.local:8443/enduser-mobile-web/1/enduserAPI/"
@@ -33,7 +33,7 @@ def test_create_local_server_config_by_ip(self):
             configuration_url="https://somfy.com",
         )
 
-        assert local_server
+        assert local_server is not None
         assert (
             local_server.endpoint
             == "https://192.168.1.105:8443/enduser-mobile-web/1/enduserAPI/"