feat(web): push precomputed service results

4 files changed, 198 insertions, 87 deletions

diff --git a/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/AwaitTerminationExecutorServiceProvider.java b/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/AwaitTerminationExecutorServiceProvider.java
index 08230335..25bcec37 100644
--- a/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/AwaitTerminationExecutorServiceProvider.java
+++ b/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/AwaitTerminationExecutorServiceProvider.java
@@ -3,7 +3,6 @@ package tools.refinery.language.web.xtext.servlet;
 import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.ExecutorService;
-import java.util.concurrent.TimeUnit;
 
 import org.eclipse.xtext.ide.ExecutorServiceProvider;
 
@@ -11,24 +10,33 @@ import com.google.inject.Singleton;
 
 @Singleton
 public class AwaitTerminationExecutorServiceProvider extends ExecutorServiceProvider {
-        private List<ExecutorService> servicesToShutDown = new ArrayList<>();
+        private List<RestartableCachedThreadPool> servicesToShutDown = new ArrayList<>();
 
         @Override
         protected ExecutorService createInstance(String key) {
-                var instance = super.createInstance(key);
-                servicesToShutDown.add(instance);
+                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();
-                for (var executorService : servicesToShutDown) {
-                        try {
-                                executorService.awaitTermination(1, TimeUnit.SECONDS);
-                        } catch (InterruptedException e) {
-                                // Continue normally.
+                synchronized (servicesToShutDown) {
+                        for (var executorService : servicesToShutDown) {
+                                executorService.waitForTermination();
                         }
+                        servicesToShutDown.clear();
                 }
         }
 }
diff --git a/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/ProblemWebInjectorProvider.java b/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/ProblemWebInjectorProvider.java
index 3493c9eb..a6d97c8b 100644
--- a/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/ProblemWebInjectorProvider.java
+++ b/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/ProblemWebInjectorProvider.java
@@ -26,7 +26,7 @@ public class ProblemWebInjectorProvider extends ProblemInjectorProvider {
 
         protected ProblemWebModule createWebModule() {
                 // Await termination of the executor service to avoid race conditions between
-                // between the tasks in the service and the {@link
+                // the tasks in the service and the {@link
                 // org.eclipse.xtext.testing.extensions.InjectionExtension}.
                 return new ProblemWebModule() {
                         @SuppressWarnings("unused")
diff --git a/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/RestartableCachedThreadPool.java b/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/RestartableCachedThreadPool.java
new file mode 100644
index 00000000..02ef38e2
--- /dev/null
+++ b/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/RestartableCachedThreadPool.java
@@ -0,0 +1,109 @@
+package tools.refinery.language.web.xtext.servlet;
+
+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/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/TransactionExecutorTest.java b/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/TransactionExecutorTest.java
index 6ad82d7f..7f7c3e43 100644
--- a/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/TransactionExecutorTest.java
+++ b/language-web/src/test/java/tools/refinery/language/web/xtext/servlet/TransactionExecutorTest.java
@@ -4,23 +4,19 @@ 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.junit.jupiter.api.Assertions.fail;
 import static org.mockito.Mockito.mock;
 import static org.mockito.Mockito.times;
 import static org.mockito.Mockito.verify;
 
-import java.io.IOException;
 import java.util.List;
 import java.util.Map;
-import java.util.UUID;
 
 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.ServiceConflictResult;
 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.hamcrest.Matcher;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -29,123 +25,121 @@ import org.mockito.junit.jupiter.MockitoExtension;
 
 import com.google.inject.Inject;
 
+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 INVALID_STATE_ID = "<invalid_state>";
-
         private static final String TEST_PROBLEM = """
-                                class Person {
-                                Person friend[0..*] opposite friend
+                        class Person {
+                                Person[0..*] friend opposite friend
                         }
 
                         friend(a, b).
                         """;
 
-        private static final Map<String, String> UPDATE_FULL_TEXT_PARAMS = Map.of("serviceType", "update", "fullText",
-                        TEST_PROBLEM);
-
-        private static final Map<String, String> VALIDATE_PARAMS = Map.of("serviceType", "validate");
+        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 emptyBatchTest() {
-                performBatchRequest(null);
-        }
 
         @Test
-        void fullTextUpdateTest() {
-                var response = performSingleRequest(null, UPDATE_FULL_TEXT_PARAMS);
-                assertThat(response, hasResponseData(instanceOf(DocumentStateResult.class)));
+        void updateFullTextTest() throws ResponseHandlerException {
+                var captor = newCaptor();
+                var stateId = updateFullText(captor);
+                assertThatPrecomputedMessagesAreReceived(stateId, captor.getAllValues());
         }
 
         @Test
-        void validationAfterFullTextUpdateInSameBatchTest() {
-                var response = performBatchRequest(null, UPDATE_FULL_TEXT_PARAMS, VALIDATE_PARAMS).get(1);
-                assertThat(response, hasResponseData(instanceOf(ValidationResult.class)));
+        void updateDeltaTextHighlightAndValidationChange() throws ResponseHandlerException {
+                var stateId = updateFullText();
+                var responseHandler = sendRequestAndWaitForAllResponses(
+                                new XtextWebRequest("bar", Map.of("resource", RESOURCE_NAME, "serviceType", "update", "requiredStateId",
+                                                stateId, "deltaText", "<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 validationAfterFullTextUpdateInDifferentBatchTest() {
+        void updateDeltaTextHighlightChangeOnly() throws ResponseHandlerException {
                 var stateId = updateFullText();
-                var validateResponse = performSingleRequest(stateId, VALIDATE_PARAMS);
-                assertThat(validateResponse, hasResponseData(instanceOf(ValidationResult.class)));
+                var responseHandler = sendRequestAndWaitForAllResponses(
+                                new XtextWebRequest("bar", Map.of("resource", RESOURCE_NAME, "serviceType", "update", "requiredStateId",
+                                                stateId, "deltaText", "class Vehicle.\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 conflictTest() {
-                updateFullText();
-                var response = performSingleRequest(INVALID_STATE_ID, VALIDATE_PARAMS);
-                assertThat(response, hasResponseData(instanceOf(ServiceConflictResult.class)));
+        private ArgumentCaptor<XtextWebResponse> newCaptor() {
+                return ArgumentCaptor.forClass(XtextWebResponse.class);
         }
 
-        @Test
-        void transactionCancelledDueToConflictTest() {
-                updateFullText();
-                var response = performBatchRequest(INVALID_STATE_ID, VALIDATE_PARAMS, VALIDATE_PARAMS).get(1);
-                assertThat(response, hasErrorKind(equalTo(XtextWebSocketErrorKind.TRANSACTION_CANCELLED)));
+        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));
         }
 
-        @SafeVarargs
-        private List<XtextWebSocketResponse> performBatchRequest(String requiredStateId, Map<String, String>... params) {
-                var id = UUID.randomUUID().toString();
-                var request = new XtextWebSocketRequest(id, RESOURCE_NAME, null, requiredStateId, List.of(params));
-                
+        private ResponseHandler sendRequestAndWaitForAllResponses(XtextWebRequest request) throws ResponseHandlerException {
                 var responseHandler = mock(ResponseHandler.class);
-                try {
-                        transactionExecutor.handleRequest(request, responseHandler);
-                } catch (IOException e) {
-                        fail("Unexpected IOException", e);
-                }
-                
-                var captor = ArgumentCaptor.forClass(XtextWebSocketResponse.class);
-                int nParams = params.length;
-                try {
-                        verify(responseHandler, times(nParams)).onResponse(captor.capture());
-                } catch (IOException e) {
-                        throw new RuntimeException("Mockito threw unexcepted exception", e);
-                }
-                var allResponses = captor.getAllValues();
-                for (int i = 0; i < nParams; i++) {
-                        var response = allResponses.get(i);
-                        assertThat(response, hasProperty("id", equalTo(id)));
-                        assertThat(response, hasProperty("index", equalTo(i)));
-                }
-                return allResponses;
+                transactionExecutor.setResponseHandler(responseHandler);
+                transactionExecutor.handleRequest(request);
+                executorServices.waitForAllTasksToFinish();
+                return responseHandler;
         }
 
-        private XtextWebSocketResponse performSingleRequest(String requiredStateId, Map<String, String> param) {
-                return performBatchRequest(requiredStateId, param).get(0);
+        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 String updateFullText() {
-                var updateResponse = (XtextWebSocketOkResponse) performSingleRequest(null, UPDATE_FULL_TEXT_PARAMS);
-                var documentStateResult = (DocumentStateResult) updateResponse.getResponseData();
-                var stateId = documentStateResult.getStateId();
-                if (INVALID_STATE_ID.equals(stateId)) {
-                        throw new RuntimeException("Service returned unexpected stateId: " + stateId);
-                }
-                return stateId;
+        private void assertThatPrecomputedMessagesAreReceived(String stateId, List<XtextWebResponse> responses) {
+                assertHighlightingResponse(stateId, responses.get(1));
+                assertValidationResponse(stateId, responses.get(2));
         }
 
-        private static Matcher<XtextWebSocketResponse> hasResponseData(Matcher<?> responseDataMatcher) {
-                return hasProperty("responseData", responseDataMatcher);
+        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("highlighting")));
+                assertThat(highlightingResponse, hasProperty("pushData", instanceOf(HighlightingResult.class)));
         }
 
-        private static Matcher<XtextWebSocketResponse> hasErrorKind(
-                        Matcher<? extends XtextWebSocketErrorKind> errorKindMatcher) {
-                return hasProperty("errorKind", errorKindMatcher);
+        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("validation")));
+                assertThat(validationResponse, hasProperty("pushData", instanceOf(ValidationResult.class)));
         }
 }