cactus-test-definitions 1.8.0__py3-none-any.whl

tests/unit/client/test_checks.py

@@ -0,0 +1,71 @@
+import pytest
+from cactus_test_definitions import variable_expressions as varexps
+from cactus_test_definitions.client.checks import Check, validate_check_parameters
+from cactus_test_definitions.errors import TestProcedureDefinitionError
+
+
+@pytest.mark.parametrize(
+    "check, is_valid",
+    [
+        (Check("foo", {}), False),  # Unknown check
+        (Check("readings-site-active-power", {}), True),
+        (Check("readings-site-active-power", {"minimum_count": "3"}), False),
+        (Check("readings-site-active-power", {"minimum_count": 3}), True),
+        (Check("readings-site-active-power", {"minimum_count": 3, "minimum_level": 12.3}), True),
+        (Check("readings-site-active-power", {"minimum_count": 3, "maximum_level": 12.3}), True),
+        (Check("readings-site-active-power", {"minimum_count": 3, "minimum_level": 12.3, "maximum_level": 12.3}), True),
+        (
+            Check(
+                "readings-site-active-power",
+                {"minimum_count": 3, "minimum_level": 12.3, "maximum_level": 12.3, "window_seconds": 12.3},
+            ),
+            False,
+        ),
+        (
+            Check(
+                "readings-site-active-power",
+                {"minimum_count": 3, "minimum_level": 12.3, "maximum_level": 12.3, "window_seconds": 180},
+            ),
+            True,
+        ),
+        (
+            Check(
+                "readings-site-active-power",
+                {"minimum_count": 3, "minimum_level": 12.3, "maximum_level": 12.3, "window_seconds": -180},
+            ),
+            False,
+        ),
+        (Check("der-settings-contents", {"setGradW": 27}), True),
+        (Check("der-settings-contents", {"doeModesEnabled_set": "0f"}), True),
+        (Check("der-settings-contents", {"doeModesEnabled_unset": "0f"}), True),
+        (Check("der-settings-contents", {"modesEnabled_set": "E"}), True),
+        (Check("der-settings-contents", {"modesEnabled_unset": "E"}), True),
+        (Check("der-settings-contents", {"doeModesEnabled_set": 12}), False),
+        (Check("der-settings-contents", {"doeModesEnabled_unset": 12}), False),
+        # Storage extension
+        (Check("der-settings-contents", {"vppModesEnabled_set": "1"}), True),
+        (Check("der-settings-contents", {"vppModesEnabled_unset": "1"}), True),
+        (Check("der-capability-contents", {"vppModesSupported_set": "1"}), True),
+        (Check("der-capability-contents", {"vppModesSupported_unset": "1"}), True),
+        (Check("readings-der-stored-energy", {"minimum_count": 3}), True),
+    ],
+)
+def test_validate_check_parameters(check: Check, is_valid: bool):
+    if is_valid:
+        validate_check_parameters("foo", check)
+    else:
+        with pytest.raises(TestProcedureDefinitionError):
+            validate_check_parameters("foo", check)
+
+
+def test_check_expression() -> None:
+    """Tests the creation of a Check that has an expression as one of its parameters"""
+    type_str = "some_check"
+    params = {"setMaxW": "$(this < rtgMaxW)"}
+    check = Check(type_str, params)
+
+    check_set_max_w = check.parameters["setMaxW"]
+    assert isinstance(check_set_max_w, varexps.Expression)
+    assert check_set_max_w.operation == varexps.OperationType.LT
+    assert check_set_max_w.lhs_operand == varexps.NamedVariable(varexps.NamedVariableType.DERSETTING_SET_MAX_W)
+    assert check_set_max_w.rhs_operand == varexps.NamedVariable(varexps.NamedVariableType.DERCAPABILITY_RTG_MAX_W)

tests/unit/client/test_events.py

@@ -0,0 +1,36 @@
+import pytest
+from cactus_test_definitions import variable_expressions as varexps
+from cactus_test_definitions.client.events import Event, validate_event_parameters
+from cactus_test_definitions.errors import TestProcedureDefinitionError
+
+
+@pytest.mark.parametrize(
+    "event, is_valid",
+    [
+        (Event("foo", {}), False),  # Unknown check
+        (Event("wait", {}), False),
+        (Event("wait", {"duration_seconds": "3"}), False),
+        (Event("wait", {"duration_seconds": 3}), True),
+        (Event("wait", {"duration_seconds": 3, "other": 4}), False),
+        (Event("GET-request-received", {"endpoint": "/dcap"}), True),
+    ],
+)
+def test_validate_event_parameters(event: Event, is_valid: bool):
+    if is_valid:
+        validate_event_parameters("foo", "bar", event)
+    else:
+        with pytest.raises(TestProcedureDefinitionError):
+            validate_event_parameters("foo", "bar", event)
+
+
+def test_event_expression() -> None:
+    """Tests the creation of an Event that has an expression as one of its parameters"""
+    type_str = "some_event"
+    params = {"setMaxW": "$(this < rtgMaxW)"}
+    event = Event(type_str, params)
+
+    check_set_max_w = event.parameters["setMaxW"]
+    assert isinstance(check_set_max_w, varexps.Expression)
+    assert check_set_max_w.operation == varexps.OperationType.LT
+    assert check_set_max_w.lhs_operand == varexps.NamedVariable(varexps.NamedVariableType.DERSETTING_SET_MAX_W)
+    assert check_set_max_w.rhs_operand == varexps.NamedVariable(varexps.NamedVariableType.DERCAPABILITY_RTG_MAX_W)

tests/unit/client/test_test_procedures.py

@@ -0,0 +1,103 @@
+from datetime import datetime, timedelta, timezone
+from importlib import resources
+from pathlib import Path
+
+import pytest
+from assertical.asserts.type import assert_dict_type
+from cactus_test_definitions.client.test_procedures import (
+    TestProcedure,
+    TestProcedureId,
+    get_all_test_procedures,
+    parse_test_procedure,
+)
+from cactus_test_definitions.variable_expressions import (
+    Constant,
+    Expression,
+    NamedVariable,
+    NamedVariableType,
+    OperationType,
+)
+from dataclass_wizard.errors import UnknownKeysError
+
+
+def test_TestProcedureId_synchronised():
+    """Ensures that TestProcedureId is in sync with all available TestProcedures YAML files.
+
+    Each MY-TEST.yaml must have a corresponding TestProcedureId.MY_TEST"""
+
+    # Discover all the YAML files
+    suffix = ".yaml"
+    raw_file_names: set[str] = set()
+    for yaml_file in resources.files("cactus_test_definitions.client.procedures").iterdir():
+        if yaml_file.is_file() and yaml_file.name.endswith(suffix):
+            raw_file_names.add(yaml_file.name[: -len(suffix)])
+
+    # Compare them against the TestProcedureId
+    for file_name in raw_file_names:
+        assert file_name in TestProcedureId
+    for tp_id in TestProcedureId:
+        assert tp_id in raw_file_names
+    assert len(raw_file_names) == len(TestProcedureId)
+
+
+def test_available_tests_populated():
+    """Force test procedures to load and ensure they all validate (and we at least have a few)"""
+
+    all_tps = get_all_test_procedures()
+    assert_dict_type(TestProcedureId, TestProcedure, all_tps, count=len(TestProcedureId))
+    assert all_tps[TestProcedureId.ALL_01] != all_tps[TestProcedureId.ALL_02], "Sanity check on uniqueness"
+
+
+def test_error_on_duplicate_key():
+    """Force test procedures to load and ensure they all validate (and we at least have a few)"""
+
+    with open(Path("tests/data/client/tp_error_duplicate_keys.yaml"), "r") as fp:
+        yaml_contents = fp.read()
+
+    with pytest.raises(ValueError):
+        parse_test_procedure(yaml_contents)
+
+
+def test_error_on_extra_key():
+    """Force test procedures to load and ensure they all validate (and we at least have a few)"""
+
+    with open(Path("tests/data/client/tp_error_extra_keys.yaml"), "r") as fp:
+        yaml_contents = fp.read()
+
+    with pytest.raises(UnknownKeysError):
+        parse_test_procedure(yaml_contents)
+
+
+def test_TestProcedures_action_parameter_types():
+    """Tests that lists/dicts/constants/datetimes can all be encoded/decoded via the yaml action definition"""
+
+    with open(Path("tests/data/client/tp_action_parameters.yaml"), "r") as fp:
+        tp = parse_test_procedure(fp.read())
+
+    step = tp.steps["Step-1"]
+    action = step.actions[0]
+
+    assert action.parameters == {
+        "param_list_str": ["List Item 1", "List Item 2", "List Item 3"],
+        "param_list_int": [11, 22, 33],
+        "param_list_mixed": [
+            11,
+            2.2,
+            "List Item 3",
+            datetime(2020, 1, 2, 3, 4, 5, tzinfo=timezone.utc),
+        ],
+        "param_dict_str": {"key1": "value1", "key2": "value2"},
+        "param_dict_int": {"key11": 11, "key22": 22},
+        "param_int": 11,
+        "param_str": "Value 11",
+        "param_datetime_utc": datetime(2025, 1, 2, 3, 4, 5, tzinfo=timezone.utc),
+        "param_datetime_naive": datetime(2025, 1, 2, 3, 4, 5, tzinfo=None),
+        "param_with_variable_date": NamedVariable(NamedVariableType.NOW),
+        "param_with_variable_db_lookup": NamedVariable(NamedVariableType.DERSETTING_SET_MAX_W),
+        "param_with_variable_relative_db_lookup": Expression(
+            OperationType.MULTIPLY, Constant(0.25), NamedVariable(NamedVariableType.DERSETTING_SET_MAX_W)
+        ),
+        "param_with_variable_relative_date": Expression(
+            OperationType.SUBTRACT, NamedVariable(NamedVariableType.NOW), Constant(timedelta(minutes=5))
+        ),
+    }

tests/unit/client/test_validate.py

@@ -0,0 +1,200 @@
+from pathlib import Path
+
+import pytest
+from cactus_test_definitions.client.test_procedures import (
+    TestProcedureId,
+    get_test_procedure,
+    parse_test_procedure,
+)
+from cactus_test_definitions.client.validate import validate_test_procedure
+from cactus_test_definitions.errors import TestProcedureDefinitionError
+from cactus_test_definitions.variable_expressions import (
+    NamedVariableType,
+    has_named_variable,
+)
+
+
+@pytest.mark.parametrize(
+    "tp_file",
+    [
+        Path("tests/data/client/tp_invalid_bad_param.yaml"),
+        Path("tests/data/client/tp_invalid_bad_step_enable.yaml"),
+        Path("tests/data/client/tp_invalid_bad_step_remove.yaml"),
+    ],
+)
+def test_TestProcedure_invalid_examples(tp_file: Path):
+    with open(tp_file, "r") as fp:
+        tp = parse_test_procedure(fp.read())
+
+    with pytest.raises(TestProcedureDefinitionError):
+        validate_test_procedure(tp, TestProcedureId.ALL_01)
+
+
+@pytest.mark.parametrize("tp_id", TestProcedureId)
+def test_TestProcedure_individually_valid(tp_id: TestProcedureId):
+    """Tests that each TestProcedureId can be loaded via get_test_procedure without issue AND that it
+    passes validate_test_procedure."""
+    tp = get_test_procedure(tp_id)
+    assert tp.steps, "There should be steps configured"
+    validate_test_procedure(tp, tp_id)
+
+
+@pytest.mark.parametrize("tp_id", TestProcedureId)
+def test_each_step_accessible(tp_id: TestProcedureId):
+    """Ensures that each test procedure's steps are enabled/removed once. Failures here indicate a bad reference to
+    enable/remove steps"""
+
+    tp = get_test_procedure(tp_id)
+
+    first_step = [k for k in tp.steps.keys()][0]
+    step_names = set(tp.steps.keys())
+
+    removal_count = dict([(s, 0) for s in step_names])
+    enabled_count = dict([(s, 0) for s in step_names])
+
+    # Tally up the number of times each step is added/removed via actions
+    for s in tp.steps.values():
+        for enabled_name in [name for a in s.actions if a.type == "enable-steps" for name in a.parameters["steps"]]:
+            enabled_count[enabled_name] = enabled_count[enabled_name] + 1
+        for removed_name in [name for a in s.actions if a.type == "remove-steps" for name in a.parameters["steps"]]:
+            removal_count[removed_name] = removal_count[removed_name] + 1
+
+    # Also check the preconditions for actions
+    if tp.preconditions and tp.preconditions.actions:
+        for enabled_name in [
+            name for a in tp.preconditions.actions if a.type == "enable-steps" for name in a.parameters["steps"]
+        ]:
+            enabled_count[enabled_name] = enabled_count[enabled_name] + 1
+        for removed_name in [
+            name for a in tp.preconditions.actions if a.type == "remove-steps" for name in a.parameters["steps"]
+        ]:
+            removal_count[removed_name] = removal_count[removed_name] + 1
+
+    # Each test should be added once and removed once
+    for step_name in step_names:
+        assert (
+            removal_count[step_name] == 1
+        ), f"{step_name}: Each test should be removed once otherwise the test cannot complete"
+
+        if step_name == first_step:
+            assert enabled_count[step_name] == 0, f"{step_name}: The first test step is already enabled"
+        else:
+            assert (
+                enabled_count[step_name] == 1
+            ), f"{step_name}: Each test should be added once - not expecting loops of steps"
+
+
+@pytest.mark.parametrize("tp_id", TestProcedureId)
+def test_each_step_connected(tp_id: TestProcedureId):
+    """Interprets each test a graph of steps linking to other steps (via enable-steps). Passes if the test procedure
+    is fully connected from the first step (i.e. there are no isolated islands of steps that can't be reached from
+    the first step)"""
+
+    tp = get_test_procedure(tp_id)
+
+    first_step = [k for k in tp.steps.keys()][0]
+    step_names = set(tp.steps.keys())
+
+    step_links_by_name: dict[str, list[str]] = {}
+    for step_name in step_names:
+        step = tp.steps[step_name]
+        child_step_names = [name for a in step.actions if a.type == "enable-steps" for name in a.parameters["steps"]]
+        step_links_by_name[step_name] = child_step_names
+
+    # Walk through our simple graph/tree - make sure we visit every node in that tree
+    def gather_connected_steps(links: dict[str, list[str]], node: str, visited_nodes: set[str]) -> None:
+        if node in visited_nodes:
+            return
+        visited_nodes.add(node)
+        for child in links[node]:
+            gather_connected_steps(links, child, visited_nodes)
+
+    visited_nodes: set[str] = set()
+    gather_connected_steps(step_links_by_name, first_step, visited_nodes)
+
+    # Also note that steps might be started as a precondition - so include those as visited too
+    if tp.preconditions and tp.preconditions.actions:
+        for n in [name for a in tp.preconditions.actions if a.type == "enable-steps" for name in a.parameters["steps"]]:
+            visited_nodes.add(n)
+
+    assert (
+        step_names == visited_nodes
+    ), "Missing entries here indicate a step (or steps) that can't be reached from the root node"
+
+
+@pytest.mark.parametrize("tp_id", TestProcedureId)
+def test_procedures_have_required_preconditions(tp_id: TestProcedureId):
+
+    tp = get_test_procedure(tp_id)
+
+    # Immediate start implies that EndDevice registration will happen during the test body - these tests
+    # don't require end-device-contents (as it will cause the test to fail anyway)
+    is_immediate_start = tp.preconditions is not None and tp.preconditions.immediate_start
+    if not is_immediate_start:
+        assert tp.preconditions is not None, "Expected precondition check 'end-device-contents'"
+        assert tp.preconditions.checks is not None, "Expected precondition check 'end-device-contents'"
+        assert any(
+            [check.type == "end-device-contents" for check in tp.preconditions.checks]
+        ), "Expected precondition check 'end-device-contents'"
+
+    # Check 'der-settings-contents' present if any precondition action parameter references setMaxW
+    if tp.preconditions is not None and tp.preconditions.actions is not None:
+        for action in tp.preconditions.actions:
+            if action.parameters is not None:
+                if any(
+                    [
+                        has_named_variable(
+                            parameter_value=parameter, named_variable=NamedVariableType.DERSETTING_SET_MAX_W
+                        )
+                        for parameter in action.parameters.values()
+                    ]
+                ):
+                    assert tp.preconditions.checks is not None
+                    assert any([check.type == "der-settings-contents" for check in tp.preconditions.checks])
+
+
+@pytest.mark.parametrize("tp_id", TestProcedureId)
+def test_response_subject_tags_have_corresponding_der_control_tags(tp_id: TestProcedureId):
+    """Ensures that every subject_tag in response-contents checks has a corresponding
+    tag defined in a create-der-control action in the same test procedure."""
+
+    tp = get_test_procedure(tp_id)
+
+    # Collect all tags defined in create-der-control actions
+    der_control_tags = set()
+
+    if tp.preconditions and tp.preconditions.actions:
+        der_control_tags.update(
+            [
+                a.parameters.get("tag")
+                for a in tp.preconditions.actions
+                if a.type == "create-der-control" and a.parameters and a.parameters.get("tag")
+            ]
+        )
+
+    der_control_tags.update(
+        [
+            a.parameters.get("tag")
+            for s in tp.steps.values()
+            for a in s.actions
+            if a.type == "create-der-control" and a.parameters and a.parameters.get("tag")
+        ]
+    )
+
+    # Collect all subject_tags referenced in response-contents checks
+    referenced_subject_tags = set(
+        [
+            c.parameters.get("subject_tag")
+            for s in tp.steps.values()
+            if s.event.checks
+            for c in s.event.checks
+            if c.type == "response-contents" and c.parameters and c.parameters.get("subject_tag")
+        ]
+    )
+
+    # Verify all referenced subject_tags have corresponding der-control tags
+    missing_tags = referenced_subject_tags - der_control_tags
+    assert not missing_tags, (
+        f"The following subject_tags in response-contents checks do not have corresponding "
+        f"tags in create-der-control actions: {missing_tags}"
+    )

tests/unit/server/test_test_procedures.py

@@ -0,0 +1,60 @@
+from importlib import resources
+from pathlib import Path
+
+import pytest
+from assertical.asserts.type import assert_dict_type
+from cactus_test_definitions.server.test_procedures import (
+    TestProcedure,
+    TestProcedureId,
+    get_all_test_procedures,
+    parse_test_procedure,
+)
+from dataclass_wizard.errors import UnknownKeysError
+
+
+def test_TestProcedureId_synchronised():
+    """Ensures that TestProcedureId is in sync with all available TestProcedures YAML files.
+
+    Each MY-TEST.yaml must have a corresponding TestProcedureId.MY_TEST"""
+
+    # Discover all the YAML files
+    suffix = ".yaml"
+    raw_file_names: set[str] = set()
+    for yaml_file in resources.files("cactus_test_definitions.server.procedures").iterdir():
+        if yaml_file.is_file() and yaml_file.name.endswith(suffix):
+            raw_file_names.add(yaml_file.name[: -len(suffix)])
+
+    # Compare them against the TestProcedureId
+    for file_name in raw_file_names:
+        assert file_name in TestProcedureId
+    for tp_id in TestProcedureId:
+        assert tp_id in raw_file_names
+    assert len(raw_file_names) == len(TestProcedureId)
+
+
+def test_available_tests_populated():
+    """Force test procedures to load and ensure they all validate (and we at least have a few)"""
+
+    all_tps = get_all_test_procedures()
+    assert_dict_type(TestProcedureId, TestProcedure, all_tps, count=len(TestProcedureId))
+    assert all_tps[TestProcedureId.S_ALL_01] != all_tps[TestProcedureId.S_ALL_02], "Sanity check on uniqueness"
+
+
+def test_error_on_duplicate_key():
+    """Force test procedures to load and ensure they all validate (and we at least have a few)"""
+
+    with open(Path("tests/data/server/tp_error_duplicate_keys.yaml"), "r") as fp:
+        yaml_contents = fp.read()
+
+    with pytest.raises(ValueError):
+        parse_test_procedure(yaml_contents)
+
+
+def test_error_on_extra_key():
+    """Force test procedures to load and ensure they all validate (and we at least have a few)"""
+
+    with open(Path("tests/data/server/tp_error_extra_keys.yaml"), "r") as fp:
+        yaml_contents = fp.read()
+
+    with pytest.raises(UnknownKeysError):
+        parse_test_procedure(yaml_contents)

tests/unit/server/test_validate.py

@@ -0,0 +1,75 @@
+import pytest
+from cactus_test_definitions.server.actions import ACTION_PARAMETER_SCHEMA
+from cactus_test_definitions.server.test_procedures import (
+    TestProcedureId,
+    get_test_procedure,
+)
+from cactus_test_definitions.server.validate import validate_test_procedure
+
+
+@pytest.mark.parametrize("tp_id", TestProcedureId)
+def test_TestProcedure_individually_valid(tp_id: TestProcedureId):
+    """Tests that each TestProcedureId can be loaded via get_test_procedure without issue AND that it
+    passes validate_test_procedure."""
+    tp = get_test_procedure(tp_id)
+    assert tp.steps, "There should be steps configured"
+    validate_test_procedure(tp, tp_id)
+
+
+@pytest.mark.parametrize("tp_id", TestProcedureId)
+def test_each_step_id_unique(tp_id: TestProcedureId):
+    tp = get_test_procedure(tp_id)
+    all_ids = [s.id for s in tp.steps]
+    assert list(sorted(all_ids)) == list(sorted(set(all_ids)))
+    assert len(set((s.id for s in tp.steps))) == len(tp.steps), "All steps must have a unique id property"
+
+
+@pytest.mark.parametrize("tp_id", TestProcedureId)
+def test_each_alias_defined(tp_id: str):
+    """Ensures that each test procedure's steps that have actions using an alias... define those aliases in advance"""
+
+    tp = get_test_procedure(tp_id)
+
+    # sanity check - make sure we are looking for the action names that are valid
+    UPSERT_MUP_ACTION = "upsert-mup"
+    INSERT_READING_ACTION = "insert-readings"
+    CREATE_SUB_ACTION = "create-subscription"
+    DELETE_SUB_ACTION = "delete-subscription"
+    assert UPSERT_MUP_ACTION in ACTION_PARAMETER_SCHEMA, "If this fails - the action name has changed. Update this test"
+    assert (
+        INSERT_READING_ACTION in ACTION_PARAMETER_SCHEMA
+    ), "If this fails - the action name has changed. Update this test"
+    assert CREATE_SUB_ACTION in ACTION_PARAMETER_SCHEMA, "If this fails - the action name has changed. Update this test"
+    assert DELETE_SUB_ACTION in ACTION_PARAMETER_SCHEMA, "If this fails - the action name has changed. Update this test"
+
+    mup_aliases_found: set[str] = set()
+    sub_aliases_found: set[str] = set()
+    for step in tp.steps:
+        if step.action.parameters:
+            mup_id = step.action.parameters.get("mup_id", None)
+            sub_id = step.action.parameters.get("sub_id", None)
+        else:
+            mup_id = None
+            sub_id = None
+
+        if step.action.type == UPSERT_MUP_ACTION:
+            mup_aliases_found.add(mup_id)
+        elif step.action.type == INSERT_READING_ACTION:
+            assert mup_id and (mup_id in mup_aliases_found), "mup_id hasn't been defined yet."
+        elif step.action.type == CREATE_SUB_ACTION:
+            assert sub_id and (sub_id not in sub_aliases_found), "sub_id is already defined in this test."
+            sub_aliases_found.add(sub_id)
+        elif step.action.type == DELETE_SUB_ACTION:
+            assert sub_id and (sub_id in sub_aliases_found), "sub_id hasn't been defined yet."
+
+        # Any instance of "sub_id" / "mup_id" in a check must have ALSO been defined in an earlier action
+        for check in step.checks or []:
+            sub_id = check.parameters.get("sub_id", None)
+            if sub_id:
+                # This will match
+                assert sub_id and (sub_id in sub_aliases_found), "sub_id hasn't been defined yet."
+
+            mup_id = check.parameters.get("mup_id", None)
+            if mup_id:
+                # This will match
+                assert mup_id and (mup_id in mup_aliases_found), "mup_id hasn't been defined yet."

tests/unit/test_csipaus.py

@@ -0,0 +1,49 @@
+import pytest
+from cactus_test_definitions.csipaus import (
+    CSIPAusReadingLocation,
+    CSIPAusReadingType,
+    CSIPAusResource,
+    is_list_resource,
+)
+
+
+@pytest.mark.parametrize("enum_val", CSIPAusResource)
+def test_CSIPAusResource_name_matches_value(enum_val: CSIPAusResource):
+    """We want case varying enum values (to match the values in CSIP Aus). This means we need to manage the names
+    manually and ensures we don't end up with a bad copy paste"""
+    assert enum_val.value == enum_val.name
+
+
+@pytest.mark.parametrize("enum_val", CSIPAusReadingLocation)
+def test_CSIPAusReadingLocation_name_matches_value(enum_val: CSIPAusReadingLocation):
+    """We want case varying enum values (to match the values in CSIP Aus). This means we need to manage the names
+    manually and ensures we don't end up with a bad copy paste"""
+    assert enum_val.value == enum_val.name
+
+
+@pytest.mark.parametrize("enum_val", CSIPAusReadingType)
+def test_CSIPAusReadingType_name_matches_value(enum_val: CSIPAusReadingType):
+    """We want case varying enum values (to match the values in CSIP Aus). This means we need to manage the names
+    manually and ensures we don't end up with a bad copy paste"""
+    assert enum_val.value == enum_val.name
+
+
+@pytest.mark.parametrize(
+    "resource, expected",
+    [
+        (CSIPAusResource.ConnectionPoint, False),
+        (CSIPAusResource.DeviceCapability, False),
+        (CSIPAusResource.DERSettings, False),
+        (CSIPAusResource.EndDeviceList, True),
+        (CSIPAusResource.EndDevice, False),
+        (CSIPAusResource.DERList, True),
+        (CSIPAusResource.DERProgramList, True),
+        (CSIPAusResource.MirrorUsagePointList, True),
+        (CSIPAusResource.DERControlList, True),
+        (CSIPAusResource.DERControl, False),
+    ],
+)
+def test_is_list_resource(resource: CSIPAusResource, expected: bool):
+    actual = is_list_resource(resource)
+    assert isinstance(actual, bool)
+    assert actual is expected