Test

Author: davidwengier

src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/Completion/Delegation/DelegatedCompletionItemResolverTest.NetFx.cs

@@ -3,6 +3,7 @@
 
 using System;
 using System.Collections.Generic;
+using System.Diagnostics;
 using System.Linq;
 using System.Threading;
 using System.Threading.Tasks;
@@ -18,6 +19,7 @@
 using Microsoft.CodeAnalysis.Razor.Tooltip;
 using Microsoft.CodeAnalysis.Testing;
 using Microsoft.CodeAnalysis.Text;
+using Roslyn.Test.Utilities;
 using Xunit;
 using Xunit.Abstractions;
 using Xunit.Sdk;
@@ -214,6 +216,68 @@ async Task FooAsync()
         Assert.True(expectedSourceText.ContentEquals(actualSourceText));
     }
 
+    [Fact]
+    public async Task ResolveAsync_CSharp_RemapAndFormatsTextEdit_UsingDirective()
+    {
+        // Arrange
+        TestCode input =
+            """
+                @{
+                    Task FooAsync()
+                    {
+                    String$$
+                    }
+                }
+                """;
+
+        // Admittedly the result here is not perfect, but only because our tests don't implement the full LSP editor logic. The key thing
+        // is the addition of the using directive.
+        var expectedSourceText = SourceText.From(
+            """
+                @using System.Text
+                @{
+                    Task FooAsync()
+                    {
+                    String
+                    }
+                }
+                """);
+
+        var codeDocument = CreateCodeDocument(input.Text, filePath: "C:/path/to/file.razor");
+        // Roslyn won't send unimported types if SupportsVisualStudioExtensions is true
+        await using var csharpServer = await CreateCSharpServerAsync(codeDocument, supportsVisualStudioExtensions: false);
+
+        var clientConnection = CreateClientConnectionForResolve(csharpServer);
+        var documentContextFactory = new TestDocumentContextFactory("C:/path/to/file.razor", codeDocument);
+        var optionsMonitor = TestRazorLSPOptionsMonitor.Create();
+        var formattingService = await _lazyFormattingService.GetValueAsync(DisposalToken);
+        var resolver = new DelegatedCompletionItemResolver(documentContextFactory, formattingService, DocumentMappingService, optionsMonitor, clientConnection, LoggerFactory);
+        var containingCompletionList = await GetCompletionListAndOriginalParamsAsync(input.Position, codeDocument, csharpServer);
+
+        var sw = Stopwatch.StartNew();
+        VSInternalCompletionItem item;
+        while ((item = containingCompletionList.Items.FirstOrDefault(item => item.Label == "StringBuilder")) == null)
+        {
+            Assert.True(sw.Elapsed < TimeSpan.FromSeconds(5), "Failed to resolve unimported completion item after 5 second.");
+
+            // Roslyn only computes unimported types in the background, and we have no access to its internal workings to wait for it to be
+            // finished, so we just have to delay and ask for completion items again.
+            await Task.Delay(100, DisposalToken);
+            containingCompletionList = await GetCompletionListAndOriginalParamsAsync(input.Position, codeDocument, csharpServer);
+        }
+
+        Assert.NotNull(item);
+
+        var originalRequestContext = new DelegatedCompletionResolutionContext(_csharpCompletionParams.Identifier, _csharpCompletionParams.ProjectedKind, containingCompletionList.Data);
+        var resolvedItem = await resolver.ResolveAsync(
+            item, containingCompletionList, originalRequestContext, s_clientCapabilities, _componentAvailabilityService, DisposalToken);
+
+        var originalSourceText = SourceText.From(input.Text);
+        var textChange = originalSourceText.GetTextChange(resolvedItem.AdditionalTextEdits.Single());
+        var actualSourceText = originalSourceText.WithChanges(textChange);
+        AssertEx.EqualOrDiff(expectedSourceText.ToString(), actualSourceText.ToString());
+    }
+
     [Fact]
     public async Task ResolveAsync_Html_Resolves()
     {
@@ -246,15 +310,14 @@ private async Task<VSInternalCompletionItem> ResolveCompletionItemAsync(string c
     {
         TestFileMarkupParser.GetPosition(content, out var documentContent, out var cursorPosition);
         var codeDocument = CreateCodeDocument(documentContent, filePath: "C:/path/to/file.razor");
-        await using var csharpServer = await CreateCSharpServerAsync(codeDocument);
+        await using var csharpServer = await CreateCSharpServerAsync(codeDocument, supportsVisualStudioExtensions: true);
 
         var clientConnection = CreateClientConnectionForResolve(csharpServer);
         var documentContextFactory = new TestDocumentContextFactory("C:/path/to/file.razor", codeDocument);
         var optionsMonitor = TestRazorLSPOptionsMonitor.Create();
         var formattingService = await _lazyFormattingService.GetValueAsync(DisposalToken);
         var resolver = new DelegatedCompletionItemResolver(documentContextFactory, formattingService, DocumentMappingService, optionsMonitor, clientConnection, LoggerFactory);
-        var (containingCompletionList, csharpCompletionParams) = await GetCompletionListAndOriginalParamsAsync(
-            cursorPosition, codeDocument, csharpServer);
+        var containingCompletionList = await GetCompletionListAndOriginalParamsAsync(cursorPosition, codeDocument, csharpServer);
 
         var originalRequestContext = new DelegatedCompletionResolutionContext(_csharpCompletionParams.Identifier, _csharpCompletionParams.ProjectedKind, containingCompletionList.Data);
         var item = containingCompletionList.Items.FirstOrDefault(item => item.Label == itemToResolve);
@@ -270,7 +333,7 @@ private async Task<VSInternalCompletionItem> ResolveCompletionItemAsync(string c
         return resolvedItem;
     }
 
-    private async Task<CSharpTestLspServer> CreateCSharpServerAsync(RazorCodeDocument codeDocument)
+    private async Task<CSharpTestLspServer> CreateCSharpServerAsync(RazorCodeDocument codeDocument, bool supportsVisualStudioExtensions)
     {
         var csharpSourceText = codeDocument.GetCSharpSourceText();
         var csharpDocumentUri = new Uri("C:/path/to/file.razor__virtual.g.cs");
@@ -283,32 +346,33 @@ private async Task<CSharpTestLspServer> CreateCSharpServerAsync(RazorCodeDocumen
             }
         };
 
+        var capabilitiesUpdater = (VSInternalClientCapabilities c) =>
+        {
+            c.SupportsVisualStudioExtensions = supportsVisualStudioExtensions;
+        };
+
         // Don't declare this with an 'await using'. The caller owns the lifetime of this C# LSP server.
         var csharpServer = await CSharpTestLspServerHelpers.CreateCSharpLspServerAsync(
-            csharpSourceText, csharpDocumentUri, serverCapabilities, DisposalToken);
+            csharpSourceText, csharpDocumentUri, serverCapabilities, capabilitiesUpdater, DisposalToken);
 
         await csharpServer.OpenDocumentAsync(csharpDocumentUri, csharpSourceText.ToString(), DisposalToken);
 
         return csharpServer;
     }
 
-    private async Task<(RazorVSInternalCompletionList, DelegatedCompletionParams)> GetCompletionListAndOriginalParamsAsync(
+    private async Task<RazorVSInternalCompletionList> GetCompletionListAndOriginalParamsAsync(
         int cursorPosition,
         RazorCodeDocument codeDocument,
         CSharpTestLspServer csharpServer)
     {
         var completionContext = new VSInternalCompletionContext() { TriggerKind = CompletionTriggerKind.Invoked };
         var documentContext = TestDocumentContext.Create("C:/path/to/file.razor", codeDocument);
 
-        DelegatedCompletionParams? delegatedParams = null;
-        var clientConnection = CreateClientConnectionForCompletion(csharpServer, processParams: @params =>
-        {
-            delegatedParams = @params;
-        });
+        var clientConnection = CreateClientConnectionForCompletion(csharpServer);
 
         var provider = CreateDelegatedCompletionListProvider(clientConnection);
 
-        var completionList = await provider.GetCompletionListAsync(
+        return await provider.GetCompletionListAsync(
             codeDocument,
             cursorPosition,
             completionContext,
@@ -317,7 +381,5 @@ private async Task<CSharpTestLspServer> CreateCSharpServerAsync(RazorCodeDocumen
             s_defaultRazorCompletionOptions,
             correlationId: Guid.Empty,
             cancellationToken: DisposalToken);
-
-        return (completionList, delegatedParams);
     }
 }

src/Razor/test/Microsoft.AspNetCore.Razor.Test.Common.Tooling/LanguageServer/CSharpTestLspServerHelpers.cs

@@ -32,6 +32,14 @@ public static Task<CSharpTestLspServer> CreateCSharpLspServerAsync(
         CancellationToken cancellationToken) =>
         CreateCSharpLspServerAsync(csharpSourceText, csharpDocumentUri, serverCapabilities, new EmptyMappingService(), capabilitiesUpdater: null, cancellationToken);
 
+    public static Task<CSharpTestLspServer> CreateCSharpLspServerAsync(
+        SourceText csharpSourceText,
+        Uri csharpDocumentUri,
+        VSInternalServerCapabilities serverCapabilities,
+        Action<VSInternalClientCapabilities> capabilitiesUpdater,
+        CancellationToken cancellationToken) =>
+        CreateCSharpLspServerAsync(csharpSourceText, csharpDocumentUri, serverCapabilities, new EmptyMappingService(), capabilitiesUpdater, cancellationToken);
+
     public static Task<CSharpTestLspServer> CreateCSharpLspServerAsync(
         SourceText csharpSourceText,
         Uri csharpDocumentUri,