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

tests/unit/client/test_config.py

@@ -0,0 +1,61 @@
+from datetime import datetime, timedelta, timezone
+from pathlib import Path
+
+import pytest
+from cactus_test_definitions.client import TestProcedureConfig
+from cactus_test_definitions.errors import TestProcedureDefinitionError
+from cactus_test_definitions.variable_expressions import (
+    Constant,
+    Expression,
+    NamedVariable,
+    NamedVariableType,
+    OperationType,
+)
+
+
+@pytest.mark.parametrize(
+    "filename",
+    [
+        # No 'steps' parameters defined for enable-steps action (NOT-A-VALID-PARAMETER-NAME supplied instead)
+        "tests/data/config_with_errors1.yaml",
+        # Action refers to step "NOT-A-VALID-STEP"
+        "tests/data/config_with_errors2.yaml",
+    ],
+)
+def test_TestProcedures_validate_raises_exception(filename: str):
+
+    with pytest.raises(TestProcedureDefinitionError):
+        _ = TestProcedureConfig.from_yamlfile(path=Path(filename))
+
+
+def test_TestProcedures_action_parameter_types():
+    """Tests that lists/dicts/constants/datetimes can all be encoded/decoded via the yaml action definition"""
+    cfg = TestProcedureConfig.from_yamlfile(path=Path("tests/data/config_action_parameters.yaml"), skip_validation=True)
+    test_proc = cfg.test_procedures["CUSTOM-01"]
+    step = test_proc.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_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,150 @@
+import pytest
+from cactus_test_definitions.client.test_procedures import (
+    TestProcedure,
+    TestProcedureConfig,
+    TestProcedureId,
+)
+from cactus_test_definitions.variable_expressions import (
+    NamedVariableType,
+    has_named_variable,
+)
+
+# Failures here will raise an issue in the test_from_yamlfile test
+ALL_TEST_PROCEDURES: list[tuple[str, TestProcedure]] = []
+try:
+    ALL_TEST_PROCEDURES = [(k, tp) for k, tp in TestProcedureConfig.from_resource().test_procedures.items()]
+except Exception:
+    pass
+
+
+def test_from_yamlfile():
+    """This test confirms the standard test procedure yaml file (intended for production use)
+    can be read and converted to the appropriate dataclasses.
+    """
+    test_procedures = TestProcedureConfig.from_resource()
+    test_procedures.validate()
+
+
+def test_TestProcedureId_synchronised():
+    """Ensures that TestProcedureId is in sync with all available TestProcedures"""
+    available_tests = set(TestProcedureConfig.available_tests())
+    for t in available_tests:
+        assert t in TestProcedureId, "TestProcedureConfig has a procedure not encoded in TestProcedureId"
+
+    # By convention - test ALL-01 will be an enum ALL_01
+    # for t in (t.replace("_", "-") for t in TestProcedureId):
+    for t in TestProcedureId:
+        assert t.value in available_tests, "TestProcedureId has extra procedures not found in TestProcedureConfig"
+
+
+def test_available_tests_populated():
+    """Force test procedures to load and ensure they all validate (and we at least have a few)"""
+    assert len(TestProcedureConfig.available_tests()) > 0
+
+
+@pytest.mark.parametrize("tp_id, tp", ALL_TEST_PROCEDURES)
+def test_each_step_accessible(tp_id: str, tp: TestProcedure):
+    """Ensures that each test procedure's steps are enabled/removed once. Failures here indicate a bad reference to
+    enable/remove steps"""
+
+    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, tp", ALL_TEST_PROCEDURES)
+def test_each_step_connected(tp_id: str, tp: TestProcedure):
+    """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)"""
+
+    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", ALL_TEST_PROCEDURES)
+def test_procedures_have_required_preconditions(_: str, tp: TestProcedure):
+
+    # 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])

tests/unit/server/test_test_procedures.py

@@ -0,0 +1,86 @@
+import pytest
+from cactus_test_definitions.server.actions import ACTION_PARAMETER_SCHEMA
+from cactus_test_definitions.server.test_procedures import (
+    TestProcedure,
+    TestProcedureConfig,
+    TestProcedureId,
+)
+
+# Failures here will raise an issue in the test_from_yamlfile test
+ALL_TEST_PROCEDURES: list[tuple[str, TestProcedure]] = []
+try:
+    ALL_TEST_PROCEDURES = [(k, tp) for k, tp in TestProcedureConfig.from_resource().test_procedures.items()]
+except Exception:
+    pass
+
+
+def test_ALL_TEST_PROCEDURES_parsed():
+    assert len(ALL_TEST_PROCEDURES) > 0
+
+
+def test_from_yamlfile():
+    """This test confirms the standard test procedure yaml file (intended for production use)
+    can be read and converted to the appropriate dataclasses.
+    """
+    test_procedures = TestProcedureConfig.from_resource()
+    test_procedures.validate()
+
+
+def test_TestProcedureId_synchronised():
+    """Ensures that TestProcedureId is in sync with all available TestProcedures"""
+    available_tests = set(TestProcedureConfig.available_tests())
+    for t in available_tests:
+        assert t in TestProcedureId, "TestProcedureConfig has a procedure not encoded in TestProcedureId"
+
+    # By convention - test ALL-01 will be an enum ALL_01
+    # for t in (t.replace("_", "-") for t in TestProcedureId):
+    for t in TestProcedureId:
+        assert t.value in available_tests, "TestProcedureId has extra procedures not found in TestProcedureConfig"
+
+
+def test_available_tests_populated():
+    """Force test procedures to load and ensure they all validate (and we at least have a few)"""
+    assert len(TestProcedureConfig.available_tests()) > 0
+
+
+@pytest.mark.parametrize("tp_id, tp", ALL_TEST_PROCEDURES)
+def test_each_step_id_unique(tp_id: str, tp: TestProcedure):
+    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, tp", ALL_TEST_PROCEDURES)
+def test_each_alias_defined(tp_id: str, tp: TestProcedure):
+    """Ensures that each test procedure's steps that have actions using an alias... define those aliases in advance"""
+
+    # sanity check - make sure we are looking for the action names that are valid
+    UPSERT_MUP_ACTION = "upsert-mup"
+    INSERT_MUP_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_MUP_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:
+            assert mup_id and (mup_id not in mup_aliases_found), "mup_id is already defined in this test."
+            mup_aliases_found.add(mup_id)
+        elif step.action.type == INSERT_MUP_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."

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

tests/unit/test_parameters.py

@@ -0,0 +1,197 @@
+from datetime import datetime, timezone
+from decimal import Decimal
+from itertools import product
+from typing import Any
+
+import pytest
+from cactus_test_definitions.errors import TestProcedureDefinitionError
+from cactus_test_definitions.parameters import (
+    ParameterSchema,
+    ParameterType,
+    is_valid_parameter_type,
+    validate_parameters,
+)
+from cactus_test_definitions.variable_expressions import (
+    Constant,
+    Expression,
+    NamedVariable,
+    NamedVariableType,
+    OperationType,
+)
+
+
+@pytest.mark.parametrize(
+    "value, type",
+    product(
+        [
+            None,
+            Expression(OperationType.ADD, Constant(1), Constant(2)),
+            Constant(1),
+            NamedVariable(NamedVariableType.NOW),
+        ],
+        list(ParameterType),
+    ),
+)
+def test_is_valid_parameter_type_skipped_values(value: Any, type: ParameterType):
+    """Tests that a number of values aren't considered and always return True"""
+    actual = is_valid_parameter_type(type, value)
+    assert isinstance(actual, bool)
+    assert actual
+
+
+@pytest.mark.parametrize(
+    "type, value, expected",
+    [
+        (ParameterType.Boolean, True, True),
+        (ParameterType.Boolean, False, True),
+        (ParameterType.Boolean, 1, False),
+        (ParameterType.Boolean, [1], False),
+        (ParameterType.Boolean, "True", False),
+        (ParameterType.Float, 0, True),
+        (ParameterType.Float, 0.0, True),
+        (ParameterType.Float, 1, True),
+        (ParameterType.Float, 1.1, True),
+        (ParameterType.Float, Decimal("1.1"), True),
+        (ParameterType.Float, "1.1", False),
+        (ParameterType.Float, [1.1], False),
+        (ParameterType.Integer, 0, True),
+        (ParameterType.Integer, 0.0, True),
+        (ParameterType.Integer, 2, True),
+        (ParameterType.Integer, 2.0, True),
+        (ParameterType.Integer, Decimal("2.0"), True),
+        (ParameterType.Integer, Decimal("2.1"), False),
+        (ParameterType.Integer, 2.1, False),
+        (ParameterType.Integer, [2], False),
+        (ParameterType.Integer, "2", False),
+        (ParameterType.DateTime, datetime(2022, 11, 1, 1, 2, 3), True),
+        (ParameterType.DateTime, datetime(2022, 11, 1, 1, 2, 3, tzinfo=timezone.utc), True),
+        (ParameterType.DateTime, "2022-11-01T01:02:03Z", False),
+        (ParameterType.DateTime, "2022-11-01T01:02:03", False),
+        (ParameterType.DateTime, 2022, False),
+        (ParameterType.DateTime, [], False),
+        (ParameterType.String, "", True),
+        (ParameterType.String, "abc", True),
+        (ParameterType.String, "12", True),
+        (ParameterType.String, 12, False),
+        (ParameterType.String, ["a"], False),
+        (ParameterType.ListString, [], True),
+        (ParameterType.ListString, [""], True),
+        (ParameterType.ListString, ["", "b"], True),
+        (ParameterType.ListString, ["", 4, "b"], False),
+        (ParameterType.ListString, False, False),
+        (ParameterType.ListString, True, False),
+        (ParameterType.ListString, 123, False),
+        (ParameterType.HexBinary, "AB", True),
+        (ParameterType.HexBinary, "XY", False),
+        (ParameterType.HexBinary, 12, False),
+        (ParameterType.HexBinary, ["AB"], False),
+        (ParameterType.HexBinary, 0.0, False),
+        (ParameterType.HexBinary, [12], False),
+        (ParameterType.HexBinary, 1.2, False),
+        (ParameterType.HexBinary, Decimal("1.0"), False),
+        (ParameterType.HexBinary, True, False),
+        (ParameterType.CSIPAusResource, True, False),
+        (ParameterType.CSIPAusResource, 123, False),
+        (ParameterType.CSIPAusResource, "NotAResourceType", False),
+        (ParameterType.CSIPAusResource, "ActivePowerInstantaneous", False),
+        (ParameterType.CSIPAusResource, "EndDevice", True),
+        (ParameterType.CSIPAusResource, ["EndDevice"], False),
+        (ParameterType.ListCSIPAusResource, True, False),
+        (ParameterType.ListCSIPAusResource, 123, False),
+        (ParameterType.ListCSIPAusResource, "NotAResourceType", False),
+        (ParameterType.ListCSIPAusResource, "EndDevice", False),
+        (ParameterType.ListCSIPAusResource, ["EndDevice"], True),
+        (ParameterType.ListCSIPAusResource, ["EndDevice", "NotAResource"], False),
+        (ParameterType.ListCSIPAusResource, ["ActivePowerInstantaneous"], False),
+        (ParameterType.CSIPAusReadingType, True, False),
+        (ParameterType.CSIPAusReadingType, 123, False),
+        (ParameterType.CSIPAusReadingType, "NotAResourceType", False),
+        (ParameterType.CSIPAusReadingType, "EndDevice", False),
+        (ParameterType.CSIPAusReadingType, "ActivePowerInstantaneous", True),
+        (ParameterType.CSIPAusReadingType, ["ActivePowerSiteInstantaneous"], False),
+        (ParameterType.ListCSIPAusReadingType, True, False),
+        (ParameterType.ListCSIPAusReadingType, 123, False),
+        (ParameterType.ListCSIPAusReadingType, "NotAResourceType", False),
+        (ParameterType.ListCSIPAusReadingType, "EndDevice", False),
+        (ParameterType.ListCSIPAusReadingType, "ActivePowerInstantaneous", False),
+        (ParameterType.ListCSIPAusReadingType, ["ActivePowerInstantaneous"], True),
+        (ParameterType.ListCSIPAusReadingType, ["ActivePowerInstantaneous", "NotAResource"], False),
+        (ParameterType.ListCSIPAusReadingType, ["EndDevice"], False),
+        (ParameterType.CSIPAusReadingLocation, True, False),
+        (ParameterType.CSIPAusReadingLocation, 123, False),
+        (ParameterType.CSIPAusReadingLocation, "NotAResourceType", False),
+        (ParameterType.CSIPAusReadingLocation, "EndDevice", False),
+        (ParameterType.CSIPAusReadingLocation, "Site", True),
+        (ParameterType.CSIPAusReadingLocation, ["Site"], False),
+        (ParameterType.ReadingTypeValues, 123, False),
+        (ParameterType.ReadingTypeValues, "ActivePowerInstantaneous", False),
+        (ParameterType.ReadingTypeValues, [123], False),
+        (ParameterType.ReadingTypeValues, {}, False),
+        (
+            ParameterType.ReadingTypeValues,
+            {"ActivePowerInstantaneous": [100, 1.23], "ActivePowerAverage": [200, -300]},
+            True,
+        ),
+        (
+            ParameterType.ReadingTypeValues,
+            {"ActivePowerInstantaneous": [100, 200], "ActivePowerAverage": [200, 300, 400]},
+            False,
+        ),
+        (
+            ParameterType.ReadingTypeValues,
+            {"ActivePowerInstantaneous": [100, 200], "ActivePowerAverage": [200, 300], "Foo": [100, 200]},
+            False,
+        ),
+        (
+            ParameterType.ReadingTypeValues,
+            {"ActivePowerInstantaneous": [100, 200], "ActivePowerAverage": [200, "1.23"]},
+            False,
+        ),
+        (
+            ParameterType.ReadingTypeValues,
+            {"ActivePowerInstantaneous": 100, "ActivePowerAverage": 200},
+            False,
+        ),
+    ],
+)
+def test_is_valid_parameter_type(type: ParameterType, value: Any, expected: bool):
+    actual = is_valid_parameter_type(type, value)
+    assert isinstance(actual, bool)
+    assert actual == expected
+
+
+@pytest.mark.parametrize(
+    "parameters, schema, is_valid",
+    [
+        ({}, {}, True),
+        ({"foo": 1}, {}, False),
+        ({"foo": 1}, {"foo": ParameterSchema(True, ParameterType.Integer)}, True),
+        ({"foo": 1}, {"foo": ParameterSchema(True, ParameterType.Float)}, True),
+        ({"foo": 1}, {"foo": ParameterSchema(True, ParameterType.String)}, False),  # wrong type
+        (
+            {"foo": 1},
+            {"foo": ParameterSchema(True, ParameterType.Integer), "bar": ParameterSchema(False, ParameterType.String)},
+            True,
+        ),  # Optional param is OK to miss
+        (
+            {"foo": 1},
+            {"foo": ParameterSchema(True, ParameterType.Integer), "bar": ParameterSchema(True, ParameterType.String)},
+            False,
+        ),  # Missing mandatory param
+        (
+            {"foo": None, "bar": "2", "baz": 4},
+            {
+                "foo": ParameterSchema(True, ParameterType.Integer),
+                "bar": ParameterSchema(True, ParameterType.String),
+                "baz": ParameterSchema(False, ParameterType.Float),
+            },
+            True,
+        ),
+    ],
+)
+def test_validate_action_parameters(parameters: dict, schema: dict, is_valid: bool):
+    if is_valid:
+        validate_parameters("foo", parameters, schema)
+    else:
+        with pytest.raises(TestProcedureDefinitionError):
+            validate_parameters("foo", parameters, schema)