Move generate method code action to use IFileSystem and add tests

Author: davidwengier

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/CodeActions/Razor/GenerateMethodCodeActionResolver.cs

@@ -19,6 +19,7 @@
 using Microsoft.CodeAnalysis.Razor.Formatting;
 using Microsoft.CodeAnalysis.Razor.ProjectSystem;
 using Microsoft.CodeAnalysis.Razor.Protocol;
+using Microsoft.CodeAnalysis.Razor.Workspaces;
 using Microsoft.VisualStudio.LanguageServer.Protocol;
 using CSharpSyntaxFactory = Microsoft.CodeAnalysis.CSharp.SyntaxFactory;
 
@@ -27,11 +28,13 @@ namespace Microsoft.CodeAnalysis.Razor.CodeActions.Razor;
 internal class GenerateMethodCodeActionResolver(
     IRoslynCodeActionHelpers roslynCodeActionHelpers,
     IDocumentMappingService documentMappingService,
-    IRazorFormattingService razorFormattingService) : IRazorCodeActionResolver
+    IRazorFormattingService razorFormattingService,
+    IFileSystem fileSystem) : IRazorCodeActionResolver
 {
     private readonly IRoslynCodeActionHelpers _roslynCodeActionHelpers = roslynCodeActionHelpers;
     private readonly IDocumentMappingService _documentMappingService = documentMappingService;
     private readonly IRazorFormattingService _razorFormattingService = razorFormattingService;
+    private readonly IFileSystem _fileSystem = fileSystem;
 
     private const string ReturnType = "$$ReturnType$$";
     private const string MethodName = "$$MethodName$$";
@@ -58,7 +61,7 @@ internal class GenerateMethodCodeActionResolver(
         var razorClassName = Path.GetFileNameWithoutExtension(uriPath);
         var codeBehindPath = $"{uriPath}.cs";
 
-        if (!File.Exists(codeBehindPath) ||
+        if (!_fileSystem.FileExists(codeBehindPath) ||
             razorClassName is null ||
             !code.TryComputeNamespace(fallbackToRootNamespace: true, out var razorNamespace))
         {
@@ -72,7 +75,7 @@ razorClassName is null ||
                 cancellationToken).ConfigureAwait(false);
         }
 
-        var content = File.ReadAllText(codeBehindPath);
+        var content = _fileSystem.ReadFile(codeBehindPath);
         if (GetCSharpClassDeclarationSyntax(content, razorNamespace, razorClassName) is not { } @class)
         {
             // The code behind file is malformed, generate the code in the razor file instead.

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/FileSystem.cs

@@ -16,4 +16,7 @@ public IEnumerable<string> GetDirectories(string workspaceDirectory)
 
     public bool FileExists(string filePath)
         => File.Exists(filePath);
+
+    public string ReadFile(string filePath)
+        => File.ReadAllText(filePath);
 }

src/Razor/src/Microsoft.CodeAnalysis.Razor.Workspaces/IFileSystem.cs

@@ -13,4 +13,6 @@ internal interface IFileSystem
     public IEnumerable<string> GetDirectories(string workspaceDirectory);
 
     bool FileExists(string filePath);
+
+    string ReadFile(string filePath);
 }

src/Razor/src/Microsoft.CodeAnalysis.Remote.Razor/CodeActions/RemoteServices.cs

@@ -85,8 +85,9 @@ internal sealed class OOPAddUsingsCodeActionResolver : AddUsingsCodeActionResolv
 internal sealed class OOPGenerateMethodCodeActionResolver(
     IRoslynCodeActionHelpers roslynCodeActionHelpers,
     IDocumentMappingService documentMappingService,
-    IRazorFormattingService razorFormattingService)
-    : GenerateMethodCodeActionResolver(roslynCodeActionHelpers, documentMappingService, razorFormattingService);
+    IRazorFormattingService razorFormattingService,
+    IFileSystem fileSystem)
+    : GenerateMethodCodeActionResolver(roslynCodeActionHelpers, documentMappingService, razorFormattingService, fileSystem);
 
 [Export(typeof(ICSharpCodeActionResolver)), Shared]
 [method: ImportingConstructor]

src/Razor/src/Microsoft.CodeAnalysis.Remote.Razor/RemoteFileSystem.cs

@@ -13,8 +13,11 @@ internal class RemoteFileSystem : IFileSystem
 {
     private IFileSystem _fileSystem = new FileSystem();
 
-    public bool FileExists(string filePath) =>
-        _fileSystem.FileExists(filePath);
+    public bool FileExists(string filePath)
+        => _fileSystem.FileExists(filePath);
+
+    public string ReadFile(string filePath)
+        => _fileSystem.ReadFile(filePath);
 
     public IEnumerable<string> GetDirectories(string workspaceDirectory)
         => _fileSystem.GetDirectories(workspaceDirectory);

src/Razor/test/Microsoft.AspNetCore.Razor.LanguageServer.Test/IFileSystemExtensionsTest.cs

@@ -100,5 +100,8 @@ public IEnumerable<string> GetFiles(string workspaceDirectory, string searchPatt
 
         public bool FileExists(string filePath)
             => throw new NotImplementedException();
+
+        public string ReadFile(string filePath)
+            => throw new NotImplementedException();
     }
 }

src/Razor/test/Microsoft.VisualStudio.LanguageServices.Razor.Test/Cohost/CohostCodeActionsEndpointTest.cs

@@ -10,7 +10,10 @@
 using Microsoft.AspNetCore.Razor.PooledObjects;
 using Microsoft.AspNetCore.Razor.Telemetry;
 using Microsoft.AspNetCore.Razor.Test.Common;
+using Microsoft.AspNetCore.Razor.Utilities;
+using Microsoft.CodeAnalysis;
 using Microsoft.CodeAnalysis.ExternalAccess.Razor;
+using Microsoft.CodeAnalysis.Razor;
 using Microsoft.CodeAnalysis.Razor.CodeActions.Models;
 using Microsoft.CodeAnalysis.Razor.Protocol.CodeActions;
 using Microsoft.CodeAnalysis.Razor.Workspaces;
@@ -22,6 +25,7 @@
 using Xunit;
 using Xunit.Abstractions;
 using WorkspacesSR = Microsoft.CodeAnalysis.Razor.Workspaces.Resources.SR;
+using LspDiagnostic = Microsoft.VisualStudio.LanguageServer.Protocol.Diagnostic;
 
 namespace Microsoft.VisualStudio.Razor.LanguageClient.Cohost;
 
@@ -505,6 +509,106 @@ private void DoesNotExist(MouseEventArgs e)
         await VerifyCodeActionAsync(input, expected, WorkspacesSR.FormatGenerate_Event_Handler_Title("DoesNotExist"));
     }
 
+    [Fact]
+    public async Task GenerateEventHandler_BadCodeBehind()
+    {
+        await VerifyCodeActionAsync(
+            input: """
+                <button @onclick="{|CS0103:Does[||]NotExist|}"></button>
+                """,
+            expected: """
+                <button @onclick="DoesNotExist"></button>
+                @code {
+                    private void DoesNotExist(MouseEventArgs e)
+                    {
+                        throw new NotImplementedException();
+                    }
+                }
+                """,
+            additionalFiles: [
+                (FilePath("File1.razor.cs"), """
+                    namespace Goo
+                    {
+                        public partial class NotAComponent
+                        {
+                        }
+                    }
+                    """)],
+            codeActionName: WorkspacesSR.FormatGenerate_Event_Handler_Title("DoesNotExist"));
+    }
+
+    [Fact]
+    public async Task GenerateEventHandler_CodeBehind()
+    {
+        await VerifyCodeActionAsync(
+            input: """
+                <button @onclick="{|CS0103:Does[||]NotExist|}"></button>
+                """,
+            expected: """
+                <button @onclick="DoesNotExist"></button>
+                """,
+            additionalFiles: [
+                (FilePath("File1.razor.cs"), """
+                    namespace SomeProject
+
+                    public partial class File1
+                    {
+                        public void M()
+                        {
+                        }
+                    }
+                    """)],
+            additionalExpectedFiles: [
+                (FileUri("File1.razor.cs"), """
+                    namespace SomeProject
+                    
+                    public partial class File1
+                    {
+                        public void M()
+                        {
+                        }
+                        private void DoesNotExist(Microsoft.AspNetCore.Components.Web.MouseEventArgs e)
+                        {
+                            throw new System.NotImplementedException();
+                        }
+                    }
+                    """)],
+            codeActionName: WorkspacesSR.FormatGenerate_Event_Handler_Title("DoesNotExist"));
+    }
+
+    [Fact]
+    public async Task GenerateEventHandler_EmptyCodeBehind()
+    {
+        await VerifyCodeActionAsync(
+            input: """
+                <button @onclick="{|CS0103:Does[||]NotExist|}"></button>
+                """,
+            expected: """
+                <button @onclick="DoesNotExist"></button>
+                """,
+            additionalFiles: [
+                (FilePath("File1.razor.cs"), """
+                    namespace SomeProject
+
+                    public partial class File1
+                    {
+                    }
+                    """)],
+            additionalExpectedFiles: [
+                (FileUri("File1.razor.cs"), """
+                    namespace SomeProject
+                    
+                    public partial class File1
+                    {
+                        private void DoesNotExist(Microsoft.AspNetCore.Components.Web.MouseEventArgs e)
+                        {
+                            throw new System.NotImplementedException();
+                        }
+                    }
+                    """)],
+            codeActionName: WorkspacesSR.FormatGenerate_Event_Handler_Title("DoesNotExist"));
+    }
+
     [Fact]
     public async Task GenerateAsyncEventHandler_NoCodeBlock()
     {
@@ -718,10 +822,10 @@ Hello World
                     """)]);
     }
 
-    private async Task VerifyCodeActionAsync(TestCode input, string? expected, string codeActionName, int childActionIndex = 0, string? fileKind = null, (Uri fileUri, string contents)[]? additionalExpectedFiles = null)
+    private async Task VerifyCodeActionAsync(TestCode input, string? expected, string codeActionName, int childActionIndex = 0, string? fileKind = null, (string filePath, string contents)[]? additionalFiles = null, (Uri fileUri, string contents)[]? additionalExpectedFiles = null)
     {
         var fileSystem = (RemoteFileSystem)OOPExportProvider.GetExportedValue<IFileSystem>();
-        fileSystem.GetTestAccessor().SetFileSystem(new TestFileSystem(additionalExpectedFiles));
+        fileSystem.GetTestAccessor().SetFileSystem(new TestFileSystem(additionalFiles));
 
         UpdateClientLSPInitializationOptions(options =>
         {
@@ -736,7 +840,7 @@ private async Task VerifyCodeActionAsync(TestCode input, string? expected, strin
             return options;
         });
 
-        var document = await CreateProjectAndRazorDocumentAsync(input.Text, fileKind, createSeparateRemoteAndLocalWorkspaces: true);
+        var document = await CreateProjectAndRazorDocumentAsync(input.Text, fileKind, createSeparateRemoteAndLocalWorkspaces: true, additionalFiles: additionalFiles);
 
         var codeAction = await VerifyCodeActionRequestAsync(document, input, codeActionName, childActionIndex);
 
@@ -759,7 +863,7 @@ private async Task VerifyCodeActionAsync(TestCode input, string? expected, strin
         var endpoint = new CohostCodeActionsEndpoint(RemoteServiceInvoker, ClientCapabilitiesService, TestHtmlDocumentSynchronizer.Instance, requestInvoker, NoOpTelemetryReporter.Instance);
         var inputText = await document.GetTextAsync(DisposalToken);
 
-        using var diagnostics = new PooledArrayBuilder<Diagnostic>();
+        using var diagnostics = new PooledArrayBuilder<LspDiagnostic>();
         foreach (var (code, spans) in input.NamedSpans)
         {
             if (code.Length == 0)
@@ -769,7 +873,7 @@ private async Task VerifyCodeActionAsync(TestCode input, string? expected, strin
 
             foreach (var diagnosticSpan in spans)
             {
-                diagnostics.Add(new Diagnostic
+                diagnostics.Add(new LspDiagnostic
                 {
                     Code = code,
                     Range = inputText.GetRange(diagnosticSpan)
@@ -812,42 +916,57 @@ private async Task VerifyCodeActionAsync(TestCode input, string? expected, strin
         return codeActionToRun;
     }
 
-    private async Task VerifyCodeActionResultAsync(CodeAnalysis.TextDocument document, WorkspaceEdit workspaceEdit, string? expected, (Uri fileUri, string contents)[]? additionalExpectedFiles = null)
+    private async Task VerifyCodeActionResultAsync(TextDocument document, WorkspaceEdit workspaceEdit, string? expected, (Uri fileUri, string contents)[]? additionalExpectedFiles = null)
     {
+        var solution = document.Project.Solution;
         var validated = false;
-        if (workspaceEdit.TryGetTextDocumentEdits(out var documentEdits))
+
+        if (workspaceEdit.DocumentChanges?.Value is SumType<TextDocumentEdit, CreateFile, RenameFile, DeleteFile>[] sumTypeArray)
         {
-            var documentUri = document.CreateUri();
-            var sourceText = await document.GetTextAsync(DisposalToken).ConfigureAwait(false);
+            using var builder = new PooledArrayBuilder<TextDocumentEdit>();
+            foreach (var sumType in sumTypeArray)
+            {
+                if (sumType.Value is CreateFile createFile)
+                {
+                    validated = true;
+                    Assert.Single(additionalExpectedFiles.AssumeNotNull(), f => f.fileUri == createFile.Uri);
+                    var documentId = DocumentId.CreateNewId(document.Project.Id);
+                    var filePath = createFile.Uri.GetDocumentFilePath();
+                    var documentInfo = DocumentInfo.Create(documentId, filePath, filePath: filePath);
+                    solution = solution.AddDocument(documentInfo);
+                }
+            }
+        }
 
+        if (workspaceEdit.TryGetTextDocumentEdits(out var documentEdits))
+        {
             foreach (var edit in documentEdits)
             {
-                if (edit.TextDocument.Uri == documentUri)
+                var textDocument = solution.GetTextDocuments(edit.TextDocument.Uri).First();
+                var text = await textDocument.GetTextAsync(DisposalToken).ConfigureAwait(false);
+                if (textDocument is Document)
                 {
-                    sourceText = sourceText.WithChanges(edit.Edits.Select(sourceText.GetTextChange));
+                    solution = solution.WithDocumentText(textDocument.Id, text.WithChanges(edit.Edits.Select(text.GetTextChange)));
                 }
                 else
                 {
-                    var contents = Assert.Single(additionalExpectedFiles.AssumeNotNull(), f => f.fileUri == edit.TextDocument.Uri).contents;
-                    AssertEx.EqualOrDiff(contents, Assert.Single(edit.Edits).NewText);
+                    solution = solution.WithAdditionalDocumentText(textDocument.Id, text.WithChanges(edit.Edits.Select(text.GetTextChange)));
                 }
             }
 
-            validated = true;
-            AssertEx.EqualOrDiff(expected, sourceText.ToString());
-        }
-
-        if (workspaceEdit.DocumentChanges?.Value is SumType<TextDocumentEdit, CreateFile, RenameFile, DeleteFile>[] sumTypeArray)
-        {
-            using var builder = new PooledArrayBuilder<TextDocumentEdit>();
-            foreach (var sumType in sumTypeArray)
+            if (additionalExpectedFiles is not null)
             {
-                if (sumType.Value is CreateFile createFile)
+                foreach (var (uri, contents) in additionalExpectedFiles)
                 {
-                    validated = true;
-                    Assert.Single(additionalExpectedFiles.AssumeNotNull(), f => f.fileUri == createFile.Uri);
+                    var additionalDocument = solution.GetTextDocuments(uri).First();
+                    var text = await additionalDocument.GetTextAsync(DisposalToken).ConfigureAwait(false);
+                    AssertEx.EqualOrDiff(contents, text.ToString());
                 }
             }
+
+            validated = true;
+            var actual = await solution.GetAdditionalDocument(document.Id).AssumeNotNull().GetTextAsync(DisposalToken).ConfigureAwait(false);
+            AssertEx.EqualOrDiff(expected, actual.ToString());
         }
 
         Assert.True(validated, "Test did not validate anything. Code action response type is presumably not supported.");
@@ -865,21 +984,18 @@ private async Task<WorkspaceEdit> ResolveCodeActionAsync(CodeAnalysis.TextDocume
         return result.Edit;
     }
 
-    private class TestFileSystem((Uri fileUri, string contents)[]? files) : IFileSystem
+    private class TestFileSystem((string filePath, string contents)[]? files) : IFileSystem
     {
         public bool FileExists(string filePath)
-        {
-            return false;
-        }
+            => files?.Any(f => FilePathNormalizingComparer.Instance.Equals(f.filePath, filePath)) ?? false;
+
+        public string ReadFile(string filePath)
+            => files.AssumeNotNull().Single(f => FilePathNormalizingComparer.Instance.Equals(f.filePath, filePath)).contents;
 
         public IEnumerable<string> GetDirectories(string workspaceDirectory)
-        {
-            throw new NotImplementedException();
-        }
+            => throw new NotImplementedException();
 
         public IEnumerable<string> GetFiles(string workspaceDirectory, string searchPattern, SearchOption searchOption)
-        {
-            throw new NotImplementedException();
-        }
+            => throw new NotImplementedException();
     }
 }