build: move modules into subproject directory

6 files changed, 665 insertions, 0 deletions

diff --git a/subprojects/language-web/src/test/java/tools/refinery/language/web/ProblemWebSocketServletIntegrationTest.java b/subprojects/language-web/src/test/java/tools/refinery/language/web/ProblemWebSocketServletIntegrationTest.java
new file mode 100644
index 00000000..a26ce040
--- /dev/null
+++ b/subprojects/language-web/src/test/java/tools/refinery/language/web/ProblemWebSocketServletIntegrationTest.java
@@ -0,0 +1,204 @@
+package tools.refinery.language.web;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.hasSize;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.hamcrest.Matchers.startsWith;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+
+import java.io.IOException;
+import java.net.InetSocketAddress;
+import java.net.URI;
+import java.util.concurrent.CompletableFuture;
+import java.util.concurrent.CompletionException;
+
+import org.eclipse.jetty.http.HttpHeader;
+import org.eclipse.jetty.http.HttpStatus;
+import org.eclipse.jetty.server.Server;
+import org.eclipse.jetty.servlet.ServletContextHandler;
+import org.eclipse.jetty.servlet.ServletHolder;
+import org.eclipse.jetty.websocket.api.Session;
+import org.eclipse.jetty.websocket.api.StatusCode;
+import org.eclipse.jetty.websocket.api.annotations.WebSocket;
+import org.eclipse.jetty.websocket.api.exceptions.UpgradeException;
+import org.eclipse.jetty.websocket.client.ClientUpgradeRequest;
+import org.eclipse.jetty.websocket.client.WebSocketClient;
+import org.eclipse.jetty.websocket.server.config.JettyWebSocketServletContainerInitializer;
+import org.eclipse.xtext.testing.GlobalRegistries;
+import org.eclipse.xtext.testing.GlobalRegistries.GlobalStateMemento;
+import org.junit.jupiter.api.AfterEach;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.params.ParameterizedTest;
+import org.junit.jupiter.params.provider.ValueSource;
+
+import tools.refinery.language.web.tests.WebSocketIntegrationTestClient;
+import tools.refinery.language.web.xtext.servlet.XtextStatusCode;
+import tools.refinery.language.web.xtext.servlet.XtextWebSocketServlet;
+
+class ProblemWebSocketServletIntegrationTest {
+        private static int SERVER_PORT = 28080;
+
+        private static String SERVLET_URI = "/xtext-service";
+
+        private GlobalStateMemento stateBeforeInjectorCreation;
+
+        private Server server;
+
+        private WebSocketClient client;
+
+        @BeforeEach
+        void beforeEach() throws Exception {
+                stateBeforeInjectorCreation = GlobalRegistries.makeCopyOfGlobalState();
+                client = new WebSocketClient();
+                client.start();
+        }
+
+        @AfterEach
+        void afterEach() throws Exception {
+                client.stop();
+                client = null;
+                if (server != null) {
+                        server.stop();
+                        server = null;
+                }
+                stateBeforeInjectorCreation.restoreGlobalState();
+                stateBeforeInjectorCreation = null;
+        }
+
+        @Test
+        void updateTest() {
+                startServer(null);
+                var clientSocket = new UpdateTestClient();
+                var session = connect(clientSocket, null, XtextWebSocketServlet.XTEXT_SUBPROTOCOL_V1);
+                assertThat(session.getUpgradeResponse().getAcceptedSubProtocol(),
+                                equalTo(XtextWebSocketServlet.XTEXT_SUBPROTOCOL_V1));
+                clientSocket.waitForTestResult();
+                assertThat(clientSocket.getCloseStatusCode(), equalTo(StatusCode.NORMAL));
+                var responses = clientSocket.getResponses();
+                assertThat(responses, hasSize(5));
+                assertThat(responses.get(0), equalTo("{\"id\":\"foo\",\"response\":{\"stateId\":\"-80000000\"}}"));
+                assertThat(responses.get(1), startsWith(
+                                "{\"resource\":\"test.problem\",\"stateId\":\"-80000000\",\"service\":\"highlight\",\"push\":{\"regions\":["));
+                assertThat(responses.get(2), equalTo(
+                                "{\"resource\":\"test.problem\",\"stateId\":\"-80000000\",\"service\":\"validate\",\"push\":{\"issues\":[]}}"));
+                assertThat(responses.get(3), equalTo("{\"id\":\"bar\",\"response\":{\"stateId\":\"-7fffffff\"}}"));
+                assertThat(responses.get(4), startsWith(
+                                "{\"resource\":\"test.problem\",\"stateId\":\"-7fffffff\",\"service\":\"highlight\",\"push\":{\"regions\":["));
+        }
+
+        @WebSocket
+        public static class UpdateTestClient extends WebSocketIntegrationTestClient {
+                @Override
+                protected void arrange(Session session, int responsesReceived) throws IOException {
+                        switch (responsesReceived) {
+                        case 0 -> session.getRemote().sendString(
+                                        "{\"id\":\"foo\",\"request\":{\"resource\":\"test.problem\",\"serviceType\":\"update\",\"fullText\":\"class Person.\n\"}}");
+                        case 3 -> session.getRemote().sendString(
+                                        "{\"id\":\"bar\",\"request\":{\"resource\":\"test.problem\",\"serviceType\":\"update\",\"requiredStateId\":\"-80000000\",\"deltaText\":\"indiv q.\nnode(q).\n\",\"deltaOffset\":\"0\",\"deltaReplaceLength\":\"0\"}}");
+                        case 5 -> session.close();
+                        }
+                }
+        }
+
+        @Test
+        void badSubProtocolTest() {
+                startServer(null);
+                var clientSocket = new CloseImmediatelyTestClient();
+                var session = connect(clientSocket, null, "<invalid sub-protocol>");
+                assertThat(session.getUpgradeResponse().getAcceptedSubProtocol(), equalTo(null));
+                clientSocket.waitForTestResult();
+                assertThat(clientSocket.getCloseStatusCode(), equalTo(StatusCode.NORMAL));
+        }
+
+        @WebSocket
+        public static class CloseImmediatelyTestClient extends WebSocketIntegrationTestClient {
+                @Override
+                protected void arrange(Session session, int responsesReceived) throws IOException {
+                        session.close();
+                }
+        }
+
+        @Test
+        void subProtocolNegotiationTest() {
+                startServer(null);
+                var clientSocket = new CloseImmediatelyTestClient();
+                var session = connect(clientSocket, null, "<invalid sub-protocol>", XtextWebSocketServlet.XTEXT_SUBPROTOCOL_V1);
+                assertThat(session.getUpgradeResponse().getAcceptedSubProtocol(),
+                                equalTo(XtextWebSocketServlet.XTEXT_SUBPROTOCOL_V1));
+                clientSocket.waitForTestResult();
+                assertThat(clientSocket.getCloseStatusCode(), equalTo(StatusCode.NORMAL));
+        }
+
+        @Test
+        void invalidJsonTest() {
+                startServer(null);
+                var clientSocket = new InvalidJsonTestClient();
+                connect(clientSocket, null, XtextWebSocketServlet.XTEXT_SUBPROTOCOL_V1);
+                clientSocket.waitForTestResult();
+                assertThat(clientSocket.getCloseStatusCode(), equalTo(XtextStatusCode.INVALID_JSON));
+        }
+
+        @WebSocket
+        public static class InvalidJsonTestClient extends WebSocketIntegrationTestClient {
+                @Override
+                protected void arrange(Session session, int responsesReceived) throws IOException {
+                        session.getRemote().sendString("<invalid json>");
+                }
+        }
+
+        @ParameterizedTest(name = "Origin: {0}")
+        @ValueSource(strings = { "https://refinery.example", "https://refinery.example:443", "HTTPS://REFINERY.EXAMPLE" })
+        void validOriginTest(String origin) {
+                startServer("https://refinery.example;https://refinery.example:443");
+                var clientSocket = new CloseImmediatelyTestClient();
+                connect(clientSocket, origin, XtextWebSocketServlet.XTEXT_SUBPROTOCOL_V1);
+                clientSocket.waitForTestResult();
+                assertThat(clientSocket.getCloseStatusCode(), equalTo(StatusCode.NORMAL));
+        }
+
+        @Test
+        void invalidOriginTest() {
+                startServer("https://refinery.example;https://refinery.example:443");
+                var clientSocket = new CloseImmediatelyTestClient();
+                var exception = assertThrows(CompletionException.class,
+                                () -> connect(clientSocket, "https://invalid.example", XtextWebSocketServlet.XTEXT_SUBPROTOCOL_V1));
+                var innerException = exception.getCause();
+                assertThat(innerException, instanceOf(UpgradeException.class));
+                assertThat(((UpgradeException) innerException).getResponseStatusCode(), equalTo(HttpStatus.FORBIDDEN_403));
+        }
+
+        private void startServer(String allowedOrigins) {
+                server = new Server(new InetSocketAddress(SERVER_PORT));
+                var handler = new ServletContextHandler();
+                var holder = new ServletHolder(ProblemWebSocketServlet.class);
+                if (allowedOrigins != null) {
+                        holder.setInitParameter(ProblemWebSocketServlet.ALLOWED_ORIGINS_INIT_PARAM, allowedOrigins);
+                }
+                handler.addServlet(holder, SERVLET_URI);
+                JettyWebSocketServletContainerInitializer.configure(handler, null);
+                server.setHandler(handler);
+                try {
+                        server.start();
+                } catch (Exception e) {
+                        throw new RuntimeException("Failed to start websocket server");
+                }
+        }
+
+        private Session connect(Object webSocketClient, String origin, String... subProtocols) {
+                var upgradeRequest = new ClientUpgradeRequest();
+                if (origin != null) {
+                        upgradeRequest.setHeader(HttpHeader.ORIGIN.name(), origin);
+                }
+                upgradeRequest.setSubProtocols(subProtocols);
+                CompletableFuture<Session> sessionFuture;
+                try {
+                        sessionFuture = client.connect(webSocketClient, URI.create("ws://localhost:" + SERVER_PORT + SERVLET_URI),
+                                        upgradeRequest);
+                } catch (IOException e) {
+                        throw new AssertionError("Unexpected exception while connection to websocket", e);
+                }
+                return sessionFuture.join();
+        }
+}
diff --git a/subprojects/language-web/src/test/java/tools/refinery/language/web/tests/AwaitTerminationExecutorServiceProvider.java b/subprojects/language-web/src/test/java/tools/refinery/language/web/tests/AwaitTerminationExecutorServiceProvider.java
new file mode 100644
index 00000000..b70d0ed5
--- /dev/null
+++ b/subprojects/language-web/src/test/java/tools/refinery/language/web/tests/AwaitTerminationExecutorServiceProvider.java
@@ -0,0 +1,42 @@
+package tools.refinery.language.web.tests;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.concurrent.ExecutorService;
+
+import org.eclipse.xtext.ide.ExecutorServiceProvider;
+
+import com.google.inject.Singleton;
+
+@Singleton
+public class AwaitTerminationExecutorServiceProvider extends ExecutorServiceProvider {
+        private List<RestartableCachedThreadPool> servicesToShutDown = new ArrayList<>();
+
+        @Override
+        protected ExecutorService createInstance(String key) {
+                var instance = new RestartableCachedThreadPool();
+                synchronized (servicesToShutDown) {
+                        servicesToShutDown.add(instance);
+                }
+                return instance;
+        }
+
+        public void waitForAllTasksToFinish() {
+                synchronized (servicesToShutDown) {
+                        for (var executorService : servicesToShutDown) {
+                                executorService.waitForAllTasksToFinish();
+                        }
+                }
+        }
+
+        @Override
+        public void dispose() {
+                super.dispose();
+                synchronized (servicesToShutDown) {
+                        for (var executorService : servicesToShutDown) {
+                                executorService.waitForTermination();
+                        }
+                        servicesToShutDown.clear();
+                }
+        }
+}
diff --git a/subprojects/language-web/src/test/java/tools/refinery/language/web/tests/ProblemWebInjectorProvider.java b/subprojects/language-web/src/test/java/tools/refinery/language/web/tests/ProblemWebInjectorProvider.java
new file mode 100644
index 00000000..43c12faa
--- /dev/null
+++ b/subprojects/language-web/src/test/java/tools/refinery/language/web/tests/ProblemWebInjectorProvider.java
@@ -0,0 +1,47 @@
+package tools.refinery.language.web.tests;
+
+import org.eclipse.xtext.ide.ExecutorServiceProvider;
+import org.eclipse.xtext.util.DisposableRegistry;
+import org.eclipse.xtext.util.Modules2;
+
+import com.google.inject.Guice;
+import com.google.inject.Injector;
+
+import tools.refinery.language.ide.ProblemIdeModule;
+import tools.refinery.language.tests.ProblemInjectorProvider;
+import tools.refinery.language.web.ProblemWebModule;
+import tools.refinery.language.web.ProblemWebSetup;
+
+public class ProblemWebInjectorProvider extends ProblemInjectorProvider {
+
+        protected Injector internalCreateInjector() {
+                return new ProblemWebSetup() {
+                        @Override
+                        public Injector createInjector() {
+                                return Guice.createInjector(
+                                                Modules2.mixin(createRuntimeModule(), new ProblemIdeModule(), createWebModule()));
+                        }
+                }.createInjectorAndDoEMFRegistration();
+        }
+
+        protected ProblemWebModule createWebModule() {
+                // Await termination of the executor service to avoid race conditions between
+                // the tasks in the service and the {@link
+                // org.eclipse.xtext.testing.extensions.InjectionExtension}.
+                return new ProblemWebModule() {
+                        @SuppressWarnings("unused")
+                        public Class<? extends ExecutorServiceProvider> bindExecutorServiceProvider() {
+                                return AwaitTerminationExecutorServiceProvider.class;
+                        }
+                };
+        }
+
+        @Override
+        public void restoreRegistry() {
+                // Also make sure to dispose any IDisposable instances (that may depend on the
+                // global state) created by Xtext before restoring the global state.
+                var disposableRegistry = getInjector().getInstance(DisposableRegistry.class);
+                disposableRegistry.dispose();
+                super.restoreRegistry();
+        }
+}
diff --git a/subprojects/language-web/src/test/java/tools/refinery/language/web/tests/RestartableCachedThreadPool.java b/subprojects/language-web/src/test/java/tools/refinery/language/web/tests/RestartableCachedThreadPool.java
new file mode 100644
index 00000000..1468273d
--- /dev/null
+++ b/subprojects/language-web/src/test/java/tools/refinery/language/web/tests/RestartableCachedThreadPool.java
@@ -0,0 +1,109 @@
+package tools.refinery.language.web.tests;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.concurrent.Callable;
+import java.util.concurrent.ExecutionException;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.Future;
+import java.util.concurrent.TimeUnit;
+import java.util.concurrent.TimeoutException;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class RestartableCachedThreadPool implements ExecutorService {
+        private static final Logger LOG = LoggerFactory.getLogger(RestartableCachedThreadPool.class);
+        
+        private ExecutorService delegate;
+
+        public RestartableCachedThreadPool() {
+                delegate = createExecutorService();
+        }
+        
+        public void waitForAllTasksToFinish() {
+                delegate.shutdown();
+                waitForTermination();
+                delegate = createExecutorService();
+        }
+        
+        public void waitForTermination() {
+                try {
+                        delegate.awaitTermination(1, TimeUnit.SECONDS);
+                } catch (InterruptedException e) {
+                        LOG.warn("Interrupted while waiting for delegate executor to stop", e);
+                }
+        }
+        
+        protected ExecutorService createExecutorService() {
+                return Executors.newCachedThreadPool();
+        }
+        
+        @Override
+        public boolean awaitTermination(long arg0, TimeUnit arg1) throws InterruptedException {
+                return delegate.awaitTermination(arg0, arg1);
+        }
+
+        @Override
+        public void execute(Runnable arg0) {
+                delegate.execute(arg0);
+        }
+
+        @Override
+        public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> arg0, long arg1, TimeUnit arg2)
+                        throws InterruptedException {
+                return delegate.invokeAll(arg0, arg1, arg2);
+        }
+
+        @Override
+        public <T> List<Future<T>> invokeAll(Collection<? extends Callable<T>> arg0) throws InterruptedException {
+                return delegate.invokeAll(arg0);
+        }
+
+        @Override
+        public <T> T invokeAny(Collection<? extends Callable<T>> arg0, long arg1, TimeUnit arg2)
+                        throws InterruptedException, ExecutionException, TimeoutException {
+                return delegate.invokeAny(arg0, arg1, arg2);
+        }
+
+        @Override
+        public <T> T invokeAny(Collection<? extends Callable<T>> arg0) throws InterruptedException, ExecutionException {
+                return delegate.invokeAny(arg0);
+        }
+
+        @Override
+        public boolean isShutdown() {
+                return delegate.isShutdown();
+        }
+
+        @Override
+        public boolean isTerminated() {
+                return delegate.isTerminated();
+        }
+
+        @Override
+        public void shutdown() {
+                delegate.shutdown();
+        }
+
+        @Override
+        public List<Runnable> shutdownNow() {
+                return delegate.shutdownNow();
+        }
+
+        @Override
+        public <T> Future<T> submit(Callable<T> arg0) {
+                return delegate.submit(arg0);
+        }
+
+        @Override
+        public <T> Future<T> submit(Runnable arg0, T arg1) {
+                return delegate.submit(arg0, arg1);
+        }
+
+        @Override
+        public Future<?> submit(Runnable arg0) {
+                return delegate.submit(arg0);
+        }
+}
diff --git a/subprojects/language-web/src/test/java/tools/refinery/language/web/tests/WebSocketIntegrationTestClient.java b/subprojects/language-web/src/test/java/tools/refinery/language/web/tests/WebSocketIntegrationTestClient.java
new file mode 100644
index 00000000..49464d27
--- /dev/null
+++ b/subprojects/language-web/src/test/java/tools/refinery/language/web/tests/WebSocketIntegrationTestClient.java
@@ -0,0 +1,98 @@
+package tools.refinery.language.web.tests;
+
+import static org.junit.jupiter.api.Assertions.fail;
+
+import java.io.IOException;
+import java.time.Duration;
+import java.util.ArrayList;
+import java.util.List;
+
+import org.eclipse.jetty.websocket.api.Session;
+import org.eclipse.jetty.websocket.api.annotations.OnWebSocketClose;
+import org.eclipse.jetty.websocket.api.annotations.OnWebSocketConnect;
+import org.eclipse.jetty.websocket.api.annotations.OnWebSocketError;
+import org.eclipse.jetty.websocket.api.annotations.OnWebSocketMessage;
+
+public abstract class WebSocketIntegrationTestClient {
+        private static long TIMEOUT_MILLIS = Duration.ofSeconds(1).toMillis();
+        
+        private boolean finished = false;
+
+        private Object lock = new Object();
+
+        private Throwable error;
+
+        private int closeStatusCode;
+
+        private List<String> responses = new ArrayList<>();
+        
+        public int getCloseStatusCode() {
+                return closeStatusCode;
+        }
+        
+        public List<String> getResponses() {
+                return responses;
+        }
+
+        @OnWebSocketConnect
+        public void onConnect(Session session) {
+                arrangeAndCatchErrors(session);
+        }
+        
+        private void arrangeAndCatchErrors(Session session) {
+                try {
+                        arrange(session, responses.size());
+                } catch (Exception e) {
+                        finishedWithError(e);
+                }
+        }
+        
+        protected abstract void arrange(Session session, int responsesReceived) throws IOException; 
+
+        @OnWebSocketClose
+        public void onClose(int statusCode, String reason) {
+                closeStatusCode = statusCode;
+                testFinished();
+        }
+
+        @OnWebSocketError
+        public void onError(Throwable error) {
+                finishedWithError(error);
+        }
+
+        @OnWebSocketMessage
+        public void onMessage(Session session, String message) {
+                responses.add(message);
+                arrangeAndCatchErrors(session);
+        }
+
+        private void finishedWithError(Throwable t) {
+                error = t;
+                testFinished();
+        }
+
+        private void testFinished() {
+                synchronized (lock) {
+                        finished = true;
+                        lock.notify();
+                }
+        }
+
+        public void waitForTestResult() {
+                synchronized (lock) {
+                        if (!finished) {
+                                try {
+                                        lock.wait(TIMEOUT_MILLIS);
+                                } catch (InterruptedException e) {
+                                        fail("Unexpected InterruptedException", e);
+                                }
+                        }
+                }
+                if (!finished) {
+                        fail("Test still not finished after timeout");
+                }
+                if (error != null) {
+                        fail("Unexpected exception in websocket thread", error);
+                }
+        }
+}
diff --git a/subprojects/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/TransactionExecutorTest.java b/subprojects/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/TransactionExecutorTest.java
new file mode 100644
index 00000000..5b8fedba
--- /dev/null
+++ b/subprojects/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/TransactionExecutorTest.java
@@ -0,0 +1,165 @@
+package tools.refinery.language.web.xtext.servlet;
+
+import static org.hamcrest.MatcherAssert.assertThat;
+import static org.hamcrest.Matchers.equalTo;
+import static org.hamcrest.Matchers.hasProperty;
+import static org.hamcrest.Matchers.instanceOf;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.times;
+import static org.mockito.Mockito.verify;
+
+import java.util.List;
+import java.util.Map;
+
+import org.eclipse.emf.common.util.URI;
+import org.eclipse.xtext.resource.IResourceServiceProvider;
+import org.eclipse.xtext.testing.InjectWith;
+import org.eclipse.xtext.testing.extensions.InjectionExtension;
+import org.eclipse.xtext.web.server.model.DocumentStateResult;
+import org.eclipse.xtext.web.server.syntaxcoloring.HighlightingResult;
+import org.eclipse.xtext.web.server.validation.ValidationResult;
+import org.junit.jupiter.api.BeforeEach;
+import org.junit.jupiter.api.Test;
+import org.junit.jupiter.api.extension.ExtendWith;
+import org.mockito.ArgumentCaptor;
+import org.mockito.junit.jupiter.MockitoExtension;
+
+import com.google.inject.Inject;
+
+import tools.refinery.language.web.tests.AwaitTerminationExecutorServiceProvider;
+import tools.refinery.language.web.tests.ProblemWebInjectorProvider;
+import tools.refinery.language.web.xtext.server.ResponseHandler;
+import tools.refinery.language.web.xtext.server.ResponseHandlerException;
+import tools.refinery.language.web.xtext.server.TransactionExecutor;
+import tools.refinery.language.web.xtext.server.message.XtextWebOkResponse;
+import tools.refinery.language.web.xtext.server.message.XtextWebRequest;
+import tools.refinery.language.web.xtext.server.message.XtextWebResponse;
+
+@ExtendWith(MockitoExtension.class)
+@ExtendWith(InjectionExtension.class)
+@InjectWith(ProblemWebInjectorProvider.class)
+class TransactionExecutorTest {
+        private static final String RESOURCE_NAME = "test.problem";
+
+        private static final String PROBLEM_CONTENT_TYPE = "application/x-tools.refinery.problem";
+
+        private static final String TEST_PROBLEM = """
+                        class Person {
+                                Person[0..*] friend opposite friend
+                        }
+
+                        friend(a, b).
+                        """;
+
+        private static final Map<String, String> UPDATE_FULL_TEXT_PARAMS = Map.of("resource", RESOURCE_NAME, "serviceType",
+                        "update", "fullText", TEST_PROBLEM);
+
+        @Inject
+        private IResourceServiceProvider.Registry resourceServiceProviderRegistry;
+
+        @Inject
+        private AwaitTerminationExecutorServiceProvider executorServices;
+
+        private TransactionExecutor transactionExecutor;
+
+        @BeforeEach
+        void beforeEach() {
+                transactionExecutor = new TransactionExecutor(new SimpleSession(), resourceServiceProviderRegistry);
+        }
+
+        @Test
+        void updateFullTextTest() throws ResponseHandlerException {
+                var captor = newCaptor();
+                var stateId = updateFullText(captor);
+                assertThatPrecomputedMessagesAreReceived(stateId, captor.getAllValues());
+        }
+
+        @Test
+        void updateDeltaTextHighlightAndValidationChange() throws ResponseHandlerException {
+                var stateId = updateFullText();
+                var responseHandler = sendRequestAndWaitForAllResponses(
+                                new XtextWebRequest("bar", Map.of("resource", RESOURCE_NAME, "serviceType", "update", "requiredStateId",
+                                                stateId, "deltaText", "individual q.\nnode(q).\n<invalid text>\n", "deltaOffset", "0", "deltaReplaceLength", "0")));
+
+                var captor = newCaptor();
+                verify(responseHandler, times(3)).onResponse(captor.capture());
+                var newStateId = getStateId("bar", captor.getAllValues().get(0));
+                assertThatPrecomputedMessagesAreReceived(newStateId, captor.getAllValues());
+        }
+
+        @Test
+        void updateDeltaTextHighlightChangeOnly() throws ResponseHandlerException {
+                var stateId = updateFullText();
+                var responseHandler = sendRequestAndWaitForAllResponses(
+                                new XtextWebRequest("bar", Map.of("resource", RESOURCE_NAME, "serviceType", "update", "requiredStateId",
+                                                stateId, "deltaText", "indiv q.\nnode(q).\n", "deltaOffset", "0", "deltaReplaceLength", "0")));
+
+                var captor = newCaptor();
+                verify(responseHandler, times(2)).onResponse(captor.capture());
+                var newStateId = getStateId("bar", captor.getAllValues().get(0));
+                assertHighlightingResponse(newStateId, captor.getAllValues().get(1));
+        }
+
+        @Test
+        void fullTextWithoutResourceTest() throws ResponseHandlerException {
+                var resourceServiceProvider = resourceServiceProviderRegistry
+                                .getResourceServiceProvider(URI.createFileURI(RESOURCE_NAME));
+                resourceServiceProviderRegistry.getContentTypeToFactoryMap().put(PROBLEM_CONTENT_TYPE, resourceServiceProvider);
+                var responseHandler = sendRequestAndWaitForAllResponses(new XtextWebRequest("foo",
+                                Map.of("contentType", PROBLEM_CONTENT_TYPE, "fullText", TEST_PROBLEM, "serviceType", "validate")));
+
+                var captor = newCaptor();
+                verify(responseHandler).onResponse(captor.capture());
+                var response = captor.getValue();
+                assertThat(response, hasProperty("id", equalTo("foo")));
+                assertThat(response, hasProperty("responseData", instanceOf(ValidationResult.class)));
+        }
+
+        private ArgumentCaptor<XtextWebResponse> newCaptor() {
+                return ArgumentCaptor.forClass(XtextWebResponse.class);
+        }
+
+        private String updateFullText() throws ResponseHandlerException {
+                return updateFullText(newCaptor());
+        }
+
+        private String updateFullText(ArgumentCaptor<XtextWebResponse> captor) throws ResponseHandlerException {
+                var responseHandler = sendRequestAndWaitForAllResponses(new XtextWebRequest("foo", UPDATE_FULL_TEXT_PARAMS));
+
+                verify(responseHandler, times(3)).onResponse(captor.capture());
+                return getStateId("foo", captor.getAllValues().get(0));
+        }
+
+        private ResponseHandler sendRequestAndWaitForAllResponses(XtextWebRequest request) throws ResponseHandlerException {
+                var responseHandler = mock(ResponseHandler.class);
+                transactionExecutor.setResponseHandler(responseHandler);
+                transactionExecutor.handleRequest(request);
+                executorServices.waitForAllTasksToFinish();
+                return responseHandler;
+        }
+
+        private String getStateId(String requestId, XtextWebResponse okResponse) {
+                assertThat(okResponse, hasProperty("id", equalTo(requestId)));
+                assertThat(okResponse, hasProperty("responseData", instanceOf(DocumentStateResult.class)));
+                return ((DocumentStateResult) ((XtextWebOkResponse) okResponse).getResponseData()).getStateId();
+        }
+
+        private void assertThatPrecomputedMessagesAreReceived(String stateId, List<XtextWebResponse> responses) {
+                assertHighlightingResponse(stateId, responses.get(1));
+                assertValidationResponse(stateId, responses.get(2));
+        }
+
+        private void assertHighlightingResponse(String stateId, XtextWebResponse highlightingResponse) {
+                assertThat(highlightingResponse, hasProperty("resourceId", equalTo(RESOURCE_NAME)));
+                assertThat(highlightingResponse, hasProperty("stateId", equalTo(stateId)));
+                assertThat(highlightingResponse, hasProperty("service", equalTo("highlight")));
+                assertThat(highlightingResponse, hasProperty("pushData", instanceOf(HighlightingResult.class)));
+        }
+
+        private void assertValidationResponse(String stateId, XtextWebResponse validationResponse) {
+                assertThat(validationResponse, hasProperty("resourceId", equalTo(RESOURCE_NAME)));
+                assertThat(validationResponse, hasProperty("stateId", equalTo(stateId)));
+                assertThat(validationResponse, hasProperty("service", equalTo("validate")));
+                assertThat(validationResponse, hasProperty("pushData", instanceOf(ValidationResult.class)));
+        }
+}