Accept _unsafe_-prefixed forward-compat fields on scenario graph DTOs (#9309)

JulianWielga · web-flow · commit 573a816cc1cb · 2026-04-28T04:14:04.000+02:00
* Allow arbitrary _unsafeExtra fields on LayoutData without validation * Work around sbt-git's lack of git worktree support Enable useConsoleForROGit when `.git` is a file — the telltale of a worktree checkout — so sbt-git shells out to the git CLI for read-only operations that its embedded JGit cannot perform against worktrees. * Accept arbitrary _unsafe_-prefixed fields on UserDefinedAdditionalNodeFields Replaces the nested _unsafeExtra field on LayoutData with top-level pattern-matched fields on UserDefinedAdditionalNodeFields: any JSON property starting with `_unsafe_` is round-tripped via a dedicated Map[String, Json] on the case class through a hand-written Circe codec. Tapir schema keeps the named $ref for UserDefinedAdditionalNodeFields; extra _unsafe_* properties pass validation because JSON Schema allows additional properties by default. The TS NodeType mirrors this with a UnsafeOptions intersection typed as Record<`_unsafe_${string}`, unknown>. * Accept _unsafe_-prefixed fields on ProcessAdditionalFields Mirrors the node-level mechanism at the scenario level: any JSON property starting with `_unsafe_` sitting next to description / properties / metaDataType / showDescription is round-tripped via a Map[String, Json] on the case class through a hand-written Circe codec. A small `omitSchemaField` helper drops the synthetic `unsafeFields` container from the derived Tapir schema (used for both ProcessAdditionalFields and UserDefinedAdditionalNodeFields) so the generated OpenAPI stays byte-identical. TS ProcessAdditionalFields picks up the matching `& UnsafeOptions` intersection. * Extract the `_unsafe_` prefix convention into shared helpers Both ProcessAdditionalFields and UserDefinedAdditionalNodeFields inlined the same prefix constant and the same extract/merge logic across the Circe codecs; lift that into CirceUtil.UnsafePrefixedFields in common-api so the prefix lives in one place. On the TS side, export the UnsafeOptions type from node.ts and consume it from scenarioGraph.ts instead of redefining the `_unsafe_${string}` template literal locally. * Add codec tests for _unsafe_-prefixed additional fields Cover the round-trip (encoder spreads the map as top-level properties, decoder collects them back) and the symmetric check that non-prefixed extras are still dropped, for both ProcessAdditionalFields and UserDefinedAdditionalNodeFields. * Strip _unsafe_ fields from the scenario before it hits Flink _unsafe_ entries are frontend-only metadata (layout, UX preferences, render hints) that should be persisted in the saved scenario but never leak into the Flink job graph, logs or UI. Add UnsafePrefixedFields.deepStrip that recursively removes _unsafe_-prefixed keys from any JSON tree and expose CanonicalProcess.withoutUnsafeFields as a round-trip wrapper over it; both the remote and mini-cluster Flink job runners now apply it at the boundary. * Link sbt-git PR #243 (which introduced useConsoleForROGit) instead of the stale placeholder URL * Make `$toggleUserFlag` return the resolved flag value so Cypress can assert on it Previously the global helper dispatched the Redux action and returned `void`, forcing tests to separately poll the store to verify the toggle took effect. Now it returns a Promise that resolves to the post-dispatch value, and the Cypress `toggleUserFlag` command asserts the value matches when one was passed.
diff --git a/build.sbt b/build.sbt
@@ -1,3 +1,4 @@
+import com.github.sbt.git.SbtGit.GitKeys.useConsoleForROGit
 import com.typesafe.sbt.packager.SettingsHelper
 import com.typesafe.sbt.packager.docker.DockerPlugin.autoImport.dockerUsername
 import pl.project13.scala.sbt.JmhPlugin
@@ -54,6 +55,15 @@ crossScalaVersions := Nil
 
 ThisBuild / isSnapshot := version(_ contains "-SNAPSHOT").value
 
+// Workaround for sbt-git not supporting git worktrees (see https://github.com/sbt/sbt-git/pull/243).
+// In a worktree `.git` is a regular file (containing `gitdir: ...` pointing at the main repo's
+// per-worktree git dir), not a directory — and sbt-git's embedded JGit cannot parse that layout,
+// which breaks read-only git operations such as gitCurrentBranch / gitHeadCommit used below.
+// Flipping `useConsoleForROGit` to true makes sbt-git shell out to the `git` CLI for those reads,
+// which handles worktrees correctly. Detecting `.git` as a file keeps the default (JGit) path
+// for normal checkouts where `.git` is a directory.
+ThisBuild / useConsoleForROGit := (baseDirectory.value / ".git").isFile
+
 lazy val publishSettings = Seq(
   publishMavenStyle             := true,
   releasePublishArtifactsAction := PgpKeys.publishSigned.value,
diff --git a/common-api/src/main/scala/pl/touk/nussknacker/engine/api/CirceUtil.scala b/common-api/src/main/scala/pl/touk/nussknacker/engine/api/CirceUtil.scala
@@ -115,4 +115,26 @@ object CirceUtil {
   // that some value is null, but for people it generates a lot of unnecessary noise
   val humanReadablePrinter: Printer = Printer.spaces2.copy(dropNullValues = true)
 
+  // Helpers for a convention where a case class exposes `unsafeFields: Map[String, Json]` that is
+  // encoded/decoded as top-level JSON properties prefixed with `_unsafe_` (rather than under a
+  // nested field). Used to round-trip forward-compatible extension fields without schema changes.
+  object UnsafePrefixedFields {
+    val Prefix = "_unsafe_"
+
+    def extract(c: HCursor): Map[String, Json] =
+      c.keys.toList.flatten
+        .filter(_.startsWith(Prefix))
+        .flatMap(k => c.downField(k).as[Json].toOption.map(k -> _))
+        .toMap
+
+    // Only entries whose key already starts with [[Prefix]] are merged in — keeps a stray entry in
+    // the map (e.g. `"description" -> ...`) from clobbering a real top-level field during encode.
+    def merge(base: JsonObject, unsafeFields: Map[String, Json]): JsonObject =
+      unsafeFields.foldLeft(base) {
+        case (obj, (k, v)) if k.startsWith(Prefix) => obj.add(k, v)
+        case (obj, _)                              => obj
+      }
+
+  }
+
 }
diff --git a/common-api/src/main/scala/pl/touk/nussknacker/engine/api/MetaData.scala b/common-api/src/main/scala/pl/touk/nussknacker/engine/api/MetaData.scala
@@ -1,9 +1,9 @@
 package pl.touk.nussknacker.engine.api
 
-import io.circe.{Decoder, Encoder, HCursor}
+import io.circe.{Decoder, Encoder, HCursor, Json, JsonObject}
 import io.circe.generic.JsonCodec
 import io.circe.generic.extras.ConfiguredJsonCodec
-import io.circe.generic.extras.semiauto.{deriveConfiguredDecoder, deriveConfiguredEncoder}
+import io.circe.generic.extras.semiauto.deriveConfiguredDecoder
 import pl.touk.nussknacker.engine.api.CirceUtil._
 import pl.touk.nussknacker.engine.api.process.ProcessName
 
@@ -86,7 +86,8 @@ case class ProcessAdditionalFields(
     description: Option[String],
     properties: Map[String, String],
     metaDataType: String,
-    showDescription: Boolean = false
+    showDescription: Boolean = false,
+    unsafeFields: Map[String, Json] = Map.empty
 ) {
 
   def combineTypeSpecificProperties(typeSpecificData: TypeSpecificData): ProcessAdditionalFields = {
@@ -106,20 +107,33 @@ case class ProcessAdditionalFields(
 }
 
 object ProcessAdditionalFields {
-
-  // TODO: is this currently needed?
-  private case class OptionalProcessAdditionalFields(
-      description: Option[String],
-      properties: Option[Map[String, String]],
-      metaDataType: String,
-      showDescription: Boolean = false
-  )
-
-  implicit val circeDecoder: Decoder[ProcessAdditionalFields] =
-    deriveConfiguredDecoder[OptionalProcessAdditionalFields].map(opp =>
-      ProcessAdditionalFields(opp.description, opp.properties.getOrElse(Map()), opp.metaDataType, opp.showDescription)
+  import io.circe.syntax._
+
+  implicit val circeEncoder: Encoder.AsObject[ProcessAdditionalFields] = Encoder.AsObject.instance { f =>
+    UnsafePrefixedFields.merge(
+      JsonObject(
+        "description"     -> f.description.asJson,
+        "properties"      -> f.properties.asJson,
+        "metaDataType"    -> f.metaDataType.asJson,
+        "showDescription" -> f.showDescription.asJson,
+      ),
+      f.unsafeFields
     )
+  }
 
-  implicit val circeEncoder: Encoder[ProcessAdditionalFields] = deriveConfiguredEncoder
+  implicit val circeDecoder: Decoder[ProcessAdditionalFields] = Decoder.instance { c =>
+    for {
+      description     <- c.get[Option[String]]("description")
+      properties      <- c.get[Option[Map[String, String]]]("properties")
+      metaDataType    <- c.get[String]("metaDataType")
+      showDescription <- c.getOrElse[Boolean]("showDescription")(false)
+    } yield ProcessAdditionalFields(
+      description,
+      properties.getOrElse(Map.empty),
+      metaDataType,
+      showDescription,
+      UnsafePrefixedFields.extract(c)
+    )
+  }
 
 }
diff --git a/designer/client/cypress/support/process.ts b/designer/client/cypress/support/process.ts
@@ -1,6 +1,7 @@
 import { padStart } from "lodash";
 
-import type { Setting } from "../../src/reducers/userSettings";
+import type { GlobalToggleUserFlag } from "../../src/containers/SettingsInitializer";
+import type { UserSettings } from "../../src/reducers/userSettings";
 
 import Chainable = Cypress.Chainable;
 
@@ -327,13 +328,19 @@ function getNode(nameOrAlias: string) {
     });
 }
 
-function toggleUserFlag(flag: Setting, value?: boolean | undefined) {
+function toggleUserFlag(
+    flag: keyof UserSettings | (string & NonNullable<unknown>),
+    value?: boolean | undefined,
+): Chainable<boolean | "default"> {
     return cy
         .window()
         .its("$toggleUserFlag")
         .should("exist")
-        .then((toggleUserFlag) => {
-            toggleUserFlag(flag, value);
+        .then((toggleUserFlag: GlobalToggleUserFlag) => toggleUserFlag(flag, value))
+        .should((currentSubject) => {
+            if (value !== undefined) {
+                expect(currentSubject).to.eq(value);
+            }
         });
 }
 
diff --git a/designer/client/cypress/tsconfig.json b/designer/client/cypress/tsconfig.json
@@ -3,7 +3,8 @@
         "target": "es5",
         "lib": ["ES7", "dom"],
         "types": ["node", "cypress", "@frsource/cypress-plugin-visual-regression-diff", "@4tw/cypress-drag-drop"],
-        "resolveJsonModule": true
+        "resolveJsonModule": true,
+        "jsx": "react-jsx"
     },
     "include": ["**/*.ts"]
 }
diff --git a/designer/client/src/containers/SettingsInitializer.tsx b/designer/client/src/containers/SettingsInitializer.tsx
@@ -8,13 +8,15 @@ import { userSettingSet, userSettingsSetInitial, userSettingsToggle } from "../a
 import { useUserSettings } from "../common/useUserSettings";
 import LoaderSpinner from "../components/spinner/Spinner";
 import HttpService from "../http/HttpService/instance";
-import type { UserSettings } from "../reducers/userSettings";
+import type { Setting, UserSettings } from "../reducers/userSettings";
 import { waitForWindowValue } from "../reducers/waitForWindowValue";
 import { useAppDispatch } from "../store/storeHelpers";
 
+export type GlobalToggleUserFlag = (flag: Setting, value?: boolean) => Promise<boolean | "default">;
+
 declare global {
     interface Window {
-        $toggleUserFlag?: <K extends keyof UserSettings>(flag: K, value?: UserSettings[K]) => void;
+        $toggleUserFlag?: GlobalToggleUserFlag;
         $initialUserFlags?: UserSettings;
     }
 }
@@ -24,13 +26,17 @@ export function SettingsProvider({ children }: PropsWithChildren<unknown>): Reac
     const dispatch = useAppDispatch();
 
     useEffect(() => {
-        window.$toggleUserFlag = (flag, value) => {
-            if (value !== undefined) {
-                dispatch(userSettingSet(flag, value));
-            } else {
-                dispatch(userSettingsToggle([flag]));
-            }
-        };
+        window.$toggleUserFlag = (flag, value) =>
+            new Promise((resolve) => {
+                if (value !== undefined) {
+                    dispatch(userSettingSet(flag, value));
+                } else {
+                    dispatch(userSettingsToggle([flag]));
+                }
+                dispatch((_dispatch, getState) => {
+                    resolve(getState().userSettings.values[flag]);
+                });
+            });
         waitForWindowValue("$initialUserFlags").then((flags) => {
             dispatch(userSettingsSetInitial(flags));
         });
diff --git a/designer/client/src/types/node.ts b/designer/client/src/types/node.ts
@@ -7,6 +7,8 @@ type Type = "FragmentInput" | typeof StickyNoteType | "Source" | "Sink" | "Enric
 
 export type LayoutData = { x: number; y: number };
 
+export type UnsafeOptions = Record<`_unsafe_${string}`, unknown>;
+
 export interface BranchParams {
     branchId: string;
     parameters: Field[];
@@ -23,7 +25,7 @@ export type NodeType<F extends Field = Field> = {
         description?: string;
         layoutData?: LayoutData;
         creatorType?: string;
-    };
+    } & UnsafeOptions;
     parameters?: Parameter[];
     branchParameters?: BranchParams[];
     branchParametersTemplate?: BranchParametersTemplate;
diff --git a/designer/client/src/types/scenarioGraph.ts b/designer/client/src/types/scenarioGraph.ts
@@ -3,7 +3,7 @@ import type { TestCase } from "../reducers/graph/testCase";
 import type { ComponentGroup } from "./component";
 import type { TypingResult, UIParameter } from "./definition";
 import type { Edge, EdgeType } from "./edge";
-import type { NodeType, PropertiesType } from "./node";
+import type { NodeType, PropertiesType, UnsafeOptions } from "./node";
 
 export type ScenarioGraph = {
     nodes: NodeType[];
@@ -21,7 +21,7 @@ export type ProcessAdditionalFields = {
     properties: { [key in PropertiesConfigKeys]: string };
     metaDataType: string;
     showDescription?: boolean;
-};
+} & UnsafeOptions;
 
 export interface UIScenarioProperty {
     defaultValue?: string;
diff --git a/designer/deployment-manager-api/src/main/scala/pl/touk/nussknacker/engine/api/deployment/DMScenarioCommand.scala b/designer/deployment-manager-api/src/main/scala/pl/touk/nussknacker/engine/api/deployment/DMScenarioCommand.scala
@@ -37,14 +37,30 @@ case class DMValidateScenarioCommand(
   * We assume that validate was already called and was successful, currently savepointPath is flink specific, but we could
   * leverage this concept also for other engines
   */
-case class DMRunDeploymentCommand(
+case class DMRunDeploymentCommand private (
     processVersion: ProcessVersion,
     deploymentData: DeploymentData,
     canonicalProcess: CanonicalProcess,
     // TODO: job update strategy should be a part of deployment service logic, instead of DeploymentManager's
     updateStrategy: DeploymentUpdateStrategy
 ) extends DMScenarioCommand[Option[ExternalDeploymentId]]
 
+object DMRunDeploymentCommand {
+
+  // `_unsafe_*` fields are frontend-only metadata (layout, UX, render hints) that must be persisted
+  // in the saved scenario but never leak into the Flink/Lite job graph. Stripping them here — at the
+  // single boundary where we build the command — keeps every DeploymentManager honest without
+  // per-engine plumbing.
+  def apply(
+      processVersion: ProcessVersion,
+      deploymentData: DeploymentData,
+      canonicalProcess: CanonicalProcess,
+      updateStrategy: DeploymentUpdateStrategy
+  ): DMRunDeploymentCommand =
+    new DMRunDeploymentCommand(processVersion, deploymentData, canonicalProcess.withoutUnsafeFields, updateStrategy)
+
+}
+
 case class DMCancelDeploymentCommand(scenarioName: ProcessName, deploymentId: DeploymentId, user: User)
     extends DMScenarioCommand[Unit]
 
diff --git a/designer/server/src/main/scala/pl/touk/nussknacker/ui/api/description/NodesApiEndpoints.scala b/designer/server/src/main/scala/pl/touk/nussknacker/ui/api/description/NodesApiEndpoints.scala
@@ -1022,9 +1022,21 @@ object NodesApiEndpoints {
       implicit lazy val typingResultInJsonSchema: Schema[TypingResultInJson] = TypingDtoSchemas.typingResult.as
     }
 
-    implicit lazy val additionalInfoSchema: Schema[AdditionalInfo]                    = Schema.derived
-    implicit lazy val scenarioAdditionalFieldsSchema: Schema[ProcessAdditionalFields] = Schema.derived
-    implicit lazy val scenarioPropertiesSchema: Schema[ProcessProperties]             = Schema.derived.hidden(true)
+    // `unsafeFields` is the Scala container for top-level `_unsafe_*` JSON entries; it has no
+    // wire representation of its own, so we strip it from the derived schema entirely (marking
+    // it hidden with `.modify` leaves a dangling entry in `required`).
+    private def omitSchemaField[T](schema: Schema[T], fieldName: String): Schema[T] =
+      schema.schemaType match {
+        case p: SProduct[T] @unchecked =>
+          schema.copy(schemaType = SProduct(p.fields.filterNot(_.name.name == fieldName)))
+        case _ => schema
+      }
+
+    implicit lazy val additionalInfoSchema: Schema[AdditionalInfo]           = Schema.derived
+    implicit lazy val unsafeFieldsSchema: Schema[Map[String, io.circe.Json]] = Schema.anyObject
+    implicit lazy val scenarioAdditionalFieldsSchema: Schema[ProcessAdditionalFields] =
+      omitSchemaField(Schema.derived[ProcessAdditionalFields], "unsafeFields")
+    implicit lazy val scenarioPropertiesSchema: Schema[ProcessProperties] = Schema.derived.hidden(true)
 
     implicit lazy val parameterSchema: Schema[EvaluatedParameter]    = Schema.derived
     implicit lazy val edgeTypeSchema: Schema[EdgeType]               = Schema.derived
@@ -1055,15 +1067,18 @@ object NodesApiEndpoints {
       implicit lazy val fragmentClazzRefSchema: Schema[FragmentClazzRef] = Schema.derived
       implicit lazy val parameterValueCompileTimeValidationSchema: Schema[ParameterValueCompileTimeValidation] =
         Schema.derived
-      implicit lazy val parameterValueInputSchema: Schema[ParameterValueInput]                         = Schema.derived
-      implicit lazy val fragmentParameterSchema: Schema[FragmentParameter]                             = Schema.derived
-      implicit lazy val serviceRefSchema: Schema[ServiceRef]                                           = Schema.derived
-      implicit lazy val branchEndDefinitionSchema: Schema[BranchEndDefinition]                         = Schema.derived
-      implicit lazy val userDefinedAdditionalNodeFieldsSchema: Schema[UserDefinedAdditionalNodeFields] = Schema.derived
-      implicit lazy val layoutDataSchema: Schema[LayoutData]                                           = Schema.derived
-      implicit lazy val branchParametersSchema: Schema[BranchParameters]                               = Schema.derived
-      implicit lazy val fieldSchema: Schema[Field]                                                     = Schema.derived
-      implicit lazy val fragmentOutputVarDefinitionSchema: Schema[FragmentOutputVarDefinition]         = Schema.derived
+      implicit lazy val parameterValueInputSchema: Schema[ParameterValueInput] = Schema.derived
+      implicit lazy val fragmentParameterSchema: Schema[FragmentParameter]     = Schema.derived
+      implicit lazy val serviceRefSchema: Schema[ServiceRef]                   = Schema.derived
+      implicit lazy val branchEndDefinitionSchema: Schema[BranchEndDefinition] = Schema.derived
+      implicit lazy val layoutDataSchema: Schema[LayoutData]                   = Schema.derived
+
+      implicit lazy val userDefinedAdditionalNodeFieldsSchema: Schema[UserDefinedAdditionalNodeFields] =
+        omitSchemaField(Schema.derived[UserDefinedAdditionalNodeFields], "unsafeFields")
+
+      implicit lazy val branchParametersSchema: Schema[BranchParameters]                       = Schema.derived
+      implicit lazy val fieldSchema: Schema[Field]                                             = Schema.derived
+      implicit lazy val fragmentOutputVarDefinitionSchema: Schema[FragmentOutputVarDefinition] = Schema.derived
 
       //  Tapir currently supports only json schema v4 which has no way to declare discriminator
       //  We declare that each type of NodeData belongs to an enum with only one value as a workaround for this problem
diff --git a/scenario-api/src/main/scala/pl/touk/nussknacker/engine/canonicalgraph/CanonicalProcess.scala b/scenario-api/src/main/scala/pl/touk/nussknacker/engine/canonicalgraph/CanonicalProcess.scala
@@ -5,7 +5,7 @@ import io.circe.{Decoder, Encoder}
 import pl.touk.nussknacker.engine.api.{MetaData, NodeId}
 import pl.touk.nussknacker.engine.api.graph.ScenarioGraph
 import pl.touk.nussknacker.engine.api.process.ProcessName
-import pl.touk.nussknacker.engine.canonicalgraph.canonicalnode.CanonicalNode
+import pl.touk.nussknacker.engine.canonicalgraph.canonicalnode.{CanonicalNode, FlatNode}
 import pl.touk.nussknacker.engine.graph.expression.Expression
 import pl.touk.nussknacker.engine.graph.node
 import pl.touk.nussknacker.engine.graph.node._
@@ -108,6 +108,45 @@ case class CanonicalProcess(
 
   lazy val withoutDisabledNodes: CanonicalProcess = mapAllNodes(withoutDisabled)
 
+  // Strips `_unsafe_*` extension fields from metadata and every node's additionalFields.
+  // The 2-case NodeData match works thanks to `copySyntax` (shapeless LabelledGeneric `.copy`
+  // lifted to the `RealNodeData` sealed trait — the trick from FragmentResolver.prefixNodeData).
+  // The outer CanonicalNode match is unavoidable: each wrapper holds its nested children under
+  // differently-shaped fields (`nextFalse`, `nexts`, `outputs` …) that need recursion.
+  lazy val withoutUnsafeFields: CanonicalProcess = {
+    import pl.touk.nussknacker.engine.util.copySyntax._
+
+    def stripAdditional(af: UserDefinedAdditionalNodeFields) = af.copy(unsafeFields = Map.empty)
+
+    def stripData[T <: NodeData](n: T): T = (n.asInstanceOf[NodeData] match {
+      case e: RealNodeData  => e.copy(additionalFields = e.additionalFields.map(stripAdditional))
+      case b: BranchEndData => b
+    }).asInstanceOf[T]
+
+    def walk(n: CanonicalNode): CanonicalNode = n match {
+      case FlatNode(data) => FlatNode(stripData(data))
+      case fn: canonicalnode.FilterNode =>
+        fn.copy(data = stripData(fn.data), nextFalse = fn.nextFalse.map(walk))
+      case sn: canonicalnode.SwitchNode =>
+        sn.copy(
+          data = stripData(sn.data),
+          nexts = sn.nexts.map(c => c.copy(nodes = c.nodes.map(walk))),
+          defaultNext = sn.defaultNext.map(walk)
+        )
+      case sp: canonicalnode.SplitNode =>
+        sp.copy(data = stripData(sp.data), nexts = sp.nexts.map(_.map(walk)))
+      case fr: canonicalnode.Fragment =>
+        fr.copy(data = stripData(fr.data), outputs = fr.outputs.map { case (k, v) => k -> v.map(walk) })
+    }
+
+    copy(
+      metaData = metaData.copy(additionalFields = metaData.additionalFields.copy(unsafeFields = Map.empty)),
+      nodes = nodes.map(walk),
+      additionalBranches = additionalBranches.map(_.map(walk)),
+      stickyNotes = stickyNotes.map(sn => sn.copy(additionalFields = sn.additionalFields.map(stripAdditional)))
+    )
+  }
+
   def collectAllSources: List[SourceNodeData] = {
     val allNodes = collectAllNodes
     allNodes.flatMap(_.asSource) ++ allNodes.flatMap(_.asFragmentInputDefinition)
diff --git a/scenario-api/src/main/scala/pl/touk/nussknacker/engine/graph/node.scala b/scenario-api/src/main/scala/pl/touk/nussknacker/engine/graph/node.scala
diff --git a/scenario-api/src/main/scala/pl/touk/nussknacker/engine/util/copySyntax.scala b/scenario-api/src/main/scala/pl/touk/nussknacker/engine/util/copySyntax.scala
diff --git a/scenario-api/src/test/scala/pl/touk/nussknacker/engine/canonicalgraph/CanonicalProcessTest.scala b/scenario-api/src/test/scala/pl/touk/nussknacker/engine/canonicalgraph/CanonicalProcessTest.scala
diff --git a/scenario-api/src/test/scala/pl/touk/nussknacker/engine/marshall/ProcessMarshallerSpec.scala b/scenario-api/src/test/scala/pl/touk/nussknacker/engine/marshall/ProcessMarshallerSpec.scala
