feat: The invocation of a non-existing function returns null

src/main/scala/org/camunda/feel/api/EvaluationFailure.scala

@@ -9,4 +9,7 @@ package org.camunda.feel.api
 case class EvaluationFailure(
                               failureType: EvaluationFailureType,
                               failureMessage: String
-                            )
+                            ) {
+
+  override def toString: String = s"[$failureType] $failureMessage"
+}

src/main/scala/org/camunda/feel/impl/interpreter/EvalContext.scala

@@ -47,7 +47,7 @@ class EvalContext(val valueMapper: ValueMapper,
       .getFunctions(name)
       .find(filter)
       .getOrElse(ValError(
-        s"no function found with name '$name' and $paramCount parameters"))
+        s"No function found with name '$name' and $paramCount parameters"))
   }
 
   def function(name: String, parameters: Set[String]): Val = {
@@ -57,7 +57,7 @@ class EvalContext(val valueMapper: ValueMapper,
       .getFunctions(name)
       .find(filter)
       .getOrElse(ValError(
-        s"no function found with name '$name' and parameters: ${
+        s"No function found with name '$name' and parameters: ${
           parameters
             .mkString(",")
         }"))

src/main/scala/org/camunda/feel/impl/interpreter/FeelInterpreter.scala

@@ -686,9 +686,13 @@ class FeelInterpreter {
     )
 
   private def withFunction(x: Val, f: ValFunction => Val)(implicit context: EvalContext): Val = x match {
-    case x: ValFunction     => f(x)
-    case ValError(failure)  => error(EvaluationFailureType.NO_FUNCTION_FOUND, failure)
-    case _                  => error(s"expect Function but found '$x'")
+    case x: ValFunction => f(x)
+    case ValError(failure) =>
+      error(EvaluationFailureType.NO_FUNCTION_FOUND, failure)
+      ValNull
+    case _ =>
+      error(EvaluationFailureType.INVALID_TYPE, s"Expected function but found '$x'")
+      ValNull
   }
 
   private def invokeFunction(function: ValFunction, params: FunctionParameters)(

src/test/scala/org/camunda/feel/impl/EvaluationResultMatchers.scala

@@ -0,0 +1,48 @@
+package org.camunda.feel.impl
+
+import org.camunda.feel.api.{EvaluationFailure, EvaluationFailureType, EvaluationResult, FailedEvaluationResult, SuccessfulEvaluationResult}
+import org.scalatest.matchers.{MatchResult, Matcher}
+
+trait EvaluationResultMatchers {
+
+  def returnResult(expectedResult: Any) = new EvaluationResultValueMatcher(expectedResult)
+
+  def returnNull() = new EvaluationResultValueMatcher(expectedResult = null)
+
+  def reportFailure(failureType: EvaluationFailureType, failureMessage: String) =
+    new SuppressedFailureMatcher(EvaluationFailure(failureType, failureMessage))
+
+  class EvaluationResultValueMatcher(expectedResult: Any) extends Matcher[EvaluationResult] {
+    override def apply(evaluationResult: EvaluationResult): MatchResult = {
+      evaluationResult match {
+        case SuccessfulEvaluationResult(result, _) => MatchResult(
+          result == expectedResult,
+          s"the evaluation didn't returned '$expectedResult' but '${evaluationResult.result}'",
+          s"The evaluation returned '${evaluationResult.result}' as expected",
+        )
+        case FailedEvaluationResult(failure, _) => MatchResult(
+          false,
+          s"the evaluation didn't returned '$expectedResult' but failed with '${failure.message}'",
+          s"the evaluation didn't returned '$expectedResult' but failed with '${failure.message}'",
+        )
+      }
+    }
+  }
+
+  class SuppressedFailureMatcher(expectedFailure: EvaluationFailure) extends Matcher[EvaluationResult] {
+    override def apply(evaluationResult: EvaluationResult): MatchResult = {
+      val matchResult = (suppressedFailures: List[EvaluationFailure]) => MatchResult(
+        suppressedFailures.contains(expectedFailure),
+        s"the evaluation didn't report '$expectedFailure' but '$suppressedFailures'",
+        s"the evaluation reported '$expectedFailure' as expected",
+      )
+      evaluationResult match {
+        case SuccessfulEvaluationResult(_, suppressedFailures) => matchResult(suppressedFailures)
+        case FailedEvaluationResult(_, suppressedFailures) => matchResult(suppressedFailures)
+      }
+    }
+  }
+
+}
+
+object EvaluationResultMatchers extends EvaluationResultMatchers

src/test/scala/org/camunda/feel/impl/FeelEngineTest.scala

@@ -0,0 +1,70 @@
+/*
+ * Copyright Camunda Services GmbH and/or licensed to Camunda Services GmbH
+ * under one or more contributor license agreements. See the NOTICE file
+ * distributed with this work for additional information regarding copyright
+ * ownership. Camunda licenses this file to you under the Apache License,
+ * Version 2.0; you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.camunda.feel.impl
+
+import org.camunda.feel.api.{EvaluationResult, FeelEngineApi, FeelEngineBuilder, SuccessfulEvaluationResult, FailedEvaluationResult}
+import org.camunda.feel.context.Context
+import org.camunda.feel.syntaxtree.ValFunction
+
+trait FeelEngineTest {
+
+  val engine: FeelEngineApi = FeelEngineBuilder()
+    .withEnabledExternalFunctions(true)
+    .build()
+
+  def evaluateExpression(
+                          expression: String,
+                          variables: Map[String, Any] = Map(),
+                          functions: Map[String, ValFunction] = Map()
+                        ): EvaluationResult = {
+    val context =
+      Context.StaticContext(
+        variables = variables,
+        functions = functions.map { case (n, f) => n -> List(f) })
+
+    engine.evaluateExpression(expression, context)
+  }
+
+  def evaluateUnaryTests(
+                          expression: String,
+                          inputValue: Any,
+                          variables: Map[String, Any] = Map(),
+                          functions: Map[String, ValFunction] = Map()
+                        ): EvaluationResult = {
+    val context =
+      Context.StaticContext(
+        variables = variables,
+        functions = functions.map { case (n, f) => n -> List(f) })
+
+    engine.evaluateUnaryTests(
+      expression = expression,
+      inputValue = inputValue,
+      context = context
+    )
+  }
+
+  def evaluateFunction(function: String): ValFunction = {
+    engine.evaluateExpression(function) match {
+      case SuccessfulEvaluationResult(result: ValFunction, _) => result
+      case SuccessfulEvaluationResult(result, _) =>
+        throw new AssertionError(s"Expected to return a function but was '$result'")
+      case FailedEvaluationResult(failure, _) =>
+        throw new AssertionError(s"Expected to return a function but failed with '${failure.message}'")
+    }
+  }
+
+}

src/test/scala/org/camunda/feel/impl/SuppressedFailuresTest.scala

@@ -1,107 +1,85 @@
 package org.camunda.feel.impl
 
-import org.camunda.feel.api._
+import org.camunda.feel.api.{EvaluationFailureType, EvaluationFailure}
 import org.scalatest.flatspec.AnyFlatSpec
 import org.scalatest.matchers.should.Matchers
-import org.scalatest.matchers.{MatchResult, Matcher}
 
 class SuppressedFailuresTest extends AnyFlatSpec
-  with Matchers {
-
-  private val engine: FeelEngineApi = FeelEngineBuilder().build()
+  with FeelEngineTest
+  with Matchers
+  with EvaluationResultMatchers {
 
   "The engine" should "report a suppressed failure for a non-existing variable" in {
-    engine.evaluateExpression("x + 1") should reportFailure(
+    evaluateExpression("x + 1") should reportFailure(
       failureType = EvaluationFailureType.NO_VARIABLE_FOUND,
       failureMessage = "No variable found with name 'x'"
     )
   }
 
   it should "report a suppressed failure for a non-existing context entry" in {
-    engine.evaluateExpression("{x: 1}.y") should reportFailure(
+    evaluateExpression("{x: 1}.y") should reportFailure(
       failureType = EvaluationFailureType.NO_CONTEXT_ENTRY_FOUND,
       failureMessage = "context contains no entry with key 'y'"
     )
   }
 
   it should "report a suppressed failure for a non-existing property" in {
-    engine.evaluateExpression(""" @"P1Y".days """) should reportFailure(
+    evaluateExpression(""" @"P1Y".days """) should reportFailure(
       failureType = EvaluationFailureType.NO_PROPERTY_FOUND,
       failureMessage = "No property found with name 'days' of value 'P1Y'. Available properties: years,months"
     )
   }
 
-  it should "report a suppressed failure for a non-existing function (with position arguments)" in {
-    engine.evaluateExpression("f(1, 2)") should reportFailure(
-      failureType = EvaluationFailureType.NO_FUNCTION_FOUND,
-      failureMessage = "no function found with name 'f' and 2 parameters"
-    )
-  }
-
-  it should "report a suppressed failure for a non-existing function (with named arguments)" in {
-    engine.evaluateExpression("f(x: 1, y: 2)") should reportFailure(
-      failureType = EvaluationFailureType.NO_FUNCTION_FOUND,
-      failureMessage = "no function found with name 'f' and parameters: x,y"
-    )
-  }
-
-  it should "report a suppressed failure if a function invocation fails" in {
-    engine.evaluateExpression("number(null)") should reportFailure(
-      failureType = EvaluationFailureType.FUNCTION_INVOCATION_FAILURE,
-      failureMessage = "Failed to invoke function 'number': Illegal arguments: List(ValNull)"
-    )
-  }
-
   it should "report a suppressed failure if input is not comparable with interval" in {
-    engine.evaluateUnaryTests("[2..5]", "NaN") should reportFailure(
+    evaluateUnaryTests("[2..5]", "NaN") should reportFailure(
       failureType = EvaluationFailureType.NOT_COMPARABLE,
       failureMessage = "Can't compare ValString(NaN) with ValNumber(2) and ValNumber(5)"
     )
   }
 
   it should "report a suppressed failure if values are not comparable" in {
-    engine.evaluateExpression("true < 2") should reportFailure(
+    evaluateExpression("true < 2") should reportFailure(
       failureType = EvaluationFailureType.NOT_COMPARABLE,
       failureMessage = "Can't compare ValBoolean(true) with ValNumber(2)"
     )
   }
 
   it should "report a suppressed failure if an addition has incompatible values" in {
-    engine.evaluateExpression("2 + true") should reportFailure(
+    evaluateExpression("2 + true") should reportFailure(
       failureType = EvaluationFailureType.INVALID_TYPE,
       failureMessage = "Expected Number but found 'ValBoolean(true)'"
     )
   }
 
   it should "report a suppressed failure if a condition is not a boolean" in {
-    engine.evaluateExpression("if 5 then 1 else 2") should reportFailure(
+    evaluateExpression("if 5 then 1 else 2") should reportFailure(
       failureType = EvaluationFailureType.INVALID_TYPE,
       failureMessage = "Expected Boolean but found 'ValNumber(5)'"
     )
 
-    engine.evaluateExpression("true and 2") should reportFailure(
+    evaluateExpression("true and 2") should reportFailure(
       failureType = EvaluationFailureType.INVALID_TYPE,
       failureMessage = "Expected Boolean but found 'ValNumber(2)'"
     )
 
-    engine.evaluateExpression("false or 3") should reportFailure(
+    evaluateExpression("false or 3") should reportFailure(
       failureType = EvaluationFailureType.INVALID_TYPE,
       failureMessage = "Expected Boolean but found 'ValNumber(3)'"
     )
 
-    engine.evaluateExpression("some x in [false, 2] satisfies x") should reportFailure(
+    evaluateExpression("some x in [false, 2] satisfies x") should reportFailure(
       failureType = EvaluationFailureType.INVALID_TYPE,
       failureMessage = "Expected Boolean but found 'ValNumber(2)'"
     )
 
-    engine.evaluateExpression("every x in [true, 3] satisfies x") should reportFailure(
+    evaluateExpression("every x in [true, 3] satisfies x") should reportFailure(
       failureType = EvaluationFailureType.INVALID_TYPE,
       failureMessage = "Expected Boolean but found 'ValNumber(3)'"
     )
   }
 
   it should "report a suppressed failure only once" in {
-    val evaluationResult = engine.evaluateExpression("1 + x")
+    val evaluationResult = evaluateExpression("1 + x")
 
     evaluationResult.hasSuppressedFailures should be (true)
     evaluationResult.suppressedFailures should have size(2)
@@ -118,23 +96,4 @@ class SuppressedFailuresTest extends AnyFlatSpec
     )
   }
 
-  // ========== test helpers =========
-
-  private def reportFailure(failureType: EvaluationFailureType, failureMessage: String) =
-    new SuppressedFailureMatcher(EvaluationFailure(failureType, failureMessage))
-
-  private class SuppressedFailureMatcher(expectedFailure: EvaluationFailure) extends Matcher[EvaluationResult] {
-    override def apply(evaluationResult: EvaluationResult): MatchResult = {
-      val matchResult = (suppressedFailures: List[EvaluationFailure]) => MatchResult(
-        suppressedFailures.contains(expectedFailure),
-        s"${evaluationResult.suppressedFailures} doesn't contain '$expectedFailure'",
-        s"$evaluationResult contains '$expectedFailure'",
-      )
-      evaluationResult match {
-        case SuccessfulEvaluationResult(_, suppressedFailures) => matchResult(suppressedFailures)
-        case FailedEvaluationResult(_, suppressedFailures) => matchResult(suppressedFailures)
-      }
-    }
-  }
-
 }