Feature/60 action retrier [+semver: major] (#66)

* Add ActionRetrier

* Add tests for ActionRetrier and ElementActionRetrier

* Fix warningns, update tests

* Modify pipeline

* Fix tests

* Update RetrierTests

* Set default value for handledExceptions

* Update ActionRetrier and ElementActionRetrier interfaces

* Fix tests

* Rename property

* Check pipeline

* Fix sonar code smells

* Add setter to HandledExceptions property in ElementActionRetrier

Author: paveliam

Aquality.Selenium.Core/src/Aquality.Selenium.Core/Utilities/ActionRetrier.cs

@@ -0,0 +1,84 @@
+using Aquality.Selenium.Core.Configurations;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading;
+
+namespace Aquality.Selenium.Core.Utilities
+{
+    public class ActionRetrier : IActionRetrier
+    {
+        private readonly IRetryConfiguration retryConfiguration;
+
+        /// <summary>
+        /// Instantiates the class using retry configuration.
+        /// </summary>
+        /// <param name="retryConfiguration">Retry configuration.</param>
+        public ActionRetrier(IRetryConfiguration retryConfiguration)
+        {
+            this.retryConfiguration = retryConfiguration;
+        }
+
+        /// <summary>
+        /// Retries the action when one of the handledExceptions occures.
+        /// </summary>
+        /// <param name="action">Action to be applied.</param>
+        /// <param name="handledExceptions">Exceptions to be handled.</param>
+        public virtual void DoWithRetry(Action action, IEnumerable<Type> handledExceptions = null)
+        {
+            DoWithRetry(() =>
+            {
+                action();
+                return true;
+            }, handledExceptions);
+        }
+
+        /// <summary>
+        /// Retries the action when one of the handledExceptions occures.
+        /// </summary>
+        /// <typeparam name="T">Return type of function.</typeparam>
+        /// <param name="function">Function to be applied.</param>
+        /// <param name="handledExceptions">Exceptions to be handled.</param>
+        /// <returns>Result of the function.</returns>
+        public virtual T DoWithRetry<T>(Func<T> function, IEnumerable<Type> handledExceptions = null)
+        {
+            var exceptionsToHandle = handledExceptions ?? new List<Type>();
+            var retryAttemptsLeft = retryConfiguration.Number;
+            var actualInterval = retryConfiguration.PollingInterval;
+            var result = default(T);
+            
+            while (retryAttemptsLeft >= 0)
+            {
+                try
+                {
+                    result = function();
+                    break;
+                }
+                catch (Exception exception)
+                {
+                    if (IsExceptionHandled(exceptionsToHandle, exception) && retryAttemptsLeft != 0)
+                    {
+                        Thread.Sleep(actualInterval);
+                        retryAttemptsLeft--;
+                    }
+                    else
+                    {
+                        throw;
+                    }
+                }
+            }
+            return result;
+        }
+
+        /// <summary>
+        /// Decides should the occured exception be handled (ignored during the retry) or not.
+        /// </summary>
+        /// <param name="handledExceptions">Exceptions to be handled.</param>
+        /// <param name="exception">Exception to proceed.</param>
+        /// <returns>True if the exception should be ignored, false otherwise.</returns>
+        protected virtual bool IsExceptionHandled(IEnumerable<Type> handledExceptions, Exception exception)
+        {
+            return handledExceptions.Any(type => type.IsAssignableFrom(exception.GetType()));
+        }
+    }
+}

Aquality.Selenium.Core/src/Aquality.Selenium.Core/Utilities/ElementActionRetrier.cs

@@ -2,93 +2,57 @@
 using OpenQA.Selenium;
 using System;
 using System.Collections.Generic;
-using System.Linq;
-using System.Threading;
 
 namespace Aquality.Selenium.Core.Utilities
 {
     /// <summary>
     /// Retries an action or function when <see cref="HandledExceptions"/> occures.
     /// </summary>
-    public class ElementActionRetrier : IElementActionRetrier
+    public class ElementActionRetrier : ActionRetrier, IElementActionRetrier
     {
-        private readonly IRetryConfiguration retryConfiguration;
-
         /// <summary>
         /// Instantiates the class using retry configuration.
         /// </summary>
         /// <param name="retryConfiguration">Retry configuration.</param>
-        /// <param name="handledExceptions">Exceptions to be handled. 
-        /// If set to null, <see cref="StaleElementReferenceException"/> and <see cref="InvalidElementStateException"/> will be handled.</param>
-        public ElementActionRetrier(IRetryConfiguration retryConfiguration, IList<Type> handledExceptions = null)
+        public ElementActionRetrier(IRetryConfiguration retryConfiguration) : base(retryConfiguration)
         {
-            this.retryConfiguration = retryConfiguration;
-            HandledExceptions = handledExceptions ?? new List<Type> { typeof(StaleElementReferenceException), typeof(InvalidElementStateException) };
+            HandledExceptions = new List<Type>
+            {
+                typeof(StaleElementReferenceException),
+                typeof(InvalidElementStateException)
+            };
         }
 
         /// <summary>
         /// Exceptions to be ignored during action retrying.
         /// Set by the constructor parameter.
-        /// If were not passed to constructor, <see cref="StaleElementReferenceException"/> and <see cref="InvalidElementStateException"/> will be handled.
-        /// </summary>
-        public virtual IList<Type> HandledExceptions { get; }
-
-        /// <summary>
-        /// Decides should the occured exception be handled (ignored during the retry) or not.
+        /// If were not passed to constructor, <see cref="StaleElementReferenceException"/> 
+        /// and <see cref="InvalidElementStateException"/> will be handled.
         /// </summary>
-        /// <param name="exception">Exception to proceed.</param>
-        /// <returns>True if the exception should be ignored, false otherwise.</returns>
-        protected virtual bool IsExceptionHandled(Exception exception)
-        {
-            return HandledExceptions.Any(type => type.IsAssignableFrom(exception.GetType()));
-        }
+        public virtual IEnumerable<Type> HandledExceptions { get; set; }
 
         /// <summary>
         /// Retries the action when the handled exception <see cref="HandledExceptions"/> occures.
         /// </summary>
         /// <param name="action">Action to be applied.</param>
-        public virtual void DoWithRetry(Action action)
+        /// <param name="handledExceptions">Exceptions to be handled.</param>
+        public override void DoWithRetry(Action action, IEnumerable<Type> handledExceptions = null)
         {
-            DoWithRetry(() =>
-            {
-                action();
-                return true;
-            });
+            var exceptionsToHandle = handledExceptions ?? HandledExceptions;
+            base.DoWithRetry(action, exceptionsToHandle);
         }
 
         /// <summary>
         /// Retries the function when <see cref="HandledExceptions"/> occures.
         /// </summary>
         /// <typeparam name="T">Return type of function.</typeparam>
         /// <param name="function">Function to be applied.</param>
+        /// <param name="handledExceptions">Exceptions to be handled.</param>
         /// <returns>Result of the function.</returns>
-        public virtual T DoWithRetry<T>(Func<T> function)
+        public override T DoWithRetry<T>(Func<T> function, IEnumerable<Type> handledExceptions = null)
         {
-            var retryAttemptsLeft = retryConfiguration.Number;
-            var actualInterval = retryConfiguration.PollingInterval;
-            var result = default(T);
-            while (retryAttemptsLeft >= 0)
-            {
-                try
-                {
-                    result = function();
-                    break;
-                }
-                catch (Exception exception)
-                {
-                    if (IsExceptionHandled(exception) && retryAttemptsLeft != 0)
-                    {
-                        Thread.Sleep(actualInterval);
-                        retryAttemptsLeft--;
-                    }
-                    else
-                    {
-                        throw;
-                    }
-                }
-            }
-
-            return result;
+            var exceptionsToHandle = handledExceptions ?? HandledExceptions;
+            return base.DoWithRetry(function, exceptionsToHandle);
         }
     }
 }

Aquality.Selenium.Core/src/Aquality.Selenium.Core/Utilities/IActionRetrier.cs

@@ -0,0 +1,27 @@
+using System;
+using System.Collections.Generic;
+
+namespace Aquality.Selenium.Core.Utilities
+{
+    /// <summary>
+    /// Retries an action or function when handledExceptions occurs.
+    /// </summary>
+    public interface IActionRetrier
+    {
+        /// <summary>
+        /// Retries the action when one of the handledExceptions occures.
+        /// </summary>
+        /// <param name="action">Action to be applied.</param>
+        /// <param name="handledExceptions">Exceptions to be handled.</param>
+        void DoWithRetry(Action action, IEnumerable<Type> handledExceptions = null);
+
+        /// <summary>
+        /// Retries the action when one of the handledExceptions occures.
+        /// </summary>
+        /// <typeparam name="T">Return type of function.</typeparam>
+        /// <param name="function">Function to be applied.</param>
+        /// <param name="handledExceptions">Exceptions to be handled.</param>
+        /// <returns>Result of the function.</returns>
+        T DoWithRetry<T>(Func<T> function, IEnumerable<Type> handledExceptions = null);
+    }
+}

Aquality.Selenium.Core/src/Aquality.Selenium.Core/Utilities/IElementActionRetrier.cs

@@ -5,28 +5,15 @@
 namespace Aquality.Selenium.Core.Utilities
 {
     /// <summary>
-    /// Retries an action or function when <see cref="HandledExceptions"/> occures.
+    /// Retries an action or function when one of <see cref="HandledExceptions"/> occures.
     /// </summary>
-    public interface IElementActionRetrier
+    public interface IElementActionRetrier : IActionRetrier
     {
         /// <summary>
         /// Exceptions to be ignored during action retrying.
-        /// By the default implementation, <see cref="StaleElementReferenceException"/> and <see cref="InvalidElementStateException"/> are handled.
+        /// By the default implementation, <see cref="StaleElementReferenceException"/> 
+        /// and <see cref="InvalidElementStateException"/> are handled.
         /// </summary>
-        IList<Type> HandledExceptions { get; }
-
-        /// <summary>
-        /// Retries the action when the handled exception <see cref="HandledExceptions"/> occures.
-        /// </summary>
-        /// <param name="action">Action to be applied.</param>
-        void DoWithRetry(Action action);
-
-        /// <summary>
-        /// Retries the function when the handled exception <see cref="HandledExceptions"/> occures.
-        /// </summary>
-        /// <typeparam name="T">Return type of function.</typeparam>
-        /// <param name="function">Function to be applied.</param>
-        /// <returns>Result of the function.</returns>
-        T DoWithRetry<T>(Func<T> function);
+        IEnumerable<Type> HandledExceptions { get; set; }
     }
 }

Aquality.Selenium.Core/tests/Aquality.Selenium.Core.Tests/Utilities/ActionRetrierTests.cs

@@ -0,0 +1,106 @@
+using Aquality.Selenium.Core.Utilities;
+using NUnit.Framework;
+using System;
+using System.Collections.Generic;
+
+namespace Aquality.Selenium.Core.Tests.Utilities
+{
+    public class ActionRetrierTests : RetrierTests
+    {
+        private IEnumerable<Type> HandledExceptions => new List<Type> { typeof(InvalidOperationException) };
+        
+        private IActionRetrier ActionRetrier => new ActionRetrier(RetryConfiguration);
+
+        [Test]
+        public void Retrier_ShouldWork_OnceIfMethodSucceeded()
+        {
+            Retrier_ShouldWork_OnceIfMethodSucceeded(() => ActionRetrier.DoWithRetry(() => Console.WriteLine(1), new List<Type>()));
+        }
+
+        [Test]
+        public void Retrier_ShouldWork_OnceIfMethodSucceeded_WithReturnValue()
+        {
+            Retrier_ShouldWork_OnceIfMethodSucceeded(() => ActionRetrier.DoWithRetry(() => string.Empty, new List<Type>()));
+        }
+
+        [Test]
+        public void Retrier_ShouldWait_PollingTimeBetweenMethodCalls()
+        {
+            var throwException = true;
+            Retrier_ShouldWait_PollingIntervalBetweenMethodsCall(() =>
+                    ActionRetrier.DoWithRetry(() => {
+                        if (throwException)
+                        {
+                            throwException = false;
+                            throw new InvalidOperationException();
+                        }
+                    }, HandledExceptions));
+        }
+
+        [Test]
+        public void Retrier_ShouldWait_PollingTimeBetweenMethodCalls_WithReturnValue()
+        {
+            var throwException = true;
+            Retrier_ShouldWait_PollingIntervalBetweenMethodsCall(() =>
+                    ActionRetrier.DoWithRetry(() => {
+                        if (throwException)
+                        {
+                            throwException = false;
+                            throw new InvalidOperationException();
+                        }
+                        return string.Empty;
+                    }, HandledExceptions));
+        }
+
+        [Test]
+        public void Retrier_ShouldThrow_UnhandledException()
+        {
+            Assert.Throws<InvalidOperationException>(() => ActionRetrier.DoWithRetry(() => {
+                throw new InvalidOperationException();
+            }, new List<Type>()));
+        }
+
+        [Test]
+        public void Retrier_ShouldThrow_UnhandledException_WithReturnValue()
+        {
+            Assert.Throws<InvalidOperationException>(() => ActionRetrier.DoWithRetry(() => {
+                throw new InvalidOperationException();
+#pragma warning disable CS0162 // Unreachable code detected
+                return string.Empty;
+#pragma warning restore CS0162 // Unreachable code detected
+            }, new List<Type>()));
+        }
+
+        [Test]
+        public void Retrier_ShouldWork_CorrectTimes()
+        {
+            var actualAttempts = 0;
+            Retrier_ShouldWork_CorrectTimes(typeof(InvalidOperationException), ref actualAttempts, () =>
+                    ActionRetrier.DoWithRetry(() => {
+                        Logger.Info($"current attempt is {actualAttempts++}");
+                        throw new InvalidOperationException();
+                    }, HandledExceptions));
+        }
+
+        [Test]
+        public void Retrier_ShouldWork_CorrectTimes_WithReturnValue()
+        {
+            var actualAttempts = 0;
+            Retrier_ShouldWork_CorrectTimes(typeof(InvalidOperationException), ref actualAttempts, () =>
+                    ActionRetrier.DoWithRetry(() => {
+                        Logger.Info($"current attempt is {actualAttempts++}");
+                        throw new InvalidOperationException();
+#pragma warning disable CS0162 // Unreachable code detected
+                        return string.Empty;
+#pragma warning restore CS0162 // Unreachable code detected
+                    }, HandledExceptions));
+        }
+
+        [Test]
+        public void Retrier_Should_ReturnValue()
+        {
+            var returnValue = string.Empty;
+            Assert.AreEqual(returnValue, ActionRetrier.DoWithRetry(() => returnValue, new List<Type>()), "Retrier should return value");
+        }
+    }
+}