public void MongoDBStorage()
{
var config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile(@"Configs\Storage.MongoDB.json")
.Build();
Assert.NotNull(config);
var exceptionalSection = config.GetSection("Exceptional");
Assert.NotNull(exceptionalSection);
var settings = new ExceptionalSettings();
exceptionalSection.Bind(settings);
// Store
Assert.NotNull(settings.Store);
Assert.Equal("Samples (ASP.NET Core MongoDB)", settings.Store.ApplicationName);
Assert.Equal("MongoDB", settings.Store.Type);
Assert.Equal("mongodb://localhost/test", settings.Store.ConnectionString);
Assert.IsType <MongoDBErrorStore>(settings.DefaultStore);
var store = settings.DefaultStore as MongoDBErrorStore;
Assert.Equal("Samples (ASP.NET Core MongoDB)", store.ApplicationName);
}
public void JSONStorage()
{
var config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile(@"Configs\Storage.JSON.json")
.Build();
Assert.NotNull(config);
var exceptionalSection = config.GetSection("Exceptional");
Assert.NotNull(exceptionalSection);
var settings = new ExceptionalSettings();
exceptionalSection.Bind(settings);
// Store
Assert.NotNull(settings.Store);
Assert.Equal("Samples (ASP.NET Core JSON)", settings.Store.ApplicationName);
Assert.Equal("JSON", settings.Store.Type);
Assert.Equal("/errors", settings.Store.Path);
Assert.Equal(200, settings.Store.Size);
Assert.IsType <JSONErrorStore>(settings.DefaultStore);
var jsonStore = settings.DefaultStore as JSONErrorStore;
Assert.Equal("Samples (ASP.NET Core JSON)", jsonStore.ApplicationName);
}
public void MySQLStorage()
{
var config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile(@"Configs\Storage.MySQL.json")
.Build();
Assert.NotNull(config);
var exceptionalSection = config.GetSection("Exceptional");
Assert.NotNull(exceptionalSection);
var settings = new ExceptionalSettings();
exceptionalSection.Bind(settings);
// Store
Assert.NotNull(settings.Store);
Assert.Equal("Samples (ASP.NET Core MySQL)", settings.Store.ApplicationName);
Assert.Equal("MySQL", settings.Store.Type);
Assert.Equal("Server=.;Database=Exceptions;Username=Exceptions;Pwd=myPassword!", settings.Store.ConnectionString);
Assert.IsType <MySQLErrorStore>(settings.DefaultStore);
var sqlStore = settings.DefaultStore as MySQLErrorStore;
Assert.Equal("Samples (ASP.NET Core MySQL)", sqlStore.ApplicationName);
}
public void PostgreSqlStorage()
{
var config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile(@"Configs\Storage.PostgreSql.json")
.Build();
Assert.NotNull(config);
var exceptionalSection = config.GetSection("Exceptional");
Assert.NotNull(exceptionalSection);
var settings = new ExceptionalSettings();
exceptionalSection.Bind(settings);
// Store
Assert.NotNull(settings.Store);
Assert.Equal("Samples (ASP.NET Core PostgreSql)", settings.Store.ApplicationName);
Assert.Equal("PostgreSql", settings.Store.Type);
Assert.Equal("Server=localhost;Port=5432;Database=Exceptions;User Id=postgres;Password=postgres;", settings.Store.ConnectionString);
Assert.IsType <PostgreSqlErrorStore>(settings.DefaultStore);
var sqlStore = settings.DefaultStore as PostgreSqlErrorStore;
Assert.Equal("Samples (ASP.NET Core PostgreSql)", sqlStore.ApplicationName);
}
public void SQLStorage()
{
var config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile(GetPath("Storage.SQL.json"))
.Build();
Assert.NotNull(config);
var exceptionalSection = config.GetSection("Exceptional");
Assert.NotNull(exceptionalSection);
var settings = new ExceptionalSettings();
exceptionalSection.Bind(settings);
// Store
Assert.NotNull(settings.Store);
Assert.Equal("Samples (ASP.NET Core SQL)", settings.Store.ApplicationName);
Assert.Equal("SQL", settings.Store.Type);
Assert.Equal("Server=.;Database=Local.Exceptions;Trusted_Connection=True;", settings.Store.ConnectionString);
Assert.Equal("MyExceptions", settings.Store.TableName);
Assert.IsType <SQLErrorStore>(settings.DefaultStore);
var sqlStore = settings.DefaultStore as SQLErrorStore;
Assert.Equal("Samples (ASP.NET Core SQL)", sqlStore.ApplicationName);
}
public async Task RendersExceptionalPage()
{
ExceptionalSettings settings = null;
var builder = new WebHostBuilder()
.ConfigureServices(services => services.AddExceptional(s =>
{
s.Store.ApplicationName = nameof(RendersExceptionalPage);
s.UseExceptionalPageOnThrow = true;
settings = s;
}))
.Configure(app =>
{
app.UseExceptional();
app.Run(_ => throw new Exception("Log me!"));
});
using (var server = new TestServer(builder))
{
using (var response = await server.CreateClient().GetAsync("").ConfigureAwait(false))
{
Assert.False(response.IsSuccessStatusCode);
Assert.Equal(System.Net.HttpStatusCode.InternalServerError, response.StatusCode);
var responseText = await response.Content.ReadAsStringAsync().ConfigureAwait(false);
Assert.Contains("var Exception = ", responseText);
Assert.Contains("An error was thrown during this request.", responseText);
Assert.Contains("Log me!", responseText);
}
var errors = await settings.DefaultStore.GetAllAsync(nameof(RendersExceptionalPage)).ConfigureAwait(false);
Assert.Single(errors);
Assert.Equal("Log me!", errors[0].Message);
}
}
public void UsingBindOverride()
{
var config = new ConfigurationBuilder()
.SetBasePath(Directory.GetCurrentDirectory())
.AddJsonFile(@"Configs\Full.json")
.Build();
Assert.NotNull(config);
var exceptionalSection = config.GetSection("Exceptional");
Assert.NotNull(exceptionalSection);
Assert.Equal("Exceptional", exceptionalSection.Key);
var settings = new ExceptionalSettings();
exceptionalSection.Bind(settings);
// Top level
Assert.NotNull(settings.DataIncludeRegex);
Assert.Matches(settings.DataIncludeRegex, "MyPrefix.Test");
Assert.True(settings.UseExceptionalPageOnThrow);
// Store
Assert.NotNull(settings.Store);
Assert.Equal("Samples (ASP.NET Core)", settings.Store.ApplicationName);
Assert.Equal("Memory", settings.Store.Type);
Assert.Equal(TimeSpan.FromMinutes(5), settings.Store.RollupPeriod);
Assert.Equal(100, settings.Store.BackupQueueSize);
// Ignore
Assert.NotNull(settings.Ignore);
Assert.Equal(2, settings.Ignore.Regexes.Count);
Assert.Contains(settings.Ignore.Regexes, r => r.IsMatch("Request timed out."));
Assert.Contains(settings.Ignore.Regexes, r => r.IsMatch("Top SECRET DATA."));
Assert.DoesNotContain(settings.Ignore.Regexes, r => r.IsMatch("Pickles"));
Assert.Equal(2, settings.Ignore.Types.Count);
Assert.Contains("MyNameSpace.MyException", settings.Ignore.Types);
Assert.Contains("MyNameSpace.NoLogPleaseException", settings.Ignore.Types);
// LogFilters
Assert.NotNull(settings.LogFilters);
Assert.Single(settings.LogFilters.Cookie);
Assert.Equal("**no tokens saved! pheww**", settings.LogFilters.Cookie["authToken"]);
Assert.Single(settings.LogFilters.Form);
Assert.Equal("*********", settings.LogFilters.Form["password"]);
Assert.Single(settings.LogFilters.Header);
Assert.Equal("*********", settings.LogFilters.Header["Accept-Language"]);
// Email
Assert.NotNull(settings.Email);
Assert.Equal("*****@*****.**", settings.Email.ToAddress);
Assert.Equal("*****@*****.**", settings.Email.FromAddress);
Assert.Equal("Wendy", settings.Email.FromDisplayName);
Assert.Equal("localhost", settings.Email.SMTPHost);
Assert.Equal(25, settings.Email.SMTPPort);
Assert.Equal("dummy", settings.Email.SMTPUserName);
Assert.Equal("pwd", settings.Email.SMTPPassword);
Assert.True(settings.Email.SMTPEnableSSL);
Assert.True(settings.Email.PreventDuplicates);
}
protected IWebHostBuilder BasicBuilder(RequestDelegate requestDelegate, [CallerMemberName] string name = null) =>
new WebHostBuilder()
.ConfigureServices(services => services.AddExceptional(s =>
{
s.SetDefaultStore(new MemoryErrorStore());
CurrentSettings = s;
}))
.Configure(app =>
{
app.UseExceptional();
app.Run(requestDelegate);
});
public void AddCommand()
{
var settings = new ExceptionalSettings();
var ex = new Exception();
var err = new Error(ex, settings);
err.AddCommand(
new Command("SQL", "Select * From MyTable")
.AddData("Server", "SQL01"));
Assert.Single(err.Commands);
Assert.Equal("SQL", err.Commands[0].Type);
Assert.Equal("Select * From MyTable", err.Commands[0].CommandString);
Assert.Single(err.Commands[0].Data);
Assert.Equal("SQL01", err.Commands[0].Data["Server"]);
}
public void RendersNullCustomData()
{
var settings = new ExceptionalSettings();
var ex = new Exception("My exception");
var error = new Error(ex, settings, initialCustomData: new Dictionary <string, string>
{
["MyData"] = null
});
var errorPage = new ErrorDetailPage(error, settings, settings.DefaultStore, "/", error.GUID);
Assert.NotNull(errorPage);
var rendered = errorPage.Render();
Assert.NotNull(rendered);
Assert.Contains("var Exception = ", rendered);
Assert.Contains("MyData", rendered);
}
public async Task ExceptionalStaticSet()
{
var appName = Guid.NewGuid().ToString();
ExceptionalSettings settings = null;
var builder = new WebHostBuilder()
.ConfigureServices(services => services.AddExceptional(s =>
{
settings = s;
settings.Store.ApplicationName = appName;
}))
.Configure(app => app.UseExceptional().Run(context => context.Response.WriteAsync("Hello World")));
using (var server = new TestServer(builder))
{
using (var response = await server.CreateClient().GetAsync("").ConfigureAwait(false))
{
Assert.Same(settings.Store.ApplicationName, Exceptional.Settings.Store.ApplicationName);
}
}
}
public void BeforeAbort()
{
bool beforeFired = false,
afterFired = false;
Error error = null;
var settings = new ExceptionalSettings();
settings.OnBeforeLog += (s, e) => { beforeFired = true; e.Abort = true; };
settings.OnAfterLog += (s, e) => { afterFired = true; error = e.Error; };
var ex = new Exception();
var err = new Error(ex, settings);
Assert.False(beforeFired);
Assert.False(afterFired);
Assert.False(err.LogToStore());
Assert.True(beforeFired);
Assert.False(afterFired);
Assert.Null(error);
}
public void Serialization()
{
var settings = new ExceptionalSettings();
var ex = new Exception();
var err = new Error(ex, settings);
err.AddCommand(
new Command("SQL", "Select * From MyTable")
.AddData("Server", "SQL01"));
var json = err.ToJson();
Assert.Contains("Select * From MyTable", json);
var derr = Error.FromJson(json);
Assert.Single(derr.Commands);
Assert.Equal("SQL", derr.Commands[0].Type);
Assert.Equal("Select * From MyTable", derr.Commands[0].CommandString);
Assert.Single(derr.Commands[0].Data);
Assert.Equal("SQL01", derr.Commands[0].Data["Server"]);
}
