wip

Author: raphaelsolarski

scenario-compiler/src/main/scala/pl/touk/nussknacker/engine/Interpreter.scala

@@ -144,12 +144,10 @@ private class InterpreterInternal[F[_]: Monad](
               interpretationResult(node, FragmentEndReference(id, fields), newCtx)
             }
           )
-      case Enricher(_, ref, outName, next, mockedOutput) =>
-        if (runtimeMode == Test && mockedOutput.isDefined) {
-          //todo: refactor
-          val valueWithModifiedContext = expressionEvaluator.evaluate[Any](mockedOutput.get, outName, node.id, ctx)
-          interpretNext(next, ctx.withVariable(outName, valueWithModifiedContext.value))
-        }
+      case Enricher(_, _, outName, next, Some(mockedOutput)) if runtimeMode == Test =>
+        val valueWithModifiedContext = expressionEvaluator.evaluate[Any](mockedOutput, outName, node.id, ctx)
+        interpretNext(next, ctx.withVariable(outName, valueWithModifiedContext.value))
+      case Enricher(_, ref, outName, next, _) =>
         invokeWrappedInInterpreterShape(ref, ctx).flatMap {
           case Left(ValueWithContext(out, newCtx)) => interpretNext(node, next, newCtx.withVariable(outName, out))
           case Right(exInfo)                       => Monad[F].pure(List(Right(exInfo)))

scenario-compiler/src/main/scala/pl/touk/nussknacker/engine/compile/PartSubGraphCompiler.scala

@@ -210,19 +210,23 @@ class PartSubGraphCompiler(nodeCompiler: NodeCompiler) {
           (ref, next) => compiledgraph.node.Processor(id, ref, next, isDisabled.contains(true))
         )
 
-      case enricher @ Enricher(id, _, output, _, mockExpression) =>
+      case enricher @ Enricher(id, _, output, _, _) =>
         val NodeCompilationResult(typingInfo, parameters, newCtx, validatedServiceRef, _) =
           nodeCompiler.compileEnricher(enricher, ctx, outputVar = OutputVar.enricher(output))
-        //tddo: compile expression
 
-        //todo: type expression here and check if it match output variable type
-
-        CompilationResult.map4(
+        CompilationResult.map3(
           toCompilationResult(validatedServiceRef, typingInfo, parameters),
           CompilationResult(newCtx),
-          compile(next, newCtx.getOrElse(ctx)),
-
-        )((ref, _, next) => compiledgraph.node.Enricher(id, ref, output, next, ))
+          compile(next, newCtx.getOrElse(ctx))
+        )((serviceCompilationResult, _, next) =>
+          compiledgraph.node.Enricher(
+            id,
+            serviceCompilationResult.serviceRef,
+            output,
+            next,
+            serviceCompilationResult.mockOutputExpression
+          )
+        )
 
       // here we don't do anything, in subgraphcompiler it's just pass through, we can't add input context here because it contains output variable context (not input)
       case CustomNode(id, _, nodeType, _, _) =>

scenario-compiler/src/main/scala/pl/touk/nussknacker/engine/compile/nodecompilation/NodeCompiler.scala

@@ -1,6 +1,6 @@
 package pl.touk.nussknacker.engine.compile.nodecompilation
 
-import cats.data.{NonEmptyList, ValidatedNel, Writer}
+import cats.data.{NonEmptyList, Validated, ValidatedNel, Writer}
 import cats.data.Validated.{invalid, valid, Invalid, Valid}
 import cats.implicits._
 import pl.touk.nussknacker.engine.{api, compiledgraph, RuntimeMode, ScenarioCompilationDependencies}
@@ -21,7 +21,10 @@ import pl.touk.nussknacker.engine.compile.{
   FragmentSourceWithTestWithParametersSupportFactory,
   NodeValidationExceptionHandler
 }
-import pl.touk.nussknacker.engine.compile.nodecompilation.NodeCompiler.NodeCompilationResult
+import pl.touk.nussknacker.engine.compile.nodecompilation.NodeCompiler.{
+  EnricherCompilationResult,
+  NodeCompilationResult
+}
 import pl.touk.nussknacker.engine.compiledgraph.{CompiledParameter, TypedParameter}
 import pl.touk.nussknacker.engine.definition.component.ComponentDefinitionWithImplementation
 import pl.touk.nussknacker.engine.definition.component.dynamic.{
@@ -60,6 +63,11 @@ object NodeCompiler {
 
   }
 
+  final case class EnricherCompilationResult(
+      serviceRef: compiledgraph.service.ServiceRef,
+      mockOutputExpression: Option[CompiledExpression]
+  )
+
 }
 
 class NodeCompiler(
@@ -374,8 +382,29 @@ class NodeCompiler(
   def compileEnricher(n: Enricher, ctx: ValidationContext, outputVar: OutputVar)(
       implicit nodeId: NodeId,
       scenarioCompilationDependencies: ScenarioCompilationDependencies
-  ): NodeCompilationResult[compiledgraph.service.ServiceRef] = {
-    compileService(n.service, ctx, Some(outputVar))
+  ): NodeCompilationResult[EnricherCompilationResult] = {
+    val serviceCompilationResult = compileService(n.service, ctx, Some(outputVar))
+
+    val expressionCompilationResult = n.mockExpression match {
+      case Some(expression) =>
+        compileEnricherMockExpression(expression, serviceCompilationResult.expressionType.getOrElse(Unknown), ctx)
+          .map(Some(_))
+      case None => Validated.validNel(None)
+    }
+    serviceCompilationResult.copy(
+      compiledObject = serviceCompilationResult.compiledObject.product(expressionCompilationResult).map {
+        case (service, mockedExpression) =>
+          EnricherCompilationResult(service, mockedExpression)
+      }
+    )
+  }
+
+  private def compileEnricherMockExpression(expression: Expression, expectedType: TypingResult, ctx: ValidationContext)(
+      implicit nodeId: NodeId
+  ): ValidatedNel[ProcessCompilationError, CompiledExpression] = {
+    expressionCompiler
+      .compile(expression, None, ctx, expectedType)
+      .map(_.expression)
   }
 
   private def compileService(n: ServiceRef, validationContext: ValidationContext, outputVar: Option[OutputVar])(