Event traffic calming

using System;
using System.Linq.Expressions;
using System.Threading;
using NUnit.Framework;

namespace TrafficCalming.Tests
{
    [TestFixture]
    public class EventCalmerFixture
    {
        private static readonly TimeSpan WaitTime = TimeSpan.FromMilliseconds(100);

        private EventCalmer _calmer;

        [SetUp]
        public void Setup()
        {
            _calmer = new EventCalmer(WaitTime);
        }

        [Test]
        public void Can_create_instances()
        {
            Assert.That(_calmer, Is.Not.Null);
        }

        [Test]
        public void HandleEvent_triggers_EventOcurred_as_soon_as_posible()
        {
            var untilEventHasBeenTriggered = new ManualResetEvent(false);
            _calmer.EventOccurred += (s,e) => 
                untilEventHasBeenTriggered.Set();

            _calmer.HandleEvent(this, EventArgs.Empty);

            var didNotTimedOut = untilEventHasBeenTriggered.WaitOne(1000);
            Assert.That(didNotTimedOut);
        }

        [Test]
        public void HandleEvent_twice_triggers_EventOcurred_only_once_in_time_frame_smaller_than_waitime()
        {
            var eventOcurredTriggeredCount = 0;
            _calmer.EventOccurred += (s, e) =>
                eventOcurredTriggeredCount++;

            _calmer.HandleEvent(this, EventArgs.Empty);
            _calmer.HandleEvent(this, EventArgs.Empty);

            Assert.That(eventOcurredTriggeredCount, Is.LessThan(2));
        }

        [Test]
        public void HandleEvent_does_not_block_main_thread()
        {
            _calmer.EventOccurred += (s, e) =>
                Thread.Sleep(200);

            ExecuteWithTimeout(() => 
                _calmer.HandleEvent(this, EventArgs.Empty), 10);
        }

        private static void ExecuteWithTimeout(Expression<Action> expression, int timeoutMillis)
        {
            var untilActionFinishes = new ManualResetEvent(false);
            var action = expression.Compile();
            Action actionAsync = 
                () =>
                {
                    action();
                    untilActionFinishes.Set();
                };

            actionAsync.BeginInvoke(null, null);
            if (!untilActionFinishes.WaitOne(timeoutMillis))
                throw new Exception("Execution timed out for expression: '" + expression + "'");
        }
    }
}