Feature/add async conditional waiting +semver: feature

* Implement asynchronous functions for Conditional wait
- add WaitForAsync that returns Task<bool>
- add WaitForTrueAsync that returns Task which may throw when awaited if the condition is not satisfied after the timeout

* Update nuget package versions and Chrome version for Azure pipelines test execution

Author: mialeska

Aquality.Selenium.Core/src/Aquality.Selenium.Core/Aquality.Selenium.Core.csproj

@@ -43,9 +43,9 @@
     </None>
   </ItemGroup>
   <ItemGroup>
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.5" />
-    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="3.1.5" />
-    <PackageReference Include="NLog" Version="4.7.2" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection" Version="3.1.8" />
+    <PackageReference Include="Microsoft.Extensions.DependencyInjection.Abstractions" Version="3.1.8" />
+    <PackageReference Include="NLog" Version="4.7.5" />
     <PackageReference Include="Selenium.Support" Version="3.141.0" />
     <PackageReference Include="Selenium.WebDriver" Version="3.141.0" />    
   </ItemGroup>

Aquality.Selenium.Core/src/Aquality.Selenium.Core/Aquality.Selenium.Core.xml

@@ -8,6 +8,7 @@
 using System.Diagnostics;
 using System.Linq;
 using System.Threading;
+using System.Threading.Tasks;
 
 namespace Aquality.Selenium.Core.Waitings
 {
@@ -79,6 +80,44 @@ public bool WaitFor(Func<bool> condition, TimeSpan? timeout = null, TimeSpan? po
             }, new List<Type> { typeof(TimeoutException) });
         }
 
+        /// <summary>
+        /// Wait for some condition asynchronously within timeout.
+        /// </summary>
+        /// <param name="condition">Predicate for waiting</param>
+        /// <param name="timeout">Condition timeout. Default value is <see cref="ITimeoutConfiguration.Condition"/></param>
+        /// <param name="pollingInterval">Condition check interval. Default value is <see cref="ITimeoutConfiguration.PollingInterval"/></param>
+        /// <param name="exceptionsToIgnore">Possible exceptions that have to be ignored. </param>
+        /// <returns>A task that returns true if condition satisfied and false otherwise.</returns>
+        public Task<bool> WaitForAsync(Func<bool> condition, TimeSpan? timeout = null, TimeSpan? pollingInterval = null, IList<Type> exceptionsToIgnore = null)
+        {
+            if (condition == null)
+            {
+                throw new ArgumentNullException(nameof(condition), "condition cannot be null");
+            }
+            var waitTimeout = ResolveConditionTimeout(timeout);
+            var checkInterval = ResolvePollingInterval(pollingInterval);
+            return WaitForAsyncCore(condition, exceptionsToIgnore, waitTimeout, checkInterval);
+        }
+
+        /// <summary>
+        /// Wait for some condition asynchronously within timeout.
+        /// </summary>
+        /// <param name="condition">Predicate for waiting</param>
+        /// <param name="timeout">Condition timeout. Default value is <see cref="ITimeoutConfiguration.Condition"/></param>
+        /// <param name="pollingInterval">Condition check interval. Default value is <see cref="ITimeoutConfiguration.PollingInterval"/></param>
+        /// <param name="message">Part of error message in case of Timeout exception</param>
+        /// <param name="exceptionsToIgnore">Possible exceptions that have to be ignored. </param>
+        /// <exception cref="TimeoutException">Throws when timeout exceeded and condition not satisfied, if only the task is awaited.</exception>
+        /// <returns>A task that throws a <see cref="TimeoutException"/> if condition is not satisfied after the timeout.</returns>
+        public async Task WaitForTrueAsync(Func<bool> condition, TimeSpan? timeout = null, TimeSpan? pollingInterval = null, string message = null, IList<Type> exceptionsToIgnore = null)
+        {
+            var waitTimeout = ResolveConditionTimeout(timeout);
+            if (!await WaitForAsync(condition, waitTimeout, pollingInterval, exceptionsToIgnore))
+            {
+                throw GetTimeoutException(waitTimeout, message);
+            }
+        }
+
         /// <summary>
         /// Wait for some condition within timeout.
         /// </summary>
@@ -107,19 +146,24 @@ public void WaitForTrue(Func<bool> condition, TimeSpan? timeout = null, TimeSpan
 
                 if (stopwatch.Elapsed > waitTimeout)
                 {
-                    var exceptionMessage = $"Timed out after {waitTimeout.TotalSeconds} seconds";
-                    if (!string.IsNullOrEmpty(message))
-                    {
-                        exceptionMessage += $": {message}";
-                    }
-
-                    throw new TimeoutException(exceptionMessage);
+                    throw GetTimeoutException(waitTimeout, message);
                 }
 
                 Thread.Sleep(checkInterval);
             }
         }
 
+        private TimeoutException GetTimeoutException(TimeSpan waitTimeout, string message)
+        {
+            var exceptionMessage = $"Timed out after {waitTimeout.TotalSeconds} seconds";
+            if (!string.IsNullOrEmpty(message))
+            {
+                exceptionMessage += $": {message}";
+            }
+
+            return new TimeoutException(exceptionMessage);
+        }
+
         private bool IsConditionSatisfied(Func<bool> condition, IList<Type> exceptionsToIgnore)
         {
             try
@@ -146,5 +190,29 @@ private TimeSpan ResolvePollingInterval(TimeSpan? pollingInterval)
         {
             return pollingInterval ?? timeoutConfiguration.PollingInterval;
         }
+
+        private async Task<bool> WaitForAsyncCore(Func<bool> condition, IList<Type> exceptionsToIgnore, TimeSpan waitTimeout, TimeSpan checkInterval)
+        {
+            using (CancellationTokenSource cts = new CancellationTokenSource())
+            {
+                var token = cts.Token;
+                var waitTask = Task.Run(async () =>
+                {
+                    while (!IsConditionSatisfied(condition, exceptionsToIgnore ?? new List<Type>()))
+                    {
+                        await Task.Delay(checkInterval);
+                    }
+                },
+                token);
+                var finishedTask = await Task.WhenAny(waitTask, Task.Delay(waitTimeout, token));
+                cts.Cancel();
+                var result = finishedTask == waitTask;
+                if (result && waitTask.Exception != null)
+                {
+                    throw waitTask.Exception.InnerExceptions.Count == 1 ? waitTask.Exception.InnerException : waitTask.Exception;
+                }
+                return result;
+            }
+        }
     }
 }

Aquality.Selenium.Core/src/Aquality.Selenium.Core/Waitings/ConditionalWait.cs

@@ -2,6 +2,7 @@
 using OpenQA.Selenium;
 using System;
 using System.Collections.Generic;
+using System.Threading.Tasks;
 
 namespace Aquality.Selenium.Core.Waitings
 {
@@ -10,16 +11,6 @@ namespace Aquality.Selenium.Core.Waitings
     /// </summary>
     public interface IConditionalWait
     {
-        /// <summary>
-        /// Wait for some condition within timeout.
-        /// </summary>
-        /// <param name="condition">Predicate for waiting</param>
-        /// <param name="timeout">Condition timeout. Default value is <see cref="ITimeoutConfiguration.Condition"/></param>
-        /// <param name="pollingInterval">Condition check interval. Default value is <see cref="ITimeoutConfiguration.PollingInterval"/></param>
-        /// <param name="exceptionsToIgnore">Possible exceptions that have to be ignored. </param>
-        /// <returns>True if condition satisfied and false otherwise.</returns>
-        bool WaitFor(Func<bool> condition, TimeSpan? timeout = null, TimeSpan? pollingInterval = null, IList<Type> exceptionsToIgnore = null);
-        
         /// <summary>
         /// Wait for some object from condition with timeout using Selenium WebDriver.
         /// </summary>
@@ -33,6 +24,26 @@ public interface IConditionalWait
         /// <exception cref="WebDriverTimeoutException">Throws when timeout exceeded and condition not satisfied.</exception>
         T WaitFor<T>(Func<IWebDriver, T> condition, TimeSpan? timeout = null, TimeSpan? pollingInterval = null, string message = null, IList<Type> exceptionsToIgnore = null);
 
+        /// <summary>
+        /// Wait for some condition within timeout.
+        /// </summary>
+        /// <param name="condition">Predicate for waiting</param>
+        /// <param name="timeout">Condition timeout. Default value is <see cref="ITimeoutConfiguration.Condition"/></param>
+        /// <param name="pollingInterval">Condition check interval. Default value is <see cref="ITimeoutConfiguration.PollingInterval"/></param>
+        /// <param name="exceptionsToIgnore">Possible exceptions that have to be ignored. </param>
+        /// <returns>True if condition satisfied and false otherwise.</returns>
+        bool WaitFor(Func<bool> condition, TimeSpan? timeout = null, TimeSpan? pollingInterval = null, IList<Type> exceptionsToIgnore = null);
+
+        /// <summary>
+        /// Wait for some condition asynchronously within timeout.
+        /// </summary>
+        /// <param name="condition">Predicate for waiting</param>
+        /// <param name="timeout">Condition timeout. Default value is <see cref="ITimeoutConfiguration.Condition"/></param>
+        /// <param name="pollingInterval">Condition check interval. Default value is <see cref="ITimeoutConfiguration.PollingInterval"/></param>
+        /// <param name="exceptionsToIgnore">Possible exceptions that have to be ignored. </param>
+        /// <returns>A task that returns true if condition satisfied and false otherwise.</returns>
+        Task<bool> WaitForAsync(Func<bool> condition, TimeSpan? timeout = null, TimeSpan? pollingInterval = null, IList<Type> exceptionsToIgnore = null);
+        
         /// <summary>
         /// Wait for some condition within timeout.
         /// </summary>
@@ -43,5 +54,17 @@ public interface IConditionalWait
         /// <param name="exceptionsToIgnore">Possible exceptions that have to be ignored. </param>
         /// <exception cref="TimeoutException">Throws when timeout exceeded and condition not satisfied.</exception>
         void WaitForTrue(Func<bool> condition, TimeSpan? timeout = null, TimeSpan? pollingInterval = null, string message = null, IList<Type> exceptionsToIgnore = null);
+
+        /// <summary>
+        /// Wait for some condition asynchronously within timeout.
+        /// </summary>
+        /// <param name="condition">Predicate for waiting</param>
+        /// <param name="timeout">Condition timeout. Default value is <see cref="ITimeoutConfiguration.Condition"/></param>
+        /// <param name="pollingInterval">Condition check interval. Default value is <see cref="ITimeoutConfiguration.PollingInterval"/></param>
+        /// <param name="message">Part of error message in case of Timeout exception</param>
+        /// <param name="exceptionsToIgnore">Possible exceptions that have to be ignored. </param>
+        /// <exception cref="TimeoutException">Throws when timeout exceeded and condition not satisfied, if only the task is awaited.</exception>
+        /// <returns>A task that throws a <see cref="TimeoutException"/> if condition is not satisfied after the timeout.</returns>
+        Task WaitForTrueAsync(Func<bool> condition, TimeSpan? timeout = null, TimeSpan? pollingInterval = null, string message = null, IList<Type> exceptionsToIgnore = null);
     }
-}
+}