Fixup tests

Author: llucax

tests/component/test_base.py

@@ -37,6 +37,7 @@ def test_creation() -> None:
         (None, "CID1<_FakeComponent>"),
         ("test-component", "CID1<_FakeComponent>:test-component"),
     ],
+    ids=["no-name", "with-name"],
 )
 def test_str(name: str | None, expected_str: str) -> None:
     """Test string representation of a component."""
@@ -114,8 +115,8 @@ def test_default_values() -> None:
     assert component.category_specific_metadata == {}
 
 
-@pytest.mark.parametrize("status", list(ComponentStatus))
-@pytest.mark.parametrize("lifetime_active", [True, False])
+@pytest.mark.parametrize("status", list(ComponentStatus), ids=lambda s: s.name)
+@pytest.mark.parametrize("lifetime_active", [True, False], ids=["active", "inactive"])
 def test_active_at(
     status: ComponentStatus, lifetime_active: bool, caplog: pytest.LogCaptureFixture
 ) -> None:
@@ -252,28 +253,19 @@ def test_active() -> None:
     category_specific_metadata=COMPONENT.category_specific_metadata,
 )
 
-ALL_COMPONENTS = [
-    COMPONENT,
-    DIFFERENT_NONHASHABLE,
-    DIFFERENT_STATUS,
-    DIFFERENT_NAME,
-    DIFFERENT_ID,
-    DIFFERENT_MICROGRID_ID,
-    DIFFERENT_BOTH_ID,
-]
-
 
 @pytest.mark.parametrize(
     "comp,expected",
     [
-        (COMPONENT, True),
-        (DIFFERENT_NONHASHABLE, False),
-        (DIFFERENT_STATUS, False),
-        (DIFFERENT_NAME, False),
-        (DIFFERENT_ID, False),
-        (DIFFERENT_MICROGRID_ID, False),
-        (DIFFERENT_BOTH_ID, False),
+        pytest.param(COMPONENT, True, id="self"),
+        pytest.param(DIFFERENT_NONHASHABLE, False, id="other-nonhashable"),
+        pytest.param(DIFFERENT_STATUS, False, id="other-status"),
+        pytest.param(DIFFERENT_NAME, False, id="other-name"),
+        pytest.param(DIFFERENT_ID, False, id="other-id"),
+        pytest.param(DIFFERENT_MICROGRID_ID, False, id="other-microgrid-id"),
+        pytest.param(DIFFERENT_BOTH_ID, False, id="other-both-ids"),
     ],
+    ids=lambda o: str(o.id) if isinstance(o, Component) else str(o),
 )
 def test_equality(comp: Component, expected: bool) -> None:
     """Test component equality."""
@@ -286,13 +278,13 @@ def test_equality(comp: Component, expected: bool) -> None:
 @pytest.mark.parametrize(
     "comp,expected",
     [
-        (COMPONENT, True),
-        (DIFFERENT_NONHASHABLE, True),
-        (DIFFERENT_STATUS, True),
-        (DIFFERENT_NAME, True),
-        (DIFFERENT_ID, False),
-        (DIFFERENT_MICROGRID_ID, False),
-        (DIFFERENT_BOTH_ID, False),
+        pytest.param(COMPONENT, True, id="self"),
+        pytest.param(DIFFERENT_NONHASHABLE, True, id="other-nonhashable"),
+        pytest.param(DIFFERENT_STATUS, True, id="other-status"),
+        pytest.param(DIFFERENT_NAME, True, id="other-name"),
+        pytest.param(DIFFERENT_ID, False, id="other-id"),
+        pytest.param(DIFFERENT_MICROGRID_ID, False, id="other-microgrid-id"),
+        pytest.param(DIFFERENT_BOTH_ID, False, id="other-both-ids"),
     ],
 )
 def test_identity(comp: Component, expected: bool) -> None:
@@ -301,8 +293,19 @@ def test_identity(comp: Component, expected: bool) -> None:
     assert comp.identity == (comp.id, comp.microgrid_id)
 
 
-@pytest.mark.parametrize("comp1", ALL_COMPONENTS)
-@pytest.mark.parametrize("comp2", ALL_COMPONENTS)
+ALL_COMPONENTS_PARAMS = [
+    pytest.param(COMPONENT, id="comp"),
+    pytest.param(DIFFERENT_NONHASHABLE, id="nonhashable"),
+    pytest.param(DIFFERENT_STATUS, id="status"),
+    pytest.param(DIFFERENT_NAME, id="name"),
+    pytest.param(DIFFERENT_ID, id="id"),
+    pytest.param(DIFFERENT_MICROGRID_ID, id="microgrid_id"),
+    pytest.param(DIFFERENT_BOTH_ID, id="both_ids"),
+]
+
+
+@pytest.mark.parametrize("comp1", ALL_COMPONENTS_PARAMS)
+@pytest.mark.parametrize("comp2", ALL_COMPONENTS_PARAMS)
 def test_hash(comp1: Component, comp2: Component) -> None:
     """Test that the hash is consistent."""
     # We can only say the hash are the same if the components are equal, if they

tests/component/test_connection.py

@@ -45,7 +45,7 @@ def test_validation() -> None:
         )
 
 
-@pytest.mark.parametrize("lifetime_active", [True, False])
+@pytest.mark.parametrize("lifetime_active", [True, False], ids=["active", "inactive"])
 def test_active_at(lifetime_active: bool) -> None:
     """Test active_at behavior with lifetime.active values."""
     mock_lifetime = Mock(spec=Lifetime)
@@ -66,6 +66,7 @@ def test_active_at(lifetime_active: bool) -> None:
 @pytest.mark.parametrize(
     "lifetime_active",
     [True, False],
+    ids=["active", "inactive"],
 )
 def test_active(lifetime_active: bool) -> None:
     """Test the active property of ComponentConnection."""
@@ -106,15 +107,15 @@ def test_str() -> None:
                 "destination_component_id": 2,
                 "has_lifetime": True,
             },
-            id="complete connection",
+            id="full",
         ),
         pytest.param(
             {
                 "source_component_id": 1,
                 "destination_component_id": 2,
                 "has_lifetime": False,
             },
-            id="missing lifetime",
+            id="no_lifetime",
         ),
     ],
 )

tests/metrics/test_bounds.py

@@ -81,28 +81,28 @@ def test_hash() -> None:
     "case",
     [
         ProtoConversionTestCase(
-            name="all fields present",
+            name="full",
             has_lower=True,
             has_upper=True,
             lower=-10.0,
             upper=10.0,
         ),
         ProtoConversionTestCase(
-            name="only lower bound",
+            name="no_upper_bound",
             has_lower=True,
             has_upper=False,
             lower=-10.0,
             upper=None,
         ),
         ProtoConversionTestCase(
-            name="only upper bound",
+            name="no_lower_bound",
             has_lower=False,
             has_upper=True,
             lower=None,
             upper=10.0,
         ),
         ProtoConversionTestCase(
-            name="no bounds",
+            name="no_both_bounds",
             has_lower=False,
             has_upper=False,
             lower=None,
@@ -116,9 +116,6 @@ def test_from_proto(case: ProtoConversionTestCase) -> None:
 
     Args:
         case: Test case parameters
-
-    Raises:
-        AssertionError: If the conversion doesn't match expected values
     """
     proto = bounds_pb2.Bounds()
     if case.has_lower and case.lower is not None:

tests/metrics/test_sample.py

@@ -230,26 +230,26 @@ def test_metric_sample_multiple_bounds(now: datetime) -> None:
     "case",
     [
         AggregatedValueTestCase(
-            name="complete data",
+            name="full",
             avg_value=5.0,
             min_value=1.0,
             max_value=10.0,
             raw_values=[1.0, 5.0, 10.0],
         ),
         AggregatedValueTestCase(
-            name="minimal data",
+            name="minimal",
             avg_value=5.0,
             has_min=False,
             has_max=False,
         ),
         AggregatedValueTestCase(
-            name="only min additional",
+            name="only_min",
             avg_value=5.0,
             has_max=False,
             min_value=1.0,
         ),
         AggregatedValueTestCase(
-            name="only max additional",
+            name="only_max",
             avg_value=5.0,
             has_min=False,
             max_value=10.0,
@@ -262,9 +262,6 @@ def test_aggregated_metric_value_from_proto(case: AggregatedValueTestCase) -> No
 
     Args:
         case: Test case parameters
-
-    Raises:
-        AssertionError: If the conversion doesn't match expected values
     """
     proto = metric_sample_pb2.AggregatedMetricValue(
         avg_value=case.avg_value,
@@ -288,28 +285,28 @@ def test_aggregated_metric_value_from_proto(case: AggregatedValueTestCase) -> No
     "case",
     [
         MetricSampleTestCase(
-            name="simple value",
+            name="simple_value",
             has_simple_value=True,
             has_aggregated_value=False,
             has_source=False,
             metric=Metric.AC_ACTIVE_POWER,
         ),
         MetricSampleTestCase(
-            name="aggregated value",
+            name="aggregated_value",
             has_simple_value=False,
             has_aggregated_value=True,
             has_source=True,
             metric=Metric.AC_ACTIVE_POWER,
         ),
         MetricSampleTestCase(
-            name="no value",
+            name="no_value",
             has_simple_value=False,
             has_aggregated_value=False,
             has_source=False,
             metric=Metric.AC_ACTIVE_POWER,
         ),
         MetricSampleTestCase(
-            name="unrecognized metric",
+            name="unrecognized_metric",
             has_simple_value=True,
             has_aggregated_value=False,
             has_source=False,
@@ -335,9 +332,6 @@ def test_metric_sample_from_proto(
         mock_enum_from_proto: Mock for enum conversion
         mock_bounds_from_proto: Mock for bounds conversion
         case: Test case parameters
-
-    Raises:
-        AssertionError: If the conversion doesn't match expected values
     """
     now = datetime.now(timezone.utc)
     mock_to_datetime.return_value = now

tests/test_delivery_area.py

@@ -56,31 +56,31 @@ class ProtoConversionTestCase:
     "case",
     [
         DeliveryAreaTestCase(
-            name="valid EIC code",
+            name="valid_EIC_code",
             code="10Y1001A1001A450",
             code_type=EnergyMarketCodeType.EUROPE_EIC,
             expected_str="10Y1001A1001A450[EUROPE_EIC]",
         ),
         DeliveryAreaTestCase(
-            name="valid NERC code",
+            name="valid_NERC_code",
             code="PJM",
             code_type=EnergyMarketCodeType.US_NERC,
             expected_str="PJM[US_NERC]",
         ),
         DeliveryAreaTestCase(
-            name="unspecified code type",
-            code="TEST",
-            code_type=EnergyMarketCodeType.UNSPECIFIED,
-            expected_str="TEST[UNSPECIFIED]",
-        ),
-        DeliveryAreaTestCase(
-            name="no code",
+            name="no_code",
             code=None,
             code_type=EnergyMarketCodeType.EUROPE_EIC,
             expected_str="<NO CODE>[EUROPE_EIC]",
         ),
         DeliveryAreaTestCase(
-            name="unknown code type",
+            name="unspecified_code_type",
+            code="TEST",
+            code_type=EnergyMarketCodeType.UNSPECIFIED,
+            expected_str="TEST[UNSPECIFIED]",
+        ),
+        DeliveryAreaTestCase(
+            name="unknown_code_type",
             code="TEST",
             code_type=999,
             expected_str="TEST[type=999]",
@@ -93,9 +93,6 @@ def test_creation(case: DeliveryAreaTestCase) -> None:
 
     Args:
         case: Test case parameters
-
-    Raises:
-        AssertionError: If any of the test assertions fail
     """
     area = DeliveryArea(code=case.code, code_type=case.code_type)
     assert area.code == case.code
@@ -107,39 +104,39 @@ def test_creation(case: DeliveryAreaTestCase) -> None:
     "case",
     [
         ProtoConversionTestCase(
-            name="valid EIC code",
+            name="valid_EIC_code",
             code="10Y1001A1001A450",
             code_type=delivery_area_pb2.EnergyMarketCodeType.ENERGY_MARKET_CODE_TYPE_EUROPE_EIC,
             expected_code="10Y1001A1001A450",
             expected_code_type=EnergyMarketCodeType.EUROPE_EIC,
             expect_warning=False,
         ),
         ProtoConversionTestCase(
-            name="valid NERC code",
+            name="valid_NERC_code",
             code="PJM",
             code_type=delivery_area_pb2.EnergyMarketCodeType.ENERGY_MARKET_CODE_TYPE_US_NERC,
             expected_code="PJM",
             expected_code_type=EnergyMarketCodeType.US_NERC,
             expect_warning=False,
         ),
         ProtoConversionTestCase(
-            name="no code",
+            name="no_code",
             code=None,
             code_type=delivery_area_pb2.EnergyMarketCodeType.ENERGY_MARKET_CODE_TYPE_EUROPE_EIC,
             expected_code=None,
             expected_code_type=EnergyMarketCodeType.EUROPE_EIC,
             expect_warning=True,
         ),
         ProtoConversionTestCase(
-            name="unspecified type",
+            name="unspecified_code_type",
             code="TEST",
             code_type=delivery_area_pb2.EnergyMarketCodeType.ENERGY_MARKET_CODE_TYPE_UNSPECIFIED,
             expected_code="TEST",
             expected_code_type=EnergyMarketCodeType.UNSPECIFIED,
             expect_warning=True,
         ),
         ProtoConversionTestCase(
-            name="unknown code type",
+            name="unknown_code_type",
             code="TEST",
             code_type=999,
             expected_code="TEST",
@@ -157,9 +154,6 @@ def test_from_proto(
     Args:
         caplog: Fixture to capture log messages
         case: Test case parameters
-
-    Raises:
-        AssertionError: If any of the test assertions fail
     """
     # We do the type-ignore here because we want to test the case of an
     # arbitrary int too.