public async Task ProvideCodeActionsAsync_CannotLookupVirtualDocument_ReturnsNullAsync()
        {
            // Arrange
            var testDocUri = new Uri("C:/path/to/file.razor");
            LSPDocumentSnapshot testDocument = new TestLSPDocumentSnapshot(testDocUri, 0);

            var documentManager = new Mock <TrackingLSPDocumentManager>(MockBehavior.Strict);

            documentManager.Setup(manager => manager.TryGetDocument(It.IsAny <Uri>(), out testDocument))
            .Returns(true);
            var target  = new DefaultRazorLanguageServerCustomMessageTarget(documentManager.Object);
            var request = new CodeActionParams()
            {
                TextDocument = new TextDocumentIdentifier()
                {
                    Uri = new Uri("C:/path/to/file.razor")
                }
            };

            // Act
            var result = await target.ProvideCodeActionsAsync(request, CancellationToken.None);

            // Assert
            Assert.Null(result);
        }
Beispiel #2
0
        public async Task ProvideCodeActionsAsync_ReturnsCodeActionsAsync()
        {
            // Arrange
            var testDocUri        = new Uri("C:/path/to/file.razor");
            var testVirtualDocUri = new Uri("C:/path/to/file2.razor.g");
            var testCSharpDocUri  = new Uri("C:/path/to/file.razor.g.cs");

            var testVirtualDocument          = new TestVirtualDocumentSnapshot(testVirtualDocUri, 0);
            var csharpVirtualDocument        = new CSharpVirtualDocumentSnapshot(testCSharpDocUri, Mock.Of <ITextSnapshot>(MockBehavior.Strict), 0);
            LSPDocumentSnapshot testDocument = new TestLSPDocumentSnapshot(testDocUri, 0, testVirtualDocument, csharpVirtualDocument);

            var documentManager = new Mock <TrackingLSPDocumentManager>(MockBehavior.Strict);

            documentManager.Setup(manager => manager.TryGetDocument(It.IsAny <Uri>(), out testDocument))
            .Returns(true);

            var languageServer1Response = new[] { new VSCodeAction()
                                                  {
                                                      Title = "Response 1"
                                                  } };
            var languageServer2Response = new[] { new VSCodeAction()
                                                  {
                                                      Title = "Response 2"
                                                  } };
            IEnumerable <VSCodeAction[]> expectedResults = new List <VSCodeAction[]>()
            {
                languageServer1Response, languageServer2Response
            };
            var requestInvoker = new Mock <LSPRequestInvoker>(MockBehavior.Strict);

            requestInvoker.Setup(invoker => invoker.ReinvokeRequestOnMultipleServersAsync <CodeActionParams, VSCodeAction[]>(
                                     Methods.TextDocumentCodeActionName,
                                     LanguageServerKind.CSharp.ToContentType(),
                                     It.IsAny <Func <JToken, bool> >(),
                                     It.IsAny <CodeActionParams>(),
                                     It.IsAny <CancellationToken>()
                                     )).Returns(Task.FromResult(expectedResults));

            var uIContextManager = new Mock <RazorUIContextManager>(MockBehavior.Strict);
            var disposable       = new Mock <IDisposable>(MockBehavior.Strict);

            var target  = new DefaultRazorLanguageServerCustomMessageTarget(documentManager.Object, JoinableTaskContext, requestInvoker.Object, uIContextManager.Object, disposable.Object);
            var request = new CodeActionParams()
            {
                TextDocument = new LanguageServer.Protocol.TextDocumentIdentifier()
                {
                    Uri = testDocUri
                }
            };

            // Act
            var result = await target.ProvideCodeActionsAsync(request, CancellationToken.None);

            // Assert
            Assert.Collection(result,
                              r => Assert.Equal(languageServer1Response[0].Title, r.Title),
                              r => Assert.Equal(languageServer2Response[0].Title, r.Title));
        }
        public async void ProvideCodeActionsAsync_ReturnsCodeActions()
        {
            // Arrange
            var testDocUri        = new Uri("C:/path/to/file.razor");
            var testVirtualDocUri = new Uri("C:/path/to/file2.razor.g");
            var testCSharpDocUri  = new Uri("C:/path/to/file.razor.g.cs");

            var testVirtualDocument          = new TestVirtualDocumentSnapshot(testVirtualDocUri, 0);
            var csharpVirtualDocument        = new CSharpVirtualDocumentSnapshot(testCSharpDocUri, Mock.Of <ITextSnapshot>(), 0);
            LSPDocumentSnapshot testDocument = new TestLSPDocumentSnapshot(testDocUri, 0, testVirtualDocument, csharpVirtualDocument);

            var documentManager = new Mock <TrackingLSPDocumentManager>();

            documentManager.Setup(manager => manager.TryGetDocument(It.IsAny <Uri>(), out testDocument))
            .Returns(true);

            var expectedResults = new[] { new VSCodeAction() };
            var requestInvoker  = new Mock <LSPRequestInvoker>();

            requestInvoker.Setup(invoker => invoker.ReinvokeRequestOnServerAsync <CodeActionParams, VSCodeAction[]>(
                                     Methods.TextDocumentCodeActionName,
                                     LanguageServerKind.CSharp.ToContentType(),
                                     It.IsAny <CodeActionParams>(),
                                     It.IsAny <CancellationToken>()
                                     )).Returns(Task.FromResult(expectedResults));
            var target  = new DefaultRazorLanguageServerCustomMessageTarget(documentManager.Object, JoinableTaskContext, requestInvoker.Object);
            var request = new CodeActionParams()
            {
                TextDocument = new TextDocumentIdentifier()
                {
                    Uri = testDocUri
                }
            };

            // Act
            var result = await target.ProvideCodeActionsAsync(request, CancellationToken.None);

            // Assert
            Assert.Equal(expectedResults, result);
        }
        public async Task ProvideCodeActionsAsync_ReturnsCodeActionsAsync()
        {
            // Arrange
            var testDocUri        = new Uri("C:/path/to/file.razor");
            var testVirtualDocUri = new Uri("C:/path/to/file2.razor.g");
            var testCSharpDocUri  = new Uri("C:/path/to/file.razor.g.cs");

            var testVirtualDocument          = new TestVirtualDocumentSnapshot(testVirtualDocUri, 0);
            var csharpVirtualDocument        = new CSharpVirtualDocumentSnapshot(testCSharpDocUri, TextBuffer.CurrentSnapshot, 0);
            LSPDocumentSnapshot testDocument = new TestLSPDocumentSnapshot(testDocUri, 0, testVirtualDocument, csharpVirtualDocument);

            var documentManager = new Mock <TrackingLSPDocumentManager>(MockBehavior.Strict);

            documentManager.Setup(manager => manager.TryGetDocument(It.IsAny <Uri>(), out testDocument))
            .Returns(true);

            var languageServer1Response = new[] { new VSInternalCodeAction()
                                                  {
                                                      Title = "Response 1"
                                                  } };
            var languageServer2Response = new[] { new VSInternalCodeAction()
                                                  {
                                                      Title = "Response 2"
                                                  } };

            async IAsyncEnumerable <ReinvocationResponse <IReadOnlyList <VSInternalCodeAction> > > GetExpectedResultsAsync()
            {
                yield return(new ReinvocationResponse <IReadOnlyList <VSInternalCodeAction> >("languageClient", languageServer1Response));

                yield return(new ReinvocationResponse <IReadOnlyList <VSInternalCodeAction> >("languageClient", languageServer2Response));

                await Task.CompletedTask;
            }

            var expectedResults = GetExpectedResultsAsync();
            var requestInvoker  = new Mock <LSPRequestInvoker>(MockBehavior.Strict);

            requestInvoker.Setup(invoker => invoker.ReinvokeRequestOnMultipleServersAsync <CodeActionParams, IReadOnlyList <VSInternalCodeAction> >(
                                     TextBuffer,
                                     Methods.TextDocumentCodeActionName,
                                     It.IsAny <Func <JToken, bool> >(),
                                     It.IsAny <CodeActionParams>(),
                                     It.IsAny <CancellationToken>()
                                     )).Returns(expectedResults);

            var uIContextManager     = new Mock <RazorUIContextManager>(MockBehavior.Strict);
            var disposable           = new Mock <IDisposable>(MockBehavior.Strict);
            var documentSynchronizer = new Mock <LSPDocumentSynchronizer>(MockBehavior.Strict);

            var target = new DefaultRazorLanguageServerCustomMessageTarget(
                documentManager.Object, JoinableTaskContext, requestInvoker.Object,
                uIContextManager.Object, disposable.Object, EditorSettingsManager, documentSynchronizer.Object);
            var request = new CodeActionParams()
            {
                TextDocument = new LanguageServer.Protocol.TextDocumentIdentifier()
                {
                    Uri = testDocUri
                }
            };

            // Act
            var result = await target.ProvideCodeActionsAsync(request, CancellationToken.None);

            // Assert
            Assert.Collection(result,
                              r => Assert.Equal(languageServer1Response[0].Title, r.Title),
                              r => Assert.Equal(languageServer2Response[0].Title, r.Title));
        }