Flaky CommandExecutorFixture tests

src/NzbDrone.Core.Test/Messaging/Commands/CommandExecutorFixture.cs

@@ -145,7 +145,7 @@ namespace NzbDrone.Core.Test.Messaging.Commands
 
             VerifyEventPublished<CommandExecutedEvent>();
 
-            ExceptionVerification.ExpectedErrors(1);
+            ExceptionVerification.WaitForErrors(1, 500);
         }
 
         [Test]

src/NzbDrone.Test.Common/ExceptionVerification.cs

@@ -1,6 +1,7 @@
 using System;
 using System.Collections.Generic;
 using System.Linq;
+using System.Threading;
 using NLog;
 using NLog.Targets;
 using NUnit.Framework;
@@ -11,17 +12,27 @@ namespace NzbDrone.Test.Common
     {
         private static List<LogEventInfo> _logs = new List<LogEventInfo>();
 
+        private static ManualResetEventSlim _waitEvent = new ManualResetEventSlim();
+
         protected override void Write(LogEventInfo logEvent)
         {
-            if (logEvent.Level >= LogLevel.Warn)
+            lock (_logs)
             {
-                _logs.Add(logEvent);
+                if (logEvent.Level >= LogLevel.Warn)
+                {
+                    _logs.Add(logEvent);
+                    _waitEvent.Set();
+                }
             }
         }
 
         public static void Reset()
         {
-            _logs = new List<LogEventInfo>();
+            lock (_logs)
+            {
+                _logs.Clear();
+                _waitEvent.Reset();
+            }
         }
 
         public static void AssertNoUnexpectedLogs()
@@ -47,6 +58,29 @@ namespace NzbDrone.Test.Common
             return errors;
         }
 
+        public static void WaitForErrors(int count, int msec)
+        {
+            while (true)
+            {
+                lock (_logs)
+                {
+                    var levelLogs = _logs.Where(l => l.Level == LogLevel.Error).ToList();
+
+                    if (levelLogs.Count >= count)
+                    {
+                        break;
+                    }
+
+                    _waitEvent.Reset();
+                }
+
+                if (!_waitEvent.Wait(msec))
+                    break;
+            }
+
+            Expected(LogLevel.Error, count);
+        }
+
         public static void ExpectedErrors(int count)
         {
             Expected(LogLevel.Error, count);
@@ -74,50 +108,62 @@ namespace NzbDrone.Test.Common
 
         public static void MarkInconclusive(Type exception)
         {
-            var inconclusiveLogs = _logs.Where(l => l.Exception != null && l.Exception.GetType() == exception).ToList();
+            lock (_logs)
-
-            if (inconclusiveLogs.Any())
             {
-                inconclusiveLogs.ForEach(c => _logs.Remove(c));
+                var inconclusiveLogs = _logs.Where(l => l.Exception != null && l.Exception.GetType() == exception).ToList();
-                Assert.Inconclusive(GetLogsString(inconclusiveLogs));
+
+                if (inconclusiveLogs.Any())
+                {
+                    inconclusiveLogs.ForEach(c => _logs.Remove(c));
+                    Assert.Inconclusive(GetLogsString(inconclusiveLogs));
+                }
             }
         }
 
         public static void MarkInconclusive(string text)
         {
-            var inconclusiveLogs = _logs.Where(l => l.FormattedMessage.ToLower().Contains(text.ToLower())).ToList();
+            lock (_logs)
-
-            if (inconclusiveLogs.Any())
             {
-                inconclusiveLogs.ForEach(c => _logs.Remove(c));
+                var inconclusiveLogs = _logs.Where(l => l.FormattedMessage.ToLower().Contains(text.ToLower())).ToList();
-                Assert.Inconclusive(GetLogsString(inconclusiveLogs));
+
+                if (inconclusiveLogs.Any())
+                {
+                    inconclusiveLogs.ForEach(c => _logs.Remove(c));
+                    Assert.Inconclusive(GetLogsString(inconclusiveLogs));
+                }
             }
         }
 
         private static void Expected(LogLevel level, int count)
         {
-            var levelLogs = _logs.Where(l => l.Level == level).ToList();
+            lock (_logs)
-
-            if (levelLogs.Count != count)
             {
+                var levelLogs = _logs.Where(l => l.Level == level).ToList();
+
+                if (levelLogs.Count != count)
+                {
 
-                var message = string.Format("{0} {1}(s) were expected but {2} were logged.\n\r{3}",
+                    var message = string.Format("{0} {1}(s) were expected but {2} were logged.\n\r{3}",
-                    count, level, levelLogs.Count, GetLogsString(levelLogs));
+                        count, level, levelLogs.Count, GetLogsString(levelLogs));
 
-                message = "\n\r****************************************************************************************\n\r"
+                    message = "\n\r****************************************************************************************\n\r"
-                    + message +
+                        + message +
-                    "\n\r****************************************************************************************";
+                        "\n\r****************************************************************************************";
 
-                Assert.Fail(message);
+                    Assert.Fail(message);
-            }
+                }
 
-            levelLogs.ForEach(c => _logs.Remove(c));
+                levelLogs.ForEach(c => _logs.Remove(c));
+            }
         }
 
         private static void Ignore(LogLevel level)
         {
-            var levelLogs = _logs.Where(l => l.Level == level).ToList();
+            lock (_logs)
-            levelLogs.ForEach(c => _logs.Remove(c));
+            {
+                var levelLogs = _logs.Where(l => l.Level == level).ToList();
+                levelLogs.ForEach(c => _logs.Remove(c));
+            }
         }
     }
 }