Add request-level tests for LspConnection.

Author: tintoy

src/Client/Protocol/LspConnection.cs

@@ -84,6 +84,11 @@ public sealed class LspConnection
         /// </summary>
         int _nextRequestId = 0;
 
+        /// <summary>
+        ///     Has the connection been disposed?
+        /// </summary>
+        bool _disposed;
+
         /// <summary>
         ///     The cancellation source for the read and write loops.
         /// </summary>
@@ -158,9 +163,19 @@ public LspConnection(ILoggerFactory loggerFactory, Stream input, Stream output)
         /// </summary>
         public void Dispose()
         {
-            Disconnect();
+            if (_disposed)
+                return;
 
-            _cancellationSource?.Dispose();
+            try
+            {
+                Disconnect();
+
+                _cancellationSource?.Dispose();
+            }
+            finally
+            {
+                _disposed = true;
+            }
         }
 
         /// <summary>

test/Client.Tests/ConnectionTests.cs

@@ -32,8 +32,8 @@ public async Task Client_HandleEmptyNotification_Success()
         {
             var testCompletion = new TaskCompletionSource<object>();
 
-            LspConnection serverConnection = await CreateServerConnection();
             LspConnection clientConnection = await CreateClientConnection();
+            LspConnection serverConnection = await CreateServerConnection();
 
             var serverDispatcher = new LspDispatcher();
             serverDispatcher.HandleEmptyNotification("test", () =>
@@ -85,5 +85,165 @@ public async Task Server_HandleEmptyNotification_Success()
 
             await Task.WhenAll(clientConnection.HasHasDisconnected, serverConnection.HasHasDisconnected);
         }
+
+        /// <summary>
+        ///     Verify that a client <see cref="LspConnection"/> can handle a request from a server <see cref="LspConnection"/>.
+        /// </summary>
+        [Fact(DisplayName = "Client connection can handle request from server")]
+        public async Task Server_HandleRequest_Success()
+        {
+            LspConnection clientConnection = await CreateClientConnection();
+            LspConnection serverConnection = await CreateServerConnection();
+
+            var clientDispatcher = new LspDispatcher();
+            clientDispatcher.HandleRequest<TestRequest, TestResponse>("test", (request, cancellationToken) =>
+            {
+                Log.LogInformation("Got request: {@Request}", request);
+
+                return Task.FromResult(new TestResponse
+                {
+                    Value = request.Value.ToString()
+                });
+            });
+            clientConnection.Connect(clientDispatcher);
+
+            serverConnection.Connect(new LspDispatcher());
+            TestResponse response = await serverConnection.SendRequest<TestResponse>("test", new TestRequest
+            {
+                Value = 1234
+            });
+
+            Assert.Equal("1234", response.Value);
+
+            Log.LogInformation("Got response: {@Response}", response);
+
+            serverConnection.Disconnect(flushOutgoing: true);
+            clientConnection.Disconnect();
+
+            await Task.WhenAll(clientConnection.HasHasDisconnected, serverConnection.HasHasDisconnected);
+        }
+
+        /// <summary>
+        ///     Verify that a server <see cref="LspConnection"/> can handle a request from a client <see cref="LspConnection"/>.
+        /// </summary>
+        [Fact(DisplayName = "Server connection can handle request from client")]
+        public async Task Client_HandleRequest_Success()
+        {
+            LspConnection clientConnection = await CreateClientConnection();
+            LspConnection serverConnection = await CreateServerConnection();
+
+            var serverDispatcher = new LspDispatcher();
+            serverDispatcher.HandleRequest<TestRequest, TestResponse>("test", (request, cancellationToken) =>
+            {
+                Log.LogInformation("Got request: {@Request}", request);
+
+                return Task.FromResult(new TestResponse
+                {
+                    Value = request.Value.ToString()
+                });
+            });
+            serverConnection.Connect(serverDispatcher);
+
+            clientConnection.Connect(new LspDispatcher());
+            TestResponse response = await clientConnection.SendRequest<TestResponse>("test", new TestRequest
+            {
+                Value = 1234
+            });
+
+            Assert.Equal("1234", response.Value);
+
+            Log.LogInformation("Got response: {@Response}", response);
+
+            clientConnection.Disconnect(flushOutgoing: true);
+            serverConnection.Disconnect();
+
+            await Task.WhenAll(clientConnection.HasHasDisconnected, serverConnection.HasHasDisconnected);
+        }
+
+        /// <summary>
+        ///     Verify that a client <see cref="LspConnection"/> can handle a command-style request (i.e. no response body) from a server <see cref="LspConnection"/>.
+        /// </summary>
+        [Fact(DisplayName = "Client connection can handle command request from server")]
+        public async Task Server_HandleCommandRequest_Success()
+        {
+            LspConnection clientConnection = await CreateClientConnection();
+            LspConnection serverConnection = await CreateServerConnection();
+
+            var clientDispatcher = new LspDispatcher();
+            clientDispatcher.HandleRequest<TestRequest>("test", (request, cancellationToken) =>
+            {
+                Log.LogInformation("Got request: {@Request}", request);
+
+                Assert.Equal(1234, request.Value);
+
+                return Task.CompletedTask;
+            });
+            clientConnection.Connect(clientDispatcher);
+
+            serverConnection.Connect(new LspDispatcher());
+            await serverConnection.SendRequest("test", new TestRequest
+            {
+                Value = 1234
+            });
+
+            serverConnection.Disconnect(flushOutgoing: true);
+            clientConnection.Disconnect();
+
+            await Task.WhenAll(clientConnection.HasHasDisconnected, serverConnection.HasHasDisconnected);
+        }
+
+        /// <summary>
+        ///     Verify that a server <see cref="LspConnection"/> can handle a command-style request (i.e. no response body) from a client <see cref="LspConnection"/>.
+        /// </summary>
+        [Fact(DisplayName = "Server connection can handle command request from client")]
+        public async Task Client_HandleCommandRequest_Success()
+        {
+            LspConnection clientConnection = await CreateClientConnection();
+            LspConnection serverConnection = await CreateServerConnection();
+
+            var serverDispatcher = new LspDispatcher();
+            serverDispatcher.HandleRequest<TestRequest>("test", (request, cancellationToken) =>
+            {
+                Log.LogInformation("Got request: {@Request}", request);
+
+                Assert.Equal(1234, request.Value);
+
+                return Task.CompletedTask;
+            });
+            serverConnection.Connect(serverDispatcher);
+
+            clientConnection.Connect(new LspDispatcher());
+            await clientConnection.SendRequest("test", new TestRequest
+            {
+                Value = 1234
+            });
+
+            clientConnection.Disconnect(flushOutgoing: true);
+            serverConnection.Disconnect();
+
+            await Task.WhenAll(clientConnection.HasHasDisconnected, serverConnection.HasHasDisconnected);
+        }
+    }
+
+    /// <summary>
+    ///     A test request.
+    /// </summary>
+    class TestRequest
+    {
+        /// <summary>
+        ///     A test value for the request.
+        /// </summary>
+        public int Value { get; set; }
+    }
+
+    /// <summary>
+    ///     A test response.
+    /// </summary>
+    class TestResponse
+    {
+        /// <summary>
+        ///     A test value for the response.
+        /// </summary>
+        public string Value { get; set; }
     }
 }