Add test for validate_all with adorned node and ignore undefined outputs

ee/vellum_ee/workflows/display/tests/test_mocks.py

@@ -779,3 +779,134 @@ class Outputs(BaseWorkflow.Outputs):
 
     # AND the then_outputs should be serialized correctly
     assert serialized_mock["then_outputs"]["result"] == "mocked_result"
+
+
+def test_mocks__validate_all__try_node_wrapped_node_deserializes_correctly():
+    """
+    Tests that validate_all correctly deserializes a mock for a node wrapped in a TryNode adornment.
+    """
+
+    # GIVEN a node wrapped in a TryNode adornment
+    @TryNode.wrap()
+    class WrappedNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            result: str
+
+    # AND a workflow that uses the wrapped node
+    class MyWorkflow(BaseWorkflow):
+        graph = WrappedNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_result = WrappedNode.Outputs.result
+
+    # AND the inner wrapped node's ID
+    inner_node = WrappedNode.__wrapped_node__
+    assert inner_node is not None
+
+    # AND a raw mock workflow node execution using the inner node's ID
+    raw_mock_workflow_node_executions = [
+        {
+            "node_id": str(inner_node.__id__),
+            "when_condition": {
+                "type": "BINARY_EXPRESSION",
+                "operator": ">=",
+                "lhs": {
+                    "type": "EXECUTION_COUNTER",
+                    "node_id": str(inner_node.__id__),
+                },
+                "rhs": {
+                    "type": "CONSTANT_VALUE",
+                    "value": {
+                        "type": "NUMBER",
+                        "value": 1,
+                    },
+                },
+            },
+            "then_outputs": {
+                "result": "mocked_result",
+            },
+        },
+    ]
+
+    # WHEN we parse the raw data on MockNodeExecution
+    node_output_mocks = MockNodeExecution.validate_all(
+        raw_mock_workflow_node_executions,
+        MyWorkflow,
+        descriptor_validator=base_descriptor_validator,
+    )
+
+    # THEN we get a list with one MockNodeExecution object
+    assert node_output_mocks is not None
+    assert len(node_output_mocks) == 1
+
+    # AND the MockNodeExecution has the correct when_condition
+    assert node_output_mocks[0].when_condition == inner_node.Execution.count.greater_than_or_equal_to(1)
+
+    # AND the then_outputs is the correct type with the expected value
+    assert node_output_mocks[0].then_outputs == inner_node.Outputs(result="mocked_result")
+
+
+def test_mocks__validate_all__ignores_undefined_outputs():
+    """
+    Tests that validate_all ignores outputs that are not defined in the node's Outputs class.
+    """
+
+    # GIVEN a node wrapped in a TryNode adornment
+    @TryNode.wrap()
+    class WrappedNode(BaseNode):
+        class Outputs(BaseNode.Outputs):
+            result: str
+
+    # AND a workflow that uses the wrapped node
+    class MyWorkflow(BaseWorkflow):
+        graph = WrappedNode
+
+        class Outputs(BaseWorkflow.Outputs):
+            final_result = WrappedNode.Outputs.result
+
+    # AND the inner wrapped node's ID
+    inner_node = WrappedNode.__wrapped_node__
+    assert inner_node is not None
+
+    # AND a raw mock workflow node execution with an undefined "error" output
+    raw_mock_workflow_node_executions = [
+        {
+            "node_id": str(inner_node.__id__),
+            "when_condition": {
+                "type": "BINARY_EXPRESSION",
+                "operator": ">=",
+                "lhs": {
+                    "type": "EXECUTION_COUNTER",
+                    "node_id": str(inner_node.__id__),
+                },
+                "rhs": {
+                    "type": "CONSTANT_VALUE",
+                    "value": {
+                        "type": "NUMBER",
+                        "value": 1,
+                    },
+                },
+            },
+            "then_outputs": {
+                "result": "mocked_result",
+                "error": "some error value",
+            },
+        },
+    ]
+
+    # WHEN we parse the raw data on MockNodeExecution
+    node_output_mocks = MockNodeExecution.validate_all(
+        raw_mock_workflow_node_executions,
+        MyWorkflow,
+        descriptor_validator=base_descriptor_validator,
+    )
+
+    # THEN we get a list with one MockNodeExecution object
+    assert node_output_mocks is not None
+    assert len(node_output_mocks) == 1
+
+    # AND the then_outputs only contains the declared "result" output
+    assert node_output_mocks[0].then_outputs == inner_node.Outputs(result="mocked_result")
+
+    # AND the "error" output was ignored and is not present
+    assert not hasattr(node_output_mocks[0].then_outputs, "error")

src/vellum/workflows/outputs/base.py

@@ -292,7 +292,9 @@ def validate(value: Any, info: ValidationInfo) -> Any:
                 return cls(**value)
 
             node_class = workflow.resolve_node_ref(node_id)
-            return node_class.Outputs(**value)
+            declared_fields = {descriptor.name for descriptor in node_class.Outputs}
+            filtered_value = {k: v for k, v in value.items() if k in declared_fields}
+            return node_class.Outputs(**filtered_value)
 
         return core_schema.union_schema(
             [