public void AnalyzeSymbol(SymbolAnalysisContext context)
{
Debug.Assert(context.Symbol.Kind == SymbolKind.NamedType);
var type = (INamedTypeSymbol)context.Symbol;
var optionsAnalysis = _context.GetRelatedSingletonAnalysis <OptionsAnalysis>(type);
if (optionsAnalysis == null)
{
return;
}
// Find the middleware analysis foreach of the Configure methods defined by this class and validate.
//
// Note that this doesn't attempt to handle inheritance scenarios.
foreach (var middlewareAnalysis in _context.GetRelatedAnalyses <MiddlewareAnalysis>(type))
{
foreach (var middlewareItem in middlewareAnalysis.Middleware)
{
if (middlewareItem.UseMethod.Name == "UseMvc" || middlewareItem.UseMethod.Name == "UseMvcWithDefaultRoute")
{
// Report a diagnostic if it's unclear that the user turned off Endpoint Routing.
if (!OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis))
{
context.ReportDiagnostic(Diagnostic.Create(
StartupAnalyzer.Diagnostics.UnsupportedUseMvcWithEndpointRouting,
middlewareItem.Operation.Syntax.GetLocation(),
middlewareItem.UseMethod.Name,
optionsAnalysis.ConfigureServicesMethod.Name));
}
}
}
}
}
public async Task StartupAnalyzer_MvcOptionsAnalysis_UseMvc_FindsEndpointRoutingDisabled()
{
// Arrange
var source = @"
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddMvc(options => options.EnableEndpointRouting = false);
var app = builder.Build();
app.UseMvcWithDefaultRoute();
app.Run();";
// Act
await VerifyAnalyzerAsync(source, DiagnosticResult.EmptyDiagnosticResults);
// Assert
var optionsAnalysis = Assert.Single(Analyses.OfType <OptionsAnalysis>());
Assert.True(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis));
var middlewareAnalysis = Assert.Single(Analyses.OfType <MiddlewareAnalysis>());
var middleware = Assert.Single(middlewareAnalysis.Middleware);
Assert.Equal("UseMvcWithDefaultRoute", middleware.UseMethod.Name);
}
public async Task StartupAnalyzer_MvcOptionsAnalysis_MultipleUseMvc()
{
// Arrange
var source = @"
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
namespace Microsoft.AspNetCore.Analyzers.TestFiles.StartupAnalyzerTest
{
public class MvcOptions_UseMvcMultiple
{
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc();
}
public void Configure(IApplicationBuilder app)
{
{|#0:app.UseMvcWithDefaultRoute()|};
app.UseStaticFiles();
app.UseMiddleware<AuthorizationMiddleware>();
{|#1:app.UseMvc()|};
app.UseRouting();
app.UseEndpoints(endpoints =>
{
});
{|#2:app.UseMvc()|};
}
}
}";
var diagnosticResults = new[]
{
new DiagnosticResult(StartupAnalyzer.Diagnostics.UnsupportedUseMvcWithEndpointRouting)
.WithLocation(0)
.WithArguments("UseMvcWithDefaultRoute", "ConfigureServices"),
new DiagnosticResult(StartupAnalyzer.Diagnostics.UnsupportedUseMvcWithEndpointRouting)
.WithLocation(1)
.WithArguments("UseMvc", "ConfigureServices"),
new DiagnosticResult(StartupAnalyzer.Diagnostics.UnsupportedUseMvcWithEndpointRouting)
.WithLocation(2)
.WithArguments("UseMvc", "ConfigureServices"),
};
// Act
await VerifyAnalyzerAsync(source, diagnosticResults);
// Assert
var optionsAnalysis = Analyses.OfType <OptionsAnalysis>().First();
Assert.False(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis));
}
public async Task StartupAnalyzer_WorksWithOtherMethodsInProgram()
{
// Arrange
var source = @"
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.AspNetCore.Authorization;
using Microsoft.AspNetCore.Mvc;
public class Program
{
public static void Main(string[] args)
{
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddMvc();
var app = builder.Build();
app.UseStaticFiles();
app.UseMiddleware<AuthorizationMiddleware>();
{|#0:app.UseMvc()|};
app.UseRouting();
app.UseEndpoints(endpoints =>
{
});
app.Run();
}
private static void MethodA()
{
}
private static void MethodB()
{
}
}";
var diagnosticResult = new DiagnosticResult(StartupAnalyzer.Diagnostics.UnsupportedUseMvcWithEndpointRouting)
.WithLocation(0)
.WithArguments("UseMvc", "Main");
// Act
await VerifyAnalyzerAsync(source, diagnosticResult);
// Assert
var optionsAnalysis = Analyses.OfType <OptionsAnalysis>().First();
Assert.False(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis));
var middlewareAnalysis = Analyses.OfType <MiddlewareAnalysis>().First();
Assert.Collection(
middlewareAnalysis.Middleware,
item => Assert.Equal("UseStaticFiles", item.UseMethod.Name),
item => Assert.Equal("UseMiddleware", item.UseMethod.Name),
item => Assert.Equal("UseMvc", item.UseMethod.Name),
item => Assert.Equal("UseRouting", item.UseMethod.Name),
item => Assert.Equal("UseEndpoints", item.UseMethod.Name));
}
private async Task VerifyMvcOptionsAnalysis(string source, string mvcMiddlewareName, params DiagnosticResult[] diagnosticResults)
{
// Arrange
await VerifyAnalyzerAsync(source, diagnosticResults);
// Assert
var optionsAnalysis = Analyses.OfType <OptionsAnalysis>().First();
Assert.False(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis));
var middlewareAnalysis = Analyses.OfType <MiddlewareAnalysis>().First();
var middleware = Assert.Single(middlewareAnalysis.Middleware);
Assert.Equal(mvcMiddlewareName, middleware.UseMethod.Name);
}
public async Task StartupAnalyzer_MvcOptionsAnalysis_MultipleUseMvc()
{
// Arrange
var source = @"
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
using Microsoft.AspNetCore.Authorization;
var builder = WebApplication.CreateBuilder(args);
builder.Services.AddMvc();
var app = builder.Build();
{|#0:app.UseMvcWithDefaultRoute()|};
app.UseStaticFiles();
app.UseMiddleware<AuthorizationMiddleware>();
{|#1:app.UseMvc()|};
app.UseRouting();
app.UseEndpoints(endpoints =>
{
});
{|#2:app.UseMvc()|};
app.Run();";
var diagnosticResults = new[]
{
new DiagnosticResult(StartupAnalyzer.Diagnostics.UnsupportedUseMvcWithEndpointRouting)
.WithLocation(0)
.WithArguments("UseMvcWithDefaultRoute", TopLevelMainName),
new DiagnosticResult(StartupAnalyzer.Diagnostics.UnsupportedUseMvcWithEndpointRouting)
.WithLocation(1)
.WithArguments("UseMvc", TopLevelMainName),
new DiagnosticResult(StartupAnalyzer.Diagnostics.UnsupportedUseMvcWithEndpointRouting)
.WithLocation(2)
.WithArguments("UseMvc", TopLevelMainName),
};
// Act
await VerifyAnalyzerAsync(source, diagnosticResults);
// Assert
var optionsAnalysis = Analyses.OfType <OptionsAnalysis>().First();
Assert.False(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis));
}
public async Task StartupAnalyzer_MvcOptionsAnalysis_AddMvcOptions_FindsEndpointRoutingDisabled()
{
// Arrange
var source = @"
using Microsoft.AspNetCore.Builder;
using Microsoft.Extensions.DependencyInjection;
namespace Microsoft.AspNetCore.Analyzers.TestFiles.StartupAnalyzerTest
{
public class MvcOptions_UseMvcWithDefaultRouteAndAddMvcOptionsEndpointRoutingDisabled
{
public void ConfigureServices(IServiceCollection services)
{
services.AddMvc().AddMvcOptions(options => options.EnableEndpointRouting = false);
}
public void Configure(IApplicationBuilder app)
{
app.UseMvcWithDefaultRoute();
}
}
}
";
// Act
await VerifyAnalyzerAsync(source, DiagnosticResult.EmptyDiagnosticResults);
// Assert
var optionsAnalysis = Assert.Single(Analyses.OfType <OptionsAnalysis>());
Assert.True(OptionsFacts.IsEndpointRoutingExplicitlyDisabled(optionsAnalysis));
var middlewareAnalysis = Assert.Single(Analyses.OfType <MiddlewareAnalysis>());
var middleware = Assert.Single(middlewareAnalysis.Middleware);
Assert.Equal("UseMvcWithDefaultRoute", middleware.UseMethod.Name);
}
