Add serializer validation

Author: amickan

app/grandchallenge/algorithms/serializers.py

@@ -374,3 +374,40 @@ def __init__(self, *args, **kwargs):
                 user=user,
                 codename="invoke_endpoint",
             )
+
+    def validate(self, data):
+        self._endpoint = data.pop("endpoint")
+        inputs = data.pop("inputs")
+        data["algorithm_interface"] = (
+            self.validate_inputs_and_return_matching_interface(inputs=inputs)
+        )
+        data["civ_data_objects"] = convert_deserialized_civ_data(
+            deserialized_civ_data=inputs
+        )
+
+        return data
+
+    def validate_inputs_and_return_matching_interface(self, *, inputs):
+        """
+        Validates that the provided inputs match one of the endpoint's algorithm's configured interfaces
+        """
+        provided_inputs = {i["interface"] for i in inputs}
+        allowed_algorithm_interfaces = (
+            self._endpoint.algorithm_image.algorithm.interfaces.all()
+        )
+        annotated_qs = annotate_input_output_counts(
+            allowed_algorithm_interfaces, inputs=provided_inputs
+        )
+        try:
+            interface = annotated_qs.get(
+                relevant_input_count=len(provided_inputs),
+                input_count=len(provided_inputs),
+            )
+            return interface
+        except ObjectDoesNotExist:
+            raise serializers.ValidationError(
+                f"The set of inputs provided does not match "
+                f"any of the endpoint's algorithm's interfaces. This algorithm supports the "
+                f"following input combinations: "
+                f"{oxford_comma([f'Interface {n}: {oxford_comma(interface.inputs.all())}' for n, interface in enumerate(allowed_algorithm_interfaces, start=1)])}"
+            )

app/tests/algorithms_tests/test_serializers.py

@@ -4,9 +4,10 @@
 from guardian.shortcuts import assign_perm
 from rest_framework.exceptions import ErrorDetail
 
-from grandchallenge.algorithms.models import Job
+from grandchallenge.algorithms.models import Endpoint, Job
 from grandchallenge.algorithms.serializers import (
     HyperlinkedJobSerializer,
+    InvocationPostSerializer,
     JobPostSerializer,
 )
 from grandchallenge.cases.models import RawImageUploadSession
@@ -16,6 +17,7 @@
     AlgorithmImageFactory,
     AlgorithmInterfaceFactory,
     AlgorithmJobFactory,
+    EndpointFactory,
 )
 from tests.cases_tests.factories import RawImageUploadSessionFactory
 from tests.components_tests.factories import (
@@ -586,3 +588,90 @@ def test_validate_inputs_on_job_serializer(inputs, interface, rf):
             in str(serializer.errors)
         )
         assert "algorithm_interface" not in serializer.validated_data
+
+
+@pytest.mark.parametrize(
+    "inputs, interface",
+    (
+        ([1], 1),  # matches interface 1 of algorithm
+        ([1, 2], 2),  # matches interface 2 of algorithm
+        ([3, 4, 5], 3),  # matches interface 3 of algorithm
+        ([4], None),  # matches interface 4, but not configured for algorithm
+        (
+            [1, 2, 3],
+            None,
+        ),  # matches interface 5, but not configured for algorithm
+        ([2], None),  # matches no interface (implements part of interface 2)
+        (
+            [1, 3, 4],
+            None,
+        ),  # matches no interface (implements interface 3 and an additional input)
+    ),
+)
+@pytest.mark.django_db
+def test_input_validation_on_invocation_serializer(inputs, interface, rf):
+    user = UserFactory()
+    algorithm = AlgorithmFactory()
+    algorithm.add_editor(user)
+    ai = AlgorithmImageFactory(
+        algorithm=algorithm,
+        is_desired_version=True,
+        is_manifest_valid=True,
+        is_in_registry=True,
+    )
+    endpoint = EndpointFactory(
+        algorithm_image=ai, creator=user, status=Endpoint.StatusChoices.RUNNING
+    )
+
+    io1, io2, io3, io4, io5 = AlgorithmInterfaceFactory.create_batch(5)
+    ci1, ci2, ci3, ci4, ci5, ci6 = ComponentInterfaceFactory.create_batch(
+        6, kind=ComponentInterface.Kind.STRING
+    )
+
+    interfaces = [io1, io2, io3]
+    cis = [ci1, ci2, ci3, ci4, ci5, ci6]
+
+    io1.inputs.set([ci1])
+    io2.inputs.set([ci1, ci2])
+    io3.inputs.set([ci3, ci4, ci5])
+    io4.inputs.set([ci1, ci2, ci3])
+    io5.inputs.set([ci4])
+    io1.outputs.set([ci6])
+    io2.outputs.set([ci3])
+    io3.outputs.set([ci1])
+    io4.outputs.set([ci1])
+    io5.outputs.set([ci1])
+
+    algorithm.interfaces.add(io1)
+    algorithm.interfaces.add(io2)
+    algorithm.interfaces.add(io3)
+
+    algorithm_interface = interfaces[interface - 1] if interface else None
+    inputs = [cis[i - 1] for i in inputs]
+
+    invocation = {
+        "endpoint": endpoint.api_url,
+        "inputs": [
+            {"interface": int.slug, "value": "dummy"} for int in inputs
+        ],
+    }
+
+    request = rf.get("/foo")
+    request.user = user
+    serializer = InvocationPostSerializer(
+        data=invocation, context={"request": request}
+    )
+
+    if interface:
+        assert serializer.is_valid()
+        assert (
+            serializer.validated_data["algorithm_interface"]
+            == algorithm_interface
+        )
+    else:
+        assert not serializer.is_valid()
+        assert (
+            "The set of inputs provided does not match any of the endpoint's algorithm's interfaces."
+            in str(serializer.errors)
+        )
+        assert "algorithm_interface" not in serializer.validated_data