test: Name the core tests that the collection filter never matched

core matches python_functions = test_it_*, so a test named anything else is
not skipped or reported, it simply never exists. Forty six had accumulated
that way, including every test of the Gen1 auth path, of the legacy HTTP
client's auth handling, and of the EM component accessors. They now carry
the name the convention asks for, and run.

Two had drifted while nothing ran them: the legacy gateway gained a timeout
argument its caller now passes, and an expired entry count had been written
for one entry in a case that expires two, which the same test's own later
assertions already said.

Author: jfmlima

packages/core/tests/unit/domain/entities/test_device_status.py

@@ -559,7 +559,7 @@ def test_it_creates_zigbee_component_from_status_only(self):
 class TestDeviceStatusEMComponents:
     """Test EM component support and total_power calculation."""
 
-    def test_total_power_with_em_only(self):
+    def test_it_totals_power_with_em_only(self):
         """Pro 3EM device with no switches -- total_power should come from EM."""
         em_comp = EMComponent(
             key="em:0",
@@ -576,7 +576,7 @@ def test_total_power_with_em_only(self):
         assert summary["total_power"] == 312.278
         assert summary["switch_count"] == 0
 
-    def test_total_power_with_em1_only(self):
+    def test_it_totals_power_with_em1_only(self):
         """Pro EM device with multiple EM1 channels and no switches."""
         em1_a = EM1Component(key="em1:0", component_type="em1", act_power=951.2)
         em1_b = EM1Component(key="em1:1", component_type="em1", act_power=200.5)
@@ -589,7 +589,7 @@ def test_total_power_with_em1_only(self):
         assert summary["total_power"] == pytest.approx(1151.7)
         assert summary["switch_count"] == 0
 
-    def test_total_power_with_switches_and_em(self):
+    def test_it_totals_power_with_switches_and_em(self):
         """Mixed device with both switches and EM components."""
         switch_comp = SwitchComponent(
             key="switch:0", component_type="switch", output=True, power=100.0
@@ -604,7 +604,7 @@ def test_total_power_with_switches_and_em(self):
         assert summary["total_power"] == pytest.approx(412.278)
         assert summary["switch_count"] == 1
 
-    def test_total_power_with_switches_only(self):
+    def test_it_totals_power_with_switches_only(self):
         """Backward compatibility: switch-only devices still work."""
         switch_a = SwitchComponent(
             key="switch:0", component_type="switch", output=True, power=50.0
@@ -621,14 +621,14 @@ def test_total_power_with_switches_only(self):
         assert summary["total_power"] == 50.0
         assert summary["switch_count"] == 2
 
-    def test_total_power_with_no_power_components(self):
+    def test_it_totals_power_with_no_power_components(self):
         """Pure sensor device with no power-producing components."""
         device_status = DeviceStatus(device_ip="192.168.1.100", components=[])
 
         summary = device_status.get_device_summary()
         assert summary["total_power"] == 0
 
-    def test_total_power_with_null_em_power(self):
+    def test_it_totals_power_with_null_em_power(self):
         """EM component with None total_act_power should not break sum."""
         em_comp = EMComponent(key="em:0", component_type="em", total_act_power=None)
         switch_comp = SwitchComponent(
@@ -642,7 +642,7 @@ def test_total_power_with_null_em_power(self):
         summary = device_status.get_device_summary()
         assert summary["total_power"] == 100.0
 
-    def test_total_power_with_null_em1_power(self):
+    def test_it_totals_power_with_null_em1_power(self):
         """EM1 component with None act_power should not break sum."""
         em1_comp = EM1Component(key="em1:0", component_type="em1", act_power=None)
 
@@ -651,7 +651,7 @@ def test_total_power_with_null_em1_power(self):
         summary = device_status.get_device_summary()
         assert summary["total_power"] == 0
 
-    def test_get_em_components(self):
+    def test_it_gets_em_components(self):
         em_comp = EMComponent(key="em:0", component_type="em", total_act_power=312.0)
         switch_comp = SwitchComponent(
             key="switch:0", component_type="switch", output=True, power=50.0
@@ -665,7 +665,7 @@ def test_get_em_components(self):
         assert len(em_components) == 1
         assert em_components[0].total_act_power == 312.0
 
-    def test_get_em1_components(self):
+    def test_it_gets_em1_components(self):
         em1_a = EM1Component(key="em1:0", component_type="em1", act_power=951.2)
         em1_b = EM1Component(key="em1:1", component_type="em1", act_power=200.5)
 
@@ -676,7 +676,7 @@ def test_get_em1_components(self):
         em1_components = device_status.get_em1_components()
         assert len(em1_components) == 2
 
-    def test_get_em_data_components(self):
+    def test_it_gets_em_data_components(self):
         emdata_comp = EMDataComponent(
             key="emdata:0", component_type="emdata", total_act=344297.48
         )
@@ -689,7 +689,7 @@ def test_get_em_data_components(self):
         assert len(em_data) == 1
         assert em_data[0].total_act == 344297.48
 
-    def test_get_em1_data_components(self):
+    def test_it_gets_em1_data_components(self):
         em1data_comp = EM1DataComponent(
             key="em1data:0", component_type="em1data", total_act_energy=12345.67
         )
@@ -702,7 +702,7 @@ def test_get_em1_data_components(self):
         assert len(em1_data) == 1
         assert em1_data[0].total_act_energy == 12345.67
 
-    def test_em_components_created_from_raw_response(self):
+    def test_it_creates_em_components_from_a_raw_response(self):
         """Test that EM components are properly created from raw API response."""
         device_ip = "192.168.1.100"
         response_data = {

packages/core/tests/unit/domain/value_objects/test_action_name.py

@@ -184,7 +184,7 @@ def test_it_still_honours_a_namespace_the_component_owns(
     ):
         assert ActionName.of(action).resolve(component_key, self.METHODS) == expected
 
-    def test_a_bare_method_still_searches_the_components_namespaces(self):
+    def test_it_searches_the_components_namespaces_for_a_bare_method(self):
         assert ActionName.of("FactoryReset").resolve("sys", self.METHODS) == (
             "Shelly.FactoryReset"
         )
@@ -197,7 +197,7 @@ def test_it_keeps_an_owned_qualified_action_working_without_a_method_list(self):
     def test_it_refuses_an_unowned_qualified_action_without_a_method_list(self):
         assert ActionName.of("Shelly.FactoryReset").resolve("wifi", []) is None
 
-    def test_a_bare_method_still_works_without_a_method_list(self):
+    def test_it_resolves_a_bare_method_without_a_method_list(self):
         assert ActionName.of("SetConfig").resolve("wifi", []) == "Wifi.SetConfig"
 
 
@@ -212,12 +212,12 @@ def test_it_splits_only_at_the_first_dot(self):
         assert action.namespace == "BLE"
         assert action.method == "CloudRelay.List"
 
-    def test_a_listed_name_pasted_back_still_resolves(self):
+    def test_it_resolves_a_listed_name_pasted_back(self):
         action = ActionName.of("BLE.CloudRelay.List")
 
         assert action.resolve("ble", self.METHODS) == "BLE.CloudRelay.List"
 
-    def test_dropping_the_leading_namespace_reads_as_another_one_and_is_refused(self):
+    def test_it_refuses_a_name_whose_leading_namespace_was_dropped(self):
         action = ActionName.of("CloudRelay.List")
 
         assert action.namespace == "CloudRelay"

packages/core/tests/unit/domain/value_objects/test_component_namespace.py

@@ -145,19 +145,19 @@ def test_it_returns_nothing_when_the_device_reported_nothing(self):
 
 
 class TestOwnershipIsNotALoosePrefix:
-    def test_zigbee_owns_its_named_shelly_method_and_nothing_else_under_shelly(self):
+    def test_it_gives_zigbee_its_named_shelly_method_and_nothing_else(self):
         namespace = ComponentNamespace.for_component_type("zigbee")
 
         assert namespace.owns("Shelly.ZigbeeClear") is True
         assert namespace.owns("Shelly.ZigbeeAnything") is False
         assert namespace.owns("Shelly.FactoryReset") is False
 
-    def test_an_exact_entry_still_matches_the_device_casing(self):
+    def test_it_matches_the_device_casing_from_an_exact_entry(self):
         namespace = ComponentNamespace.for_component_type("zigbee")
 
         assert namespace.actions_in(["shelly.zigbeeclear"]) == ["shelly.zigbeeclear"]
 
-    def test_a_namespace_prefix_entry_still_matches_a_whole_family(self):
+    def test_it_matches_a_whole_family_from_a_namespace_prefix_entry(self):
         namespace = ComponentNamespace.for_component_type("zigbee")
 
         assert namespace.actions_in(["Zigbee.GetStatus", "Zigbee.SetConfig"]) == [

packages/core/tests/unit/gateways/device/test_legacy_component_mapper.py

@@ -94,7 +94,7 @@ def test_it_treats_garbage_auto_timer_as_disabled(self, mapper):
 
 
 class TestSwitchComponentAcceptsMappedGen1Relay:
-    def test_switch_component_accepts_mapped_relay_with_timer(self, mapper):
+    def test_it_accepts_a_mapped_relay_with_a_timer(self, mapper):
         components = mapper.map(
             {"mac": "AABBCCDDEEFF", "type": "SHSW-1"},
             {"relays": [{"ison": True}]},
@@ -110,7 +110,7 @@ def test_switch_component_accepts_mapped_relay_with_timer(self, mapper):
         assert component.config["auto_off_delay"] == 0.5
         assert component.config["auto_on_delay"] == 30.0
 
-    def test_raw_numeric_seconds_still_raise_at_the_component(self):
+    def test_it_still_raises_at_the_component_on_raw_numeric_seconds(self):
         # The component stays strict on purpose; only the mapper heals raw seconds.
         with pytest.raises(ValidationError):
             SwitchComponent.from_raw_data(

packages/core/tests/unit/gateways/device/test_legacy_device_gateway_auth.py

@@ -69,15 +69,17 @@ def sample_credential(self):
 
     # --- _ensure_mac ---
 
-    async def test_ensure_mac_fetches_from_shelly(self, gateway, mock_http_client):
+    async def test_it_fetches_the_mac_from_shelly(self, gateway, mock_http_client):
         mock_http_client.fetch_json.return_value = {"mac": "AA:BB:CC:DD:EE:FF"}
 
         mac = await gateway._ensure_mac("192.168.1.100")
 
         assert mac == "AABBCCDDEEFF"
-        mock_http_client.fetch_json.assert_called_once_with("192.168.1.100", "shelly")
+        mock_http_client.fetch_json.assert_called_once_with(
+            "192.168.1.100", "shelly", timeout=None
+        )
 
-    async def test_ensure_mac_caches_result(self, gateway, mock_http_client):
+    async def test_it_caches_the_mac_it_fetched(self, gateway, mock_http_client):
         mock_http_client.fetch_json.return_value = {"mac": "AABBCCDDEEFF"}
 
         await gateway._ensure_mac("192.168.1.100")
@@ -86,14 +88,16 @@ async def test_ensure_mac_caches_result(self, gateway, mock_http_client):
         assert mac == "AABBCCDDEEFF"
         assert mock_http_client.fetch_json.call_count == 1
 
-    async def test_ensure_mac_returns_none_on_failure(self, gateway, mock_http_client):
+    async def test_it_has_no_mac_when_the_fetch_fails(self, gateway, mock_http_client):
         mock_http_client.fetch_json.side_effect = Exception("timeout")
 
         mac = await gateway._ensure_mac("192.168.1.100")
 
         assert mac is None
 
-    async def test_ensure_mac_returns_none_when_no_mac(self, gateway, mock_http_client):
+    async def test_it_has_no_mac_when_the_device_reports_none(
+        self, gateway, mock_http_client
+    ):
         mock_http_client.fetch_json.return_value = {"type": "SHSW-1"}
 
         mac = await gateway._ensure_mac("192.168.1.100")
@@ -102,7 +106,7 @@ async def test_ensure_mac_returns_none_when_no_mac(self, gateway, mock_http_clie
 
     # --- _resolve_auth ---
 
-    async def test_resolve_auth_returns_credentials(
+    async def test_it_resolves_credentials(
         self, gateway, mock_http_client, mock_auth_service, sample_credential
     ):
         mock_http_client.fetch_json.return_value = {"mac": "AABBCCDDEEFF"}
@@ -113,7 +117,7 @@ async def test_resolve_auth_returns_credentials(
         assert auth == ("admin", "secret")
         mock_auth_service.resolve_credentials.assert_called_once_with("AABBCCDDEEFF")
 
-    async def test_resolve_auth_caches_credentials(
+    async def test_it_caches_resolved_credentials(
         self, gateway, mock_http_client, mock_auth_service, sample_credential
     ):
         mock_http_client.fetch_json.return_value = {"mac": "AABBCCDDEEFF"}
@@ -125,14 +129,14 @@ async def test_resolve_auth_caches_credentials(
         assert auth == ("admin", "secret")
         assert mock_auth_service.resolve_credentials.call_count == 1
 
-    async def test_resolve_auth_returns_none_without_service(
+    async def test_it_resolves_nothing_without_an_authentication_service(
         self, gateway_no_auth, mock_http_client
     ):
         auth = await gateway_no_auth._resolve_auth("192.168.1.100")
 
         assert auth is None
 
-    async def test_resolve_auth_returns_none_when_no_credential(
+    async def test_it_resolves_nothing_when_no_credential_is_stored(
         self, gateway, mock_http_client, mock_auth_service
     ):
         mock_http_client.fetch_json.return_value = {"mac": "AABBCCDDEEFF"}
@@ -144,7 +148,7 @@ async def test_resolve_auth_returns_none_when_no_credential(
 
     # --- discover_device with auth ---
 
-    async def test_discover_detects_auth_and_fetches_with_credentials(
+    async def test_it_detects_auth_and_discovers_with_credentials(
         self,
         gateway,
         mock_http_client,
@@ -169,7 +173,7 @@ async def test_discover_detects_auth_and_fetches_with_credentials(
         for call in mock_http_client.fetch_json_optional.call_args_list:
             assert call[1].get("auth") == ("admin", "secret")
 
-    async def test_discover_no_auth_when_not_required(
+    async def test_it_discovers_without_auth_when_it_is_not_required(
         self,
         gateway,
         mock_http_client,
@@ -192,7 +196,7 @@ async def test_discover_no_auth_when_not_required(
 
     # --- get_device_status with auth ---
 
-    async def test_get_device_status_uses_proactive_auth(
+    async def test_it_reads_status_with_proactive_auth(
         self,
         gateway,
         mock_http_client,
@@ -217,7 +221,7 @@ async def test_get_device_status_uses_proactive_auth(
         status_call = mock_http_client.fetch_json.call_args_list[1]
         assert status_call[1].get("auth") == ("admin", "secret")
 
-    async def test_get_device_status_raises_on_auth_failure(
+    async def test_it_raises_on_auth_failure_while_reading_status(
         self,
         gateway,
         mock_http_client,
@@ -236,7 +240,7 @@ async def test_get_device_status_raises_on_auth_failure(
 
     # --- execute_action with auth ---
 
-    async def test_execute_action_sends_auth(
+    async def test_it_sends_auth_with_an_action(
         self,
         gateway,
         mock_http_client,
@@ -255,7 +259,7 @@ async def test_execute_action_sends_auth(
         call_kwargs = mock_http_client.get_with_params.call_args[1]
         assert call_kwargs.get("auth") == ("admin", "secret")
 
-    async def test_execute_action_no_auth_without_service(
+    async def test_it_sends_no_auth_with_an_action_without_a_service(
         self, gateway_no_auth, mock_http_client
     ):
         mock_http_client.get_with_params.return_value = {"ison": True}
@@ -270,13 +274,13 @@ async def test_execute_action_no_auth_without_service(
 
     # --- invalidate_credential_cache ---
 
-    async def test_invalidate_credential_cache(self, gateway):
+    async def test_it_invalidates_the_credential_cache(self, gateway):
         gateway._basic_auth_cache["AABBCCDDEEFF"] = ("admin", "old_pass")
 
         gateway.invalidate_credential_cache("AA:BB:CC:DD:EE:FF")
 
         assert "AABBCCDDEEFF" not in gateway._basic_auth_cache
 
-    async def test_invalidate_credential_cache_noop_for_unknown(self, gateway):
+    async def test_it_invalidates_nothing_for_an_unknown_device(self, gateway):
         # Should not raise
         gateway.invalidate_credential_cache("FFFFFFFFFFFF")

packages/core/tests/unit/gateways/network/test_legacy_http_client_auth.py

@@ -24,7 +24,7 @@ def _mock_ok_response(self, data: dict) -> MagicMock:
         resp.json.return_value = data
         return resp
 
-    async def test_fetch_json_passes_auth_to_session(self, client, mock_session):
+    async def test_it_passes_auth_to_the_session(self, client, mock_session):
         mock_session.get.return_value = self._mock_ok_response({"ok": True})
 
         result = await client.fetch_json(
@@ -35,15 +35,15 @@ async def test_fetch_json_passes_auth_to_session(self, client, mock_session):
         call_kwargs = mock_session.get.call_args[1]
         assert call_kwargs["auth"] == ("admin", "secret")
 
-    async def test_fetch_json_passes_none_auth_by_default(self, client, mock_session):
+    async def test_it_passes_no_auth_by_default(self, client, mock_session):
         mock_session.get.return_value = self._mock_ok_response({"ok": True})
 
         await client.fetch_json("192.168.1.1", "status")
 
         call_kwargs = mock_session.get.call_args[1]
         assert call_kwargs["auth"] is None
 
-    async def test_fetch_json_optional_passes_auth(self, client, mock_session):
+    async def test_it_passes_auth_on_an_optional_fetch(self, client, mock_session):
         mock_session.get.return_value = self._mock_ok_response({"ok": True})
 
         result = await client.fetch_json_optional(
@@ -54,7 +54,7 @@ async def test_fetch_json_optional_passes_auth(self, client, mock_session):
         call_kwargs = mock_session.get.call_args[1]
         assert call_kwargs["auth"] == ("admin", "pw")
 
-    async def test_get_with_params_passes_auth(self, client, mock_session):
+    async def test_it_passes_auth_with_params(self, client, mock_session):
         mock_session.get.return_value = self._mock_ok_response({"ison": True})
 
         result = await client.get_with_params(
@@ -65,7 +65,7 @@ async def test_get_with_params_passes_auth(self, client, mock_session):
         call_kwargs = mock_session.get.call_args[1]
         assert call_kwargs["auth"] == ("admin", "pass")
 
-    async def test_get_with_params_none_auth_by_default(self, client, mock_session):
+    async def test_it_passes_no_auth_with_params_by_default(self, client, mock_session):
         mock_session.get.return_value = self._mock_ok_response({"ison": True})
 
         await client.get_with_params("192.168.1.1", "relay/0", {"turn": "on"})