Skip to content
Snippets Groups Projects
Commit e9766100 authored by René Schöne's avatar René Schöne
Browse files

Merge branch '9-subtree-update' into 'dev'

Resolve "Subtree update"

See merge request !4
parents 089a11b4 e8897e27
No related branches found
No related tags found
2 merge requests!5Testing incremental dependency tracking.,!4Resolve "Subtree update"
Pipeline #9497 passed
package org.jastadd.ragconnect.tests;
import org.junit.jupiter.api.Test;
import treeAllowedTokens.ast.*;
import java.io.IOException;
import java.nio.file.Paths;
import java.time.Instant;
import java.time.Period;
import java.util.concurrent.TimeUnit;
import static org.jastadd.ragconnect.tests.TestUtils.mqttUri;
import static org.jastadd.ragconnect.tests.TestUtils.testJaddContainReferenceToJackson;
import static org.junit.jupiter.api.Assertions.*;
/**
* Test case "tree allowed tokens manual"
*
* @author rschoene - Initial contribution
*/
public class TreeAllowedTokensManualTest extends AbstractTreeAllowedTokensTest {
private Root model;
private SenderRoot senderRoot;
private MqttHandler handler;
@Test
public void checkJacksonReference() {
testJaddContainReferenceToJackson(
Paths.get("src", "test",
"02-after-ragconnect", "treeAllowedTokens", "RagConnect.jadd"), true);
}
@Override
protected void createModel() {
model = new Root();
senderRoot = new SenderRoot();
senderRoot.setFlag(false);
senderRoot.setInput2(INSTANT_A);
model.addSenderRoot(senderRoot);
receiverRoot = new ReceiverRoot();
model.addReceiverRoot((ReceiverRoot) receiverRoot);
}
@Override
protected void setupReceiverAndConnect(boolean writeCurrentValue) throws IOException {
model.ragconnectSetupMqttWaitUntilReady(2, TimeUnit.SECONDS);
handler = new MqttHandler().dontSendWelcomeMessage().setHost(TestUtils.getMqttHost());
assertTrue(handler.waitUntilReady(2, TimeUnit.SECONDS));
// add dependencies
senderRoot.addFlagDependency(senderRoot);
senderRoot.addInput1WhenFlagIsFalseDependency(senderRoot);
senderRoot.addInput1WhenFlagIsTrueDependency(senderRoot);
senderRoot.addInput2Dependency(senderRoot);
senderRoot.addInput3Dependency(senderRoot);
senderRoot.addPrimitiveInput2Dependency(senderRoot);
data = new ReceiverData();
handler.newConnection(TOPIC_ALFA, bytes -> data.numberOfTrees += 1);
handler.newConnection(TOPIC_ALFA_PRIMITIVE, bytes -> data.numberOfPrimitiveTrees += 1);
// connect. important: first receiver, then sender. to not miss initial value.
senderRoot.connectInput1WhenFlagIsFalse(mqttUri(TOPIC_INPUT1FALSE));
senderRoot.connectInput1WhenFlagIsTrue(mqttUri(TOPIC_INPUT1TRUE));
senderRoot.connectInput2(mqttUri(TOPIC_INPUT2));
senderRoot.connectInput3(mqttUri(TOPIC_INPUT3));
receiverRoot.connectAlfa(mqttUri(TOPIC_ALFA));
receiverRoot.connectAlfaPrimitive(mqttUri(TOPIC_ALFA_PRIMITIVE));
senderRoot.connectAlfa(mqttUri(TOPIC_ALFA), writeCurrentValue);
senderRoot.connectAlfaPrimitive(mqttUri(TOPIC_ALFA_PRIMITIVE), writeCurrentValue);
}
@Override
protected void closeConnections() {
if (handler != null) {
handler.close();
}
if (model != null) {
model.ragconnectCloseConnections();
}
}
protected void setFlag(boolean value) {
senderRoot.setFlag(value);
}
@Override
protected void checkMyEnum(TestWrapperAlfa alfa, boolean expectedBooleanValue) {
assertEquals(expectedBooleanValue ? MyEnum.TRUE : MyEnum.FALSE, ((Alfa) alfa).getEnumValue());
}
}
package org.jastadd.ragconnect.tests;
import org.junit.jupiter.api.Test;
import treeInc.ast.*;
import java.io.IOException;
import java.nio.file.Paths;
import java.util.concurrent.TimeUnit;
import static org.assertj.core.api.Assertions.assertThat;
import static org.jastadd.ragconnect.tests.TestUtils.mqttUri;
import static org.jastadd.ragconnect.tests.TestUtils.testJaddContainReferenceToJackson;
import static org.junit.jupiter.api.Assertions.*;
/**
* Test case "tree incremental"
*
* @author rschoene - Initial contribution
*/
public class TreeIncrementalTest extends AbstractTreeTest {
private Root model;
private SenderRoot senderRoot;
private MqttHandler handler;
@Test
public void checkJacksonReference() {
testJaddContainReferenceToJackson(
Paths.get("src", "test",
"02-after-ragconnect", "treeInc", "RagConnect.jadd"), true);
}
@Override
protected void createModel() {
model = new Root();
senderRoot = new SenderRoot();
model.addSenderRoot(senderRoot);
receiverRoot = new ReceiverRoot();
model.addReceiverRoot((ReceiverRoot) receiverRoot);
}
@Override
protected void setupReceiverAndConnect(boolean writeCurrentValue) throws IOException {
model.ragconnectSetupMqttWaitUntilReady(2, TimeUnit.SECONDS);
handler = new MqttHandler().dontSendWelcomeMessage().setHost(TestUtils.getMqttHost());
assertTrue(handler.waitUntilReady(2, TimeUnit.SECONDS));
// no dependencies
data = new ReceiverData();
handler.newConnection(TOPIC_ALFA, bytes -> data.numberOfTrees += 1);
// connect. important: first receiver, then sender. to not miss initial value.
receiverRoot.connectAlfa(mqttUri(TOPIC_ALFA));
senderRoot.connectAlfa(mqttUri(TOPIC_ALFA), writeCurrentValue);
}
@Override
protected void closeConnections() {
if (handler != null) {
handler.close();
}
if (model != null) {
model.ragconnectCloseConnections();
}
}
protected void setInput(int input) {
senderRoot.setInput(input);
}
}
package org.jastadd.ragconnect.tests;
import org.junit.jupiter.api.Test;
import tree.ast.MqttHandler;
import tree.ast.ReceiverRoot;
import tree.ast.Root;
import tree.ast.SenderRoot;
import java.io.IOException;
import java.nio.file.Paths;
import java.util.concurrent.TimeUnit;
import static org.jastadd.ragconnect.tests.TestUtils.mqttUri;
import static org.jastadd.ragconnect.tests.TestUtils.testJaddContainReferenceToJackson;
import static org.junit.jupiter.api.Assertions.assertTrue;
/**
* Test case "tree manual"
*
* @author rschoene - Initial contribution
*/
public class TreeManualTest extends AbstractTreeTest {
private Root model;
private SenderRoot senderRoot;
private MqttHandler handler;
@Test
public void checkJacksonReference() {
testJaddContainReferenceToJackson(
Paths.get("src", "test",
"02-after-ragconnect", "tree", "RagConnect.jadd"), true);
}
@Override
protected void createModel() {
model = new Root();
senderRoot = new SenderRoot();
model.addSenderRoot(senderRoot);
receiverRoot = new ReceiverRoot();
model.addReceiverRoot((ReceiverRoot) receiverRoot);
}
@Override
protected void setupReceiverAndConnect(boolean writeCurrentValue) throws IOException {
model.ragconnectSetupMqttWaitUntilReady(2, TimeUnit.SECONDS);
handler = new MqttHandler().dontSendWelcomeMessage().setHost(TestUtils.getMqttHost());
assertTrue(handler.waitUntilReady(2, TimeUnit.SECONDS));
// add dependencies
senderRoot.addInputDependency(senderRoot);
data = new ReceiverData();
handler.newConnection(TOPIC_ALFA, bytes -> data.numberOfTrees += 1);
// connect. important: first receiver, then sender. to not miss initial value.
receiverRoot.connectAlfa(mqttUri(TOPIC_ALFA));
senderRoot.connectAlfa(mqttUri(TOPIC_ALFA), writeCurrentValue);
}
@Override
protected void closeConnections() {
if (handler != null) {
handler.close();
}
if (model != null) {
model.ragconnectCloseConnections();
}
}
protected void setInput(int input) {
senderRoot.setInput(input);
}
}
...@@ -57,16 +57,68 @@ public class ViaTest extends AbstractMqttTest { ...@@ -57,16 +57,68 @@ public class ViaTest extends AbstractMqttTest {
private WebTarget senderBoth2Rest; private WebTarget senderBoth2Rest;
@Override @Override
public void closeConnections() { protected void createModel() {
if (handler != null) { // Setting value for Input without dependencies does not trigger any updates
handler.close(); model = new A();
} model.setMqtt2MqttInput("100");
if (model != null) { model.setRest2RestInput("200");
model.ragconnectCloseConnections(); model.setMqtt2RestInput("300");
} model.setRest2MqttInput("400");
model.setBoth2BothInput("500");
} }
@Override
protected void setupReceiverAndConnect(boolean writeCurrentValue) throws IOException {
model.ragconnectSetupMqttWaitUntilReady(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);
model.addDependencyBoth2Mqtt(model);
model.addDependencyBoth2Rest(model);
dataMqtt2Mqtt = new ReceiverData();
dataRest2Mqtt = new ReceiverData();
dataBoth2Mqtt = new ReceiverData();
handler.newConnection(TOPIC_MQTT_2_MQTT_SEND, bytes -> {
dataMqtt2Mqtt.numberOfStringValues += 1;
dataMqtt2Mqtt.lastStringValue = TestUtils.DefaultMappings.BytesToString(bytes);
});
handler.newConnection(TOPIC_REST_2_MQTT_SEND, bytes -> {
dataRest2Mqtt.numberOfStringValues += 1;
dataRest2Mqtt.lastStringValue = TestUtils.DefaultMappings.BytesToString(bytes);
});
handler.newConnection(TOPIC_BOTH_2_MQTT_SEND, bytes -> {
dataBoth2Mqtt.numberOfStringValues += 1;
dataBoth2Mqtt.lastStringValue = TestUtils.DefaultMappings.BytesToString(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);
dataBoth2Rest = client.target(REST_SERVER_BASE_URL + PATH_BOTH_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);
senderBoth2Rest = client.target(REST_SERVER_BASE_URL + PATH_BOTH_REST_RECEIVE);
model.connectMqtt2MqttInput(mqttUri(TOPIC_MQTT_2_MQTT_RECEIVE));
model.connectMqtt2MqttOutput(mqttUri(TOPIC_MQTT_2_MQTT_SEND), writeCurrentValue);
model.connectMqtt2RestInput(mqttUri(TOPIC_MQTT_2_REST_RECEIVE));
model.connectMqtt2RestOutput(restUri(PATH_MQTT_2_REST_SEND, REST_PORT), writeCurrentValue);
model.connectRest2MqttInput(restUri(PATH_REST_2_MQTT_RECEIVE, REST_PORT));
model.connectRest2MqttOutput(mqttUri(TOPIC_REST_2_MQTT_SEND), writeCurrentValue);
model.connectRest2RestInput(restUri(PATH_REST_2_REST_RECEIVE, REST_PORT));
model.connectRest2RestOutput(restUri(PATH_REST_2_REST_SEND, REST_PORT), writeCurrentValue);
model.connectBoth2BothInput(mqttUri(TOPIC_BOTH_MQTT_RECEIVE));
model.connectBoth2BothInput(restUri(PATH_BOTH_REST_RECEIVE, REST_PORT));
model.connectBoth2MqttOutput(mqttUri(TOPIC_BOTH_2_MQTT_SEND), writeCurrentValue);
model.connectBoth2RestOutput(restUri(PATH_BOTH_2_REST_SEND, REST_PORT), writeCurrentValue);
}
@Override @Override
protected void communicateSendInitialValue() throws InterruptedException { protected void communicateSendInitialValue() throws InterruptedException {
...@@ -212,16 +264,26 @@ public class ViaTest extends AbstractMqttTest { ...@@ -212,16 +264,26 @@ public class ViaTest extends AbstractMqttTest {
"512-B2R-ToRest"); "512-B2R-ToRest");
} }
@Override
public void closeConnections() {
if (handler != null) {
handler.close();
}
if (model != null) {
model.ragconnectCloseConnections();
}
}
private void sendData(String inputMqtt2Mqtt, String inputRest2Rest, String inputMqtt2Rest, String inputRest2Mqtt) { private void sendData(String inputMqtt2Mqtt, String inputRest2Rest, String inputMqtt2Rest, String inputRest2Mqtt) {
handler.publish(TOPIC_MQTT_2_MQTT_RECEIVE, inputMqtt2Mqtt.getBytes()); publisher.publish(TOPIC_MQTT_2_MQTT_RECEIVE, inputMqtt2Mqtt.getBytes());
senderRest2Rest.request().put(Entity.entity(inputRest2Rest, MediaType.TEXT_PLAIN_TYPE)); senderRest2Rest.request().put(Entity.entity(inputRest2Rest, MediaType.TEXT_PLAIN_TYPE));
handler.publish(TOPIC_MQTT_2_REST_RECEIVE, inputMqtt2Rest.getBytes()); publisher.publish(TOPIC_MQTT_2_REST_RECEIVE, inputMqtt2Rest.getBytes());
senderRest2Mqtt.request().put(Entity.entity(inputRest2Mqtt, MediaType.TEXT_PLAIN_TYPE)); senderRest2Mqtt.request().put(Entity.entity(inputRest2Mqtt, MediaType.TEXT_PLAIN_TYPE));
} }
private void sendDataForBoth(String input, boolean useMqtt) { private void sendDataForBoth(String input, boolean useMqtt) {
if (useMqtt) { if (useMqtt) {
handler.publish(TOPIC_BOTH_MQTT_RECEIVE, input.getBytes()); publisher.publish(TOPIC_BOTH_MQTT_RECEIVE, input.getBytes());
} else { } else {
senderBoth2Rest.request().put(Entity.entity(input, MediaType.TEXT_PLAIN_TYPE)); senderBoth2Rest.request().put(Entity.entity(input, MediaType.TEXT_PLAIN_TYPE));
} }
...@@ -248,70 +310,6 @@ public class ViaTest extends AbstractMqttTest { ...@@ -248,70 +310,6 @@ public class ViaTest extends AbstractMqttTest {
return dataBoth2Rest.request().get().readEntity(String.class); return dataBoth2Rest.request().get().readEntity(String.class);
} }
@Override
protected 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");
model.setBoth2BothInput("500");
}
@Override
protected void setupReceiverAndConnect(boolean writeCurrentValue) throws IOException {
model.ragconnectSetupMqttWaitUntilReady(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);
model.addDependencyBoth2Mqtt(model);
model.addDependencyBoth2Rest(model);
dataMqtt2Mqtt = new ReceiverData();
dataRest2Mqtt = new ReceiverData();
dataBoth2Mqtt = new ReceiverData();
handler.newConnection(TOPIC_MQTT_2_MQTT_SEND, bytes -> {
dataMqtt2Mqtt.numberOfStringValues += 1;
dataMqtt2Mqtt.lastStringValue = TestUtils.DefaultMappings.BytesToString(bytes);
});
handler.newConnection(TOPIC_REST_2_MQTT_SEND, bytes -> {
dataRest2Mqtt.numberOfStringValues += 1;
dataRest2Mqtt.lastStringValue = TestUtils.DefaultMappings.BytesToString(bytes);
});
handler.newConnection(TOPIC_BOTH_2_MQTT_SEND, bytes -> {
dataBoth2Mqtt.numberOfStringValues += 1;
dataBoth2Mqtt.lastStringValue = TestUtils.DefaultMappings.BytesToString(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);
dataBoth2Rest = client.target(REST_SERVER_BASE_URL + PATH_BOTH_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);
senderBoth2Rest = client.target(REST_SERVER_BASE_URL + PATH_BOTH_REST_RECEIVE);
model.connectMqtt2MqttInput(mqttUri(TOPIC_MQTT_2_MQTT_RECEIVE));
model.connectMqtt2MqttOutput(mqttUri(TOPIC_MQTT_2_MQTT_SEND), writeCurrentValue);
model.connectMqtt2RestInput(mqttUri(TOPIC_MQTT_2_REST_RECEIVE));
model.connectMqtt2RestOutput(restUri(PATH_MQTT_2_REST_SEND, REST_PORT), writeCurrentValue);
model.connectRest2MqttInput(restUri(PATH_REST_2_MQTT_RECEIVE, REST_PORT));
model.connectRest2MqttOutput(mqttUri(TOPIC_REST_2_MQTT_SEND), writeCurrentValue);
model.connectRest2RestInput(restUri(PATH_REST_2_REST_RECEIVE, REST_PORT));
model.connectRest2RestOutput(restUri(PATH_REST_2_REST_SEND, REST_PORT), writeCurrentValue);
model.connectBoth2BothInput(mqttUri(TOPIC_BOTH_MQTT_RECEIVE));
model.connectBoth2BothInput(restUri(PATH_BOTH_REST_RECEIVE, REST_PORT));
model.connectBoth2MqttOutput(mqttUri(TOPIC_BOTH_2_MQTT_SEND), writeCurrentValue);
model.connectBoth2RestOutput(restUri(PATH_BOTH_2_REST_SEND, REST_PORT), writeCurrentValue);
}
private static class ReceiverData { private static class ReceiverData {
String lastStringValue; String lastStringValue;
int numberOfStringValues = 0; int numberOfStringValues = 0;
......
0% Loading or .
You are about to add 0 people to the discussion. Proceed with caution.
Please register or to comment