Fix CachedElementStateProvider issue (#51): return state regardless from constructor ElementState

* Fix CachedElementStateProvider to return state regardless from constructor ElementState

* Corrected condition in test Should_ReturnCorrectState_True_WhenWindowIsRefreshed

Author: mialeska

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

@@ -21,30 +21,27 @@ public CachedElementStateProvider(By locator, ConditionalWait conditionalWait, I
             this.locator = locator;
         }
 
-        protected virtual IList<Type> ExceptionsHandledByDefault => new List<Type> { typeof(StaleElementReferenceException) };
+        protected virtual IList<Type> HandledExceptions => new List<Type> { typeof(StaleElementReferenceException), typeof(NoSuchElementException) };
 
-        protected virtual bool TryInvokeFunction(Func<IWebElement, bool> func, IList<Type> exceptionsToHandle = null)
+        protected virtual bool TryInvokeFunction(Func<IWebElement, bool> func)
         {
-            var handledExceptions = exceptionsToHandle ?? ExceptionsHandledByDefault;
             try
             {
-                return func(elementCacheHandler.GetElement(TimeSpan.Zero));
+                return func(elementCacheHandler.GetElement(TimeSpan.Zero, ElementState.ExistsInAnyState));
             }
             catch (Exception e)
             {
-                if (handledExceptions.Any(type => type.IsAssignableFrom(e.GetType())))
+                if (HandledExceptions.Any(type => type.IsAssignableFrom(e.GetType())))
                 {
                     return false;
                 }
                 throw;
             }
         }
 
-        public virtual bool IsDisplayed => !elementCacheHandler.IsStale 
-            && TryInvokeFunction(element => element.Displayed, new List<Type> { typeof(StaleElementReferenceException), typeof(NoSuchElementException) });
+        public virtual bool IsDisplayed => !elementCacheHandler.IsStale && TryInvokeFunction(element => element.Displayed);
 
-        public virtual bool IsExist => !elementCacheHandler.IsStale
-            && TryInvokeFunction(element => true, new List<Type> { typeof(NoSuchElementException) });
+        public virtual bool IsExist => !elementCacheHandler.IsStale && TryInvokeFunction(element => true);
 
         public virtual bool IsClickable => TryInvokeFunction(element => element.Displayed && element.Enabled);
 

Aquality.Selenium.Core/src/Aquality.Selenium.Core/Elements/CachedElementStateProvider.cs

@@ -20,35 +20,33 @@ public ElementCacheHandler(By locator, ElementState state, IElementFinder finder
             elementFinder = finder;
         }
 
-        public bool IsStale => remoteElement != null && IsRefreshNeeded;
+        public bool IsStale => remoteElement != null && IsRefreshNeeded();
 
-        public bool IsRefreshNeeded
+        public bool IsRefreshNeeded(ElementState? customState = null)
         {
-            get
+            if (remoteElement == null)
             {
-                if (remoteElement == null)
-                {
-                    return true;
-                }
-                try
-                {
-                    var isDisplayed = remoteElement.Displayed;
-                    // no refresh needed if the property is available
-                    return false;
-                }
-                catch
-                {
-                    return true;
-                }
+                return true;
+            }
+            try
+            {
+                var isDisplayed = remoteElement.Displayed;
+                // refresh is needed only if the property is not match to expected element state
+                return (customState ?? state) == ElementState.Displayed && !isDisplayed;
+            }
+            catch
+            {
+                // refresh is needed if the property is not available
+                return true;
             }
         }
 
-        public RemoteWebElement GetElement(TimeSpan? timeout = null)
+        public RemoteWebElement GetElement(TimeSpan? timeout = null, ElementState? customState = null)
         {
 
-            if (IsRefreshNeeded)
+            if (IsRefreshNeeded(customState))
             {
-                remoteElement = (RemoteWebElement)elementFinder.FindElement(locator, state, timeout);
+                remoteElement = (RemoteWebElement)elementFinder.FindElement(locator, customState ?? state, timeout);
             }
 
             return remoteElement;

Aquality.Selenium.Core/src/Aquality.Selenium.Core/Elements/ElementCacheHandler.cs

@@ -11,7 +11,9 @@ public interface IElementCacheHandler
         /// <summary>
         /// Determines is the cached element refresh needed.
         /// </summary>
-        bool IsRefreshNeeded { get; }
+        /// <param name="customState">Custom element's existance state used for search.</param>
+        /// <returns></returns>
+        bool IsRefreshNeeded(ElementState? customState = null);
 
         /// <summary>
         /// Determines is the element stale.
@@ -21,8 +23,9 @@ public interface IElementCacheHandler
         /// <summary>
         /// Allows to get cached element.
         /// </summary>
-        /// <param name="timeout">Timeout used to retrive the element when <see cref="IsRefreshNeeded"/> is true.</param>
+        /// <param name="timeout">Timeout used to retrive the element when <see cref="IsRefreshNeeded(ElementState?)"/> is true.</param>
+        /// <param name="customState">Custom element's existance state used for search.</param>
         /// <returns>Cached element.</returns>
-        RemoteWebElement GetElement(TimeSpan? timeout = null);
+        RemoteWebElement GetElement(TimeSpan? timeout = null, ElementState? customState = null);
     }
 }

Aquality.Selenium.Core/src/Aquality.Selenium.Core/Elements/Interfaces/IElementCacheHandler.cs

@@ -13,7 +13,10 @@ public class CachedElementTests : TestWithBrowser
     {
         private static readonly By RemoveButtonLoc = By.XPath("//button[.='Remove']");
         private static readonly By ContentLoc = By.Id("checkbox");
+        private static readonly By StartLoc = By.XPath("//*[@id='start']//button");
+        private static readonly By LoadingLoc = By.Id("loading");
         private static readonly Uri DynamicContentUrl = new Uri($"{TestSite}/dynamic_controls");
+        private static readonly Uri DynamicLoadingUrl = new Uri($"{TestSite}/dynamic_loading/1");
         private const string ElementCacheVariableName = "elementCache.isEnabled"; 
 
         private static readonly Func<IElementStateProvider, bool>[] StateFunctionsFalseWhenElementStale
@@ -40,12 +43,60 @@ private static readonly Func<IElementStateProvider, bool>[] StateFunctionsTrueWh
         public new void SetUp()
         {
             Environment.SetEnvironmentVariable(ElementCacheVariableName, true.ToString());
+        }
+
+        private void StartLoading()
+        {
+            AqualityServices.Application.Driver.Navigate().GoToUrl(DynamicLoadingUrl);
+            new Label(StartLoc, "start", ElementState.Displayed).Click();
+        }
+
+        private void OpenDynamicContent()
+        {
             AqualityServices.Application.Driver.Navigate().GoToUrl(DynamicContentUrl);
         }
 
+        private void WaitForLoading(Label loader)
+        {
+            Assume.That(loader.State.WaitForDisplayed(), "Loader should be displayed in the beginning");
+            Assume.That(loader.State.WaitForNotDisplayed(), "Loader should not be displayed in the end");
+        }
+
+        [Test]
+        public void Should_ReturnFalse_AtWaitForDisplayed_WhenElementIsNotDisplayed()
+        {
+            var loader = new Label(LoadingLoc, "loader", ElementState.Displayed);
+            StartLoading();
+            WaitForLoading(loader);
+            Assert.IsFalse(loader.State.WaitForDisplayed(TimeSpan.Zero), nameof(Should_ReturnFalse_AtWaitForDisplayed_WhenElementIsNotDisplayed));
+        }
+
+        [Test]
+        public void Should_ReturnTrue_AtWaitForExist_WhenElementIsNotDisplayed()
+        {
+            var loader = new Label(LoadingLoc, "loader", ElementState.Displayed);
+            StartLoading();
+            WaitForLoading(loader);
+            Assert.IsTrue(loader.State.WaitForExist(TimeSpan.Zero), nameof(Should_ReturnTrue_AtWaitForExist_WhenElementIsNotDisplayed));
+        }
+
+        [Test]
+        public void Should_BeStale_WhenBecameInvisible()
+        {
+            StartLoading();
+            var loader = new Label(LoadingLoc, "loader", ElementState.Displayed);
+            Assume.That(loader.State.WaitForDisplayed(), "Loader should be displayed in the beginning");
+            Assert.IsTrue(AqualityServices.ServiceProvider.GetRequiredService<ConditionalWait>().WaitFor(
+                () => loader.Cache.IsStale), "Loader should become invisible and be treated as stale");
+            Assert.IsFalse(loader.State.IsDisplayed, "Invisible loader should be not displayed");
+            Assert.IsFalse(loader.State.IsExist, "Loader that was displayed previously and become invisible should be treated as disappeared");
+            Assert.IsTrue(loader.State.WaitForExist(TimeSpan.Zero), "When waiting for existance, we should get an actual element's state");
+        }
+
         [Test]
         public void Should_RefreshElement_WhenItIsStale()
         {
+            OpenDynamicContent();
             var example = new Label(ContentLoc, "Example", ElementState.Displayed);
             example.GetElement();
             var exToString = example.GetElement().ToString();
@@ -68,13 +119,12 @@ public void Should_ReturnCorrectState_True_WhenWindowIsRefreshed([ValueSource(na
 
         private void AssertStateConditionAfterRefresh(Func<IElementStateProvider, bool> stateCondition, bool expectedValue)
         {
+            OpenDynamicContent();
             var testElement = new Label(ContentLoc, "Example", ElementState.ExistsInAnyState);
             testElement.State.WaitForClickable();
             new Label(RemoveButtonLoc, "Remove", ElementState.Displayed).Click();
-            AqualityServices.ServiceProvider.GetRequiredService<ConditionalWait>().WaitFor(driver =>
-            {
-                return testElement.Cache.IsStale;
-            }, message: "Element should be stale when it disappeared.");
+            AqualityServices.ServiceProvider.GetRequiredService<ConditionalWait>().WaitForTrue(
+                () => testElement.Cache.IsStale, message: "Element should be stale when it disappeared.");
             AqualityServices.Application.Driver.Navigate().Refresh();
             Assert.IsTrue(testElement.Cache.IsStale, "Element should remain stale after the page refresh.");
             Assert.AreEqual(expectedValue, stateCondition(testElement.State),