Add request-level tests for LspConnection

src/Client/Processes/NamedPipeServerProcess.cs

@@ -91,10 +91,10 @@ public override async Task Start()
         {
             ServerExitCompletion = new TaskCompletionSource<object>();
 
-            ServerInputStream = new NamedPipeServerStream(BaseName + "/in", PipeDirection.Out, 2, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, inBufferSize: 1024, outBufferSize: 1024);
-            ServerOutputStream = new NamedPipeServerStream(BaseName + "/out", PipeDirection.In, 2, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, inBufferSize: 1024, outBufferSize: 1024);
-            ClientInputStream = new NamedPipeClientStream(".", BaseName + "/out", PipeDirection.Out, PipeOptions.Asynchronous);
-            ClientOutputStream = new NamedPipeClientStream(".", BaseName + "/in", PipeDirection.In, PipeOptions.Asynchronous);
+            ServerInputStream = new NamedPipeServerStream(BaseName + "_in", PipeDirection.Out, 2, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, inBufferSize: 1024, outBufferSize: 1024);
+            ServerOutputStream = new NamedPipeServerStream(BaseName + "_out", PipeDirection.In, 2, PipeTransmissionMode.Byte, PipeOptions.Asynchronous, inBufferSize: 1024, outBufferSize: 1024);
+            ClientInputStream = new NamedPipeClientStream(".", BaseName + "_out", PipeDirection.Out, PipeOptions.Asynchronous);
+            ClientOutputStream = new NamedPipeClientStream(".", BaseName + "_in", PipeDirection.In, PipeOptions.Asynchronous);
 
             // Ensure all pipes are connected before proceeding.
             await Task.WhenAll(

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/ClientTests.cs

@@ -0,0 +1,306 @@
+using Microsoft.Extensions.Logging;
+using OmniSharp.Extensions.LanguageServer.Capabilities.Server;
+using OmniSharp.Extensions.LanguageServer.Models;
+using OmniSharp.Extensions.LanguageServerProtocol.Client.Dispatcher;
+using OmniSharp.Extensions.LanguageServerProtocol.Client.Protocol;
+using OmniSharp.Extensions.LanguageServerProtocol.Client.Utilities;
+using System.IO;
+using System.Linq;
+using System.Threading.Tasks;
+using Xunit;
+using Xunit.Abstractions;
+using System.Collections.Generic;
+using System;
+
+namespace OmniSharp.Extensions.LanguageServerProtocol.Client.Tests
+{
+    /// <summary>
+    ///     Tests for <see cref="LanguageClient"/>.
+    /// </summary>
+    public class ClientTests
+        : PipeServerTestBase
+    {
+        /// <summary>
+        ///     Create a new <see cref="LanguageClient"/> test suite.
+        /// </summary>
+        /// <param name="testOutput">
+        ///     Output for the current test.
+        /// </param>
+        public ClientTests(ITestOutputHelper testOutput)
+            : base(testOutput)
+        {
+        }
+
+        /// <summary>
+        ///     Get an absolute document path for use in tests.
+        /// </summary>
+        string AbsoluteDocumentPath => IsWindows ? @"C:\Foo.txt" : "/Foo.txt";
+
+        /// <summary>
+        ///     The <see cref="LanguageClient"/> under test.
+        /// </summary>
+        LanguageClient LanguageClient { get; set; }
+
+        /// <summary>
+        ///     The server-side dispatcher.
+        /// </summary>
+        LspDispatcher ServerDispatcher { get; } = new LspDispatcher();
+
+        /// <summary>
+        ///     The server-side connection.
+        /// </summary>
+        LspConnection ServerConnection { get; set; }
+
+        /// <summary>
+        ///     Ensure that the language client can successfully request Hover information.
+        /// </summary>
+        [Fact(DisplayName = "Language client can successfully request hover info")]
+        public async Task Hover_Success()
+        {
+            await Connect();
+
+            const int line = 5;
+            const int column = 5;
+            var expectedHoverContent = new MarkedStringContainer("123", "456", "789");
+
+            ServerDispatcher.HandleRequest<TextDocumentPositionParams, Hover>("textDocument/hover", (request, cancellationToken) =>
+            {
+                Assert.NotNull(request.TextDocument);
+
+                Assert.Equal(AbsoluteDocumentPath,
+                    DocumentUri.GetFileSystemPath(request.TextDocument.Uri)
+                );
+
+                Assert.Equal(line, request.Position.Line);
+                Assert.Equal(column, request.Position.Character);
+
+                return Task.FromResult(new Hover
+                {
+                    Contents = expectedHoverContent,
+                    Range = new Range
+                    {
+                        Start = request.Position,
+                        End = request.Position
+                    }
+                });
+            });
+
+            Hover hover = await LanguageClient.TextDocument.Hover(AbsoluteDocumentPath, line, column);
+
+            Assert.NotNull(hover.Range);
+            Assert.NotNull(hover.Range.Start);
+            Assert.NotNull(hover.Range.End);
+
+            Assert.Equal(line, hover.Range.Start.Line);
+            Assert.Equal(column, hover.Range.Start.Character);
+
+            Assert.Equal(line, hover.Range.End.Line);
+            Assert.Equal(column, hover.Range.End.Character);
+
+            Assert.NotNull(hover.Contents);
+            Assert.Equal(expectedHoverContent.Select(markedString => markedString.Value),
+                hover.Contents.Select(
+                    markedString => markedString.Value
+                )
+            );
+        }
+
+        /// <summary>
+        ///     Ensure that the language client can successfully request Completions.
+        /// </summary>
+        [Fact(DisplayName = "Language client can successfully request completions")]
+        public async Task Completions_Success()
+        {
+            await Connect();
+
+            const int line = 5;
+            const int column = 5;
+            string expectedDocumentPath = AbsoluteDocumentPath;
+            Uri expectedDocumentUri = DocumentUri.FromFileSystemPath(expectedDocumentPath);
+
+            var expectedCompletionItems = new CompletionItem[]
+            {
+                new CompletionItem
+                {
+                    Kind = CompletionItemKind.Class,
+                    Label = "Class1",
+                    TextEdit = new TextEdit
+                    {
+                        Range = new Range
+                        {
+                            Start = new Position
+                            {
+                                Line = line,
+                                Character = column
+                            },
+                            End = new Position
+                            {
+                                Line = line,
+                                Character = column
+                            }
+                        },
+                        NewText = "Class1",
+                    }
+                }
+            };
+
+            ServerDispatcher.HandleRequest<TextDocumentPositionParams, CompletionList>("textDocument/completion", (request, cancellationToken) =>
+            {
+                Assert.NotNull(request.TextDocument);
+
+                Assert.Equal(expectedDocumentUri, request.TextDocument.Uri);
+
+                Assert.Equal(line, request.Position.Line);
+                Assert.Equal(column, request.Position.Character);
+
+                return Task.FromResult(new CompletionList(
+                    expectedCompletionItems,
+                    isIncomplete: true
+                ));
+            });
+
+            CompletionList actualCompletions = await LanguageClient.TextDocument.Completions(AbsoluteDocumentPath, line, column);
+
+            Assert.True(actualCompletions.IsIncomplete, "completions.IsIncomplete");
+            Assert.NotNull(actualCompletions.Items);
+
+            CompletionItem[] actualCompletionItems = actualCompletions.Items.ToArray();
+            Assert.Collection(actualCompletionItems, actualCompletionItem =>
+            {
+                CompletionItem expectedCompletionItem = expectedCompletionItems[0];
+
+                Assert.Equal(expectedCompletionItem.Kind, actualCompletionItem.Kind);
+                Assert.Equal(expectedCompletionItem.Label, actualCompletionItem.Label);
+
+                Assert.NotNull(actualCompletionItem.TextEdit);
+                Assert.Equal(expectedCompletionItem.TextEdit.NewText, actualCompletionItem.TextEdit.NewText);
+
+                Assert.NotNull(actualCompletionItem.TextEdit.Range);
+                Assert.NotNull(actualCompletionItem.TextEdit.Range.Start);
+                Assert.NotNull(actualCompletionItem.TextEdit.Range.End);
+                Assert.Equal(expectedCompletionItem.TextEdit.Range.Start.Line, actualCompletionItem.TextEdit.Range.Start.Line);
+                Assert.Equal(expectedCompletionItem.TextEdit.Range.Start.Character, actualCompletionItem.TextEdit.Range.Start.Character);
+                Assert.Equal(expectedCompletionItem.TextEdit.Range.End.Line, actualCompletionItem.TextEdit.Range.End.Line);
+                Assert.Equal(expectedCompletionItem.TextEdit.Range.End.Character, actualCompletionItem.TextEdit.Range.End.Character);
+            });
+        }
+
+        /// <summary>
+        ///     Ensure that the language client can successfully receive Diagnostics from the server.
+        /// </summary>
+        [Fact(DisplayName = "Language client can successfully receive diagnostics")]
+        public async Task Diagnostics_Success()
+        {
+            await Connect();
+
+            string documentPath = AbsoluteDocumentPath;
+            Uri expectedDocumentUri = DocumentUri.FromFileSystemPath(documentPath);
+            List<Diagnostic> expectedDiagnostics = new List<Diagnostic>
+            {
+                new Diagnostic
+                {
+                    Source = "Test",
+                    Code = new DiagnosticCode(1234),
+                    Message = "This is a diagnostic message.",
+                    Range = new Range
+                    {
+                        Start = new Position
+                        {
+                            Line = 2,
+                            Character = 5
+                        },
+                        End = new Position
+                        {
+                            Line = 3,
+                            Character = 7
+                        }
+                    },
+                    Severity = DiagnosticSeverity.Warning
+                }
+            };
+
+            TaskCompletionSource<object> receivedDiagnosticsNotification = new TaskCompletionSource<object>();
+
+            Uri actualDocumentUri = null;
+            List<Diagnostic> actualDiagnostics = null;
+            LanguageClient.TextDocument.OnPublishDiagnostics((documentUri, diagnostics) =>
+            {
+                actualDocumentUri = documentUri;
+                actualDiagnostics = diagnostics;
+
+                receivedDiagnosticsNotification.SetResult(null);
+            });
+
+            ServerConnection.SendNotification("textDocument/publishDiagnostics", new PublishDiagnosticsParams
+            {
+                Uri = DocumentUri.FromFileSystemPath(documentPath),
+                Diagnostics = expectedDiagnostics
+            });
+
+            // Timeout.
+            Task winner = await Task.WhenAny(
+                receivedDiagnosticsNotification.Task,
+                Task.Delay(
+                    TimeSpan.FromSeconds(2)
+                )
+            );
+            Assert.Same(receivedDiagnosticsNotification.Task, winner);
+
+            Assert.NotNull(actualDocumentUri);
+            Assert.Equal(expectedDocumentUri, actualDocumentUri);
+
+            Assert.NotNull(actualDiagnostics);
+            Assert.Equal(1, actualDiagnostics.Count);
+
+            Diagnostic expectedDiagnostic = expectedDiagnostics[0];
+            Diagnostic actualDiagnostic = actualDiagnostics[0];
+
+            Assert.Equal(expectedDiagnostic.Code, actualDiagnostic.Code);
+            Assert.Equal(expectedDiagnostic.Message, actualDiagnostic.Message);
+            Assert.Equal(expectedDiagnostic.Range.Start.Line, actualDiagnostic.Range.Start.Line);
+            Assert.Equal(expectedDiagnostic.Range.Start.Character, actualDiagnostic.Range.Start.Character);
+            Assert.Equal(expectedDiagnostic.Range.End.Line, actualDiagnostic.Range.End.Line);
+            Assert.Equal(expectedDiagnostic.Range.End.Character, actualDiagnostic.Range.End.Character);
+            Assert.Equal(expectedDiagnostic.Severity, actualDiagnostic.Severity);
+            Assert.Equal(expectedDiagnostic.Source, actualDiagnostic.Source);
+        }
+
+        /// <summary>
+        ///     Connect the client and server.
+        /// </summary>
+        /// <param name="handleServerInitialize">
+        ///     Add standard handlers for server initialisation?
+        /// </param>
+        async Task Connect(bool handleServerInitialize = true)
+        {
+            ServerConnection = await CreateServerConnection();
+            ServerConnection.Connect(ServerDispatcher);
+
+            if (handleServerInitialize)
+                HandleServerInitialize();
+
+            LanguageClient = await CreateClient(initialize: true);
+        }
+
+        /// <summary>
+        ///     Add standard handlers for sever initialisation.
+        /// </summary>
+        void HandleServerInitialize()
+        {
+            ServerDispatcher.HandleRequest<InitializeParams, InitializeResult>("initialize", (request, cancellationToken) =>
+            {
+                return Task.FromResult(new InitializeResult
+                {
+                    Capabilities = new ServerCapabilities
+                    {
+                        HoverProvider = true
+                    }
+                });
+            });
+            ServerDispatcher.HandleEmptyNotification("initialized", () =>
+            {
+                Log.LogInformation("Server initialized.");
+            });
+        }
+    }
+}