From 88b3ea9cee509cc5dccaac0cdf3acb0b3ed2be65 Mon Sep 17 00:00:00 2001 From: pedro-camargo-MSFT Date: Wed, 22 Jun 2022 15:43:48 -0700 Subject: [PATCH 1/4] Add analyzer issue #35816 --- .../src/Analyzers/DiagnosticDescriptors.cs | 9 + .../WebApplicationBuilderAnalyzer.cs | 37 +++ .../WebApplicationBuilder/WellKnownTypes.cs | 8 + .../DisallowConfigureHostLoggingTest.cs | 276 ++++++++++++++++++ 4 files changed, 330 insertions(+) create mode 100644 src/Framework/AspNetCoreAnalyzers/test/WebApplicationBuilder/DisallowConfigureHostLoggingTest.cs diff --git a/src/Framework/AspNetCoreAnalyzers/src/Analyzers/DiagnosticDescriptors.cs b/src/Framework/AspNetCoreAnalyzers/src/Analyzers/DiagnosticDescriptors.cs index c01db137deaa..aea3be7a92ec 100644 --- a/src/Framework/AspNetCoreAnalyzers/src/Analyzers/DiagnosticDescriptors.cs +++ b/src/Framework/AspNetCoreAnalyzers/src/Analyzers/DiagnosticDescriptors.cs @@ -79,4 +79,13 @@ internal static class DiagnosticDescriptors DiagnosticSeverity.Error, isEnabledByDefault: true, helpLinkUri: "https://aka.ms/aspnet/analyzers"); + + internal static readonly DiagnosticDescriptor DoNotUseHostConfigureLogging = new( + "ASP0011", + "Do not use ConfigureLogging with WebApplication.Host or WebApplication.WebHost", + "Favor using builder.Logging", + "Usage", + DiagnosticSeverity.Warning, + isEnabledByDefault: true, + helpLinkUri: "https://aka.ms/aspnet/analyzers"); } diff --git a/src/Framework/AspNetCoreAnalyzers/src/Analyzers/WebApplicationBuilder/WebApplicationBuilderAnalyzer.cs b/src/Framework/AspNetCoreAnalyzers/src/Analyzers/WebApplicationBuilder/WebApplicationBuilderAnalyzer.cs index 01cfdc829a71..9278c4817383 100644 --- a/src/Framework/AspNetCoreAnalyzers/src/Analyzers/WebApplicationBuilder/WebApplicationBuilderAnalyzer.cs +++ b/src/Framework/AspNetCoreAnalyzers/src/Analyzers/WebApplicationBuilder/WebApplicationBuilderAnalyzer.cs @@ -5,6 +5,7 @@ using System.Collections.Immutable; using System.Diagnostics; using System.Linq; +using System.Net.NetworkInformation; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; using Microsoft.CodeAnalysis.Diagnostics; @@ -21,6 +22,7 @@ public class WebApplicationBuilderAnalyzer : DiagnosticAnalyzer DiagnosticDescriptors.DoNotUseConfigureWebHostWithConfigureHostBuilder, DiagnosticDescriptors.DoNotUseConfigureWithConfigureWebHostBuilder, DiagnosticDescriptors.DoNotUseUseStartupWithConfigureWebHostBuilder, + DiagnosticDescriptors.DoNotUseHostConfigureLogging }); public override void Initialize(AnalysisContext context) @@ -44,6 +46,12 @@ public override void Initialize(AnalysisContext context) wellKnownTypes.HostingAbstractionsWebHostBuilderExtensions, wellKnownTypes.WebHostBuilderExtensions, }; + //add INamedTypeSymbol[] wellKnownTypes.OURANALYZER + INamedTypeSymbol[] configureLoggingTypes = + { + wellKnownTypes.HostingHostBuilderExtensions, + wellKnownTypes.WebHostBuilderExtensions + }; compilationStartAnalysisContext.RegisterOperationAction(operationAnalysisContext => { @@ -98,6 +106,35 @@ public override void Initialize(AnalysisContext context) invocation)); } + //Configure Logging + if (IsDisallowedMethod( + operationAnalysisContext, + invocation, + targetMethod, + wellKnownTypes.ConfigureHostBuilder, + "ConfigureLogging", + configureLoggingTypes)) + { + operationAnalysisContext.ReportDiagnostic( + CreateDiagnostic( + DiagnosticDescriptors.DoNotUseHostConfigureLogging, + invocation)); + } + + if (IsDisallowedMethod( + operationAnalysisContext, + invocation, + targetMethod, + wellKnownTypes.ConfigureWebHostBuilder, + "ConfigureLogging", + configureLoggingTypes)) + { + operationAnalysisContext.ReportDiagnostic( + CreateDiagnostic( + DiagnosticDescriptors.DoNotUseHostConfigureLogging, + invocation)); + } + static Diagnostic CreateDiagnostic(DiagnosticDescriptor descriptor, IInvocationOperation operation) { // Take the location for the whole invocation operation as a starting point. diff --git a/src/Framework/AspNetCoreAnalyzers/src/Analyzers/WebApplicationBuilder/WellKnownTypes.cs b/src/Framework/AspNetCoreAnalyzers/src/Analyzers/WebApplicationBuilder/WellKnownTypes.cs index d4c43aa2a843..0e2f1102d4d1 100644 --- a/src/Framework/AspNetCoreAnalyzers/src/Analyzers/WebApplicationBuilder/WellKnownTypes.cs +++ b/src/Framework/AspNetCoreAnalyzers/src/Analyzers/WebApplicationBuilder/WellKnownTypes.cs @@ -42,6 +42,12 @@ public static bool TryCreate(Compilation compilation, [NotNullWhen(true)] out We return false; } + const string HostingHostBuilderExtensions = "Microsoft.Extensions.Hosting.HostingHostBuilderExtensions"; + if (compilation.GetTypeByMetadataName(HostingHostBuilderExtensions) is not { } hostingHostBuilderExtensions) + { + return false; + } + wellKnownTypes = new WellKnownTypes { ConfigureHostBuilder = configureHostBuilder, @@ -49,6 +55,7 @@ public static bool TryCreate(Compilation compilation, [NotNullWhen(true)] out We GenericHostWebHostBuilderExtensions = genericHostWebHostBuilderExtensions, HostingAbstractionsWebHostBuilderExtensions = hostingAbstractionsWebHostBuilderExtensions, WebHostBuilderExtensions = webHostBuilderExtensions, + HostingHostBuilderExtensions = hostingHostBuilderExtensions }; return true; @@ -59,4 +66,5 @@ public static bool TryCreate(Compilation compilation, [NotNullWhen(true)] out We public INamedTypeSymbol GenericHostWebHostBuilderExtensions { get; private init; } public INamedTypeSymbol HostingAbstractionsWebHostBuilderExtensions { get; private init; } public INamedTypeSymbol WebHostBuilderExtensions { get; private init; } + public INamedTypeSymbol HostingHostBuilderExtensions { get; private init; } } diff --git a/src/Framework/AspNetCoreAnalyzers/test/WebApplicationBuilder/DisallowConfigureHostLoggingTest.cs b/src/Framework/AspNetCoreAnalyzers/test/WebApplicationBuilder/DisallowConfigureHostLoggingTest.cs new file mode 100644 index 000000000000..2cf4956b00f8 --- /dev/null +++ b/src/Framework/AspNetCoreAnalyzers/test/WebApplicationBuilder/DisallowConfigureHostLoggingTest.cs @@ -0,0 +1,276 @@ +// Licensed to the .NET Foundation under one or more agreements. +// The .NET Foundation licenses this file to you under the MIT license. +using System.Globalization; +using Microsoft.AspNetCore.Analyzer.Testing; +namespace Microsoft.AspNetCore.Analyzers.WebApplicationBuilder; +public partial class DisallowConfigureHostLoggingTest +{ + private TestDiagnosticAnalyzerRunner Runner { get; } = new(new WebApplicationBuilderAnalyzer()); + + [Fact] + public async Task DoesNotWarnWhenBuilderLoggingIsUsed() + { + //arrange + var source = @" +using Microsoft.AspNetCore.Builder; +using Microsoft.Extensions.Hosting; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +var builder = WebApplication.CreateBuilder(args); +builder.Logging.AddJsonConsole(); +"; + //act + var diagnostics = await Runner.GetDiagnosticsAsync(source); + //assert + Assert.Empty(diagnostics); + } + + [Fact] + public async Task DoesNotWarnWhenBuilderLoggingIsUsed_InMain() + { + //arrange + var source = @" +using Microsoft.AspNetCore.Builder; +using Microsoft.Extensions.Hosting; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +public static class Program +{ + public static void Main (string[] args) + { + var builder = WebApplication.CreateBuilder(args); + builder.Logging.AddJsonConsole(); + } +} +public class Startup { } +"; + //act + var diagnostics = await Runner.GetDiagnosticsAsync(source); + //assert + Assert.Empty(diagnostics); + } + + [Fact] + public async Task WarnsWhenBuilderLoggingIsNotUsed_Host() + { + //arrange + var source = TestSource.Read(@" +using Microsoft.AspNetCore.Builder; +using Microsoft.Extensions.Hosting; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +var builder = WebApplication.CreateBuilder(args); +builder.Host./*MM*/ConfigureLogging(logging => +{ +logging.AddJsonConsole(); +}); +"); + //act + var diagnostics = await Runner.GetDiagnosticsAsync(source.Source); + //assert + var diagnostic = Assert.Single(diagnostics); + Assert.Same(DiagnosticDescriptors.DoNotUseHostConfigureLogging, diagnostic.Descriptor); + AnalyzerAssert.DiagnosticLocation(source.DefaultMarkerLocation, diagnostic.Location); + Assert.Equal("Favor using builder.Logging", diagnostic.GetMessage(CultureInfo.InvariantCulture)); + } + + [Fact] + public async Task WarnsWhenBuilderLoggingIsNotUsed_WebHost() + { + //arrange + var source = TestSource.Read(@" +using Microsoft.AspNetCore.Builder; +using Microsoft.Extensions.Hosting; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using Microsoft.AspNetCore.Hosting; +var builder = WebApplication.CreateBuilder(args); +builder.WebHost./*MM*/ConfigureLogging(logging => +{ +logging.AddJsonConsole(); +}); +"); + //act + var diagnostics = await Runner.GetDiagnosticsAsync(source.Source); + //assert + var diagnostic = Assert.Single(diagnostics); + Assert.Same(DiagnosticDescriptors.DoNotUseHostConfigureLogging, diagnostic.Descriptor); + AnalyzerAssert.DiagnosticLocation(source.DefaultMarkerLocation, diagnostic.Location); + Assert.Equal("Favor using builder.Logging", diagnostic.GetMessage(CultureInfo.InvariantCulture)); + } + + [Fact] + public async Task WarnsWhenBuilderLoggingIsNotUsed_OnDifferentLine_Host() + { + //arrange + var source = TestSource.Read(@" +using Microsoft.AspNetCore.Builder; +using Microsoft.Extensions.Hosting; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +var builder = WebApplication.CreateBuilder(args); +builder.Host. + /*MM*/ConfigureLogging(logging => +{ + logging.AddJsonConsole(); +}); +"); + //act + var diagnostics = await Runner.GetDiagnosticsAsync(source.Source); + //assert + var diagnostic = Assert.Single(diagnostics); + Assert.Same(DiagnosticDescriptors.DoNotUseHostConfigureLogging, diagnostic.Descriptor); + AnalyzerAssert.DiagnosticLocation(source.DefaultMarkerLocation, diagnostic.Location); + Assert.Equal("Favor using builder.Logging", diagnostic.GetMessage(CultureInfo.InvariantCulture)); + } + + [Fact] + public async Task WarnsWhenBuilderLoggingIsNotUsed_OnDifferentLine_WebHost() + { + //arrange + var source = TestSource.Read(@" +using Microsoft.AspNetCore.Builder; +using Microsoft.Extensions.Hosting; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using Microsoft.AspNetCore.Hosting; +var builder = WebApplication.CreateBuilder(args); +builder.WebHost. + /*MM*/ConfigureLogging(logging => +{ +logging.AddJsonConsole(); +}); +"); + //act + var diagnostics = await Runner.GetDiagnosticsAsync(source.Source); + //assert + var diagnostic = Assert.Single(diagnostics); + Assert.Same(DiagnosticDescriptors.DoNotUseHostConfigureLogging, diagnostic.Descriptor); + AnalyzerAssert.DiagnosticLocation(source.DefaultMarkerLocation, diagnostic.Location); + Assert.Equal("Favor using builder.Logging", diagnostic.GetMessage(CultureInfo.InvariantCulture)); + } + + [Fact] + public async Task WarnsWhenBuilderLoggingIsNotUsed_InMain_Host() + { + //arrange + var source = TestSource.Read(@" +using Microsoft.AspNetCore.Builder; +using Microsoft.Extensions.Hosting; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +public static class Program +{ + public static void Main (string[] args) + { + var builder = WebApplication.CreateBuilder(args); + builder.Host./*MM*/ConfigureLogging(logging => + { + logging.AddJsonConsole(); + }); + } +} +public class Startup { } +"); + //act + var diagnostics = await Runner.GetDiagnosticsAsync(source.Source); + //assert + var diagnostic = Assert.Single(diagnostics); + Assert.Same(DiagnosticDescriptors.DoNotUseHostConfigureLogging, diagnostic.Descriptor); + AnalyzerAssert.DiagnosticLocation(source.DefaultMarkerLocation, diagnostic.Location); + Assert.Equal("Favor using builder.Logging", diagnostic.GetMessage(CultureInfo.InvariantCulture)); + } + + [Fact] + public async Task WarnsWhenBuilderLoggingIsNotUsed_InMain_WebHost() + { + //arrange + var source = TestSource.Read(@" +using Microsoft.AspNetCore.Builder; +using Microsoft.Extensions.Hosting; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using Microsoft.AspNetCore.Hosting; +public static class Program +{ + public static void Main (string[] args) + { + var builder = WebApplication.CreateBuilder(args); + builder.WebHost./*MM*/ConfigureLogging(logging => + { + logging.AddJsonConsole(); + }); + } +} +public class Startup { } +"); + //act + var diagnostics = await Runner.GetDiagnosticsAsync(source.Source); + //assert + var diagnostic = Assert.Single(diagnostics); + Assert.Same(DiagnosticDescriptors.DoNotUseHostConfigureLogging, diagnostic.Descriptor); + AnalyzerAssert.DiagnosticLocation(source.DefaultMarkerLocation, diagnostic.Location); + Assert.Equal("Favor using builder.Logging", diagnostic.GetMessage(CultureInfo.InvariantCulture)); + } + + [Fact] + public async Task WarnsWhenBuilderLoggingIsNotUsed_WhenChained_WebHost() + { + //arrange + var source = TestSource.Read(@" +using Microsoft.AspNetCore.Builder; +using Microsoft.Extensions.Hosting; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +using Microsoft.AspNetCore.Hosting; +var builder = WebApplication.CreateBuilder(args); +builder.WebHost. + /*MM*/ConfigureLogging(logging => { }) + .ConfigureServices(services => { }); +"); + //act + var diagnostics = await Runner.GetDiagnosticsAsync(source.Source); + //assert + var diagnostic = Assert.Single(diagnostics); + Assert.Same(DiagnosticDescriptors.DoNotUseHostConfigureLogging, diagnostic.Descriptor); + AnalyzerAssert.DiagnosticLocation(source.DefaultMarkerLocation, diagnostic.Location); + Assert.Equal("Favor using builder.Logging", diagnostic.GetMessage(CultureInfo.InvariantCulture)); + } + + [Fact] + public async Task WarnsTwiceWhenBuilderLoggingIsNotUsed_Host() + { + //arrange + var source = TestSource.Read(@" +using Microsoft.AspNetCore.Builder; +using Microsoft.Extensions.Hosting; +using Microsoft.Extensions.DependencyInjection; +using Microsoft.Extensions.Logging; +var builder = WebApplication.CreateBuilder(args); +builder.Host./*MM1*/ConfigureLogging(logging => +{ +logging.AddJsonConsole(); +}); +builder.Host./*MM2*/ConfigureLogging(logging => +{ +logging.AddJsonConsole(); +}); +"); + //act + var diagnostics = await Runner.GetDiagnosticsAsync(source.Source); + //assert + Assert.Equal(2, diagnostics.Length); + var diagnostic1 = diagnostics[0]; + var diagnostic2 = diagnostics[1]; + + Assert.Same(DiagnosticDescriptors.DoNotUseHostConfigureLogging, diagnostic1.Descriptor); + AnalyzerAssert.DiagnosticLocation(source.MarkerLocations["MM1"], diagnostic1.Location); + Assert.Equal("Favor using builder.Logging", diagnostic1.GetMessage(CultureInfo.InvariantCulture)); + + Assert.Same(DiagnosticDescriptors.DoNotUseHostConfigureLogging, diagnostic2.Descriptor); + AnalyzerAssert.DiagnosticLocation(source.MarkerLocations["MM2"], diagnostic2.Location); + Assert.Equal("Favor using builder.Logging", diagnostic2.GetMessage(CultureInfo.InvariantCulture)); + } + +} + From 606345dcebcb3ddeeb9bbbe8d21cc36ebbfe435d Mon Sep 17 00:00:00 2001 From: pedro-camargo-MSFT Date: Thu, 23 Jun 2022 09:36:38 -0700 Subject: [PATCH 2/4] Deleting uneccessary using statement and comment --- .../WebApplicationBuilder/WebApplicationBuilderAnalyzer.cs | 7 ++++--- 1 file changed, 4 insertions(+), 3 deletions(-) diff --git a/src/Framework/AspNetCoreAnalyzers/src/Analyzers/WebApplicationBuilder/WebApplicationBuilderAnalyzer.cs b/src/Framework/AspNetCoreAnalyzers/src/Analyzers/WebApplicationBuilder/WebApplicationBuilderAnalyzer.cs index 9278c4817383..fa0a3829b752 100644 --- a/src/Framework/AspNetCoreAnalyzers/src/Analyzers/WebApplicationBuilder/WebApplicationBuilderAnalyzer.cs +++ b/src/Framework/AspNetCoreAnalyzers/src/Analyzers/WebApplicationBuilder/WebApplicationBuilderAnalyzer.cs @@ -5,7 +5,6 @@ using System.Collections.Immutable; using System.Diagnostics; using System.Linq; -using System.Net.NetworkInformation; using Microsoft.CodeAnalysis; using Microsoft.CodeAnalysis.CSharp.Syntax; using Microsoft.CodeAnalysis.Diagnostics; @@ -46,7 +45,6 @@ public override void Initialize(AnalysisContext context) wellKnownTypes.HostingAbstractionsWebHostBuilderExtensions, wellKnownTypes.WebHostBuilderExtensions, }; - //add INamedTypeSymbol[] wellKnownTypes.OURANALYZER INamedTypeSymbol[] configureLoggingTypes = { wellKnownTypes.HostingHostBuilderExtensions, @@ -106,7 +104,8 @@ public override void Initialize(AnalysisContext context) invocation)); } - //Configure Logging + //var builder = WebApplication.CreateBuilder(args); + //builder.Host.ConfigureLogging(x => {}) if (IsDisallowedMethod( operationAnalysisContext, invocation, @@ -121,6 +120,8 @@ public override void Initialize(AnalysisContext context) invocation)); } + //var builder = WebApplication.CreateBuilder(args); + //builder.WebHost.ConfigureLogging(x => {}) if (IsDisallowedMethod( operationAnalysisContext, invocation, From 6cc36427274865aa6a73d3599277fde9a199f536 Mon Sep 17 00:00:00 2001 From: pedro-camargo-MSFT Date: Fri, 24 Jun 2022 14:38:24 -0700 Subject: [PATCH 3/4] Make DiagnosticDescriptor title and description consistent with other DiagnosticDescriptors --- .../src/Analyzers/DiagnosticDescriptors.cs | 4 ++-- .../WebApplicationBuilderAnalyzer.cs | 2 +- .../DisallowConfigureHostLoggingTest.cs | 20 ++++++++++--------- 3 files changed, 14 insertions(+), 12 deletions(-) diff --git a/src/Framework/AspNetCoreAnalyzers/src/Analyzers/DiagnosticDescriptors.cs b/src/Framework/AspNetCoreAnalyzers/src/Analyzers/DiagnosticDescriptors.cs index aea3be7a92ec..65e398b67345 100644 --- a/src/Framework/AspNetCoreAnalyzers/src/Analyzers/DiagnosticDescriptors.cs +++ b/src/Framework/AspNetCoreAnalyzers/src/Analyzers/DiagnosticDescriptors.cs @@ -82,8 +82,8 @@ internal static class DiagnosticDescriptors internal static readonly DiagnosticDescriptor DoNotUseHostConfigureLogging = new( "ASP0011", - "Do not use ConfigureLogging with WebApplication.Host or WebApplication.WebHost", - "Favor using builder.Logging", + "Suggest using builder.Logging over Host.ConfigureLogging or WebHost.ConfigureLoggin", + "Suggest using builder.Logging instead of {0}", "Usage", DiagnosticSeverity.Warning, isEnabledByDefault: true, diff --git a/src/Framework/AspNetCoreAnalyzers/src/Analyzers/WebApplicationBuilder/WebApplicationBuilderAnalyzer.cs b/src/Framework/AspNetCoreAnalyzers/src/Analyzers/WebApplicationBuilder/WebApplicationBuilderAnalyzer.cs index fa0a3829b752..0e1b4f220e4a 100644 --- a/src/Framework/AspNetCoreAnalyzers/src/Analyzers/WebApplicationBuilder/WebApplicationBuilderAnalyzer.cs +++ b/src/Framework/AspNetCoreAnalyzers/src/Analyzers/WebApplicationBuilder/WebApplicationBuilderAnalyzer.cs @@ -185,7 +185,7 @@ static Diagnostic CreateDiagnostic(DiagnosticDescriptor descriptor, IInvocationO location = Location.Create(operation.Syntax.SyntaxTree, targetSpan); } - return Diagnostic.Create(descriptor, location); + return Diagnostic.Create(descriptor, location, methodName); } }, OperationKind.Invocation); diff --git a/src/Framework/AspNetCoreAnalyzers/test/WebApplicationBuilder/DisallowConfigureHostLoggingTest.cs b/src/Framework/AspNetCoreAnalyzers/test/WebApplicationBuilder/DisallowConfigureHostLoggingTest.cs index 2cf4956b00f8..38934ee8d166 100644 --- a/src/Framework/AspNetCoreAnalyzers/test/WebApplicationBuilder/DisallowConfigureHostLoggingTest.cs +++ b/src/Framework/AspNetCoreAnalyzers/test/WebApplicationBuilder/DisallowConfigureHostLoggingTest.cs @@ -2,6 +2,8 @@ // The .NET Foundation licenses this file to you under the MIT license. using System.Globalization; using Microsoft.AspNetCore.Analyzer.Testing; +using Microsoft.CodeAnalysis; + namespace Microsoft.AspNetCore.Analyzers.WebApplicationBuilder; public partial class DisallowConfigureHostLoggingTest { @@ -71,7 +73,7 @@ public async Task WarnsWhenBuilderLoggingIsNotUsed_Host() var diagnostic = Assert.Single(diagnostics); Assert.Same(DiagnosticDescriptors.DoNotUseHostConfigureLogging, diagnostic.Descriptor); AnalyzerAssert.DiagnosticLocation(source.DefaultMarkerLocation, diagnostic.Location); - Assert.Equal("Favor using builder.Logging", diagnostic.GetMessage(CultureInfo.InvariantCulture)); + Assert.Equal("Suggest using builder.Logging instead of ConfigureLogging", diagnostic.GetMessage(CultureInfo.InvariantCulture)); } [Fact] @@ -96,7 +98,7 @@ public async Task WarnsWhenBuilderLoggingIsNotUsed_WebHost() var diagnostic = Assert.Single(diagnostics); Assert.Same(DiagnosticDescriptors.DoNotUseHostConfigureLogging, diagnostic.Descriptor); AnalyzerAssert.DiagnosticLocation(source.DefaultMarkerLocation, diagnostic.Location); - Assert.Equal("Favor using builder.Logging", diagnostic.GetMessage(CultureInfo.InvariantCulture)); + Assert.Equal("Suggest using builder.Logging instead of ConfigureLogging", diagnostic.GetMessage(CultureInfo.InvariantCulture)); } [Fact] @@ -121,7 +123,7 @@ public async Task WarnsWhenBuilderLoggingIsNotUsed_OnDifferentLine_Host() var diagnostic = Assert.Single(diagnostics); Assert.Same(DiagnosticDescriptors.DoNotUseHostConfigureLogging, diagnostic.Descriptor); AnalyzerAssert.DiagnosticLocation(source.DefaultMarkerLocation, diagnostic.Location); - Assert.Equal("Favor using builder.Logging", diagnostic.GetMessage(CultureInfo.InvariantCulture)); + Assert.Equal("Suggest using builder.Logging instead of ConfigureLogging", diagnostic.GetMessage(CultureInfo.InvariantCulture)); } [Fact] @@ -147,7 +149,7 @@ public async Task WarnsWhenBuilderLoggingIsNotUsed_OnDifferentLine_WebHost() var diagnostic = Assert.Single(diagnostics); Assert.Same(DiagnosticDescriptors.DoNotUseHostConfigureLogging, diagnostic.Descriptor); AnalyzerAssert.DiagnosticLocation(source.DefaultMarkerLocation, diagnostic.Location); - Assert.Equal("Favor using builder.Logging", diagnostic.GetMessage(CultureInfo.InvariantCulture)); + Assert.Equal("Suggest using builder.Logging instead of ConfigureLogging", diagnostic.GetMessage(CultureInfo.InvariantCulture)); } [Fact] @@ -178,7 +180,7 @@ public class Startup { } var diagnostic = Assert.Single(diagnostics); Assert.Same(DiagnosticDescriptors.DoNotUseHostConfigureLogging, diagnostic.Descriptor); AnalyzerAssert.DiagnosticLocation(source.DefaultMarkerLocation, diagnostic.Location); - Assert.Equal("Favor using builder.Logging", diagnostic.GetMessage(CultureInfo.InvariantCulture)); + Assert.Equal("Suggest using builder.Logging instead of ConfigureLogging", diagnostic.GetMessage(CultureInfo.InvariantCulture)); } [Fact] @@ -210,7 +212,7 @@ public class Startup { } var diagnostic = Assert.Single(diagnostics); Assert.Same(DiagnosticDescriptors.DoNotUseHostConfigureLogging, diagnostic.Descriptor); AnalyzerAssert.DiagnosticLocation(source.DefaultMarkerLocation, diagnostic.Location); - Assert.Equal("Favor using builder.Logging", diagnostic.GetMessage(CultureInfo.InvariantCulture)); + Assert.Equal("Suggest using builder.Logging instead of ConfigureLogging", diagnostic.GetMessage(CultureInfo.InvariantCulture)); } [Fact] @@ -234,7 +236,7 @@ public async Task WarnsWhenBuilderLoggingIsNotUsed_WhenChained_WebHost() var diagnostic = Assert.Single(diagnostics); Assert.Same(DiagnosticDescriptors.DoNotUseHostConfigureLogging, diagnostic.Descriptor); AnalyzerAssert.DiagnosticLocation(source.DefaultMarkerLocation, diagnostic.Location); - Assert.Equal("Favor using builder.Logging", diagnostic.GetMessage(CultureInfo.InvariantCulture)); + Assert.Equal("Suggest using builder.Logging instead of ConfigureLogging", diagnostic.GetMessage(CultureInfo.InvariantCulture)); } [Fact] @@ -265,11 +267,11 @@ public async Task WarnsTwiceWhenBuilderLoggingIsNotUsed_Host() Assert.Same(DiagnosticDescriptors.DoNotUseHostConfigureLogging, diagnostic1.Descriptor); AnalyzerAssert.DiagnosticLocation(source.MarkerLocations["MM1"], diagnostic1.Location); - Assert.Equal("Favor using builder.Logging", diagnostic1.GetMessage(CultureInfo.InvariantCulture)); + Assert.Equal("Suggest using builder.Logging instead of ConfigureLogging", diagnostic1.GetMessage(CultureInfo.InvariantCulture)); Assert.Same(DiagnosticDescriptors.DoNotUseHostConfigureLogging, diagnostic2.Descriptor); AnalyzerAssert.DiagnosticLocation(source.MarkerLocations["MM2"], diagnostic2.Location); - Assert.Equal("Favor using builder.Logging", diagnostic2.GetMessage(CultureInfo.InvariantCulture)); + Assert.Equal("Suggest using builder.Logging instead of ConfigureLogging", diagnostic2.GetMessage(CultureInfo.InvariantCulture)); } } From a1da1d4b8b1f6f6897ed966c759ea83e2a30305e Mon Sep 17 00:00:00 2001 From: pedro-camargo-MSFT <106186580+pedro-camargo-MSFT@users.noreply.github.com> Date: Tue, 28 Jun 2022 09:27:01 -0700 Subject: [PATCH 4/4] Update src/Framework/AspNetCoreAnalyzers/src/Analyzers/DiagnosticDescriptors.cs Co-authored-by: Safia Abdalla --- .../AspNetCoreAnalyzers/src/Analyzers/DiagnosticDescriptors.cs | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/src/Framework/AspNetCoreAnalyzers/src/Analyzers/DiagnosticDescriptors.cs b/src/Framework/AspNetCoreAnalyzers/src/Analyzers/DiagnosticDescriptors.cs index 65e398b67345..a2d5903de4e3 100644 --- a/src/Framework/AspNetCoreAnalyzers/src/Analyzers/DiagnosticDescriptors.cs +++ b/src/Framework/AspNetCoreAnalyzers/src/Analyzers/DiagnosticDescriptors.cs @@ -82,7 +82,7 @@ internal static class DiagnosticDescriptors internal static readonly DiagnosticDescriptor DoNotUseHostConfigureLogging = new( "ASP0011", - "Suggest using builder.Logging over Host.ConfigureLogging or WebHost.ConfigureLoggin", + "Suggest using builder.Logging over Host.ConfigureLogging or WebHost.ConfigureLogging", "Suggest using builder.Logging instead of {0}", "Usage", DiagnosticSeverity.Warning,