public void StopReportingAfterDaysValid()
{
Settings.StopReportingAfter = 99;
new BugReport().Report(new Exception(), ExceptionThread.Main);
Assert.Equal(1, Storer.GetReportCount());
Storer.TruncateReportFiles(0);
}
public void MaxQueuedReports()
{
Settings.MaxQueuedReports = 2;
new BugReport().Report(new Exception(), ExceptionThread.Main);
new BugReport().Report(new Exception(), ExceptionThread.Main);
new BugReport().Report(new Exception(), ExceptionThread.Main);
Assert.Equal(2, Storer.GetReportCount());
Storer.TruncateReportFiles(1);
Assert.Equal(1, Storer.GetReportCount());
Storer.TruncateReportFiles(0);
Assert.Equal(0, Storer.GetReportCount());
}
public void StoragePathWindowsTemp()
{
Settings.StoragePath = StoragePath.WindowsTemp;
new BugReport().Report(new Exception(), ExceptionThread.Main);
Assert.Equal(Storer.GetReportCount(), 1);
using (var storer = new Storer())
using (var stream = storer.GetFirstReportFile())
{
Assert.NotNull(stream);
Assert.True(storer.FilePath.Contains(Path.Combine(new[] { Path.GetTempPath(), Settings.EntryAssembly.GetName().Name })));
storer.DeleteCurrentReportFile();
}
Assert.Equal(Storer.GetReportCount(), 0);
}
public void StoragePathCustom()
{
Settings.StoragePath = "C:\\";
new BugReport().Report(new Exception(), ExceptionThread.Main);
Assert.Equal(Storer.GetReportCount(), 1);
using (var storer = new Storer())
using (var stream = storer.GetFirstReportFile())
{
Assert.NotNull(stream);
Assert.True(storer.FilePath.Contains("C:\\"));
storer.DeleteCurrentReportFile();
}
Assert.Equal(Storer.GetReportCount(), 0);
}
public void StoragePathCurrentDirectory()
{
Settings.StoragePath = StoragePath.CurrentDirectory;
new BugReport().Report(new Exception(), ExceptionThread.Main);
Assert.Equal(Storer.GetReportCount(), 1);
using (var storer = new Storer())
using (var stream = storer.GetFirstReportFile())
{
Assert.NotNull(stream);
Assert.True(storer.FilePath.Contains(Path.GetDirectoryName(Settings.EntryAssembly.Location)));
storer.DeleteCurrentReportFile();
}
Assert.Equal(Storer.GetReportCount(), 0);
}
public void MiniDumpTypeTiny()
{
Settings.MiniDumpType = MiniDumpType.Tiny;
new BugReport().Report(new Exception(), ExceptionThread.Main);
Assert.Equal(Storer.GetReportCount(), 1);
using (var storer = new Storer())
using (var stream = storer.GetFirstReportFile())
{
Assert.NotNull(stream);
Assert.InRange(stream.Length, 10 * 1024, 1 * 1024 * 1024);
storer.DeleteCurrentReportFile();
}
Assert.Equal(Storer.GetReportCount(), 0);
}
public void StoragePathIsolatedStorage()
{
Settings.StoragePath = StoragePath.IsolatedStorage;
new BugReport().Report(new Exception(), ExceptionThread.Main);
Assert.Equal(Storer.GetReportCount(), 1);
using (var storer = new Storer())
using (var stream = storer.GetFirstReportFile())
{
Assert.NotNull(stream);
var filePath = stream.GetType().GetField("m_FullPath", BindingFlags.Instance | BindingFlags.NonPublic).GetValue(stream).ToString();
Assert.True(filePath.Contains("IsolatedStorage"));
storer.DeleteCurrentReportFile();
}
Assert.Equal(Storer.GetReportCount(), 0);
}
public void MixedDestinations()
{
Settings.AddDestinationFromConnectionString(this.settings.ReadCustomDispatcherDestinationSettings(typeof(Mail).Name)[0]);
Settings.AddDestinationFromConnectionString(this.settings.ReadCustomDispatcherDestinationSettings(typeof(Http).Name)[0]);
Settings.AddDestinationFromConnectionString(this.settings.ReadCustomDispatcherDestinationSettings(typeof(Ftp).Name)[0]);
Settings.AddDestinationFromConnectionString(this.settings.ReadCustomDispatcherDestinationSettings(typeof(Redmine).Name)[0]);
// ToDo: Settings.Destination5 = this.settings.ReadCustomDispatcherDestinationSettings(Protocols.Trac)[0];
try
{
throw new DummyArgumentException();
}
catch (Exception exception)
{
Trace.WriteLine("Submitting bug report to 5 different destinations at once: Mail, HTTP, FTP, Redmine, Trac");
new BugReport().Report(exception, ExceptionThread.Main);
Assert.Equal(1, Storer.GetReportCount());
new Dispatcher(false); // Dispatch async = false;
Assert.Equal(0, Storer.GetReportCount());
}
}
public void HttpDispatcher()
{
var destinations = this.settings.ReadCustomDispatcherDestinationSettings(typeof(Http).Name);
foreach (var destination in destinations)
{
Settings.Destinations.Clear();
Settings.AddDestinationFromConnectionString(destination);
try
{
throw new DummyArgumentException();
}
catch (Exception exception)
{
Trace.WriteLine("Uploading report using HTTP with connection string: " + destination);
new BugReport().Report(exception, ExceptionThread.Main);
Assert.Equal(1, Storer.GetReportCount());
new Dispatcher(false); // Dispatch async = false;
Assert.Equal(0, Storer.GetReportCount());
}
}
Trace.WriteLine("HTTP uploads: " + destinations.Count);
}
public void RedmineDispatcher()
{
var destinations = this.settings.ReadCustomDispatcherDestinationSettings(typeof(Redmine).Name);
foreach (var destination in destinations)
{
Settings.Destinations.Clear();
Settings.AddDestinationFromConnectionString(destination);
try
{
throw new DummyArgumentException();
}
catch (Exception exception)
{
Trace.WriteLine("Submitting bug report to Redmine issue tracker with connection string: " + destination);
new BugReport().Report(exception, ExceptionThread.Main);
Assert.Equal(1, Storer.GetReportCount());
new Dispatcher(false); // Dispatch async = false;
Assert.Equal(0, Storer.GetReportCount());
}
}
Trace.WriteLine("Redmine submissions: " + destinations.Count);
}
public void StopReportingAfterDaysExpired()
{
Settings.StopReportingAfter = 0;
new BugReport().Report(new Exception(), ExceptionThread.Main);
Assert.Equal(0, Storer.GetReportCount());
}
private void CreateReportZip(SerializableException serializableException, Report report)
{
// Test if it has NOT been more than x many days since entry assembly was last modified)
if (Settings.StopReportingAfter < 0 ||
File.GetLastWriteTime(Settings.EntryAssembly.Location).AddDays(Settings.StopReportingAfter).CompareTo(DateTime.Now) > 0)
{
// Test if there is already more than enough queued report files
if (Settings.MaxQueuedReports < 0 || Storer.GetReportCount() < Settings.MaxQueuedReports)
{
var reportFileName = "Exception_" + DateTime.UtcNow.ToFileTime() + ".zip";
var minidumpFilePath = Path.Combine(
Environment.GetFolderPath(Environment.SpecialFolder.CommonApplicationData), "Exception_MiniDump_" + DateTime.UtcNow.ToFileTime() + ".mdmp");
using (var storer = new Storer())
using (var zipStorer = ZipStorer.Create(storer.CreateReportFile(reportFileName), string.Empty))
using (var stream = new MemoryStream())
{
// Store the exception
var serializer = new XmlSerializer(typeof(SerializableException));
serializer.Serialize(stream, serializableException);
stream.Position = 0;
zipStorer.AddStream(ZipStorer.Compression.Deflate, StoredItemFile.Exception, stream, DateTime.UtcNow, string.Empty);
// Store the report
stream.SetLength(0);
try
{
serializer = report.CustomInfo != null
? new XmlSerializer(typeof(Report), new[] { report.CustomInfo.GetType() })
: new XmlSerializer(typeof(Report));
serializer.Serialize(stream, report);
}
catch (Exception exception)
{
Logger.Error(
string.Format(
"The given custom info of type [{0}] cannot be serialized. Make sure that given type and inner types are XML serializable.",
report.CustomInfo.GetType()),
exception);
report.CustomInfo = null;
serializer = new XmlSerializer(typeof(Report));
serializer.Serialize(stream, report);
}
stream.Position = 0;
zipStorer.AddStream(ZipStorer.Compression.Deflate, StoredItemFile.Report, stream, DateTime.UtcNow, string.Empty);
// Add the memory minidump to the report file (only if configured so)
if (DumpWriter.Write(minidumpFilePath))
{
zipStorer.AddFile(ZipStorer.Compression.Deflate, minidumpFilePath, StoredItemFile.MiniDump, string.Empty);
File.Delete(minidumpFilePath);
}
// Add any user supplied files in the report (if any)
if (Settings.AdditionalReportFiles.Count != 0)
{
// ToDo: This needs a lot more work!
this.AddAdditionalFiles(zipStorer);
}
}
Logger.Trace("Created a new report file. Currently the number of report files queued to be send is: " + Storer.GetReportCount());
}
else
{
Logger.Trace(
"Current report count is at its limit as per 'Settings.MaxQueuedReports (" + Settings.MaxQueuedReports
+ ")' setting: Skipping bug report generation.");
}
}
else
{
Logger.Trace(
"As per setting 'Settings.StopReportingAfter(" + Settings.StopReportingAfter
+ ")', bug reporting feature was enabled for a certain amount of time which has now expired: Bug reporting is now disabled.");
// ToDo: Completely eliminate this with SettingsOverride.DisableReporting = true; since enumerating filesystem adds overhead);
if (Storer.GetReportCount() > 0)
{
Logger.Trace(
"As per setting 'Settings.StopReportingAfter(" + Settings.StopReportingAfter
+ ")', bug reporting feature was enabled for a certain amount of time which has now expired: Truncating all expired bug reports.");
Storer.TruncateReportFiles(0);
}
}
}
