kaoto-archive · Delawen · May 16, 2023 · May 10, 2023
diff --git a/api/src/test/resources/io/kaoto/backend/api/resource/kamelet-binding-multi.yaml b/api/src/test/resources/io/kaoto/backend/api/resource/kamelet-binding-multi.yaml
@@ -21,7 +21,6 @@ spec:
       kind: Broker
     properties:
       type: sometype
-
 ---
 apiVersion: camel.apache.org/v1alpha1
 kind: KameletBinding

diff --git a/api/src/test/resources/io/kaoto/backend/api/resource/kamelet-multi.yaml b/api/src/test/resources/io/kaoto/backend/api/resource/kamelet-multi.yaml
@@ -75,7 +75,6 @@ spec:
             clientIdentifier: '{{clientIdentifier}}'
             uploadMode: '{{uploadMode}}'
             accessToken: '{{accessToken}}'
-
 ---
 apiVersion: camel.apache.org/v1alpha1
 kind: Kamelet

diff --git a/...nd/api/service/deployment/generator/camelroute/IntegrationDeploymentGeneratorService.java b/...nd/api/service/deployment/generator/camelroute/IntegrationDeploymentGeneratorService.java
@@ -88,9 +88,15 @@ public String parse(final List<Step> steps, final Map<String, Object> metadata,
     @Override
     public String parse(List<StepParserService.ParseResult<Step>> flows) {
         StringBuilder sb = new StringBuilder();
-        flows.stream().forEachOrdered(stepParseResult -> sb.append(parse(stepParseResult.getSteps(),
-                stepParseResult.getMetadata(), stepParseResult.getParameters())
-                + System.lineSeparator() + "---" + System.lineSeparator()));
+
+        StepParserService.ParseResult<Step> last = flows.stream().reduce((a, b) -> b).get();
+        flows.stream().forEachOrdered(stepParseResult -> {
+            sb.append(
+                    parse(stepParseResult.getSteps(), stepParseResult.getMetadata(), stepParseResult.getParameters()));
+            if (stepParseResult != last) {
+                sb.append("---" + System.lineSeparator());
+            }
+        });
         return sb.toString();
     }
 

diff --git a/...ava/io/kaoto/backend/api/service/step/parser/camelroute/IntegrationStepParserService.java b/...ava/io/kaoto/backend/api/service/step/parser/camelroute/IntegrationStepParserService.java
@@ -96,7 +96,7 @@ public boolean appliesTo(final String yaml) {
         String[] kinds = new String[]{"Integration"};
 
         Pattern pattern = Pattern.compile(
-                "(\nkind:)(.+)\n", Pattern.CASE_INSENSITIVE);
+                System.lineSeparator()+ "(kind:)(.+)" + System.lineSeparator(), Pattern.CASE_INSENSITIVE);
         Matcher matcher = pattern.matcher(yaml);
         if (matcher.find()) {
             return Arrays.stream(kinds).anyMatch(

diff --git a/...o/backend/api/service/deployment/generator/camelroute/DeploymentGeneratorServiceTest.java b/...o/backend/api/service/deployment/generator/camelroute/DeploymentGeneratorServiceTest.java
@@ -8,7 +8,10 @@
 
 import javax.inject.Inject;
 
+import java.util.Arrays;
+
 import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.assertj.core.api.Assertions.assertThat;
 
 @QuarkusTest
 class DeploymentGeneratorServiceTest {
@@ -26,26 +29,65 @@ void ensureCatalog() {
 
     @Test
     void parse() {
-        String yaml = "apiVersion: camel.apache.org/v1\n"
-                + "kind: Integration\n"
-                + "metadata:\n"
-                + "  name: hello.yaml\n"
-                + "spec:\n"
-                + "  flows:\n"
-                + "  - from:\n"
-                + "      uri: timer:tick\n"
-                + "      parameters:\n"
-                + "        period: '5000'\n"
-                + "      steps:\n"
-                + "      - to:\n"
-                + "          uri: log:tick\n";
+        String yaml = String.join(System.lineSeparator(), Arrays.asList(
+                "apiVersion: camel.apache.org/v1",
+                "kind: Integration",
+                "metadata:",
+                "  name: hello.yaml",
+                "spec:",
+                "  flows:",
+                "  - from:",
+                "      uri: timer:tick",
+                "      parameters:",
+                "        period: '5000'",
+                "      steps:",
+                "      - to:",
+                "          uri: log:tick")) + System.lineSeparator();
 
         var parsed = stepParserService.deepParse(yaml);
 
         var yaml2 = deploymentGeneratorService.parse(parsed.getSteps(),
                 parsed.getMetadata(), parsed.getParameters());
 
-        assertEquals(yaml, yaml2);
+        assertThat(yaml).isEqualToNormalizingNewlines(yaml2);
+    }
+
+    @Test
+    void parseFlows() {
+        String yaml = String.join(System.lineSeparator(), Arrays.asList(
+                "apiVersion: camel.apache.org/v1",
+                "kind: Integration",
+                "metadata:",
+                "  name: hello.yaml",
+                "spec:",
+                "  flows:",
+                "  - from:",
+                "      uri: timer:tick",
+                "      parameters:",
+                "        period: '5000'",
+                "      steps:",
+                "      - to:",
+                "          uri: log:tick",
+                "---",
+                "apiVersion: camel.apache.org/v1",
+                "kind: Integration",
+                "metadata:",
+                "  name: bye.yaml",
+                "spec:",
+                "  flows:",
+                "  - from:",
+                "      uri: timer:tock",
+                "      parameters:",
+                "        period: '3000'",
+                "      steps:",
+                "      - to:",
+                "          uri: log:tock")) + System.lineSeparator();
+
+        var parsed = stepParserService.getParsedFlows(yaml);
+
+        var yaml2 = deploymentGeneratorService.parse(parsed);
+
+        assertThat(yaml).isEqualToNormalizingNewlines(yaml2);
     }
 
     @Inject

diff --git a/...nd/api/service/deployment/generator/kamelet/KameletBindingDeploymentGeneratorService.java b/...nd/api/service/deployment/generator/kamelet/KameletBindingDeploymentGeneratorService.java
@@ -211,14 +211,15 @@ public Status getStatus(final CustomResource cr) {
     @Override
     public String parse(List<StepParserService.ParseResult<Step>> flows) {
         StringBuilder sb = new StringBuilder();
+
+        StepParserService.ParseResult<Step> last = flows.stream().reduce((a, b) -> b).get();
         flows.stream().forEachOrdered(stepParseResult -> {
-            if (!sb.isEmpty()) {
-                sb.append(System.lineSeparator());
+            sb.append(parse(stepParseResult.getSteps(), stepParseResult.getMetadata(),
+                    stepParseResult.getParameters()));
+            if (stepParseResult != last) {
                 sb.append("---");
                 sb.append(System.lineSeparator());
             }
-            sb.append(parse(stepParseResult.getSteps(), stepParseResult.getMetadata(),
-                    stepParseResult.getParameters()));
         });
         return sb.toString();
     }

diff --git a/...o/backend/api/service/deployment/generator/kamelet/KameletDeploymentGeneratorService.java b/...o/backend/api/service/deployment/generator/kamelet/KameletDeploymentGeneratorService.java
@@ -85,13 +85,14 @@ public String parse(final List<Step> steps,
     @Override
     public String parse(List<StepParserService.ParseResult<Step>> flows) {
         StringBuilder res = new StringBuilder("");
+
+        StepParserService.ParseResult<Step> last = flows.stream().reduce((a, b) -> b).get();
         flows.stream().forEachOrdered(parseResult -> {
-            if (!res.isEmpty()) {
-                res.append(System.lineSeparator());
+            res.append(parse(parseResult.getSteps(), parseResult.getMetadata(), parseResult.getParameters()));
+            if (parseResult != last) {
                 res.append("---");
                 res.append(System.lineSeparator());
             }
-            res.append(parse(parseResult.getSteps(), parseResult.getMetadata(), parseResult.getParameters()));
         });
         return res.toString();
     }

diff --git a/...io/kaoto/backend/api/service/step/parser/kamelet/KameletBindingStepParserServiceTest.java b/...io/kaoto/backend/api/service/step/parser/kamelet/KameletBindingStepParserServiceTest.java
@@ -4,7 +4,6 @@
 import io.kaoto.backend.api.metadata.catalog.StepCatalog;
 import io.kaoto.backend.api.service.deployment.generator.kamelet.KameletBindingDeploymentGeneratorService;
 import io.quarkus.test.junit.QuarkusTest;
-
 import org.junit.jupiter.api.BeforeAll;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
@@ -17,13 +16,15 @@
 
 import static org.assertj.core.api.Assertions.assertThat;
 import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertTrue;
 import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertTrue;
 
 @QuarkusTest
 class KameletBindingStepParserServiceTest {
 
-    private static String binding;
+    private static String twitterSearchSourceBinding;
+    private static String knativeBinding;
+    private static String multiRouteBinding;
 
     @Inject
     private KameletBindingStepParserService service;
@@ -40,10 +41,18 @@ public void setStepCatalog(final StepCatalog catalog) {
 
     @BeforeAll
     static void setup() throws URISyntaxException, IOException {
-        binding = Files.readString(Path.of(
+        twitterSearchSourceBinding = Files.readString(Path.of(
                 KameletBindingStepParserServiceTest.class.getResource(
                                 "twitter-search-source-binding.yaml")
                         .toURI()));
+        knativeBinding = Files.readString(Path.of(
+                KameletBindingStepParserServiceTest.class.getResource(
+                                "knative-binding.yaml")
+                        .toURI()));
+        multiRouteBinding = Files.readString(Path.of(
+                KameletBindingStepParserServiceTest.class.getResource(
+                                "multi-route-binding.yaml")
+                        .toURI()));
     }
 
     @BeforeEach
@@ -53,32 +62,42 @@ void ensureCatalog() {
 
     @Test
     void parse() throws JsonProcessingException {
-        var parsed = service.deepParse(binding);
+        var parsed = service.deepParse(twitterSearchSourceBinding);
         assertEquals(3, parsed.getSteps().size());
         assertEquals("twitter-search-source", parsed.getSteps().get(0).getName());
         assertEquals("aws-translate-action", parsed.getSteps().get(1).getName());
         assertEquals("knative", parsed.getSteps().get(2).getName());
         assertEquals("Kamelet Binding generated by Kaoto", parsed.getMetadata().get("name"));
         assertTrue(parsed.getParameters().isEmpty());
         var yaml = deploymentService.parse(parsed.getSteps(), parsed.getMetadata(), parsed.getParameters());
+        assertThat(yaml).isEqualToNormalizingNewlines(twitterSearchSourceBinding);
+    }
 
-        assertThat(yaml).isEqualToNormalizingNewlines(binding);
+    @Test
+    void parseMultipleFlows() throws JsonProcessingException {
+        var parsed = service.getParsedFlows(multiRouteBinding);
+        assertEquals(2, parsed.size());
+        assertEquals("Kamelet Binding generated by Kaoto", parsed.get(0).getMetadata().get("name"));
+        assertEquals("Kamelet Binding timer to log", parsed.get(1).getMetadata().get("name"));
+        assertTrue(parsed.get(0).getParameters().isEmpty());
+        assertTrue(parsed.get(1).getParameters().isEmpty());
+        var yaml = deploymentService.parse(parsed);
+
+        assertThat(yaml).isEqualToNormalizingNewlines(multiRouteBinding);
     }
 
     @Test
     void parseKnative() throws URISyntaxException, IOException {
-        final String binding = Files.readString(
-                Path.of(KameletBindingStepParserServiceTest.class.getResource("knative-binding.yaml").toURI()));
-        var parsed = service.deepParse(binding);
+        var parsed = service.deepParse(knativeBinding);
         assertEquals(2, parsed.getSteps().size());
-       var yaml = deploymentService.parse(parsed.getSteps(), parsed.getMetadata(), parsed.getParameters());
+        var yaml = deploymentService.parse(parsed.getSteps(), parsed.getMetadata(), parsed.getParameters());
 
-       assertThat(yaml).isEqualToNormalizingNewlines(binding);
+        assertThat(yaml).isEqualToNormalizingNewlines(knativeBinding);
     }
 
     @Test
     void appliesTo() {
-        assertTrue(service.appliesTo(binding));
+        assertTrue(service.appliesTo(twitterSearchSourceBinding));
         assertFalse(service.appliesTo("whatever"));
     }
 }
diff --git a/...t/java/io/kaoto/backend/api/service/step/parser/kamelet/KameletStepParserServiceTest.java b/...t/java/io/kaoto/backend/api/service/step/parser/kamelet/KameletStepParserServiceTest.java
@@ -1,5 +1,6 @@
 package io.kaoto.backend.api.service.step.parser.kamelet;
 
+import com.fasterxml.jackson.core.JsonProcessingException;
 import io.kaoto.backend.api.metadata.catalog.StepCatalog;
 import io.kaoto.backend.api.service.deployment.generator.kamelet.KameletDeploymentGeneratorService;
 import io.kaoto.backend.metadata.ParseCatalog;
@@ -37,7 +38,7 @@ class KameletStepParserServiceTest {
     private static String incomplete;
     private static String kameletEIP;
     private static String kameletJq;
-
+    private static String multiKamelet;
 
     private CamelRouteParseCatalog parseCatalog;
     @Inject
@@ -76,6 +77,10 @@ static void setup() throws URISyntaxException, IOException {
                 KameletBindingStepParserServiceTest.class.getResource(
                                 "jq.kamelet.yaml")
                         .toURI()));
+        multiKamelet = Files.readString(Path.of(
+                KameletBindingStepParserServiceTest.class.getResource(
+                                "multi-kamelets.yaml")
+                        .toURI()));
     }
 
     @BeforeEach
@@ -175,6 +180,15 @@ void deepParse() {
         assertEquals("string", accessToken.getType());
     }
 
+    @Test
+    void parseMultipleFlows() throws JsonProcessingException {
+        var parsed = service.getParsedFlows(multiKamelet);
+        assertEquals(2, parsed.size());
+        var yaml = deploymentService.parse(parsed);
+
+        assertThat(yaml).isEqualToNormalizingWhitespace(multiKamelet);
+    }
+
     @Test
     void goAndBackAgain() {
         var parsed = service.deepParse(kamelet);

diff --git a/.../src/test/java/io/kaoto/backend/metadata/parser/step/kamelet/KameletParseCatalogTest.java b/.../src/test/java/io/kaoto/backend/metadata/parser/step/kamelet/KameletParseCatalogTest.java
@@ -139,7 +139,7 @@ void localFolder() throws URISyntaxException {
                                 .toURI()));
         List<Step> steps = kameletParser.parse().join().stream().filter(Objects::nonNull).collect(Collectors.toList());
 
-        assertEquals(4, steps.size());
+        assertEquals(5, steps.size());
     }
 
     @Test