Allow event monitoring to ignore failing event accessors

Src/FluentAssertions/AssertionExtensions.cs

@@ -360,7 +360,8 @@ public static StringCollectionAssertions Should(this IEnumerable<string> @this)
     /// current <see cref="IDictionary{TKey, TValue}"/>.
     /// </summary>
     [Pure]
-    public static GenericDictionaryAssertions<IDictionary<TKey, TValue>, TKey, TValue> Should<TKey, TValue>(this IDictionary<TKey, TValue> actualValue)
+    public static GenericDictionaryAssertions<IDictionary<TKey, TValue>, TKey, TValue> Should<TKey, TValue>(
+        this IDictionary<TKey, TValue> actualValue)
     {
         return new GenericDictionaryAssertions<IDictionary<TKey, TValue>, TKey, TValue>(actualValue);
     }
@@ -370,7 +371,8 @@ public static StringCollectionAssertions Should(this IEnumerable<string> @this)
     /// current <see cref="IEnumerable{T}"/> of <see cref="KeyValuePair{TKey, TValue}"/>.
     /// </summary>
     [Pure]
-    public static GenericDictionaryAssertions<IEnumerable<KeyValuePair<TKey, TValue>>, TKey, TValue> Should<TKey, TValue>(this IEnumerable<KeyValuePair<TKey, TValue>> actualValue)
+    public static GenericDictionaryAssertions<IEnumerable<KeyValuePair<TKey, TValue>>, TKey, TValue> Should<TKey, TValue>(
+        this IEnumerable<KeyValuePair<TKey, TValue>> actualValue)
     {
         return new GenericDictionaryAssertions<IEnumerable<KeyValuePair<TKey, TValue>>, TKey, TValue>(actualValue);
     }
@@ -380,7 +382,8 @@ public static StringCollectionAssertions Should(this IEnumerable<string> @this)
     /// current <typeparamref name="TCollection"/>.
     /// </summary>
     [Pure]
-    public static GenericDictionaryAssertions<TCollection, TKey, TValue> Should<TCollection, TKey, TValue>(this TCollection actualValue)
+    public static GenericDictionaryAssertions<TCollection, TKey, TValue> Should<TCollection, TKey, TValue>(
+        this TCollection actualValue)
         where TCollection : IEnumerable<KeyValuePair<TKey, TValue>>
     {
         return new GenericDictionaryAssertions<TCollection, TKey, TValue>(actualValue);
@@ -916,7 +919,27 @@ public static TaskCompletionSourceAssertions<T> Should<T>(this TaskCompletionSou
     /// <exception cref="ArgumentNullException">Thrown if <paramref name="eventSource"/> is Null.</exception>
     public static IMonitor<T> Monitor<T>(this T eventSource, Func<DateTime> utcNow = null)
     {
-        return new EventMonitor<T>(eventSource, utcNow ?? (() => DateTime.UtcNow));
+        return Monitor(eventSource, o =>
+        {
+            o.ConfigureTimestampProvider(utcNow);
+        });
+    }
+
+    /// <summary>
+    /// Starts monitoring <paramref name="eventSource"/> for its events using the given <paramref name="configureOptions"/>.
+    /// </summary>
+    /// <param name="eventSource">The object for which to monitor the events.</param>
+    /// <param name="configureOptions">
+    /// Options to configure the EventMonitor.
+    /// </param>
+    /// <exception cref="ArgumentNullException">Thrown if <paramref name="eventSource"/> is Null.</exception>
+    public static IMonitor<T> Monitor<T>(this T eventSource, Action<EventMonitorOptions> configureOptions)
+    {
+        Guard.ThrowIfArgumentIsNull(configureOptions, nameof(configureOptions));
+
+        var options = new EventMonitorOptions();
+        configureOptions(options);
+        return new EventMonitor<T>(eventSource, options);
     }
 
 #endif
@@ -968,7 +991,7 @@ public static void Should<TAssertions>(this DateTimeOffsetAssertions<TAssertions
         InvalidShouldCall();
     }
 
-#if  NET6_0_OR_GREATER
+#if NET6_0_OR_GREATER
 
     /// <inheritdoc cref="Should(ExecutionTimeAssertions)" />
     [Obsolete("You are asserting the 'AndConstraint' itself. Remove the 'Should()' method directly following 'And'", error: true)]
@@ -1078,7 +1101,8 @@ public static void Should<TAssertions>(this DateTimeOffsetRangeAssertions<TAsser
     [DoesNotReturn]
     private static void InvalidShouldCall()
     {
-        throw new InvalidOperationException("You are asserting the 'AndConstraint' itself. Remove the 'Should()' method directly following 'And'.");
+        throw new InvalidOperationException(
+            "You are asserting the 'AndConstraint' itself. Remove the 'Should()' method directly following 'And'.");
     }
 
     #endregion

Src/FluentAssertions/Events/EventMonitor.cs

@@ -19,18 +19,22 @@ internal class EventMonitor<T> : IMonitor<T>
     private readonly ConcurrentDictionary<string, EventRecorder> recorderMap =
         new ConcurrentDictionary<string, EventRecorder>();
 
-    public EventMonitor(object eventSource, Func<DateTime> utcNow)
+    public EventMonitor(object eventSource, EventMonitorOptions options)
     {
         Guard.ThrowIfArgumentIsNull(eventSource, nameof(eventSource), "Cannot monitor the events of a <null> object.");
+        Guard.ThrowIfArgumentIsNull(eventSource, nameof(eventSource), "Event monitor needs configuration.");
+
+        this.options = options;
 
         subject = new WeakReference(eventSource);
 
-        Attach(typeof(T), utcNow);
+        Attach(typeof(T), this.options.TimestampProvider);
     }
 
     public T Subject => (T)subject.Target;
 
     private readonly ThreadSafeSequenceGenerator threadSafeSequenceGenerator = new();
+    private readonly EventMonitorOptions options;
 
     public EventMetadata[] MonitoredEvents
     {
@@ -117,20 +121,48 @@ public void Dispose()
     {
         foreach (EventRecorder recorder in recorderMap.Values)
         {
-            recorder.Dispose();
+            DisposeSafeIfRequested(recorder);
         }
 
         recorderMap.Clear();
     }
 
+    private void DisposeSafeIfRequested(EventRecorder recorder)
+    {
+        try
+        {
+            recorder.Dispose();
+        }
+        catch when (options.ShouldIgnoreEventAccessorExceptions)
+        {
+            // ignore
+        }
+    }
+
     private void AttachEventHandler(EventInfo eventInfo, Func<DateTime> utcNow)
     {
         if (!recorderMap.TryGetValue(eventInfo.Name, out _))
         {
             var recorder = new EventRecorder(subject.Target, eventInfo.Name, utcNow, threadSafeSequenceGenerator);
             if (recorderMap.TryAdd(eventInfo.Name, recorder))
             {
-                recorder.Attach(subject, eventInfo);
+                AttachEventHandler(eventInfo, recorder);
+            }
+        }
+    }
+
+    private void AttachEventHandler(EventInfo eventInfo, EventRecorder recorder)
+    {
+        try
+        {
+            recorder.Attach(subject, eventInfo);
+        }
+        catch when (options.ShouldIgnoreEventAccessorExceptions)
+        {
+            if (!recorderMap.TryRemove(eventInfo.Name, out _))
+            {
+                throw new InvalidOperationException(
+                    $"Could not remove event {eventInfo.Name} with broken event accessor from event recording.");
             }
         }
     }

Src/FluentAssertions/Events/EventMonitorOptions.cs

@@ -0,0 +1,45 @@
+using System;
+using System.Collections.Generic;
+
+namespace FluentAssertions.Events;
+
+/// <summary>
+/// Settings for the <see cref="EventMonitor{T}"/>.
+/// </summary>
+public class EventMonitorOptions
+{
+    /// <summary>
+    /// Will ignore the events, if they throw an exception on any custom event accessor implementation. default: false.
+    /// </summary>
+    internal bool ShouldIgnoreEventAccessorExceptions { get; private set; }
+
+    /// <summary>
+    /// Func used to generate the timestamp.
+    /// </summary>
+    internal Func<DateTime> TimestampProvider { get; private set; } = () => DateTime.UtcNow;
+
+    /// <summary>
+    /// When called it will ignore event accessor Exceptions.
+    /// </summary>
+    /// <returns>The options instance for method stacking.</returns>
+    public EventMonitorOptions IgnoreEventAccessorExceptions()
+    {
+        ShouldIgnoreEventAccessorExceptions = true;
+        return this;
+    }
+
+    /// <summary>
+    /// Sets the timestamp provider. default it is <see cref="DateTime.Now"/>.
+    /// </summary>
+    /// <param name="timestampProvider">The timestamp provider.</param>
+    /// <returns>The options instance for method stacking.</returns>
+    internal EventMonitorOptions ConfigureTimestampProvider(Func<DateTime> timestampProvider)
+    {
+        if (timestampProvider != null)
+        {
+            TimestampProvider = timestampProvider;
+        }
+
+        return this;
+    }
+}

Tests/Approval.Tests/ApprovedApi/FluentAssertions/net47.verified.txt

@@ -38,6 +38,7 @@ namespace FluentAssertions
         public static FluentAssertions.Specialized.MemberExecutionTime<T> ExecutionTimeOf<T>(this T subject, System.Linq.Expressions.Expression<System.Action<T>> action, FluentAssertions.Common.StartTimer createTimer = null) { }
         public static System.Action Invoking<T>(this T subject, System.Action<T> action) { }
         public static System.Func<TResult> Invoking<T, TResult>(this T subject, System.Func<T, TResult> action) { }
+        public static FluentAssertions.Events.IMonitor<T> Monitor<T>(this T eventSource, System.Action<FluentAssertions.Events.EventMonitorOptions> configureOptions) { }
         public static FluentAssertions.Events.IMonitor<T> Monitor<T>(this T eventSource, System.Func<System.DateTime> utcNow = null) { }
         public static FluentAssertions.Specialized.ExecutionTimeAssertions Should(this FluentAssertions.Specialized.ExecutionTime executionTime) { }
         [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" +
@@ -1255,6 +1256,11 @@ namespace FluentAssertions.Events
         public string EventName { get; }
         public System.Type HandlerType { get; }
     }
+    public class EventMonitorOptions
+    {
+        public EventMonitorOptions() { }
+        public FluentAssertions.Events.EventMonitorOptions IgnoreEventAccessorExceptions() { }
+    }
     public interface IEventRecording : System.Collections.Generic.IEnumerable<FluentAssertions.Events.OccurredEvent>, System.Collections.IEnumerable
     {
         System.Type EventHandlerType { get; }

Tests/Approval.Tests/ApprovedApi/FluentAssertions/net6.0.verified.txt

@@ -38,6 +38,7 @@ namespace FluentAssertions
         public static FluentAssertions.Specialized.MemberExecutionTime<T> ExecutionTimeOf<T>(this T subject, System.Linq.Expressions.Expression<System.Action<T>> action, FluentAssertions.Common.StartTimer createTimer = null) { }
         public static System.Action Invoking<T>(this T subject, System.Action<T> action) { }
         public static System.Func<TResult> Invoking<T, TResult>(this T subject, System.Func<T, TResult> action) { }
+        public static FluentAssertions.Events.IMonitor<T> Monitor<T>(this T eventSource, System.Action<FluentAssertions.Events.EventMonitorOptions> configureOptions) { }
         public static FluentAssertions.Events.IMonitor<T> Monitor<T>(this T eventSource, System.Func<System.DateTime> utcNow = null) { }
         public static FluentAssertions.Specialized.ExecutionTimeAssertions Should(this FluentAssertions.Specialized.ExecutionTime executionTime) { }
         [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" +
@@ -1267,6 +1268,11 @@ namespace FluentAssertions.Events
         public string EventName { get; }
         public System.Type HandlerType { get; }
     }
+    public class EventMonitorOptions
+    {
+        public EventMonitorOptions() { }
+        public FluentAssertions.Events.EventMonitorOptions IgnoreEventAccessorExceptions() { }
+    }
     public interface IEventRecording : System.Collections.Generic.IEnumerable<FluentAssertions.Events.OccurredEvent>, System.Collections.IEnumerable
     {
         System.Type EventHandlerType { get; }

Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp2.1.verified.txt

@@ -38,6 +38,7 @@ namespace FluentAssertions
         public static FluentAssertions.Specialized.MemberExecutionTime<T> ExecutionTimeOf<T>(this T subject, System.Linq.Expressions.Expression<System.Action<T>> action, FluentAssertions.Common.StartTimer createTimer = null) { }
         public static System.Action Invoking<T>(this T subject, System.Action<T> action) { }
         public static System.Func<TResult> Invoking<T, TResult>(this T subject, System.Func<T, TResult> action) { }
+        public static FluentAssertions.Events.IMonitor<T> Monitor<T>(this T eventSource, System.Action<FluentAssertions.Events.EventMonitorOptions> configureOptions) { }
         public static FluentAssertions.Events.IMonitor<T> Monitor<T>(this T eventSource, System.Func<System.DateTime> utcNow = null) { }
         public static FluentAssertions.Specialized.ExecutionTimeAssertions Should(this FluentAssertions.Specialized.ExecutionTime executionTime) { }
         [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" +
@@ -1255,6 +1256,11 @@ namespace FluentAssertions.Events
         public string EventName { get; }
         public System.Type HandlerType { get; }
     }
+    public class EventMonitorOptions
+    {
+        public EventMonitorOptions() { }
+        public FluentAssertions.Events.EventMonitorOptions IgnoreEventAccessorExceptions() { }
+    }
     public interface IEventRecording : System.Collections.Generic.IEnumerable<FluentAssertions.Events.OccurredEvent>, System.Collections.IEnumerable
     {
         System.Type EventHandlerType { get; }

Tests/Approval.Tests/ApprovedApi/FluentAssertions/netcoreapp3.0.verified.txt

@@ -38,6 +38,7 @@ namespace FluentAssertions
         public static FluentAssertions.Specialized.MemberExecutionTime<T> ExecutionTimeOf<T>(this T subject, System.Linq.Expressions.Expression<System.Action<T>> action, FluentAssertions.Common.StartTimer createTimer = null) { }
         public static System.Action Invoking<T>(this T subject, System.Action<T> action) { }
         public static System.Func<TResult> Invoking<T, TResult>(this T subject, System.Func<T, TResult> action) { }
+        public static FluentAssertions.Events.IMonitor<T> Monitor<T>(this T eventSource, System.Action<FluentAssertions.Events.EventMonitorOptions> configureOptions) { }
         public static FluentAssertions.Events.IMonitor<T> Monitor<T>(this T eventSource, System.Func<System.DateTime> utcNow = null) { }
         public static FluentAssertions.Specialized.ExecutionTimeAssertions Should(this FluentAssertions.Specialized.ExecutionTime executionTime) { }
         [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" +
@@ -1255,6 +1256,11 @@ namespace FluentAssertions.Events
         public string EventName { get; }
         public System.Type HandlerType { get; }
     }
+    public class EventMonitorOptions
+    {
+        public EventMonitorOptions() { }
+        public FluentAssertions.Events.EventMonitorOptions IgnoreEventAccessorExceptions() { }
+    }
     public interface IEventRecording : System.Collections.Generic.IEnumerable<FluentAssertions.Events.OccurredEvent>, System.Collections.IEnumerable
     {
         System.Type EventHandlerType { get; }

Tests/Approval.Tests/ApprovedApi/FluentAssertions/netstandard2.1.verified.txt

@@ -38,6 +38,7 @@ namespace FluentAssertions
         public static FluentAssertions.Specialized.MemberExecutionTime<T> ExecutionTimeOf<T>(this T subject, System.Linq.Expressions.Expression<System.Action<T>> action, FluentAssertions.Common.StartTimer createTimer = null) { }
         public static System.Action Invoking<T>(this T subject, System.Action<T> action) { }
         public static System.Func<TResult> Invoking<T, TResult>(this T subject, System.Func<T, TResult> action) { }
+        public static FluentAssertions.Events.IMonitor<T> Monitor<T>(this T eventSource, System.Action<FluentAssertions.Events.EventMonitorOptions> configureOptions) { }
         public static FluentAssertions.Events.IMonitor<T> Monitor<T>(this T eventSource, System.Func<System.DateTime> utcNow = null) { }
         public static FluentAssertions.Specialized.ExecutionTimeAssertions Should(this FluentAssertions.Specialized.ExecutionTime executionTime) { }
         [System.Obsolete("You are asserting the \'AndConstraint\' itself. Remove the \'Should()\' method direct" +
@@ -1255,6 +1256,11 @@ namespace FluentAssertions.Events
         public string EventName { get; }
         public System.Type HandlerType { get; }
     }
+    public class EventMonitorOptions
+    {
+        public EventMonitorOptions() { }
+        public FluentAssertions.Events.EventMonitorOptions IgnoreEventAccessorExceptions() { }
+    }
     public interface IEventRecording : System.Collections.Generic.IEnumerable<FluentAssertions.Events.OccurredEvent>, System.Collections.IEnumerable
     {
         System.Type EventHandlerType { get; }