Add code fix for FunctionContext helper migration (#79)

* Add FunctionContext helper code fix

* Clarify FunctionContext analyzer docs

* Tighten FunctionContext migration fixes

Author: cwinland

FastMoq.Analyzers.Tests/AnalyzerTestHelpers.cs

@@ -18,7 +18,12 @@ internal static class AnalyzerTestHelpers
     {
         public static async Task<ImmutableArray<Diagnostic>> GetDiagnosticsAsync(string source, params DiagnosticAnalyzer[] analyzers)
         {
-            var document = CreateDocument(source);
+            return await GetDiagnosticsAsync(source, includeAzureFunctionsHelpers: false, analyzers).ConfigureAwait(false);
+        }
+
+        public static async Task<ImmutableArray<Diagnostic>> GetDiagnosticsAsync(string source, bool includeAzureFunctionsHelpers, params DiagnosticAnalyzer[] analyzers)
+        {
+            var document = CreateDocument(source, includeAzureFunctionsHelpers);
             return await GetDiagnosticsAsync(document, analyzers).ConfigureAwait(false);
         }
 
@@ -36,9 +41,9 @@ public static async Task<ImmutableArray<Diagnostic>> GetDiagnosticsAsync(Documen
                 .ConfigureAwait(false);
         }
 
-        public static async Task<string> ApplyCodeFixAsync(string source, DiagnosticAnalyzer analyzer, CodeFixProvider codeFixProvider, string diagnosticId)
+        public static async Task<string> ApplyCodeFixAsync(string source, DiagnosticAnalyzer analyzer, CodeFixProvider codeFixProvider, string diagnosticId, bool includeAzureFunctionsHelpers = false)
         {
-            var document = CreateDocument(source);
+            var document = CreateDocument(source, includeAzureFunctionsHelpers);
             var diagnostics = await GetDiagnosticsAsync(document, analyzer).ConfigureAwait(false);
             var diagnostic = diagnostics.Single(item => item.Id == diagnosticId);
 
@@ -54,6 +59,19 @@ public static async Task<string> ApplyCodeFixAsync(string source, DiagnosticAnal
             return changedRoot!.NormalizeWhitespace().ToFullString();
         }
 
+        public static async Task<ImmutableArray<string>> GetCodeFixTitlesAsync(string source, DiagnosticAnalyzer analyzer, CodeFixProvider codeFixProvider, string diagnosticId, bool includeAzureFunctionsHelpers = false)
+        {
+            var document = CreateDocument(source, includeAzureFunctionsHelpers);
+            var diagnostics = await GetDiagnosticsAsync(document, analyzer).ConfigureAwait(false);
+            var diagnostic = diagnostics.Single(item => item.Id == diagnosticId);
+
+            var actions = new List<CodeAction>();
+            var context = new CodeFixContext(document, diagnostic, (action, _) => actions.Add(action), CancellationToken.None);
+            await codeFixProvider.RegisterCodeFixesAsync(context).ConfigureAwait(false);
+
+            return actions.Select(action => action.Title).ToImmutableArray();
+        }
+
         public static string NormalizeCode(string source)
         {
             return CSharpSyntaxTree.ParseText(source, new CSharpParseOptions(LanguageVersion.Preview))
@@ -62,7 +80,7 @@ public static string NormalizeCode(string source)
                 .ToFullString();
         }
 
-        private static Document CreateDocument(string source)
+        private static Document CreateDocument(string source, bool includeAzureFunctionsHelpers = false)
         {
             var workspace = new AdhocWorkspace();
             var projectId = ProjectId.CreateNewId();
@@ -73,7 +91,7 @@ private static Document CreateDocument(string source)
                 .WithProjectParseOptions(projectId, new CSharpParseOptions(LanguageVersion.Preview))
                 .WithProjectCompilationOptions(projectId, new CSharpCompilationOptions(OutputKind.DynamicallyLinkedLibrary));
 
-            foreach (var metadataReference in GetMetadataReferences())
+            foreach (var metadataReference in GetMetadataReferences(includeAzureFunctionsHelpers))
             {
                 solution = solution.AddMetadataReference(projectId, metadataReference);
             }
@@ -82,13 +100,19 @@ private static Document CreateDocument(string source)
             return solution.GetDocument(documentId)!;
         }
 
-        private static IEnumerable<MetadataReference> GetMetadataReferences()
+        private static IEnumerable<MetadataReference> GetMetadataReferences(bool includeAzureFunctionsHelpers)
         {
             var references = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
             if (AppContext.GetData("TRUSTED_PLATFORM_ASSEMBLIES") is string trustedPlatformAssemblies)
             {
                 foreach (var assemblyPath in trustedPlatformAssemblies.Split(Path.PathSeparator))
                 {
+                    if (!includeAzureFunctionsHelpers &&
+                        string.Equals(Path.GetFileNameWithoutExtension(assemblyPath), "FastMoq.AzureFunctions", StringComparison.OrdinalIgnoreCase))
+                    {
+                        continue;
+                    }
+
                     references.Add(assemblyPath);
                 }
             }
@@ -102,6 +126,13 @@ private static IEnumerable<MetadataReference> GetMetadataReferences()
             references.Add(typeof(Microsoft.AspNetCore.Http.DefaultHttpContext).Assembly.Location);
             references.Add(typeof(Microsoft.AspNetCore.Mvc.ControllerContext).Assembly.Location);
 
+            if (includeAzureFunctionsHelpers)
+            {
+                references.Add(typeof(FastMoq.AzureFunctions.Extensions.FunctionContextTestExtensions).Assembly.Location);
+                references.Add(typeof(Microsoft.Azure.Functions.Worker.FunctionContext).Assembly.Location);
+                references.Add(typeof(Azure.Core.Serialization.ObjectSerializer).Assembly.Location);
+            }
+
             return references.Select(path => MetadataReference.CreateFromFile(path));
         }
     }

FastMoq.Analyzers.Tests/FastMoq.Analyzers.Tests.csproj

@@ -31,6 +31,7 @@
 
   <ItemGroup>
     <ProjectReference Include="..\FastMoq.Analyzers\FastMoq.Analyzers.csproj" OutputItemType="Analyzer" />
+    <ProjectReference Include="..\FastMoq.AzureFunctions\FastMoq.AzureFunctions.csproj" />
     <ProjectReference Include="..\FastMoq.Core\FastMoq.Core.csproj" />
     <ProjectReference Include="..\FastMoq.Provider.Moq\FastMoq.Provider.Moq.csproj" />
     <ProjectReference Include="..\FastMoq.Provider.NSubstitute\FastMoq.Provider.NSubstitute.csproj" />

FastMoq.Analyzers.Tests/MigrationAnalyzerTests.cs

@@ -651,6 +651,166 @@ void Execute(Mocker Mocks)
             Assert.Equal(DiagnosticIds.PreferTypedServiceProviderHelpers, diagnostic.Id);
         }
 
+        [Fact]
+        public async Task ServiceProviderShimAnalyzer_ShouldReportAndFix_FunctionContextInstanceServicesReturnsUsage()
+        {
+            const string SOURCE = @"
+using System;
+using FastMoq;
+using FastMoq.Providers.MoqProvider;
+
+namespace Microsoft.Azure.Functions.Worker
+{
+    abstract class FunctionContext
+    {
+        public virtual IServiceProvider InstanceServices { get; set; }
+    }
+}
+
+class Sample
+{
+    void Execute(Mocker Mocks, IServiceProvider provider)
+    {
+        var context = Mocks.GetOrCreateMock<Microsoft.Azure.Functions.Worker.FunctionContext>();
+        context.Setup(x => x.InstanceServices).Returns(provider);
+    }
+}";
+
+            var diagnostics = await AnalyzerTestHelpers.GetDiagnosticsAsync(SOURCE, new ServiceProviderShimAnalyzer());
+            var diagnostic = Assert.Single(diagnostics.Where(item => item.Id == DiagnosticIds.PreferTypedServiceProviderHelpers));
+            Assert.Equal(DiagnosticIds.PreferTypedServiceProviderHelpers, diagnostic.Id);
+
+            var fixedSource = await AnalyzerTestHelpers.ApplyCodeFixAsync(
+                SOURCE,
+                new ServiceProviderShimAnalyzer(),
+                codeFixProvider,
+                DiagnosticIds.PreferTypedServiceProviderHelpers,
+                includeAzureFunctionsHelpers: true);
+            var expected = AnalyzerTestHelpers.NormalizeCode(@"
+using System;
+using FastMoq;
+using FastMoq.Providers.MoqProvider;
+using FastMoq.AzureFunctions.Extensions;
+
+namespace Microsoft.Azure.Functions.Worker
+{
+    abstract class FunctionContext
+    {
+        public virtual IServiceProvider InstanceServices { get; set; }
+    }
+}
+
+class Sample
+{
+    void Execute(Mocker Mocks, IServiceProvider provider)
+    {
+        var context = Mocks.GetOrCreateMock<Microsoft.Azure.Functions.Worker.FunctionContext>();
+        context.AddFunctionContextInstanceServices(provider);
+    }
+}");
+
+            Assert.Equal(expected, fixedSource);
+        }
+
+        [Fact]
+        public async Task ServiceProviderShimAnalyzer_ShouldReportButNotOfferFix_WhenFunctionContextHelperPackageIsUnavailable()
+        {
+            const string SOURCE = @"
+using System;
+using FastMoq;
+using FastMoq.Providers.MoqProvider;
+
+namespace Microsoft.Azure.Functions.Worker
+{
+    abstract class FunctionContext
+    {
+        public virtual IServiceProvider InstanceServices { get; set; }
+    }
+}
+
+class Sample
+{
+    void Execute(Mocker Mocks, IServiceProvider provider)
+    {
+        var context = Mocks.GetOrCreateMock<Microsoft.Azure.Functions.Worker.FunctionContext>();
+        context.SetupGet(x => x.InstanceServices).Returns(provider);
+    }
+}";
+
+            var diagnostics = await AnalyzerTestHelpers.GetDiagnosticsAsync(SOURCE, new ServiceProviderShimAnalyzer());
+            var diagnostic = Assert.Single(diagnostics.Where(item => item.Id == DiagnosticIds.PreferTypedServiceProviderHelpers));
+            Assert.Equal(DiagnosticIds.PreferTypedServiceProviderHelpers, diagnostic.Id);
+
+            var codeFixTitles = await AnalyzerTestHelpers.GetCodeFixTitlesAsync(
+                SOURCE,
+                new ServiceProviderShimAnalyzer(),
+                codeFixProvider,
+                DiagnosticIds.PreferTypedServiceProviderHelpers);
+
+            Assert.Empty(codeFixTitles);
+        }
+
+        [Fact]
+        public async Task ServiceProviderShimAnalyzer_ShouldReportAndFix_FunctionContextInstanceServicesSetupPropertyUsage()
+        {
+            const string SOURCE = @"
+using System;
+using FastMoq;
+using FastMoq.Providers.MoqProvider;
+
+namespace Microsoft.Azure.Functions.Worker
+{
+    abstract class FunctionContext
+    {
+        public virtual IServiceProvider InstanceServices { get; set; }
+    }
+}
+
+class Sample
+{
+    void Execute(Mocker Mocks, IServiceProvider provider)
+    {
+        var context = Mocks.GetOrCreateMock<Microsoft.Azure.Functions.Worker.FunctionContext>();
+        context.AsMoq().SetupProperty(x => x.InstanceServices, provider);
+    }
+}";
+
+            var diagnostics = await AnalyzerTestHelpers.GetDiagnosticsAsync(SOURCE, new ServiceProviderShimAnalyzer());
+            var diagnostic = Assert.Single(diagnostics.Where(item => item.Id == DiagnosticIds.PreferTypedServiceProviderHelpers));
+            Assert.Equal(DiagnosticIds.PreferTypedServiceProviderHelpers, diagnostic.Id);
+
+            var fixedSource = await AnalyzerTestHelpers.ApplyCodeFixAsync(
+                SOURCE,
+                new ServiceProviderShimAnalyzer(),
+                codeFixProvider,
+                DiagnosticIds.PreferTypedServiceProviderHelpers,
+                includeAzureFunctionsHelpers: true);
+            var expected = AnalyzerTestHelpers.NormalizeCode(@"
+using System;
+using FastMoq;
+using FastMoq.Providers.MoqProvider;
+using FastMoq.AzureFunctions.Extensions;
+
+namespace Microsoft.Azure.Functions.Worker
+{
+    abstract class FunctionContext
+    {
+        public virtual IServiceProvider InstanceServices { get; set; }
+    }
+}
+
+class Sample
+{
+    void Execute(Mocker Mocks, IServiceProvider provider)
+    {
+        var context = Mocks.GetOrCreateMock<Microsoft.Azure.Functions.Worker.FunctionContext>();
+        context.AddFunctionContextInstanceServices(provider);
+    }
+}");
+
+            Assert.Equal(expected, fixedSource);
+        }
+
         [Fact]
         public async Task KnownTypeAuthoringAnalyzer_ShouldReport_WhenContextAwareAddTypeOverloadIsUsed()
         {

FastMoq.Analyzers/CodeFixes/FastMoqMigrationCodeFixProvider.cs

@@ -20,6 +20,7 @@ public sealed class FastMoqMigrationCodeFixProvider : CodeFixProvider
             DiagnosticIds.UseVerifyLogged,
             DiagnosticIds.UseConsistentMockRetrieval,
             DiagnosticIds.UseProviderFirstMockRetrieval,
+            DiagnosticIds.PreferTypedServiceProviderHelpers,
             DiagnosticIds.UseExplicitOptionalParameterResolution,
             DiagnosticIds.ReplaceInitializeCompatibilityWrapper,
             DiagnosticIds.PreferSetupOptionsHelper);
@@ -107,6 +108,31 @@ public override async Task RegisterCodeFixesAsync(CodeFixContext context)
                         break;
                     }
 
+                case DiagnosticIds.PreferTypedServiceProviderHelpers:
+                    {
+                        var invocationExpression = root.FindNode(diagnostic.Location.SourceSpan).FirstAncestorOrSelf<InvocationExpressionSyntax>();
+                        if (invocationExpression is null)
+                        {
+                            return;
+                        }
+
+                        var semanticModel = await document.GetSemanticModelAsync(context.CancellationToken).ConfigureAwait(false);
+                        if (semanticModel is null ||
+                            !FastMoqAnalysisHelpers.HasFunctionContextInstanceServicesMockHelper(semanticModel) ||
+                            !FastMoqAnalysisHelpers.TryBuildFunctionContextInstanceServicesReplacement(invocationExpression, semanticModel, context.CancellationToken, out _, out _))
+                        {
+                            return;
+                        }
+
+                        context.RegisterCodeFix(
+                            CodeAction.Create(
+                                "Use AddFunctionContextInstanceServices(...)",
+                                cancellationToken => ReplaceFunctionContextInstanceServicesInvocationAsync(document, invocationExpression, cancellationToken),
+                                nameof(DiagnosticIds.PreferTypedServiceProviderHelpers)),
+                            diagnostic);
+                        break;
+                    }
+
                 case DiagnosticIds.UseExplicitOptionalParameterResolution:
                     {
                         var assignmentExpression = root.FindNode(diagnostic.Location.SourceSpan).FirstAncestorOrSelf<AssignmentExpressionSyntax>();
@@ -302,11 +328,27 @@ private static async Task<Document> ReplaceSetupOptionsInvocationAsync(Document
                 .WithTriviaFrom(invocationExpression);
             var updatedRoot = root.ReplaceNode(invocationExpression, replacementExpression);
 
-            if (updatedRoot is CompilationUnitSyntax compilationUnit && !compilationUnit.Usings.Any(@using => @using.Name?.ToString() == "FastMoq.Extensions"))
+            return document.WithSyntaxRoot(AddUsingDirectiveIfMissing(updatedRoot, "FastMoq.Extensions"));
+        }
+
+        private static async Task<Document> ReplaceFunctionContextInstanceServicesInvocationAsync(Document document, InvocationExpressionSyntax invocationExpression, CancellationToken cancellationToken)
+        {
+            var root = await document.GetSyntaxRootAsync(cancellationToken).ConfigureAwait(false);
+            var semanticModel = await document.GetSemanticModelAsync(cancellationToken).ConfigureAwait(false);
+            if (root is null || semanticModel is null)
             {
-                updatedRoot = compilationUnit.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName("FastMoq.Extensions")));
+                return document;
             }
 
+            if (!FastMoqAnalysisHelpers.TryBuildFunctionContextInstanceServicesReplacement(invocationExpression, semanticModel, cancellationToken, out var targetInvocation, out var replacementText))
+            {
+                return document;
+            }
+
+            var replacementExpression = SyntaxFactory.ParseExpression(replacementText)
+                .WithTriviaFrom(targetInvocation);
+            var updatedRoot = root.ReplaceNode(targetInvocation, replacementExpression);
+            updatedRoot = AddUsingDirectiveIfMissing(updatedRoot, "FastMoq.AzureFunctions.Extensions");
             return document.WithSyntaxRoot(updatedRoot);
         }
 
@@ -326,6 +368,16 @@ private static async Task<Document> ReplaceGetMockAsync(Document document, Membe
             return document.WithSyntaxRoot(updatedRoot);
         }
 
+        private static SyntaxNode AddUsingDirectiveIfMissing(SyntaxNode root, string namespaceName)
+        {
+            if (root is CompilationUnitSyntax compilationUnit && !compilationUnit.Usings.Any(@using => @using.Name?.ToString() == namespaceName))
+            {
+                return compilationUnit.AddUsings(SyntaxFactory.UsingDirective(SyntaxFactory.ParseName(namespaceName)));
+            }
+
+            return root;
+        }
+
         private delegate string? ReplacementBuilder(Document document, SemanticModel semanticModel, SyntaxNode syntaxNode, CancellationToken cancellationToken);
     }
 }