Working on REST impl.

- differentiate between push-send and pull-send

ragconnect.tests/build.gradle

@@ -25,7 +25,16 @@ dependencies {
     testImplementation group: 'org.junit.jupiter', name: 'junit-jupiter-api', version: '5.4.0'
     testRuntimeOnly group: 'org.junit.jupiter', name: 'junit-jupiter-engine', version: '5.4.0'
     testImplementation group: 'org.assertj', name: 'assertj-core', version: '3.12.1'
+
+    // mqtt
     testImplementation group: 'org.fusesource.mqtt-client', name: 'mqtt-client', version: '1.15'
+
+    // rest and client
+    testImplementation group: 'com.sparkjava', name: 'spark-core', version: '2.9.2'
+    testImplementation group: 'org.apache.logging.log4j', name: 'log4j-slf4j-impl', version: '2.11.2'
+    testImplementation group: 'org.glassfish.jersey.core', name: 'jersey-client', version: '2.31'
+    testImplementation group: 'org.glassfish.jersey.inject', name: 'jersey-hk2', version: '2.31'
+
     testImplementation group: 'net.sf.beaver', name: 'beaver-rt', version: '0.9.11'
     api group: 'com.google.protobuf', name: 'protobuf-java', version: '3.0.0'
 }
@@ -97,7 +106,7 @@ task compileExampleTest(type: RelastTest) {
             'src/test/02-after-ragconnect/example/RagConnect.jadd'
 }
 
-testClasses.dependsOn compileExampleTest
+compileTestJava.dependsOn compileExampleTest
 compileExampleTest.dependsOn preprocessExampleTest
 
 // --- Test: default-only-read ---
@@ -113,8 +122,7 @@ task preprocessDefaultOnlyReadTest(type: JavaExec, group: 'verification') {
     args '--o=src/test/02-after-ragconnect/defaultOnlyRead',
             'src/test/01-input/defaultOnlyRead/Test.relast',
             'src/test/01-input/defaultOnlyRead/Test.connect',
-            '--rootNode=A',
-            '--verbose'
+            '--rootNode=A'
 }
 
 task compileDefaultOnlyReadTest(type: RelastTest) {
@@ -128,7 +136,7 @@ task compileDefaultOnlyReadTest(type: RelastTest) {
             'src/test/02-after-ragconnect/defaultOnlyRead/RagConnect.jadd'
 }
 
-testClasses.dependsOn compileDefaultOnlyReadTest
+compileTestJava.dependsOn compileDefaultOnlyReadTest
 compileDefaultOnlyReadTest.dependsOn preprocessDefaultOnlyReadTest
 
 // --- Test: default-only-write ---
@@ -144,8 +152,7 @@ task preprocessDefaultOnlyWriteTest(type: JavaExec, group: 'verification') {
     args '--o=src/test/02-after-ragconnect/defaultOnlyWrite',
             'src/test/01-input/defaultOnlyWrite/Test.relast',
             'src/test/01-input/defaultOnlyWrite/Test.connect',
-            '--rootNode=A',
-            '--verbose'
+            '--rootNode=A'
 }
 
 task compileDefaultOnlyWriteTest(type: RelastTest) {
@@ -160,7 +167,7 @@ task compileDefaultOnlyWriteTest(type: RelastTest) {
             'src/test/02-after-ragconnect/defaultOnlyWrite/RagConnect.jadd'
 }
 
-testClasses.dependsOn compileDefaultOnlyWriteTest
+compileTestJava.dependsOn compileDefaultOnlyWriteTest
 compileDefaultOnlyWriteTest.dependsOn preprocessDefaultOnlyWriteTest
 
 // --- Test: read1write2 ---
@@ -192,7 +199,7 @@ task compileRead1Write2Test(type: RelastTest) {
             'src/test/02-after-ragconnect/read1write2/RagConnect.jadd'
 }
 
-testClasses.dependsOn compileRead1Write2Test
+compileTestJava.dependsOn compileRead1Write2Test
 compileRead1Write2Test.dependsOn preprocessRead1Write2Test
 
 // --- Test: read2write1 ---
@@ -208,7 +215,7 @@ task preprocessRead2Write1Test(type: JavaExec, group: 'verification') {
     args '--o=src/test/02-after-ragconnect/read2write1',
             'src/test/01-input/read2write1/Test.relast',
             'src/test/01-input/read2write1/Test.connect',
-            '--rootNode=A', '--verbose',
+            '--rootNode=A',
             '--logReads', '--logWrites'
 }
 
@@ -224,7 +231,7 @@ task compileRead2Write1Test(type: RelastTest) {
             'src/test/02-after-ragconnect/read2write1/RagConnect.jadd'
 }
 
-testClasses.dependsOn compileRead2Write1Test
+compileTestJava.dependsOn compileRead2Write1Test
 compileRead2Write1Test.dependsOn preprocessRead2Write1Test
 
 // --- Test: via ---
@@ -232,6 +239,7 @@ task preprocessViaTest(type: JavaExec, group: 'verification') {
     doFirst {
         delete 'src/test/02-after-ragconnect/via/Test.relast',
                 'src/test/02-after-ragconnect/via/MqttHandler.java',
+                'src/test/02-after-ragconnect/via/RestHandler.java',
                 'src/test/02-after-ragconnect/via/RagConnect.jadd'
     }
 
@@ -253,8 +261,9 @@ task compileViaTest(type: RelastTest) {
     packageName = 'via.ast'
     moreInputFiles 'src/test/01-input/via/Test.jadd',
             'src/test/02-after-ragconnect/via/MqttHandler.jadd',
+            'src/test/02-after-ragconnect/via/RestHandler.jadd',
             'src/test/02-after-ragconnect/via/RagConnect.jadd'
 }
 
-testClasses.dependsOn compileViaTest
+compileTestJava.dependsOn compileViaTest
 compileViaTest.dependsOn preprocessViaTest

ragconnect.tests/src/test/01-input/via/Test.connect

@@ -2,27 +2,33 @@ receive A.Mqtt2MqttInput via mqtt using MarkMqttInput ;
 receive A.Rest2RestInput via rest using MarkRestInput ;
 receive A.Mqtt2RestInput via mqtt using MarkMqttInput ;
 receive A.Rest2MqttInput via rest using MarkRestInput ;
+receive A.Both2BothInput via mqtt using MarkMqttInput ;
+receive A.Both2BothInput via rest using MarkRestInput ;
 
 send A.Mqtt2MqttOutput via mqtt using MarkMqttOutput ;
 send A.Rest2RestOutput via rest using MarkRestOutput ;
 send A.Mqtt2RestOutput via rest using MarkRestOutput ;
 send A.Rest2MqttOutput via mqtt using MarkMqttOutput ;
+send A.Both2RestOutput via rest using MarkRestOutput ;
+send A.Both2MqttOutput via mqtt using MarkMqttOutput ;
 
 A.Mqtt2MqttOutput canDependOn A.Mqtt2MqttInput as dependencyMqtt2Mqtt ;
 A.Rest2RestOutput canDependOn A.Rest2RestInput as dependencyRest2Rest ;
 A.Mqtt2RestOutput canDependOn A.Mqtt2RestInput as dependencyMqtt2Rest ;
 A.Rest2MqttOutput canDependOn A.Rest2MqttInput as dependencyRest2Mqtt ;
+A.Both2RestOutput canDependOn A.Both2BothInput as dependencyBoth2Rest ;
+A.Both2MqttOutput canDependOn A.Both2BothInput as dependencyBoth2Mqtt ;
 
 MarkMqttInput maps String s to String {:
-  return "FromMqtt" + s;
+  return "FromMqtt-" + s;
 :}
 MarkRestInput maps String s to String {:
-  return "FromRest" + s;
+  return "FromRest-" + s;
 :}
 
 MarkMqttOutput maps String s to String {:
-  return s + "ToMqtt";
+  return s + "-ToMqtt";
 :}
 MarkRestOutput maps String s to String {:
-  return s + "ToRest";
+  return s + "-ToRest";
 :}

ragconnect.tests/src/test/01-input/via/Test.jadd

 aspect Computation {
-  syn lazy String A.getMqtt2MqttOutput() = getMqtt2MqttInput() + "M2M" ;
-  syn lazy String A.getRest2RestOutput() = getRest2RestInput() + "R2R" ;
-  syn lazy String A.getMqtt2RestOutput() = getMqtt2RestInput() + "M2R" ;
-  syn lazy String A.getRest2MqttOutput() = getRest2MqttInput() + "R2M" ;
+  syn lazy String A.getMqtt2MqttOutput() = getMqtt2MqttInput() + "-M2M" ;
+  syn lazy String A.getRest2RestOutput() = getRest2RestInput() + "-R2R" ;
+  syn lazy String A.getMqtt2RestOutput() = getMqtt2RestInput() + "-M2R" ;
+  syn lazy String A.getRest2MqttOutput() = getRest2MqttInput() + "-R2M" ;
+  syn lazy String A.getBoth2MqttOutput() = getBoth2BothInput() + "-B2M" ;
+  syn lazy String A.getBoth2RestOutput() = getBoth2BothInput() + "-B2R" ;
 }

ragconnect.tests/src/test/01-input/via/Test.relast

 A ::= <Mqtt2MqttInput> /<Mqtt2MqttOutput>/
       <Rest2RestInput> /<Rest2RestOutput>/
       <Mqtt2RestInput> /<Mqtt2RestOutput>/
-      <Rest2MqttInput> /<Rest2MqttOutput>/;
+      <Rest2MqttInput> /<Rest2MqttOutput>/
+      <Both2BothInput> /<Both2MqttOutput>/ /<Both2RestOutput>/;

ragconnect.tests/src/test/java/org/jastadd/ros2rag/tests/AbstractMqttTest.java → ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/AbstractMqttTest.java

-package org.jastadd.ros2rag.tests;
+package org.jastadd.ragconnect.tests;
 
 import defaultOnlyRead.ast.MqttHandler;
 import org.junit.jupiter.api.BeforeAll;

ragconnect.tests/src/test/java/org/jastadd/ros2rag/tests/DefaultOnlyReadTest.java → ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/DefaultOnlyReadTest.java

-package org.jastadd.ros2rag.tests;
+package org.jastadd.ragconnect.tests;
 
 import defaultOnlyRead.ast.A;
 import defaultOnlyRead.ast.BoxedTypes;

ragconnect.tests/src/test/java/org/jastadd/ros2rag/tests/DefaultOnlyWriteTest.java → ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/DefaultOnlyWriteTest.java

-package org.jastadd.ros2rag.tests;
+package org.jastadd.ragconnect.tests;
 
 import defaultOnlyWrite.ast.A;
 import defaultOnlyWrite.ast.BoxedTypesSyn;

ragconnect.tests/src/test/java/org/jastadd/ros2rag/tests/Errors.java → ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/Errors.java

-package org.jastadd.ros2rag.tests;
+package org.jastadd.ragconnect.tests;
 
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
@@ -15,8 +15,8 @@ import java.util.Collections;
 import java.util.List;
 import java.util.stream.Collectors;
 
-import static org.jastadd.ros2rag.tests.TestUtils.exec;
-import static org.jastadd.ros2rag.tests.TestUtils.readFile;
+import static org.jastadd.ragconnect.tests.TestUtils.exec;
+import static org.jastadd.ragconnect.tests.TestUtils.readFile;
 import static org.junit.jupiter.api.Assertions.assertTrue;
 
 class Errors {
@@ -24,7 +24,7 @@ class Errors {
   private static final Logger logger = LogManager.getLogger(Errors.class);
   private static final String FILENAME_PATTERN = "$FILENAME";
   private static final String INPUT_DIRECTORY = "./src/test/01-input/errors/";
-  private static final String OUTPUT_DIRECTORY = "./src/test/02-after-ros2rag/errors/";
+  private static final String OUTPUT_DIRECTORY = "./src/test/02-after-ragconnect/errors/";
 
   @BeforeAll
   public static void createOutputDirectory() {
@@ -40,21 +40,21 @@ class Errors {
   @SuppressWarnings("SameParameterValue")
   private void test(String name, String rootNode) throws IOException {
     String grammarFile = INPUT_DIRECTORY + name + ".relast";
-    String ros2ragFile = INPUT_DIRECTORY + name + ".ros2rag";
+    String ragconnectFile = INPUT_DIRECTORY + name + ".connect";
     String outFile = OUTPUT_DIRECTORY + name + ".out";
     String expectedFile = INPUT_DIRECTORY + name + ".expected";
 
     try {
       logger.debug("user.dir: {}", System.getProperty("user.dir"));
       String[] args = {
-          "--outputDir=" + OUTPUT_DIRECTORY,
-          "--inputGrammar=" + grammarFile,
-          "--inputRos2Rag=" + ros2ragFile,
+          "--o=" + OUTPUT_DIRECTORY,
+          grammarFile,
+          ragconnectFile,
           "--rootNode=" + rootNode,
           "--verbose"
       };
       int returnValue = exec(Compiler.class, args, new File(outFile));
-      Assertions.assertEquals(1, returnValue, "Ros2Rag did not return with value 1");
+      Assertions.assertEquals(1, returnValue, "RagConnect did not return with value 1");
     } catch (IOException | InterruptedException e) {
       e.printStackTrace();
     }
@@ -78,7 +78,7 @@ class Errors {
     // FIXME errors not handled correctly at the moment
 //    Assertions.assertLinesMatch(expectedList, outList);
 
-    logger.info("ros2rag for " + name + " returned:\n{}", out);
+    logger.info("ragconnect for " + name + " returned:\n{}", out);
   }
 
 }

ragconnect.tests/src/test/java/org/jastadd/ros2rag/tests/ExampleTest.java → ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/ExampleTest.java

-package org.jastadd.ros2rag.tests;
+package org.jastadd.ragconnect.tests;
 
 import com.google.protobuf.InvalidProtocolBufferException;
 import config.Config.RobotConfig;

ragconnect.tests/src/test/java/org/jastadd/ros2rag/tests/Read1Write2Test.java → ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/Read1Write2Test.java

-package org.jastadd.ros2rag.tests;
+package org.jastadd.ragconnect.tests;
 
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;

ragconnect.tests/src/test/java/org/jastadd/ros2rag/tests/Read2Write1Test.java → ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/Read2Write1Test.java

-package org.jastadd.ros2rag.tests;
+package org.jastadd.ragconnect.tests;
 
 import org.junit.jupiter.api.AfterEach;
 import org.junit.jupiter.api.Test;

ragconnect.tests/src/test/java/org/jastadd/ros2rag/tests/TestUtils.java → ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/TestUtils.java

-package org.jastadd.ros2rag.tests;
+package org.jastadd.ragconnect.tests;
 
 import java.io.File;
 import java.io.IOException;

ragconnect.tests/src/test/java/org/jastadd/ragconnect/tests/ViaTest.java

+package org.jastadd.ragconnect.tests;
+
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.Tag;
+import org.junit.jupiter.api.Test;
+import via.ast.A;
+import via.ast.MqttHandler;
+
+import javax.ws.rs.client.Client;
+import javax.ws.rs.client.ClientBuilder;
+import javax.ws.rs.client.Entity;
+import javax.ws.rs.client.WebTarget;
+import javax.ws.rs.core.MediaType;
+import java.io.IOException;
+import java.util.concurrent.TimeUnit;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/**
+ * Test case "via".
+ *
+ * @author rschoene - Initial contribution
+ */
+@Tag("rest")
+public class ViaTest extends AbstractMqttTest {
+
+  private static final int REST_PORT = 9002;
+
+  private static final String TOPIC_MQTT_2_MQTT_RECEIVE = "mqtt2mqtt/receive";
+  private static final String PATH_REST_2_REST_RECEIVE = "rest2rest/receive";
+  private static final String TOPIC_MQTT_2_REST_RECEIVE = "mqtt2rest/receive";
+  private static final String PATH_REST_2_MQTT_RECEIVE = "rest2mqtt/receive";
+
+  private static final String TOPIC_MQTT_2_MQTT_SEND = "mqtt2mqtt/send";
+  private static final String PATH_REST_2_REST_SEND = "rest2rest/send";
+  private static final String PATH_MQTT_2_REST_SEND = "mqtt2rest/send";
+  private static final String TOPIC_REST_2_MQTT_SEND = "rest2mqtt/send";
+  private static final String REST_SERVER_BASE_URL = "http://localhost:" + REST_PORT + "/";
+
+  private MqttHandler handler;
+  private A model;
+  private ReceiverData dataMqtt2Mqtt;
+  private ReceiverData dataRest2Mqtt;
+  private WebTarget dataRest2Rest;
+  private WebTarget dataMqtt2Rest;
+  private WebTarget senderRest2Rest;
+  private WebTarget senderRest2Mqtt;
+
+  @AfterEach
+  public void closeConnections() {
+    if (handler != null) {
+      handler.close();
+    }
+    if (model != null) {
+      model.MqttCloseConnections();
+      model.RestCloseConnections();
+    }
+  }
+
+  @Test
+  public void buildModel() {
+    createModel();
+  }
+
+  @Test
+  public void communicateSendInitialValue() throws IOException, InterruptedException {
+    createModel();
+    setupReceiverAndConnect(true);
+
+    // check initial value
+    TestUtils.waitForMqtt();
+    checkData(1, "100-M2M-ToMqtt", "200-R2R-ToRest", "300-M2R-ToRest", 1, "400-R2M-ToMqtt");
+
+    sendData("101", "201", "301", "401");
+
+    // check new value
+    TestUtils.waitForMqtt();
+    checkData(2, "FromMqtt-101-M2M-ToMqtt", "FromRest-201-R2R-ToRest", "FromMqtt-301-M2R-ToRest", 2, "FromRest-401-R2M-ToMqtt");
+  }
+
+  @Test
+  public void communicateOnlyUpdatedValue() throws IOException, InterruptedException {
+    createModel();
+    setupReceiverAndConnect(false);
+
+    // check initial value
+    TestUtils.waitForMqtt();
+    checkData(0, null, "200-R2R-ToRest", "300-M2R-ToRest", 0, null);
+
+    sendData("111", "211", "311", "411");
+
+    // check new value
+    TestUtils.waitForMqtt();
+    checkData(1, "FromMqtt-111-M2M-ToMqtt", "FromRest-211-R2R-ToRest", "FromMqtt-311-M2R-ToRest", 1, "FromRest-411-R2M-ToMqtt");
+  }
+
+  private void sendData(String inputMqtt2Mqtt, String inputRest2Rest, String inputMqtt2Rest, String inputRest2Mqtt) {
+    handler.publish(TOPIC_MQTT_2_MQTT_RECEIVE, inputMqtt2Mqtt.getBytes());
+    senderRest2Rest.request().put(Entity.entity(inputRest2Rest, MediaType.TEXT_PLAIN_TYPE));
+    handler.publish(TOPIC_MQTT_2_REST_RECEIVE, inputMqtt2Rest.getBytes());
+    senderRest2Mqtt.request().put(Entity.entity(inputRest2Mqtt, MediaType.TEXT_PLAIN_TYPE));
+  }
+
+  private void checkData(int numberOfMqtt2MqttValues, String mqtt2MqttValue, String rest2RestValue, String mqtt2RestValue, int numberOfRest2MqttValues, String rest2MqttValue) {
+    dataMqtt2Mqtt.assertEqualData(numberOfMqtt2MqttValues, mqtt2MqttValue);
+    dataRest2Mqtt.assertEqualData(numberOfRest2MqttValues, rest2MqttValue);
+    assertEquals(rest2RestValue, readRest2Rest());
+    assertEquals(mqtt2RestValue, readMqtt2Rest());
+  }
+
+  private String readRest2Rest() {
+    return dataRest2Rest.request().get().readEntity(String.class);
+  }
+
+  private String readMqtt2Rest() {
+    return dataMqtt2Rest.request().get().readEntity(String.class);
+  }
+
+  private void createModel() {
+    // Setting value for Input without dependencies does not trigger any updates
+    model = new A();
+    model.setMqtt2MqttInput("100");
+    model.setRest2RestInput("200");
+    model.setMqtt2RestInput("300");
+    model.setRest2MqttInput("400");
+  }
+
+  private void setupReceiverAndConnect(boolean writeCurrentValue) throws IOException {
+    model.MqttSetHost(TestUtils.getMqttHost());
+    model.RestSetPort(REST_PORT);
+    assertTrue(model.MqttWaitUntilReady(2, TimeUnit.SECONDS));
+
+    handler = new MqttHandler().dontSendWelcomeMessage().setHost(TestUtils.getMqttHost());
+    assertTrue(handler.waitUntilReady(2, TimeUnit.SECONDS));
+
+    model.addDependencyMqtt2Mqtt(model);
+    model.addDependencyRest2Rest(model);
+    model.addDependencyMqtt2Rest(model);
+    model.addDependencyRest2Mqtt(model);
+
+    dataMqtt2Mqtt = new ReceiverData();
+    dataRest2Mqtt = new ReceiverData();
+
+    handler.newConnection(TOPIC_MQTT_2_MQTT_SEND, bytes -> {
+      dataMqtt2Mqtt.numberOfStringValues += 1;
+      dataMqtt2Mqtt.lastStringValue = new String(bytes);
+    });
+    handler.newConnection(TOPIC_REST_2_MQTT_SEND, bytes -> {
+      dataRest2Mqtt.numberOfStringValues += 1;
+      dataRest2Mqtt.lastStringValue = new String(bytes);
+    });
+
+    Client client = ClientBuilder.newClient();
+    dataRest2Rest = client.target(REST_SERVER_BASE_URL + PATH_REST_2_REST_SEND);
+    dataMqtt2Rest = client.target(REST_SERVER_BASE_URL + PATH_MQTT_2_REST_SEND);
+    senderRest2Rest = client.target(REST_SERVER_BASE_URL + PATH_REST_2_REST_RECEIVE);
+    senderRest2Mqtt = client.target(REST_SERVER_BASE_URL + PATH_REST_2_MQTT_RECEIVE);
+
+    model.connectMqtt2MqttInput(TOPIC_MQTT_2_MQTT_RECEIVE);
+    model.connectMqtt2MqttOutput(TOPIC_MQTT_2_MQTT_SEND, writeCurrentValue);
+    model.connectMqtt2RestInput(TOPIC_MQTT_2_REST_RECEIVE);
+    model.connectMqtt2RestOutput(PATH_MQTT_2_REST_SEND, writeCurrentValue);
+    model.connectRest2MqttInput(PATH_REST_2_MQTT_RECEIVE);
+    model.connectRest2MqttOutput(TOPIC_REST_2_MQTT_SEND, writeCurrentValue);
+    model.connectRest2RestInput(PATH_REST_2_REST_RECEIVE);
+    model.connectRest2RestOutput(PATH_REST_2_REST_SEND, writeCurrentValue);
+  }
+
+  private static class ReceiverData {
+    String lastStringValue;
+    int numberOfStringValues = 0;
+
+    public void assertEqualData(int expectedNumberOfValues, String expectedLastValue) {
+      assertEquals(expectedNumberOfValues, this.numberOfStringValues);
+      assertEquals(expectedLastValue, this.lastStringValue);
+    }
+  }
+}