public static IServiceCollection AddExceptionMapper(this IServiceCollection services)
{
var options = new ExceptionMapperOptions {
ServiceName = Assembly.GetEntryAssembly().GetName().Name
};
return(AddExceptionMapperClasses(services, AppDomain.CurrentDomain.GetAssemblies(), options));
}
public static IServiceCollection AddExceptionMapper(this IServiceCollection services, params Type[] profileAssemblyMarkerTypes)
{
var options = new ExceptionMapperOptions {
ServiceName = Assembly.GetEntryAssembly().GetName().Name
};
return(AddExceptionMapperClasses(services, profileAssemblyMarkerTypes.Select(t => t.GetTypeInfo().Assembly), options));
}
public static IServiceCollection AddExceptionMapper(this IServiceCollection services, params Assembly[] assemblies)
{
var options = new ExceptionMapperOptions {
ServiceName = Assembly.GetEntryAssembly().GetName().Name
};
return(AddExceptionMapperClasses(services, assemblies, options));
}
public static IServiceCollection AddExceptionMapper(this IServiceCollection services, ExceptionMapperOptions options, params Assembly[] assemblies)
{
if (options == null)
{
options = new ExceptionMapperOptions();
}
if (options.ServiceName == null)
{
options.ServiceName = Assembly.GetEntryAssembly().GetName().Name;
}
return(AddExceptionMapperClasses(services, assemblies, options));
}
public static IServiceCollection AddExceptionMapper(this IServiceCollection services, ExceptionMapperOptions options)
{
if (options == null)
{
options = new ExceptionMapperOptions();
}
if (options.ServiceName == null)
{
options.ServiceName = Assembly.GetEntryAssembly().GetName().Name;
}
return(AddExceptionMapperClasses(services, AppDomain.CurrentDomain.GetAssemblies(), options));
}
/// <summary>Add ExceptionMapper to ServiceCollection with Options.</summary>
/// <param name="services">Current ServiceCollection.</param>
/// <param name="setupAction">Setup Options action.</param>
public static IServiceCollection AddExceptionMapper(this IServiceCollection services, Action <ExceptionMapperOptions> setupAction)
{
var options = new ExceptionMapperOptions();
setupAction(options);
var mapper = new ExceptionMapper(options);
services.AddSingleton <IExceptionMapper>(mapper);
return(services);
}
private HttpClient SetupServerWithControllers(bool useExceptionHandlerFilter, bool addExceptionListener, string testServiceName)
{
var options = new ExceptionMapperOptions
{
RespondWithDeveloperContext = true
};
if (testServiceName != null)
{
options.ServiceName = testServiceName;
}
return(ServerHelper.SetupServerWithControllers(
options =>
{
options.EnableEndpointRouting = false;
options.Filters.AddValidateModelFilter(1337);
if (useExceptionHandlerFilter && addExceptionListener)
{
options.Filters.AddApiExceptionFilter(ex => _exceptionSetByExceptionListener = ex, ex => throw new Exception("Should not crash the application."));
}
else if (useExceptionHandlerFilter)
{
options.Filters.AddApiExceptionFilter();
}
},
app =>
{
if (!useExceptionHandlerFilter && addExceptionListener)
{
app.UseApiExceptionHandler(ex => _exceptionSetByExceptionListener = ex);
}
else if (!useExceptionHandlerFilter)
{
app.UseApiExceptionHandler();
}
app.UseMiddleware <TestAddCustomHeaderMiddleware>();
app.UseRouting();
app.UseEndpoints(endpoints =>
{
endpoints.MapControllers();
});
},
_output,
options));
}
private static IServiceCollection AddExceptionMapperClasses(IServiceCollection services, IEnumerable <Assembly> assembliesToScan, ExceptionMapperOptions options)
{
// Just return if we've already added ExceptionMapper to avoid double-registration
if (services.Any(sd => sd.ServiceType == typeof(IExceptionMapper)))
{
return(services);
}
var allTypes = assembliesToScan
.SelectMany(a => a.DefinedTypes)
.ToArray();
var profileTypeInfo = typeof(IExceptionMappingProfile).GetTypeInfo();
var profiles = allTypes
.Where(t => profileTypeInfo.IsAssignableFrom(t) && !t.IsAbstract)
.ToArray();
return(services.AddSingleton <IExceptionMapper>(sp => new ExceptionMapper(profiles, options)));
}
public static HttpClient SetupServerWithControllers(Action <MvcOptions> mvcOptions, Action <IApplicationBuilder> appBuilder, ITestOutputHelper output, ExceptionMapperOptions exceptionMapperOptions = null)
{
var builder = new HostBuilder()
.ConfigureWebHost(webHost =>
{
webHost.UseTestServer();
webHost.ConfigureServices(services =>
{
var descriptor =
new ServiceDescriptor(
typeof(ILogger <ValidateModelFilter>),
TestLogger.Create <ValidateModelFilter>(output));
services.Replace(descriptor);
services.AddExceptionMapper(exceptionMapperOptions, typeof(ServerHelper));
services.AddControllers(mvcOptions)
.AddApplicationPart(typeof(ServerHelper).Assembly);
})
.Configure(appBuilder);
});
var host = builder.Start();
return(host.GetTestClient());
}
public static HttpClient SetupServerWithMvc(Action <MvcOptions> mvcOptions, Action <IApplicationBuilder> appBuilder, ITestOutputHelper output, ExceptionMapperOptions exceptionMapperOptions = null)
{
var builder = new WebHostBuilder()
.ConfigureServices(services =>
{
var descriptor =
new ServiceDescriptor(
typeof(ILogger <ValidateModelFilter>),
TestLogger.Create <ValidateModelFilter>(output));
services.Replace(descriptor);
services.AddExceptionMapper(exceptionMapperOptions, typeof(ServerHelper));
services.AddMvc(mvcOptions);
})
.Configure(appBuilder);
var server = new TestServer(builder);
return(server.CreateClient());
}
public static IServiceCollection AddExceptionMapper(this IServiceCollection services, ExceptionMapperOptions options, params Type[] profileAssemblyMarkerTypes)
{
return(AddExceptionMapperClasses(services, profileAssemblyMarkerTypes.Select(t => t.GetTypeInfo().Assembly), options));
}
public static IServiceCollection AddExceptionMapper(this IServiceCollection services, ExceptionMapperOptions options, params Assembly[] assemblies)
{
return(AddExceptionMapperClasses(services, assemblies, options));
}
public static IServiceCollection AddExceptionMapper(this IServiceCollection services, ExceptionMapperOptions options)
{
return(AddExceptionMapperClasses(services, AppDomain.CurrentDomain.GetAssemblies(), options));
}
private static IServiceCollection AddExceptionMapperClasses(IServiceCollection services, ExceptionMapperOptions options, TypeInfo[] typeInfos)
{
// Just return if we've already added ExceptionMapper to avoid double-registration
if (services.Any(sd => sd.ServiceType == typeof(IExceptionMapper)))
{
return(services);
}
var profileTypeInfo = typeof(IExceptionMappingProfile).GetTypeInfo();
var profiles = typeInfos
.Where(t => profileTypeInfo.IsAssignableFrom(t) && !t.IsAbstract)
.ToArray();
return(services.AddSingleton <IExceptionMapper>(sp => new ExceptionMapper(profiles, options ?? new ExceptionMapperOptions())));
}
private static IServiceCollection AddExceptionMapperClasses(IServiceCollection services, ExceptionMapperOptions options, IEnumerable <Assembly> assembliesToScan)
{
// Just return if we've already added ExceptionMapper to avoid double-registration
if (services.Any(sd => sd.ServiceType == typeof(IExceptionMapper)))
{
return(services);
}
var allTypes = assembliesToScan
.SelectMany(a => a.DefinedTypes)
.ToArray();
return(AddExceptionMapperClasses(services, options, allTypes));
}
public static IServiceCollection AddExceptionMapper(this IServiceCollection services, ExceptionMapperOptions options, params TypeInfo[] profileTypes)
{
return(AddExceptionMapperClasses(services, options, profileTypes));
}
